Upload TMIDIX.py

TMIDIX.py

@@ -14,14 +14,14 @@ r'''############################################################################
 #
 #	Project Los Angeles
 #
-#	Tegridy Code 2021
+#	Tegridy Code 2024
 #
 #   https://github.com/Tegridy-Code/Project-Los-Angeles
 #
 #
 ###################################################################################
 ###################################################################################
-#       Copyright 2021 Project Los Angeles / Tegridy Code
+#       Copyright 2024 Project Los Angeles / Tegridy Code
 #
 #       Licensed under the Apache License, Version 2.0 (the "License");
 #       you may not use this file except in compliance with the License.
@@ -56,6 +56,8 @@ VersionDate = '20201120'
 
 _previous_warning = ''  # 5.4
 _previous_times = 0     # 5.4
+_no_warning = False
+
 #------------------------------- Encoding stuff --------------------------
 
 def opus2midi(opus=[], text_encoding='ISO-8859-1'):
@@ -845,10 +847,11 @@ def _unshift_ber_int(ba):
     r'''Given a bytearray, returns a tuple of (the ber-integer at the
 start, and the remainder of the bytearray).
 '''
-    if not len(ba):   # 6.7
+    if not len(ba):  # 6.7
         _warn('_unshift_ber_int: no integer found')
         return ((0, b""))
-    byte = ba.pop(0)
+    byte = ba[0]
+    ba = ba[1:]
     integer = 0
     while True:
         integer += (byte & 0x7F)
@@ -857,13 +860,17 @@ start, and the remainder of the bytearray).
         if not len(ba):
             _warn('_unshift_ber_int: no end-of-integer found')
             return ((0, ba))
-        byte = ba.pop(0)
+        byte = ba[0]
+        ba = ba[1:]
         integer <<= 7
 
+
 def _clean_up_warnings():  # 5.4
     # Call this before returning from any publicly callable function
     # whenever there's a possibility that a warning might have been printed
     # by the function, or by any private functions it might have called.
+    if _no_warning:
+        return
     global _previous_times
     global _previous_warning
     if _previous_times > 1:
@@ -876,27 +883,32 @@ def _clean_up_warnings():  # 5.4
     _previous_times = 0
     _previous_warning = ''
 
+
 def _warn(s=''):
+    if _no_warning:
+        return
     global _previous_times
     global _previous_warning
     if s == _previous_warning:  # 5.4
         _previous_times = _previous_times + 1
     else:
         _clean_up_warnings()
-        sys.stderr.write(str(s)+"\n")
+        sys.stderr.write(str(s) + "\n")
         _previous_warning = s
 
+
 def _some_text_event(which_kind=0x01, text=b'some_text', text_encoding='ISO-8859-1'):
-    if str(type(text)).find("'str'") >= 0:   # 6.4 test for back-compatibility
+    if str(type(text)).find("'str'") >= 0:  # 6.4 test for back-compatibility
         data = bytes(text, encoding=text_encoding)
     else:
         data = bytes(text)
-    return b'\xFF'+bytes((which_kind,))+_ber_compressed_int(len(data))+data
+    return b'\xFF' + bytes((which_kind,)) + _ber_compressed_int(len(data)) + data
+
 
 def _consistentise_ticks(scores):  # 3.6
     # used by mix_scores, merge_scores, concatenate_scores
     if len(scores) == 1:
-         return copy.deepcopy(scores)
+        return copy.deepcopy(scores)
     are_consistent = True
     ticks = scores[0][0]
     iscore = 1
@@ -917,9 +929,8 @@ def _consistentise_ticks(scores):  # 3.6
 
 
 ###########################################################################
-
 def _decode(trackdata=b'', exclude=None, include=None,
- event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
+            event_callback=None, exclusive_event_callback=None, no_eot_magic=False):
     r'''Decodes MIDI track data into an opus-style list of events.
 The options:
   'exclude' is a list of event types which will be ignored SHOULD BE A SET
@@ -939,24 +950,24 @@ The options:
     exclude = set(exclude)
 
     # Pointer = 0;  not used here; we eat through the bytearray instead.
-    event_code = -1; # used for running status
+    event_code = -1;  # used for running status
     event_count = 0;
     events = []
 
-    while(len(trackdata)):
+    while (len(trackdata)):
         # loop while there's anything to analyze ...
-        eot = False   # When True, the event registrar aborts this loop
+        eot = False  # When True, the event registrar aborts this loop
         event_count += 1
 
         E = []
         # E for events - we'll feed it to the event registrar at the end.
 
         # Slice off the delta time code, and analyze it
-        [time, remainder] = _unshift_ber_int(trackdata)
+        [time, trackdata] = _unshift_ber_int(trackdata)
 
         # Now let's see what we can make of the command
-        first_byte = trackdata.pop(0) & 0xFF
-
+        first_byte = trackdata[0] & 0xFF
+        trackdata = trackdata[1:]
         if (first_byte < 0xF0):  # It's a MIDI event
             if (first_byte & 0x80):
                 event_code = first_byte
@@ -970,17 +981,19 @@ The options:
             command = event_code & 0xF0
             channel = event_code & 0x0F
 
-            if (command == 0xF6):  #  0-byte argument
+            if (command == 0xF6):  # 0-byte argument
                 pass
-            elif (command == 0xC0 or command == 0xD0):  #  1-byte argument
-                parameter = trackdata.pop(0)  # could be B
-            else: # 2-byte argument could be BB or 14-bit
-                parameter = (trackdata.pop(0), trackdata.pop(0))
+            elif (command == 0xC0 or command == 0xD0):  # 1-byte argument
+                parameter = trackdata[0]  # could be B
+                trackdata = trackdata[1:]
+            else:  # 2-byte argument could be BB or 14-bit
+                parameter = (trackdata[0], trackdata[1])
+                trackdata = trackdata[2:]
 
             #################################################################
             # MIDI events
 
-            if (command      == 0x80):
+            if (command == 0x80):
                 if 'note_off' in exclude:
                     continue
                 E = ['note_off', time, channel, parameter[0], parameter[1]]
@@ -991,11 +1004,11 @@ The options:
             elif (command == 0xA0):
                 if 'key_after_touch' in exclude:
                     continue
-                E = ['key_after_touch',time,channel,parameter[0],parameter[1]]
+                E = ['key_after_touch', time, channel, parameter[0], parameter[1]]
             elif (command == 0xB0):
                 if 'control_change' in exclude:
                     continue
-                E = ['control_change',time,channel,parameter[0],parameter[1]]
+                E = ['control_change', time, channel, parameter[0], parameter[1]]
             elif (command == 0xC0):
                 if 'patch_change' in exclude:
                     continue
@@ -1008,93 +1021,94 @@ The options:
                 if 'pitch_wheel_change' in exclude:
                     continue
                 E = ['pitch_wheel_change', time, channel,
-                 _read_14_bit(parameter)-0x2000]
+                     _read_14_bit(parameter) - 0x2000]
             else:
-                _warn("Shouldn't get here; command="+hex(command))
+                _warn("Shouldn't get here; command=" + hex(command))
 
         elif (first_byte == 0xFF):  # It's a Meta-Event! ##################
-            #[command, length, remainder] =
+            # [command, length, remainder] =
             #    unpack("xCwa*", substr(trackdata, $Pointer, 6));
-            #Pointer += 6 - len(remainder);
+            # Pointer += 6 - len(remainder);
             #    # Move past JUST the length-encoded.
-            command = trackdata.pop(0) & 0xFF
+            command = trackdata[0] & 0xFF
+            trackdata = trackdata[1:]
             [length, trackdata] = _unshift_ber_int(trackdata)
-            if (command      == 0x00):
-                 if (length == 2):
-                     E = ['set_sequence_number',time,_twobytes2int(trackdata)]
-                 else:
-                     _warn('set_sequence_number: length must be 2, not '+str(length))
-                     E = ['set_sequence_number', time, 0]
-
-            elif command >= 0x01 and command <= 0x0f:   # Text events
+            if (command == 0x00):
+                if (length == 2):
+                    E = ['set_sequence_number', time, _twobytes2int(trackdata)]
+                else:
+                    _warn('set_sequence_number: length must be 2, not ' + str(length))
+                    E = ['set_sequence_number', time, 0]
+
+            elif command >= 0x01 and command <= 0x0f:  # Text events
                 # 6.2 take it in bytes; let the user get the right encoding.
                 # text_str = trackdata[0:length].decode('ascii','ignore')
                 # text_str = trackdata[0:length].decode('ISO-8859-1')
                 # 6.4 take it in bytes; let the user get the right encoding.
-                text_data = bytes(trackdata[0:length])   # 6.4
+                text_data = bytes(trackdata[0:length])  # 6.4
                 # Defined text events
                 if (command == 0x01):
-                     E = ['text_event', time, text_data]
+                    E = ['text_event', time, text_data]
                 elif (command == 0x02):
-                     E = ['copyright_text_event', time, text_data]
+                    E = ['copyright_text_event', time, text_data]
                 elif (command == 0x03):
