[FEATURE REQ] MIDI to musicpy notation parser

[asigalov61]

Hey @Rainbow-Dreamer !!!

Its been a while since we have talked so I figured I would pop in and say hi! :)

First of all, I wanted to thank you for all the work you did on musicpy. Its very nice now and very mature/feature-rich :)

The reason I am writing is that I wanted to ask you if you can make a MIDI to musicpy notation parser/converter?

I think it would be a nice feature/option and it can be very useful for ML/DL applications of musicpy.

For example, I want to be able to take a Iron Maiden MIDI and get the result similar to your example:

a12 = translate('D, G, D, a:1/8;., E[l:1/4; i:.]')

a1 = a11 * 2 + a12

a20 = translate('D2, G2, D2, a:1/8;.')

a21 = translate('E2[l:.4; i:.] | E2[l:.16; i:.; r:2], E2[l:.8; i:.], n:1, u:1, r:4, E2[l:.16; i:.; r:2], D2[l:.8; i:.; r:3]')

a22 = translate('C2[l:.4; i:.] | C2[l:.16; i:.; r:2], C2[l:.8; i:.], n:1, u:1, r:4, C2[l:.16; i:.; r:2], D2[l:.8; i:.; r:3]')

a23 = translate('D2, G2, D2, a:1/8;., E2[l:.4; i:.]')

a2 = a20 + a21 * 2 + a22 + a21[:-3] + a23

a3 = drum('C;S;K[l:1/4; i:.], H, S, H, K, H, S, H, K, H, S, H, S[r:3], r:4, C;S;K[l:1/4; i:.]').notes

a41 = translate('F#, G, F#, a:1/8;., G[l:1/4; i:.], B4[l:1/8; i:.] | A, B, A, B, a:1/16;., n:1, D5[l:1/8; i:.], B4[l:1/8; i:.], u:1, B[l:1/8;i:.], G[l:1/8; i:.], G[l:1/4; i:.]') * 2

a42 = translate('F#, G, F#, a:1/8;., G[l:1/4; i:.]')

a4 = a41 * 2 + a42

a4.set_volume(80)

result = P([a1, a2, a3, a4], [31, 34, 1, 31], channels=[0, 1, 9, 2], bpm=165, start_times=[0, 0, 3/8, 0])

play(result)

Another thing I wanted to say is that I really liked algorithms.write_pop(scale('C', 'minor')) option. I think you should really develop it and make it work well.

Anyway, please let me know.

Sincerely,

Alex

[neldivad]

Idk what parser you're looking for, but I did end up building my own when I'm working with midi.

Not the best solution, but mp.read() gives you a piece object. If you isolate the tracks you get a chord object. Assuming your midi only has one track and channel:

If you are talking about XML, I don't have it because my current use does not require music notation representation, but XML is very close to the dict implementation I had so you can borrow some ideas.

def read_midi_path(midi_path):
    """ 
    read path and return chord obj
    """
    midi = mp.read(midi_path)
    return midi.tracks[0]

Suppose you want to deconstruct the chord object to different formats that allow easier manipulation of notes, etc:

