khodowany
79 lines
4.8 KiB
Python
79 lines
4.8 KiB
Python
"""Explicit registered repertoire. Authored playback is not model prediction.
|
||
|
||
Matching is by canonical source music and role, never title or filename. This
|
||
path intentionally reads the registered solo, following the user's exact-reuse
|
||
policy. Unknown song/role pairs go to the learned composer.
|
||
"""
|
||
from __future__ import annotations
|
||
import dataclasses
|
||
import hashlib
|
||
import json
|
||
from pathlib import Path
|
||
from fractions import Fraction as F
|
||
from generator import musicxml,parts,training_io,harmonic_time
|
||
from generator.solo import analysis,types,placement,profiles,harmonic
|
||
|
||
|
||
def sounding(evidence,offset=F()):
|
||
result=[]
|
||
for i,event in enumerate(evidence['sounding_events']):
|
||
p=event['pitch'];number=F(event['sounding_midi'])
|
||
if number.denominator!=1:raise ValueError('Microtonal guitar solo is unsupported')
|
||
pitch=types.Pitch(p['step'].lower(),F(p['alter']),p['octave']+(int(number)-int(F(event['encoded_midi'])))//12)
|
||
result.append(types.Note(F(event['start'])-offset,F(event['end'])-offset,pitch,role='authored',event_id=f'authored_{i}'))
|
||
return tuple(result)
|
||
|
||
|
||
def validate_evidence(document,evidence):
|
||
"""Training uses the same source-form harmonic context as solo playback."""
|
||
h=harmonic.Harmony(harmonic_time.solo_source(document['staves'][0]))
|
||
checked=h.evaluate(sounding(evidence),complete=True)
|
||
if not checked.valid:raise ValueError('Unsupported harmonic relationship in authored solo: '+checked.error)
|
||
return checked
|
||
|
||
|
||
def lookup(source,role,data_dir):
|
||
from generator.production import SourceAnalysis
|
||
root=Path(data_dir);manifest=root/'training/manifest.json'
|
||
if not manifest.exists():return None
|
||
value=json.loads(manifest.read_text())
|
||
if value.get('version')!=1:raise ValueError('Unsupported training manifest')
|
||
matches=[]
|
||
for entry in value['examples']:
|
||
if entry['slot']!=(1 if role=='acoustic' else 2):continue
|
||
path=(manifest.parent/entry['source']).resolve()
|
||
if not path.is_relative_to((root/'songs').resolve()):raise ValueError('Registered sources must be in data/songs')
|
||
doc=parts.prepare_document(musicxml.load_musicxml(path))
|
||
if SourceAnalysis.read(doc).musical_key==source.musical_key:
|
||
target=(manifest.parent/entry['solo']).resolve()
|
||
if not target.is_relative_to(manifest.parent.resolve()):raise ValueError('Registered solo must be inside data/training')
|
||
evidence=training_io.read(target,role,pitch_convention=entry['pitch_convention'])
|
||
training_io.validate_harmony(doc,evidence,entry['id'])
|
||
matches.append({**entry,'path':target,'sha256':hashlib.sha256(target.read_bytes()).hexdigest()})
|
||
if len(matches)>1:raise ValueError('Multiple authored solos registered for the same source music and role')
|
||
return matches[0] if matches else None
|
||
|
||
|
||
def realize(entry,source_analysis,measures,part,start,end,initial=None):
|
||
evidence=training_io.read(entry['path'],part,pitch_convention=entry['pitch_convention'])
|
||
if evidence['discrepancies']:raise ValueError(entry['id']+': invalid authored timing/ties: '+str(evidence['discrepancies']))
|
||
expected=[(a,b-a) for a,b in zip(source_analysis.boundaries,source_analysis.boundaries[1:])]
|
||
if [(F(m['start']),F(m['duration'])) for m in evidence['measures']]!=expected:raise ValueError(entry['id']+': source/solo forms differ; register and retrain the correct pair')
|
||
notes=sounding(evidence,source_analysis.body_offset)
|
||
for n in notes:
|
||
if n.start<start or n.end>end:raise ValueError(f'{entry["id"]}: authored event {n.start}–{n.end} conflicts with arrangement window {start}–{end}; no clipping applied')
|
||
profile=profiles.for_part(part,source_analysis)
|
||
illegal=next((n for n in notes if not placement.positions(n.pitch.number(),profile)),None)
|
||
if illegal:raise ValueError(f'{entry["id"]}: {illegal.pitch.label()} at {illegal.start} is outside strings 1–6/frets 1–12; authored solo left unchanged')
|
||
placed=placement.place(tuple(notes),source_analysis.tempo,profile=profile)
|
||
if placed is None:raise ValueError(entry['id']+': no legal complete guitar placement')
|
||
spans=tuple(dataclasses.replace(s,start=s.start+start,end=s.end+start) for s in harmonic_time.read({'measures':measures},initial=initial))
|
||
checked=harmonic.Harmony(spans).evaluate(placed[1],complete=True)
|
||
if not checked.valid:raise ValueError(entry['id']+': '+checked.error)
|
||
phrase=types.Phrase('authored',start,end,placed[1],'authored','authored','handoff',theme=entry['id'],expressions=checked.contracts)
|
||
return types.Solo(part,spans,(phrase,),source_analysis.tempo,end,
|
||
{'construction':'authored_repertoire','authored_id':entry['id'],'authored_sha256':entry['sha256'],
|
||
'pitch_convention':entry['pitch_convention'],'exact_sounding_events':True,
|
||
'note':'Authored music is preserved and passes automatic contextual harmonic validation.',
|
||
'annotations':evidence['annotations']},profile,start)
|