def inside(self):
middle = float(len(self.items)) / 2
if middle % 2 != 0:
return NoteSeq([self.items[int(middle - .5)]])
else:
return NoteSeq(
[self.items[int(middle - 1)], self.items[int(middle)]])
def determine_dominant_key(self, notes):
'''
Takes a list of notes and compares it to each key, then returns the key which the
notes match best.
:param str notes: A list of notes in string format or as a pyknon.music.NoteSeq.
:returns: A string representation of the dominant key (i.e. 'fminor')
'''
if isinstance(notes, pyknon.music.NoteSeq):
test_seq = notes
else:
if isinstance(notes, str):
test_seq = NoteSeq(notes)
elif isinstance(notes, list):
test_seq = NoteSeq(''.join(notes))
else:
raise ValueError(
'Notes supplied to determine_dominant_key not in a known format (list, string, NoteSeq)'
)
key_score = {}
for key in self.music_keys.keys():
key_score[key] = 0
for note in test_seq:
for key, value in self.music_keys.items():
if note in value:
key_score[key] = key_score[key] + 1
dominant_key = max(key_score, key=key_score.get)
return dominant_key
def get_meter_notes(beats_sample,
meter_signature,
pitch_sample,
octave_sample,
volume_sample=120,
shuffle_pitch_sample=True,
shuffle_beats=True,
n_beats=None):
""" Return the sequence of notes
"""
notes = NoteSeq()
# get the beats
if shuffle_beats:
beats = get_beats(beats_sample, meter_signature)
else:
beats = beats_sample
if n_beats:
beats = beats[:n_beats]
vol = get_random_item(volume_sample)
for ctr, beat in enumerate(beats):
if shuffle_pitch_sample:
pitch = get_random_item(pitch_sample)
else:
pitch = pitch_sample[ctr]
note = pitch_to_note(pitch)
octave = get_random_item(octave_sample)
notes.append(Note(note, octave, beat, vol))
return notes
def test_stretch_inverval(self):
seq1 = NoteSeq("C D E")
seq2 = NoteSeq("C E G#")
seq3 = NoteSeq("A Bb F#")
seq4 = NoteSeq("A C#'' C''")
self.assertEqual(seq1.stretch_inverval(2), seq2)
self.assertEqual(seq3.stretch_inverval(3), seq4)
def strToMidi(msg, fileName):
from pyknon.genmidi import Midi
from pyknon.music import NoteSeq
from pyknon.music import Note
notes = {
'0' : Note(value=0, octave=5), # Do
'1' : Note(value=2, octave=5), # Re
'2' : Note(value=4, octave=5), # Mi
'3' : Note(value=5, octave=5), # Fa
'4' : Note(value=7, octave=5), # Sol
'5' : Note(value=9, octave=5), # La
'6' : Note(value=11, octave=5), # Si
'7' : Note(value=0, octave=6),
'8' : Note(value=2, octave=6),
'9' : Note(value=4, octave=6),
'a' : Note(value=5, octave=6),
'b' : Note(value=7, octave=6),
'c' : Note(value=9, octave=6),
'd' : Note(value=11, octave=6),
'e' : Note(value=0, octave=7),
'f' : Note(value=2, octave=7)
}
msgHex = msg.encode('hex');
sequence = NoteSeq('C1')
before = ''
for i in msgHex:
if before == i:
sequence.append(Note(value=4, octave=7))
sequence.append(notes[i])
before = i
midi = Midi(1, tempo = 290)
midi.seq_notes(sequence, track=0)
midi.write(fileName)
def pix2noteseq(pixelmap, width, height):
"""
Convert a PIL pixel map to a PyKnon NoteSeq
Use:
pix2noteseq(pixelmap)
Arguemnts:
pixelmap: the PIL pixel map of the image
width: the width in pixels
height: height in pixels
This function presumes the pixel map is in RGB and correct behavior when
otherwise is not at all guaranteed.
"""
notes = NoteSeq()
# Iterate over the pixels, starting at the top left and working
# colomn by colomn
for y in range(height):
for x in range(width):
notes.append(pix2note(pixelmap[x,y]))
if y == math.ceil(height/2) and x == math.ceil(width/2):
print("50% done...")
return notes
def test_rotate(self):
seq1 = NoteSeq("C E G")
seq2 = NoteSeq("E G C")
seq3 = NoteSeq("G C E")
self.assertEqual(seq1.rotate(0), seq1)
self.assertEqual(seq1.rotate(1), seq2)
self.assertEqual(seq1.rotate(2), seq3)
self.assertEqual(seq1.rotate(3), seq1)
def chord_prog(chords_note):
cprog6251 = NoteSeq()
count = 0
while count < 2: # while true if break
for i in chords_note:
cprog6251.append(Note(i, 4, 1, 100))
count += 1
return cprog6251
def crab_canon(filename):
theme = NoteSeq("file://%s.notes" % filename)
rev_theme = theme.transposition(-12).retrograde()
midi = Midi(2, tempo=120)
midi.seq_notes(theme)
midi.seq_notes(rev_theme, track=1)
midi.write("%s.mid" % filename)
def demo():
notes1 = NoteSeq("D4 F#8 A Bb4")
notes2 = NoteSeq([Note(2, dur=1/4), Note(6, dur=1/8),
Note(9, dur=1/8), Note(10, dur=1/4)])
midi = Midi(number_tracks=2, tempo=90)
midi.seq_notes(notes1, track=0)
midi.seq_notes(notes2, track=1)
midi.write("midi/demo.mid")
def crab_canon():
theme2 = NoteSeq("file://canon-crab")
rev_theme = theme2.transposition(-12).retrograde()
midi = Midi(2, tempo=120)
midi.seq_notes(theme2)
midi.seq_notes(rev_theme, track=1)
midi.write("midi/canon-crab.mid")
def random_notes(pitch_list, octave, duration, number_of_notes, volume=120):
result = NoteSeq()
for x in range(0, number_of_notes):
pitch = choice(pitch_list)
octave = choice_if_list(octave)
dur = choice_if_list(duration)
vol = choice_if_list(volume)
result.append(Note(pitch, octave, dur, vol))
return result
def play_list(pitch_list, octave_list, duration, volume=120):
result = NoteSeq()
for pitch in pitch_list:
note = pitch % 12
octave = choice_if_list(octave_list)
dur = choice_if_list(duration)
vol = choice_if_list(volume)
result.append(Note(note, octave, dur, vol))
return result
def play_list(pitch_list, octave_list, duration, volume=120):
result = NoteSeq()
for pitch in pitch_list:
note = pitch % 12
octave = choice_if_list(octave_list)
dur = choice_if_list(duration)
vol = choice_if_list(volume)
result.append(Note(note, octave, dur, vol))
return result
def random_notes(pitch_list, octave_list, duration, volume):
result = NoteSeq()
number_of_notes = int(1 // duration)
for x in range(0, number_of_notes, 1):
pitch = choice(pitch_list)
octave = choice(octave_list)
dur = duration
vol = volume
result.append(Note(pitch, octave, dur, vol))
return result
def random_notes(pitch_list, octave_list, duration,
number_of_notes, volume=120):
result = NoteSeq()
for x in range(0, number_of_notes):
pitch = choice(pitch_list)
octave = choice_if_list(octave_list)
dur = choice_if_list(duration)
vol = choice_if_list(volume)
result.append(Note(pitch, octave, dur, vol))
return result
def test_init_empty(self):
"""Test if NoteSeq without arguments will clean previous values."""
seq = NoteSeq()
seq.append(Note("C"))
seq = NoteSeq()
seq.append(Note("D"))
self.assertEqual(seq, NoteSeq("D"))
def josquin():
main_theme = NoteSeq("file://josquin")
theme1 = main_theme.stretch_dur(0.66666)
theme2 = main_theme[0:24].stretch_dur(2).transp(Note("C"))
theme3 = main_theme[0:50]
midi = Midi(3, tempo=80)
midi.seq_notes(theme1, track=0)
midi.seq_notes(theme2, track=1)
midi.seq_notes(theme3, track=2)
midi.write("midi/josquin.mid")
def rhythm_16th_note_subdivided_right(self, chord: Chord) -> [NoteSeq]:
# works best with subdivided = 20
chord = chord.stretch_dur(2 / self.subdivided)
l1 = [NoteSeq([chord[0]])] + [NoteSeq([chord[1]])]
l2 = [NoteSeq([chord[2]])] + [NoteSeq([chord[1]])]
rhythm = []
for i in range(0, 4):
rhythm += l1 + l2
return rhythm
def __init__(self, args, first_note=None, name=None):
NoteSeq.__init__(self, args=args)
if isinstance(first_note, Note):
self.first_note = first_note
elif first_note is None:
self.first_note = self.items[0]
if name is None:
self.name = self.first_note.name
else:
self.name = name
def test_init(self):
notes = [Note(0, 5), Note(2, 5)]
seq1 = NoteSeq(notes)
seq2 = NoteSeq("C#2' D#4''")
seq3 = NoteSeq([Note(1, 5, 0.5), Note(3, 6, 0.25)])
self.assertEqual(seq1, NoteSeq(notes))
self.assertEqual(seq2, seq3)
self.assertNotEqual(seq1, NoteSeq(notes + [Note(3, 5)]))
self.assertRaises(MusiclibError, NoteSeq,
[Note(1, 5, 0.5), Rest(2), 1])
self.assertRaises(MusiclibError, NoteSeq, 1)
def test_sum_with_rest(self):
# Test adding in regular order
rest1 = Rest(1)
seq = NoteSeq("C2 D8 E4")
expected = NoteSeq("C2 D8 E4 R1")
self.assertEqual(seq + rest1, expected)
# Test reverse adding, rest first
seq = NoteSeq("C2 D8 E4")
expected = NoteSeq("R1 C2 D8 E4")
self.assertEqual(rest1 + seq, expected)
def test_sum_with_note(self):
# Test adding in regular order
note1 = Note("G1")
seq = NoteSeq("C2 D8 E4")
expected = NoteSeq("C2 D8 E4 G1")
self.assertEqual(seq + note1, expected)
# Test reverse adding, note first
seq = NoteSeq("C2 D8 E4")
expected = NoteSeq("G1 C2 D8 E4")
self.assertEqual(note1 + seq, expected)
def getNotesFromNums(nums, scaleNum, durations):
#convert back to noteSeq
scale = majorScales[scaleNum]
ans = NoteSeq()
j = 0
for num in nums:
for i in range(len(scale)):
if num==i:
ans.append(Note(scale[i], dur=durations[j]))
j+=1
#print(ans)
return ans
def test_harmonize(self):
c_major = NoteSeq("C D E F G A B")
c_major_harmonized = [
NoteSeq("C E G"),
NoteSeq("D F A"),
NoteSeq("E G B"),
NoteSeq("F A C''"),
NoteSeq("G B D''"),
NoteSeq("A C'' E"),
NoteSeq("B D'' F''")
]
self.assertEqual(c_major.harmonize(), c_major_harmonized)
def rhythm_heart_and_soul_right(self, chord: Chord) -> [NoteSeq]:
rhythm = []
new_chord = chord
silence_chord = NoteSeq("R")
rhythm.append(silence_chord.stretch_dur(8 / self.subdivided))
rhythm.append(new_chord.stretch_dur(4 / self.subdivided))
rhythm.append(new_chord.stretch_dur(4 / self.subdivided))
rhythm.append(silence_chord.stretch_dur(8 / self.subdivided))
rhythm.append(new_chord.stretch_dur(4 / self.subdivided))
rhythm.append(new_chord.stretch_dur(4 / self.subdivided))
return rhythm
def test_init_with_rest(self):
seq1 = NoteSeq("C4 R4 D4")
seq2 = NoteSeq("C8 R D")
seq3 = NoteSeq([Note(0, dur=0.25), Rest(0.25), Note(2, dur=0.25)])
self.assertEqual(seq1[0].dur, 0.25)
self.assertEqual(seq1[1].dur, 0.25)
self.assertEqual(seq1[2].dur, 0.25)
self.assertEqual(seq2[0].dur, 0.125)
self.assertEqual(seq2[1].dur, 0.125)
self.assertEqual(seq2[2].dur, 0.125)
self.assertEqual(seq3[0].dur, 0.25)
self.assertEqual(seq3[1].dur, 0.25)
self.assertEqual(seq3[2].dur, 0.25)
def makemidi(self):
note_names = 'c c# d d# e f f# g g# a a# b'.split()
octav10 = {
'c10', 'c#10', 'd10', 'd#10', 'e10', 'f10', 'f#10', 'g10', 'g#10',
'a10', 'a#10', 'b10'
}
result = NoteSeq()
for s in self.song:
duration = 1. / s[1]
if s[0] == 'r':
result.append(Rest(dur=duration))
elif {s[0]}.issubset(octav10):
md = s[0][:-2]
octave = int(s[0][-2:]) + 1
note_number = note_names.index(md)
result.append(Note(note_number, octave=octave, dur=duration))
else:
md = s[0][:-1]
octave = int(s[0][-1]) + 1
note_number = note_names.index(md)
result.append(Note(note_number, octave=octave, dur=duration))
midi = Midi(number_tracks=1, tempo=self.bpm)
midi.seq_notes(result, track=0)
midi.write(self.path)
def test_stretch_interval(self):
seq1 = NoteSeq("C D E")
seq2 = NoteSeq("C E G#")
seq3 = NoteSeq("A Bb F#")
seq4 = NoteSeq("A C#'' C''")
self.assertEqual(seq1.stretch_interval(2), seq2)
self.assertEqual(seq3.stretch_interval(3), seq4)
def test_harmonize(self):
c_major_scale = NoteSeq("C D E F G A B")
scale_as_list = [
Note("C"),
Note("D"),
Note("E"),
Note("F"),
Note("G"),
Note("A"),
Note("B")
]
c_major = Note("C").harmonize(c_major_scale, 3, 3)
a_minor = Note("A").harmonize(scale_as_list, 3, 4)
self.assertEqual(NoteSeq(c_major), NoteSeq("C E G"))
self.assertEqual(NoteSeq(a_minor), NoteSeq("A C'' E G"))
def randomTune():
# creating a string of random notes from the pool
noteString = ''
for _ in range(NUMBER_OF_NOTES):
noteString += random.choice(notesPoolA) + " "
return NoteSeq(noteString)
def saveSong(self, filename):
def nameFile(filename, iterator):
return "".join(filename.split(".")[:-1]) + str(
iterator) + "." + filename.split(".")[-1]
if self.__notes != []:
self.__addTrack()
# for track in self.__tracks:
# track.addPause()
fileNameIterator = 0
for track in self.__tracks:
midi = Midi(number_tracks=1,
instrument=track.getInstrument().value)
notes = NoteSeq(track.getNotes())
midi.seq_notes(notes, track=0)
midi.write(nameFile(filename, fileNameIterator))
fileNameIterator += 1
fileNameIterator -= 1
if fileNameIterator > 0:
for i in range(fileNameIterator):
os.system("python midisox.py --combine concatenate " +
nameFile(filename, i) + " " +
nameFile(filename, i + 1) + " " +
nameFile(filename, i + 1))
os.remove(nameFile(filename, i))
if os.path.exists(filename):
os.remove(filename)
os.rename(nameFile(filename, fileNameIterator), filename)
def randomTune():
#creamos un string de notas random para la agrupacion
noteString = ''
for _ in range(NUMBER_OF_NOTES):
noteString += random.choice(notesPoolA) + " "
return NoteSeq(noteString)
def midi_from_melodies(melodies): notes = [[Note(x%Octave, 4 + x//Octave, 1/4) for x in melody] for melody in melodies] chords = [NoteSeq([melody_notes[i] for melody_notes in notes]) for i in range(len(melody))] midi = Midi(tempo=120) midi.seq_chords(chords) return midi
def random_melody(note_list, octave_low, octave_high, dur_list):
rm_seq = NoteSeq() #[]
rm_data = []
melody_len = 0
while melody_len < 8: # while True if break bug
pitch = random.choice(note_list) #refactor by root +2 +4 ...
octave = random.randint(octave_low, octave_high)
dur = random.choice(dur_list)
vol = random.randrange(80, 125, 5) #refactor
print([pitch, octave, dur, vol])
rm_seq.append(Note(pitch, octave, dur, vol)) #refactor
rm_data.append([pitch, octave, dur, vol])
melody_len += dur
print(melody_len)
rm = [rm_seq, rm_data]
return rm
def conform_notes_to_key(self, notes, music_key):
'''
Takes a list of notes, and a music key and ensures that every note either
belongs to that key or to its relative key.
:param str notes: The notes to be matched
:param str music_key: The name of the key to be matched (i.e. 'cmajor')
:returns: A list of notes that are all in the specified key or its relative key.
'''
if isinstance(notes, NoteSeq):
test_notes = notes
else:
test_notes = NoteSeq(' '.join(notes))
new_note_list = []
key_notes = self.music_keys[music_key]
relative_key = self.relative_keys[music_key]
if relative_key:
relative_key_notes = self.music_keys[relative_key]
for note in test_notes:
if note in key_notes or note in relative_key_notes:
new_note_list.append(note)
else:
new_note = numpy.random.choice(key_notes + relative_key_notes)
new_note_list.append(new_note)
return new_note_list
def get_random_note_seq(notes: int,
pitches: set,
durations: set,
rests=False):
if rests:
if random.randint(1, 20) is 1:
pitches.add('r')
notes *= random.randint(1, 2)
this_seq = ''
for i in range(notes):
try:
pitch = random.sample(pitches, 3)
except:
pitch = random.sample(pitches, 2)
duration = random.sample(durations, 1)
try:
this_seq += pitch[0] + duration[0] + ' ' + pitch[1] + duration[
1] + pitch[2] + duration[2] + pitch[0] + duration[
0] + ' ' + pitch[1] + duration[1] + pitch[2] + duration[
2] + pitch[0] + duration[0] + ' ' + pitch[
1] + duration[1] + pitch[2] + duration[2] + ' '
except:
try:
this_seq += pitch[0] + duration[0] + ' ' + pitch[
1] + duration[1] + ' '
except:
this_seq += pitch[0] + duration[0] + ' '
return NoteSeq(this_seq)
def play_list(pitch_list, octave_list, duration,
volume=120):
result = NoteSeq()
durl = [1/8, 1/8, 1/16, 1/16]
cc = [choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11])]
st = 0
for pitch in pitch_list:
note1 = pitch
note = cc[st%4]
#octave = choice_if_list(octave_list)
octave = change_range(note1, 0, 11, 1, 7)
#dur = choice_if_list(duration)
dur = durl[st%4]
st += 1
vol = choice_if_list(volume)
result.append(Note(note, octave, dur, vol))
return result
def test_init_empty(self):
"""Test if NoteSeq without arguments will clean previous values."""
seq = NoteSeq()
seq.append(Note("C"))
seq = NoteSeq()
seq.append(Note("D"))
self.assertEqual(seq, NoteSeq("D"))
def random_notes_with_memory(pitch_list, octave_list, duration_list,
number_of_notes, memory_weights, volume=120):
assert len(memory_weights) > 1, "more than 1 weight expected for memory"
result = NoteSeq()
for offset in range(0, number_of_notes):
if 1+offset >= len(memory_weights):
weights = memory_weights
else:
weights = memory_weights[0:1+offset]
pitch_selection = weighted_random(weights)
if pitch_selection == 0: # new note
pitch = choice(pitch_list)
else:
pitch = result[-pitch_selection].value
octave_selection = weighted_random(weights)
if octave_selection == 0: # new note
octave = choice_if_list(octave_list)
else: # previous note at given position starting from the end
octave = result[-octave_selection].octave
duration_selection = weighted_random(weights)
if duration_selection == 0: # new note
dur = choice_if_list(duration_list)
else: # previous note at given position starting from the end
dur = result[-duration_selection].dur
volume_selection = weighted_random(weights)
if volume_selection == 0: # new note
vol = choice_if_list(volume)
else: # previous note at given position starting from the end
vol = result[-volume_selection].volume
result.append(Note(pitch, octave, dur, vol))
return result
def test_inversion_startswith_integer(self):
seq1 = NoteSeq("C E G")
seq2 = NoteSeq("C Ab, F,")
self.assertEqual(seq1.inversion_startswith(0), seq2)
def test_transposition(self):
seq = NoteSeq("C E G")
self.assertEqual(seq.transposition(3), NoteSeq("Eb G Bb"))
self.assertEqual(seq.transposition(5), NoteSeq("F A C''"))
indices = range(1, size*i, i)
return self.harmonize_template(scale, indices)
Note.harmonize_template = note_harmonize_template
Note.harmonize = note_harmonize
def noteseq_harmonize_template(self, indices):
return [\
NoteSeq(note.harmonize_template(self, indices)) for note in self\
]
NoteSeq.harmonize_template = noteseq_harmonize_template
c = Note("C")
assert str(c) == '<C>'
c_major_scale = NoteSeq("C D E F G A B")
assert str(c_major_scale) == '<Seq: [<C>, <D>, <E>, <F>, <G>, <A>, <B>]>'
assert str(c.harmonize(c_major_scale)) == '[<C>, <E>, <G>]'
assert str(c.harmonize_template(c_major_scale, [1, 3, 5])) == '[<C>, <E>, <G>]'
assert str(c.harmonize_template(c_major_scale, [1, 2, 3])) == '[<C>, <D>, <E>]'
assert str(c.harmonize_template(c_major_scale, [1, 4, 2])) == '[<C>, <F>, <D>]'
assert str(c.harmonize_template(c_major_scale, [5, 7, 9])) == '[<G>, <B>, <D>]'
assert str(c.harmonize_template(c_major_scale, [1, 2, 3, 4])) == \
'[<C>, <D>, <E>, <F>]'
assert str(c.harmonize_template(c_major_scale, [1, 3, 5, 6, 8])) == \
'[<C>, <E>, <G>, <A>, <C>]'
assert str(c_major_scale.harmonize()) == '[' \
def test_retrograde(self):
seq1 = NoteSeq("C4 D8 E8")
seq2 = NoteSeq("E8 D8 C4")
self.assertEqual(seq1.retrograde(), seq2)
def test_intervals(self):
seq = NoteSeq("C D E F#")
self.assertEqual(seq.intervals(), [2, 2, 2])
def test_transposition_with_rest(self):
seq1 = NoteSeq("C8 D R E")
self.assertEqual(seq1.transposition(3), NoteSeq("Eb8 F R G"))
def test_stretch_dur(self):
seq1 = NoteSeq("C4 D8 E8")
seq2 = NoteSeq("C8 D16 E16")
seq3 = NoteSeq("C2 D4 E4")
self.assertEqual(seq1.stretch_dur(.5), seq2)
self.assertEqual(seq1.stretch_dur(2), seq3)
def test_append(self):
seq1 = NoteSeq("C# D#")
seq1.append(Note("F#"))
seq2 = NoteSeq("C# D# F#")
self.assertEqual(seq1, seq2)
def test_transposition_startswith(self):
seq1 = NoteSeq("E G C#")
seq2 = NoteSeq([Note(2, 5), Note(5, 5), Note(11, 4)])
seq3 = NoteSeq([Note(2, 4), Note(5, 4), Note(11, 3)])
self.assertEqual(seq1.transposition_startswith(Note(2, 5)), seq2)
self.assertEqual(seq1.transposition_startswith(Note(2, 4)), seq3)
def test_transposition_startswith_string(self):
seq1 = NoteSeq("C D E")
seq2 = NoteSeq("D E F#")
self.assertEqual(seq1.transposition_startswith("D"), seq2)
def test_transposition_startswith_rest(self):
seq1 = NoteSeq("E G R C#")
seq2 = NoteSeq([Note(2, 5), Note(5, 5), Rest(), Note(11, 4)])
self.assertEqual(seq1.transposition_startswith(Note(2, 5)), seq2)
def test_inversion_startswith(self):
seq1 = NoteSeq("C E G")
seq2 = NoteSeq([Note(1, 5), Note(9, 4), Note(6, 4)])
self.assertEqual(seq1.inversion_startswith(Note(1, 5)), seq2)
def test_inversion_rest(self):
seq1 = NoteSeq("C E R G")
seq2 = NoteSeq([Note(0, 5), Note(8, 4), Rest(), Note(5, 4)])
self.assertEqual(seq1.inversion(0), seq2)
def test_inversion_octave(self):
seq1 = NoteSeq("G Ab B,")
seq2 = NoteSeq("G F# Eb''")
self.assertEqual(seq1.inversion(7), seq2)
def test_intervals(self):
seq1 = NoteSeq("C D E F#")
seq2 = NoteSeq("B' C''")
self.assertEqual(seq1.intervals(), [2, 2, 2])
self.assertEqual(seq2.intervals(), [1])
def test_inversion_startswith_octave(self):
seq1 = NoteSeq("G Ab B,")
seq2 = NoteSeq("E Eb C''")
self.assertEqual(seq1.inversion_startswith(Note(4, 5)), seq2)
def test_inversion_startswith_string(self):
seq1 = NoteSeq("C E G")
seq2 = NoteSeq("C Ab, F,")
self.assertEqual(seq1.inversion_startswith("C"), seq2)
def test_harmonize(self):
c_major = NoteSeq("C D E F G A B")
c_major_harmonized = [NoteSeq("C E G"), NoteSeq("D F A"), NoteSeq("E G B"),
NoteSeq("F A C''"), NoteSeq("G B D''"), NoteSeq("A C'' E"),
NoteSeq("B D'' F''")]
self.assertEqual(c_major.harmonize(), c_major_harmonized)
def test_transposition_startswith_integer(self):
seq1 = NoteSeq("C D E")
seq2 = NoteSeq("D E F#")
self.assertEqual(seq1.transposition_startswith(2), seq2)
def test_insert(self):
seq1 = NoteSeq("Ab Bb Eb")
seq1.insert(2, Note("C#"))
seq2 = NoteSeq("Ab Bb C# Eb")
self.assertEqual(seq1, seq2)
