Black Aura Tech Blog

Simple library to generate midi patterns from numbers. This library can be used to build generative music tools.

Download from http://code.google.com/p/python-music-gen/

Midi examples

http://www.black-aura.com/resources/python-music-gen/arptest.mid

http://www.black-aura.com/resources/python-music-gen/bassline.mid

http://www.black-aura.com/resources/python-music-gen/chords.mid

http://www.black-aura.com/resources/python-music-gen/chords2.mid

MP3 examples (imported MIDI in Ableton Live and added instruments)

http://www.black-aura.com/resources/python-music-gen/arps.mp3

Code Examples

View the examples under /music to start creating your own music!

Documentation

Creating a MIDI file

from midiutil.MidiGenerator import MidiGenerator
midiGenerator = MidiGenerator(tempo=105)
midiGenerator.write()

This code will write an empty midi file. The midi file name will be the python_file_name.mid.

A simple loop

The following code will generate a loop with notes 60,62 and 64 playing in sequence. The length and distance between notes will be 1/2 a beat. The velocities will loop as follows: 100, 90, 100, 90, etc.

from midiutil.MidiGenerator import MidiGenerator
from midiutil.TrackGen import LoopingArray
midiGenerator = MidiGenerator(tempo=105)
# Create a looping array of notes 60, 62 and 64 (C, D, E)
notes = LoopingArray([[60],[62],[64]])
# Create a looping array of beats (note duration, note length)
beats = LoopingArray([(0.5,0.5)])
# Create a looping array of velocities
velocities = LoopingArray([100,90])
midiGenerator.add_track(0, 0, beat=beats, notes=notes, velocities=velocities, length=16)
midiGenerator.write()

A slightly more complex loop

The following loop will play multiple notes with a varying beat.

from midiutil.MidiGenerator import MidiGenerator
from midiutil.TrackGen import LoopingArray
midiGenerator = MidiGenerator(tempo=105)
# Create a looping array of chord C, note C, and notes 64+67
notes = LoopingArray([[60,64,67],[60],[64,67]])
# Create a looping array of beats (note duration, note length)
beats = LoopingArray([(0.5,0.5), (0.25,0.125)])
# Create a looping array of velocities
velocities = LoopingArray([100,90])
midiGenerator.add_track(0, 0, beat=beats, notes=notes, velocities=velocities, length=16)
midiGenerator.write()

Introducing functioniterator

The LoopingArray class can take as a parameter a number of generator classes which modify the way notes are read from the array. For example the following code will read notes from the array by skipping a value.

from midiutil.MidiGenerator import MidiGenerator
from midiutil.TrackGen import LoopingArray, StaticIterator
midiGenerator = MidiGenerator(tempo=105)
notes = LoopingArray([[x] for x in range(60,80)], functioniterator=[('add',StaticIterator(value=2))])
beats = LoopingArray([(0.5,0.5)])
velocities = LoopingArray([100,90])
midiGenerator.add_track(0, 0, beat=beats, notes=notes, velocities=velocities, length=16)
midiGenerator.write()

functioniterator is a list of tuples in the form (function, generator)

function can be: add, dec, mult, div

For example:

notes = LoopingArray(
[[x] for x in range(60,80)],
functioniterator=[
('add',StaticIterator(value=2)),
('dec',StaticIterator(value=1)),
])

Will first add 2 to the index and reduce it by 1. Note that when using StaticIterator, this does not make alot of sense. However when using complex generators such as LoopingArray, then very complex patterns can be achieved.

Complex functioniterator

As already mentioned, one can add a LoopingArray as a functioniterator. In the following example, the note array index is first incremented by 1, then by 2, 1 again, etc…

from midiutil.MidiGenerator import MidiGenerator
from midiutil.TrackGen import LoopingArray, StaticIterator
midiGenerator = MidiGenerator(tempo=105)
notes = LoopingArray([[x] for x in range(60,80)], functioniterator=[('add',LoopingArray([1,2])) ])
beats = LoopingArray([(0.5,0.5)])
velocities = LoopingArray([100,90])
midiGenerator.add_track(0, 0, beat=beats, notes=notes, velocities=velocities, length=16)
midiGenerator.write()

One can build complex patterns such as:

import sys
sys.path.append("../")
from midiutil.TrackGen import LoopingArray
if __name__ == '__main__':
arr = LoopingArray(
[x for x in range(128)],
functioniterator=[
('add', LoopingArray([1, 2, 3], functioniterator=[
('add', LoopingArray([1, 2, 3], functioniterator=[
('add', LoopingArray([1,2,3], id='      array4', debug=True))
],
id='    array3', debug=True)
)
],
id='  array2', debug=True)
)
],
id='array1', debug=True
)
for _ in range(20):
arr.next()

LoopingIndexedArray

A LoopingIndexedArray returns items from an array.

values = [value1, value2, value3, value4, value5]
indexes = [index1, index2, index3, index4, index5]
^
loopindex
returns values[indexes[loopindex]]

on next(), the loopindex is moved. By default the value is incremented by 1, however this can be modified by adding values to the list functioniterator (see below).

Example:

x = LoopingIndexedArray([1,2,3,4,5],[0,1,0,2,0,3])
x.next()
> 1
x.next()
> 2
x.next()
> 1
x.next()
3
x.next()
> 1

LoopingIncrementalIndexedArray

A LoopingIncrementalIndexedArray returns items from an array.

values = [value1, value2, value3, value4, value5]
indexes = [index1, index2, index3, index4, index5]
^
loopindex
noteindex=noteindex+indexes[loopindex]
returns values[noteindex]

on next(), the loopindex is moved. By default the value is incremented by 1, however this can be modified by adding values to the list functioniterator (see below).

Example:

x = LoopingIncrementalIndexedArray([1,2,3,4,5],[0,1,-1,2,0,3])
x.next()
> 1
x.next()
> 1
x.next()
> 2
x.next()
> 1
x.next()
> 3
x.next()
> 3
x.next()
> 1

Note: negative values will move the loopindex to the right

Arpeggiator

So far we have seen adding note loops as tracks. You can also add arpeggios by using the add_arpeggio method.

from midiutil.MidiGenerator import MidiGenerator
from midiutil.Scales import MINOR, buildScale
from midiutil.TrackGen import LoopingIncrementalIndexedArray, LoopingArray
midiGenerator = MidiGenerator(tempo=105)
sc = MINOR
mscale = buildScale(sc, 48, 80)
notes = LoopingArray([
[mscale[x] for x in [0, 2, 4, 6]], # chord 1
[mscale[x] for x in [3, 5, 7, 9]], # chord 2
[mscale[x] for x in [5, 7, 11]] # chord 3
], functioniterator=[('add', LoopingArray([1, 1, 2]))])
chord_beats = LoopingArray([(4, 4), (2, 2)])
notes_beats = LoopingArray([(0.25, 0.25)])
velocities = LoopingArray([120, 120])
note_skip = LoopingArray([0, 1, 2, 3, 1], functioniterator=[('add', LoopingArray([1, 2]))])
midiGenerator.add_arpeggio(0, 0,
chords_beat=chord_beats,
notes_beat=notes_beats,
chords=notes,
velocities=velocities,
note_skip=note_skip,
length=32)
midiGenerator.write()

In this example, the chords inside the LoopingArray notes, are played note by note. The length of the chorded arpeggio is determined by chords_beat. The duration of the notes inside the arpeggio is determined by notes_beat. So in this example, the arpeggio chords are held for 4 beat and then 2 beats. The notes inside the arpeggio are 1/4 in length.

Download from http://code.google.com/p/python-music-gen/