def test_event_dict_permut(dummy_timeline):
notes = [{
"note": 60,
"duration": 0.5
}, {
"note": 64,
"duration": 0.25
}, {
"note": 67,
"duration": 1.0
}]
dummy_timeline.schedule(iso.PPermut(iso.PSequence(notes, 1)))
dummy_timeline.run()
times = [event[0] for event in dummy_timeline.output_device.events]
notes = [event[2] for event in dummy_timeline.output_device.events]
assert times == [
0.0, 0.5, 0.5, 0.75, 0.75, 1.75, 1.75, 2.25, 2.25, 3.25, 3.25, 3.5,
3.5, 3.75, 3.75, 4.25, 4.25, 5.25, 5.25, 5.5, 5.5, 6.5, 6.5, 7.0, 7.0,
8.0, 8.0, 8.5, 8.5, 8.75, 8.75, 9.75, 9.75, 10.0, 10.0, 10.5
]
assert notes == [
60, 60, 64, 64, 67, 67, 60, 60, 67, 67, 64, 64, 64, 64, 60, 60, 67, 67,
64, 64, 67, 67, 60, 60, 67, 67, 60, 60, 64, 64, 67, 67, 64, 64, 60, 60
]
#------------------------------------------------------------------------
# isobar: ex-subsequence
#------------------------------------------------------------------------
import isobar as iso
import logging
logging.basicConfig(level=logging.DEBUG, format="[%(asctime)s] %(message)s")
scale = iso.Scale.pelog
sequence = iso.PDegree(iso.PBrown(0, 3, -12, 12), scale)
offset = iso.PStutter(iso.pattern.PWhite(0, 4), 2)
sequence = iso.PSubsequence(sequence, offset, 4)
sequence = iso.PPermut(sequence)
sequence = sequence + 64
sequence = iso.PReset(sequence, iso.PImpulse(24))
amp = iso.pattern.PSequence([45, 35, 25, 40]) + iso.PBrown(0, 1, -15, 10)
gate = iso.pattern.PBrown(1.5, 0.01, 0.6, 2.5)
timeline = iso.Timeline(120)
timeline.schedule({
"note": sequence.copy(),
"amplitude": amp.copy(),
"duration": 0.25,
"gate": gate.copy()
})
timeline.schedule({
# [1, 2, 3] -> [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]
#
# Use simple permutations to generate intertwining musical structures.
#------------------------------------------------------------------------
import isobar as iso
import random
import logging
logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")
#------------------------------------------------------------------------
# Create a pitch line comprised of multiple permutations on a pelog scale
#------------------------------------------------------------------------
ppitch = iso.PShuffle([random.randint(-6, 6) for n in range(6)])
ppitch = iso.PPermut(ppitch)
ppitch = iso.PDegree(ppitch, iso.Key("F#", "pelog"))
#------------------------------------------------------------------------
# Create permuted sets of durations and amplitudes.
# Different lengths mean poly-combinations.
#------------------------------------------------------------------------
pdur = iso.PShuffle([1, 1, 2, 2, 4], 1)
pdur = iso.PPermut(pdur) / 4
pamp = iso.PShuffle([10, 15, 20, 35], 2)
pamp = iso.PPermut(pamp)
#------------------------------------------------------------------------
# Schedule on a 60bpm timeline and send to MIDI output
#------------------------------------------------------------------------
def test_ppermut():
a = iso.PPermut(iso.PSequence([1, 11, 111]), 3)
assert list(a) == [
1, 11, 111, 1, 111, 11, 11, 1, 111, 11, 111, 1, 111, 1, 11, 111, 11, 1
]