khodowany
98 lines
4.7 KiB
Python
98 lines
4.7 KiB
Python
from __future__ import annotations
|
|
|
|
import fractions
|
|
import pathlib
|
|
|
|
import generator.accompaniment
|
|
import generator.guitar
|
|
import generator.model
|
|
import generator.pitch
|
|
import generator.rhythm
|
|
import generator.score
|
|
|
|
PART_TYPES = ('acoustic', 'electric', 'vocal')
|
|
|
|
def source_paths(directory: pathlib.Path, *, practice: bool = False) -> list[pathlib.Path]:
|
|
if not directory.is_dir():
|
|
raise ValueError(f'{"practice" if practice else "performance"} source directory not found: {directory}')
|
|
paths = sorted(directory.rglob('*.xml'))
|
|
identities = {}
|
|
for path in paths:
|
|
if practice:
|
|
if path.parent != directory or len(path.stem) != 4 or not path.stem.isascii() or not path.stem.isdecimal():
|
|
raise ValueError(f'{path}: practice sources require a four-digit filename directly under data/practice')
|
|
elif path.parent != directory:
|
|
raise ValueError(f'{path}: performance sources belong directly under data/songs')
|
|
identity = path.stem if practice else generator.score.slugify(path.stem)
|
|
if identity in identities:
|
|
raise ValueError(f'{identities[identity]} and {path}: conflicting output path {identity}-acoustic.json')
|
|
identities[identity] = path
|
|
return paths
|
|
|
|
def prepare_document(document: dict, *, practice: bool = False) -> dict:
|
|
validate_source(document, practice=practice)
|
|
return generator.pitch.concert_document(document, octave_transposing=True)
|
|
|
|
def generated_voice(measure: dict, role: str, previous: dict | None) -> list[dict]:
|
|
length = generator.model.fraction(measure['duration'])
|
|
if role == 'rest':
|
|
return [generator.model.make_event('rest', fractions.Fraction(), length, 'rest', written={'type': 'whole', 'dots': 0}) | {'measure_rest': True}]
|
|
if role != 'slash':
|
|
raise ValueError(f'{role} requires a preplanned rhythm')
|
|
events = []
|
|
states = [(fractions.Fraction(), measure['meter'])]
|
|
states.extend((generator.model.fraction(a['onset']), a['meter']) for a in measure.get('attributes', []) if 'meter' in a)
|
|
for index, (onset, meter) in enumerate(states):
|
|
end = states[index + 1][0] if index + 1 < len(states) else length
|
|
beats = generator.model.beat_lengths(meter)
|
|
beat_index = 0
|
|
while onset < end:
|
|
duration = min(beats[beat_index % len(beats)] if beats else end - onset, end - onset)
|
|
event = generator.model.make_event(f'slash-{len(events)}', onset, duration, 'note')
|
|
event['notehead'] = 'slash'
|
|
events.append(event)
|
|
onset += duration
|
|
beat_index += 1
|
|
return events
|
|
|
|
def validate_source(document: dict, *, practice: bool = False) -> None:
|
|
voices = set()
|
|
for measure in generator.score.source_staff(document)['measures']:
|
|
for state in [measure, *measure.get('attributes', [])]:
|
|
if state.get('clef', {}).get('sign') in ('TAB', 'percussion'):
|
|
raise ValueError(f'{measure["id"]}: parts require a pitched, non-TAB source')
|
|
if 'staff_details' in state:
|
|
generator.guitar.validate_tuning(state, measure['id'])
|
|
for voice in measure['voices']:
|
|
voices.add(voice['id'])
|
|
for note in voice['notes']:
|
|
if practice and len(note['pitches']) > 1:
|
|
raise ValueError(f'{measure["id"]}: practice requires a monophonic melody, not chord stacks')
|
|
if any('tablature' in p or 'unpitched' in p for p in note['pitches']):
|
|
raise ValueError(f'{measure["id"]}: authored TAB and percussion are unsupported')
|
|
if practice and len(voices) > 1:
|
|
raise ValueError('practice requires one monophonic voice')
|
|
|
|
def build_measure(source: dict, identifier: str, role: str, part: str, previous: dict | None, label: str = '', rhythm: generator.rhythm.Bar | None = None) -> dict:
|
|
voices = generator.score.copy_source_voices(source, strip_lyrics=role == 'melody') if role in ('vocal', 'melody') else None
|
|
notes = [n for v in voices for n in v['notes']] if voices else generator.accompaniment.realize(source, rhythm, previous) if rhythm is not None else generated_voice(source, role, previous)
|
|
if role in ('melody', 'vocal'):
|
|
for note in notes:
|
|
note['pitches'] = [generator.pitch.shift_pitch(p, 7, 12) for p in note['pitches']]
|
|
result = generator.score.make_measure(identifier, source, [] if voices else notes, section_label=label)
|
|
if voices:
|
|
result['voices'] = voices
|
|
result['transpose'] = {'diatonic': 0, 'chromatic': 0, 'octave_change': -1, 'explicit': True}
|
|
result['clef']['octave_change'] = 0
|
|
for change in result.get('attributes', []):
|
|
change.pop('transpose', None)
|
|
if 'clef' in change:
|
|
change['clef']['octave_change'] = 0
|
|
if part != 'vocal':
|
|
result['clef'] = {'sign': 'G', 'line': 2, 'octave_change': 0}
|
|
result['staff_details'] = {'lines': 5, 'tunings': [], 'capo': 0}
|
|
for change in result.get('attributes', []):
|
|
change.pop('clef', None)
|
|
change.pop('staff_details', None)
|
|
return result
|