def test_transponse_reversable(self):
"""
Ensure that transpose is reversable
"""
from sebastian.core.transforms import transpose
s1 = self.make_sequence()
transposed = s1 | transpose(5) | transpose(-5)
self.assertEqual(s1, transposed)
def test_transponse_reversable(self):
"""
Ensure that transpose is reversable
"""
from sebastian.core.transforms import transpose
s1 = self.make_sequence()
transposed = s1 | transpose(5) | transpose(-5)
self.assertEqual(s1, transposed)
def next(self):
keys = EvenKeyboard().notes
self.keys = list(keys)
keycount = len(self.keys)
right = HSeq(self.keys.__getslice__(keycount-(keycount/2), keycount-(keycount/4)))
whole = 64
seed_pitch = random.randint(1,12)
seed_unit = random.choice([1,2,4,8,16])
seed_duration = whole/seed_unit
measure_length = 4*whole
phrase_lengths = range(50,90)
phrase_length = Randomized(phrase_lengths)
reaches = range(-1,1)
reach = Wandering(reaches)
finger1 = Finger(
length = 16,
note = Wandering(right),
duration = Randomized([2,4,4,4,4,4,4,4,4,4,5,6,9,8,8,8,8,16,32,32,32]),
velocity = Randomized(range(20,127)),
rest = Randomized([2,4,8,16,32,32,32,32,32,32,32,32])
)
finger2 = Finger(
length = 160,
note = Wandering(keys),
duration = Randomized(range(2,80)),
velocity = Wandering(range(50,90)),
rest = Randomized([1,2,3,4,5])
)
finger3 = Finger(
length = 16,
note = Wandering(keys),
duration = Randomized([2,4,8,16,32]),
velocity = Randomized(range(20,127)),
rest = Oscilating([2,4,8,16,32])
)
beat = metrenome(seed_unit,seed_pitch,5,seed_duration)
measure_length = beat.next_offset()
phrase_length_new = phrase_length.next()
phrase1 = finger1.next(phrase_length_new)
phrase1_b = mutate(phrase1,1,2,1,0,0)
phrase2 = finger2.next(phrase_length_new*2)
phrase2_b = mutate(phrase2,1,2,1,0,0)
phrase3 = finger1.next(phrase_length_new*3)
phrase1_3 = mutate(phrase3,1,2,1,0,0)
#metrenome
left_seq = (phrase1*3)+phrase1_b+(phrase3*3)+phrase1_b
right_seq = (phrase2*3)+phrase2_b+(phrase2*3)+phrase2_b
left_composition = (left_seq*2)+((left_seq*2) | transpose(reach.next()) )+(left_seq*2)
self.output = left_composition#//(right_seq | delay(phrase1.next_offset()*2))
self.hand = [finger1,finger2]
self.last = self.output | transforms.stretch(.25)
try:
player.play([self.last | midi_pitch()])
except Exception as e:
print e
def fade_mutate(incoming, count, mutation_matrix=[0,2,30,0,0]):
output = OSequence()
last = incoming
for r in xrange(16):
current = last | mutate(mutation_matrix[0], mutation_matrix[1], mutation_matrix[2], mutation_matrix[3], mutation_matrix[4])
output += (tock//incoming // current) | transpose(transpositions.next())
last = current
return output
def performance():
tracks = []
for track_num in range(8): # 8 tracks
seq = OSequence([])
for pattern in patterns:
seq += parse(pattern) * random.randint(2, 5) # repeat 2-5 times
tracks.append(seq | transpose(random.choice([-12, 0, 12]))) # transpose -1, 0 or 1 octaves
f = open("in_c_performance.mid", "w")
s = SMF(tracks)
s.write(f)
f.close()
def test_transpose(self):
"""
Ensure transpose modifies the midi pitch
"""
from sebastian.core.transforms import transpose
s1 = self.make_sequence()
transposed = s1 | transpose(12)
from sebastian.core import OFFSET_64, DURATION_64, MIDI_PITCH
self.assertEqual(transposed._elements, [
{MIDI_PITCH: 62, OFFSET_64: 16, DURATION_64: 17},
{MIDI_PITCH: 65, OFFSET_64: 19, DURATION_64: 20}
])
def next(self):
keys = MinorBluesKeyboard().notes
self.keys = list(keys)
keycount = len(self.keys)
stretch_length = ()
finger1 = Finger(
length = 300,
note = Wandering(HSeq(self.keys.__getslice__(20,40))),
duration = Wandering([8]),
velocity = Wandering(range(50,51)),
rest = Randomized([8])
)
finger2 = Finger(
length = 300,
note = Oscilating(HSeq(self.keys.__getslice__(10,20))),
duration = Oscilating([32]),
velocity = Oscilating(range(50,51)),
rest = Randomized([0])
)
alpha = finger1.next(60)
beta = finger2.next(60)
gamma = finger1.next(70)
self.hand = [finger1]
sequence_1 = (alpha//beta) | transforms.stretch(.5)
#sequence_2 = sequence_1 | transforms.stretch(.5)
sequence_2 = sequence_1 | transpose(11)
sequence_3 = sequence_1 | transpose(1)
self.last = sequence_1+sequence_2+sequence_3+sequence_1
try:
player.play([self.last | midi_pitch()])
except Exception as e:
print e
def next(self):
keys = MajorKeyboard().notes
self.keys = list(keys)
keycount = len(self.keys)
stretch_length = ()
finger1 = Finger(
length = 300,
note = Wandering(HSeq(self.keys.__getslice__(20,80))),
duration = Wandering([8,4]),
velocity = Wandering(range(50,51)),
rest = Randomized([8])
)
finger2 = Finger(
length = 300,
note = Oscilating(HSeq(self.keys.__getslice__(10,20))),
duration = Oscilating([32]),
velocity = Oscilating(range(50,51)),
rest = Randomized([0])
)
finger3 = Finger(
length = 300,
note = Wandering(self.keys),
duration = Wandering([2,4,6,8,16]),
velocity = Wandering(range(50,80)),
rest = Wandering([2,4,6,8,16])
)
g = 50
self.hand = [finger1]
sequence_1 = (finger1.next(g)//finger2.next(g))
sequence_1_a = sequence_1 | transpose(11)
sequence_1_b = sequence_1 | transpose(1)
sequence_2 = (finger2.next(g)//finger2.next(g))
sequence_2_a = sequence_1 | transpose(11)
sequence_2_b = sequence_1 | transpose(1)
sequence_3 = (finger1.next(g)//finger1.next(g))
sequence_3_a = sequence_1 | transpose(11)
sequence_3_b = sequence_1 | transpose(1)
solo = finger3.next(g*6)
self.last = sequence_1+sequence_1_a+((sequence_2_b+sequence_2+sequence_1+sequence_3_a+sequence_3_b+sequence_1_a))+sequence_2
try:
player.play([sequence_1 | midi_pitch()])
except Exception as e:
print e
def test_transpose(self):
"""
Ensure transpose modifies the pitch
"""
from sebastian.core.transforms import transpose
s1 = self.make_sequence()
transposed = s1 | transpose(12)
from sebastian.core import OFFSET_64, DURATION_64
self.assertEqual(transposed._elements, [{
"pitch": 62,
OFFSET_64: 16,
DURATION_64: 17
}, {
"pitch": 65,
OFFSET_64: 19,
DURATION_64: 20
}])
from sebastian.lilypond.interp import parse
from sebastian.lilypond.write_lilypond import write
from sebastian.midi import write_midi, player
from sebastian.core import OSequence, HSeq, Point, DURATION_64
from sebastian.core.transforms import transpose, reverse, add, degree_in_key, midi_pitch, lilypond
from sebastian.core.notes import Key, major_scale
# construct sequences using lilypond syntax
seq1 = parse("c d e")
seq2 = parse("e f g")
# concatenate
seq3 = seq1 + seq2
# transpose and reverse
seq4 = seq3 | transpose(12) | reverse()
# merge
seq5 = seq3 // seq4
# play MIDI
player.play([seq5])
# write to MIDI
write_midi.write("seq5.mid", [seq5])
# contruct a horizontal sequence of scale degrees
seq6 = HSeq(Point(degree=degree) for degree in [1, 2, 3, 2, 1])
# put that sequence into C major, octave 4 quavers
C_MAJOR = Key("C", major_scale)
down_degrees = [6, 4, 3, 2, 1, 2, 3, 4]
final_degree = [1]
sections = [
(up_degrees, 4, range(14)),
(down_degrees, 4, range(13, -2, -1)),
(final_degree, 32, range(1)),
]
hanon_1 = OSequence()
for section in sections:
pattern, duration_64, offset = section
for o in offset:
for note in pattern:
hanon_1.append({"degree": note + o, DURATION_64: duration_64})
hanon_1 = hanon_1 | degree_in_key_with_octave(Key("C", major_scale), 4) | midi_pitch()
hanon_rh_1 = hanon_1
hanon_lh_1 = hanon_1 | transpose(-12)
seq = hanon_lh_1 // hanon_rh_1
if __name__ == "__main__":
f = open("hanon.mid", "w")
s = SMF([seq])
s.write(f)
f.close()
def multiply(seq, matrix):
output = seq
for m in matrix:
output = output // (seq | transpose(m))
return output
from sebastian.lilypond.interp import parse
from sebastian.lilypond.write_lilypond import write
from sebastian.midi import write_midi, player
from sebastian.core import OSequence, HSeq, Point, DURATION_64
from sebastian.core.transforms import transpose, reverse, add, degree_in_key, midi_pitch, lilypond
from sebastian.core.notes import Key, major_scale
# construct sequences using lilypond syntax
seq1 = parse("c d e")
seq2 = parse("e f g")
# concatenate
seq3 = seq1 + seq2
# transpose and reverse
seq4 = seq3 | transpose(12) | reverse()
# merge
seq5 = seq3 // seq4
# play MIDI
player.play([seq5])
# write to MIDI
write_midi.write("seq5.mid", [seq5])
# contruct a horizontal sequence of scale degrees
seq6 = HSeq(Point(degree=degree) for degree in [1, 2, 3, 2, 1])
# put that sequence into C major, octave 4 quavers
C_MAJOR = Key("C", major_scale)
{MIDI_PITCH: 64, OFFSET_64: 32, DURATION_64: 16},
{MIDI_PITCH: 66, OFFSET_64: 32, DURATION_64: 8},
{MIDI_PITCH: 66, OFFSET_64: 40, DURATION_64: 8},
{MIDI_PITCH: 64, OFFSET_64: 48, DURATION_64: 16},
{MIDI_PITCH: 66, OFFSET_64: 48, DURATION_64: 8},
{MIDI_PITCH: 66, OFFSET_64: 56, DURATION_64: 8}
]
## point transformation
from sebastian.core.transforms import transpose, reverse, stretch, invert, add, degree_in_key, midi_pitch
# transpose
assert (s1 | transpose(12))._elements == [
{MIDI_PITCH: 62, OFFSET_64: 16, DURATION_64: 16},
{MIDI_PITCH: 64, OFFSET_64: 32, DURATION_64: 16}
]
assert s1 | transpose(5) | transpose(-5) == s1
# reverse
assert (s1 | reverse())._elements == [
{MIDI_PITCH: 52, OFFSET_64: 0, DURATION_64: 16},
{MIDI_PITCH: 50, OFFSET_64: 16, DURATION_64: 16},
{OFFSET_64: 48}
]
assert s1 | reverse() | reverse() == s1
down_degrees = [6, 4, 3, 2, 1, 2, 3, 4]
final_degree = [1]
sections = [
(up_degrees, 4, range(14)),
(down_degrees, 4, range(13, -2, -1)),
(final_degree, 32, range(1)),
]
hanon_1 = OSequence()
for section in sections:
pattern, duration_64, offset = section
for o in offset:
for note in pattern:
hanon_1.append({"degree": note + o, DURATION_64: duration_64})
hanon_1 = hanon_1 | degree_in_key_with_octave(Key("C", major_scale),
4) | midi_pitch()
hanon_rh_1 = hanon_1
hanon_lh_1 = hanon_1 | transpose(-12)
seq = hanon_lh_1 // hanon_rh_1
if __name__ == "__main__":
f = open("hanon.mid", "w")
s = SMF([seq])
s.write(f)
f.close()