-                     E = ['track_name', time, text_data]
+                    E = ['track_name', time, text_data]
                 elif (command == 0x04):
-                     E = ['instrument_name', time, text_data]
+                    E = ['instrument_name', time, text_data]
                 elif (command == 0x05):
-                     E = ['lyric', time, text_data]
+                    E = ['lyric', time, text_data]
                 elif (command == 0x06):
-                     E = ['marker', time, text_data]
+                    E = ['marker', time, text_data]
                 elif (command == 0x07):
-                     E = ['cue_point', time, text_data]
+                    E = ['cue_point', time, text_data]
                 # Reserved but apparently unassigned text events
                 elif (command == 0x08):
-                     E = ['text_event_08', time, text_data]
+                    E = ['text_event_08', time, text_data]
                 elif (command == 0x09):
-                     E = ['text_event_09', time, text_data]
+                    E = ['text_event_09', time, text_data]
                 elif (command == 0x0a):
-                     E = ['text_event_0a', time, text_data]
+                    E = ['text_event_0a', time, text_data]
                 elif (command == 0x0b):
-                     E = ['text_event_0b', time, text_data]
+                    E = ['text_event_0b', time, text_data]
                 elif (command == 0x0c):
-                     E = ['text_event_0c', time, text_data]
+                    E = ['text_event_0c', time, text_data]
                 elif (command == 0x0d):
-                     E = ['text_event_0d', time, text_data]
+                    E = ['text_event_0d', time, text_data]
                 elif (command == 0x0e):
-                     E = ['text_event_0e', time, text_data]
+                    E = ['text_event_0e', time, text_data]
                 elif (command == 0x0f):
-                     E = ['text_event_0f', time, text_data]
+                    E = ['text_event_0f', time, text_data]
 
             # Now the sticky events -------------------------------------
             elif (command == 0x2F):
-                 E = ['end_track', time]
-                     # The code for handling this, oddly, comes LATER,
-                     # in the event registrar.
-            elif (command == 0x51): # DTime, Microseconds/Crochet
-                 if length != 3:
-                     _warn('set_tempo event, but length='+str(length))
-                 E = ['set_tempo', time,
-                      struct.unpack(">I", b'\x00'+trackdata[0:3])[0]]
+                E = ['end_track', time]
+                # The code for handling this, oddly, comes LATER,
+                # in the event registrar.
+            elif (command == 0x51):  # DTime, Microseconds/Crochet
+                if length != 3:
+                    _warn('set_tempo event, but length=' + str(length))
+                E = ['set_tempo', time,
+                     struct.unpack(">I", b'\x00' + trackdata[0:3])[0]]
             elif (command == 0x54):
-                 if length != 5:   # DTime, HR, MN, SE, FR, FF
-                     _warn('smpte_offset event, but length='+str(length))
-                 E = ['smpte_offset',time] + list(struct.unpack(">BBBBB",trackdata[0:5]))
+                if length != 5:  # DTime, HR, MN, SE, FR, FF
+                    _warn('smpte_offset event, but length=' + str(length))
+                E = ['smpte_offset', time] + list(struct.unpack(">BBBBB", trackdata[0:5]))
             elif (command == 0x58):
-                 if length != 4:   # DTime, NN, DD, CC, BB
-                     _warn('time_signature event, but length='+str(length))
-                 E = ['time_signature', time]+list(trackdata[0:4])
+                if length != 4:  # DTime, NN, DD, CC, BB
+                    _warn('time_signature event, but length=' + str(length))
+                E = ['time_signature', time] + list(trackdata[0:4])
             elif (command == 0x59):
-                 if length != 2:   # DTime, SF(signed), MI
-                     _warn('key_signature event, but length='+str(length))
-                 E = ['key_signature',time] + list(struct.unpack(">bB",trackdata[0:2]))
-            elif (command == 0x7F):   # 6.4
-                 E = ['sequencer_specific',time, bytes(trackdata[0:length])]
+                if length != 2:  # DTime, SF(signed), MI
+                    _warn('key_signature event, but length=' + str(length))
+                E = ['key_signature', time] + list(struct.unpack(">bB", trackdata[0:2]))
+            elif (command == 0x7F):  # 6.4
+                E = ['sequencer_specific', time, bytes(trackdata[0:length])]
             else:
-                 E = ['raw_meta_event', time, command,
-                   bytes(trackdata[0:length])]   # 6.0
-                 #"[uninterpretable meta-event command of length length]"
-                 # DTime, Command, Binary Data
-                 # It's uninterpretable; record it as raw_data.
+                E = ['raw_meta_event', time, command,
+                     bytes(trackdata[0:length])]  # 6.0
+                # "[uninterpretable meta-event command of length length]"
+                # DTime, Command, Binary Data
+                # It's uninterpretable; record it as raw_data.
 
             # Pointer += length; #  Now move Pointer
             trackdata = trackdata[length:]
@@ -1111,7 +1125,7 @@ The options:
             # is omitted if this is a non-final block in a multiblock sysex;
             # but the F7 (if there) is counted in the message's declared
             # length, so we don't have to think about it anyway.)
-            #command = trackdata.pop(0)
+            # command = trackdata.pop(0)
             [length, trackdata] = _unshift_ber_int(trackdata)
             if first_byte == 0xF0:
                 # 20091008 added ISO-8859-1 to get an 8-bit str
@@ -1135,32 +1149,32 @@ The options:
         # from the MIDI file spec.  So, I'm going to assume that
         # they CAN, in practice, occur.  I don't know whether it's
         # proper for you to actually emit these into a MIDI file.
-        
-        elif (first_byte == 0xF2):   # DTime, Beats
+
+        elif (first_byte == 0xF2):  # DTime, Beats
             #  <song position msg> ::=     F2 <data pair>
             E = ['song_position', time, _read_14_bit(trackdata[:2])]
             trackdata = trackdata[2:]
 
-        elif (first_byte == 0xF3):   # <song select msg> ::= F3 <data singlet>
+        elif (first_byte == 0xF3):  # <song select msg> ::= F3 <data singlet>
             # E = ['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]]
             E = ['song_select', time, trackdata[0]]
             trackdata = trackdata[1:]
             # DTime, Thing (what?! song number?  whatever ...)
 
-        elif (first_byte == 0xF6):   # DTime
+        elif (first_byte == 0xF6):  # DTime
             E = ['tune_request', time]
             # What would a tune request be doing in a MIDI /file/?
 
