Upload TMIDIX.py

TMIDIX.py

@@ -9381,6 +9381,351 @@ def advanced_add_drums_to_escore_notes(escore_notes,
     
     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]
+
+    if len(escore_times) > 0:
+        if len(escore_times) == len(set(escore_times)):
+            comp_type = 'melody only'
+        
+        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 only'
+    
+        else:
+            comp_type = 'mixed'
+    
+    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)]
+
+    #==============================================================================
+
+    pitches = [e[4] for e in escore_notes if e[3] != 9]
+
+    key = SEMITONES[statistics.mode(pitches) % 12]
+
+    #==============================================================================
+
+    cscore = chordify_score([1000, escore_notes])
+
+    tones_chords = Counter()
+
+    for c in cscore:
+        if len([e for e in c if e[3] != 9]) > 1:
+            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]
+
+    #==============================================================================
+
+    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 != 'drums only' or comp_type != 'mixed':
+
+        if drums_present:
+            description += ' with drums'
+    
+        else:
+            description += ' without drums'
+    
+        if key and mood:
+            description += ' in ' + key + ' ' + mood
+
+    description += '.'
+
+    description += '\n'
+
+    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 + '.'
+
+    else:
+        description += 'features ' + NUMERALS[len(instruments)-1] + ' instruments: '
+        description += ', '.join(instruments[:-1]) + ' and ' + instruments[-1] + '.'
+
+    description += '\n'
+
+    if drums_present:
+        description += 'The drum track has predominant '
+        description += ', '.join(most_common_drums[:-1]) + ' and ' + most_common_drums[-1] + '.'
+
+    #==============================================================================
+
+    return description
+
 ###################################################################################
 #  
 # This is the end of the TMIDI X Python module