class ChordParser:

    def __init__(self, chord):
        self.chord = chord.standard_notation()
        self.pitch = None # set global pitch for all notes
        self.verbose = 0

        self.deconstructed_melody = None
        self.deconstructed_bass = None
        self.deconstructed_rhythm_chords = None


    #-----------
    # data structure methods
    #-----------

    
    def is_drum(self):
        """Check if the chord is from a drum channel (channel 10)."""
        if len(self.chord.notes) > 0:
            return self.chord.notes[0].channel == 9
        return False
    

    def set_channel(self, channel:int):
        """Set the channel of the chord."""
        for note in self.chord.notes:
            note.channel = channel

    
    def split_melody(self): 
        """ 
        Wrapper for mp.alg.split_melody()
        """
        return mp.alg.split_melody(self.chord)


    def split_chord(self): 
        """ 
        Wrapper for mp.alg.split_chord()
        """
        return mp.alg.split_chord(self.chord)
    

    def to_piece(self, leading_rests=False):
        """
        Converts the chord object to a piece object.

        Example:
            c = mp.chord('C4, E4, G4, B4')
            ChordParser(c).to_piece()

        Returns:
            piece(notes=[C4, E4, G4, B4], start_time=0)
        """
        total_bars = self.chord.bars()
        remainder = total_bars % 1 

        if leading_rests == True:
            if remainder == 0:
                print('No leading rests needed. Total bars is a whole number.')
            else:
                piece = mp.piece(tracks=[self.chord], start_times=[remainder])
        else:
            piece = mp.piece(tracks=[self.chord])
        return piece
    

    def to_dict(self, note_as_string=False):
        """
        Converts the chord object to a list of dictionaries with notes and intervals.

        Example:
        c = mp.chord('C4, E4, G4, B4') % (1/8, 1/8)
        ChordParser(c).to_dict()

        Returns:
            [{'notes': ['C4'], 'interval': 0.125},
             {'notes': ['E4'], 'interval': 0.125},
             {'notes': ['G4'], 'interval': 0.125},
             {'notes': ['B4'], 'interval': 0.125}]
        """
        chord_data = []
        current_notes = []
        for note, interval in zip(self.chord.notes, self.chord.interval):
            note_str = f"{note.name}{note.num}"
            # current_notes.append(note_str)
            
            note_degree = note.degree
            current_notes.append((note_str, note_degree))  # eg: ('C4', 60)
            
            if interval > 0:
                # Sort current_notes by degree before appending
                sorted_notes = sorted(current_notes, key=lambda x: x[1])   
                chord_data.append({
                    'notes': [note_str for note_str, _ in sorted_notes] if not note_as_string else ','.join(note_str for note_str, _ in sorted_notes),
                    'interval': interval
                })
                current_notes = []  # Reset current notes

        return chord_data
    

    def to_md(self):
        """
        Converts the chord object to a markdown string.

        Example:
            c = chord(notes=[C#3, C2, C2, D2, A#2, A#2, C2, C2, D2, A#2], interval=[0, 1/4, 1/8, 0, 1/4, 0, 1/8, 1/8, 0, 1/8], start_time=0)
            md = ChordParser(c).to_md()

            print(md)
            >>
            C#3,C2[1/4]
            C2[1/8]
            D2,A#2[1/4]
            A#2,C2[1/8]
            C2[1/8]
            D2,A#2[1/8]
        """
        chord_dict = self.to_dict(note_as_string=True)
        md_lines = [
            f"{item['notes']}[{self._format_interval(item['interval'])}]"
            for item in chord_dict
        ]
        return '\n'.join(md_lines)
    

    def _format_interval(self, interval, quantize_limit=64):
        """
        Converts a float interval to a simplified fraction string.
        """
        from fractions import Fraction

        denominators = {1, 2, 3, 4, 6, 8, 16, 32, 64}
        fraction = Fraction(interval).limit_denominator(quantize_limit)

         # If float very small, return 0
        if fraction.numerator == 0:
            return '0'
        return f"{fraction.numerator}/{fraction.denominator}"
    

Reconstruct chord obj with alternative data structures

def dict_to_chord(dict_list):
    """
    Converts a list of dictionaries representing chords into a single chord object.

    dict_list: list of dict
        List of dictionaries where each dictionary has 'notes' and 'interval' keys.

    Example:
        Input: [{'notes': ['B1'], 'interval': 0.0625},
                {'notes': ['G#2'], 'interval': 0.0625},
                {'notes': ['F#2'], 'interval': 0.0625},
                {'notes': ['G#2'], 'interval': 0.0625},
                {'notes': ['D2', 'E2', 'A#2'], 'interval': 0.125},
        
        Output: mp.chord('B1[1/16]') + mp.chord('G#2[1/16]') + mp.chord('F#2[1/16]') + ...
    """
    chd = mp.chord('')
    for chord_dict in dict_list:
        notes = ','.join(chord_dict['notes'])
        interval = chord_dict['interval']
        chord_str = f"{notes}[{interval}]"
        try:
            chord = mp.chord(chord_str, duration=interval)
            chd += chord

        except Exception as e:
            print(f"Error parsing chord: {chord_str}")
            print(e)

    return chd




def markdown_to_chord(markdown_str):
    """
    markdown_str: str
        String of chords in markdown format. Each chord should be on a new line.
        NO LONGER SUPPORTS PERIODS. USE SLASH. eg: [1/16] instead of [.16]

    Example:
        "A4[1/16]\nB4[1/16]\nA3,E4,G4,C5[3/16]" 
        
        >> mp.chord('A4[1/16]') + mp.chord('B4[1/16]') + mp.chord('A3,E4,G4,C5[3/16]')
    """
    chd = mp.chord('')
    lines = markdown_str.strip().split('\n')

    for line in lines:
        try:
            if '[' in line and ']' in line:
                notes_part, interval_part = line.split('[')
                interval = float(eval(interval_part.rstrip(']')))
                chord = mp.chord(notes_part, duration=interval) # set duration else the total bars will not reconcile
                chd += chord

            else:
                chord = mp.chord(line)
                chd += chord

        except Exception as e:
            print(f"Error parsing chord: {line}")
            print(e)

    return chd

[asigalov61]

@neldivad Thank you. This is very helpful :)

I wonder if @Rainbow-Dreamer can implement something like that?

Basically, I want to see MIDI to musicpy notation parser (as in that Iron Maiden example) because I think it would be great as a template maker for musicpy and also for composing new songs with it.

But thank you for sharing your code. I will see if I can adapt it to musicpy notation format.

[Rainbow-Dreamer]

Thanks for the suggestion, I will take a look into this when I have more free time from my full-time job, it is welcome to keep the discussions for this feature's implementation :)