khodowany
67 lines
3.2 KiB
Python
67 lines
3.2 KiB
Python
from __future__ import annotations
|
|
|
|
import dataclasses
|
|
import pathlib
|
|
import types
|
|
|
|
import generator.model
|
|
import generator.musicxml
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class Sequence:
|
|
id: str
|
|
steps: tuple[int, ...]
|
|
def offsets(self) -> tuple[int, ...]:
|
|
result = [0]
|
|
for step in self.steps:
|
|
result.append(result[-1] + step)
|
|
return tuple(result)
|
|
def rank(self) -> tuple:
|
|
offsets = self.offsets()
|
|
return max(map(abs, self.steps)), max(offsets) - min(offsets), sum(a * b < 0 for a, b in zip(self.steps, self.steps[1:])), self.id
|
|
|
|
@dataclasses.dataclass(frozen=True, init=False)
|
|
class Library:
|
|
paths: types.MappingProxyType
|
|
def __init__(self, sequences: tuple[Sequence, ...]):
|
|
paths, identities = {}, set()
|
|
for sequence in sequences:
|
|
if sequence.id in identities or not 1 <= len(sequence.steps) <= 3 or any(not 1 <= abs(step) <= 7 for step in sequence.steps):
|
|
raise ValueError(f'{sequence.id}: invalid or duplicate sequence')
|
|
identities.add(sequence.id)
|
|
paths.setdefault(len(sequence.steps) + 1, []).append(sequence)
|
|
object.__setattr__(self, 'paths', types.MappingProxyType({count: tuple(sorted(items, key=lambda s: s.rank())) for count, items in paths.items()}))
|
|
def connecting(self, count: int, displacement: int | None = None) -> tuple[Sequence, ...]:
|
|
return tuple(s for s in self.paths.get(count, ()) if displacement is None or s.offsets()[-1] == displacement)
|
|
|
|
def read(path: pathlib.Path, identifier: str, count: int) -> Sequence:
|
|
document = generator.musicxml.load_musicxml(path)
|
|
measures = document['staves'][0]['measures']
|
|
if len(measures) != 1 or len(measures[0]['voices']) != 1 or measures[0]['time_signature'] != f'{count}/4':
|
|
raise ValueError(f'{path}: expected one {count}/4 sequence measure and one voice')
|
|
notes = measures[0]['voices'][0]['notes']
|
|
if len(notes) != count:
|
|
raise ValueError(f'{path}: expected {count} sequence notes')
|
|
degrees = []
|
|
for index, event in enumerate(notes):
|
|
if event.get('grace') or len(event['pitches']) != 1 or generator.model.fraction(event['onset']) != index or generator.model.fraction(event['duration']) != 1:
|
|
raise ValueError(f'{path}: sequence requires consecutive untied quarter notes')
|
|
pitch = event['pitches'][0]
|
|
if generator.model.alteration(pitch['alter']) or 'tie_from' in pitch or 'tie_to' in pitch:
|
|
raise ValueError(f'{path}: sequences must use untied C-major scale degrees')
|
|
degrees.append(7 * pitch['octave'] + generator.model.LETTERS.index(pitch['letter']))
|
|
if degrees[0] != 28:
|
|
raise ValueError(f'{path}: sequence must begin on C4')
|
|
return Sequence(identifier, tuple(b - a for a, b in zip(degrees, degrees[1:])))
|
|
|
|
def load_library(root: pathlib.Path) -> Library:
|
|
sequences = []
|
|
for path in sorted(root.rglob('*.xml')):
|
|
relative = path.relative_to(root)
|
|
if len(relative.parts) != 2 or relative.parts[0] not in ('2_4', '3_4', '4_4'):
|
|
raise ValueError(f'{path}: sequence sources belong under 2_4, 3_4, or 4_4')
|
|
sequences.append(read(path, relative.as_posix(), int(relative.parts[0][0])))
|
|
if not sequences:
|
|
raise ValueError(f'{root}: sequence library is empty or missing')
|
|
return Library(tuple(sequences))
|