-        #########################################################
-        # ADD MORE META-EVENTS HERE.  TODO:
-        # f1 -- MTC Quarter Frame Message. One data byte follows
-        #     the Status; it's the time code value, from 0 to 127.
-        # f8 -- MIDI clock.    no data.
-        # fa -- MIDI start.    no data.
-        # fb -- MIDI continue. no data.
-        # fc -- MIDI stop.     no data.
-        # fe -- Active sense.  no data.
-        # f4 f5 f9 fd -- unallocated
+            #########################################################
+            # ADD MORE META-EVENTS HERE.  TODO:
+            # f1 -- MTC Quarter Frame Message. One data byte follows
+            #     the Status; it's the time code value, from 0 to 127.
+            # f8 -- MIDI clock.    no data.
+            # fa -- MIDI start.    no data.
+            # fb -- MIDI continue. no data.
+            # fc -- MIDI stop.     no data.
+            # fe -- Active sense.  no data.
+            # f4 f5 f9 fd -- unallocated
 
             r'''
         elif (first_byte > 0xF0) { # Some unknown kinda F-series event ####
@@ -1175,31 +1189,30 @@ The options:
         elif first_byte > 0xF0:  # Some unknown F-series event
             # Here we only produce a one-byte piece of raw data.
             # E = ['raw_data', time, bytest(trackdata[0])]   # 6.4
-            E = ['raw_data', time, trackdata[0]]   # 6.4 6.7
+            E = ['raw_data', time, trackdata[0]]  # 6.4 6.7
             trackdata = trackdata[1:]
         else:  # Fallthru.
-            _warn("Aborting track.  Command-byte first_byte="+hex(first_byte))
+            _warn("Aborting track.  Command-byte first_byte=" + hex(first_byte))
             break
         # End of the big if-group
 
-
         ######################################################################
         #  THE EVENT REGISTRAR...
-        if E and  (E[0] == 'end_track'):
+        if E and (E[0] == 'end_track'):
             # This is the code for exceptional handling of the EOT event.
             eot = True
             if not no_eot_magic:
                 if E[1] > 0:  # a null text-event to carry the delta-time
                     E = ['text_event', E[1], '']
                 else:
-                    E = []   # EOT with a delta-time of 0; ignore it.
-        
+                    E = []  # EOT with a delta-time of 0; ignore it.
+
         if E and not (E[0] in exclude):
-            #if ( $exclusive_event_callback ):
+            # if ( $exclusive_event_callback ):
             #    &{ $exclusive_event_callback }( @E );
-            #else:
+            # else:
             #    &{ $event_callback }( @E ) if $event_callback;
-                events.append(E)
+            events.append(E)
         if eot:
             break
 
@@ -1819,6 +1832,7 @@ def plot_ms_SONG(ms_song,
         plt.close()
 
     if return_plt:
+      plt.close(fig)
       return fig
 
     plt.show()
@@ -4595,12 +4609,18 @@ def ascii_text_words_counter(ascii_text):
     
 ###################################################################################
 
-def check_and_fix_tones_chord(tones_chord):
+def check_and_fix_tones_chord(tones_chord, use_full_chords=True):
 
   tones_chord_combs = [list(comb) for i in range(len(tones_chord), 0, -1) for comb in combinations(tones_chord, i)]
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
   for c in tones_chord_combs:
-    if c in ALL_CHORDS_FULL:
+    if c in CHORDS:
       checked_tones_chord = c
       break
 
@@ -4613,12 +4633,18 @@ def find_closest_tone(tones, tone):
 
 ###################################################################################
 
-def advanced_check_and_fix_tones_chord(tones_chord, high_pitch=0):
+def advanced_check_and_fix_tones_chord(tones_chord, high_pitch=0, use_full_chords=True):
 
   tones_chord_combs = [list(comb) for i in range(len(tones_chord), 0, -1) for comb in combinations(tones_chord, i)]
 
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
   for c in tones_chord_combs:
-    if c in ALL_CHORDS_FULL:
+    if c in CHORDS:
       tchord = c
 
   if 0 < high_pitch < 128 and len(tchord) == 1:
@@ -4664,7 +4690,8 @@ def augment_enhanced_score_notes(enhanced_score_notes,
                                   pitch_shift=0,
                                   ceil_timings=False,
                                   round_timings=False,
-                                  legacy_timings=False
+                                  legacy_timings=True,
+                                  sort_drums_last=False
                                 ):
 
     esn = copy.deepcopy(enhanced_score_notes)
@@ -4714,6 +4741,9 @@ def augment_enhanced_score_notes(enhanced_score_notes,
       esn.sort(key=lambda x: x[6])
       esn.sort(key=lambda x: x[4], reverse=True)
       esn.sort(key=lambda x: x[1])
+      
+    if sort_drums_last:
+        esn.sort(key=lambda x: (x[1], -x[4], x[6]) if x[6] != 128 else (x[1], x[6], -x[4]))
 
     return esn
 
@@ -5153,8 +5183,9 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
                                                       pitches_index=4,
                                                       patches_index=6,
                                                       use_filtered_chords=False,
-                                                      use_full_chords=True,
+                                                      use_full_chords=False,
                                                       remove_duplicate_pitches=True,
+                                                      fix_bad_tones_chords=False,
                                                       fix_bad_pitches=False,
                                                       skip_drums=False
                                                       ):
@@ -5208,22 +5239,64 @@ def advanced_check_and_fix_chords_in_chordified_score(chordified_score,
             tones_counts = Counter([p % 12 for p in pitches_chord]).most_common()
 
             if tones_counts[0][1] > 1:
-              tones_chord = [tones_counts[0][0]]
+              good_tone = tones_counts[0][0]
+              bad_tone = tones_counts[1][0]
             
             elif tones_counts[1][1] > 1:
-              tones_chord = [tones_counts[1][0]]
+              good_tone = tones_counts[1][0]
+              bad_tone = tones_counts[0][0]
             
             else:
-              tones_chord = [pitches_chord[0] % 12]
+              good_tone = pitches_chord[0] % 12
+              bad_tone = [t for t in tones_chord if t != good_tone][0]
 
-          else:
+            tones_chord = [good_tone]
+
+            if fix_bad_tones_chords:
+
+              if good_tone > bad_tone:
+
+                if sorted([good_tone, (12+(bad_tone+1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone-1)) % 12])
+
+                elif sorted([good_tone, (12+(bad_tone-1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone+1)) % 12])
+
+              else:
+
+                if sorted([good_tone, (12+(bad_tone-1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone-1)) % 12])
+
+                elif sorted([good_tone, (12+(bad_tone+1)) % 12]) in CHORDS:
+                  tones_chord = sorted([good_tone, (12+(bad_tone+1)) % 12])          
+
+          if len(tones_chord) > 2:
             tones_chord_combs = [list(comb) for i in range(len(tones_chord)-1, 0, -1) for comb in combinations(tones_chord, i)]
 
             for co in tones_chord_combs:
               if co in CHORDS:
-                tones_chord = co
                 break
 
+            if fix_bad_tones_chords:
+
+              dt_chord = list(set(co) ^ set(tones_chord))
+
+              for t in dt_chord:
+                tones_chord.append((12+(t+1)) % 12)
+                tones_chord.append((12+(t-1)) % 12)
+
+              ex_tones_chord = sorted(set(tones_chord))
+
+              tones_chord_combs = [list(comb) for i in range(4, 0, -2) for comb in combinations(ex_tones_chord, i) if all(t in list(comb) for t in co)]
+              
+              for eco in tones_chord_combs:
+                if eco in CHORDS:
+                  tones_chord = eco
+                  break              
+
+            else:
+              tones_chord = co
+
           if len(tones_chord) == 1:
             tones_chord = [pitches_chord[0] % 12]
             
@@ -7028,13 +7101,25 @@ def escore_notes_averages(escore_notes,
   else:
     durs = [e[durs_index] for e in escore_notes if e[chans_index] != 9]
 
+  if len(times) == 0:
+      times = [0]
+      
+  if len(durs) == 0:
+      durs = [0]
+
   if return_ptcs_and_vels:
     if average_drums:
       ptcs = [e[ptcs_index] for e in escore_notes]
       vels = [e[vels_index] for e in escore_notes]
     else:
       ptcs = [e[ptcs_index] for e in escore_notes if e[chans_index] != 9]
-      vels = [e[vels_index] for e in escore_notes if e[chans_index] != 9]      
+      vels = [e[vels_index] for e in escore_notes if e[chans_index] != 9]
+      
+    if len(ptcs) == 0:
+        ptcs = [0]
+      
+    if len(vels) == 0:
+        vels = [0]
 
     return [sum(times) / len(times), sum(durs) / len(durs), sum(ptcs) / len(ptcs), sum(vels) / len(vels)]
   
@@ -7814,19 +7899,21 @@ def solo_piano_escore_notes(escore_notes,
     chord = []
 
     for cc in c:
-      if cc[pitches_index] not in seen:
 
-          if cc[channels_index] != 9:
+      if cc[channels_index] != 9:
+        if cc[pitches_index] not in seen:
+            
             cc[channels_index] = 0
             cc[patches_index] = 0
-            
+        
             chord.append(cc)
             seen.append(cc[pitches_index])
-          
-          else:
-            if keep_drums:
+      
+      else:
+        if keep_drums:
+          if cc[pitches_index]+128 not in seen:
               chord.append(cc)
-              seen.append(cc[pitches_index])
+              seen.append(cc[pitches_index]+128)
 
     sp_escore_notes.append(chord)
 
@@ -8858,7 +8945,1360 @@ def escore_notes_to_parsons_code(escore_notes,
 def all_consequtive(list_of_values):
   return all(b > a for a, b in zip(list_of_values[:-1], list_of_values[1:]))
 
-###################################################################################  
+###################################################################################
+
+def escore_notes_patches(escore_notes, patches_index=6):
+  return sorted(set([e[patches_index] for e in escore_notes]))
+
+###################################################################################
+
+def build_suffix_array(lst):
+
+    n = len(lst)
+
+    suffixes = [(lst[i:], i) for i in range(n)]
+    suffixes.sort()
+    suffix_array = [suffix[1] for suffix in suffixes]
+
+    return suffix_array
+
+###################################################################################
+
+def build_lcp_array(lst, suffix_array):
+
+    n = len(lst)
+    rank = [0] * n
+    lcp = [0] * n
+
+    for i, suffix in enumerate(suffix_array):
+      rank[suffix] = i
+
+    h = 0
+
+    for i in range(n):
+      if rank[i] > 0:
+
+        j = suffix_array[rank[i] - 1]
+
+        while i + h < n and j + h < n and lst[i + h] == lst[j + h]:
+          h += 1
+
+        lcp[rank[i]] = h
+
+        if h > 0:
+          h -= 1
+
+    return lcp
+
+###################################################################################
+
+def find_lrno_pattern_fast(lst):
+    n = len(lst)
+    if n == 0:
+      return []
+
+    suffix_array = build_suffix_array(lst)
+    lcp_array = build_lcp_array(lst, suffix_array)
+
+    max_len = 0
+    start_index = 0
+
+    for i in range(1, n):
+      if lcp_array[i] > max_len:
+        if suffix_array[i] + lcp_array[i] <= suffix_array[i - 1] or suffix_array[i - 1] + lcp_array[i - 1] <= suffix_array[i]:
+          max_len = lcp_array[i]
+          start_index = suffix_array[i]
+
+    return lst[start_index:start_index + max_len]
+
+###################################################################################
+
+def find_chunk_indexes(original_list, chunk, ignore_index=-1):
+
+  chunk_length = len(chunk)
+
+  for i in range(len(original_list) - chunk_length + 1):
+
+    chunk_index = 0
+    start_index = ignore_index
+
+    for j in range(i, len(original_list)):
+      if original_list[j] == chunk[chunk_index]:
+
+        if start_index == ignore_index:
+          start_index = j
+
+        chunk_index += 1
+
+        if chunk_index == chunk_length:
+          return [start_index, j]
+
+      elif original_list[j] != ignore_index:
+        break
+
+  return None
+
+###################################################################################
+
+def escore_notes_lrno_pattern_fast(escore_notes, 
+                                   channels_index=3, 
+                                   pitches_index=4, 
+                                   zero_start_time=True
+                                  ):
+
+  cscore = chordify_score([1000, escore_notes])
+
+  score_chords = []
+
+  for c in cscore:
+
+    tchord = sorted(set([e[pitches_index] % 12 for e in c if e[channels_index] != 9]))
+
+    chord_tok = -1
+
+    if tchord:
+
+      if tchord not in ALL_CHORDS_FULL:
+        tchord = check_and_fix_tones_chord(tchord)
+
+      chord_tok = ALL_CHORDS_FULL.index(tchord)
+
+    score_chords.append(chord_tok)
+
+  schords = [c for c in score_chords if c != -1]
+
+  lrno = find_lrno_pattern_fast(schords)
+
+  if lrno:
+
+    sidx, eidx = find_chunk_indexes(score_chords, lrno)
+
+    escore_notes_lrno_pattern = flatten(cscore[sidx:eidx+1])
+
+    if escore_notes_lrno_pattern is not None:
+
+      if zero_start_time:
+        return recalculate_score_timings(escore_notes_lrno_pattern)
+
+      else:
+        return escore_notes_lrno_pattern
+
+    else:
+      return None
+  
+  else:
+    return None
+
+###################################################################################
+
+def escore_notes_durations_counter(escore_notes, 
+                                   min_duration=0, 
+                                   durations_index=2, 
+                                   channels_index=3
+                                   ):
+  
+  escore = [e for e in escore_notes if e[channels_index] != 9]
+  durs = [e[durations_index] for e in escore if e[durations_index] >= min_duration]
+  zero_durs = sum([1 for e in escore if e[durations_index] == 0])
+  
+  return [len(durs), len(escore), zero_durs, Counter(durs).most_common()]
+
+###################################################################################
+
+def count_bad_chords_in_chordified_score(chordified_score,  
+                                         pitches_index=4,
+                                         patches_index=6,
+                                         max_patch=127, 
+                                         use_full_chords=False
+                                         ):
+
+  if use_full_chords:
+    CHORDS = ALL_CHORDS_FULL
+
+  else:
+    CHORDS = ALL_CHORDS_SORTED
+
+  bad_chords_count = 0
+
+  for c in chordified_score:
+
+    cpitches = [e[pitches_index] for e in c if e[patches_index] <= max_patch]
+    tones_chord = sorted(set([p % 12 for p in cpitches]))
+
+    if tones_chord:
+      if tones_chord not in CHORDS:
+        bad_chords_count += 1
+
+  return [bad_chords_count, len(chordified_score)]
+
+###################################################################################
+
+def needleman_wunsch_aligner(seq1,
+                             seq2,
+                             align_idx,
+                             gap_penalty=-1,
+                             match_score=2,
+                             mismatch_penalty=-1
+                             ):
+    
+    n = len(seq1)
+    m = len(seq2)
+    
+    score_matrix = [[0] * (m + 1) for _ in range(n + 1)]
+
+    for i in range(1, n + 1):
+        score_matrix[i][0] = gap_penalty * i
+    for j in range(1, m + 1):
+        score_matrix[0][j] = gap_penalty * j
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            match = score_matrix[i-1][j-1] + (match_score if seq1[i-1][align_idx] == seq2[j-1][align_idx] else mismatch_penalty)
+            delete = score_matrix[i-1][j] + gap_penalty
+            insert = score_matrix[i][j-1] + gap_penalty
+            score_matrix[i][j] = max(match, delete, insert)
+
+    align1, align2 = [], []
+    i, j = n, m
+    
+    while i > 0 and j > 0:
+        
+        score = score_matrix[i][j]
+        score_diag = score_matrix[i-1][j-1]
+        score_up = score_matrix[i-1][j]
+        score_left = score_matrix[i][j-1]
+
+        if score == score_diag + (match_score if seq1[i-1][align_idx] == seq2[j-1][align_idx] else mismatch_penalty):
+            align1.append(seq1[i-1])
+            align2.append(seq2[j-1])
+            i -= 1
+            j -= 1
+        elif score == score_up + gap_penalty:
+            align1.append(seq1[i-1])
+            align2.append([None] * 6)
+            i -= 1
+        elif score == score_left + gap_penalty:
+            align1.append([None] * 6)
+            align2.append(seq2[j-1])
+            j -= 1
+
+    while i > 0:
+        align1.append(seq1[i-1])
+        align2.append([None] * 6)
+        i -= 1
+    while j > 0:
+        align1.append([None] * 6)
+        align2.append(seq2[j-1])
+        j -= 1
+
+    align1.reverse()
+    align2.reverse()
+
+    return align1, align2
+
+###################################################################################
+
+def align_escore_notes_to_escore_notes(src_escore_notes,
+                                       trg_escore_notes,
+                                       recalculate_scores_timings=True,
+                                       pitches_idx=4
+                                       ):
+    
+    if recalculate_scores_timings:
+        src_escore_notes = recalculate_score_timings(src_escore_notes)
+        trg_escore_notes = recalculate_score_timings(trg_escore_notes)
+        
+    src_align1, trg_align2 = needleman_wunsch_aligner(src_escore_notes, trg_escore_notes, pitches_idx)
+
+    aligned_scores = [[al[0], al[1]] for al in zip(src_align1, trg_align2) if al[0][0] is not None and al[1][0] is not None]
+    
+    return aligned_scores
+
+###################################################################################
+
+def t_to_n(arr, si, t):
+
+    ct = 0
+    ci = si
+    
+    while ct + arr[ci][1] < t and ci < len(arr)-1:
+        ct += arr[ci][1]
+        ci += 1
+
+    return ci+1
+
+###################################################################################
+
+def max_sum_chunk_idxs(arr, t=255):
+
+    n = t_to_n(arr, 0, t)
+    
+    if n > len(arr):
+        return [0, n]
+
+    max_sum = 0
+    max_sum_start_index = 0
+    
+    max_sum_start_idxs = [0, len(arr), sum([a[0] for a in arr])]
+
+    for i in range(len(arr)):
+
+        n = t_to_n(arr, i, t)
+
+        current_sum  = sum([a[0] for a in arr[i:n]])
+        current_time = sum([a[1] for a in arr[i:n]])
+
+        if current_sum > max_sum and current_time <= t:
+            max_sum = current_sum
+            max_sum_start_idxs = [i, n, max_sum]
+
+    return max_sum_start_idxs
+
+###################################################################################
+
+def find_highest_density_escore_notes_chunk(escore_notes, max_chunk_time=512):
+
+    dscore = delta_score_notes(escore_notes)
+    
+    cscore = chordify_score([d[1:] for d in dscore])
+
+    notes_counts = [[len(c), c[0][0]] for c in cscore]
+
+    msc_idxs = max_sum_chunk_idxs(notes_counts, max_chunk_time)
+
+    chunk_dscore = [['note'] + c for c in flatten(cscore[msc_idxs[0]:msc_idxs[1]])]
+
+    chunk_escore = recalculate_score_timings(delta_score_to_abs_score(chunk_dscore))
+    
+    return chunk_escore
+
+###################################################################################
+
+def advanced_add_drums_to_escore_notes(escore_notes,
+                                       main_beat_min_dtime=5,
+                                       main_beat_dtime_thres=1,
+                                       drums_durations_value=2,
+                                       drums_pitches_velocities=[(36, 100), 
+                                                                 (38, 100), 
+                                                                 (41, 125)],
+                                       recalculate_score_timings=True,
+                                       intro_drums_count=4,
+                                       intro_drums_time_k=4,
+                                       intro_drums_pitch_velocity=[37, 110]
+                                      ):
+
+    #===========================================================
+    
+    new_dscore = delta_score_notes(escore_notes)
+
+    times = [d[1] for d in new_dscore if d[1] != 0]
+
+    time = [c[0] for c in Counter(times).most_common() if c[0] >= main_beat_min_dtime][0]
+
+    #===========================================================
+
+    if intro_drums_count > 0:
+
+        drums_score = []
+
+        for i in range(intro_drums_count):
+
+            if i == 0:
+                dtime = 0
+
+            else:
+                dtime = time
+            
+            drums_score.append(['note', 
+                                dtime * intro_drums_time_k, 
+                                drums_durations_value, 
+                                9, 
+                                intro_drums_pitch_velocity[0], 
+                                intro_drums_pitch_velocity[1], 
+                                128]
+                              )
+            
+        new_dscore[0][1] = time * intro_drums_time_k
+
+        new_dscore = drums_score + new_dscore
+
+    #===========================================================
+
+    for e in new_dscore:
+    
+        if abs(e[1] - time) == main_beat_dtime_thres:
+            e[1] = time
+
+        if recalculate_score_timings:
+        
+            if e[1] % time != 0 and e[1] > time:
+                if e[1] % time < time // 2:
+                    e[1] -= e[1] % time
+        
+                else:
+                    e[1] += time - (e[1] % time)
+
+    #===========================================================
+
+    drums_score = []
+    
+    dtime = 0
+    
+    idx = 0
+    
+    for i, e in enumerate(new_dscore):
+        
+        drums_score.append(e)
+        
+        dtime += e[1]
+
+        if e[1] != 0:
+            idx += 1
+
+        if i >= intro_drums_count:
+    
+            if (e[1] % time == 0 and e[1] != 0) or i == 0:
+                
+                if idx % 2 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[0][0], 
+                                        drums_pitches_velocities[0][1], 
+                                        128]
+                                      )
+                    
+                if idx % 2 != 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[1][0], 
+                                        drums_pitches_velocities[1][1], 
+                                        128]
+                                      )
+        
+                if idx % 4 == 0 and e[1] != 0:
+                    drums_score.append(['note', 
+                                        0, 
+                                        drums_durations_value, 
+                                        9, 
+                                        drums_pitches_velocities[2][0], 
+                                        drums_pitches_velocities[2][1], 
+                                        128]
+                                      )
+
+    #===========================================================
+    
+    return delta_score_to_abs_score(drums_score)
+
+###################################################################################
+
+MIDI_TEXT_EVENTS = ['text_event',
+                    'copyright_text_event',
+                    'track_name',
+                    'instrument_name',
+                    'lyric',
+                    'marker',
+                    'cue_point',
+                    'text_event_08',
+                    'text_event_09',
+                    'text_event_0a',
+                    'text_event_0b',
+                    'text_event_0c',
+                    'text_event_0d',
+                    'text_event_0e',
+                    'text_event_0f'
+                  ]
+
+###################################################################################
+
+import hashlib
+import re
+
+###################################################################################
+
+def get_md5_hash(data):
+    return hashlib.md5(data).hexdigest()
+
+###################################################################################
+
+def is_valid_md5_hash(string):
+    return bool(re.match(r'^[a-fA-F0-9]{32}$', string))
+
+###################################################################################
+
+def clean_string(original_string,
+                 regex=r'[^a-zA-Z0-9 ]',
+                 remove_duplicate_spaces=True,
+                 title=False
+                ):
+    
+    cstr1 = re.sub(regex, '', original_string)
+
+    if title:
+        cstr1 = cstr1.title()
+
+    if remove_duplicate_spaces:
+        return re.sub(r'\s+', ' ', cstr1).strip()
+
+    else:
+        return cstr1
+    
+###################################################################################
+    
+def encode_to_ord(text, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+
+    encoded = []
+    
+    for char in text:
+        if ord(char) in chars_range:
+            encoded.append(chars_range.index(ord(char)) + chars_shift)
+            
+        else:
+            if sub_char:
+                encoded.append(chars_range.index(ord(sub_char)) + chars_shift)
+        
+    
+    return [encoded, chars_range]
+
+###################################################################################
+
+def decode_from_ord(ord_list, chars_range=[], sub_char='', chars_shift=0):
+
+    if not chars_range:
+        chars_range = [32] + list(range(65, 91)) + list(range(97, 123))
+
+    if sub_char:
+        chars_range.append(ord(sub_char))
+
+    chars_range = sorted(set(chars_range))
+        
+    return ''.join(chr(chars_range[num-chars_shift]) if 0 <= num-chars_shift < len(chars_range) else sub_char for num in ord_list)
+
+###################################################################################
+
+def lists_similarity(list1, list2, by_elements=True, by_sum=True):
+    
+    if len(list1) != len(list2):
+        return -1
+    
+    element_ratios = []
+    total_counts1 = sum(list1)
+    total_counts2 = sum(list2)
+
+    for a, b in zip(list1, list2):
+        if a == 0 and b == 0:
+            element_ratios.append(1)
+        elif a == 0 or b == 0:
+            element_ratios.append(0)
+        else:
+            element_ratios.append(min(a, b) / max(a, b))
+
+    average_element_ratio = sum(element_ratios) / len(element_ratios)
+
+    total_counts_ratio = min(total_counts1, total_counts2) / max(total_counts1, total_counts2)
+
+    if by_elements and by_sum:
+        return (average_element_ratio + total_counts_ratio) / 2
+
+    elif by_elements and not by_sum:
+        return average_element_ratio
+
+    elif not by_elements and by_sum:
+        return total_counts_ratio
+
+    else:
+        return -1
+
+###################################################################################
+
+def find_indexes(lst, value, mode='equal', dual_mode=True):
+
+    indexes = []
+
+    if mode == 'equal' or dual_mode:    
+        indexes.extend([index for index, elem in enumerate(lst) if elem == value])
+
+    if mode == 'smaller':
+        indexes.extend([index for index, elem in enumerate(lst) if elem < value])
+
+    if mode == 'larger':
+        indexes.extend([index for index, elem in enumerate(lst) if elem > value])
+
+    return sorted(set(indexes))
+
+###################################################################################
+
+NUMERALS = ["one", "two", "three", "four", 
+            "five", "six", "seven", "eight", 
+            "nine", "ten", "eleven", "twelve", 
+            "thirteen", "fourteen", "fifteen", "sixteen"
+           ]
+
+SEMITONES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+MOOD_SCALES = ['Major', 'Minor', 'Major Minor']
+
+###################################################################################
+
+def alpha_str(string):
+    return re.sub(r'[^a-zA-Z ()]', '', string).strip()
+
+###################################################################################
+
+def escore_notes_to_text_description(escore_notes, song_name='', artist_name=''):
+
+    #==============================================================================
+
+    song_time_min = (escore_notes[-1][1] * 16) / 1000 / 60
+
+    if song_time_min < 1.5:
+        song_length = 'short'
+    
+    elif 1.5 <= song_time_min < 2.5:
+        song_length = 'average'
+    
+    elif song_time_min >= 2.5:
+        song_length = 'long'
+
+    #==============================================================================
+
+    escore_times = [e[1] for e in escore_notes if e[3] != 9]
+    
+    comp_type = ''
+
+    if len(escore_times) > 0:
+        if len(escore_times) == len(set(escore_times)):
+            comp_type = 'monophonic melody'
+        
+        elif len(escore_times) >= len(set(escore_times)) and 1 in Counter(escore_times).values():
+            comp_type = 'melody and accompaniment'
+        
+        elif len(escore_times) >= len(set(escore_times)) and 1 not in Counter(escore_times).values():
+            comp_type = 'accompaniment'
+    
+    else:
+        comp_type = 'drums only'
+
+    #==============================================================================
+
+    patches = sorted(set([e[6] for e in escore_notes]))
+    
+    instruments = [alpha_str(Number2patch[p]) for p in patches if p < 128]
+
+    if 128 in patches:
+        drums_present = True
+
+    else:
+        drums_present = False
+
+    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]
+
+    #==============================================================================
+
+    pitches = [e[4] for e in escore_notes if e[3] != 9]
+    
+    key = ''
+    
+    if pitches:
+        key = SEMITONES[statistics.mode(pitches) % 12]
+
+    #==============================================================================
+        
+    mood = ''
+    
+    if pitches:
+    
+        cscore = chordify_score([1000, escore_notes])
+
+        tones_chords = Counter()
+
+        for c in cscore:
+            if len([e for e in c if e[3] != 9]) > 0:
+                tones_chords[tuple(sorted(set([e[4] % 12 for e in c if e[3] != 9])))] += 1
+                
+        most_common_tones_chords = [check_and_fix_tones_chord(list(c[0])) for c in tones_chords.most_common(10)]
+        
+        mood_scale = statistics.mode(tones_chords_to_types(most_common_tones_chords, return_chord_type_index=True)) % 3
+
+        mood = MOOD_SCALES[mood_scale]
+
+    #==============================================================================
+    
+    if pitches:
+    
+        escore_averages = escore_notes_averages(escore_notes, return_ptcs_and_vels=True)
+
+        if escore_averages[0] < 8:
+            rythm = 'fast'
+        
+        elif 8 <= escore_averages[0] <= 12:
+            rythm = 'average'
+        
+        elif escore_averages[0] > 12:
+            rythm = 'slow'
+        
+        if escore_averages[1] < 16:
+            tempo = 'fast'
+        
+        elif 16 <= escore_averages[1] <= 24:
+            tempo = 'average'
+        
+        elif escore_averages[1] > 24:
+            tempo = 'slow'
+        
+        if escore_averages[2] < 50:
+            tone = 'bass'
+        
+        elif 50 <= escore_averages[2] <= 70:
+            tone = 'midrange'
+        
+        elif escore_averages[2] > 70:
+            tone = 'treble'
+        
+        if escore_averages[3] < 80:
+            dynamics = 'quiet'
+        
+        elif 80 <= escore_averages[3] <= 100:
+            dynamics = 'average'
+        
+        elif escore_averages[3] > 100:
+            dynamics = 'loud'
+
+    #==============================================================================
+        
+    description = ''
+
+    if song_name != '':
+        description = 'Song "' + song_name + '"'
+    
+    if artist_name != '':
+        description += ' by ' + artist_name
+
+    if song_name != '' or artist_name != '':
+        description += '.'
+        description += '\n'
+    
+    description += 'The song is '
+
+    if song_length != 'average':
+        description += 'a ' + song_length
+
+    else:
+        description += 'an ' + song_length
+
+    description += ' duration '
+
+    description += comp_type + ' composition'
+
+    if comp_type != 'drum track':
+
+        if drums_present:
+            description += ' with drums'
+    
+        else:
+            description += ' without drums'
+    
+        if key and mood:
+            description += ' in ' + key + ' ' + mood
+
+    description += '.'
+
+    description += '\n'
+    
+    if pitches:
+
+        description += 'It has '
+        
+        description += rythm + ' rythm, '
+        description += tempo + ' tempo, '
+        description += tone + ' tone and '
+        description += dynamics + ' dynamics.'
+
+        description += '\n'
+
+        description += 'The song ' 
+
+        if len(instruments) == 1:
+            description += 'is played on a solo ' + instruments[0] + '.'
+
+        else:
+            description += 'features ' + NUMERALS[max(0, min(15, len(instruments)-1))] + ' instruments: '
+            description += ', '.join(instruments[:-1]) + ' and ' + instruments[-1] + '.'
+
+        description += '\n'
+
+    if drums_present and most_common_drums:
+        description += 'The drum track has predominant '
+        description += ', '.join(most_common_drums[:-1]) + ' and ' + most_common_drums[-1] + '.'
+
+    #==============================================================================
+
+    return description
+
+###################################################################################
+
+#==================================================================================
+#
+# Below constants code is a courtesy of MidiTok
+#
+# Retrieved on 12/29/2024
+#
+# https://github.com/Natooz/MidiTok/blob/main/src/miditok/constants.py
+#
+#==================================================================================
+
+MIDI_FILES_EXTENSIONS = [".mid", ".midi", ".kar", ".MID", ".MIDI", ".KAR"]
+
+# The recommended pitches for piano in the GM2 specs are from 21 to 108
+PIANO_PITCH_RANGE = range(21, 109)
+
+# Chord params
+# "chord_unknown" specifies the range of number of notes that can form "unknown" chords
+# (that do not fit in "chord_maps") to add in tokens.
+# Known chord maps, with 0 as root note
+BASIC_CHORDS_MAP = {
+    "min": (0, 3, 7),
+    "maj": (0, 4, 7),
+    "dim": (0, 3, 6),
+    "aug": (0, 4, 8),
+    "sus2": (0, 2, 7),
+    "sus4": (0, 5, 7),
+    "7dom": (0, 4, 7, 10),
+    "7min": (0, 3, 7, 10),
+    "7maj": (0, 4, 7, 11),
+    "7halfdim": (0, 3, 6, 10),
+    "7dim": (0, 3, 6, 9),
+    "7aug": (0, 4, 8, 11),
+    "9maj": (0, 4, 7, 10, 14),
+    "9min": (0, 4, 7, 10, 13),
+    }
+
+# Drums
+# Recommended range from the GM2 specs
+DRUMS_PITCH_RANGE = range(27, 90)
+
+# Used with chords
+PITCH_CLASSES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+# http://newt.phys.unsw.edu.au/jw/notes.html
+# https://www.midi.org/specifications
+
+# index i = program i+1 in the GM2 specs (7. Appendix A)
+# index i = program i as retrieved by packages
+MIDI_INSTRUMENTS = [
+    # Piano
+    {"name": "Acoustic Grand Piano", "pitch_range": range(21, 109)},
+    {"name": "Bright Acoustic Piano", "pitch_range": range(21, 109)},
+    {"name": "Electric Grand Piano", "pitch_range": range(21, 109)},
+    {"name": "Honky-tonk Piano", "pitch_range": range(21, 109)},
+    {"name": "Electric Piano 1", "pitch_range": range(28, 104)},
+    {"name": "Electric Piano 2", "pitch_range": range(28, 104)},
+    {"name": "Harpsichord", "pitch_range": range(41, 90)},
+    {"name": "Clavi", "pitch_range": range(36, 97)},
+    # Chromatic Percussion
+    {"name": "Celesta", "pitch_range": range(60, 109)},
+    {"name": "Glockenspiel", "pitch_range": range(72, 109)},
+    {"name": "Music Box", "pitch_range": range(60, 85)},
+    {"name": "Vibraphone", "pitch_range": range(53, 90)},
+    {"name": "Marimba", "pitch_range": range(48, 85)},
+    {"name": "Xylophone", "pitch_range": range(65, 97)},
+    {"name": "Tubular Bells", "pitch_range": range(60, 78)},
+    {"name": "Dulcimer", "pitch_range": range(60, 85)},
+    # Organs
+    {"name": "Drawbar Organ", "pitch_range": range(36, 97)},
+    {"name": "Percussive Organ", "pitch_range": range(36, 97)},
+    {"name": "Rock Organ", "pitch_range": range(36, 97)},
+    {"name": "Church Organ", "pitch_range": range(21, 109)},
+    {"name": "Reed Organ", "pitch_range": range(36, 97)},
+    {"name": "Accordion", "pitch_range": range(53, 90)},
+    {"name": "Harmonica", "pitch_range": range(60, 85)},
+    {"name": "Tango Accordion", "pitch_range": range(53, 90)},
+    # Guitars
+    {"name": "Acoustic Guitar (nylon)", "pitch_range": range(40, 85)},
+    {"name": "Acoustic Guitar (steel)", "pitch_range": range(40, 85)},
+    {"name": "Electric Guitar (jazz)", "pitch_range": range(40, 87)},
+    {"name": "Electric Guitar (clean)", "pitch_range": range(40, 87)},
+    {"name": "Electric Guitar (muted)", "pitch_range": range(40, 87)},
+    {"name": "Overdriven Guitar", "pitch_range": range(40, 87)},
+    {"name": "Distortion Guitar", "pitch_range": range(40, 87)},
+    {"name": "Guitar Harmonics", "pitch_range": range(40, 87)},
+    # Bass
+    {"name": "Acoustic Bass", "pitch_range": range(28, 56)},
+    {"name": "Electric Bass (finger)", "pitch_range": range(28, 56)},
+    {"name": "Electric Bass (pick)", "pitch_range": range(28, 56)},
+    {"name": "Fretless Bass", "pitch_range": range(28, 56)},
+    {"name": "Slap Bass 1", "pitch_range": range(28, 56)},
+    {"name": "Slap Bass 2", "pitch_range": range(28, 56)},
+    {"name": "Synth Bass 1", "pitch_range": range(28, 56)},
+    {"name": "Synth Bass 2", "pitch_range": range(28, 56)},
+    # Strings & Orchestral instruments
+    {"name": "Violin", "pitch_range": range(55, 94)},
+    {"name": "Viola", "pitch_range": range(48, 85)},
+    {"name": "Cello", "pitch_range": range(36, 73)},
+    {"name": "Contrabass", "pitch_range": range(28, 56)},
+    {"name": "Tremolo Strings", "pitch_range": range(28, 94)},
+    {"name": "Pizzicato Strings", "pitch_range": range(28, 94)},
+    {"name": "Orchestral Harp", "pitch_range": range(23, 104)},
+    {"name": "Timpani", "pitch_range": range(36, 58)},
+    # Ensembles
+    {"name": "String Ensembles 1", "pitch_range": range(28, 97)},
+    {"name": "String Ensembles 2", "pitch_range": range(28, 97)},
+    {"name": "SynthStrings 1", "pitch_range": range(36, 97)},
+    {"name": "SynthStrings 2", "pitch_range": range(36, 97)},
+    {"name": "Choir Aahs", "pitch_range": range(48, 80)},
+    {"name": "Voice Oohs", "pitch_range": range(48, 80)},
+    {"name": "Synth Voice", "pitch_range": range(48, 85)},
+    {"name": "Orchestra Hit", "pitch_range": range(48, 73)},
+    # Brass
+    {"name": "Trumpet", "pitch_range": range(58, 95)},
+    {"name": "Trombone", "pitch_range": range(34, 76)},
+    {"name": "Tuba", "pitch_range": range(29, 56)},
+    {"name": "Muted Trumpet", "pitch_range": range(58, 83)},
+    {"name": "French Horn", "pitch_range": range(41, 78)},
+    {"name": "Brass Section", "pitch_range": range(36, 97)},
+    {"name": "Synth Brass 1", "pitch_range": range(36, 97)},
+    {"name": "Synth Brass 2", "pitch_range": range(36, 97)},
+    # Reed
+    {"name": "Soprano Sax", "pitch_range": range(54, 88)},
+    {"name": "Alto Sax", "pitch_range": range(49, 81)},
+    {"name": "Tenor Sax", "pitch_range": range(42, 76)},
+    {"name": "Baritone Sax", "pitch_range": range(37, 69)},
+    {"name": "Oboe", "pitch_range": range(58, 92)},
+    {"name": "English Horn", "pitch_range": range(52, 82)},
+    {"name": "Bassoon", "pitch_range": range(34, 73)},
+    {"name": "Clarinet", "pitch_range": range(50, 92)},
+    # Pipe
+    {"name": "Piccolo", "pitch_range": range(74, 109)},
+    {"name": "Flute", "pitch_range": range(60, 97)},
+    {"name": "Recorder", "pitch_range": range(60, 97)},
+    {"name": "Pan Flute", "pitch_range": range(60, 97)},
+    {"name": "Blown Bottle", "pitch_range": range(60, 97)},
+    {"name": "Shakuhachi", "pitch_range": range(55, 85)},
+    {"name": "Whistle", "pitch_range": range(60, 97)},
+    {"name": "Ocarina", "pitch_range": range(60, 85)},
+    # Synth Lead
+    {"name": "Lead 1 (square)", "pitch_range": range(21, 109)},
+    {"name": "Lead 2 (sawtooth)", "pitch_range": range(21, 109)},
+    {"name": "Lead 3 (calliope)", "pitch_range": range(36, 97)},
+    {"name": "Lead 4 (chiff)", "pitch_range": range(36, 97)},
+    {"name": "Lead 5 (charang)", "pitch_range": range(36, 97)},
+    {"name": "Lead 6 (voice)", "pitch_range": range(36, 97)},
+    {"name": "Lead 7 (fifths)", "pitch_range": range(36, 97)},
+    {"name": "Lead 8 (bass + lead)", "pitch_range": range(21, 109)},
+    # Synth Pad
+    {"name": "Pad 1 (new age)", "pitch_range": range(36, 97)},
+    {"name": "Pad 2 (warm)", "pitch_range": range(36, 97)},
+    {"name": "Pad 3 (polysynth)", "pitch_range": range(36, 97)},
+    {"name": "Pad 4 (choir)", "pitch_range": range(36, 97)},
+    {"name": "Pad 5 (bowed)", "pitch_range": range(36, 97)},
+    {"name": "Pad 6 (metallic)", "pitch_range": range(36, 97)},
+    {"name": "Pad 7 (halo)", "pitch_range": range(36, 97)},
+    {"name": "Pad 8 (sweep)", "pitch_range": range(36, 97)},
+    # Synth SFX
+    {"name": "FX 1 (rain)", "pitch_range": range(36, 97)},
+    {"name": "FX 2 (soundtrack)", "pitch_range": range(36, 97)},
+    {"name": "FX 3 (crystal)", "pitch_range": range(36, 97)},
+    {"name": "FX 4 (atmosphere)", "pitch_range": range(36, 97)},
+    {"name": "FX 5 (brightness)", "pitch_range": range(36, 97)},
+    {"name": "FX 6 (goblins)", "pitch_range": range(36, 97)},
+    {"name": "FX 7 (echoes)", "pitch_range": range(36, 97)},
+    {"name": "FX 8 (sci-fi)", "pitch_range": range(36, 97)},
+    # Ethnic Misc.
+    {"name": "Sitar", "pitch_range": range(48, 78)},
+    {"name": "Banjo", "pitch_range": range(48, 85)},
+    {"name": "Shamisen", "pitch_range": range(50, 80)},
+    {"name": "Koto", "pitch_range": range(55, 85)},
+    {"name": "Kalimba", "pitch_range": range(48, 80)},
+    {"name": "Bag pipe", "pitch_range": range(36, 78)},
+    {"name": "Fiddle", "pitch_range": range(55, 97)},
+    {"name": "Shanai", "pitch_range": range(48, 73)},
+    # Percussive
+    {"name": "Tinkle Bell", "pitch_range": range(72, 85)},
+    {"name": "Agogo", "pitch_range": range(60, 73)},
+    {"name": "Steel Drums", "pitch_range": range(52, 77)},
+    {"name": "Woodblock", "pitch_range": range(128)},
+    {"name": "Taiko Drum", "pitch_range": range(128)},
+    {"name": "Melodic Tom", "pitch_range": range(128)},
+    {"name": "Synth Drum", "pitch_range": range(128)},
+    {"name": "Reverse Cymbal", "pitch_range": range(128)},
+    # SFX
+    {"name": "Guitar Fret Noise, Guitar Cutting Noise", "pitch_range": range(128)},
+    {"name": "Breath Noise, Flute Key Click", "pitch_range": range(128)},
+    {
+        "name": "Seashore, Rain, Thunder, Wind, Stream, Bubbles",
+        "pitch_range": range(128),
+    },
+    {"name": "Bird Tweet, Dog, Horse Gallop", "pitch_range": range(128)},
+    {
+        "name": "Telephone Ring, Door Creaking, Door, Scratch, Wind Chime",
+        "pitch_range": range(128),
+    },
+    {"name": "Helicopter, Car Sounds", "pitch_range": range(128)},
+    {
+        "name": "Applause, Laughing, Screaming, Punch, Heart Beat, Footstep",
+        "pitch_range": range(128),
+    },
+    {"name": "Gunshot, Machine Gun, Lasergun, Explosion", "pitch_range": range(128)},
+]
+
+INSTRUMENTS_CLASSES = [
+    {"name": "Piano", "program_range": range(8)},  # 0
+    {"name": "Chromatic Percussion", "program_range": range(8, 16)},
+    {"name": "Organ", "program_range": range(16, 24)},
+    {"name": "Guitar", "program_range": range(24, 32)},
+    {"name": "Bass", "program_range": range(32, 40)},
+    {"name": "Strings", "program_range": range(40, 48)},  # 5
+    {"name": "Ensemble", "program_range": range(48, 56)},
+    {"name": "Brass", "program_range": range(56, 64)},
+    {"name": "Reed", "program_range": range(64, 72)},
+    {"name": "Pipe", "program_range": range(72, 80)},
+    {"name": "Synth Lead", "program_range": range(80, 88)},  # 10
+    {"name": "Synth Pad", "program_range": range(88, 96)},
+    {"name": "Synth Effects", "program_range": range(96, 104)},
+    {"name": "Ethnic", "program_range": range(104, 112)},
+    {"name": "Percussive", "program_range": range(112, 120)},
+    {"name": "Sound Effects", "program_range": range(120, 128)},  # 15
+    {"name": "Drums", "program_range": range(-1, 0)},
+]
+
+# To easily get the class index of any instrument program
+CLASS_OF_INST = [
+    i
+    for i, inst_class in enumerate(INSTRUMENTS_CLASSES)
+    for _ in inst_class["program_range"]
+]
+
+# index i = program i+1 in the GM2 specs (8. Appendix B)
+# index i = program i retrieved by packages
+DRUMS_SETS = {
+    0: "Standard",
+    8: "Room",
+    16: "Power",
+    24: "Electronic",
+    25: "Analog",
+    32: "Jazz",
+    40: "Brush",
+    48: "Orchestra",
+    56: "SFX",
+}
+
+# Control changes list (without specifications):
+# https://www.midi.org/specifications-old/item/table-3-control-change-messages-data-bytes-2
+# Undefined and general control changes are not considered here
+# All these attributes can take values from 0 to 127, with some of them being on/off
+CONTROL_CHANGES = {
+    # MSB
+    0: "Bank Select",
+    1: "Modulation Depth",
+    2: "Breath Controller",
+    4: "Foot Controller",
+    5: "Portamento Time",
+    6: "Data Entry",
+    7: "Channel Volume",
+    8: "Balance",
+    10: "Pan",
+    11: "Expression Controller",
+    # LSB
+    32: "Bank Select",
+    33: "Modulation Depth",
+    34: "Breath Controller",
+    36: "Foot Controller",
+    37: "Portamento Time",
+    38: "Data Entry",
+    39: "Channel Volume",
+    40: "Balance",
+    42: "Pan",
+    43: "Expression Controller",
+    # On / Off control changes, ≤63 off, ≥64 on
+    64: "Damper Pedal",
+    65: "Portamento",
+    66: "Sostenuto",
+    67: "Soft Pedal",
+    68: "Legato Footswitch",
+    69: "Hold 2",
+    # Continuous controls
+    70: "Sound Variation",
+    71: "Timbre/Harmonic Intensity",
+    72: "Release Time",
+    73: "Attack Time",
+    74: "Brightness",
+    75: "Decay Time",
+    76: "Vibrato Rate",
+    77: "Vibrato Depth",
+    78: "Vibrato Delay",
+    84: "Portamento Control",
+    88: "High Resolution Velocity Prefix",
+    # Effects depths
+    91: "Reverb Depth",
+    92: "Tremolo Depth",
+    93: "Chorus Depth",
+    94: "Celeste Depth",
+    95: "Phaser Depth",
+    # Registered parameters numbers
+    96: "Data Increment",
+    97: "Data Decrement",
+    #  98: 'Non-Registered Parameter Number (NRPN) - LSB',
+    #  99: 'Non-Registered Parameter Number (NRPN) - MSB',
+    100: "Registered Parameter Number (RPN) - LSB",
+    101: "Registered Parameter Number (RPN) - MSB",
+    # Channel mode controls
+    120: "All Sound Off",
+    121: "Reset All Controllers",
+    122: "Local Control On/Off",
+    123: "All Notes Off",
+    124: "Omni Mode Off",  # + all notes off
+    125: "Omni Mode On",  # + all notes off
+    126: "Mono Mode On",  # + poly off, + all notes off
+    127: "Poly Mode On",  # + mono off, +all notes off
+}
+
+###################################################################################
+
+def patches_onset_times(escore_notes, times_idx=1, patches_idx=6):
+    
+    patches = [e[patches_idx] for e in escore_notes]
+
+    patches_oset = ordered_set(patches)
+
+    patches_onset_times = []
+
+    for p in patches_oset:
+        for e in escore_notes:
+            if e[patches_idx] == p:
+                patches_onset_times.append([p, e[times_idx]])
+                break
+
+    return patches_onset_times
+
+###################################################################################
+
+def count_escore_notes_patches(escore_notes, patches_idx=6):
+
+    patches = [e[patches_idx] for e in escore_notes]
+
+    return Counter(patches).most_common()
+
+###################################################################################
+
+def escore_notes_monoponic_melodies(escore_notes,
+                                    bad_notes_ratio=0.0,
+                                    times_idx=1,
+                                    patches_idx=6
+                                    ):
+
+    patches = escore_notes_patches(escore_notes, patches_index=patches_idx)
+
+    monophonic_melodies = []
+
+    for p in patches:
+        patch_score = [e for e in escore_notes if e[patches_idx] == p]
+
+        ps_times = [e[times_idx] for e in patch_score]
+
+        if len(ps_times) <= len(set(ps_times)) * (1+bad_notes_ratio):
+            monophonic_melodies.append([p, len(patch_score)])
+            
+    return monophonic_melodies
+
+###################################################################################
+
+from itertools import groupby
+from operator import itemgetter
+
+def group_by_threshold(data, threshold, groupby_idx):
+
+    data.sort(key=itemgetter(groupby_idx))
+
+    grouped_data = []
+    cluster = []
+
+    for i, item in enumerate(data):
+        if not cluster:
+            cluster.append(item)
+        elif abs(item[groupby_idx] - cluster[-1][groupby_idx]) <= threshold:
+            cluster.append(item)
+        else:
+            grouped_data.append(cluster)
+            cluster = [item]
+    
+    if cluster:
+        grouped_data.append(cluster)
+        
+    return grouped_data
+
+###################################################################################
+
+def split_escore_notes_by_time(escore_notes, time_threshold=256):
+
+    dscore = delta_score_notes(escore_notes, timings_clip_value=time_threshold-1)
+
+    score_chunks = []
+
+    ctime = 0
+    pchunk_idx = 0
+
+    for i, e in enumerate(dscore):
+        
+        ctime += e[1]
+
+        if ctime >= time_threshold:
+            score_chunks.append(escore_notes[pchunk_idx:i])
+            pchunk_idx = i
+            ctime = 0
+
+    return score_chunks
+
+###################################################################################
+
+def escore_notes_grouped_patches(escore_notes, time_threshold=256):
+    
+    split_score_chunks = split_escore_notes_by_time(escore_notes,
+                                                    time_threshold=time_threshold
+                                                    )
+
+    chunks_patches = []
+
+    for s in split_score_chunks:
+        chunks_patches.append(escore_notes_patches(s))
+
+    return chunks_patches
+
+###################################################################################
+
+def computeLPSArray(pattern, M, lps):
+    length = 0
+    i = 1
+    
+    lps[0] = 0
+    
+    while i < M:
+        if pattern[i] == pattern[length]:
+            length += 1
+            lps[i] = length
+            i += 1
+        else:
+            if length != 0:
+                length = lps[length-1]
+            else:
+                lps[i] = 0
+                i += 1
+                
+###################################################################################
+
+def find_pattern_idxs(sub_pattern, pattern):
+
+    lst = pattern
+    pattern = sub_pattern
+    
+    M = len(pattern)
+    N = len(lst)
+    
+    lps = [0] * M
+    j = 0  # index for pattern[]
+
+    computeLPSArray(pattern, M, lps)
+    
+    i = 0  # index for lst[]
+    indexes = []
+    
+    while i < N:
+        if pattern[j] == lst[i]:
+            i += 1
+            j += 1
+        
+        if j == M:
+            end_index = i - 1
+            start_index = end_index - M + 1
+            indexes.append((start_index, end_index))
+            j = lps[j-1]
+        elif i < N and pattern[j] != lst[i]:
+            if j != 0:
+                j = lps[j-1]
+            else:
+                i += 1
+                
+    return indexes
+
+###################################################################################
+
+def escore_notes_patch_lrno_patterns(escore_notes, 
+                                     patch=0, 
+                                     zero_score_timings=False,
+                                     pitches_idx=4,
+                                     patches_idx=6
+                                    ):
+
+    patch_escore = [e for e in escore_notes if e[patches_idx] == patch]
+
+    if patch_escore:
+        
+        patch_cscore = chordify_score([1000, patch_escore])
+    
+        patch_tscore = []
+    
+        for c in patch_cscore:
+    
+            tones_chord = sorted(set([p[pitches_idx] % 12 for p in c]))
+    
+            if tones_chord not in ALL_CHORDS_SORTED:
+                tnoes_chord = check_and_fix_tones_chord(tones_chord)
+    
+            patch_tscore.append(ALL_CHORDS_SORTED.index(tones_chord))
+    
+        pattern = find_lrno_pattern_fast(patch_tscore)
+    
+        patterns_idxs = find_pattern_idxs(pattern, patch_tscore)
+    
+        patch_lrno_scores = []
+    
+        for idxs in patterns_idxs:
+            
+            score = patch_escore[idxs[0]:idxs[1]]
+            
+            if zero_score_timings:
+                score = recalculate_score_timings(score)
+                
+            patch_lrno_scores.append(score)
+    
+        return patch_lrno_scores
+        
+    else:
+        return []
+
+###################################################################################
+
+ALL_BASE_CHORDS_SORTED = [[0], [0, 2], [0, 2, 4], [0, 2, 4, 6], [0, 2, 4, 6, 8], [0, 2, 4, 6, 8, 10],
+                         [0, 2, 4, 6, 9], [0, 2, 4, 6, 10], [0, 2, 4, 7], [0, 2, 4, 7, 9],
+                         [0, 2, 4, 7, 10], [0, 2, 4, 8], [0, 2, 4, 8, 10], [0, 2, 4, 9], [0, 2, 4, 10],
+                         [0, 2, 5], [0, 2, 5, 7], [0, 2, 5, 7, 9], [0, 2, 5, 7, 10], [0, 2, 5, 8],
+                         [0, 2, 5, 8, 10], [0, 2, 5, 9], [0, 2, 5, 10], [0, 2, 6], [0, 2, 6, 8],
+                         [0, 2, 6, 8, 10], [0, 2, 6, 9], [0, 2, 6, 10], [0, 2, 7], [0, 2, 7, 9],
+                         [0, 2, 7, 10], [0, 2, 8], [0, 2, 8, 10], [0, 2, 9], [0, 2, 10], [0, 3],
+                         [0, 3, 5], [0, 3, 5, 7], [0, 3, 5, 7, 9], [0, 3, 5, 7, 10], [0, 3, 5, 8],
+                         [0, 3, 5, 8, 10], [0, 3, 5, 9], [0, 3, 5, 10], [0, 3, 6], [0, 3, 6, 8],
+                         [0, 3, 6, 8, 10], [0, 3, 6, 9], [0, 3, 6, 10], [0, 3, 7], [0, 3, 7, 9],
+                         [0, 3, 7, 10], [0, 3, 8], [0, 3, 8, 10], [0, 3, 9], [0, 3, 10], [0, 4],
+                         [0, 4, 6], [0, 4, 6, 8], [0, 4, 6, 8, 10], [0, 4, 6, 9], [0, 4, 6, 10],
+                         [0, 4, 7], [0, 4, 7, 9], [0, 4, 7, 10], [0, 4, 8], [0, 4, 8, 10], [0, 4, 9],
+                         [0, 4, 10], [0, 5], [0, 5, 7], [0, 5, 7, 9], [0, 5, 7, 10], [0, 5, 8],
+                         [0, 5, 8, 10], [0, 5, 9], [0, 5, 10], [0, 6], [0, 6, 8], [0, 6, 8, 10],
+                         [0, 6, 9], [0, 6, 10], [0, 7], [0, 7, 9], [0, 7, 10], [0, 8], [0, 8, 10],
+                         [0, 9], [0, 10]]
+
+###################################################################################
 #  
 # This is the end of the TMIDI X Python module
 #