def test_noterest_ind_func_1(self): # Check the indexer_func on note, rest, and chord objects expected = pandas.Series(('A-4', 'Rest', 'F#5')) n1 = note.Note('A-4') n2 = note.Note('D#5') n3 = note.Note('F#5') r1 = note.Rest() c1 = chord.Chord([n3, n2, n1]) temp = pandas.Series((n1, r1, c1)) actual = temp.apply(noterest.noterest_ind_func) self.assertTrue(actual.equals(expected))
def create_note(length, is_rest): """Creates a music21 note based on length and whether it is a rest or not""" if is_rest == True: new_note = note.Rest() else: new_note = note.Note() #new_note.offset = length new_note.duration.quarterLength = length new_note.storedInstrument = instrument.Piano() return new_note
def save_song(song): ''' Takes in the converted sequence and creates a midi stream, saves each note/chord and rest object to the stream then saves as a midi file in the VAE_generated_sequences fdir ''' mt = midi.MidiTrack(0) dtime = midi.DeltaTime(mt) dtime.time = 0.5 new_stream = stream.Stream() for element in song: if ('.' in element) or element.isdigit(): chord_component = element.split('-') if '/' in chord_component[1]: duration_components = chord_component[1].split('/') duration_ = (float(duration_components[0])) / (float( duration_components[1])) else: duration_ = chord_component[1] notes_in_chord = chord_component[0].split('.') notes = [] for current_note in notes_in_chord: new_note = note.Note(int(current_note)) notes.append(new_note) new_chord = chord.Chord(notes) new_chord.quarterLength = float(duration_) new_stream.append(new_chord) elif '.' not in element and (len(element) != 0): note_component = element.split('-') duration_ = None if '/' in note_component[1]: duration_components = note_component[1].split('/') duration_ = (float(duration_components[0])) / (float( duration_components[1])) else: duration_ = note_component[1] new_note = note.Note(int(note_component[0])) new_note.quarterLength = float(duration_) new_stream.append(new_note) elif element is "": new_stream.append(note.Rest()) count = len(os.listdir(params['save_dir'])) + 1 midi_out = new_stream.write('midi', fp=params['save_dir'] + str(count) + '_' + dataset_name + '_' + str(params['input_dim']) + '_' + str(timestamp) + ".mid") print("--------------------------------------------------") print("Generated Sequence Saved") print("--------------------------------------------------")
def generateBassLine(self): ''' Generates the bass line as a :class:`~music21.stream.Score`. >>> from music21.figuredBass import realizer >>> from music21 import key >>> from music21 import meter >>> from music21 import note >>> fbLine = realizer.FiguredBassLine(key.Key('B'), meter.TimeSignature('3/4')) >>> fbLine.addElement(note.Note('B2')) >>> fbLine.addElement(note.Note('C#3'), '6') >>> fbLine.addElement(note.Note('D#3'), '6') >>> #_DOCS_SHOW fbLine.generateBassLine().show() .. image:: images/figuredBass/fbRealizer_bassLine.* :width: 200 >>> from music21 import corpus >>> sBach = corpus.parse('bach/bwv307') >>> sBach['bass'].measure(0).show('text') {0.0} ... {0.0} <music21.clef.BassClef> {0.0} <music21.key.Key of B- major> {0.0} <music21.meter.TimeSignature 4/4> {0.0} <music21.note.Note B-> {0.5} <music21.note.Note C> >>> fbLine = realizer.figuredBassFromStream(sBach['bass']) >>> fbLine.generateBassLine().measure(1).show('text') {0.0} <music21.clef.BassClef> {0.0} <music21.key.KeySignature of 2 flats> {0.0} <music21.meter.TimeSignature 4/4> {3.0} <music21.note.Note B-> {3.5} <music21.note.Note C> ''' bassLine = stream.Part() bassLine.append(clef.BassClef()) bassLine.append(key.KeySignature(self.inKey.sharps)) bassLine.append(copy.deepcopy(self.inTime)) r = None if self._paddingLeft != 0.0: r = note.Rest(quarterLength=self._paddingLeft) bassLine.append(r) for (bassNote, unused_notationString) in self._fbList: bassLine.append(bassNote) bl2 = bassLine.makeNotation(inPlace=False, cautionaryNotImmediateRepeat=False) if r is not None: m0 = bl2.getElementsByClass('Measure')[0] m0.remove(m0.getElementsByClass('Rest')[0]) m0.padAsAnacrusis() return bl2
def standard_note(note_or_rest_string): """ :param note_or_rest_string: string representation of note or rest :return: music21.note.Note object """ if note_or_rest_string == 'rest': return note.Rest() # treat other additional symbols as rests elif note_or_rest_string == END_SYMBOL: return note.Note('D~3', quarterLength=1) elif note_or_rest_string == START_SYMBOL: return note.Note('C~3', quarterLength=1) elif note_or_rest_string == PAD_SYMBOL: return note.Note('E~3', quarterLength=1) elif note_or_rest_string == SLUR_SYMBOL: return note.Rest() elif note_or_rest_string == OUT_OF_RANGE: return note.Rest() else: return note.Note(note_or_rest_string)
def __init__(self): from music21 import stream from music21 import note from music21 import clef from music21 import meter from music21 import chord self.s = stream.Stream() self.s.repeatAppend(note.Note(), 300) self.s.repeatAppend(note.Rest(), 300) self.s.repeatAppend(chord.Chord(), 300) self.s.repeatInsert(meter.TimeSignature(), [0, 50, 100, 150]) self.s.repeatInsert(clef.BassClef(), [0, 50, 100, 150])
def melody_texture(token_seq, duration=0.25, use_last=False): for token in token_seq: if token[0] == REST_WORD: yield note.Rest() elif token[0] in (START_WORD, END_WORD): yield bar.Barline('double') else: if use_last: yield (note.Note(token[-1], quarterLength=duration)) else: for elem in token: yield (note.Note(elem, quarterLength=duration))
def create_midi(prediction_output): """ convert the output from the prediction to notes and create a midi file from the notes """ offset = 0 output_notes = [] # create note and chord objects based on the values generated by the model for pattern in prediction_output: # pattern is a chord if ('.' in pattern) or pattern.isdigit(): notes_in_chord = pattern.split('.') notes = [] for current_note in notes_in_chord: new_note = note.Note(int(current_note)) new_note.storedInstrument = instrument.Piano() notes.append(new_note) new_chord = chord.Chord(notes) new_chord.offset = offset output_notes.append(new_chord) elif pattern == 'Rest': # Pattern is a rest output_notes.append(note.Rest()) # pattern is a note else: new_note = note.Note(pattern) new_note.offset = offset new_note.storedInstrument = instrument.Piano() output_notes.append(new_note) # increase offset each iteration so that notes do not stack offset += 0.5 midi_stream = stream.Stream(output_notes) counter = 0 for note_index in range(1, len(midi_stream.notes)): if midi_stream.pitches[note_index] == midi_stream.pitches[note_index - 1]: counter += 1 else: for between_notes in range(1, counter + 1): randomizer = random.uniform(0, 1) print(randomizer) if randomizer < .85: midi_stream.notes[note_index - between_notes].volume = 0.1 midi_stream.notes[note_index - (counter + 1)].duration.quarterLength = float(1 + counter) counter = 0 midi_stream.write('midi', fp='duration_accounted_output.mid')
def chordsToAnalysis(chordStream, manifest, scale): ''' manifest is a list of tuples in the following form: (measureNumber, chordNumberOrNone, scaleDegree, octaveDisplay, durationTypeDisplay) ''' from music21 import note, bar chordMeasures = chordStream.getElementsByClass('Measure') measureTemplate = copy.deepcopy(chordMeasures) for i, m in enumerate(measureTemplate): m.removeByClass(['GeneralNote']) # assuming we have measure numbers for (measureNumber, chordNumberOrNone, scaleDegree, octaveDisplay, durationTypeDisplay, textDisplay) in manifest: # assume measures are in order; replace with different method m = chordMeasures[measureNumber - 1] mPost = measureTemplate[measureNumber - 1] if chordNumberOrNone is None: c = m.notes[0] else: c = m.notes[chordNumberOrNone - 1] # assume counting from 1 pTarget = scale.pitchFromDegree(scaleDegree) match = False p = None for p in c.pitches: if p.name == pTarget.name: match = True break if not match: print('no scale degree found in specified chord', p, pTarget) pTarget.octave = octaveDisplay n = note.Note(pTarget) if durationTypeDisplay in ['whole']: n.noteheadFill = False else: n.noteheadFill = True n.stemDirection = 'noStem' n.addLyric(textDisplay) mPost.insert(c.getOffsetBySite(m), n) # fill with rests for m in measureTemplate: m.rightBarline = bar.Barline('none') # need to hide rests if len(m.notes) == 0: r = note.Rest(quarterLength=4) r.hideObjectOnPrint = True m.append(r) return measureTemplate
def mix_note_chord(self, chord_list, groove): pick_list = [0, 1, 2] mix_list = [] for g in groove: pick = random.choice(pick_list) if pick == 0: mix_list.append(note.Rest(quarterLength=g)) elif pick == 1: mix_list.append( note.Note(random.choice(chord_list), quarterLength=g)) else: mix_list.append(chord.Chord(chord_list[:-1], quarterLength=g)) return mix_list
def train_network(): """ Train a Neural Network to generate music """ notes = parser() notes.append(str(note.Rest().fullName)) # get amount of pitch names print(set(notes)) n_vocab = len(set(notes)) network_input, network_output = prepare_sequences(notes, n_vocab) model = create_network(network_input, n_vocab) train(model, network_input, network_output)
def decode_to_stream(song_data, filename=None): df = np_to_df(song_data) melody_stream = stream.Stream() for _, row in df.iterrows(): if row.pitch == MELODY_NO_EVENT or row.pitch == MELODY_NOTE_OFF: new_note = note.Rest() else: new_note = note.Note(row.pitch) new_note.quarterLength = row.duration * 0.25 melody_stream.append(new_note) if filename: melody_stream.write('midi', fp=f'./music_data/output/{filename}') return melody_stream
def standard_note(note_or_rest_string): """ Convert str representing a music21 object to this object :param note_or_rest_string: :return: """ if note_or_rest_string == 'rest': return note.Rest() # treat other additional symbols as rests elif (note_or_rest_string == END_SYMBOL or note_or_rest_string == START_SYMBOL or note_or_rest_string == PAD_SYMBOL): # print('Warning: Special symbol is used in standard_note') return note.Rest() elif note_or_rest_string == SLUR_SYMBOL: # print('Warning: SLUR_SYMBOL used in standard_note') return note.Rest() elif note_or_rest_string == OUT_OF_RANGE: # print('Warning: OUT_OF_RANGE used in standard_note') return note.Rest() else: return note.Note(note_or_rest_string)
def standard_note(string): ''' Converts str (name) representing a music21 object to the corresponding object :param string : str (name) representing a music21 object :return : corresponding music21 object ''' if string == "rest": return note.Rest() ### Treat additional symbols as RESTS ### if (string == START_SYMBOL) or (string == END_SYMBOL) or (string == PAD_SYMBOL): return note.Rest() if string == SLUR_SYMBOL: return note.Rest() if string == OUT_OF_RANGE: return note.Rest() else: return note.Note(string)
def mergeLeadSheetAndBassLine(leadsheet, bassLine): ''' method to combine the lead sheet (i.e. from the ex-wikifonia) with just the melody line and chord symbols with the newly realized bassLine (i.e. from fbRealizer) which consists of two parts, the treble line and bass line. ''' s = stream.Score() s.insert(metadata.Metadata()) s.metadata.title = leadsheet.metadata.title cs = leadsheet.flat.getElementsByClass(harmony.ChordSymbol) if cs[0].offset > 0: bassLine.parts[0].insertAndShift(0, note.Rest(quarterLength=cs[0].offset)) bassLine.parts[1].insertAndShift(0, note.Rest(quarterLength=cs[0].offset)) voicePart = leadsheet.parts[0] pianoTreble = bassLine.parts[0] pianoBass = bassLine.parts[1] s.insert(0, voicePart) s.insert(0, pianoTreble) s.insert(0, pianoBass) return s
def make_base(self, base): base_melody = stream.Stream() for itr_note in base: name = itr_note[0] duration = itr_note[1] if name == 'r': temp_note = note.Rest(type='quarter') else: temp_note = note.Note(name, quarterLength=duration) base_melody.append(temp_note) return base_melody
def create_part(prediction_output, instrumentType): offset = 0 output_notes = [] for pattern in prediction_output: # pattern is invalid (start or end symbol) if pattern == 1 or pattern == 2: continue # pattern is a rest if pattern == 0: new_note = note.Rest() else: new_note = note.Note(get_note(pattern)) # assign instrument if instrumentType == 'piano': new_note.storedInstrument = instrument.Piano() elif instrumentType == 'bass': new_note.storedInstrument = instrument.Bass() else: new_note.storedInstrument = instrument.Saxophone() # assign duration new_note.duration.quarterLength = 0.25 # assign and update offset new_note.offset = offset offset += .25 # add note to part output_notes.append(new_note) # merge consecutive notes output = [output_notes[0]] for i in range(1, len(output_notes)): if isinstance(output_notes[i], note.Rest): output.append(output_notes[i]) else: current_note = output_notes[i].nameWithOctave if not isinstance( output[-1], note.Rest) and current_note == output[-1].nameWithOctave: output[-1].duration.quarterLength += .25 else: output.append(output_notes[i]) return stream.Part(output)
def undo_full_chords_no_duration(self, chords): part = stream.Part() for c in chords: if c != 'r': pitches = c.split(' ') if pitches[0] == 'r': newChord = note.Rest() else: newChord = chord.Chord([int(p) for p in pitches[:-1]]) part.append(newChord) return part
def tabToM21(self): ''' Creates and returns a music21.roman.RomanNumeral() object from a TabChord with all shared attributes. NB: call changeRepresentation() first if .representationType is not 'm21' but you plan to process it with m21 (e.g. moving it into a stream). >>> tabCd = romanText.tsvConverter.TabChord() >>> tabCd.numeral = 'vii' >>> tabCd.global_key = 'F' >>> tabCd.local_key = 'V' >>> tabCd.representationType = 'm21' >>> m21Ch = tabCd.tabToM21() Now we can check it's a music21 RomanNumeral(): >>> m21Ch.figure 'vii' ''' if self.numeral: if self.form: if self.figbass: combined = ''.join([self.numeral, self.form, self.figbass]) else: combined = ''.join([self.numeral, self.form]) else: combined = self.numeral if self.relativeroot: # special case requiring '/'. combined = ''.join([combined, '/', self.relativeroot]) localKeyNonRoman = getLocalKey(self.local_key, self.global_key) thisEntry = roman.RomanNumeral(combined, localKeyNonRoman) thisEntry.quarterLength = self.length thisEntry.op = self.op thisEntry.no = self.no thisEntry.mov = self.mov thisEntry.pedal = self.pedal thisEntry.phraseend = None else: # handling case of '@none' thisEntry = note.Rest() thisEntry.quarterLength = self.length return thisEntry
def seqs_to_stream(seqs): """ :param seqs: list of sequences a sequence is a list (one for each voice) of list of (pitch, articulation) add rests between sequences :return: """ score = stream.Score() for voice_index in range(len(seqs[0])): part = stream.Part(id='part' + str(voice_index)) for s_index, seq in enumerate(seqs): # print(voice_index, s_index) voice = seq[voice_index] dur = 0 f = note.Rest() for k, n in enumerate(voice): if n[1] == 1: # add previous note if not f.name == 'rest': f.duration = duration.Duration(dur / SUBDIVISION) part.append(f) dur = 1 f = note.Note() f.pitch.midi = n[0] else: dur += 1 # add last note f.duration = duration.Duration(dur / SUBDIVISION) part.append(f) # add rests (8 beats) f = note.Rest() f.duration = duration.Duration(SUBDIVISION * 8) part.append(f) score.insert(part) return score
def _convert_to_midi_file(self, notes): """Convert encoded input notes array into a midi file""" offset = 0 output_notes = [] # create note and chord objects based on the values generated by the model for pattern in notes: # pattern is a chord if (',' in pattern) or pattern.isdigit(): pitch = pattern.split(":")[0] duration = pattern.split(":")[1] notes_in_chord = pitch.split(',') chord_notes = [] for current_note in notes_in_chord: new_note = note.Note(int(current_note)) new_note.storedInstrument = instrument.AltoSaxophone() chord_notes.append(new_note) new_chord = chord.Chord(chord_notes) new_chord.offset = offset output_notes.append(new_chord) # pattern is a note elif "rest" in pattern: duration = pattern.split(":")[1] new_note = note.Rest() new_note.offset = offset output_notes.append(new_note) else: pitch = pattern.split(":")[0] duration = pattern.split(":")[1] try: new_note = note.Note(pitch) except: continue new_note.offset = offset new_note.storedInstrument = instrument.AltoSaxophone() output_notes.append(new_note) # increase offset each iteration so that notes do not stack if '/' in duration: duration = float(int(duration.split('/')[0]) / int(duration.split('/')[1])) offset += float(duration) midi_stream = stream.Stream(output_notes) output_fp = os.path.join(SCRATCH_DIR, f"{uuid1().hex}_{self.composer.get_name()}.midi") midi_stream.write('midi', fp=output_fp) return output_fp
def predict_and_create_midi(model, X, unique_info, unique_size): int_to_note = dict((number, note) for number, note in enumerate(unique_info)) Y_pred = [] random = np.random.randint(0, len(X) - 1) seq = X[random] #sequence of music information for number in range(300): X_pred = np.reshape(seq, (1, len(seq), 1)) X_pred = X_pred / float(unique_size) pred = model.predict(X_pred, verbose=0) best = np.argmax(pred) #taking the muisic info with the highest probability best_info = int_to_note[best] # un-encoding Y_pred.append(best_info) seq.append(best) seq = seq[1:len(seq)] #create the next sequence song = [] offset= 0.5 # create note and chord objects based on the values generated by the model for info in predictions: # info=chord if ('.' in info) or info.isdigit(): chord_notes = info.split('.') notes = [] for current in chord_notes: new_note = note.Note(int(current)) new_note.offset = offset new_note.storedInstrument = instrument.SnareDrum() notes.append(new_note) new_chord = chord.Chord(notes) song.append(new_chord) # info = Rest elif ('Re' in info): new_rest= note.Rest() new_rest.offset = offset new_rest.quarterLength = float(info[1:]) new_rest.storedInstrument = instrument.SnareDrum() song.append(new_rest) # info = note else: new_note = note.Note(info) new_note.offset = offset new_note.storedInstrument = instrument.SnareDrum() song.append(new_note) offset += 0.5 midi = stream.Stream(song) midi.write('midi', fp='C:/Users/PycharmProjects/AI-music/generate-music/generated_song.mid')
def translate(int_note, dur): """ Given an integer value of a note, gets a corresponding music21.note object :param int_note: integer value of the note :param dur: duration of desired note :return music21.note """ first_char_arr = [ "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" ] pitch = first_char_arr[int_note % 12] + str(int(2 + int_note / 12)) if dur < 0: return note.Rest(duration=duration.Duration(quarterLength=-dur)) return note.Note(pitch, duration=duration.Duration(quarterLength=dur))
def _left_hand_interlude(): lh_interlude = stream.Voice() lh_interlude.append(meter.TimeSignature("6/4")) for _ in range(2): lh_interlude.append(note.Rest(duration=duration.Duration(2.75))) note_1 = note.Note("E1", duration=duration.Duration(0.25)) note_2 = note.Note("A0", duration=duration.Duration(3)) ottava = spanner.Ottava() ottava.type = (8, "down") ottava.addSpannedElements([note_1, note_2]) lh_interlude.append(ottava) lh_interlude.append(note_1) lh_interlude.append(note_2) lh_interlude.makeMeasures(inPlace=True, finalBarline=None) return lh_interlude
def convert_measure_to_music21_measure(m: Measure): m.notes: [Note] measure = stream.Measure(1) for j in m.notes: if j.pitch == 'REST': n_1 = note.Rest() n_1.duration = duration.Duration( quarterLength=j.duration.duration_value / 0.25) else: n_1 = note.Note(j.pitch) n_1.duration = duration.Duration( quarterLength=j.duration.duration_value / 0.25) measure.append(n_1) return measure
def testOutOfBoundsExpressionDoesNotCreateForward(self): ''' A metronome mark at an offset exceeding the bar duration was causing <forward> tags, i.e. hidden rests. Prefer <offset> instead. ''' m = stream.Measure() m.append(meter.TimeSignature('1/4')) m.append(note.Rest()) m.insert(2, tempo.MetronomeMark('slow', 40)) gex = GeneralObjectExporter() tree = self.getET(gex.fromGeneralObject(m)) self.assertFalse(tree.findall('.//forward')) self.assertEqual(int(tree.findall('.//direction/offset')[0].text), defaults.divisionsPerQuarter)
def convert_to_midi(sequence, bpm=60, output_file='./midi_output/music.mid'): """Save sequence as a midi file (with path = output_file). sequence can be from the original dataset or a new sequence generated by a trained model""" offset = 0 # the distance in quarter-notes of the note/chord/rest # being written from the beginning output_notes = [instrument.Piano(), tempo.MetronomeMark(number=bpm)] bps = bpm / 60 # beats per second converted_duration = duration.Duration() # create note, chord, and rest objects for vector in sequence: # convert from seconds to beats converted_duration.quarterLength = vector[-1] * bps if (np.sum(vector[:-1]) > 1): # chord indices_in_chord = np.argsort(vector[:-1])[-int(np.sum(\ vector[:-1])):] notes_in_chord = [piano_idx_to_note(i) for i in indices_in_chord] notes = [] for cur_note in notes_in_chord: new_note = note.Note(cur_note) new_note.storedInstrument = instrument.Piano() notes.append(new_note) new_chord = chord.Chord(notes) new_chord.offset = offset new_chord.duration = converted_duration output_notes.append(new_chord) elif (np.sum(vector[:-1]) == 1): # note index = np.argmax(vector[:-1]) new_note = piano_idx_to_note(index) new_note = note.Note(new_note) new_note.offset = offset new_note.storedInstrument = instrument.Piano() new_note.duration = converted_duration output_notes.append(new_note) elif (np.sum(vector[:-1]) == 0): # rest new_rest = note.Rest() new_rest.offset = offset new_rest.duration = converted_duration output_notes.append(new_rest) offset += vector[-1] midi_stream = stream.Stream(output_notes) midi_stream.write('midi', fp=output_file)
def testExportChordSymbolsWithRealizedDurations(self): gex = GeneralObjectExporter() def realizeDurationsAndAssertTags(mm: stream.Measure, forwardTag=False, offsetTag=False): mm = copy.deepcopy(mm) harmony.realizeChordSymbolDurations(mm) obj = gex.fromGeneralObject(mm) tree = self.getET(obj) self.assertIs(bool(tree.findall('.//forward')), forwardTag) self.assertIs(bool(tree.findall('.//offset')), offsetTag) # Two consecutive chord symbols, no rests cs1 = harmony.ChordSymbol('C7') cs2 = harmony.ChordSymbol('F7') m = stream.Measure() m.insert(0, cs1) m.insert(2, cs2) realizeDurationsAndAssertTags(m, forwardTag=True, offsetTag=False) # Two consecutive chord symbols, rest coinciding with first one r1 = note.Rest(type='half') m.insert(0, r1) realizeDurationsAndAssertTags(m, forwardTag=False, offsetTag=False) # One chord symbol midmeasure, no rests m.remove(cs1) m.remove(r1) realizeDurationsAndAssertTags(m, forwardTag=True, offsetTag=False) # One chord symbol midmeasure coinciding with whole note n1 = note.Note(type='whole') m.insert(0, n1) # Need an offset tag to show the -2.0 offset to get from end to midmeasure realizeDurationsAndAssertTags(m, forwardTag=False, offsetTag=True) # One chord symbol at beginning of measure coinciding with whole note m.remove(cs2) m.insert(0, cs1) realizeDurationsAndAssertTags(m, forwardTag=False, offsetTag=False) # One chord symbol at beginning of measure with writeAsChord=True # followed by a half note cs1.writeAsChord = True n1.offset = 2 n1.quarterLength = 2 realizeDurationsAndAssertTags(m, forwardTag=False, offsetTag=False)
def restFromRest(self, restElement): ''' Returns a :class:`~music21.rest.Rest` object from a <rest> tag. >>> ci = capella.fromCapellaXML.CapellaImporter() >>> restElement = ci.domElementFromText('<rest><duration base="1/2"/></rest>') >>> r = ci.restFromRest(restElement) >>> r <music21.note.Rest rest> >>> r.duration.type 'half' ''' r = note.Rest() durationList = restElement.findall('duration') r.duration = self.durationFromDuration(durationList[0]) return r
def runStreamIterationByElements(self): '''Stream iteration by .elements access ''' from music21 import note, stream # create a stream with 750 notes, 250 rests s = stream.Stream() for i in range(1000): n = note.Note() s.append(n) for i in range(500): r = note.Rest() s.append(r) for i in range(100): for j in s.elements: # this will create an iterator instances pass