def test_book_example(self):
print('----- book_example -----')
voice_line = Line()
melody_line = Line()
melody_1 = Line(
[Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'aceg'])
melody_2 = Line(
[Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'cadg'])
base_line = Line(
[Note(DiatonicPitch(4, y), Duration(1, 4)) for y in 'dddddddd'])
melody_line.pin(melody_1, Offset(1, 8))
melody_line.pin(melody_2, Offset(1, 4))
voice_line.pin(melody_line)
voice_line.pin(base_line)
print(voice_line)
all_notes = voice_line.get_all_notes()
print('... pinned notes ...')
for n in all_notes:
print('({0}) : {1}'.format(n.get_absolute_position(),
n.diatonic_pitch))
print('... end pinned notes ...')
print('End test_pin')
def test_simple_fixed_pitch(self):
logging.debug('Start test_simple_fixed_pitch')
note = Note(DiatonicPitch.parse("C:5"), Duration(1, 4))
select_notes = {'A:5', 'C:4', 'Eb:2', 'F#:6'}
constraint = FixedPitchSelectSetConstraint(
note, {DiatonicPitch.parse(p)
for p in select_notes})
policy_context = TestFixedPitchSelectSetConstraint.policy_creator(
ModalityType.Major, DiatonicTone('C'), 'tIV', 'C:2', 'C:8')
lower_contextual = ContextualNote(policy_context)
p_map = PMap()
p_map[note] = lower_contextual
v_results = constraint.values(p_map, note)
assert v_results is not None
assert len(v_results) == len(select_notes)
for result in v_results:
print(str(result))
assert select_notes == {str(n.diatonic_pitch) for n in v_results}
assert not constraint.verify(p_map)
lower_contextual.note = Note(DiatonicPitch.parse('Eb:2'),
Duration(1, 4))
assert constraint.verify(p_map)
def test_adding_notes(self):
score = Score()
# set up 3 instrument voices: 2 violins, 1 trumpet, 1 clarinet
catalogue = InstrumentCatalog.instance()
score.add_instrument_voice(
InstrumentVoice(catalogue.get_instrument("violin"), 2))
# 1 beat == 1 sec, 3/4 TS + 60 beats per minute,
score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0)))
score.time_signature_sequence.add(
TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0)))
violin_voice = score.get_instrument_voice("violin")[0]
line = Line([Note(DiatonicPitch(4, y), Duration(1, 8)) for y in 'afd'])
violin_voice.voice(0).pin(line)
notes = violin_voice.get_all_notes()
for n in notes:
print(n)
line.append(Note(DiatonicPitch(4, 'g'), Duration(1, 8)))
notes = violin_voice.get_all_notes()
for n in notes:
print(n)
def test_book_example(self):
score = Score()
# set up 3 instrument voices: 2 violins, 1 trumpet, 1 clarinet
catalogue = InstrumentCatalog.instance()
score.add_instrument_voice(
InstrumentVoice(catalogue.get_instrument("violin"), 2))
score.add_instrument_voice(
InstrumentVoice(catalogue.get_instrument("trumpet")))
score.add_instrument_voice(
InstrumentVoice(catalogue.get_instrument("clarinet")))
# 1 beat == 1 sec, 3/4 TS + 60 beats per minute,
score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0)))
score.time_signature_sequence.add(
TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0)))
# set up some notes in the two violins
violin_voice = score.get_instrument_voice("violin")[0]
violin_voice.voice(0).pin(
Line([Note(DiatonicPitch(4, y), Duration(1, 8))
for y in 'afdecd']))
violin_voice.voice(0).pin(
Line([Note(DiatonicPitch(4, y), Duration(1, 4)) for y in 'cdc']))
def test_book_example(self):
# Creating a beam with 1/8, 3/8, and 1/16 notes
note0 = Note(DiatonicPitch(4, 'c'), Duration(1, 8))
note1 = Note(DiatonicPitch(4, 'd'), Duration(1, 8), 1)
note2 = Note(DiatonicPitch(4, 'e'), Duration(1, 16))
beam = Beam([note0, note1, note2])
print(beam)
def test_add_note_at_lower_level(self):
print('start test_add_note_at_lower_level')
sub_beam = Beam([
Note(DiatonicPitch(2, 'c'), Duration(1, 8)),
Note(DiatonicPitch(2, 'd'), Duration(1, 8))
])
beam = Beam([
Note(DiatonicPitch(3, 'c'), Duration(1, 8)), sub_beam,
Note(DiatonicPitch(3, 'd'), Duration(1, 8))
])
AbstractNote.print_structure(beam)
notes = beam.get_all_notes()
assert len(notes) == 4
assert beam.sub_notes[1].duration == Duration(1, 8)
assert beam.sub_notes[1].relative_position == Offset(1, 8)
assert beam.sub_notes[1].sub_notes[1].duration == Duration(1, 16)
assert beam.sub_notes[1].sub_notes[1].relative_position == Offset(
1, 16)
sub_beam.add(Note(DiatonicPitch(2, 'c'), Duration(1, 8)), 1)
AbstractNote.print_structure(beam)
assert beam.sub_notes[1].duration == Duration(3, 16)
assert beam.sub_notes[1].relative_position == Offset(1, 8)
assert beam.sub_notes[1].sub_notes[1].duration == Duration(1, 16)
assert beam.sub_notes[1].sub_notes[1].relative_position == Offset(
1, 16)
def test_from_book(self):
# Quarter note at C:4
note = Note(DiatonicPitch(4, 'c'), Duration(1, 4))
print('{0} duration={1}'.format(note.diatonic_pitch, note.duration))
# Double dotted quarter not at F#:5
note = Note(DiatonicPitch(5, 'f#'), 'Q', 2)
print('{0} duration={1}'.format(note.diatonic_pitch, note.duration))
def test_basic_policy(self):
logging.debug('Start test_basic_policy')
lower_policy_context = TestRelativeScalarStepConstraint.policy_creator(
ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8')
note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8))
note2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8))
lower_note_1 = ContextualNote(
lower_policy_context,
Note(DiatonicPitch.parse('F#:5'), Duration(1, 8)))
lower_note_2 = ContextualNote(lower_policy_context)
p_map = dict([(note1, lower_note_1), (note2, lower_note_2)])
# F#:5 --> G Major two below and 3 above
policy = RelativeScalarStepConstraint(note1, note2, -2, 3)
v_result = policy.values(p_map, note2)
pitches = [n.diatonic_pitch for n in v_result]
assert len(pitches) == 6
for s in ['D:5', 'E:5', 'F#:5', 'G:5', 'A:5', 'B:5']:
assert DiatonicPitch.parse(s) in pitches
for note in v_result:
logging.debug(note)
# Check verify for each answer
for n in v_result:
lower_note_2.note = n
assert policy.verify(p_map)
logging.debug('End test_basic_policy')
def test_basic_construction(self):
note = Note(DiatonicPitch(4, 'c'), Duration(1, 4))
print(note)
assert note.base_duration == Duration(1, 4)
assert note.duration == Duration(1, 4)
assert str(note.diatonic_pitch) == 'C:4'
assert not note.is_rest
# quarter rest
note = Note(None, Duration(1, 4))
print(note)
assert note.base_duration == Duration(1, 4)
assert note.duration == Duration(1, 4)
assert note.diatonic_pitch is None
assert note.is_rest
note = Note(DiatonicPitch(4, 'c'), Duration(1, 4), 2)
print(note)
assert note.base_duration == Duration(1, 4)
assert note.duration == Duration(7, 16)
assert str(note.diatonic_pitch) == 'C:4'
assert not note.is_rest
note = Note(DiatonicPitch(5, 'f#'), 'Q', 2)
print(note)
assert note.base_duration == Duration(1, 4)
assert note.duration == Duration(7, 16)
assert str(note.diatonic_pitch) == 'F#:5'
assert not note.is_rest
def test_reversal_on_policy(self):
logging.debug('Start test_reversal_on_policy')
lower_policy_context = TestRelativeScalarStepConstraint.policy_creator(
ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8')
note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8))
note2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8))
lower_note_1 = ContextualNote(lower_policy_context)
lower_note_2 = ContextualNote(
lower_policy_context,
Note(DiatonicPitch.parse('C:5'), Duration(1, 8)))
p_map = dict([(note1, lower_note_1), (note2, lower_note_2)])
# F#:5 --> G Major two below and 3 above
policy = RelativeScalarStepConstraint(note1, note2, -2, 3)
result = policy.values(p_map, note1)
pitches = [n.diatonic_pitch for n in result]
for pitch in pitches:
logging.debug(pitch)
# Check that each returned verifies
for n in result:
lower_note_1.note = n
assert policy.verify(p_map)
logging.debug('End test_reversal_on_policy')
def test_across_tonalities(self):
logging.debug('Start test_across_tonalities.')
lower_policy_context_1 = TestRelativeDiatonicConstraint.policy_creator(
ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8')
lower_policy_context_2 = TestRelativeDiatonicConstraint.policy_creator(
ModalityType.Major, DiatonicTone('Ab'), 'tI', 'C:2', 'C:8')
upper_note_1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8))
upper_note_2 = Note(DiatonicPitch.parse('D:5'), Duration(1, 8))
lower_note_1 = ContextualNote(
lower_policy_context_1,
Note(DiatonicPitch.parse('F#:5'), Duration(1, 8)))
lower_note_2 = ContextualNote(lower_policy_context_2)
p_map = dict([(upper_note_1, lower_note_1),
(upper_note_2, lower_note_2)])
policy = RelativeDiatonicConstraint(upper_note_1, upper_note_2,
Interval(3, IntervalType.Minor),
Interval(3, IntervalType.Major))
v_result = policy.values(p_map, upper_note_2)
for note in v_result:
logging.debug(note)
pitches = [note.diatonic_pitch for note in v_result]
assert {str(p) for p in pitches} == {'Eb:5', 'F:5', 'G:5', 'Ab:5'}
logging.debug('End test_across_tonalities.')
def test_simple_tuplet_reverse(self):
print('test simple tuplet reverse')
a = Note(DiatonicPitch(3, 'a'), Duration(1, 8))
b = Note(DiatonicPitch(3, 'b'), Duration(1, 8))
c = Note(DiatonicPitch(3, 'c'), Duration(1, 8))
d = Note(DiatonicPitch(3, 'd'), Duration(1, 8))
tuplet = Tuplet(Duration(1, 8), 3, [a, b, c, d])
print(tuplet)
tuplet.reverse()
print(tuplet)
notes = tuplet.get_all_notes()
assert notes is not None
assert len(notes) == 4
assert notes[0].diatonic_pitch == DiatonicPitch(3, 'd')
assert notes[1].diatonic_pitch == DiatonicPitch(3, 'c')
assert notes[2].diatonic_pitch == DiatonicPitch(3, 'b')
assert notes[3].diatonic_pitch == DiatonicPitch(3, 'a')
assert notes[0].relative_position == Offset(0)
assert notes[1].relative_position == Offset(3, 32)
assert notes[2].relative_position == Offset(3, 16)
assert notes[3].relative_position == Offset(9, 32)
def test_simple_beam_reverse(self):
print('test simple beam reverse')
a = Note(DiatonicPitch(3, 'a'), Duration(1, 8))
b = Note(DiatonicPitch(3, 'b'), Duration(1, 8))
c = Note(DiatonicPitch(3, 'c'), Duration(1, 8))
d = Note(DiatonicPitch(3, 'd'), Duration(1, 8))
beam = Beam([a, b, c, d])
print(beam)
beam.reverse()
print(beam)
notes = beam.get_all_notes()
assert notes is not None
assert len(notes) == 4
assert notes[0].diatonic_pitch == DiatonicPitch(3, 'd')
assert notes[1].diatonic_pitch == DiatonicPitch(3, 'c')
assert notes[2].diatonic_pitch == DiatonicPitch(3, 'b')
assert notes[3].diatonic_pitch == DiatonicPitch(3, 'a')
assert notes[0].relative_position == Offset(0)
assert notes[1].relative_position == Offset(1, 8)
assert notes[2].relative_position == Offset(1, 4)
assert notes[3].relative_position == Offset(3, 8)
def test_is_equal(self):
logging.debug('Start test_is_equal')
note1 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8))
note2 = Note(DiatonicPitch.parse('C:5'), Duration(1, 8))
lower_policy_context = TestEqualPitchConstraint.policy_creator(
ModalityType.Major, DiatonicTone('G'), 'tV', 'C:2', 'C:8')
lower_context_note_a = ContextualNote(
lower_policy_context,
Note(DiatonicPitch.parse('F#:6'), Duration(1, 8)))
lower_context_note_b = ContextualNote(lower_policy_context)
parameter_map = dict([(note1, lower_context_note_a),
(note2, lower_context_note_b)])
parameter_map = PMap(parameter_map)
policy = EqualPitchConstraint([note1, note2])
result = policy.values(parameter_map, note2)
actual_note = next(iter(result))
print('test_is_equal; note = {0}'.format(actual_note))
assert actual_note.diatonic_pitch == DiatonicPitch.parse("F#:6")
assert actual_note.base_duration == Duration(1, 8)
parameter_map[note2].note = actual_note
assert policy.verify(parameter_map) is True
logging.debug('End test_is_equal')
def test_simple_major_scale_descent_two_steps(self):
logging.debug('Start test_simple_major_scale_descent_two_steps')
upper_context_notes = list()
for s in ['C:6', 'A:5', 'F:5', 'D:5', 'B:4']:
upper_context_notes.append(Note(DiatonicPitch.parse(s), Duration(1, 8)))
lower_policy_context = TestPitchStepConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV',
'C:2', 'C:8')
lower_context_notes = list()
for s in range(0, len(upper_context_notes)):
lower_context_notes.append(ContextualNote(lower_policy_context))
lower_context_notes[0].note = Note(DiatonicPitch.parse("E:5"), Duration(1, 8))
parameter_map = dict()
policies = []
for s, sp in zip(upper_context_notes, lower_context_notes):
parameter_map[s] = sp
for i in range(0, len(upper_context_notes) - 1):
policies.append(PitchStepConstraint(upper_context_notes[i], upper_context_notes[i + 1], 2,
PitchStepConstraint.Down))
answers = ['C:5', 'A:4', 'F#:4', 'D:4']
for policy, answer in zip(policies, answers):
result = policy.values(parameter_map, policy.note_two)
note = next(iter(result))
print(note)
assert str(note.diatonic_pitch) == answer
parameter_map[policy.note_two].note = note
assert policy.verify(parameter_map)
logging.debug('End test_simple_major_scale_descent_two_steps')
def test_another_book_example(self):
# Creating a simple line of 2 eighth notes a quarter note and a half note.
vnote0 = Note(DiatonicPitch(4, 'a'), Duration(1, 8))
vnote1 = Note(DiatonicPitch(4, 'b'), Duration(1, 8))
vnote2 = Note(DiatonicPitch(4, 'c'), Duration(1, 4))
vnote3 = Note(DiatonicPitch(4, 'd'), Duration(1, 2))
line = Line([vnote0, vnote1, vnote2, vnote3])
AbstractNote.print_structure(line)
def test_nested_notes(self):
note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 8))
note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 8))
note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16))
sub_beam = Beam([note1, note2, note3])
beam = Beam()
beam.append(Note(DiatonicPitch(4, 'f'), Duration(1, 8)))
beam.append(sub_beam)
beam.append(Note(DiatonicPitch(4, 'g'), Duration(1, 8)))
print(beam)
notes = beam.get_all_notes()
assert len(notes) == 5
assert notes[0].diatonic_pitch == DiatonicPitch(4, 'f')
assert notes[1].diatonic_pitch == DiatonicPitch(4, 'c')
assert notes[2].diatonic_pitch == DiatonicPitch(4, 'd')
assert notes[3].diatonic_pitch == DiatonicPitch(4, 'e')
assert notes[4].diatonic_pitch == DiatonicPitch(4, 'g')
assert notes[0].relative_position == Offset(0)
assert notes[1].relative_position == Offset(0)
assert notes[2].relative_position == Offset(1, 16)
assert notes[3].relative_position == Offset(1, 8)
assert notes[4].relative_position == Offset(9, 32)
TestBeam.print_all_notes(notes)
notes = sub_beam.get_all_notes()
TestBeam.print_all_notes(notes)
b = Beam()
b.append(beam)
notes = sub_beam.get_all_notes()
TestBeam.print_all_notes(notes)
assert notes[0].duration == Duration(1, 32)
assert str(notes[0].diatonic_pitch) == 'C:4'
sub_beam_prime = sub_beam.clone()
notes = sub_beam_prime.get_all_notes()
TestBeam.print_all_notes(notes)
assert notes[0].duration == Duration(1, 8)
assert str(notes[0].diatonic_pitch) == 'C:4'
beam_prime = beam.clone()
notes = beam_prime.get_all_notes()
TestBeam.print_all_notes(notes)
assert notes[0].duration == Duration(1, 8)
assert str(notes[0].diatonic_pitch) == 'F:4'
b_prime = b.clone()
notes = b_prime.get_all_notes()
TestBeam.print_all_notes(notes)
assert notes[0].duration == Duration(1, 16)
assert str(notes[0].diatonic_pitch) == 'F:4'
def test_simple_cross_tonality(self):
logging.debug('Start test_simple_cross_tonality')
# upper_policy_context = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('C'), 'tIV',
# 'C:2', 'C:8')
lower_policy_context_1 = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV',
'C:2', 'C:8')
lower_policy_context_2 = TestStepSequenceConstraint.policy_creator(ModalityType.Major, DiatonicTone('B'), 'tV',
'C:2', 'C:8')
upper_pitch_txts = ['C:5', 'D:5', 'E:5', 'F:5']
tonalities = [lower_policy_context_1, lower_policy_context_1, lower_policy_context_2, lower_policy_context_2]
differentials = [1, 1, 1]
actors = list()
p_map = dict()
for i in range(0, len(upper_pitch_txts)):
upper_note = Note(DiatonicPitch.parse(upper_pitch_txts[i]), Duration(1, 8))
lower_note = ContextualNote(tonalities[i])
actors.append(upper_note)
p_map[upper_note] = lower_note
policy = StepSequenceConstraint(actors, differentials)
p_map[actors[0]].note = Note(DiatonicPitch.parse('B:5'), Duration(1, 8))
answers = ['B:6', 'C:6', 'C#:6', 'D#:6']
for i in range(1, len(actors)):
notes = policy.values(p_map, actors[i])
for note in notes:
print(note.diatonic_pitch)
assert str(next(iter(notes)).diatonic_pitch) == answers[i]
print("------")
upper_pitch_txts = ['F#:5', 'E:5', 'D:5', 'C:5']
tonalities = [lower_policy_context_1, lower_policy_context_1, lower_policy_context_2, lower_policy_context_2]
differentials = [-1, -1, -1]
actors = list()
p_map = dict()
for i in range(0, len(upper_pitch_txts)):
upper_note = Note(DiatonicPitch.parse(upper_pitch_txts[i]), Duration(1, 8))
lower_note = ContextualNote(tonalities[i])
actors.append(upper_note)
p_map[upper_note] = lower_note
policy = StepSequenceConstraint(actors, differentials)
p_map[actors[0]].note = Note(DiatonicPitch.parse('F#:6'), Duration(1, 8))
answers = ['F#:6', 'E:6', 'D#:6', 'C#:6']
for i in range(1, len(actors)):
notes = policy.values(p_map, actors[i])
for note in notes:
print(note.diatonic_pitch)
assert str(next(iter(notes)).diatonic_pitch) == answers[i]
print("------")
logging.debug('End test_simple_cross_tonality')
def test_line_convert(self):
note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 16))
note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 16))
note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16))
note4 = Note(DiatonicPitch(4, 'f'), Duration(1, 16))
beam = Beam([note1, note2, note3, note4])
line = Line(beam)
ScoreToMidiConverter.convert_line(line, 'line_output_file.mid')
TestScoreToMidiConverter.read_midi_file('line_output_file.mid')
def test_odd_structure(self):
print('test odd structure')
n1 = Note(DiatonicPitch(4, 'c'), Duration(1, 12))
n2 = Note(DiatonicPitch(4, 'c'), Duration(1, 12))
from structure.tuplet import Tuplet
tuplet = Tuplet(Duration(1, 12), 1, [n1, n2])
n3 = Note(DiatonicPitch(4, 'd'), Duration(1, 8))
beam = Beam([tuplet, n3])
AbstractNote.print_structure(beam)
def test_score_book_example(self):
score = Score()
catalogue = InstrumentCatalog.instance()
score.add_instrument_voice(
InstrumentVoice(catalogue.get_instrument("violin")))
score.tempo_sequence.add(TempoEvent(Tempo(60), Position(0)))
score.time_signature_sequence.add(
TimeSignatureEvent(TimeSignature(4, Duration(1, 4)), Position(0)))
violin_voice = score.get_instrument_voice("violin")[0]
note_1 = Note(DiatonicPitch(4, 'A'), Duration(1, 4))
note_2 = Note(DiatonicPitch(5, 'C'), Duration(1, 8))
note_3 = Note(DiatonicPitch(5, 'B'), Duration(1, 8))
note_4 = Note(DiatonicPitch(5, 'D'), Duration(1, 4))
note_5 = Note(DiatonicPitch(5, 'E'), Duration(1, 8))
note_6 = Note(DiatonicPitch(5, 'D'), Duration(1, 8))
note_7 = Note(DiatonicPitch(4, 'G'), Duration(1, 4))
note_8 = Note(DiatonicPitch(4, 'C'), Duration(1, 4))
line = Line(
[note_1, note_2, note_3, note_4, note_5, note_6, note_7, note_8])
violin_voice.voice(0).pin(line)
smc = ScoreToMidiConverter(score)
smc.create('book_example_midi_file.mid', True)
ScoreToMidiConverter.convert_line(line,
'line_example_midi_file.mid',
Tempo(90, Duration(1, 8)),
instrument_name='violin')
def test_motif_book_example(self):
s = Beam()
s.append(Note(DiatonicPitch.parse('C:4'), Duration(1, 8)))
s.append(Note(DiatonicPitch.parse('D:4'), Duration(1, 8)))
s.append(Note(DiatonicPitch.parse('C:4'), Duration(1, 8)))
s.append(Note(DiatonicPitch.parse('F#:4'), Duration(1, 8)))
notes = s.get_all_notes()
c = [
EqualPitchConstraint([notes[0], notes[2]]),
NotEqualPitchConstraint([notes[1], notes[3]])
]
m = Motif(s, c, 'A')
cs = Beam()
cs.append(Note(DiatonicPitch.parse('C:5'), Duration(1, 8)))
cs.append(Note(DiatonicPitch.parse('D:5'), Duration(1, 8)))
cs.append(Note(DiatonicPitch.parse('C:5'), Duration(1, 8)))
cs.append(Note(DiatonicPitch.parse('F#:5'), Duration(1, 8)))
c_motif = m.copy_to(cs.get_all_notes()[0])
assert 'A' == c_motif.name
assert len(c_motif.actors) == len(notes)
assert len(c_motif.constraints) == len(c)
assert isinstance(c_motif.constraints[0], EqualPitchConstraint)
assert c_motif.constraints[0].actors[0] == c_motif.actors[0]
assert c_motif.constraints[0].actors[1] == c_motif.actors[2]
assert isinstance(c_motif.constraints[1], NotEqualPitchConstraint)
assert c_motif.constraints[1].actors[0] == c_motif.actors[1]
assert c_motif.constraints[1].actors[1] == c_motif.actors[3]
def recursive_dilate(self, strct, new_to_old_map):
if isinstance(strct, Note):
d = strct.base_duration.duration / strct.contextual_reduction_factor
n = Note(strct.diatonic_pitch, Duration(d * self.dilation_factor),
strct.num_dots)
new_to_old_map[n] = strct
return n
else:
collect = list()
for s in strct.sub_notes:
collect.append(self.recursive_dilate(s, new_to_old_map))
if isinstance(strct, Beam):
b = Beam(collect)
new_to_old_map[b] = strct
return b
elif isinstance(strct, Tuplet):
t = Tuplet(strct.unit_duration * self.dilation_factor,
strct.unit_duration_factor, collect)
new_to_old_map[t] = strct
return t
elif isinstance(strct, Line):
line = Line()
new_to_old_map[line] = strct
for s in collect:
line.pin(
s, new_to_old_map[s].relative_position *
self.dilation_factor)
return line
def _build_p_map_dict(self, partial_pitch_results=None):
actors = OrderedSet()
for p in self.pitch_constraints:
actors = actors.union(p.actors)
d = OrderedDict()
for note in actors:
hc = self.hct[note.get_absolute_position().position]
if hc is None:
raise Exception(
'Cannot locate harmonic context for note \'{0}\''.format(
note))
contextual = ContextualNote(PolicyContext(hc, self.pitch_range))
d[note] = contextual
if partial_pitch_results is not None:
for k, v in partial_pitch_results.items():
if not isinstance(k, Note):
raise Exception(
'key of partial_pitch_results must be a Note.')
if not isinstance(v, DiatonicPitch):
raise Exception(
'value of partial_pitch_results must be a DiatonicPitch.'
)
if k not in d:
raise Exception(
'Note \'{0}\' of partial result is not a constraint actor.'
.format(k))
d[k].note = Note(v, k.base_duration, k.num_dots)
return d
def build_line(note_spec_list):
note_list = list()
for spec in note_spec_list:
pitch = DiatonicPitch.parse(spec[0])
n = Note(pitch, Duration(spec[1][0], spec[1][1]))
note_list.append(n)
return Line(note_list)
def test_non_scale_note(self):
logging.debug('Start test_non_scale_note')
note = Note(DiatonicPitch.parse("Bb:4"), Duration(1, 4))
policy = FixedPitchConstraint(note, DiatonicPitch.parse("Ab:5"))
policy_context = TestFixedPitchConstraint.policy_creator(
ModalityType.Major, DiatonicTone('C'), 'tIV', 'C:2', 'C:8')
contextual_note = ContextualNote(policy_context)
p_map = PMap()
p_map[note] = contextual_note
v_result = policy.values(p_map, note)
result = next(iter(v_result))
print('test_non_scale_note note= {0}'.format(result))
assert result.diatonic_pitch == DiatonicPitch.parse("Ab:5")
assert result.base_duration == Duration(1, 4)
contextual_note.note = result
result = policy.verify(p_map)
assert result is True
logging.debug('end test_non_scale_note')
def test_add_post_beam_note(self):
print('test add post beam note.')
note1 = Note(DiatonicPitch(4, 'c'), Duration(1, 8))
note2 = Note(DiatonicPitch(4, 'd'), Duration(1, 8))
note3 = Note(DiatonicPitch(4, 'e'), Duration(1, 16))
sub_beam = Beam([note1, note2, note3])
parent_beam = Beam()
parent_beam.append(Note(DiatonicPitch(4, 'f'), Duration(1, 8)))
parent_beam.append(sub_beam)
print(parent_beam)
note4 = Note(DiatonicPitch(4, 'e'), Duration(1, 16))
sub_beam.append(note4)
print(parent_beam)
def test_is_chordal(self):
logging.debug('Start test_is_chordal')
upper_context_note = Note(DiatonicPitch.parse('F:5'), Duration(1, 4))
lower_policy_context = TestChordalToneConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV',
'C:2', 'C:8')
lower_context_note = ContextualNote(lower_policy_context)
parameter_map = dict([(upper_context_note, lower_context_note)])
policy = ChordalPitchConstraint(upper_context_note)
v_result = policy.values(parameter_map, upper_context_note)
results = {DiatonicTone('D'), DiatonicTone('F#'), DiatonicTone('A')}
for note in v_result:
print('test_is_chordal; note = {0}'.format(note))
tone = note.diatonic_pitch.diatonic_tone
octave = note.diatonic_pitch.octave
assert tone in results
assert octave in range(2, 9)
assert len(v_result) == 6 * 3
for note in v_result:
parameter_map[upper_context_note].note = note
assert policy.verify(parameter_map) is True
logging.debug('End test_is_chordal')
def test_enharmonic_fixed_tone(self):
logging.debug('Start test_enharmonic_fixed_tone')
note = Note(DiatonicPitch.parse("C:5"), Duration(1, 4))
policy = FixedToneConstraint(note, DiatonicToneCache.get_tone("Bbb"))
lower_policy_context = TestFixedToneConstraint.policy_creator(ModalityType.Major, DiatonicTone('G'), 'tV',
'C:2', 'C:8')
lower_contextual_note = ContextualNote(lower_policy_context)
m = dict([(note, lower_contextual_note)])
v_result = policy.values(m, note)
assert len(v_result) == 6
for note in v_result:
print('test_simple_fixed_tone pitch = {0}'.format(note.diatonic_pitch))
assert note.diatonic_pitch.diatonic_tone == DiatonicToneCache.get_tone('A')
assert note.base_duration == Duration(1, 4)
lower_contextual_note.note = note
result = policy.verify(m)
assert result is True
lower_contextual_note.note = None
logging.debug('End test_enharmonic_fixed_tone')
def values(self, p_map, v_note):
if v_note != self.actor_note:
raise Exception("Illegal v_note {0} for constraint".format(v_note))
if p_map[v_note].note is not None:
if p_map[v_note].note.diatonic_pitch.chromatic_distance in (p.chromatic_distance for p in self.pitches):
return OrderedSet[p_map[v_note].note]
raise Exception('Fixed Pitch Select Set Constraint Violated has {0} not in pitch set'.format(
p_map[v_note].note.diatonic_pitch))
# Return all pitches (self.pitches) except though, for each
# select a representation closest to the target tonality, if it exists.
tonality = p_map[self.actor_note].policy_context.harmonic_context.tonality
result_pitches = []
for pitch in self.pitches:
found_pitch = pitch
for p in pitch.enharmonics():
if p.diatonic_tone in tonality.annotation:
found_pitch = p
break
result_pitches.append(found_pitch)
result = OrderedSet()
for p in result_pitches:
result.add(Note(p, self.actor_note.base_duration, self.actor_note.num_dots))
return result