khodowany
155 lines
10 KiB
Python
155 lines
10 KiB
Python
"""Construction and permission contracts; listening remains the taste test."""
|
|
import dataclasses
|
|
import pathlib
|
|
import unittest
|
|
from fractions import Fraction as F
|
|
|
|
from generator.solo import analysis, composer, drafts, harmonic, leads, references, realization, scoring, types
|
|
import tests.test_solo as solo_fixture
|
|
import tests.test_solo_passages as passage_fixture
|
|
import tests.test_solo_development as fixture
|
|
import tests.rhythm_fixtures
|
|
import tests.scale_fixtures
|
|
import tests.solo_fixtures
|
|
|
|
class ChromaticApproachTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.harmony = harmonic.Harmony(passage_fixture.choices(('C7', 'FM7')))
|
|
self.approach = dataclasses.replace(fixture.note(F(7, 2), 4, 'g', -1), event_id='approach')
|
|
self.target = dataclasses.replace(fixture.note(4, 6, 'f'), event_id='resolution')
|
|
self.treatment = types.HarmonicTreatment('test', 'chromatic_approach', 66, F(7, 2), F(4), 65, F(4), F(), 'approach', 'resolution')
|
|
def test_approach_resolves_across_chord_boundary_without_remapping_scale(self):
|
|
self.assertFalse(self.harmony.evaluate((self.approach, self.target), complete=True).valid)
|
|
result = self.harmony.evaluate((self.approach, self.target), (self.treatment,), complete=True)
|
|
self.assertTrue(result.valid, result.error)
|
|
self.assertFalse(result.pending)
|
|
report = self.harmony.describe((self.approach, self.target), (self.treatment,))
|
|
self.assertEqual((report[0]['function'], report[0]['motion']), ('outside_collection', 'chromatic_approach'))
|
|
def test_pending_approach_survives_computational_boundary(self):
|
|
partial = self.harmony.evaluate((self.approach,), (self.treatment,), until=F(4))
|
|
self.assertTrue(partial.valid)
|
|
self.assertEqual(partial.pending, (self.treatment,))
|
|
self.assertFalse(self.harmony.evaluate((self.approach,), (self.treatment,), until=F(5)).valid)
|
|
def test_tie_partition_does_not_change_approach_or_sustain(self):
|
|
split = (dataclasses.replace(self.approach, end=F(15, 4)), dataclasses.replace(self.approach, start=F(15, 4), continuation=True, event_id='tie'), dataclasses.replace(self.target, end=F(5)), dataclasses.replace(self.target, start=F(5), continuation=True, event_id='target_tie'))
|
|
whole = (self.approach, self.target)
|
|
self.assertEqual(self.harmony.evaluate(whole, (self.treatment,), complete=True), self.harmony.evaluate(split, (self.treatment,), complete=True))
|
|
self.assertEqual(self.harmony.describe(whole, (self.treatment,)), self.harmony.describe(split, (self.treatment,)))
|
|
self.assertEqual(len(types.sounding_notes(split)), 2)
|
|
def test_labels_cannot_excuse_arbitrary_notes(self):
|
|
cases = [
|
|
(dataclasses.replace(self.approach, start=F(3)), self.target, self.treatment),
|
|
(self.approach, dataclasses.replace(self.target, start=F(9, 2)), self.treatment),
|
|
(self.approach, dataclasses.replace(self.target, pitch=fixture.note(0, 1, 'e').pitch), self.treatment),
|
|
(self.approach, self.target, dataclasses.replace(self.treatment, event='unrelated')),
|
|
(dataclasses.replace(self.approach, role='quote'), self.target, self.treatment),
|
|
(self.approach, self.target, dataclasses.replace(self.treatment, deadline=F(5))),
|
|
]
|
|
for approach, target, treatment in cases:
|
|
with self.subTest(approach=approach, target=target, treatment=treatment):
|
|
self.assertFalse(self.harmony.evaluate((approach, target), (treatment,), complete=True).valid)
|
|
def test_resolution_must_be_chord_member_and_valid_through_its_hold(self):
|
|
nonmember = dataclasses.replace(self.target, pitch=fixture.note(4, 6, 'g').pitch)
|
|
treatment = dataclasses.replace(self.treatment, resolution=67)
|
|
self.assertFalse(self.harmony.evaluate((self.approach, nonmember), (treatment,), complete=True).valid)
|
|
long_approach = dataclasses.replace(self.approach, start=F(2))
|
|
self.assertFalse(self.harmony.evaluate((long_approach, self.target), (dataclasses.replace(self.treatment, start=F(2)),), complete=True).valid)
|
|
def test_approach_spelling_avoids_unnecessary_double_accidentals(self):
|
|
target = fixture.note(0, 1, 'a', -1).pitch
|
|
self.assertEqual(leads.approach_pitch(target, 69).label(), 'A4')
|
|
target = fixture.note(0, 1, 'e').pitch
|
|
self.assertEqual(leads.approach_pitch(target, 63).label(), 'D#4')
|
|
def test_chromatic_spacing_carries_across_passage_boundary(self):
|
|
notes = (dataclasses.replace(self.approach, pitch=fixture.note(0, 1, 'g').pitch), self.target)
|
|
plan = dataclasses.replace(fixture.plan(), end=F(8), release=F(2), target=None, passages=())
|
|
group = types.Transformation('group', '', '', 'answer', F(), F(8), tuple(n.event_id for n in notes), tuple((n.start, n.end) for n in notes), preserves=())
|
|
draft = types.MelodicDraft('spacing', F(), F(8), notes, (group,), ('resolution',), (), (), None, 'answer')
|
|
empty = types.ContinuationState('previous')
|
|
phrase = realization.checked_phrase(plan, draft, notes, (), empty, self.harmony, F(120))
|
|
self.assertIsNotNone(phrase)
|
|
self.assertTrue(leads.chromatic(phrase, empty, self.harmony, F(120)).edits)
|
|
recent = dataclasses.replace(empty, treatments=(dataclasses.replace(self.treatment, start=F(-7, 2)),))
|
|
self.assertFalse(leads.chromatic(phrase, recent, self.harmony, F(120)).edits)
|
|
|
|
class CompleteLeadTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.references = references.load_library(pathlib.Path('data/lead_phrases'))
|
|
cls.source = solo_fixture.song(count=8, chords=('Gm7', 'C7', 'FM7', 'BbM7', 'Em7b5', 'A7', 'Dm7', 'Dm7'))
|
|
cls.context = realization.SearchContext()
|
|
cls.result = cls.compose(cls.context)
|
|
@classmethod
|
|
def compose(cls, context, stage='elaborated'):
|
|
return composer.compose(analysis.analyze(cls.source), cls.source['staves'][0]['measures'], 'acoustic', F(32), scales=tests.scale_fixtures.library(), sequences=tests.solo_fixtures.library(), rhythms=tests.rhythm_fixtures.library(), references=cls.references, context=context, stage=stage)
|
|
def test_complete_tune_precedes_decorations_and_contains_a_return(self):
|
|
for phrase in self.result.phrases:
|
|
self.assertTrue(phrase.draft.lead_identity)
|
|
self.assertTrue(phrase.draft.correspondence)
|
|
self.assertTrue(drafts.contract_valid(phrase.initial, phrase.initial.notes)[0])
|
|
self.assertTrue(drafts.contract_valid(phrase.initial, realization.emitted_notes(phrase))[0])
|
|
source = {n.event_id: n for n in phrase.initial.notes}
|
|
for a, b in phrase.draft.correspondence:
|
|
self.assertEqual(source[a].end - source[a].start, source[b].end - source[b].start)
|
|
self.assertNotIn('diminish', [t.operation for t in phrase.draft.transformations])
|
|
for route in phrase.routes:
|
|
run = peak = 0
|
|
end = None
|
|
for note in route.notes:
|
|
eighth = note.end-note.start == F(1,2)
|
|
run = run+1 if eighth and end == note.start else int(eighth)
|
|
peak = max(peak, run)
|
|
end = note.end
|
|
self.assertGreaterEqual(peak, 4)
|
|
composer.validate(self.result)
|
|
self.assertTrue(all(1 <= n.position.fret <= 12 for n in self.result.notes()))
|
|
def test_same_inputs_and_cache_preserve_music(self):
|
|
second = self.compose(self.context)
|
|
self.assertEqual(self.result.notes(), second.notes())
|
|
self.assertGreater(self.context.diagnostics['cache_hits'], 0)
|
|
def test_lead_evaluation_is_independent_of_computational_partitions(self):
|
|
phrase = self.result.phrases[0]
|
|
whole = phrase.initial.notes
|
|
split = []
|
|
for note in whole:
|
|
cuts = sorted({note.start,note.end} | {F(i,2) for i in range(64) if note.start < F(i,2) < note.end})
|
|
split.extend(dataclasses.replace(note,start=a,end=b,continuation=i>0) for i,(a,b) in enumerate(zip(cuts,cuts[1:])))
|
|
harmony = harmonic.Harmony(self.result.choices)
|
|
self.assertEqual(harmony.describe(whole),harmony.describe(split))
|
|
self.assertEqual(scoring.features(phrase.plan,whole,self.result.choices),scoring.features(phrase.plan,split,self.result.choices))
|
|
self.assertTrue(drafts.contract_valid(phrase.initial,split)[0])
|
|
def test_activity_and_occupancy_are_ranges(self):
|
|
plan = dataclasses.replace(fixture.plan(), start=F(), end=F(4), release=F(), treatment='lead', passages=())
|
|
choices = passage_fixture.choices(('C7',))
|
|
for count in (4, 5, 6):
|
|
notes = tuple(fixture.note(F(4*i, count), F(4*(i+1), count), 'e') for i in range(count))
|
|
values = scoring.features(plan, notes, choices)
|
|
self.assertEqual(values['activity'], 0)
|
|
self.assertEqual(values['occupancy'], 0)
|
|
self.assertFalse(scoring.feasible(plan, (), choices, F(4)))
|
|
def test_new_identity_is_a_joint_rhythm_and_pitch_object(self):
|
|
identities = leads.identities(self.references, types.ContinuationState(''))
|
|
self.assertEqual(len(identities), 12)
|
|
self.assertGreater(len({i.durations for i in identities}), 1)
|
|
self.assertGreater(len({i.degrees for i in identities}), 1)
|
|
for identity in identities:
|
|
self.assertEqual(len(identity.degrees), len(identity.durations))
|
|
self.assertEqual(sum(identity.durations), 4)
|
|
def test_invented_material_can_be_replaced_but_committed_hook_is_preserved(self):
|
|
phrase = self.result.phrases[0]
|
|
changed = tuple(n for n in phrase.initial.notes if n.event_id != phrase.draft.correspondence[0][1])
|
|
self.assertFalse(drafts.contract_valid(phrase.initial, changed)[0])
|
|
def test_missing_harmony_remains_space_with_lead_generation_enabled(self):
|
|
document = solo_fixture.song(count=4, chords=())
|
|
solo = composer.compose(analysis.analyze(document), document['staves'][0]['measures'], 'acoustic', F(16), scales=tests.scale_fixtures.library(), sequences=tests.solo_fixtures.library(), rhythms=tests.rhythm_fixtures.library(), references=self.references)
|
|
self.assertFalse(solo.notes())
|
|
composer.validate(solo)
|
|
def test_vocal_pickup_cutoff_does_not_compress_a_full_ending(self):
|
|
solo = composer.compose(analysis.analyze(self.source), self.source['staves'][0]['measures'], 'electric', F(29), scales=tests.scale_fixtures.library(), sequences=tests.solo_fixtures.library(), rhythms=tests.rhythm_fixtures.library(), references=self.references)
|
|
composer.validate(solo)
|
|
self.assertTrue(all(n.end <= 29 and n.end-n.start >= F(1,2) for n in solo.notes()))
|
|
tail = [n for n in solo.notes() if n.start >= 28]
|
|
self.assertEqual([(n.start,n.end) for n in tail], [(28,29)])
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|