khodowany
200 lines
13 KiB
Python
200 lines
13 KiB
Python
import tests.production_fixtures
|
|
import argparse
|
|
import copy
|
|
import dataclasses
|
|
import fractions
|
|
import pathlib
|
|
import tempfile
|
|
import unittest
|
|
import unittest.mock
|
|
import generator.__main__
|
|
import generator.arrange.generate
|
|
import generator.fretboard
|
|
import generator.harmony
|
|
import generator.model
|
|
import generator.parts
|
|
import generator.playback
|
|
import generator.scales.library
|
|
import generator.scales.selection
|
|
import generator.scales.timeline
|
|
import generator.score
|
|
import generator.solo.analysis
|
|
import generator.solo.arrangement
|
|
import generator.solo.composer
|
|
import generator.solo.notation
|
|
import generator.solo.placement
|
|
import generator.solo.report
|
|
import generator.solo.sequences
|
|
import generator.solo.types
|
|
import tests.rhythm_fixtures
|
|
import tests.scale_fixtures
|
|
import tests.solo_fixtures
|
|
import tests.test_musicxml
|
|
|
|
def song(meter=4, count=6, chords=('Dm7', 'G7', 'CM7')):
|
|
document = tests.test_musicxml.parse(tests.test_musicxml.xml_score(''.join((tests.test_musicxml.xml_note(step, 1, 'quarter') for step in ('C', 'D', 'E', 'G')))))
|
|
first = document['staves'][0]['measures'][0]
|
|
measures = []
|
|
for index in range(count):
|
|
measure = copy.deepcopy(first)
|
|
measure.update(id=f'measure_{index + 1}', number=str(index + 1), duration=generator.model.rational(meter), meter={'groups': [{'beats': [meter], 'unit': 4}]}, time_signature=f'{meter}/4')
|
|
measure['voices'][0]['notes'] = [generator.model.make_event(f'source_{index}_{beat}', fractions.Fraction(beat), fractions.Fraction(1), 'note', [{'letter': 'cdefg'[beat % 5], 'octave': 4, 'alter': 0}]) for beat in range(meter)]
|
|
measure['harmonies'] = [{**generator.harmony.parse_symbol(chords[index % len(chords)]), 'id': f'h_{index}', 'onset': generator.model.rational(0)}] if chords else []
|
|
for harmony in measure['harmonies']:
|
|
harmony['symbol'] = generator.harmony.symbol(harmony)
|
|
measures.append(measure)
|
|
document['staves'][0]['measures'] = measures
|
|
return generator.parts.prepare_document(document)
|
|
|
|
def compose(document, part='acoustic', cutoff=None):
|
|
analysis = generator.solo.analysis.analyze(document)
|
|
measures = document['staves'][0]['measures']
|
|
end = sum((generator.model.fraction(m['duration']) for m in measures)) if cutoff is None else cutoff
|
|
return generator.solo.composer.compose(analysis, measures, part, end, scales=tests.scale_fixtures.library(), sequences=tests.solo_fixtures.library(), rhythms=tests.rhythm_fixtures.library())
|
|
|
|
class SoloTests(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
tests.production_fixtures.install(self)
|
|
|
|
def test_catalog_intervals_and_negative_scale_indices(self):
|
|
library = generator.solo.sequences.load_library(pathlib.Path('data/sequences'))
|
|
self.assertEqual({k: len(v) for k, v in library.paths.items()}, {2: 14, 3: 196, 4: 2744})
|
|
self.assertEqual(len({s.steps for s in library.paths[4]}), 2744)
|
|
self.assertTrue(all((s.offsets()[-1] == 0 for s in library.connecting(3, 0))))
|
|
scale = tests.scale_fixtures.library().scale('major', 6, 'D')
|
|
pitches = [generator.solo.types.scale_pitch(scale, i) for i in (2, 3, 5, 4)]
|
|
self.assertEqual([p.label() for p in pitches], ['F4', 'G4', 'Bb4', 'A4'])
|
|
self.assertEqual(generator.solo.types.scale_pitch(scale, -1).label(), 'C4')
|
|
self.assertEqual(generator.solo.types.scale_pitch(scale, -8).label(), 'C3')
|
|
self.assertEqual(generator.solo.types.scale_pitch(scale, 7).label(), 'D5')
|
|
diminished = tests.scale_fixtures.library().scale('harmonic_minor', 7, 'C')
|
|
self.assertEqual(generator.solo.types.scale_pitch(diminished, 6).label(), 'Bbb4')
|
|
|
|
def test_invalid_sequences_fail_with_source(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = pathlib.Path(directory)
|
|
with self.assertRaisesRegex(ValueError, 'empty or missing'):
|
|
generator.solo.sequences.load_library(root)
|
|
path = root / '2_4/0001.xml'
|
|
path.parent.mkdir()
|
|
path.write_text(tests.test_musicxml.xml_score(tests.test_musicxml.xml_note()))
|
|
with self.assertRaisesRegex(ValueError, '0001.xml.*2/4'):
|
|
generator.solo.sequences.load_library(root)
|
|
for steps in ((0,), (8,), (), (1, 1, 1, 1)):
|
|
with self.assertRaisesRegex(ValueError, 'invalid'):
|
|
generator.solo.sequences.Library((generator.solo.sequences.Sequence('bad', steps),))
|
|
|
|
def test_ties_are_one_attack_but_repeated_notes_are_two(self):
|
|
content = tests.test_musicxml.xml_note(duration=1, kind='quarter', extra='<tie type="start"/>')
|
|
content += tests.test_musicxml.xml_note(duration=1, kind='quarter', extra='<tie type="stop"/>')
|
|
content += tests.test_musicxml.xml_note(duration=2, kind='half')
|
|
document = tests.test_musicxml.parse(tests.test_musicxml.xml_score(content))
|
|
attacks = generator.solo.analysis.attacks(document)
|
|
self.assertEqual([(n.start, n.end) for n in attacks], [(0, 2), (2, 4)])
|
|
self.assertEqual(len(attacks[0].sources), 2)
|
|
self.assertEqual(attacks[0].pitch, attacks[1].pitch)
|
|
|
|
def test_held_pitch_checked_across_every_collection(self):
|
|
document = song(count=2, chords=('CM7', 'DmM7'))
|
|
choices = generator.scales.selection.select(generator.scales.timeline.read(document['staves'][0]), generator.scales.timeline.Solo(0, 8, 'solo'), tests.scale_fixtures.library())
|
|
self.assertIn(0, generator.solo.types.permitted(choices, 0, 4))
|
|
self.assertNotIn(0, generator.solo.types.permitted(choices, 3, 5))
|
|
self.assertIn(2, generator.solo.types.permitted(choices, 3, 5))
|
|
self.assertFalse(generator.solo.types.permitted(choices, 7, 9))
|
|
|
|
def test_no_harmony_is_silence_and_conflict_is_an_error(self):
|
|
result = compose(song(chords=()))
|
|
self.assertFalse(result.notes())
|
|
with self.assertRaisesRegex(ValueError, 'source measure 1.*No exact match'):
|
|
compose(song(chords=('A13b9',)))
|
|
|
|
def test_microtones_are_not_rounded_into_the_catalog(self):
|
|
with self.assertRaisesRegex(ValueError, 'semitones'):
|
|
generator.solo.types.Pitch('c', fractions.Fraction(1, 2), 4)
|
|
|
|
def test_pickup_cutoff_is_reserved_before_composition(self):
|
|
result = compose(song(count=6), 'electric', fractions.Fraction(43, 2))
|
|
self.assertTrue(all((n.end <= fractions.Fraction(43, 2) for n in result.notes())))
|
|
self.assertEqual(result.phrases[-1].end, fractions.Fraction(43, 2))
|
|
|
|
def test_time_aware_placement_does_not_penalize_absolute_frets(self):
|
|
p = generator.solo.types.Pitch('c', fractions.Fraction(), 4)
|
|
before = generator.solo.types.Note(0, 1, p, position=generator.fretboard.TabPosition(2, 1, 60))
|
|
after = generator.solo.types.Note(1, 2, p, position=generator.fretboard.TabPosition(2, 6, 65))
|
|
self.assertGreater(generator.solo.placement.travel(before, after, fractions.Fraction(180)), generator.solo.placement.travel(before, after, fractions.Fraction(90)))
|
|
shifted = dataclasses.replace(before, position=generator.fretboard.TabPosition(2, 8, 67))
|
|
current = dataclasses.replace(after, position=generator.fretboard.TabPosition(2, 13, 72))
|
|
self.assertEqual(generator.solo.placement.travel(before, after, fractions.Fraction(120)), generator.solo.placement.travel(shifted, current, fractions.Fraction(120)))
|
|
|
|
def test_notation_ties_cross_bars_and_keep_string_without_new_attack(self):
|
|
document = song(count=2, chords=('CM7',))
|
|
note = generator.solo.types.Note(fractions.Fraction(3), fractions.Fraction(6), generator.solo.types.Pitch('e', fractions.Fraction(), 4), position=generator.fretboard.TabPosition(2, 5, 64))
|
|
document['staves'][0]['measures'] = generator.solo.notation.measures(document['staves'][0]['measures'], (note,), 'test')
|
|
document['staves'][0]['tablature'] = True
|
|
generator.model.validate_document(document)
|
|
events = generator.playback.compile_timeline(document)['events']
|
|
self.assertEqual(len(events), 1)
|
|
self.assertEqual(generator.model.fraction(events[0]['duration']), 3)
|
|
self.assertEqual(generator.model.fraction(events[0]['pitch']), 64)
|
|
|
|
def test_rational_motif_rhythm_has_visible_tuplets_and_exact_playback(self):
|
|
document = song(count=1, chords=('CM7',))
|
|
pitch = generator.solo.types.Pitch('e', fractions.Fraction(), 4)
|
|
notes = tuple((generator.solo.types.Note(fractions.Fraction(i, 3), fractions.Fraction(i + 1, 3), pitch, position=generator.fretboard.TabPosition(2, 5, 64)) for i in range(3)))
|
|
replacement = generator.solo.notation.measures(document['staves'][0]['measures'], notes, 'triplet')
|
|
generator.solo.notation.replace_region(document, 0, replacement)
|
|
generator.model.validate_document(document)
|
|
self.assertEqual(document['staves'][0]['tuplets'][0]['note_count'], 3)
|
|
self.assertEqual(document['staves'][0]['tuplets'][0]['space_count'], 2)
|
|
timeline = generator.playback.compile_timeline(document)
|
|
self.assertEqual([generator.model.fraction(e['duration']) for e in timeline['events']], [fractions.Fraction(1, 3)] * 3)
|
|
|
|
def test_source_tempo_and_fallback_are_quarter_note_rates(self):
|
|
source = song()
|
|
self.assertEqual(generator.solo.analysis.analyze(source).tempo, 120)
|
|
source['staves'][0]['measures'][0]['tempos'] = [{'onset': generator.model.rational(0), 'written': {'type': 'half', 'dots': 0}, 'bpm': generator.model.rational(75)}]
|
|
self.assertEqual(generator.solo.analysis.analyze(source).tempo, 150)
|
|
|
|
def test_harmony_carries_into_the_solo_until_an_explicit_no_chord(self):
|
|
source = song(count=2, chords=())
|
|
source['staves'][0]['measures'][1]['harmonies'] = [{'id': 'nc', 'onset': generator.model.rational(0), 'kind': 'none', 'symbol': 'N.C.'}]
|
|
result = generator.solo.composer.compose(generator.solo.analysis.analyze(source), source['staves'][0]['measures'], 'acoustic', 8, initial=generator.harmony.parse_symbol('CM7'), scales=tests.scale_fixtures.library(), sequences=tests.solo_fixtures.library(), rhythms=tests.rhythm_fixtures.library())
|
|
self.assertTrue(result.notes())
|
|
self.assertTrue(all((n.end <= 4 for n in result.notes())))
|
|
|
|
def test_conflict_preserves_published_assets(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = pathlib.Path(directory)
|
|
(root / 'data/songs').mkdir(parents=True)
|
|
path = root / 'data/songs/conflict.xml'
|
|
path.write_text(tests.test_musicxml.xml_score(tests.test_musicxml.xml_note()))
|
|
output = root / 'assets'
|
|
output.mkdir()
|
|
(output / 'accepted').write_text('previous build')
|
|
args = argparse.Namespace(data_dir=root / 'data', output_dir=output, static_assets_dir=pathlib.Path('package/assets'), check=False)
|
|
with unittest.mock.patch('generator.rhythm.load_library', return_value=tests.rhythm_fixtures.library()), unittest.mock.patch('generator.scales.library.load_library', return_value=tests.scale_fixtures.library()), unittest.mock.patch('generator.solo.sequences.load_library', return_value=tests.solo_fixtures.library()), unittest.mock.patch('generator.solo.composer.compose', side_effect=ValueError('No exact match within the permitted catalog')):
|
|
with self.assertRaisesRegex(ValueError, 'conflict.xml.*No exact match'):
|
|
generator.__main__.generate_assets(args)
|
|
self.assertEqual([p.name for p in output.iterdir()], ['accepted'])
|
|
self.assertEqual((output / 'accepted').read_text(), 'previous build')
|
|
|
|
def test_unrelated_song_does_not_change_an_accepted_solo(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = pathlib.Path(directory)
|
|
source, output = (root / 'songs', root / 'assets/songs')
|
|
source.mkdir()
|
|
xml = tests.test_musicxml.xml_score('<harmony><root><root-step>C</root-step></root><kind>major-seventh</kind></harmony>' + ''.join((tests.test_musicxml.xml_note(step, 1, 'quarter') for step in ('C', 'D', 'E', 'G'))))
|
|
(source / 'accepted.xml').write_text(xml)
|
|
resources = {'rhythms': tests.rhythm_fixtures.library(), 'scales': tests.scale_fixtures.library(), 'sequences': tests.solo_fixtures.library()}
|
|
generator.arrange.generate.generate_performance_scores(source, output, **resources)
|
|
before = {p: p.read_bytes() for p in root.joinpath('assets').rglob('*') if p.is_file()}
|
|
(source / 'another.xml').write_text(xml.replace('Fixture', 'Another'))
|
|
generator.arrange.generate.generate_performance_scores(source, output, **resources)
|
|
self.assertEqual(before, {p: p.read_bytes() for p in before})
|
|
|
|
def test_sequence_sources_are_packaged_and_tracked(self):
|
|
self.assertIn('"data/sequences/**/*.xml"', pathlib.Path('conanfile.py').read_text())
|
|
self.assertIn("'data/sequences/**/*.xml'", pathlib.Path('.gitea/workflows/ci.yml').read_text())
|
|
self.assertIn('data/*.xml', pathlib.Path('cmake/zero.cmake').read_text())
|