khodowany
228 lines
12 KiB
Python
228 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import copy
|
|
from fractions import Fraction
|
|
from typing import Any
|
|
|
|
SCHEMA_VERSION = 2
|
|
MAX_INTEGER = (1 << 63) - 1
|
|
NOTE_TYPES = ('maxima', 'long', 'breve', 'whole', 'half', 'quarter', 'eighth', '16th', '32nd', '64th', '128th', '256th', '512th', '1024th')
|
|
TYPE_LENGTHS = {name: Fraction(32, 2 ** index) for index, name in enumerate(NOTE_TYPES)}
|
|
NATURAL = {'c': 0, 'd': 2, 'e': 4, 'f': 5, 'g': 7, 'a': 9, 'b': 11}
|
|
LETTERS = 'cdefgab'
|
|
MODE_STEPS = {'major': 0, 'ionian': 0, 'dorian': 1, 'phrygian': 2, 'lydian': 3, 'mixolydian': 4, 'minor': 5, 'aeolian': 5, 'locrian': 6}
|
|
|
|
def rational(value: Fraction | int) -> dict[str, int]:
|
|
value = Fraction(value)
|
|
if abs(value.numerator) > MAX_INTEGER or value.denominator > MAX_INTEGER:
|
|
raise ValueError('musical time exceeds the supported 64-bit rational range')
|
|
return {'numerator': value.numerator, 'denominator': value.denominator}
|
|
|
|
def fraction(value: Any) -> Fraction:
|
|
if not isinstance(value, dict) or set(value) != {'numerator', 'denominator'}:
|
|
raise ValueError('musical time must be a numerator/denominator object')
|
|
n, d = value['numerator'], value['denominator']
|
|
if type(n) is not int or type(d) is not int or d <= 0 or abs(n) > MAX_INTEGER or d > MAX_INTEGER:
|
|
raise ValueError('invalid musical time')
|
|
result = Fraction(n, d)
|
|
if rational(result) != value:
|
|
raise ValueError('musical time must be reduced')
|
|
return result
|
|
|
|
def written_length(written: dict) -> Fraction:
|
|
kind, dots = written['type'], written.get('dots', 0)
|
|
if kind not in TYPE_LENGTHS or type(dots) is not int or not 0 <= dots <= 16:
|
|
raise ValueError('invalid written duration or augmentation-dot count (maximum 16)')
|
|
return TYPE_LENGTHS[kind] * (2 - Fraction(1, 2 ** dots))
|
|
|
|
def written_for(length: Fraction) -> dict:
|
|
for name, base in TYPE_LENGTHS.items():
|
|
for dots in range(17):
|
|
if length == base * (2 - Fraction(1, 2 ** dots)):
|
|
return {'type': name, 'dots': dots}
|
|
# Generated rational spans need an explicit time modification, not rounded ticks.
|
|
base = next((name for name, size in TYPE_LENGTHS.items() if size <= length), '1024th')
|
|
return {'type': base, 'dots': 0, 'ratio': rational(length / TYPE_LENGTHS[base])}
|
|
|
|
def metric_length(written: dict) -> Fraction:
|
|
ratio = fraction(written.get('ratio', rational(1)))
|
|
if ratio <= 0:
|
|
raise ValueError('written duration ratio must be positive')
|
|
if 'normal' in written:
|
|
written_length(written['normal'])
|
|
return written_length(written) * ratio
|
|
|
|
def pitch_number(pitch: dict) -> int:
|
|
letter = pitch['letter'].lower()
|
|
alter, octave = pitch.get('alter', 0), pitch['octave']
|
|
if letter not in NATURAL or type(alter) is not int or type(octave) is not int or not -3 <= alter <= 3 or not -4 <= octave <= 16:
|
|
raise ValueError('invalid spelled pitch')
|
|
return 12 * (octave + 1) + NATURAL[letter] + alter
|
|
|
|
def pitch_name(pitch: dict) -> str:
|
|
alter = pitch.get('alter', 0)
|
|
return pitch['letter'].upper() + ('#' * alter if alter > 0 else 'b' * -alter)
|
|
|
|
def parse_pitch_name(name: str) -> dict:
|
|
if not name or name[0].lower() not in NATURAL or any(c not in '#b' for c in name[1:]):
|
|
raise ValueError(f'invalid pitch name: {name!r}')
|
|
return {'letter': name[0].lower(), 'alter': name[1:].count('#') - name[1:].count('b')}
|
|
|
|
def key_from_fifths(fifths: int, mode: str = 'major') -> dict:
|
|
if mode not in MODE_STEPS and mode != 'none':
|
|
raise ValueError(f'unsupported mode: {mode}')
|
|
if not -14 <= fifths <= 14:
|
|
raise ValueError('key signatures support up to fourteen fifths in either direction')
|
|
degree = fifths * 4 + MODE_STEPS.get(mode, 0)
|
|
letter = LETTERS[degree % 7]
|
|
signature = [0] * 7
|
|
order = 'fcgdaeb' if fifths > 0 else 'beadgcf'
|
|
for i in range(abs(fifths)):
|
|
signature[LETTERS.index(order[i % 7])] += 1 if fifths > 0 else -1
|
|
tonic = {'letter': letter, 'alter': signature[LETTERS.index(letter)]}
|
|
return {'fifths': fifths, 'mode': mode, 'tonic': tonic if mode != 'none' else None, 'alterations': signature}
|
|
|
|
def key_label(key: dict) -> str:
|
|
if not key.get('tonic'):
|
|
return 'No key'
|
|
label = pitch_name(key['tonic'])
|
|
return label if key['mode'] in ('major', 'ionian') else label + ' ' + key['mode']
|
|
|
|
def meter_length(meter: dict) -> Fraction:
|
|
return sum((Fraction(sum(group['beats']) * 4, group['unit']) for group in meter.get('groups', [])), Fraction())
|
|
|
|
def meter_label(meter: dict) -> str:
|
|
if meter.get('unmetered'):
|
|
return 'senza misura'
|
|
return '+'.join('+'.join(map(str, group['beats'])) + '/' + str(group['unit']) for group in meter['groups'])
|
|
|
|
def beat_lengths(meter: dict) -> list[Fraction]:
|
|
result = []
|
|
for group in meter.get('groups', []):
|
|
beats, unit = group['beats'], group['unit']
|
|
if len(beats) > 1:
|
|
result.extend(Fraction(b * 4, unit) for b in beats)
|
|
elif beats[0] > 3 and beats[0] % 3 == 0 and unit >= 8:
|
|
result.extend([Fraction(12, unit)] * (beats[0] // 3))
|
|
else:
|
|
result.extend([Fraction(4, unit)] * beats[0])
|
|
return result
|
|
|
|
def validate_meter(meter: dict) -> None:
|
|
groups = meter.get('groups', [])
|
|
if not groups and not meter.get('unmetered'):
|
|
raise ValueError('meter requires beat groups or senza misura')
|
|
for group in groups:
|
|
if type(group['unit']) is not int or not 0 < group['unit'] <= 4096 or not group['beats']:
|
|
raise ValueError('meter unit must be between 1 and 4096 with nonempty beats')
|
|
if any(type(b) is not int or not 0 < b <= 1024 for b in group['beats']):
|
|
raise ValueError('meter count must be between 1 and 1024')
|
|
|
|
def make_event(identifier: str, onset: Fraction, duration: Fraction, kind: str, pitches: list[dict] | None = None, written: dict | None = None) -> dict:
|
|
if duration <= 0:
|
|
raise ValueError('generated event duration must be positive')
|
|
notation = written or written_for(duration)
|
|
event = {'id': identifier, 'kind': kind, 'onset': rational(onset), 'duration': rational(duration), 'written': notation, 'hidden': False, 'pitches': []}
|
|
for i, p in enumerate(pitches or []):
|
|
event['pitches'].append({**copy.deepcopy(p), 'id': f'{identifier}-p{i + 1}', 'duration': rational(duration), 'written': copy.deepcopy(notation)})
|
|
return event
|
|
|
|
def validate_document(document: dict) -> None:
|
|
if document.get('schema_version') != SCHEMA_VERSION:
|
|
raise ValueError('unsupported score schema; regenerate score assets with the current generator')
|
|
staves = document.get('staves', [])
|
|
if len(staves) != 1:
|
|
raise ValueError('exactly one staff is currently supported')
|
|
ids: set[str] = set()
|
|
events: dict[str, dict] = {}
|
|
tones: dict[str, tuple[dict, Fraction, Fraction]] = {}
|
|
absolute = Fraction()
|
|
for measure in staves[0]['measures']:
|
|
length = fraction(measure['duration'])
|
|
if length <= 0:
|
|
raise ValueError('measure duration must be positive')
|
|
voices = measure.get('voices', [])
|
|
if len(voices) != 1:
|
|
raise ValueError('exactly one rhythmic voice is currently supported')
|
|
previous_end = Fraction()
|
|
for note in voices[0]['notes']:
|
|
if not note['id'] or note['id'] in ids:
|
|
raise ValueError(f'duplicate event ID: {note["id"]}')
|
|
ids.add(note['id'])
|
|
events[note['id']] = note
|
|
onset, duration = fraction(note['onset']), fraction(note['duration'])
|
|
if onset < 0 or duration < 0 or onset + duration > length:
|
|
raise ValueError(f'event outside measure: {note["id"]}')
|
|
if note['kind'] not in ('note', 'rest', 'spacer'):
|
|
raise ValueError('invalid event kind')
|
|
if not note.get('grace'):
|
|
if duration == 0 or onset < previous_end:
|
|
raise ValueError('overlapping events in one rhythmic voice')
|
|
previous_end = onset + duration
|
|
elif duration != 0:
|
|
raise ValueError('grace notes must not advance metric time')
|
|
expected = metric_length(note['written'])
|
|
if not note.get('grace') and not note.get('measure_rest') and duration != expected:
|
|
raise ValueError('metric and written event durations disagree')
|
|
if note['kind'] != 'note' and note.get('pitches'):
|
|
raise ValueError('rests and spacers cannot contain pitches')
|
|
if note['kind'] == 'note' and not note.get('pitches') and note.get('notehead') != 'slash':
|
|
raise ValueError('pitched event requires at least one pitch')
|
|
for p in note.get('pitches', []):
|
|
pitch_number(p)
|
|
pd = fraction(p['duration'])
|
|
if pd < 0 or (pd == 0 and not note.get('grace')) or pd > duration or not p['id'] or p['id'] in tones:
|
|
raise ValueError('invalid chord-tone duration or duplicate ID')
|
|
if not note.get('grace') and pd != metric_length(p['written']):
|
|
raise ValueError('metric and written chord-tone durations disagree')
|
|
tones[p['id']] = (p, absolute + onset, pd)
|
|
for harmony in measure.get('harmonies', []):
|
|
if not 0 <= fraction(harmony['onset']) < length:
|
|
raise ValueError('harmony outside measure')
|
|
for change in measure.get('attributes', []):
|
|
if not 0 <= fraction(change['onset']) < length:
|
|
raise ValueError('attribute change outside measure')
|
|
for state in [measure, *measure.get('attributes', [])]:
|
|
if 'meter' in state:
|
|
validate_meter(state['meter'])
|
|
if 'key' in state and (len(state['key']['alterations']) != 7 or any(type(a) is not int or not -3 <= a <= 3 for a in state['key']['alterations'])):
|
|
raise ValueError('key alterations must contain seven integers from -3 through 3')
|
|
if 'clef' in state and (state['clef']['sign'] not in ('G', 'F', 'C') or not 1 <= state['clef']['line'] <= 5 or not -3 <= state['clef']['octave_change'] <= 3):
|
|
raise ValueError('invalid pitched clef')
|
|
absolute += length
|
|
for identifier, (p, start, duration) in tones.items():
|
|
if target := p.get('tie_to'):
|
|
if target not in tones:
|
|
raise ValueError(f'dangling tie: {identifier} -> {target}')
|
|
other, next_start, _ = tones[target]
|
|
if other.get('tie_from') != identifier or pitch_number(p) != pitch_number(other) or next_start != start + duration:
|
|
raise ValueError(f'invalid tie: {identifier} -> {target}')
|
|
if source := p.get('tie_from'):
|
|
if source not in tones or tones[source][0].get('tie_to') != identifier:
|
|
raise ValueError(f'dangling incoming tie: {identifier}')
|
|
span_ids = set()
|
|
event_order = {identifier: index for index, identifier in enumerate(events)}
|
|
for span in staves[0].get('tuplets', []):
|
|
if not span['id'] or span['id'] in span_ids or span['start'] not in ids or span['end'] not in ids or not 0 < span['note_count'] <= 1000000 or not 0 < span['space_count'] <= 1000000 or not 0 <= span['depth'] <= 16:
|
|
raise ValueError('invalid tuplet span')
|
|
members = [n['id'] for n in events.values() if span['id'] in n.get('tuplet_ids', [])]
|
|
if not members or members[0] != span['start'] or members[-1] != span['end'] or event_order[span['start']] > event_order[span['end']]:
|
|
raise ValueError('tuplet endpoints disagree with member events')
|
|
if span.get('bracket', 'auto') not in ('yes', 'no', 'auto') or span.get('show_number', 'actual') not in ('none', 'actual', 'both'):
|
|
raise ValueError('invalid tuplet appearance')
|
|
span_ids.add(span['id'])
|
|
for note in events.values():
|
|
if any(t not in span_ids for t in note.get('tuplet_ids', [])):
|
|
raise ValueError('event refers to an unknown tuplet')
|
|
if tremolo := note.get('tremolo'):
|
|
if tremolo['type'] not in ('single', 'start', 'stop') or type(tremolo['marks']) is not int or not 0 <= tremolo['marks'] <= 8:
|
|
raise ValueError('invalid measured tremolo')
|
|
if tremolo['type'] in ('start', 'stop'):
|
|
other = events.get(tremolo.get('partner'))
|
|
expected_type = 'stop' if tremolo['type'] == 'start' else 'start'
|
|
if not other or other.get('tremolo', {}).get('partner') != note['id'] or other['tremolo']['type'] != expected_type or other['tremolo']['marks'] != tremolo['marks']:
|
|
raise ValueError('invalid paired tremolo')
|
|
for span in staves[0].get('octave_shifts', []):
|
|
if not 0 <= fraction(span['start']) < fraction(span['end']) <= absolute or not -3 <= span['octaves'] <= 3:
|
|
raise ValueError('invalid octave-shift span')
|