pysynth/wrappers/mml.py
def read_note(self, no_time=False):

        """
        Reads a note at the current position.

        We also handle the processing of accidentals, and
        the reading of note lengths.

        Once the note is invoked, we calculate the time the note will take,
        and then disable it.
        If we are working with chords and don't want each note to be waited on,
        then you can pass True to the 'no_time' parameter.
        If the no_time parameter is true, then we will keep a record of the notes invoked,
        and will only stop those notes specified.

        :param no_time: Value determining if we should wait calculate note time
        :type no_time: bool
        """

        # Lets get the note value at this position:

        note = self.source.get()

        # Decode the note into value:

        note_num = self.note_map[note]

        # Read for accidentals and apply them:

        note_val = Note(self.octave, note_num + self.read_accidental())

        if no_time:

            # Lets just add the note to the lists:

            self.notes.append(note_val)

            return

        # Let's get the note length:

        length = self.read_length()

        # Calculate the amount of time to keep the note on:

        time_amount = self.find_time_type(length)

        print("Adding note {} with time {}".format(note_val, time_amount))

        # Add the note to the SeqCommand:

        self.command.note(note_val, time_amount, velocity=self.velocity)

        Reads a note at the current position.

        We also handle the processing of accidentals, and
        the reading of note lengths.

        Once the note is invoked, we calculate the time the note will take,
        and then disable it.
        If we are working with chords and don't want each note to be waited on,
        then you can pass True to the 'no_time' parameter.
        If the no_time parameter is true, then we will keep a record of the notes invoked,
        and will only stop those notes specified.

        :param no_time: Value determining if we should wait calculate note time
        :type no_time: bool
        
Reads a note at the current position.
We also handle the processing of accidentals, and
the reading of note lengths.

Once the note is invoked, we calculate the time the note will take,
and then disable it.
If we are working with chords and don't want each note to be waited on,
then you can pass True to the 'no_time' parameter.
If the no_time parameter is true, then we will keep a record of the notes invoked,
and will only stop those notes specified.
Reads a note at the current position . We also handle the processing of accidentals and the reading of note lengths . Once the note is invoked we calculate the time the note will take and then disable it . If we are working with chords and don ' t want each note to be waited on then you can pass True to the ' no_time ' parameter . If the no_time parameter is true then we will keep a record of the notes invoked and will only stop those notes specified .
def read_note(self, no_time=False):
        note = self.source.get()
        note_num = self.note_map[note]
        note_val = Note(self.octave, note_num + self.read_accidental())
        if no_time:
            self.notes.append(note_val)
            return
        length = self.read_length()
        time_amount = self.find_time_type(length)
        print("Adding note {} with time {}".format(note_val, time_amount))
        self.command.note(note_val, time_amount, velocity=self.velocity)
def read_note ( self , no_time = False ) : note = self . source . get ( ) note_num = self . note_map [ note ] note_val = Note ( self . octave , note_num + self . read_accidental ( ) ) if no_time : self . notes . append ( note_val ) return length = self . read_length ( ) time_amount = self . find_time_type ( length ) print ( "Adding note {} with time {}" . format ( note_val , time_amount ) ) self . command . note ( note_val , time_amount , velocity = self . velocity )
Reads a note at the current position.
Reads a note at the current position .
"""
        Reads a note at the current position.

        We also handle the processing of accidentals, and
        the reading of note lengths.

        Once the note is invoked, we calculate the time the note will take,
        and then disable it.
        If we are working with chords and don't want each note to be waited on,
        then you can pass True to the 'no_time' parameter.
        If the no_time parameter is true, then we will keep a record of the notes invoked,
        and will only stop those notes specified.

        :param no_time: Value determining if we should wait calculate note time
        :type no_time: bool
        """ # Lets get the note value at this position: # Decode the note into value: # Read for accidentals and apply them: # Lets just add the note to the lists: # Let's get the note length: # Calculate the amount of time to keep the note on: # Add the note to the SeqCommand:
self
no_time
Value determining if we should wait calculate note time
Value determining if we should wait calculate note time