Save
This commit is contained in:
khodowany
@@ -0,0 +1,44 @@
|
||||
"""Isolated production-role benchmark. No target discovery or audition capture."""
|
||||
from __future__ import annotations
|
||||
import argparse
|
||||
import cProfile
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import pstats
|
||||
import time
|
||||
from generator import production, parts, musicxml, vocabulary
|
||||
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__)
|
||||
p.add_argument('--source',type=Path,required=True)
|
||||
p.add_argument('--data-dir',type=Path,default=Path('data'))
|
||||
p.add_argument('--role',choices=production.ROLES,required=True)
|
||||
p.add_argument('--cache',type=Path)
|
||||
p.add_argument('--output',type=Path,required=True)
|
||||
p.add_argument('--profile',action='store_true')
|
||||
args=p.parse_args();args.output.mkdir(parents=True,exist_ok=True)
|
||||
start=time.monotonic()
|
||||
source=production.SourceAnalysis.read(parts.prepare_document(musicxml.load_musicxml(args.source)))
|
||||
analysis_seconds=time.monotonic()-start
|
||||
profile=cProfile.Profile() if args.profile else None
|
||||
if profile:profile.enable()
|
||||
start=time.monotonic()
|
||||
result=production.generate_role(source,args.role,args.data_dir,cache_dir=args.cache)
|
||||
seconds=time.monotonic()-start
|
||||
if profile:
|
||||
profile.disable();profile.dump_stats(args.output/'role.prof')
|
||||
with (args.output/'profile.txt').open('w') as out:pstats.Stats(profile,stream=out).sort_stats('cumulative').print_stats(70)
|
||||
evidence={'source':str(args.source),'canonical_source':source.musical_key,'role':args.role,
|
||||
'platform':platform.platform(),'processor':platform.processor(),'cpu_count':os.cpu_count(),'workers':1,
|
||||
'cache_hit':result['cache_hit'],'analysis_seconds':analysis_seconds,'role_seconds':seconds,
|
||||
'cprofile_enabled':bool(profile),'musical_document_hash':vocabulary.fingerprint(result['document']),
|
||||
'input_trace':result['trace'],'observed_reads':result.get('observed_reads',[])}
|
||||
(args.output/'result.json').write_text(json.dumps(result,sort_keys=True,indent=2))
|
||||
(args.output/'benchmark.json').write_text(json.dumps(evidence,sort_keys=True,indent=2))
|
||||
print(json.dumps({k:v for k,v in evidence.items() if k!='input_trace'},indent=2))
|
||||
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Explicit reproducibility exercise with authored synthetic input; no targets needed."""
|
||||
from __future__ import annotations
|
||||
import argparse,concurrent.futures,contextlib,copy,json,multiprocessing,tempfile
|
||||
from pathlib import Path
|
||||
from generator import production,vocabulary
|
||||
from tests.test_solo import song
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__);p.add_argument('--output',type=Path,required=True);a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
|
||||
data=Path('data').resolve();source=production.SourceAnalysis.read(song(count=1,chords=('C7',)))
|
||||
results={};evidence={'scope':'One-bar independently authored source, real production catalogs, all six roles; not a whole-song musical quality test.','canonical_source':source.musical_key,'cases':{}}
|
||||
def collect(label,values):
|
||||
hashes={role:vocabulary.fingerprint(value['document']) for role,value in values.items()}
|
||||
evidence['cases'][label]=hashes
|
||||
evidence.setdefault('reads',{})[label]={r:v.get('observed_reads',[]) for r,v in values.items()}
|
||||
if results:assert hashes==results['base'],label
|
||||
else:results['base']=hashes
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
cache=Path(temp)/'cache'
|
||||
collect('alone_cold',{r:production.generate_role(source,r,data,cache_dir=cache) for r in production.ROLES})
|
||||
collect('reverse_warm',{r:production.generate_role(source,r,data,cache_dir=cache) for r in reversed(production.ROLES)})
|
||||
with concurrent.futures.ProcessPoolExecutor(max_workers=2,mp_context=multiprocessing.get_context('spawn')) as pool:
|
||||
futures={r:pool.submit(production._job,(source,r,data,{},None)) for r in reversed(production.ROLES)}
|
||||
collect('parallel_cold',{r:f.result() for r,f in futures.items()})
|
||||
with contextlib.chdir(temp):
|
||||
refs=Path('build');refs.mkdir()
|
||||
for name in ('all-of-me','autumn-leaves'):
|
||||
for i in (1,2):(refs/f'{name}-solo-{i}.xml').write_text('invalid optional content')
|
||||
collect('targets_present_cold',{r:production.generate_role(source,r,data) for r in production.ROLES})
|
||||
for path in refs.glob('*.xml'):path.unlink()
|
||||
collect('targets_absent_cold',{r:production.generate_role(source,r,data) for r in production.ROLES})
|
||||
production.generate_role(source,'electric_solo',data,{'choice_seed':'different electric only'})
|
||||
collect('after_electric_setting',{r:production.generate_role(source,r,data,cache_dir=cache) for r in production.ROLES})
|
||||
evidence['passed']=True
|
||||
(a.output/'dependency.json').write_text(json.dumps(evidence,indent=2))
|
||||
print(json.dumps({'passed':True,'hashes':results['base']},indent=2))
|
||||
if __name__=='__main__':main()
|
||||
@@ -23,7 +23,8 @@ def region(document, part):
|
||||
def staged(document, details, stage, tempo):
|
||||
notes=[]
|
||||
for phrase in details['phrases']:
|
||||
for n in phrase['lead_stages'].get(stage,{}).get('notes',[]):
|
||||
selected=phrase['lead_stages'].get(stage) or phrase['draft']
|
||||
for n in selected.get('notes',[]):
|
||||
p=n['pitch']
|
||||
notes.append(types.Note(F(n['start']),F(n['end']),types.Pitch(p['letter'],F(p['alter']),p['octave']),
|
||||
tuple(n['sources']),n['role'],continuation=n['continuation'],event_id=n['event_id']))
|
||||
@@ -86,7 +87,8 @@ def export(assets,baseline,output):
|
||||
notes_report.append(f"{phrase['id']}: {phrase['start']}–{phrase['end']}; {phrase['ending']}; completed={phrase['ending_completed']}\n")
|
||||
for n in phrase['draft']['notes']:
|
||||
p=n['pitch'];tone=types.Pitch(p['letter'],F(p['alter']),p['octave'])
|
||||
pos=n['position'];notes_report.append(f" {n['start']}–{n['end']} {tone.label()} {n['role']} string {pos[0]} fret {pos[1]}\n")
|
||||
pos=n['position'];tab=f' string {pos[0]} fret {pos[1]}' if pos else ' (draft pitch; final TAB in XML)'
|
||||
notes_report.append(f" {n['start']}–{n['end']} {tone.label()} {n['role']}{tab}\n")
|
||||
back_audio=mix([backing],tempo,output,tone_cache)
|
||||
for name,document in versions.items():
|
||||
label=key+'_'+name
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
"""Summarize finished production decisions; no composition or reference reading."""
|
||||
from __future__ import annotations
|
||||
import argparse,collections,json
|
||||
from fractions import Fraction as F
|
||||
from pathlib import Path
|
||||
from generator import vocabulary
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__);p.add_argument('--assets',type=Path,required=True);p.add_argument('--output',type=Path,required=True);args=p.parse_args();args.output.mkdir(parents=True,exist_ok=True)
|
||||
evidence={};text=['# Finished production evidence','', 'Times below are exact quarter-note beats relative to the solo. Counts describe the selected music; they are not targets or listening verdicts.','']
|
||||
for path in sorted((args.assets/'analysis').glob('*.roles')):
|
||||
roles=json.loads(path.read_text())
|
||||
for role,v in roles.items():
|
||||
key=path.stem+'/'+role
|
||||
evidence[key]={'document_hash':vocabulary.fingerprint(v['document']),'trace':v['trace']}
|
||||
if not role.endswith('_solo'):continue
|
||||
d=v['details'];ps=d['phrases'];ns=[n for p in ps for n in p['draft']['notes']]
|
||||
operations=collections.Counter(t['operation'] for p in ps for t in p['draft']['transformations'])
|
||||
span=max(F(p['end']) for p in ps)-min(F(p['start']) for p in ps)
|
||||
sounding=sum((F(n['end'])-F(n['start']) for n in ns),F())
|
||||
summary={'attacks':sum(not n['continuation'] for n in ns),'quarter_beats':str(span),'occupancy':float(sounding/span),'fretboard':d['fretboard'],'operations_selected':dict(operations),'operation_funnel':d['selection_trace'].get('operations',{}),'expressions_selected':dict(collections.Counter(e['kind'] for e in d['expressions'])),'expression_funnel':d['selection_trace'].get('expression_operations',{}),'evaluation_total':d['selection_trace']['selection_total'],'unresolved':d['unresolved_treatments'],'boundaries':[]}
|
||||
evidence[key].update(summary)
|
||||
text += ['## '+key,'',f"{summary['attacks']} attacks over {span} quarter beats; sounding occupancy {summary['occupancy']:.1%}; sounding MIDI range {d['fretboard']['range_midi']}. Harmonic valid: {d['harmonic_valid']}; unresolved obligations: {len(d['unresolved_treatments'])}.",'', '| Span | Behavior | Destination / actual hold | Home identity |','|---|---|---|---|']
|
||||
for phrase in ps:
|
||||
anchors=[{k:a[k] for k in ('role','effect','pitch','actual_start','actual_end','completed')} for a in phrase['anchors']]
|
||||
summary['boundaries'].append({'start':phrase['start'],'end':phrase['end'],'closure':phrase['closure'],'anchors':anchors,'home':phrase['home']})
|
||||
destination='; '.join(a['effect']+' '+a['pitch']+' '+str(a['actual_start'])+'–'+str(a['actual_end']) for a in anchors) or 'no forced arrival'
|
||||
text.append(f"| {phrase['start']}–{phrase['end']} | {phrase['closure']} / {phrase['ending']} | {destination} | `{phrase['home']}` |")
|
||||
text += ['', 'Selected actions: '+', '.join(f'{k}: {v}' for k,v in sorted(operations.items()))+'.','', 'Typed treatments: '+str(summary['expressions_selected'])+'.','', '### Representative evaluated phrase','']
|
||||
phrase=next(p for p in ps if p['draft']['notes']);evaluation=phrase['evaluation'];assert abs(phrase['score']-sum(evaluation['contributions'].values()))<1e-10
|
||||
text += [f"Selected `{phrase['id']}`; score {phrase['score']:.9f}. Identity is a hard feature contract.",'','| Contribution | Raw | Weight | Weighted |','|---|---:|---:|---:|']
|
||||
for k,value in evaluation['raw'].items():text.append(f"| {k} | {value:.9f} | {evaluation['weights'][k]} | {evaluation['contributions'][k]:.9f} |")
|
||||
pool=d['selection_trace'].get('source_candidate_pools',{}).get(phrase['passage'],[])
|
||||
alternatives=sorted((c for c in pool if c['id']!=phrase['draft']['id']),key=lambda c:(c['score'],c['id']))
|
||||
text += ['', 'Other retained alternatives for this source window (possibly different incoming histories):']
|
||||
for c in alternatives[:3]:text.append(f"- `{c['id']}`: {c['score']:.9f}, {c['attacks']} attacks; selected ending {c['ending']}.")
|
||||
text += ['', 'These are local alternatives, not a proof of a global optimum. The chorus frontier compares complete histories using duration-weighted phrase scores. The JSON retains every reported contribution, operation cutoff counts and source input trace.','']
|
||||
evidence[key]['winner_evaluation']=evaluation;evidence[key]['local_alternatives']=alternatives[:3]
|
||||
(args.output/'evidence.json').write_text(json.dumps(evidence,indent=2))
|
||||
(args.output/'phrase_traces.md').write_text('\n'.join(text)+'\n')
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,32 @@
|
||||
"""Optional evaluation of independent source excerpts; never a production import."""
|
||||
from __future__ import annotations
|
||||
import argparse,json,time
|
||||
from pathlib import Path
|
||||
from generator import musicxml,parts,production,vocabulary,score,musicxml_writer
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__)
|
||||
p.add_argument('--sources',type=Path,default=Path('tests/evaluation_sources'))
|
||||
p.add_argument('--data-dir',type=Path,default=Path('data'))
|
||||
p.add_argument('--output',type=Path,required=True)
|
||||
args=p.parse_args();args.output.mkdir(parents=True,exist_ok=True)
|
||||
report={'scope':'Four-bar source excerpts, not complete standards; read adjacent provenance. No target solo used.', 'cases':[]}
|
||||
for path in sorted(args.sources.glob('*.xml')):
|
||||
source=production.SourceAnalysis.read(parts.prepare_document(musicxml.load_musicxml(path)))
|
||||
roles={};case={'source':str(path),'canonical_source':source.musical_key,'roles':{}}
|
||||
for role in production.ROLES:
|
||||
start=time.monotonic()
|
||||
try:
|
||||
value=production.generate_role(source,role,args.data_dir)
|
||||
roles[role]=value;case['roles'][role]={'valid':True,'seconds':time.monotonic()-start,'hash':vocabulary.fingerprint(value['document'])}
|
||||
except ValueError as error:
|
||||
case['roles'][role]={'valid':False,'seconds':time.monotonic()-start,'diagnostic':str(error)}
|
||||
print(path.stem,role,case['roles'][role],flush=True)
|
||||
if len(roles)==len(production.ROLES):
|
||||
for part,document in production.assemble(source,roles).items():
|
||||
score.write_json(args.output/(path.stem+'_'+part+'.json'),document)
|
||||
musicxml_writer.write_musicxml(args.output/(path.stem+'_'+part+'.xml'),document)
|
||||
report['cases'].append(case)
|
||||
(args.output/'report.json').write_text(json.dumps(report,indent=2))
|
||||
return int(any(not r['valid'] for c in report['cases'] for r in c['roles'].values()))
|
||||
if __name__=='__main__':raise SystemExit(main())
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"version": 1,
|
||||
"provenance": "Original transposable transformations authored from the musical brief, independently of audition references.",
|
||||
"provenance": "Original transposable transformations authored from the musical brief, independently of audition references. Group operations and evaluator policy independently authored from the repair brief; no target inspection or fitting.",
|
||||
"license": "MIT",
|
||||
"transformations": [
|
||||
{
|
||||
@@ -56,10 +56,29 @@
|
||||
},
|
||||
{
|
||||
"id": "continue",
|
||||
"preserve": [],
|
||||
"purpose": "free complete connection conditioned on incoming sound and later destination"
|
||||
},
|
||||
{
|
||||
"id": "answer",
|
||||
"preserve": [
|
||||
"contour"
|
||||
],
|
||||
"purpose": "extend heard material through a boundary"
|
||||
"purpose": "related answer with new timing and destination"
|
||||
},
|
||||
{
|
||||
"id": "extend",
|
||||
"preserve": [
|
||||
"contour"
|
||||
],
|
||||
"purpose": "reopen a provisional ending into a longer route"
|
||||
},
|
||||
{
|
||||
"id": "fragment",
|
||||
"preserve": [
|
||||
"rhythm"
|
||||
],
|
||||
"purpose": "develop a selected fragment"
|
||||
}
|
||||
],
|
||||
"ending_holds": [
|
||||
@@ -74,5 +93,49 @@
|
||||
"1/2",
|
||||
"1",
|
||||
"2"
|
||||
]
|
||||
],
|
||||
"operations": [
|
||||
{
|
||||
"id": "develop_contour",
|
||||
"after_statement": true
|
||||
},
|
||||
{
|
||||
"id": "develop_rhythm",
|
||||
"after_statement": true
|
||||
},
|
||||
{
|
||||
"id": "answer",
|
||||
"after_statement": true
|
||||
},
|
||||
{
|
||||
"id": "extend",
|
||||
"after_statement": true,
|
||||
"needs_recent": true
|
||||
},
|
||||
{
|
||||
"id": "fragment",
|
||||
"after_statement": true
|
||||
},
|
||||
{
|
||||
"id": "continue",
|
||||
"after_statement": true
|
||||
},
|
||||
{
|
||||
"id": "return",
|
||||
"after_statement": true,
|
||||
"entry_only": true
|
||||
}
|
||||
],
|
||||
"evaluation": {
|
||||
"version": "joint-musical-1",
|
||||
"weights": {
|
||||
"rhythm": 3,
|
||||
"destination": 2,
|
||||
"harmony": 2,
|
||||
"register": 1,
|
||||
"repetition": 1,
|
||||
"activity": 1,
|
||||
"difficulty": 0.5
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+133
-12
@@ -3,18 +3,139 @@
|
||||
"provenance": "Original conservative chord/function rules; not learned from supplied reference scores.",
|
||||
"license": "MIT",
|
||||
"colors": [
|
||||
{"id": "major_ninth", "qualities": ["major"], "degree": 9, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "major_thirteenth", "qualities": ["major"], "degree": 13, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "lydian_color", "qualities": ["major", "dominant"], "degree": 11, "alter": 1, "max_beats": "2", "outside": true, "resolve": true},
|
||||
{"id": "minor_ninth", "qualities": ["minor"], "degree": 9, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "minor_eleventh", "qualities": ["minor", "half_diminished"], "degree": 11, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "minor_sixth", "qualities": ["minor"], "degree": 6, "alter": 0, "max_beats": "2", "outside": true, "resolve": true, "function": "tonic_or_predominant"},
|
||||
{"id": "dominant_ninth", "qualities": ["dominant"], "degree": 9, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "dominant_thirteenth", "qualities": ["dominant"], "degree": 13, "alter": 0, "max_beats": "4", "outside": false},
|
||||
{"id": "dominant_flat_ninth", "qualities": ["dominant"], "degree": 9, "alter": -1, "max_beats": "2", "outside": true, "resolve": true, "function": "resolving_dominant"},
|
||||
{"id": "dominant_sharp_ninth", "qualities": ["dominant"], "degree": 9, "alter": 1, "max_beats": "2", "outside": true, "resolve": true, "function": "resolving_dominant"},
|
||||
{"id": "dominant_flat_thirteenth", "qualities": ["dominant"], "degree": 13, "alter": -1, "max_beats": "2", "outside": true, "resolve": true, "function": "resolving_dominant"}
|
||||
{
|
||||
"id": "major_ninth",
|
||||
"qualities": [
|
||||
"major"
|
||||
],
|
||||
"degree": 9,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "major_thirteenth",
|
||||
"qualities": [
|
||||
"major"
|
||||
],
|
||||
"degree": 13,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "lydian_color",
|
||||
"qualities": [
|
||||
"major",
|
||||
"dominant"
|
||||
],
|
||||
"degree": 11,
|
||||
"alter": 1,
|
||||
"max_beats": "2",
|
||||
"outside": true,
|
||||
"resolve": true
|
||||
},
|
||||
{
|
||||
"id": "minor_ninth",
|
||||
"qualities": [
|
||||
"minor"
|
||||
],
|
||||
"degree": 9,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "minor_eleventh",
|
||||
"qualities": [
|
||||
"minor",
|
||||
"half_diminished"
|
||||
],
|
||||
"degree": 11,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "minor_sixth",
|
||||
"qualities": [
|
||||
"minor"
|
||||
],
|
||||
"degree": 6,
|
||||
"alter": 0,
|
||||
"max_beats": "2",
|
||||
"outside": true,
|
||||
"resolve": true,
|
||||
"function": "tonic_or_predominant"
|
||||
},
|
||||
{
|
||||
"id": "dominant_ninth",
|
||||
"qualities": [
|
||||
"dominant"
|
||||
],
|
||||
"degree": 9,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "dominant_thirteenth",
|
||||
"qualities": [
|
||||
"dominant"
|
||||
],
|
||||
"degree": 13,
|
||||
"alter": 0,
|
||||
"max_beats": "4",
|
||||
"outside": false
|
||||
},
|
||||
{
|
||||
"id": "dominant_flat_ninth",
|
||||
"qualities": [
|
||||
"dominant"
|
||||
],
|
||||
"degree": 9,
|
||||
"alter": -1,
|
||||
"max_beats": "2",
|
||||
"outside": true,
|
||||
"resolve": true,
|
||||
"function": "resolving_dominant"
|
||||
},
|
||||
{
|
||||
"id": "dominant_sharp_ninth",
|
||||
"qualities": [
|
||||
"dominant"
|
||||
],
|
||||
"degree": 9,
|
||||
"alter": 1,
|
||||
"max_beats": "2",
|
||||
"outside": true,
|
||||
"resolve": true,
|
||||
"function": "resolving_dominant"
|
||||
},
|
||||
{
|
||||
"id": "dominant_flat_thirteenth",
|
||||
"qualities": [
|
||||
"dominant"
|
||||
],
|
||||
"degree": 13,
|
||||
"alter": -1,
|
||||
"max_beats": "2",
|
||||
"outside": true,
|
||||
"resolve": true,
|
||||
"function": "resolving_dominant"
|
||||
}
|
||||
],
|
||||
"resolution_gap": "1",
|
||||
"anticipation_max": "1"
|
||||
"anticipation_max": "1",
|
||||
"suspensions": [
|
||||
{
|
||||
"id": "prepared_step_down",
|
||||
"preparation": "1/2",
|
||||
"max_delay": "1",
|
||||
"steps": [
|
||||
-1,
|
||||
-2
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
@@ -3,22 +3,238 @@
|
||||
"provenance": "Independently authored, transposable rhythmic gestures and chord-member traversal operators. No notes, rhythms, measurements, or fitted parameters were extracted from the optional reference scores.",
|
||||
"license": "MIT",
|
||||
"cells": [
|
||||
{"id": "pickup_to_statement", "purpose": "entrance", "values": ["r:1/2", "1/2", "1", "1/2", "1/2", "1"]},
|
||||
{"id": "delayed_statement", "purpose": "entrance", "values": ["r:1", "1", "1/2", "1/2", "1"]},
|
||||
{"id": "syncopated_connection", "purpose": "connect", "values": ["1/2", "1", "1/2", "1/2", "1/2"]},
|
||||
{"id": "cross_bar_connection", "purpose": "connect", "values": ["r:3/2", "1/2", "1/2", "1/2", "1", "1/2", "1/2"]},
|
||||
{"id": "quarter_eighth_development", "purpose": "continue", "values": ["1", "1/2", "1/2", "1", "1"]},
|
||||
{"id": "held_note_continuation", "purpose": "continue", "values": ["3/2", "1/2", "1/2", "1/2", "1"]},
|
||||
{"id": "answer_with_breath", "purpose": "answer", "values": ["1/2", "1/2", "3/2", "r:1/2", "1"]},
|
||||
{"id": "short_then_broaden", "purpose": "answer", "values": ["1/2", "1", "3/2", "r:1"]},
|
||||
{"id": "anticipated_sustain", "purpose": "arrival", "values": ["r:5/2", "1/2", "3"]},
|
||||
{"id": "late_sustain", "purpose": "arrival", "values": ["1", "1/2", "5/2"]},
|
||||
{"id": "triplet_resolution", "purpose": "arrival", "values": ["1/3", "1/3", "1/3", "2", "r:1"], "difficulty": "triplet"}
|
||||
{
|
||||
"id": "pickup_to_statement",
|
||||
"purpose": "entrance",
|
||||
"values": [
|
||||
"r:1/2",
|
||||
"1/2",
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "delayed_statement",
|
||||
"purpose": "entrance",
|
||||
"values": [
|
||||
"r:1",
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "syncopated_connection",
|
||||
"purpose": "connect",
|
||||
"values": [
|
||||
"1/2",
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "cross_bar_connection",
|
||||
"purpose": "connect",
|
||||
"values": [
|
||||
"r:3/2",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "quarter_eighth_development",
|
||||
"purpose": "continue",
|
||||
"values": [
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "held_note_continuation",
|
||||
"purpose": "continue",
|
||||
"values": [
|
||||
"3/2",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "answer_with_breath",
|
||||
"purpose": "answer",
|
||||
"values": [
|
||||
"1/2",
|
||||
"1/2",
|
||||
"3/2",
|
||||
"r:1/2",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "short_then_broaden",
|
||||
"purpose": "answer",
|
||||
"values": [
|
||||
"1/2",
|
||||
"1",
|
||||
"3/2",
|
||||
"r:1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "release"
|
||||
},
|
||||
{
|
||||
"id": "anticipated_sustain",
|
||||
"purpose": "arrival",
|
||||
"values": [
|
||||
"r:5/2",
|
||||
"1/2",
|
||||
"3"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "late_sustain",
|
||||
"purpose": "arrival",
|
||||
"values": [
|
||||
"1",
|
||||
"1/2",
|
||||
"5/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "triplet_resolution",
|
||||
"purpose": "arrival",
|
||||
"values": [
|
||||
"1/3",
|
||||
"1/3",
|
||||
"1/3",
|
||||
"2",
|
||||
"r:1"
|
||||
],
|
||||
"difficulty": "triplet",
|
||||
"subdivision": "triplet",
|
||||
"entry": "attack",
|
||||
"exit": "release"
|
||||
}
|
||||
],
|
||||
"chord_paths": [
|
||||
{"id": "ascending_members", "purpose": ["entrance", "continue", "connect", "arrival"], "direction": "up", "member_steps": [1], "prefix_attacks": [2, 3], "max_interval": 7, "members": "basic", "require_chord_entry": true},
|
||||
{"id": "descending_members", "purpose": ["entrance", "continue", "connect", "arrival"], "direction": "down", "member_steps": [1], "prefix_attacks": [2, 3], "max_interval": 7, "members": "basic", "require_chord_entry": true},
|
||||
{"id": "member_turn", "purpose": ["continue", "connect", "answer"], "direction": "toward", "member_steps": [1, -1], "prefix_attacks": [3], "max_interval": 7, "members": "basic", "require_chord_entry": true},
|
||||
{"id": "guide_connection", "purpose": ["continue", "connect", "answer", "arrival"], "direction": "toward", "member_steps": [1], "prefix_attacks": [2], "max_interval": 7, "members": "defining", "require_chord_entry": false}
|
||||
{
|
||||
"id": "ascending_members",
|
||||
"purpose": [
|
||||
"entrance",
|
||||
"continue",
|
||||
"connect",
|
||||
"arrival"
|
||||
],
|
||||
"direction": "up",
|
||||
"member_steps": [
|
||||
1
|
||||
],
|
||||
"prefix_attacks": [
|
||||
2,
|
||||
3
|
||||
],
|
||||
"max_interval": 7,
|
||||
"members": "basic",
|
||||
"require_chord_entry": true
|
||||
},
|
||||
{
|
||||
"id": "descending_members",
|
||||
"purpose": [
|
||||
"entrance",
|
||||
"continue",
|
||||
"connect",
|
||||
"arrival"
|
||||
],
|
||||
"direction": "down",
|
||||
"member_steps": [
|
||||
1
|
||||
],
|
||||
"prefix_attacks": [
|
||||
2,
|
||||
3
|
||||
],
|
||||
"max_interval": 7,
|
||||
"members": "basic",
|
||||
"require_chord_entry": true
|
||||
},
|
||||
{
|
||||
"id": "member_turn",
|
||||
"purpose": [
|
||||
"continue",
|
||||
"connect",
|
||||
"answer"
|
||||
],
|
||||
"direction": "toward",
|
||||
"member_steps": [
|
||||
1,
|
||||
-1
|
||||
],
|
||||
"prefix_attacks": [
|
||||
3
|
||||
],
|
||||
"max_interval": 7,
|
||||
"members": "basic",
|
||||
"require_chord_entry": true
|
||||
},
|
||||
{
|
||||
"id": "guide_connection",
|
||||
"purpose": [
|
||||
"continue",
|
||||
"connect",
|
||||
"answer",
|
||||
"arrival"
|
||||
],
|
||||
"direction": "toward",
|
||||
"member_steps": [
|
||||
1
|
||||
],
|
||||
"prefix_attacks": [
|
||||
2
|
||||
],
|
||||
"max_interval": 7,
|
||||
"members": "defining",
|
||||
"require_chord_entry": false
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
+163
-15
@@ -3,22 +3,170 @@
|
||||
"provenance": "Original rhythm cells authored as general transformations, not extracted from audition scores.",
|
||||
"license": "MIT",
|
||||
"cells": [
|
||||
{"id": "pickup", "purpose": "entrance", "values": ["r:1/2", "1/2", "1"]},
|
||||
{"id": "delayed", "purpose": "entrance", "values": ["r:1", "1/2", "1/2"]},
|
||||
{"id": "offbeat_hold", "purpose": "arrival", "values": ["1/2", "3/2"]},
|
||||
{"id": "short_answer", "purpose": "answer", "values": ["1/2", "1/2", "r:1"]},
|
||||
{"id": "mixed_motion", "purpose": "continue", "values": ["1", "1/2", "1/2"]},
|
||||
{"id": "eighth_motion", "purpose": "connect", "values": ["1/2", "1/2", "1/2", "1/2"]},
|
||||
{"id": "broadening", "purpose": "arrival", "values": ["1", "2", "r:1"]},
|
||||
{"id": "triplet_turn", "purpose": "connect", "values": ["1/3", "1/3", "1/3"], "difficulty": "triplet"},
|
||||
{"id": "sixteenth_pickup", "purpose": "connect", "values": ["1/4", "1/4", "1/2"], "difficulty": "sixteenth"}
|
||||
{
|
||||
"id": "pickup",
|
||||
"purpose": "entrance",
|
||||
"values": [
|
||||
"r:1/2",
|
||||
"1/2",
|
||||
"1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "delayed",
|
||||
"purpose": "entrance",
|
||||
"values": [
|
||||
"r:1",
|
||||
"1/2",
|
||||
"1/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "pickup",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "offbeat_hold",
|
||||
"purpose": "arrival",
|
||||
"values": [
|
||||
"1/2",
|
||||
"3/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "settle"
|
||||
},
|
||||
{
|
||||
"id": "short_answer",
|
||||
"purpose": "answer",
|
||||
"values": [
|
||||
"1/2",
|
||||
"1/2",
|
||||
"r:1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "release"
|
||||
},
|
||||
{
|
||||
"id": "mixed_motion",
|
||||
"purpose": "continue",
|
||||
"values": [
|
||||
"1",
|
||||
"1/2",
|
||||
"1/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "eighth_motion",
|
||||
"purpose": "connect",
|
||||
"values": [
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1/2",
|
||||
"1/2"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "broadening",
|
||||
"purpose": "arrival",
|
||||
"values": [
|
||||
"1",
|
||||
"2",
|
||||
"r:1"
|
||||
],
|
||||
"subdivision": "binary",
|
||||
"entry": "attack",
|
||||
"exit": "release"
|
||||
},
|
||||
{
|
||||
"id": "triplet_turn",
|
||||
"purpose": "connect",
|
||||
"values": [
|
||||
"1/3",
|
||||
"1/3",
|
||||
"1/3"
|
||||
],
|
||||
"difficulty": "triplet",
|
||||
"subdivision": "triplet",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
},
|
||||
{
|
||||
"id": "sixteenth_pickup",
|
||||
"purpose": "connect",
|
||||
"values": [
|
||||
"1/4",
|
||||
"1/4",
|
||||
"1/2"
|
||||
],
|
||||
"difficulty": "sixteenth",
|
||||
"subdivision": "sixteenth",
|
||||
"entry": "attack",
|
||||
"exit": "continue"
|
||||
}
|
||||
],
|
||||
"comping": [
|
||||
{"id": "establish_release", "attacks": [["0", "1/2"]]},
|
||||
{"id": "broad_shell", "attacks": [["0", "3/2"]]},
|
||||
{"id": "delayed_shell", "attacks": [["1/2", "1"]]},
|
||||
{"id": "answer", "attacks": [["0", "1/2"], ["3/2", "1/2"]]},
|
||||
{"id": "sustain", "attacks": [["0", "3"]]},
|
||||
{"id": "space", "attacks": []}
|
||||
{
|
||||
"id": "establish_release",
|
||||
"attacks": [
|
||||
[
|
||||
"0",
|
||||
"1/2"
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "broad_shell",
|
||||
"attacks": [
|
||||
[
|
||||
"0",
|
||||
"3/2"
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "delayed_shell",
|
||||
"attacks": [
|
||||
[
|
||||
"1/2",
|
||||
"1"
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "answer",
|
||||
"attacks": [
|
||||
[
|
||||
"0",
|
||||
"1/2"
|
||||
],
|
||||
[
|
||||
"3/2",
|
||||
"1/2"
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "sustain",
|
||||
"attacks": [
|
||||
[
|
||||
"0",
|
||||
"3"
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"id": "space",
|
||||
"attacks": []
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
@@ -3,12 +3,57 @@
|
||||
"provenance": "Independently authored general composition policy; no validation-score measurements or material.",
|
||||
"license": "MIT",
|
||||
"roles": {
|
||||
"acoustic_solo": {"seed": "acoustic", "register_offset": 0, "preferred_features": ["rhythmic_seed", "opening_fragment", "characteristic_interval", "contour_seed"], "register_motion": [0, 5, -3, 2]},
|
||||
"electric_solo": {"seed": "electric", "register_offset": 12, "preferred_features": ["characteristic_interval", "contour_seed", "rhythmic_seed", "opening_fragment"], "register_motion": [0, -4, 5, 0]},
|
||||
"acoustic_accompaniment": {"seed": "acoustic_comp", "bass": "primary", "center": 53},
|
||||
"electric_accompaniment": {"seed": "electric_comp", "bass": "essential", "center": 60},
|
||||
"electric_melody": {"seed": "head"},
|
||||
"vocal_melody": {"seed": "voice"}
|
||||
"acoustic_solo": {
|
||||
"seed": "acoustic",
|
||||
"preferred_features": [
|
||||
"rhythmic_seed",
|
||||
"opening_fragment",
|
||||
"characteristic_interval",
|
||||
"contour_seed"
|
||||
],
|
||||
"register_center": 57,
|
||||
"register_alternatives": [
|
||||
-7,
|
||||
0,
|
||||
7
|
||||
]
|
||||
},
|
||||
"difficulty": {"name": "moderate", "triplet_max_bpm": 160, "sixteenth_max_bpm": 112, "burst_attacks": 4}
|
||||
"electric_solo": {
|
||||
"seed": "electric",
|
||||
"preferred_features": [
|
||||
"characteristic_interval",
|
||||
"contour_seed",
|
||||
"rhythmic_seed",
|
||||
"opening_fragment"
|
||||
],
|
||||
"register_center": 62,
|
||||
"register_alternatives": [
|
||||
-7,
|
||||
0,
|
||||
7
|
||||
]
|
||||
},
|
||||
"acoustic_accompaniment": {
|
||||
"seed": "acoustic_comp",
|
||||
"bass": "primary",
|
||||
"center": 53
|
||||
},
|
||||
"electric_accompaniment": {
|
||||
"seed": "electric_comp",
|
||||
"bass": "essential",
|
||||
"center": 60
|
||||
},
|
||||
"electric_melody": {
|
||||
"seed": "head"
|
||||
},
|
||||
"vocal_melody": {
|
||||
"seed": "voice"
|
||||
}
|
||||
},
|
||||
"difficulty": {
|
||||
"name": "moderate",
|
||||
"triplet_max_bpm": 160,
|
||||
"sixteenth_max_bpm": 112,
|
||||
"burst_attacks": 4
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
# Active production path audit
|
||||
|
||||
Baseline: revision `405066e` (`Revamp`), initially clean working tree. The immutable copy is `build/composer_repair/405066e/baseline/`; `baseline_inputs.json` records source/data and optional-reference hashes. These are evidence, not production inputs. The named ZIP archives and external remediation/comparison Markdown files were absent. The extracted source copies in `data/songs/` remain authoritative and unchanged.
|
||||
|
||||
Optional reference paths actually present:
|
||||
|
||||
- `build/all-of-me-solo-1.xml` — acoustic
|
||||
- `build/all-of-me-solo-2.xml` — electric
|
||||
- `build/autumn-leaves-solo-1.xml` — acoustic
|
||||
- `build/autumn-leaves-solo-2.xml` — electric
|
||||
|
||||
No reference contents were inspected to author the production changes. Optional comparison commands run after generation, preserve raw XML, and explicitly apply the separately confirmed guitar-written octave convention. Source import keeps its own contract.
|
||||
|
||||
| Reported issue | Reproduction / earliest failing stage | Repair |
|
||||
|---|---|---|
|
||||
| Broad score overwritten | Confirmed: `checked_phrase` score replaced in `themes.phrase_candidates`; selection | One `MusicalEvaluation` supplies the actual score; no subsequent replacement or extra chorus transition cost |
|
||||
| Density calculated but unused | Confirmed in removed `phrasing.evaluate`; selection | Active-span attack-range contribution in authoritative evaluator; sustains and planned space have separate intents |
|
||||
| Absolute onset “rhythm diversity” | Confirmed in `themes.seeds`; retrieval | Duration/rest descriptors invariant under time translation |
|
||||
| Chord tone at every internal endpoint | Confirmed in `unit_candidates`; construction and validity | Ordinary endpoints use mapped pitches; sustained notes and declared destinations retain their contracts |
|
||||
| Every window sustained/closed | Confirmed; representation/construction | Open alternative; local settles are intermediate; cadential completions and source handoffs are terminal |
|
||||
| Answer vocabulary unreachable | Confirmed: operation chooser omitted answer; construction | Data-defined chooser requests answer, extension, fragment, free continuation, development and return |
|
||||
| Residual third/sixth-beat offsets | Reproduced from half-beat edits of triplet material; construction | Complete group checks; binary-only boundary alteration; complete displaced triplets preserved |
|
||||
| Expressions after strict winner | Confirmed in `composer.compose`; construction | Typed alternatives and direct versions compete before phrase selection |
|
||||
| Narrow starting/route choices | Confirmed: three first pitches, prefix of two paths, suffix of three; pruning | Whole-route actions, register representatives, named cutoff counts; no independently selected suffix |
|
||||
| Source register / electric +12 | Confirmed in role data and `profiles.for_part`; construction | Soft overlapping role centers and phrase alternatives, all six strings |
|
||||
| Role dependency / reference lookup | Not reproduced in baseline normal path | Existing independent process workers retained; runtime read boundary added |
|
||||
| Overly full responsive accompaniment | Not reproduced in current production | Current source-only canonical sparse comping retained; no generated-solo response reintroduced |
|
||||
|
||||
## Before and after call graph
|
||||
|
||||
Both enter through `generator.__main__ → arrange.generate.generate_performance_scores → production.generate_tree → generate_role`. A spawn process pool already existed (default two workers). Roles use immutable original-song analysis and independently keyed policies/caches. Assembly applies source-defined role masks.
|
||||
|
||||
Previously the solo path was `composer.compose → leads.thematic_options → themes.phrase_candidates → unit_candidates → protected prefix + route suffix → checked_phrase → overwritten score → solo winner → expressions.refine`.
|
||||
|
||||
Now it is `composer.compose → leads.thematic_options → themes.phrase_candidates → whole joint unit_candidates → complete routes → provisional two-sided join alternatives / typed expression alternatives → checked_phrase → scoring.musical → phrase frontier → independent solo winner → validation → notation → assembly`. Source masks, vocal pickup, scales and physical checks are retained.
|
||||
|
||||
| Module/function | Live responsibility | Production inputs / budgets |
|
||||
|---|---|---|
|
||||
| `production.SourceAnalysis.read` | Canonical melody, harmony, exact meter/tempo/form | Original source only; corrected `meter` key to actual `time_signature` |
|
||||
| `themes.seeds` | Source feature evidence throughout the head | Source notes, preferred feature roles; eight diverse seeds |
|
||||
| `themes.rhythm_windows` / `patterns` | Complete rhythm alternatives and lawful transformations | Meter-filtered catalog, authored cells and difficulty; eight representatives |
|
||||
| `themes.operation_choices` | Request development purposes | `grammar.operations`, actual home/incoming state |
|
||||
| `themes.unit_candidates` | Complete joint actions | Actual incoming note, theme, destination, register; 16 jobs, eight retained gestures, deterministic retry |
|
||||
| `routes.candidates` | Full octave-aware scale/chord route | Relative sequence catalog, chord traversal operators, exact sounding span; eight route representatives |
|
||||
| `gesture_rhythm.join_variants` | Bounded edits across internal joins | Up to two beats on each side; eight legal alternatives; no protected hold consumed |
|
||||
| `expressions.joint_candidates` | Approach/color/anticipation/suspension alternatives | Versioned rules; eight representatives per provisional phrase, with direct version retained |
|
||||
| `realization.checked_phrase` | Identity, harmony, hold, placement, final evaluation | No optional reference inputs; one final evaluation result |
|
||||
| `leads.thematic_options` | Bounded continuation across windows | Eight chorus alternatives; duration-weighted complete evaluations |
|
||||
| `comping.Canonical` | Source-only reusable accompaniment | Written harmony/source rhythm/form, sparse voicing and comping resources |
|
||||
|
||||
`themes.prefix_paths`, `_prefix_paths`, and unused `instantiate` were removed. The old thematic `phrasing.evaluate` was removed. The generic cell/draft realizer and explicit `mode='paraphrase'` API remain compatibility/test/audition paths; ordinary production does not call them or silently fall back to them. Their existence is not claimed as a new production capability.
|
||||
|
||||
A further pruning defect appeared during the real-song build: the seed category combined treatment and form position. Its first layer could fill the entire budget with eight exact-interval references and discard rhythm/contour contracts. The corrected cutoff preserves treatment families first; a synthetic reachability regression covers this. Open windows now also request continuing rhythm, rather than using arrival rhythm simply because a computational window ends.
|
||||
|
||||
Profiling found repeated `diverse` ranking and interval-family classification among the major costs. Ranking is now decorated once per item and immutable path descriptors are memoized. A stable-order comparison test proves that the optimized cutoff preserves the old ordering for tied ranks; no larger beam or wall-clock-dependent choice was added.
|
||||
|
||||
## Baseline export correspondence
|
||||
|
||||
A fresh read of each preserved MusicXML export was compared with `playback.compile_timeline` of its saved role document (explicit guitar octave convention and merged sounding ties). All four matched exactly: All of Me acoustic 117 attacks, electric 121; Autumn Leaves acoustic 83, electric 110. Evidence is `baseline-export-proof.json`. This confirms the saved baseline's exported music; it is not a claim that XML formatting or those counts predict musical quality.
|
||||
@@ -0,0 +1,46 @@
|
||||
# Reproduction commands
|
||||
|
||||
Run from the repository root. Prefix module invocations with:
|
||||
|
||||
```
|
||||
build/build_common/python/bin/python3 build/build_tools/python_runner.py build/build_common/modulus
|
||||
```
|
||||
|
||||
Full staged production build actually run:
|
||||
|
||||
```
|
||||
-m generator --data-dir data --output-dir build/composer_repair/405066e/candidate --static-assets-dir package/assets --check --jobs 2 --composition-jobs 2 --composition-cache build/composer_repair/405066e/cache --engraving-cache build/build_common/engraving_cache --export-solo-xml --trace-level full --profile-output build/composer_repair/405066e/candidate-profile.json --progress
|
||||
```
|
||||
|
||||
Post-generation comparison actually run, with explicit role and alignment conventions:
|
||||
|
||||
```
|
||||
-m audition.solo_compare --generated-dir build/composer_repair/405066e/candidate/solo_xml --reference all_of_me/acoustic=build/all-of-me-solo-1.xml --reference all_of_me/electric=build/all-of-me-solo-2.xml --reference autumn_leaves/acoustic=build/autumn-leaves-solo-1.xml --reference autumn_leaves/electric=build/autumn-leaves-solo-2.xml --form-start autumn_leaves/acoustic=2 --form-start autumn_leaves/electric=2 --form-start all_of_me/acoustic=1 --form-start all_of_me/electric=1 --reference-pitch guitar-written --assets build/composer_repair/405066e/candidate --output build/composer_repair/405066e/references
|
||||
```
|
||||
|
||||
The standalone production role interface remains available (example, not part of the benchmark measurements):
|
||||
|
||||
```
|
||||
-m generator.compose --song data/songs/autumn_leaves.xml --role electric_solo --data-dir data --cache-dir build/build_common/composition_cache --output build/electric-role.json --solo-xml build/electric-role.xml
|
||||
```
|
||||
|
||||
Both CLI and CMake support independent process workers. The CMake setting is `VAMP_COMPOSITION_JOBS`; default 2, accepted range 1–16. More workers can increase memory/CPU contention. Worker completion order is not a musical input.
|
||||
|
||||
All baseline/reference/audition paths are downstream evidence only. Deleting them is not a cache invalidation or musical configuration change. To test cold generation, use an empty **composition cache** directory, not a previous output score as an input.
|
||||
|
||||
|
||||
Isolated single-role measurements actually run sequentially after regression and audition work completed:
|
||||
|
||||
```
|
||||
-m audition.benchmark --source tests/evaluation_sources/after-youve-gone.xml --data-dir data --role electric_solo --cache build/composer_repair/405066e/benchmark-cache --output build/composer_repair/405066e/profile-cold --profile
|
||||
-m audition.benchmark --source tests/evaluation_sources/after-youve-gone.xml --data-dir data --role electric_solo --cache build/composer_repair/405066e/benchmark-cache --output build/composer_repair/405066e/profile-warm
|
||||
-m audition.benchmark --source tests/evaluation_sources/after-youve-gone.xml --data-dir data --role electric_solo --cache build/composer_repair/405066e/benchmark-unprofiled-cache --output build/composer_repair/405066e/benchmark-cold
|
||||
```
|
||||
|
||||
The first run measures profiler overhead as well as generation. The third uses a separate initially empty cache to measure unprofiled cold generation. All three canonical musical hashes are checked in `isolated-role-proof.json`.
|
||||
|
||||
Isolated full warm-cache build actually run:
|
||||
|
||||
```
|
||||
-m generator --data-dir data --output-dir build/composer_repair/405066e/warm --static-assets-dir package/assets --check --jobs 2 --composition-jobs 2 --composition-cache build/composer_repair/405066e/cache --engraving-cache build/build_common/engraving_cache --export-solo-xml --trace-level full --profile-output build/composer_repair/405066e/warm-profile.json --progress
|
||||
```
|
||||
@@ -0,0 +1,25 @@
|
||||
# Production data and consumer inventory
|
||||
|
||||
All additions are independently authored general rules under the repository MIT license. No optional target pitches, rhythm fingerprints, statistics, fitted weights, or derivatives were added. Existing source songs and target files are untouched.
|
||||
|
||||
| Resource | Action / count | Live consumer and reason |
|
||||
|---|---|---|
|
||||
| `data/songs/*.xml` | Keep both authoritative sources | Import/immutable analysis; no source archive overwrite |
|
||||
| `data/scales` | Keep 21 patterns | Seven modes each of major, melodic minor, harmonic minor; ordinary mapped permission |
|
||||
| `data/sequences` | Keep 2,954 paths (14/196/2,744) | Exact degree-route utility; not uniform lick sampling |
|
||||
| `data/rhythms` | Keep 3,538 snippets (34 2/4, 146 3/4, 630 4/4, 2,728 5/4) | Meter-indexed retrieval; 5/4 does not compete in 4/4 |
|
||||
| `composition/rhythms.json` | Extend nine cells with entry/exit/subdivision semantics; keep six comping figures | `vocabulary.rhythm_cells`, `themes.rhythm_windows`, `comping.Canonical` |
|
||||
| `composition/melodic_vocabulary.json` | Extend eleven cells similarly; retain four chord traversal rules | Complete rhythmic groups plus transposable chord-member paths |
|
||||
| `composition/grammar.json` | Add reachable operation chooser, answer/extend/fragment contracts, authoritative evaluation configuration | `themes.operation_choices`, `feature`, `scoring.musical`; preserves existing development contracts where applicable |
|
||||
| `composition/harmony.json` | Keep eleven optional color policies; add bounded prepared step-down suspension policy | Typed full-duration expression validation and candidate construction |
|
||||
| `composition/lead_ins.json` | Keep seven formulas and two blues rules | Whole approach/target contracts, direct alternatives always available |
|
||||
| `composition/roles.json` | Replace source octave offsets and fixed register cycles with overlapping soft centers and alternative regions | Both instruments use all six strings, frets 1–12; no equal-use quotas |
|
||||
| `data/expected/performance_summary.json` | Keep validation-only | Form/layout compatibility check, never winner selection |
|
||||
| `audition/controls/original_lead_theme.json` | Already migrated outside production; keep optional | No production read; runtime read boundary excludes audition files |
|
||||
| Saved outputs and references under `build/` | Keep comparison-only | Separate explicitly invoked audition commands |
|
||||
|
||||
The JSON version remains 1 with additive named fields; loader rejects missing provenance, duplicate IDs and unsupported subdivision groups. Event/runtime/score schemas did not change. `composer-report-2` and `joint-musical-1` identify diagnostic and evaluation schemas. Semantic generation is `joint-gestures-1`; instrumentation does not intentionally reseed music.
|
||||
|
||||
The old “prefix then cheap suffix” constructor and overriding thematic scorer were removed. Legacy nonproduction fixture helpers remain explicit, with no fallback from the current production route. Exhaustive path inventories and other meters are useful and were not deleted for directory size.
|
||||
|
||||
Evaluation-only additions: `tests/evaluation_sources/{after-youve-gone,indiana,hindustan}.xml` plus provenance JSON and README; `audition.transfer_review` is their sole consumer. These are four-measure original-song excerpts with declared piano-harmony reductions, not expected generated output or a production phrase bank. They were transcribed from cited original editions after the production vocabulary was authored. Neither ordinary builds nor required regression tests load them. The separate optional command records generation failures without relaxing policy.
|
||||
@@ -0,0 +1,31 @@
|
||||
# Independent-input and reproducibility evidence
|
||||
|
||||
The normal dependency is `original source → immutable SourceAnalysis → generate_role(role, settings, data) → assembly`. No pairwise winner selection, generated foreground prediction, responsive comping or other-role grip reuse was introduced. Acoustic/electric accompaniment remains canonical by source form position. Source-defined windows suppress a guitar's accompaniment while that same guitar solos and protect the returning vocal pickup before construction.
|
||||
|
||||
`generator.input_audit.composition` installs a scoped Python audit hook. Composition reads are restricted to production data, generator code, Python runtime and that role's cache directory. Read/write handles do not bypass the rule. Reads of optional references, audition snapshots, previously published scores or another role's concrete cache are rejected. Original source content is supplied explicitly as immutable canonical analysis, before this scope. Rendering/assembly legitimately consume finished assets outside the scope.
|
||||
|
||||
This is an internal dependency guard, not a hostile-code security sandbox. Provenance review is still needed: a runtime deletion test alone would not detect target-derived material already copied into production data. All newly authored rules were reviewed as general operations; no target score contents were consulted during production authoring.
|
||||
|
||||
Command actually run through the repository Python runner:
|
||||
|
||||
```
|
||||
-m audition.dependency_check --output build/composer_repair/405066e/dependency
|
||||
```
|
||||
|
||||
`dependency/dependency.json` records actual read paths and canonical hashes for six roles using an independently authored one-bar C7 source and **real production catalogs**. All roles matched across standalone cold builds, reversed warm builds, reversed two-process cold builds, deliberately invalid optional target files present, targets deleted, and generation after an electric-only setting change. This is a dependency test, not a claim of whole-chorus artistic equivalence.
|
||||
|
||||
| Role | Stable document SHA-256 |
|
||||
|---|---|
|
||||
| Acoustic accompaniment | `2c3cc9efe4c6fbe7c1f8206d57e7f7d3a66bdadc9dbc2c657ea3d2d600425741` |
|
||||
| Electric accompaniment | `b89eedfd82fcfe83475c13cdf461c7123a8c99137bb0452875e3d2509267e183` |
|
||||
| Electric melody | `b8d18ef6fd65b204bd2fc2b69e660068890cb30aea6db827c3f3b506284ea2a1` |
|
||||
| Vocal melody | `e3348117b9c63771cfa0439f276bdadf0d26dd6e560c9676c97e12a4a713737b` |
|
||||
| Acoustic solo | `2d91f4f14615f6aa65c8f46ff0c8d858da1e808d8d132723c37342c20ea13e5b` |
|
||||
| Electric solo | `78640b8c8776735638141f1d34cf820a737b2891cae4c4529b6907a448c272f3` |
|
||||
|
||||
Required tests also check irrelevant title/export-ID changes, changed original melody under unchanged harmony, unrelated song addition, role-specific settings, tuplets through assembly, and cache digest validation. Optional reference adapters remain under `audition/`; production rejects supplied reference objects. Performance measurements and observed read lists are excluded from stable asset reports, so timing variation does not make otherwise equal assets differ.
|
||||
|
||||
Cache identity covers source semantics/notation, relevant role data, shared musical resources, role settings, algorithm version and relevant code. Code edits can invalidate caches; instrumentation does not intentionally alter musical choice seeds. Concrete route caches retain sounding timing/endpoints/collection context, and phrase caches retain incoming history and theme. Process completion order only determines reporting order, never a musical winner.
|
||||
|
||||
|
||||
Full-song cold/warm evidence: the isolated warm two-process rebuild of both current songs matched **all twelve complete role documents and stable reports**, plus all four exported solo XML files, against the staged build with cold solo caches. [The proof and per-role hashes](../../build/composer_repair/405066e/warm-equivalence.json) record 12.045 seconds and twelve cache hits. The separate four-bar cold/profiled/warm role runs also match one canonical document hash; see [isolated role evidence](../../build/composer_repair/405066e/isolated-role-proof.json). These checks supplement the role-order/parallel/reference-presence exercise; the full-song warm check by itself does not exercise every role-order permutation cold.
|
||||
@@ -0,0 +1,31 @@
|
||||
# Authoritative musical evaluation
|
||||
|
||||
Normal thematic production uses `scoring.musical` and its immutable `MusicalEvaluation` result (`joint-musical-1`). `Phrase.score` is exactly `evaluation.total`. A complete solo is selected by the duration-weighted sum of those complete phrase evaluations. No later post-pass changes the winning notes or adds an undisclosed transition penalty.
|
||||
|
||||
The result exposes validity, pending obligations, exact scope, raw values, denominators, weights, contributions, total and an error. Invalid harmony, identity, protected sounding tails, placement, or activity intent cannot be traded against a low cost. Identity is a contract, not two differently named resemblance rewards. Consequently the proposed redundant soft “theme” weight was not retained: fulfilled identity does not earn ever-increasing credit for copying more events.
|
||||
|
||||
| Contribution | Initial weight | Meaning |
|
||||
|---|---:|---|
|
||||
| Rhythm | 3 | Internal isolated short events / interruptions and actual incoming connection; entrance/release are distinct |
|
||||
| Destination | 2 | Preparation of declared arrivals, including the final approach; no destination obligation at an ordinary frontier |
|
||||
| Harmony | 2 | Time-normalized unexplained exposure; validated typed treatments have their own hard checks |
|
||||
| Register | 1 | Soft overlapping role corridor, weighted by sounding duration |
|
||||
| Repetition | 1 | Bounded recent exact/relative figure and oscillation history; sustains are separate from attacks |
|
||||
| Activity | 1 | Configured broad activity range over active spans, excluding held-arrival/intentional-space demands |
|
||||
| Difficulty | 0.5 | Approximate time-aware fretboard travel, normalized by attacks |
|
||||
|
||||
Weights reside in `data/composition/grammar.json`. These independently authored preferences are not fitted to optional targets and are not a model of aesthetic quality. Source time and chord semantics remain exact rational values. Floating-point arithmetic is confined to soft costs.
|
||||
|
||||
Retrieval uses explicitly separate estimates to keep purposeful rhythmic, register and directional alternatives before expensive route/placement work. Unit and phrase frontiers use elapsed-duration rates when their coverage differs; only complete equal-span candidates enter the authoritative comparison. This is a bounded heuristic, not an admissible global-optimality proof. Cutoff counts are recorded under `selection_trace.operations` and `expression_operations`.
|
||||
|
||||
Tie continuations merge before durations, attack count, harmonic exposure and evaluation. Repeated attacks remain separate. Empty active passages are invalid; intentional space has no fabricated pitch/register cost. Partial expressive gestures carry a pending contract until the actual target/hold is heard; a missing past event or expired deadline fails.
|
||||
|
||||
`--trace-level full` preserves candidate evaluation tables and operation counts in `.roles` reports. Summary mode removes heavy candidate tables only; it does not change generation. Optional profiling reports are outside musical inputs. The report schema is `composer-report-2` and runtime score/notation schemas are unchanged.
|
||||
|
||||
Tests: `tests/test_composer_repair.py`, existing sustained-note/quotation/placement/expression tests, and production score-equals-evaluation assertions. Selected and competing evaluation examples are exported in the release evidence; their aggregate scores establish explainable selection, not listener preference.
|
||||
|
||||
Counterfactual fixtures cover every configured contribution, including nonzero rhythm interruption, destination approach and recent-pattern recurrence. Identity evidence is a hard treatment contract, not a second hidden cost. Exact sustained notes and tie-split versions return equal evaluations. Ordinary mapped nonmember notes may end an open computational unit; they do not acquire an accidental anchor requirement.
|
||||
|
||||
The expressive toggle now means **exclude jointly composed expression candidates**. It can select a different valid complete phrase. It does not promise the decorated winner minus ornament notes. The exported `before_enclosure` stage preserves the selected phrase's actual strict provisional realization for a local controlled comparison; undecorated phrases retain their complete notes rather than becoming silent in that view.
|
||||
|
||||
`Policy.weights` still belongs to the explicit legacy draft/paraphrase API and is not the active thematic evaluator's weight table. The normal score uses `data/composition/grammar.json → evaluation.weights`. The audit distinguishes those consumers; modifying a legacy-only weight is not claimed to affect the new production winner.
|
||||
@@ -0,0 +1,106 @@
|
||||
# Deterministic composer repair — implementation report
|
||||
|
||||
The active production composer was refactored in place. The four complete new solos and independently generated accompaniment are published through the normal CMake target in `build/build_x86_debug/generated_assets/`. The previous release remains under `build/composer_repair/405066e/baseline/`. This is a technically validated candidate musical version, not a claim of listener approval or resemblance to the optional target compositions.
|
||||
|
||||
## What changed
|
||||
|
||||
The previous final-score overwrite is removed. One versioned evaluator supplies the actual selected total, with visible raw values, denominators, weights and contributions. Activity now affects selection. Relative rhythm descriptors replace the absolute-onset proxy. Explicit identity and hold contracts remain hard requirements and are not counted again as duplicate fidelity costs.
|
||||
|
||||
The normal constructor proposes complete pitch/rhythm routes from the incoming state, then checks the declared source/theme relationship. It no longer chooses a motif prefix and a separate cheap suffix. Source features are considered throughout the head; treatment diversity survives seed retrieval. This fixed a real-song failure where all eight retained seeds could demand exact intervals and exclude every rhythm/contour alternative.
|
||||
|
||||
Generated rhythmic edits preserve complete binary/tuplet groups. Open windows request continuation rhythm and have no compulsory chord-tone stop. Local settles remain open; cadential completion and handoff have actual held-ending contracts. The original realized theme stays available for returns, while answer, extension, fragment and free continuation are reachable operations. Bounded two-sided join revisions compete with the original phrase.
|
||||
|
||||
Approaches, enclosures, chromatic connections, colors, anticipations and prepared suspensions now compete over provisional phrases **before selection of the phrase/chorus**. Direct alternatives remain. Exact timing, target octave, preparation, resolution, complete sounding span and protected tails are checked. This is still bounded rewriting of complete provisional phrases, not exhaustive joint search over every possible expression and note.
|
||||
|
||||
Acoustic and electric have overlapping soft register preferences instead of source-octave anchoring and compulsory electric transposition. Both retain strings 1–6, frets 1–12, no open strings. The existing phrase-placement path, sparse canonical source-only accompaniment and independent spawn-process architecture were retained. No generated role supplies another role's musical inputs.
|
||||
|
||||
The runtime/notation representation is unchanged. Timing, source harmony, the 21 collection patterns, vocal handoff, source melody/vocal content and physical constraints remain. All four new exported XML sounding streams match their saved role documents exactly. Vocal and electric head-melody role documents are byte-equivalent as parsed JSON to the baseline for both songs.
|
||||
|
||||
## Evidence and review artifacts
|
||||
|
||||
- [Active call path, confirmed findings and budgets](active_path_audit.md)
|
||||
- [Production data inventory and provenance](data_migration.md)
|
||||
- [Authoritative evaluator and toggle semantics](evaluation_contract.md)
|
||||
- [Capabilities, tests and limits](musical_capability_matrix.md)
|
||||
- [Independent-input proof](dependency_proof.md)
|
||||
- [Selected phrase traces and local alternative score breakdowns](../../build/composer_repair/405066e/evidence/phrase_traces.md)
|
||||
- [Machine-readable operation funnels, hashes and evaluations](../../build/composer_repair/405066e/evidence/evidence.json)
|
||||
- [Baseline/new/source/plain/strict/final listening page](../../build/composer_repair/405066e/auditions/index.html)
|
||||
- [Separate optional target comparison](../../build/composer_repair/405066e/references/index.html)
|
||||
|
||||
The listening page contains complete solos, excerpts, solo-only audio, fixed comparison backing, and independently assembled final backing. Rendering uses consistent neutral synthesis and levels. Signal checks covered 112 WAV files with zero full-scale samples (largest absolute 16-bit sample 16,377); this checks clipping, not perceptual balance or musical quality. The strict view restores each selected phrase's valid provisional version; it does not remove chromatic notes and leave timing holes. A phrase without decoration remains audible in that view.
|
||||
|
||||
The local strict/decorated comparison isolates selected expression edits. Baseline versus new production changes multiple mechanisms and cannot identify which one caused a subjective improvement. Separate whole-chorus ablations restoring each superseded defect were **not** produced; broken old objectives were not retained as normal production branches. No ear-based audition was performed or claimed.
|
||||
|
||||
## Selected output facts
|
||||
|
||||
| Song / role | New attacks | Sounding span available | Range, sounding MIDI |
|
||||
|---|---:|---:|---|
|
||||
| All of Me acoustic | 120 | 128 quarter beats | 42–64 |
|
||||
| All of Me electric | 106 | 128 quarter beats | 48–67 |
|
||||
| Autumn Leaves acoustic | 100 | 128 quarter beats | 49–69 |
|
||||
| Autumn Leaves electric | 103 | 125 quarter beats | 46–70 |
|
||||
|
||||
All four pass full harmonic validation with no unresolved obligations. These counts/ranges are observations, not quotas or evidence of musical preference. The three protected quarter beats at the returning Autumn Leaves vocal are explicitly excluded from the electric solo's allocation.
|
||||
|
||||
For example, All of Me electric has an open continuation over beats 20–42, a local settle on B3 at 104.5–107.5, and a final G3 handoff at 123–126 followed by space. Its selected actions include rhythm and contour development, answers, fragments, a clear return and a free continuation. All of Me acoustic selects a prepared suspension and an anticipation; these are real validated events, not unused vocabulary labels. The full trace reports proposed/valid/retained candidates and the selected actions separately.
|
||||
|
||||
Autumn Leaves electric selects more free continuations and no explicitly labeled full return. That is a useful listening question about identity retention, not an invitation to enforce a return quota. Autumn Leaves acoustic repeatedly resolves to D4 in its earlier cadential passages; the report exposes this rather than interpreting pitch diversity as automatic improvement.
|
||||
|
||||
## Reference and source handling
|
||||
|
||||
The authoritative source files are still `data/songs/all-of-me.xml` and `data/songs/autumn_leaves.xml`. Named source/target ZIP archives and supplied review Markdown were not found; existing extracted files were used only in their authorized roles. No source was overwritten from another arrangement.
|
||||
|
||||
The four optional `build/*-solo-1.xml` / `*-solo-2.xml` references are unchanged, verified by SHA-256. Their contents were first used here by a separate post-generation comparison, not to author production rules. Solo 1 maps to acoustic; Solo 2 maps to electric. The adapter preserves raw pitches and applies the explicitly confirmed guitar-written minus-one-octave convention only to its normalized comparison. Autumn Leaves aligns at measure 2 / first Gm7 and retains its preceding measure; All of Me starts at measure 1. All four normalized reference solos have a legal placement under the current domain. This is not a complete ergonomic assessment. Four Autumn electric reference events extend beyond the production vocal-protection cutoff and are reported rather than clipped or imported.
|
||||
|
||||
The additional transfer review uses independently transcribed four-measure excerpts from the original editions of After You've Gone, Indiana and Hindustan, with declared harmonic reductions and provenance outside `data/`. All six roles completed for each excerpt. These are limited transfer probes, not complete standard/form coverage or pristine external judgments of quality. No production policy was fitted to those outputs.
|
||||
|
||||
## Performance and reproducibility
|
||||
|
||||
Hardware: Intel Core i7-1355U, 12 logical CPUs; two composition processes and two engraving workers. Deterministic expansion budgets are used; elapsed time never selects a winner.
|
||||
|
||||
The full candidate build took **1,576.3 seconds (26.3 minutes)**. Solo caches were cold, accompaniment/head caches were warm, and regression/diagnostic work overlapped; this is an observed build cost, **not an isolated cold benchmark or a clean before/after speedup claim**. Individual cold-role elapsed times were 828.6s / 645.1s for All of Me acoustic/electric and 809.8s / 722.9s for Autumn Leaves acoustic/electric. Worker times overlap and must not be added as total wall time. Engraving rendered 92 new pages, reused two complete scores and took 11.3s wall time.
|
||||
|
||||
The normal cached CMake rebuild took **25.4 seconds**, with all twelve role caches and all six engraving results reused, while regression tests were running. Both source songs' published solo XML files are identical to the staged validated candidates. The profile files distinguish cache lookup from original search work. A later **isolated warm full build took 12.045 seconds** with twelve role-cache hits and two workers. All twelve role documents, their stable reports, and all four solo XML files matched the staged build exactly; `warm-equivalence.json` records their hashes.
|
||||
|
||||
An isolated single-process four-bar **After You've Gone electric solo** benchmark took **19.924s cold** and **0.930s warm**, excluding interpreter startup and output-report writing. Source analysis took about 0.006s separately. Both used the real production catalogs and identical settings; the cold, warm and profiled runs produced the same canonical document hash (`5b2525a214ed7f30971752434faad2a39ca22adddcfc9947c009e1431b77187b`). These are excerpt-role measurements, not estimates for a complete chorus. No concurrent tests or audition rendering ran during these benchmarks.
|
||||
|
||||
A separate cProfile run of that same cold role took 63.770s including profiler overhead. Nested cumulative times were catalog loading 17.889s, complete composer 44.310s, route candidates 23.073s, harmonic validation 2.949s, expression alternatives 1.625s, placement 0.694s and final evaluation 0.509s. JSON writing was about 0.108s; report/provenance construction is also distributed among composer calls and is not fully isolated by that number. These nested times must not be summed. Full function evidence is in `profile-cold/{role.prof,profile.txt,stages.json}`; the measured cold/warm hash proof is `isolated-role-proof.json`.
|
||||
|
||||
A construction profile identified sequence retrieval, repeated ranking/representation and harmonic checks as costs. Ranking now computes each key once per cutoff; immutable interval descriptors are memoized. Stable-order tests verify unchanged ordering for tied ranks. A narrow 800-item/30-repeat microbenchmark returned identical selections (0.826s original versus 0.806s optimized); this is deliberately not presented as a whole-build speedup. More efficient cold search remains unfinished performance work; no beam was widened to hide candidate defects.
|
||||
|
||||
The dependency exercise used real catalogs and an independently authored source. All six role hashes matched when built alone, in reverse order, in two spawned processes, warm/cold, with invalid optional target files present/absent, and after an electric-only setting change. Actual read traces and a runtime guard accompany equality tests. This does not by itself prove absence of an already embedded derivative; the independently authored data provenance is separately reviewed.
|
||||
|
||||
## Commands and verification
|
||||
|
||||
All Python commands below were run with:
|
||||
|
||||
```
|
||||
build/build_common/python/bin/python3 build/build_tools/python_runner.py build/build_common/modulus
|
||||
```
|
||||
|
||||
Append the relevant module/arguments:
|
||||
|
||||
```
|
||||
-m unittest discover -s tests -p 'test_*.py'
|
||||
-m unittest tests.test_composer_repair tests.test_solo_leads.CompleteRouteTests
|
||||
-m unittest tests.test_solo_themes.ThemeProduction.test_library_routes_match_the_actual_complete_theme
|
||||
-m audition.dependency_check --output build/composer_repair/405066e/dependency
|
||||
-m audition.transfer_review --output build/composer_repair/405066e/transfer-final
|
||||
-m audition.release_evidence --assets build/composer_repair/405066e/candidate --output build/composer_repair/405066e/evidence
|
||||
-m audition.production_review --assets build/composer_repair/405066e/candidate --baseline build/composer_repair/405066e/baseline --output build/composer_repair/405066e/auditions
|
||||
```
|
||||
|
||||
The full generator invocation and reference comparison are recorded in [reproduction commands](commands.md). Publication used `cmake --build build/build_x86_debug --target vamp_generated_assets -j2`. Native verification used `ctest --test-dir build/build_x86_debug -R '^product_vamp$' --output-on-failure`.
|
||||
|
||||
Earlier runs deliberately remain in the evidence directory: the first suite exposed timer leakage in supposedly stable reports and obsolete fixed-closure/phrase-count expectations. Those were repaired. A later 565-test run passed 564 tests and exposed the obsolete requirement for an unedited route in every selected fixture. The corrected provenance test passed (115.4s including class construction); the final full-suite rerun passed **all 565 tests in 737.334 seconds**, recorded in `tests-complete.log`. The focused 19-test repair/route run passed. The native suite initially failed sandbox-denied localhost socket operations; rerunning with the required local socket access passed. After publication, the native CTest target passed again in **18.91 seconds**. These infrastructure failures were not musical validation failures.
|
||||
|
||||
## Boundaries and next experiment
|
||||
|
||||
- Cold construction is still costly. The next performance step should profile purpose-conditioned route retrieval and repeated provenance work with fixed musical hashes, rather than indiscriminately widening or shrinking search.
|
||||
- The frontier is bounded and can miss a viable theme/destination combination. Exhaustion is reported as budget exhaustion, not a proof of incompatibility; there is no hidden old-generator fallback.
|
||||
- The final evaluator is inspectable but intentionally small. It does not establish memorability or predict listener preference.
|
||||
- Current production chooses complete actions before crossing the search frontier; the partial-treatment API supports bounded pending obligations, but this is not an unbounded multi-phrase optimizer.
|
||||
- Unsupported written chord stacks still produce explicit no-exact-map diagnostics. Complex importer/form conventions beyond existing support are not newly certified. Original rhythms are never silently quantized.
|
||||
- Legal TAB and approximate travel costs are not a complete biomechanical model. Independent backing cannot guarantee exact gaps around a solo's realized holds; no reactive recomposition is claimed.
|
||||
- Listen first to whether the introduced idea remains recognizable in Autumn Leaves electric's freer continuation. Compare the plain/strict/final versions before changing density, return counts or chromatic vocabulary. The optional target comparisons remain outside the selection process.
|
||||
@@ -0,0 +1,28 @@
|
||||
# Musical capability and limits
|
||||
|
||||
| Capability | Representation / live operation | Validation |
|
||||
|---|---|---|
|
||||
| New source-influenced theme | Features throughout original head → complete joint pitch/rhythm statement | Source change test; explicit feature evidence; whole-head near-copy check |
|
||||
| Recognizable return | Original realized signature retained, with harmonic adaptation | Multi-event rhythm/interval contract; no one-note perfect match |
|
||||
| Answer / extension / fragment | Data-defined chooser in normal `themes.phrase_candidates` | Independent positive operation-realization tests |
|
||||
| Free connected movement | Complete route conditioned on actual incoming pitch and future destination | All mapped spans, full route export correspondence; no mandatory basic endpoint |
|
||||
| Rhythm groups | Binary, complete ternary and supported sixteenth groups; delayed entrances and cross-bar notes | Incomplete tuplet/residual drift rejected; imported timing never quantized |
|
||||
| Open / local settle / completion / handoff | Open alternative; intermediate holds; cadential and source-boundary terminal contracts | Actual sounding hold, release and post-target motion checks |
|
||||
| Two-sided join revision | Fixed outer endpoints, editable material on both sides | Full affected harmony, identifying features and protected tails revalidated |
|
||||
| Approaches / enclosures / connections | Complete target-relative formulas in joint phrase alternatives | Exact octave, timing, preparation where required and complete resolution |
|
||||
| Optional color | Quality/function/degree policy, distinct from written chord requirements | Full duration, exclusions/omissions, bounded exposure and specified resolution |
|
||||
| Anticipation | Bounded early onset into actual future harmony | Pre-boundary contract and arriving collection/chord checked independently |
|
||||
| Prepared suspension | Explicit actual preparation and delayed downward resolution | Preparation, deadline, target and mapped sounding interval |
|
||||
| Blues inflection | Two conservative prepared semitone-resolution rules | Actual preparation and appropriate chord target; no blanket exemption |
|
||||
| Guitar domain | Both roles all six strings, frets 1–12, no open strings | Full phrase path; ties keep exact position |
|
||||
| Sparse accompaniment | Source-only canonical shells/compact voicings with rhythmic space | Written degrees/bass responsibility and repeated-form consistency |
|
||||
|
||||
Not every eligible operation is guaranteed to survive a bounded search or occur in either current song. Trace counts distinguish proposed, valid and retained candidates. A zero selected count is not evidence of a feature being absent from the code, and merely loading data is not evidence of reachability.
|
||||
|
||||
Known boundaries: sources must satisfy the existing importer/arrangement form contract; ambiguous exporter harmony is not repaired from a target. Exact unsupported chord stacks still fail scale mapping contextually. Physical validation is a limited hand-region/travel model, not a complete ergonomic guarantee. Shape-changing treatments compete over provisional complete phrases; this is not an unbounded jointly optimized chorus. Cross-window continuation still uses bounded lookahead, so phrase partition choices can change winners even though evaluating the same sounded candidate is partition-invariant.
|
||||
|
||||
The additional source review uses independently transcribed historic-source excerpts, kept outside `data/`, after production vocabulary freeze. These are transfer diagnostics rather than a claim of comprehensive coverage of every standard, meter or arrangement convention. Optional four-target comparison uses guitar-written normalization once and explicit form alignment; original encoded evidence remains available. No auditory judgment is claimed from event/signal checks alone.
|
||||
|
||||
Final additional-source run: all six independent roles completed for each of After You've Gone, Indiana and Hindustan (18 role generations), with exact source excerpt timing and ordinary physical validation. [the final transfer report](../../build/composer_repair/405066e/transfer-final/report.json) records hashes, times and scope. No vocabulary was fitted from this run. Short excerpts are useful evidence of source dependence and basic transfer, not evidence that the entire standards' forms or every original piano chord are supported.
|
||||
|
||||
A repeated attack is now a named low-level primitive, distinct from a zero step smuggled into the nonzero interval catalog and distinct from one tied sustain. The complete-route test retains the exact authored descending path while permitting additional explicitly constructed chord/repetition routes. This deliberately changes the old one-candidate expectation, not the endpoint or scale constraint.
|
||||
+21
-1
@@ -1,6 +1,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
import shutil
|
||||
import tempfile
|
||||
@@ -44,6 +45,8 @@ def parse_args() -> argparse.Namespace:
|
||||
parser.add_argument("--composition-jobs", type=int, default=2, choices=range(1, 17), metavar="1-16")
|
||||
parser.add_argument("--composition-cache", type=pathlib.Path)
|
||||
parser.add_argument("--export-solo-xml", action="store_true", help="Export completed solo roles as comparison MusicXML, without recomposing.")
|
||||
parser.add_argument("--trace-level",choices=("summary","full"),default="summary",help="Diagnostic detail only; does not seed composition.")
|
||||
parser.add_argument("--profile-output",type=pathlib.Path,help="Write build and per-role elapsed timings (not a search timeout).")
|
||||
parser.add_argument("--progress", action="store_true")
|
||||
args = parser.parse_args()
|
||||
if not args.renderer_fingerprint and (args.data_dir is None or args.output_dir is None):
|
||||
@@ -65,8 +68,12 @@ def generate_assets(args: argparse.Namespace) -> None:
|
||||
raise ValueError('composition cache and generated assets must not overlap')
|
||||
progress = getattr(args, 'progress', False)
|
||||
started = time.monotonic()
|
||||
timings=[];stages=[];last_stage=started
|
||||
|
||||
def report(message):
|
||||
nonlocal last_stage
|
||||
now=time.monotonic()
|
||||
stages.append({'completed_before':message,'seconds':now-last_stage});last_stage=now
|
||||
if progress:
|
||||
print(f'Assets [{time.monotonic() - started:.0f}s]: {message}', flush=True)
|
||||
|
||||
@@ -90,7 +97,14 @@ def generate_assets(args: argparse.Namespace) -> None:
|
||||
copy_runtime_fonts(static_assets_dir, staged)
|
||||
report('generating performance parts')
|
||||
performance_count = generator.arrange.generate.generate_performance_scores(data_dir / 'songs', staged / 'songs', rhythms=rhythms, scales=scales, sequences=sequences,
|
||||
composition_jobs=getattr(args,'composition_jobs',2), cache_dir=getattr(args,'composition_cache',None), progress=progress)
|
||||
composition_jobs=getattr(args,'composition_jobs',2), cache_dir=getattr(args,'composition_cache',None), progress=progress,timings=timings)
|
||||
if getattr(args,'trace_level','summary')=='summary':
|
||||
for path in (staged/'analysis').glob('*.roles'):
|
||||
roles=json.loads(path.read_text())
|
||||
for role in roles.values():
|
||||
trace=role.get('details',{}).get('selection_trace',{})
|
||||
trace.pop('evaluations',None);trace.pop('source_candidate_pools',None)
|
||||
path.write_text(json.dumps(roles,sort_keys=True,indent=2))
|
||||
if getattr(args, 'export_solo_xml', False):
|
||||
from generator.solo.export import export_tree
|
||||
export_tree(staged)
|
||||
@@ -110,6 +124,12 @@ def generate_assets(args: argparse.Namespace) -> None:
|
||||
with modulus.filesystem.publish_directories([(staged, output_dir)]):
|
||||
pass
|
||||
report('publishing complete')
|
||||
profile_path=getattr(args,'profile_output',None)
|
||||
if profile_path:
|
||||
import platform,os
|
||||
profile_path.parent.mkdir(parents=True,exist_ok=True)
|
||||
profile_path.write_text(json.dumps({'total_seconds':time.monotonic()-started,'stages':stages,'roles':timings,
|
||||
'platform':platform.platform(),'cpus':os.cpu_count(),'workers':getattr(args,'composition_jobs',2)},indent=2))
|
||||
print(f'Generated Product Vamp assets: {performance_count} performance scores.')
|
||||
if args.check:
|
||||
print('Generator check passed.')
|
||||
|
||||
@@ -143,6 +143,6 @@ def _arrange_document(document: dict, part_type: str, plans: dict[int, generator
|
||||
reports.append(report)
|
||||
return result
|
||||
|
||||
def generate_performance_scores(source_dir: pathlib.Path, output_dir: pathlib.Path, *, rhythms=None, scales=None, sequences=None, composition_jobs=2, cache_dir=None, progress=False) -> int:
|
||||
def generate_performance_scores(source_dir: pathlib.Path, output_dir: pathlib.Path, *, rhythms=None, scales=None, sequences=None, composition_jobs=2, cache_dir=None, progress=False, timings=None) -> int:
|
||||
from generator.production import generate_tree
|
||||
return generate_tree(source_dir, output_dir, jobs=composition_jobs, cache_dir=cache_dir, progress=progress)
|
||||
return generate_tree(source_dir, output_dir, jobs=composition_jobs, cache_dir=cache_dir, progress=progress,timings=timings)
|
||||
|
||||
@@ -26,6 +26,6 @@ def main():
|
||||
from generator.solo.export import write_role
|
||||
manifest=write_role(result,args.solo_xml)
|
||||
args.solo_xml.with_suffix('.manifest.solo').write_text(json.dumps(manifest,indent=2)+'\n')
|
||||
print(f'{args.role}: {time.monotonic()-start:.2f}s wall; cached={result["cache_hit"]}; original composition {result["seconds"]:.2f}s')
|
||||
print(f'{args.role}: {time.monotonic()-start:.2f}s wall; cached={result["cache_hit"]}; role generation/cache lookup {result["seconds"]:.2f}s')
|
||||
|
||||
if __name__=='__main__':main()
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Composition read boundary, independent of optional audition/reference tools."""
|
||||
from __future__ import annotations
|
||||
import contextlib
|
||||
import contextvars
|
||||
import os
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
ACTIVE=contextvars.ContextVar('composition_reads',default=None)
|
||||
|
||||
|
||||
def _read(event,args):
|
||||
scope=ACTIVE.get()
|
||||
if scope is None or event!='open':return
|
||||
name,mode,flags=args
|
||||
if not isinstance(name,(str,bytes,os.PathLike)):return
|
||||
# r+ and w+ can read; they must obey the same boundary as a plain read.
|
||||
if flags & os.O_WRONLY:return
|
||||
path=Path(os.fsdecode(name)).resolve()
|
||||
data,code,cache,reads=scope
|
||||
python_runtime=any(path.is_relative_to(Path(root).resolve()) for root in (sys.base_prefix,sys.prefix))
|
||||
allowed=path.is_relative_to(data) or path.is_relative_to(code) or python_runtime
|
||||
if cache and path.is_relative_to(cache):allowed=True
|
||||
if not allowed:raise ValueError('Forbidden composition input: '+str(path))
|
||||
reads.add(str(path))
|
||||
|
||||
|
||||
sys.addaudithook(_read)
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def composition(data,role,cache=None):
|
||||
reads=set()
|
||||
code=Path(__file__).resolve().parent
|
||||
token=ACTIVE.set((Path(data).resolve(),code,Path(cache).resolve()/role if cache else None,reads))
|
||||
try:yield reads
|
||||
finally:ACTIVE.reset(token)
|
||||
+17
-4
@@ -43,7 +43,7 @@ class SourceAnalysis:
|
||||
staff.update(id='source', name='Source')
|
||||
melodic = analysis.analyze(prepared)
|
||||
content = {'melody': [(str(n.start), str(n.end), dataclasses.asdict(n.pitch)) for n in melodic.melody],
|
||||
'measures': [{k: m.get(k) for k in ('duration', 'meter', 'key', 'harmonies', 'tempos', 'section_label', 'implicit')} for m in staff['measures']]}
|
||||
'measures': [{k: m.get(k) for k in ('duration', 'time_signature', 'key', 'harmonies', 'tempos', 'section_label', 'implicit')} for m in staff['measures']]}
|
||||
# Fraction/string spelling is canonical and never includes filesystem IDs.
|
||||
key = hashlib.sha256(json.dumps(content, sort_keys=True, default=str).encode()).hexdigest()
|
||||
return cls(json.dumps(prepared, sort_keys=True), key)
|
||||
@@ -148,6 +148,18 @@ def _fill(notes, length, prefix, voice='voice_arranged'):
|
||||
|
||||
|
||||
def generate_role(source, role, data_dir, settings=None, cache_dir=None):
|
||||
from generator.input_audit import composition
|
||||
started=time.monotonic()
|
||||
with composition(data_dir,role,cache_dir) as reads:
|
||||
result=_generate_role(source,role,data_dir,settings,cache_dir)
|
||||
# Observed reads are diagnostics, never cache identity or musical seeds.
|
||||
result['trace']={**result['trace'],'input_boundary':'data, generator code, Python runtime, own role cache'}
|
||||
result['observed_reads']=sorted(reads)
|
||||
result['seconds']=time.monotonic()-started
|
||||
return result
|
||||
|
||||
|
||||
def _generate_role(source, role, data_dir, settings=None, cache_dir=None):
|
||||
if role not in ROLES: raise ValueError('Unknown generation role: '+role)
|
||||
data_dir=Path(data_dir); resources=vocabulary.load(data_dir/'composition')
|
||||
settings=settings or {}
|
||||
@@ -190,7 +202,7 @@ def generate_role(source, role, data_dir, settings=None, cache_dir=None):
|
||||
output=notation.measures(result['staves'][0]['measures'][first:first+count],solo.notes(),'solo_'+part)
|
||||
notation.replace_region(result,first,output);annotate(result,solo,offset)
|
||||
details=report.structure(solo)
|
||||
solo_report=report.describe(solo,scale_library,first,offset)
|
||||
solo_report=report.describe(solo,scale_library,first,offset,detail=details)
|
||||
elif role.endswith('_accompaniment'):
|
||||
canonical=comping.Canonical(document,part,seed)
|
||||
result=generate._arrange_document(document,part,{},owned={'accompaniment'},accompaniment=canonical)
|
||||
@@ -251,7 +263,7 @@ def _job(request):
|
||||
return generate_role(source,role,directory,settings,cache)
|
||||
|
||||
|
||||
def generate_tree(source_dir, output_dir, *, jobs=2, cache_dir=None, progress=False):
|
||||
def generate_tree(source_dir, output_dir, *, jobs=2, cache_dir=None, progress=False, timings=None):
|
||||
if type(jobs) is not int or not 1<=jobs<=16:
|
||||
raise ValueError('composition workers must be between 1 and 16')
|
||||
source_dir,output_dir=Path(source_dir),Path(output_dir)
|
||||
@@ -263,6 +275,7 @@ def generate_tree(source_dir, output_dir, *, jobs=2, cache_dir=None, progress=Fa
|
||||
results={p:{} for p in sources}
|
||||
def accept(path,role,value):
|
||||
results[path][role]=value
|
||||
if timings is not None:timings.append({'source':str(path),'role':role,'seconds':value['seconds'],'cache_hit':value['cache_hit'],'observed_reads':value.get('observed_reads',[])})
|
||||
if progress:print(f'Composition: {path.stem}/{role}: '+('cached' if value['cache_hit'] else f'{value["seconds"]:.1f}s'),flush=True)
|
||||
if jobs==1:
|
||||
for path,role,args in requests:
|
||||
@@ -283,6 +296,6 @@ def generate_tree(source_dir, output_dir, *, jobs=2, cache_dir=None, progress=Fa
|
||||
analysis_dir=output_dir.parent/'analysis';analysis_dir.mkdir(parents=True,exist_ok=True)
|
||||
(analysis_dir/(score.slugify(path.stem)+'.txt')).write_text('\n'.join(results[path][r]['report'] for r in ROLES))
|
||||
# Not a score file: diagnostics are deliberately outside the songs schema.
|
||||
stable={role:{k:v for k,v in value.items() if k not in ('seconds','cache_hit')} for role,value in results[path].items()}
|
||||
stable={role:{k:v for k,v in value.items() if k not in ('seconds','cache_hit','observed_reads')} for role,value in results[path].items()}
|
||||
(analysis_dir/(score.slugify(path.stem)+'.roles')).write_text(json.dumps(stable,sort_keys=True,indent=2))
|
||||
return len(sources)*3
|
||||
|
||||
@@ -31,11 +31,14 @@ def compose(analysis, measures, part, end, *, scales, sequences, rhythms, initia
|
||||
raise ValueError(f'{part} solo, source measure {choice.span.source_measure}, beat {choice.span.beat}, {generator.harmony.symbol(choice.span.chord)}: No exact match within the permitted catalog')
|
||||
from generator.solo import leads
|
||||
context = context if context is not None else generator.solo.realization.SearchContext()
|
||||
context.expressions_enabled = enclosures_enabled
|
||||
options = leads.solo_options(analysis, measures, part, end, choices, sequences, rhythms, context, stage, mode)
|
||||
result = options[0][1]
|
||||
result.diagnostics['strict_composition_seconds'] = time.monotonic()-started
|
||||
from generator.solo import expressions
|
||||
result = expressions.refine(result,enclosures_enabled and stage=='elaborated' and mode=='thematic')
|
||||
if mode!='thematic':result = expressions.refine(result,False)
|
||||
result.diagnostics['enclosures_enabled']=enclosures_enabled
|
||||
result.diagnostics['expressions_selected']=[e.kind for p in result.phrases for e in p.draft.expressions]
|
||||
validate(result)
|
||||
return result
|
||||
|
||||
|
||||
@@ -89,6 +89,17 @@ def validate(notes,contracts,harmony):
|
||||
last=c.events[-1]
|
||||
if rule.get('resolve'):
|
||||
if target is last or not 0<=target.start-last.end<=F(vocabulary.data('harmony')['resolution_gap']) or not 0<abs(target.pitch.number()-last.pitch.number())<=2 or target.pitch.number()%12 not in harmony.members(target.start,target.end):return {},c.id+': unresolved color'
|
||||
elif c.kind=='suspension':
|
||||
rule=next((r for r in vocabulary.data('harmony').get('suspensions',[]) if r['id']==c.rule),None)
|
||||
if not rule or len(c.events)!=1 or c.boundary is None:return {},c.id+': unsupported suspension'
|
||||
held,=c.events
|
||||
if not held.start<=c.boundary-F(rule['preparation'])<c.boundary<held.end:
|
||||
return {},c.id+': insufficient sounding preparation'
|
||||
if held.pitch.number()%12 not in harmony.members(held.start,c.boundary):return {},c.id+': nonchordal preparation'
|
||||
if held.end-c.boundary>F(rule['max_delay']) or target.start!=held.end or target.pitch.number()-held.pitch.number() not in rule['steps']:
|
||||
return {},c.id+': missed suspension resolution'
|
||||
if target.pitch.number()%12 not in harmony.members(target.start,target.end):return {},c.id+': invalid suspension target'
|
||||
if held.pitch.number()%12 not in types.permitted(harmony.choices,held.start,held.end):return {},c.id+': suspension outside mapped collections'
|
||||
elif c.kind=='anticipation':
|
||||
if c.rule!='early_chord_tone' or len(c.events)!=1 or c.target!=c.events[0] or span.start!=c.boundary:
|
||||
return {},c.id+': unknown anticipation or non-boundary target'
|
||||
@@ -116,6 +127,34 @@ def validate(notes,contracts,harmony):
|
||||
return approved,''
|
||||
|
||||
|
||||
def validate_frontier(notes,contracts,harmony,until,complete):
|
||||
"""Validate heard prefixes and bounded future obligations separately.
|
||||
|
||||
Future contract events are used ONLY to establish rule feasibility. They do
|
||||
not count as heard resolution; the contract stays pending until its entire
|
||||
target hold is present. Missing past events and expired deadlines fail.
|
||||
"""
|
||||
if complete:
|
||||
approved,error=validate(notes,contracts,harmony)
|
||||
return approved,(),error
|
||||
actual={n.event_id:n for n in notes};future=dict(actual);pending=[]
|
||||
for c in contracts:
|
||||
required=tuple(dict.fromkeys((*c.events,c.target,*((c.preparation,) if c.preparation else ()))))
|
||||
incomplete=False
|
||||
for expected in required:
|
||||
heard=actual.get(expected.event_id)
|
||||
if expected.start>=until:
|
||||
future[expected.event_id]=expected;incomplete=True
|
||||
elif heard and heard.pitch==expected.pitch and heard.start==expected.start and heard.end==min(until,expected.end):
|
||||
future[expected.event_id]=expected
|
||||
incomplete |= heard.end<expected.end
|
||||
elif not heard or (heard.start,heard.end,heard.pitch)!=(expected.start,expected.end,expected.pitch):
|
||||
return {},(),c.id+': missing/changed event before resolution deadline'
|
||||
if incomplete:pending.append(c)
|
||||
approved,error=validate(tuple(sorted(future.values(),key=lambda n:(n.start,n.event_id))),contracts,harmony)
|
||||
return {key:c for key,c in approved.items() if key in actual},tuple(pending),error
|
||||
|
||||
|
||||
def proposals(phrase,harmony):
|
||||
draft=phrase.draft
|
||||
if not draft or any(n.continuation for n in draft.notes):return
|
||||
@@ -160,6 +199,73 @@ def proposals(phrase,harmony):
|
||||
if actual:
|
||||
actual=tuple(n if a.event_id==target.event_id else a for a in actual)
|
||||
yield actual,types.ExpressionContract(target.event_id+':anticipate','anticipation','early_chord_tone',(n,),n,harmony.at(target.start).chord,boundary=target.start)
|
||||
for i,(before,target) in enumerate(zip(notes,notes[1:])):
|
||||
boundary=target.start
|
||||
if before.end!=boundary or boundary not in {s.start for s in harmony.spans}:continue
|
||||
if not enclosures.editable(draft,before.start,target.end):continue
|
||||
for rule in vocabulary.data('harmony').get('suspensions',[]):
|
||||
delay=min(F(1,2),F(rule['max_delay']))
|
||||
if target.end<=boundary+delay:continue
|
||||
held=dataclasses.replace(before,end=boundary+delay,role='suspension')
|
||||
resolved=dataclasses.replace(target,start=boundary+delay)
|
||||
yield (*notes[:i],held,resolved,*notes[i+2:]),types.ExpressionContract(before.event_id+':suspend',
|
||||
'suspension',rule['id'],(held,),resolved,harmony.at(boundary).chord,boundary=boundary)
|
||||
|
||||
|
||||
def joint_candidates(phrases,incoming,harmony,tempo,context,*,bar=F(4)):
|
||||
"""Expression alternatives compete BEFORE complete-phrase selection.
|
||||
|
||||
This rewrites provisional gestures, never the selected chorus. The direct
|
||||
realization remains available and every alternative uses the same evaluator.
|
||||
"""
|
||||
from generator.solo import realization, sequences, phrasing, groups
|
||||
result=list(phrases)
|
||||
trace=context.diagnostics.setdefault('expression_operations',{})
|
||||
for phrase in phrases:
|
||||
proposed={}
|
||||
for actual,c in proposals(phrase,harmony):
|
||||
counts=trace.setdefault(c.kind,dict(proposed=0,valid=0,retained=0,rejected_by_rule=0))
|
||||
counts['proposed']+=1
|
||||
old_pattern=tuple((n.start-phrase.plan.start,n.end-phrase.plan.start) for n in phrase.draft.notes)
|
||||
new_pattern=tuple((n.start-phrase.plan.start,n.end-phrase.plan.start) for n in actual)
|
||||
if groups.valid(old_pattern) and not groups.valid(new_pattern):
|
||||
counts['rejected_by_rule']+=1;continue
|
||||
if not drafts.contract_valid(phrase.draft,actual)[0]:
|
||||
counts['rejected_by_rule']+=1;continue
|
||||
checked=harmony.evaluate(actual,until=phrase.plan.end,complete=True,expressions=(c,))
|
||||
if not checked.valid:
|
||||
counts['rejected_by_rule']+=1;continue
|
||||
counts['valid']+=1
|
||||
prior=next((n for n in reversed(actual) if n.end<=c.events[0].start),None)
|
||||
join=abs(prior.pitch.number()-c.events[0].pitch.number()) if prior else 0
|
||||
rank=max(0,join-5)+bool(prior and prior.pitch==c.events[0].pitch)
|
||||
proposed.setdefault(c.kind,[]).append((rank,actual,c))
|
||||
# One representative per treatment kind, then a bounded second sweep.
|
||||
options=sequences.diverse([v for values in proposed.values() for v in values],
|
||||
lambda v:(v[0],policy.stable_rank(phrase.plan.seed,v[2].id)),lambda v:v[2].kind,8)
|
||||
for _,actual,c in options:
|
||||
transforms=tuple(dataclasses.replace(t,
|
||||
events=tuple(n.event_id for n in actual if t.start<=n.start<t.end),
|
||||
rhythm=tuple((n.start-t.start,n.end-t.start) for n in actual if t.start<=n.start<t.end))
|
||||
for t in phrase.draft.transformations)
|
||||
changed=dataclasses.replace(phrase.draft,id=phrase.draft.id+':'+c.rule,
|
||||
notes=actual,expressions=(c,),transformations=transforms)
|
||||
candidate=realization.checked_phrase(phrase.plan,changed,actual,incoming.treatments,incoming,harmony,tempo,phrase.edits)
|
||||
if candidate is None:continue
|
||||
trace[c.kind]['retained']+=1
|
||||
state=dataclasses.replace(phrase.state,notes=candidate.state.notes,last=candidate.state.last,
|
||||
motifs=candidate.state.motifs,travel=candidate.state.travel)
|
||||
history=incoming.history
|
||||
for t in transforms:
|
||||
ns=tuple(n for n in actual if n.event_id in t.events)
|
||||
if ns:history=phrasing.remember(history,phrasing.heard(ns,t.operation,bar=bar),bar)
|
||||
state=dataclasses.replace(state,history=history)
|
||||
kept_routes=tuple(r for r in phrase.routes if all(any((n.event_id,n.start,n.end,n.pitch)==
|
||||
(a.event_id,a.start,a.end,a.pitch) for a in actual) for n in r.notes))
|
||||
original=dataclasses.replace(phrase.draft,notes=tuple(n for d in phrase.decisions for n in d.notes))
|
||||
result.append(dataclasses.replace(candidate,state=state,initial=phrase.initial,
|
||||
refined=phrase.refined,before_rhythm=phrase.before_rhythm,before_enclosure=original,routes=kept_routes))
|
||||
return result
|
||||
|
||||
|
||||
def refine(solo,enabled=True):
|
||||
|
||||
@@ -4,7 +4,44 @@ from __future__ import annotations
|
||||
import dataclasses
|
||||
from fractions import Fraction as F
|
||||
|
||||
from generator.solo import drafts, harmonic, types
|
||||
from generator.solo import drafts, harmonic, types, groups
|
||||
|
||||
|
||||
def join_variants(draft,harmony,library):
|
||||
"""Recompose both sides of an editable internal join as one complete route.
|
||||
|
||||
Keep endpoints and exact span. A provisional held tail can reopen into two
|
||||
binary attacks; a committed hold or identifying event is never consumed.
|
||||
Alternatives are returned to the authoritative phrase evaluator.
|
||||
"""
|
||||
from generator.solo import routes, policy
|
||||
fixed=set(draft.protected)|set(draft.structural)|{e for f in draft.features for e in f.events}
|
||||
produced=0
|
||||
for join in (t.start for t in draft.transformations[1:]):
|
||||
inside=tuple(n for n in draft.notes if join-2<=n.start and n.end<=join+2)
|
||||
if len(inside)<3 or any(n.event_id in fixed or n.role=='quote' for n in inside[1:-1]):continue
|
||||
if any(t.start<inside[-1].end and t.end>inside[0].start for t in draft.sustained_tails):continue
|
||||
pattern=tuple((n.start-inside[0].start,n.end-inside[0].start) for n in inside)
|
||||
if not groups.valid(pattern):continue
|
||||
alternatives=[inside]
|
||||
for i,n in enumerate(inside[1:-1],1):
|
||||
if n.end==join and n.end-n.start>=1 and (n.start*2).denominator==1:
|
||||
cut=n.end-F(1,2)
|
||||
alternatives.append((*inside[:i],dataclasses.replace(n,end=cut),
|
||||
dataclasses.replace(n,start=cut,event_id=n.event_id+':extend'),*inside[i+1:]))
|
||||
break
|
||||
for template in alternatives:
|
||||
for route in routes.candidates(template,{template[-1].event_id},harmony,library,harmony.profile.register,'two-sided join'):
|
||||
if route.notes==inside:continue
|
||||
actual=tuple(n for n in draft.notes if n.end<=inside[0].start)+route.notes+tuple(n for n in draft.notes if n.start>=inside[-1].end)
|
||||
if not drafts.contract_valid(draft,actual)[0] or not harmony.evaluate(actual,until=draft.end,complete=True).valid:continue
|
||||
transforms=tuple(dataclasses.replace(t,events=tuple(n.event_id for n in actual if t.start<=n.start<t.end),
|
||||
rhythm=tuple((n.start-t.start,n.end-t.start) for n in actual if t.start<=n.start<t.end)) for t in draft.transformations)
|
||||
changed=dataclasses.replace(draft,id=draft.id+':join:'+route.id,notes=actual,transformations=transforms)
|
||||
yield changed,types.DraftEdit('two_sided_join',inside[0].start,inside[-1].end,
|
||||
tuple(n.event_id for n in inside),tuple(n.event_id for n in route.notes),'complete route over both sides; endpoints and contracts preserved'),route
|
||||
produced+=1
|
||||
if produced>=policy.DEFAULT.join_alternatives:return
|
||||
|
||||
|
||||
def fragmentation(notes):
|
||||
@@ -71,6 +108,7 @@ def revise(draft, harmony, treatments=()):
|
||||
if len(proposals)>=8: break
|
||||
valid=[]
|
||||
for actual in proposals[:8]:
|
||||
if not groups.valid(tuple((n.start-draft.start,n.end-draft.start) for n in actual)):continue
|
||||
if fragmentation(actual)>=fragmentation(notes): continue
|
||||
if not drafts.contract_valid(draft,actual)[0]: continue
|
||||
if not harmony.evaluate(actual,treatments,until=draft.end,complete=True).valid: continue
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
"""Exact rhythmic groups for generated material; imported music is not quantized.
|
||||
|
||||
Binary boundaries may be displaced together. Tuplet runs must return to their
|
||||
entry subdivision phase before binary material resumes. A search boundary is
|
||||
not a rhythmic boundary and must not be used to clip a group.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import dataclasses
|
||||
from fractions import Fraction as F
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class RhythmGroup:
|
||||
start: F
|
||||
end: F
|
||||
family: str
|
||||
events: tuple[tuple[F, F], ...]
|
||||
displacement: F = F()
|
||||
source: str = ''
|
||||
|
||||
|
||||
def describe(pattern, *, origin=F(), source='', imported=False):
|
||||
if not pattern:return ()
|
||||
if imported:
|
||||
return (RhythmGroup(origin, origin+pattern[-1][1], 'source', pattern, source=source),)
|
||||
result=[]; i=0
|
||||
while i<len(pattern):
|
||||
a,b=pattern[i]
|
||||
if b<=a or i and a<pattern[i-1][1]:raise ValueError('overlapping rhythm group')
|
||||
# A complete ternary figure can be intentionally displaced on an eighth.
|
||||
if (b-a).denominator%3==0:
|
||||
if (a*2).denominator!=1:raise ValueError('unexplained tuplet entry phase')
|
||||
start=i; cursor=a
|
||||
while i<len(pattern):
|
||||
x,y=pattern[i]
|
||||
if x!=cursor or (y-x).denominator not in (3,6):break
|
||||
cursor=y;i+=1
|
||||
if (cursor-a).denominator==1:break
|
||||
if i==start or (cursor-a).denominator!=1:
|
||||
raise ValueError('incomplete tuplet group')
|
||||
group=pattern[start:i]
|
||||
result.append(RhythmGroup(origin+a,origin+cursor,'triplet',group,a%1,source))
|
||||
else:
|
||||
if (a*4).denominator!=1 or (b*4).denominator!=1:
|
||||
raise ValueError('unexplained binary subdivision phase')
|
||||
family='sixteenth' if (a*2).denominator!=1 or (b*2).denominator!=1 else 'binary'
|
||||
result.append(RhythmGroup(origin+a,origin+b,family,((a,b),),a%1,source));i+=1
|
||||
return tuple(result)
|
||||
|
||||
|
||||
def valid(pattern):
|
||||
try:describe(pattern);return True
|
||||
except ValueError:return False
|
||||
|
||||
|
||||
def signature(notes):
|
||||
"""Translation-invariant duration, inter-onset and rest vocabulary."""
|
||||
return tuple((n.end-n.start, notes[i+1].start-n.end if i+1<len(notes) else F())
|
||||
for i,n in enumerate(notes))
|
||||
|
||||
|
||||
def broaden(pattern, arrival, release):
|
||||
"""Reopen an editable binary tail; never slice a tuplet or inherit its phase."""
|
||||
if (arrival*2).denominator!=1 or (release*2).denominator!=1:return ()
|
||||
for group in describe(pattern):
|
||||
if group.family=='triplet' and group.start<arrival<group.end:return ()
|
||||
result=tuple((a,min(b,arrival)) for a,b in pattern if a<arrival)+((arrival,release),)
|
||||
return result if valid(result) else ()
|
||||
@@ -150,15 +150,15 @@ class Harmony:
|
||||
|
||||
def evaluate(self, notes, treatments=(), *, until=None, complete=False, enclosures=(), expressions=()):
|
||||
notes = generator.solo.types.sounding_notes(notes)
|
||||
from generator.solo.expressions import validate
|
||||
permissions, expression_error = validate(notes, expressions, self)
|
||||
if expression_error:
|
||||
return Result(False, 0, error=expression_error)
|
||||
from generator.solo.expressions import validate_frontier
|
||||
explicit_frontier=until is not None
|
||||
until = until if until is not None else max((n.end for n in notes), default=fractions.Fraction())
|
||||
permissions, expression_pending, expression_error = validate_frontier(notes,expressions,self,until,complete or not explicit_frontier)
|
||||
if expression_error:return Result(False,0,error=expression_error)
|
||||
ornaments, error = self.enclosure_events(notes, enclosures, until) if enclosures else ({}, '')
|
||||
if error:
|
||||
return Result(False, 0, error=error)
|
||||
pending, valid_contracts = [], []
|
||||
pending, valid_contracts = list(expression_pending), []
|
||||
for treatment in treatments:
|
||||
if treatment.start >= until:
|
||||
continue
|
||||
|
||||
+13
-9
@@ -27,13 +27,17 @@ def shift(notes, octave):
|
||||
|
||||
|
||||
def available(harmony, start, end, *, members=False):
|
||||
if not hasattr(harmony,'available_pitches'):harmony.available_pitches={}
|
||||
span=harmony.at(start)
|
||||
allowed=types.permitted(harmony.choices,start,end)
|
||||
if members:
|
||||
allowed &= harmony.members(start, end)
|
||||
if not span or not span.scale:
|
||||
return ()
|
||||
return tuple(p for i in range(-35, 28) if harmony.profile.register[0] <= (p := types.scale_pitch(span.scale, i)).number() <= harmony.profile.register[1] and p.number()%12 in allowed and placement.positions(p.number(),harmony.profile))
|
||||
if members:allowed &= harmony.members(start,end)
|
||||
if not span or not span.scale:return ()
|
||||
key=(span.scale,allowed,harmony.profile)
|
||||
if key not in harmony.available_pitches:
|
||||
harmony.available_pitches[key]=tuple(p for i in range(-35,28)
|
||||
if harmony.profile.register[0]<=(p:=types.scale_pitch(span.scale,i)).number()<=harmony.profile.register[1]
|
||||
and p.number()%12 in allowed and placement.positions(p.number(),harmony.profile))
|
||||
return harmony.available_pitches[key]
|
||||
|
||||
|
||||
def adapt(notes, harmony):
|
||||
@@ -350,6 +354,7 @@ def thematic_options(analysis,measures,part,end,choices,library,rhythms,context,
|
||||
if elapsed>start:
|
||||
meter=measure['time_signature'];break
|
||||
bar=F(meter.split('/')[0])*4/int(meter.split('/')[1])
|
||||
harmony.bar=bar
|
||||
for source in sources:
|
||||
key=('phrasing',source,incoming,part,end,stage,seed,id(library),id(rhythms),policy.DEFAULT,harmony.profile)
|
||||
if key in context.results:
|
||||
@@ -367,11 +372,10 @@ def thematic_options(analysis,measures,part,end,choices,library,rhythms,context,
|
||||
context.results[key]=pool
|
||||
context.diagnostics.setdefault('source_candidate_pools',{}).setdefault(source.id,[]).extend(
|
||||
{'id':p.draft.id,'score':p.score,'attacks':len(p.draft.notes),'theme':p.state.home.id if p.state.home else None,
|
||||
'ending':str(p.anchors[-1].duration) if p.anchors else None,'returns':len(p.state.returns)} for p in pool)
|
||||
'ending':str(p.anchors[-1].duration) if p.anchors else None,'returns':len(p.state.returns),'evaluation':dataclasses.asdict(p.evaluation) if p.evaluation else None} for p in pool)
|
||||
for candidate in pool:
|
||||
span=float((source.end-source.start)/end)
|
||||
total=cost+span*(candidate.score+phrasing.endpoint_cost(source.end,start,end,incoming.closures,harmony,bar))
|
||||
total+=transition(history[-1] if history else None,candidate)
|
||||
total=cost+span*candidate.score
|
||||
following.append((total,(*history,candidate)))
|
||||
if not pool:failures.append(f'{source.id}: planned sustained destination, feature or incoming continuation')
|
||||
if not following:
|
||||
@@ -385,7 +389,7 @@ def thematic_options(analysis,measures,part,end,choices,library,rhythms,context,
|
||||
finished=[(cost,history) for cost,history in states if history[-1].plan.end==end]
|
||||
if not finished:raise realization.SearchExhausted(f'{part}: phrase-boundary search budget exhausted; not proof of incompatibility')
|
||||
return tuple((rank((cost,phrases))[0],types.Solo(part,choices,phrases,analysis.tempo,end,
|
||||
{**context.diagnostics,'construction':'thematic_recomposition','policy':policy.describe()['fingerprint']},
|
||||
{**context.diagnostics,'selection_total':rank((cost,phrases))[0], 'selection_scope':'duration-weighted complete phrase evaluations; partial frontiers use elapsed-duration rates', 'construction':'thematic_recomposition','policy':policy.describe()['fingerprint']},
|
||||
tuple(types.MelodicPassagePlan(p.plan.passage_id,p.plan.start,p.plan.end,(p.plan.id,),seed) for p in phrases),harmony.profile)) for cost,phrases in finished)
|
||||
|
||||
|
||||
|
||||
@@ -57,9 +57,13 @@ def register_goal(incoming, part, fallback, profile=None):
|
||||
if profile and profile.reference is not None:
|
||||
recent = [p for h in incoming.history[-2:] for _,_,p in h.events]
|
||||
center = round(sum(recent)/len(recent)) if recent else profile.reference
|
||||
trajectory=generator.vocabulary.role(part+'_solo').get('register_motion',[0,4,-3,0])
|
||||
phase=min(len(trajectory)-1,incoming.closures%len(trajectory))
|
||||
goal=profile.reference+trajectory[phase]
|
||||
# Follow a whole-gesture excursion with a possible return, not an
|
||||
# instrument-specific octave or a repeating register cycle.
|
||||
if center>profile.reference+7:goal=profile.reference
|
||||
elif center<profile.reference-7:goal=profile.reference
|
||||
else:
|
||||
motion=incoming.direction*4 if incoming.home else 0
|
||||
goal=profile.reference+motion
|
||||
return max(profile.register[0]+3,min(profile.register[1]-3,round((center+goal)/2)))
|
||||
recent = [p for h in incoming.history[-2:] for _,_,p in h.events]
|
||||
if not recent:
|
||||
@@ -127,7 +131,7 @@ def endings(source, incoming, part, harmony, bar, *, limit=8, final=False):
|
||||
for pitch in available(harmony,arrival,arrival+hold,members=True):
|
||||
if abs(pitch.number()-goal)>12:continue
|
||||
anchor=types.Anchor(f'{source.id}:close:{arrival}:{pitch.number()}',arrival,arrival,pitch,
|
||||
harmony.members(arrival,arrival+hold),harmony.profile.register,hold,'terminal',harmony.at(arrival).chord,
|
||||
harmony.members(arrival,arrival+hold),harmony.profile.register,hold,'terminal' if final or ending_effect(arrival,harmony)=='cadential_arrival' else 'intermediate',harmony.at(arrival).chord,
|
||||
hold_until=arrival+hold,effect=ending_effect(arrival,harmony,final))
|
||||
cadence=sum(h.ending==(pitch.number()%12,arrival%bar,hold) for h in incoming.history)
|
||||
rank=harmony.profile.cost(pitch.number())+destination_cost(pitch,arrival,arrival+hold,harmony,incoming,goal,True)+.16*min(2,cadence)+.035*abs(float(hold)-3)
|
||||
@@ -145,6 +149,7 @@ def appearance_cost(operation, incoming, start, end):
|
||||
|
||||
|
||||
def activity(source, ending):
|
||||
if ending is None:return (types.ActivitySpan(source.start,source.end,'active',F(5,4),F()),)
|
||||
spans=[]
|
||||
if ending.earliest>source.start:
|
||||
spans.append(types.ActivitySpan(source.start,ending.earliest,'active',F(5,4),F()))
|
||||
@@ -154,17 +159,6 @@ def activity(source, ending):
|
||||
return tuple(spans)
|
||||
|
||||
|
||||
def evaluate(notes, incoming, harmony, start, end, bar):
|
||||
"""Final musical cost uses a complete sounding phrase, never cell totals."""
|
||||
notes=types.sounding_notes(notes)
|
||||
checked=harmony.evaluate(notes,until=end,complete=True)
|
||||
if not checked.valid or not notes:return float('inf')
|
||||
density=4*len(notes)/float(end-start)
|
||||
entry=max(0,abs(notes[0].pitch.number()-incoming.last.pitch.number())-5)/12 if incoming.last else 0.
|
||||
leaps=sum(max(0,abs(b.pitch.number()-a.pitch.number())-5)/12 for a,b in zip(notes,notes[1:]))/max(1,len(notes)-1)
|
||||
history_cost=repetition(heard(notes,'develop'),incoming.history,bar)
|
||||
return harmony.profile.cost(profiles.weighted_center(notes))+2*checked.exposure+entry+leaps+.8*history_cost
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=512)
|
||||
def defining_members(symbol):
|
||||
|
||||
@@ -50,7 +50,7 @@ class Policy:
|
||||
enclosure_routes: int = 4
|
||||
enclosure_frontier: int = 8
|
||||
enclosure_max_per_32_bars: int = 4
|
||||
composition_version: str = 'purposeful-phrases-2'
|
||||
composition_version: str = 'joint-gestures-1'
|
||||
|
||||
# Preserve the former default root seeds while decoupling them from policy edits.
|
||||
SEED_NAMESPACE = 'a85abb240d7cfa9d054375b654bcb5c23c746201fd4aed7acf81cb3f4ee720e1'
|
||||
|
||||
@@ -47,10 +47,9 @@ def for_part(part, analysis=None):
|
||||
strings = (1, 2, 3, 4, 5, 6)
|
||||
if analysis is None or not analysis.melody:
|
||||
return Instrument(part, strings)
|
||||
# Analysis contains the prepared concert source. Electric melody is written
|
||||
# two octaves up and sounds one down (parts.build_measure), hence +12.
|
||||
# Use the source voice, never the highest added harmonization voice.
|
||||
shift = generator.vocabulary.role(part + '_solo').get('register_offset', 12 if part == 'electric' else 0)
|
||||
# Source identity is independent of sounding register. Roles have soft,
|
||||
# overlapping centers; all legal positions remain available to both guitars.
|
||||
center=generator.vocabulary.role(part+'_solo').get('register_center',57 if part=='acoustic' else 62)
|
||||
notes=tuple(n for n in analysis.melody if n.end>analysis.body_offset)
|
||||
return Instrument(part, strings, weighted_center(notes) + shift,
|
||||
(min(n.pitch.number() for n in notes) + shift, max(n.pitch.number() for n in notes) + shift))
|
||||
return Instrument(part,strings,center,
|
||||
(min(n.pitch.number() for n in notes),max(n.pitch.number() for n in notes)))
|
||||
|
||||
@@ -510,12 +510,18 @@ def checked_phrase(plan, draft, notes, contracts, incoming, harmony, tempo, edit
|
||||
except ValueError:
|
||||
return None
|
||||
complete = plan.end == (plan.passage_end or plan.end)
|
||||
checked = harmony.evaluate(canonical, contracts, until=plan.end, complete=complete, enclosures=draft.enclosures)
|
||||
checked = harmony.evaluate(canonical, contracts, until=plan.end, complete=complete, enclosures=draft.enclosures, expressions=draft.expressions)
|
||||
valid, _ = generator.solo.harmonic.anchors_valid(draft.anchors, canonical, plan.end, complete=complete, closure=plan.closure)
|
||||
if not checked.valid or not valid or not target_ok(notes, plan.target):
|
||||
return None
|
||||
shared = bool(plan.passage_id and incoming.passage_id == plan.passage_id)
|
||||
score_notes = canonical if shared or notes and notes[0].continuation else generator.solo.drafts.local_sounding(notes)
|
||||
musical = None
|
||||
if plan.treatment == 'thematic_recomposition':
|
||||
musical = generator.solo.scoring.musical(plan,draft,notes,incoming,harmony,travel=travel)
|
||||
if not musical.valid:return None
|
||||
score = musical.total
|
||||
else:
|
||||
evaluation_key = (plan, draft.anchors)
|
||||
if evaluation_key not in harmony.evaluations:
|
||||
harmony.evaluations[evaluation_key] = generator.solo.scoring.Evaluation(evaluation_plan(plan, draft.anchors), harmony.choices, plan.end)
|
||||
@@ -568,7 +574,7 @@ def checked_phrase(plan, draft, notes, contracts, incoming, harmony, tempo, edit
|
||||
(notes[-1].pitch.number() > notes[0].pitch.number()) - (notes[-1].pitch.number() < notes[0].pitch.number()) if notes else incoming.direction,
|
||||
last, 0, (), travel + (incoming.travel if shared else 0), home, motifs[-1] if motifs else incoming.development, themes, draft.anchors, plan.ending)
|
||||
actual_plan = dataclasses.replace(plan, relationship=draft.relationship)
|
||||
return generator.solo.types.Phrase(actual_plan, tuple(decisions), score, state, draft.anchors, draft, edits)
|
||||
return generator.solo.types.Phrase(actual_plan, tuple(decisions), score, state, draft.anchors, draft, edits, evaluation=musical)
|
||||
|
||||
def legacy_target_plan(plan, choices):
|
||||
if not plan.target or plan.anchor_options:
|
||||
|
||||
@@ -16,13 +16,13 @@ import generator.solo.similarity
|
||||
import generator.solo.features
|
||||
import generator.solo.placement
|
||||
|
||||
def describe(solo: generator.solo.types.Solo, scales, measure_offset=0, time_offset=0) -> str:
|
||||
def describe(solo: generator.solo.types.Solo, scales, measure_offset=0, time_offset=0, *, detail=None) -> str:
|
||||
region = generator.scales.timeline.Solo(time_offset, time_offset + solo.end, solo.part.capitalize() + ' Solo')
|
||||
positioned = tuple(dataclasses.replace(c, span=dataclasses.replace(c.span, start=c.span.start + time_offset, end=c.span.end + time_offset, measure=c.span.measure + measure_offset)) for c in solo.choices)
|
||||
lines = [generator.scales.report.passage(solo.part, region, positioned, scales), f'Phrase composition: {solo.part}', f'Placement reference tempo: {solo.tempo} quarter notes/minute. Runtime tempo changes are not a comfort guarantee.', 'Times below are quarter-note offsets from the start of this solo; pitches are sounding.']
|
||||
if solo.diagnostics:
|
||||
lines.append('Composition diagnostics: ' + json.dumps({k: v for k, v in solo.diagnostics.items() if not k.endswith('_seconds')}, sort_keys=True))
|
||||
detail = structure(solo)
|
||||
lines.append('Composition diagnostics: ' + json.dumps({k: v for k, v in solo.diagnostics.items() if not k.endswith('_seconds')}, sort_keys=True,default=str))
|
||||
detail = structure(solo) if detail is None else detail
|
||||
lines.append("Sustained phrasing: " + json.dumps(detail["phrasing"], sort_keys=True))
|
||||
for passage in detail['passages']:
|
||||
lines.append(f"Melodic passage {passage['id']}: {passage['start']}-{passage['end']}; phrases {', '.join(passage['phrases'])}")
|
||||
@@ -126,9 +126,15 @@ def structure(solo):
|
||||
entry['head_comparison_elaborated']=generator.solo.similarity.compare(tuple(n for d in phrase.decisions for n in d.notes),local_source)
|
||||
if phrase.state and phrase.state.home:
|
||||
entry['theme_relationship']=generator.solo.features.relationship(phrase.refined.notes,phrase.state.home)
|
||||
entry['evaluation'] = rational(dataclasses.asdict(phrase.evaluation)) if phrase.evaluation else None
|
||||
from generator.solo import groups
|
||||
try:
|
||||
entry['rhythm_groups']=rational([dataclasses.asdict(g) for g in groups.describe(tuple((n.start-phrase.plan.start,n.end-phrase.plan.start) for n in phrase.draft.notes),origin=phrase.plan.start)]) if phrase.draft else []
|
||||
except ValueError as error:
|
||||
entry['rhythm_groups']=[{'family':'source','reason':str(error)}]
|
||||
entry['score'] = phrase.score
|
||||
phrases.append(entry)
|
||||
return {'instrument_profile': rational(dataclasses.asdict(solo.profile)) if solo.profile else None, 'phrasing': phrasing_report(solo), 'source_comparison': {stage:generator.solo.similarity.compare(tuple(n for p in solo.phrases for n in (p.refined.notes if stage=='plain' and p.refined else tuple(n for d in p.decisions for n in d.notes))),tuple(n for p in solo.phrases if p.initial for n in p.initial.notes)) for stage in ('plain','elaborated')}, 'fretboard': fretboard_report(solo), 'passages': [{'id': p.id, 'start': str(p.start), 'end': str(p.end), 'phrases': list(p.phrase_ids), 'seed': p.seed} for p in solo.passages], 'phrases': phrases, 'expressions': rational([dataclasses.asdict(e) for e in expressions]), 'enclosures': rational([dataclasses.asdict(e) for e in enclosures]), 'harmonic_roles': harmony.describe(solo.notes(), contracts,enclosures,expressions), 'harmonic_exposure': checked.exposure, 'harmonic_valid': checked.valid, 'harmonic_error': checked.error, 'unresolved_treatments': rational([dataclasses.asdict(t) for t in checked.pending]), 'treatments': rational([dataclasses.asdict(t) for t in contracts])}
|
||||
return {'schema':'composer-report-2','selection_trace':rational({k:v for k,v in solo.diagnostics.items() if not k.endswith('_seconds')}), 'instrument_profile': rational(dataclasses.asdict(solo.profile)) if solo.profile else None, 'phrasing': phrasing_report(solo), 'source_comparison': {stage:generator.solo.similarity.compare(tuple(n for p in solo.phrases for n in (p.refined.notes if stage=='plain' and p.refined else tuple(n for d in p.decisions for n in d.notes))),tuple(n for p in solo.phrases if p.initial for n in p.initial.notes)) for stage in ('plain','elaborated')}, 'fretboard': fretboard_report(solo), 'passages': [{'id': p.id, 'start': str(p.start), 'end': str(p.end), 'phrases': list(p.phrase_ids), 'seed': p.seed} for p in solo.passages], 'phrases': phrases, 'expressions': rational([dataclasses.asdict(e) for e in expressions]), 'enclosures': rational([dataclasses.asdict(e) for e in enclosures]), 'harmonic_roles': harmony.describe(solo.notes(), contracts,enclosures,expressions), 'harmonic_exposure': checked.exposure, 'harmonic_valid': checked.valid, 'harmonic_error': checked.error, 'unresolved_treatments': rational([dataclasses.asdict(t) for t in checked.pending]), 'treatments': rational([dataclasses.asdict(t) for t in contracts])}
|
||||
|
||||
|
||||
def phrasing_report(solo):
|
||||
|
||||
@@ -89,7 +89,7 @@ def _candidates(notes, fixed, harmony, library, register, purpose='connect'):
|
||||
if not span or not span.scale:
|
||||
return ()
|
||||
contexts=tuple((harmony.at(n.start).scale if harmony.at(n.start) else None,
|
||||
types.permitted(harmony.choices,n.start,n.end),
|
||||
types.permitted(harmony.choices,n.start,n.end) & (harmony.members(n.start,n.end) if n.end-n.start>=2 else frozenset(range(12))),
|
||||
n.pitch.number() if n.event_id in fixed or i==len(notes)-1 else None) for i,n in enumerate(notes))
|
||||
if not hasattr(harmony,'pitch_routes'):harmony.pitch_routes={}
|
||||
key=(first.pitch,contexts,id(library),register,harmony.profile)
|
||||
@@ -175,6 +175,11 @@ def pitch_paths(first, contexts, library, register, profile=None):
|
||||
low,high=generator.fretboard.single_register((register[0]-7,register[1]+5))
|
||||
low, high = max(low, profile.register[0]), min(high, profile.register[1])
|
||||
result=[]
|
||||
# Reattacks are an explicit primitive, separate from interval catalog paths
|
||||
# (whose zero steps are deliberately excluded). Tied holds remain one event.
|
||||
if all(first.number()%12 in allowed and (fixed is None or fixed==first.number())
|
||||
for _,allowed,fixed in contexts):
|
||||
result.append(((first,)*len(contexts),('primitive:repeated_attack',)))
|
||||
for path in paths:
|
||||
realized=[first]
|
||||
for (scale,allowed,fixed),step in zip(contexts[1:],path.steps):
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import fractions
|
||||
import dataclasses
|
||||
|
||||
import generator.solo.policy
|
||||
import generator.solo.types
|
||||
@@ -116,3 +117,75 @@ def value(features):
|
||||
|
||||
def feasible(plan, notes, choices, until):
|
||||
return Evaluation(plan, choices, until).feasible(notes)
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class MusicalEvaluation:
|
||||
version: str
|
||||
scope: tuple
|
||||
valid: bool
|
||||
pending: tuple
|
||||
raw: dict
|
||||
denominators: dict
|
||||
weights: dict
|
||||
contributions: dict
|
||||
total: float
|
||||
error: str = ''
|
||||
|
||||
|
||||
MUSICAL_WEIGHTS = {'rhythm':3., 'destination':2., 'harmony':2.,
|
||||
'register':1., 'repetition':1., 'activity':1., 'difficulty':.5}
|
||||
|
||||
|
||||
def musical(plan, draft, notes, incoming, harmony, *, travel=0, weights=None, bar=None):
|
||||
"""The sole final evaluator of the active thematic composer.
|
||||
|
||||
Scores are normalized on complete sounding events, never notation fragments.
|
||||
Contracts are validity requirements, not additional similarity rewards.
|
||||
Retrieval estimates are deliberately not added to this result.
|
||||
"""
|
||||
from generator.solo import drafts, groups, harmonic, phrasing, types
|
||||
notes=types.sounding_notes(notes)
|
||||
bar=getattr(harmony,'bar',fractions.Fraction(4)) if bar is None else bar
|
||||
from generator import vocabulary
|
||||
weights=dict(vocabulary.data('grammar').get('evaluation',{}).get('weights',MUSICAL_WEIGHTS) if weights is None else weights)
|
||||
if set(weights)!=set(MUSICAL_WEIGHTS):raise ValueError('unknown or missing evaluation contribution')
|
||||
checked=harmony.evaluate(notes, incoming.treatments, until=plan.end, complete=True,
|
||||
enclosures=draft.enclosures, expressions=draft.expressions)
|
||||
identity,identity_error=drafts.contract_valid(draft,notes)
|
||||
anchors,anchor_error=harmonic.anchors_valid(draft.anchors,notes,plan.end,complete=True,closure=plan.closure)
|
||||
feasible=Evaluation(plan,harmony.choices).feasible(notes)
|
||||
valid=checked.valid and identity and anchors and feasible
|
||||
error=checked.error or identity_error or anchor_error or ('' if feasible else 'activity intent not fulfilled')
|
||||
span=float(plan.end-plan.start); sounded=sum(float(n.end-n.start) for n in notes)
|
||||
islands=sum(a.end<b.start and b.end<c.start and b.end-b.start<=fractions.Fraction(1,2)
|
||||
for a,b,c in zip(notes,notes[1:],notes[2:]))
|
||||
# Rests at the edges can be entrance/release. Long internal gaps need a
|
||||
# completed gesture, rather than receiving a universal occupancy penalty.
|
||||
settled={a.hold_until for a in draft.anchors}
|
||||
broken=sum(max(0,float(b.start-a.end)-1) for a,b in zip(notes,notes[1:])
|
||||
if a.end not in settled and a.end-a.start<2)
|
||||
entry=max(0,abs(notes[0].pitch.number()-incoming.last.pitch.number())-7)/12 if notes and incoming.last else 0.
|
||||
rhythm=min(1.,islands/max(1,len(notes)-2)+broken/max(1,span)+entry/2)
|
||||
# Explicit source groups retain their imported timing contract. Generated
|
||||
# groups are checked before construction, not retroactively quantized here.
|
||||
destinations=[]
|
||||
for anchor in draft.anchors:
|
||||
approach=[n for n in notes if n.start<anchor.earliest][-3:]
|
||||
if approach:
|
||||
distances=[abs(n.pitch.number()-anchor.pitch.number()) for n in approach]
|
||||
# A broad approach may turn; large last-second jumps are a preference,
|
||||
# not a nearest-note mandate for all intermediate events.
|
||||
destinations.append(min(1,max(0,distances[-1]-5)/12))
|
||||
goal=harmony.profile.reference
|
||||
register=sum(float(n.end-n.start)*min(1,max(0,abs(n.pitch.number()-goal)-9)/12)
|
||||
for n in notes)/max(sounded,.001) if goal is not None else 0.
|
||||
history=phrasing.repetition(phrasing.heard(notes,draft.relationship),incoming.history,bar) if notes else 0.
|
||||
activity=Evaluation(plan,harmony.choices).features(notes)['activity']
|
||||
raw={'rhythm':rhythm,'destination':sum(destinations)/max(1,len(destinations)),
|
||||
'harmony':checked.exposure,'register':register,'repetition':min(1,history),
|
||||
'activity':activity,'difficulty':min(1,travel/max(1,len(notes))/2000)}
|
||||
contributions={name:weights[name]*value for name,value in raw.items()}
|
||||
return MusicalEvaluation('joint-musical-1',(plan.start,plan.end),valid,checked.pending,raw,
|
||||
{'span':span,'sounding':sounded,'attacks':len(notes),'destinations':len(destinations)},weights,
|
||||
contributions,sum(contributions.values()) if valid else float('inf'),error)
|
||||
|
||||
@@ -3,6 +3,7 @@ from __future__ import annotations
|
||||
import dataclasses
|
||||
import pathlib
|
||||
import types
|
||||
import functools
|
||||
|
||||
import generator.solo.policy
|
||||
|
||||
@@ -13,6 +14,7 @@ import generator.musicxml
|
||||
class Sequence:
|
||||
id: str
|
||||
steps: tuple[int, ...]
|
||||
@functools.lru_cache(maxsize=32768)
|
||||
def offsets(self) -> tuple[int, ...]:
|
||||
result = [0]
|
||||
for step in self.steps:
|
||||
@@ -26,12 +28,14 @@ class Sequence:
|
||||
class Path:
|
||||
steps: tuple[int, ...]
|
||||
sources: tuple[str, ...]
|
||||
@functools.lru_cache(maxsize=32768)
|
||||
def offsets(self):
|
||||
result = [0]
|
||||
for step in self.steps:
|
||||
result.append(result[-1] + step)
|
||||
return tuple(result)
|
||||
|
||||
@functools.lru_cache(maxsize=32768)
|
||||
def family(steps):
|
||||
if not steps or all(s == 0 for s in steps):
|
||||
return 'repeated'
|
||||
@@ -47,14 +51,19 @@ def family(steps):
|
||||
def diverse(items, rank, category, limit):
|
||||
"""Round-robin eligible musical families before a destructive cutoff."""
|
||||
groups = {}
|
||||
for item in sorted(items, key=rank):
|
||||
groups.setdefault(category(item), []).append(item)
|
||||
# Rank once: hashing full event provenance and classifying interval paths
|
||||
# used to be repeated for every retained layer. Preserve stable tie order.
|
||||
decorated = sorted(((rank(item), i, item) for i,item in enumerate(items)),key=lambda v:v[:2])
|
||||
for value in decorated:
|
||||
groups.setdefault(category(value[2]), []).append(value)
|
||||
result, index = [], 0
|
||||
while len(result) < limit:
|
||||
layer = [values[index] for values in groups.values() if len(values) > index]
|
||||
if not layer:
|
||||
break
|
||||
result.extend(sorted(layer, key=rank)[:limit - len(result)])
|
||||
# Equal ranks retain category insertion order, just as the original stable
|
||||
# layer sort did; the input index is only for the initial sort.
|
||||
result.extend(v[2] for v in sorted(layer,key=lambda v:v[0])[:limit-len(result)])
|
||||
index += 1
|
||||
return tuple(result)
|
||||
|
||||
|
||||
+148
-165
@@ -11,7 +11,7 @@ from fractions import Fraction as F
|
||||
import generator.model
|
||||
import generator.harmony
|
||||
import generator.vocabulary
|
||||
from generator.solo import types, policy, sequences, routes, features as references, similarity, phrasing, profiles
|
||||
from generator.solo import types, policy, sequences, routes, features as references, similarity, phrasing, profiles, groups as rhythm_groups
|
||||
|
||||
|
||||
def source_notes(analysis):
|
||||
@@ -71,13 +71,16 @@ def seeds(analysis, bar, seed):
|
||||
identity=policy.stable_rank(seed,(group,treatment))[:12]
|
||||
groups.append(types.SourceReference(identity,parent,group[0].start,group[-1].end,local,treatment))
|
||||
def rank(ref):
|
||||
rhythm={(n.start,n.end-n.start) for n in ref.notes}
|
||||
rhythm=set(rhythm_groups.signature(ref.notes))
|
||||
intervals={b.pitch.number()-a.pitch.number() for a,b in zip(ref.notes,ref.notes[1:])}
|
||||
preferred=generator.vocabulary.role().get('preferred_features',[])
|
||||
preference=preferred.index(ref.treatment) if ref.treatment in preferred else 0
|
||||
turn=any(a*b<0 for a,b in zip(ref.notes and tuple(b.pitch.number()-a.pitch.number() for a,b in zip(ref.notes,ref.notes[1:])),tuple(b.pitch.number()-a.pitch.number() for a,b in zip(ref.notes,ref.notes[1:]))[1:]))
|
||||
return (-min(4,len(intervals))-.3*turn+.15*preference,-min(3,len(rhythm)),ref.id)
|
||||
return sequences.diverse(groups,rank,lambda r:(r.treatment,int(max(0,r.start)//(4*bar))),policy.DEFAULT.theme_seed_limit)
|
||||
# Preserve different contracts first. Combining treatment with form position
|
||||
# created many categories of the preferred treatment and could crowd every
|
||||
# rhythm/contour seed out before a single pitch was constructed.
|
||||
return sequences.diverse(groups,rank,lambda r:r.treatment,policy.DEFAULT.theme_seed_limit)
|
||||
|
||||
|
||||
def feature(reference, actual, *, treatment=None):
|
||||
@@ -87,7 +90,7 @@ def feature(reference, actual, *, treatment=None):
|
||||
'repeat_with_harmonic_adaptation':('rhythm','contour'),'answer':('contour',),
|
||||
'extend':('contour',),'fragment':('rhythm',),'callback':('rhythm','pitches'),
|
||||
'return':('rhythm','intervals'), 'develop_rhythm':('rhythm',),
|
||||
'develop_contour':('intervals',), 'continue':('contour',)}[treatment]
|
||||
'develop_contour':('intervals',), 'continue':(), 'connect':(), 'extension':('contour',)}[treatment]
|
||||
original=reference.notes
|
||||
authored=next((r for r in generator.vocabulary.data('grammar')['transformations'] if r['id']==treatment),None)
|
||||
if authored:required=tuple(authored['preserve'])
|
||||
@@ -103,7 +106,7 @@ def rhythmic_purpose(operation, terminal=False):
|
||||
if terminal:return 'arrival'
|
||||
if operation in ('introduce','callback','return','repeat_with_harmonic_adaptation'):return 'entrance'
|
||||
if operation in ('answer','fragment'):return 'answer'
|
||||
return 'connect' if operation=='continue' else 'continue'
|
||||
return 'connect' if operation in ('continue','connect') else 'continue'
|
||||
|
||||
|
||||
def rhythm_cost(pattern,length,purpose):
|
||||
@@ -145,12 +148,12 @@ def rhythm_windows(library,meter,length,context,purpose='continue'):
|
||||
for offset in sorted({F(),*(a for a,_ in pattern)}):
|
||||
if offset+length>total or any(a<offset<b or a<offset+length<b for a,b in pattern):continue
|
||||
selected=tuple((a-offset,b-offset) for a,b in pattern if offset<=a and b<=offset+length)
|
||||
if selected and len(selected)<=16:patterns.setdefault(selected,identifier)
|
||||
if selected and len(selected)<=16 and rhythm_groups.valid(selected):patterns.setdefault(selected,identifier)
|
||||
# Authored cells can start late and continue over computational barlines.
|
||||
for cell in generator.vocabulary.rhythm_cells(tempo,purpose):
|
||||
identifier,pattern,total=cell.id,cell.pattern,cell.duration
|
||||
if total>length:continue
|
||||
for offset in (F(),F(1,2),max(F(),length-total)):
|
||||
for offset in ((F(),) if cell.entry=='pickup' else (F(),F(1,2),max(F(),length-total))):
|
||||
if offset+total>length:continue
|
||||
head=tuple((a+offset,b+offset) for a,b in pattern)
|
||||
# Keep representative compatible continuations; never let dictionary
|
||||
@@ -159,8 +162,10 @@ def rhythm_windows(library,meter,length,context,purpose='continue'):
|
||||
lambda p:(len(p),p[-1][1]-p[-1][0]),2) or ((),)
|
||||
for tail in tails:
|
||||
if any(a<offset+total<b for a,b in tail):continue
|
||||
combined=(*head,*((a,b) for a,b in tail if a>=offset+total))
|
||||
if 2<=len(combined)<=16:patterns.setdefault(combined,'authored:'+identifier)
|
||||
continuation=tuple((a,b) for a,b in tail if a>=offset+total)
|
||||
if cell.exit=='continue' and offset+total<length and (not continuation or continuation[0][0]!=offset+total):continue
|
||||
combined=(*head,*continuation)
|
||||
if 2<=len(combined)<=16 and rhythm_groups.valid(combined):patterns.setdefault(combined,'authored:'+identifier)
|
||||
context.pools[key]=sequences.diverse(tuple(patterns.items()),
|
||||
lambda x:(rhythm_cost(x[0],length,purpose)+(0 if x[1].startswith('authored:') else .05),policy.stable_rank('rhythm-window',x[0])),
|
||||
lambda x:(x[1].startswith('authored:'),len(x[0]),x[0][0][0],any(a[1]!=b[0] for a,b in zip(x[0],x[0][1:]))),8)
|
||||
@@ -193,7 +198,7 @@ def patterns(ref, start, finish, rhythms, meter, context, *, home=None, operatio
|
||||
if b-a==1:
|
||||
values[(*original[:i],(a,a+F(1,2)),(a+F(1,2),b),*original[i+1:])]=label+'; diminution'
|
||||
for i,((a,b),(c,d)) in enumerate(zip(original,original[1:])):
|
||||
if b!=c:continue
|
||||
if b!=c or any((v*2).denominator!=1 for v in (a,b,c,d)):continue
|
||||
for split in (a+F(1,2),a+F(3,2),d-F(1,2)):
|
||||
if a<split<d:
|
||||
values[(*original[:i],(a,split),(split,d),*original[i+2:])]=label+'; rhythmic alteration'
|
||||
@@ -201,10 +206,12 @@ def patterns(ref, start, finish, rhythms, meter, context, *, home=None, operatio
|
||||
arrivals={}
|
||||
arrival=ending.earliest-start
|
||||
for original,label in values.items():
|
||||
head=tuple((a,min(b,arrival)) for a,b in original if a<arrival)
|
||||
if len(head)>=len(ref.notes):
|
||||
arrivals[(*head,(arrival,ending.hold_until-start))]=label+'; planned sustained close'
|
||||
try: revised=rhythm_groups.broaden(original,arrival,ending.hold_until-start)
|
||||
except ValueError: revised=()
|
||||
if revised and len(revised)>=len(ref.notes):
|
||||
arrivals[revised]=label+'; planned sounding destination'
|
||||
values=arrivals
|
||||
values={p:label for p,label in values.items() if rhythm_groups.valid(p) or fixed_rhythm and p==prefix}
|
||||
return sequences.diverse(tuple(values.items()),lambda x:(rhythm_cost(x[0],length,purpose),policy.stable_rank(ref.id,x[0])),
|
||||
lambda x:(len(x[0]),tuple(b-a for a,b in x[0][:3]),x[0][0][0]),policy.DEFAULT.theme_rhythm_alternatives)
|
||||
|
||||
@@ -233,61 +240,6 @@ def relative_steps(notes,harmony):
|
||||
return tuple(result)
|
||||
|
||||
|
||||
def instantiate(templates,first,steps,harmony):
|
||||
result=[dataclasses.replace(templates[0],pitch=first)]
|
||||
for note,step in zip(templates[1:],steps):
|
||||
span=harmony.at(note.start)
|
||||
if not span or not span.scale:return ()
|
||||
options=routes.advance(span.scale,result[-1].pitch.number(),step)
|
||||
if not options:return ()
|
||||
p=options[0]
|
||||
if not harmony.profile.permits(p.number()) or p.number()%12 not in types.permitted(harmony.choices,note.start,note.end):return ()
|
||||
result.append(dataclasses.replace(note,pitch=p))
|
||||
return tuple(result) if len(result)==len(templates) else ()
|
||||
|
||||
|
||||
def prefix_paths(templates,ref,first,harmony,library):
|
||||
if not hasattr(harmony,'theme_prefixes'):harmony.theme_prefixes={}
|
||||
key=(templates[:len(ref.notes)],ref,first,id(library))
|
||||
if key not in harmony.theme_prefixes:
|
||||
harmony.theme_prefixes[key]=_prefix_paths(templates,ref,first,harmony,library)
|
||||
return harmony.theme_prefixes[key]
|
||||
|
||||
|
||||
def _prefix_paths(templates,ref,first,harmony,library):
|
||||
count=len(ref.notes); original=ref.notes
|
||||
if count==1:return ((dataclasses.replace(templates[0],pitch=first),),)
|
||||
if ref.treatment in ('opening_fragment','characteristic_interval','callback'):
|
||||
delta=first.number()-original[0].pitch.number()
|
||||
if ref.treatment in ('opening_fragment','callback') and delta%12:return ()
|
||||
result=[]
|
||||
from generator.solo.leads import available
|
||||
for template,n in zip(templates,original):
|
||||
target=n.pitch.number()+delta
|
||||
p=next((p for p in available(harmony,template.start,template.end,members=template.end-template.start>=2) if p.number()==target),None)
|
||||
if p is None:return ()
|
||||
result.append(dataclasses.replace(template,pitch=p))
|
||||
return (tuple(result),)
|
||||
paths=[]
|
||||
if ref.treatment == 'return':
|
||||
from generator.solo.leads import available
|
||||
delta=first.number()-original[0].pitch.number()
|
||||
direct=[]
|
||||
for template,n in zip(templates,original):
|
||||
p=next((p for p in available(harmony,template.start,template.end,members=template.end-template.start>=2) if p.number()==n.pitch.number()+delta),None)
|
||||
if p is None: break
|
||||
direct.append(dataclasses.replace(template,pitch=p))
|
||||
if len(direct)==count: paths.append(tuple(direct))
|
||||
end_template=templates[count-1]
|
||||
source_motion=original[-1].pitch.number()-original[0].pitch.number()
|
||||
for target in pitches(harmony,end_template,first.number()+source_motion,limit=4):
|
||||
template=tuple(dataclasses.replace(n,pitch=first if i==0 else target) for i,n in enumerate(templates[:count]))
|
||||
paths.extend(r.notes for r in routes.candidates(template,{template[-1].event_id},harmony,library,harmony.profile.register,'seed '+ref.id,purpose='entrance'))
|
||||
valid=[p for p in paths if not references.feature_error(feature(ref,p),p)]
|
||||
return sequences.diverse(valid,lambda ns:(routes.path_cost(ns),policy.stable_rank(ref.id,ns)),
|
||||
lambda ns:routes.path_family(ns,harmony),4)
|
||||
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Unit:
|
||||
notes: tuple[types.Note,...]
|
||||
@@ -303,81 +255,86 @@ class Unit:
|
||||
|
||||
|
||||
def unit_candidates(ref,start,finish,incoming,harmony,library,rhythms,meter,context,*,home=None,operation='introduce',terminal=False,batch=0,ending=None,goal=None):
|
||||
# History is evaluated by the caller after retrieving these concrete options.
|
||||
# Every state component used to construct this pool is in its cache key.
|
||||
if not hasattr(harmony,'fingerprint'):harmony.fingerprint=policy.stable_rank('harmony',(harmony.choices,harmony.profile))
|
||||
key=('theme-unit',ref,start,finish,incoming.last,incoming.direction,incoming.treatments,incoming.history,home,operation,ending,goal,batch,harmony.fingerprint,id(library),id(rhythms),policy.DEFAULT)
|
||||
"""Joint whole-gesture pitch/rhythm actions, conditioned on the actual entry.
|
||||
|
||||
A complete route is proposed before thematic evidence is checked. No motif
|
||||
prefix is spliced to an independently cheapest suffix. Ordinary search ends
|
||||
carry no chord-tone obligation; long-note and destination contracts still do.
|
||||
"""
|
||||
from generator.solo import leads
|
||||
key=('joint-gesture-1',ref,start,finish,incoming.last,incoming.direction,incoming.treatments,
|
||||
home,operation,ending,goal,batch,id(harmony),id(library),id(rhythms))
|
||||
if key in context.results:
|
||||
context.diagnostics['cache_hits']+=1;return context.results[key]
|
||||
result=[]; count=len(ref.notes)
|
||||
trace=context.diagnostics.setdefault('operations',{}).setdefault(operation,
|
||||
dict(eligible=0,proposed=0,valid=0,retained=0,jobs=0,pruned_jobs=0,rejected_by_rule=0))
|
||||
trace['eligible']+=1
|
||||
require_feature=operation not in ('continue','connect')
|
||||
count=len(ref.notes) if require_feature else 0
|
||||
jobs=[]
|
||||
for pattern,label in patterns(ref,start,finish,rhythms,meter,context,home=home,operation=operation,terminal=terminal,ending=ending):
|
||||
if len(pattern)<count or len(pattern)>16:continue
|
||||
templates=tuple(types.Note(start+a,start+b,ref.notes[0].pitch,tuple(s for n in ref.notes for s in n.sources),
|
||||
'theme',event_id=f'{ref.id}:{start}:{i}') for i,(a,b) in enumerate(pattern))
|
||||
base=incoming.last.pitch.number() if incoming.last else harmony.profile.reference if harmony.profile.reference is not None else ref.notes[0].pitch.number()
|
||||
firsts=pitches(harmony,templates[0],base,limit=6 if batch else 3)
|
||||
targets=(ending.pitch,) if ending else pitches(harmony,templates[-1],goal if goal is not None else base,members=True,limit=policy.DEFAULT.theme_destinations,incoming=incoming)
|
||||
if len(pattern)<max(2,count) or len(pattern)>16:continue
|
||||
provenance=tuple(dict.fromkeys(s for n in ref.notes for s in n.sources))
|
||||
templates=tuple(types.Note(start+a,start+b,ref.notes[0].pitch,provenance,
|
||||
'theme' if require_feature else 'connection',event_id=f'{ref.id}:{operation}:{start}:{i}') for i,(a,b) in enumerate(pattern))
|
||||
base=incoming.last.pitch.number() if incoming.last else harmony.profile.reference or ref.notes[0].pitch.number()
|
||||
firsts=pitches(harmony,templates[0],base,limit=6)
|
||||
if incoming.last is None:
|
||||
offsets=generator.vocabulary.role().get('register_alternatives',[-7,0,7])
|
||||
firsts=tuple(dict.fromkeys(p for offset in offsets for p in pitches(harmony,templates[0],base+offset,limit=2)))
|
||||
targets=(ending.pitch,) if ending else pitches(harmony,templates[-1],goal if goal is not None else base,
|
||||
members=False,limit=policy.DEFAULT.theme_destinations,incoming=incoming)
|
||||
for first in firsts:
|
||||
for target in targets:
|
||||
# Rank joint jobs, retaining rhythm and destination coverage before
|
||||
# expensive path instantiation. The budget is spent on complete routes.
|
||||
rank=harmony.profile.cost(first.number())+max(0,abs(first.number()-base)-5)/12+phrasing.destination_cost(target,templates[-1].start,templates[-1].end,harmony,incoming,goal if goal is not None else base,terminal)
|
||||
motion=ref.notes[-1].pitch.number()-ref.notes[0].pitch.number()
|
||||
if operation=='answer':motion=-motion
|
||||
# Rank purposeful direction separately from entry continuity. No reward
|
||||
# for minimizing every interval or for repeatedly visiting the midpoint.
|
||||
rank=max(0,abs(first.number()-base)-7)/12
|
||||
rank+=.1*min(1,abs((target.number()-first.number())-motion)/12)
|
||||
jobs.append((rank,templates,label,first,target))
|
||||
jobs.sort(key=lambda j:(j[0],policy.stable_rank(ref.id,(j[1],j[3],j[4]))))
|
||||
selected=[];rhythm_seen=set();target_seen=set();entry_seen=set();degrees_seen=set()
|
||||
for job in jobs:
|
||||
family=phrasing.destination_family(job[4],job[1][-1].start,harmony)
|
||||
if family not in degrees_seen:
|
||||
selected.append(job);degrees_seen.add(family)
|
||||
for job in jobs:
|
||||
rhythm=tuple((n.start,n.end) for n in job[1]);target=job[4].number();entry=job[3].number()
|
||||
if rhythm not in rhythm_seen or target not in target_seen or entry not in entry_seen:
|
||||
if job not in selected:selected.append(job)
|
||||
rhythm_seen.add(rhythm);target_seen.add(target);entry_seen.add(entry)
|
||||
job_limit=policy.DEFAULT.theme_route_jobs*(batch+1)
|
||||
for job in jobs:
|
||||
if len(selected)>=job_limit:break
|
||||
if job not in selected:selected.append(job)
|
||||
for _,templates,label,first,target in selected[:job_limit]:
|
||||
proposed=[]
|
||||
if home and operation in ('repeat_with_harmonic_adaptation','return') and len(templates)==len(home.notes):
|
||||
heard=instantiate(templates,first,home.degree_steps,harmony)
|
||||
if heard and heard[-1].pitch==target:proposed.append((heard,()))
|
||||
for prefix in prefix_paths(templates,ref,first,harmony,library)[:2+batch]:
|
||||
if len(prefix)==len(templates):
|
||||
if prefix[-1].pitch==target:proposed.append((prefix,()))
|
||||
continue
|
||||
tail=(prefix[-1],*templates[count:])
|
||||
tail=(*tail[:-1],dataclasses.replace(tail[-1],pitch=target))
|
||||
for route in routes.candidates(tail,{tail[-1].event_id},harmony,library,harmony.profile.register,operation+' '+ref.id,purpose=rhythmic_purpose(operation,terminal))[:3+batch]:
|
||||
proposed.append(((*prefix[:-1],*route.notes),(route,)))
|
||||
seen=set()
|
||||
for actual,connections in proposed:
|
||||
identity=tuple(n.pitch.number() for n in actual)
|
||||
if identity in seen:continue
|
||||
seen.add(identity)
|
||||
core=actual[:count]; contract=feature(ref,core,treatment=operation if operation!='introduce' else None)
|
||||
if references.feature_error(contract,actual):continue
|
||||
last=actual[-1]
|
||||
if last.pitch.number()%12 not in harmony.members(last.start,last.end):continue
|
||||
selected=sequences.diverse(jobs,lambda j:(j[0],policy.stable_rank(ref.id,(j[1],j[3],j[4]))),
|
||||
lambda j:(tuple(n.end-n.start for n in j[1]),j[3].number()//12,
|
||||
(j[4].number()>j[3].number())-(j[4].number()<j[3].number())),policy.DEFAULT.theme_route_jobs*(batch+1))
|
||||
trace['jobs']+=len(jobs);trace['pruned_jobs']+=len(jobs)-len(selected)
|
||||
result=[]
|
||||
for _,templates,label,first,target in selected:
|
||||
timed=(dataclasses.replace(templates[0],pitch=first),*templates[1:-1],dataclasses.replace(templates[-1],pitch=target))
|
||||
proposed=list(routes.candidates(timed,{timed[-1].event_id},harmony,library,harmony.profile.register,
|
||||
operation+' '+ref.id,purpose=rhythmic_purpose(operation,terminal)))
|
||||
# A substantial literal return is a musical action, not merely the hope
|
||||
# that a general interval search will accidentally reproduce the theme.
|
||||
if require_feature and len(templates)==len(ref.notes):
|
||||
delta=first.number()-ref.notes[0].pitch.number()
|
||||
actual=[]
|
||||
for template,n in zip(templates,ref.notes):
|
||||
options=leads.available(harmony,template.start,template.end,members=template.end-template.start>=2)
|
||||
p=next((p for p in options if p.number()==n.pitch.number()+delta),None)
|
||||
if p is None:break
|
||||
actual.append(dataclasses.replace(template,pitch=p))
|
||||
if len(actual)==len(templates) and actual[-1].pitch==target:
|
||||
proposed.append(types.RouteCandidate('theme:'+ref.id,tuple(actual),actual[-1],(),operation,(ref.id,)))
|
||||
for route in proposed:
|
||||
trace['proposed']+=1
|
||||
actual=route.notes
|
||||
contract=feature(ref,actual[:count],treatment=operation if operation!='introduce' else None) if count else None
|
||||
if contract and references.feature_error(contract,actual):
|
||||
trace['rejected_by_rule']+=1;continue
|
||||
checked=harmony.evaluate(actual,until=finish,complete=True)
|
||||
if not checked.valid:continue
|
||||
entry=max(0,abs(first.number()-incoming.last.pitch.number())-5)/12 if incoming.last else 0.
|
||||
leaps=sum(max(0,abs(b.pitch.number()-a.pitch.number())-5)/12 for a,b in zip(actual,actual[1:]))/max(1,len(actual)-1)
|
||||
direction=min(1,abs(last.pitch.number()-goal)/12) if goal is not None else 0.
|
||||
# Activity belongs to the complete phrase; contracts are pass/fail.
|
||||
score=harmony.profile.cost(profiles.weighted_center(actual))+2*checked.exposure+entry+leaps+phrasing.destination_cost(last.pitch,last.start,last.end,harmony,incoming,goal,terminal)
|
||||
anchor=ending or types.Anchor(last.event_id+':arrival',last.start,last.start,last.pitch,harmony.members(last.start,last.end),harmony.profile.register,
|
||||
last.end-last.start,'intermediate',harmony.at(last.start).chord,hold_until=last.end)
|
||||
if not checked.valid:trace['rejected_by_rule']+=1;continue
|
||||
trace['valid']+=1
|
||||
entry=max(0,abs(first.number()-incoming.last.pitch.number())-7)/12 if incoming.last else 0.
|
||||
score=2*checked.exposure+entry+.1*routes.path_cost(actual)
|
||||
score+=.25*rhythm_cost(tuple((n.start-start,n.end-start) for n in actual),finish-start,rhythmic_purpose(operation,terminal))
|
||||
result.append(Unit(actual,contract,ref,operation,anchor,score,label,connections,start,finish))
|
||||
result.append(Unit(actual,contract,ref,operation,ending,score,label,(route,),start,finish))
|
||||
unique={tuple((n.start,n.end,n.pitch) for n in u.notes):u for u in result}
|
||||
selected=sequences.diverse(tuple(unique.values()),lambda u:(u.score,policy.stable_rank(ref.id,u.notes)),
|
||||
lambda u:(u.notes[0].pitch.number()//12,u.notes[-1].pitch.number(),tuple(n.end-n.start for n in u.notes[:count])),policy.DEFAULT.theme_unit_alternatives)
|
||||
context.diagnostics['generated_candidates']+=len(selected)
|
||||
context.results[key]=selected
|
||||
return selected
|
||||
chosen=sequences.diverse(tuple(unique.values()),lambda u:(u.score,policy.stable_rank(ref.id,u.notes)),
|
||||
lambda u:(routes.path_family(u.notes,harmony),u.notes[0].pitch.number()//12,
|
||||
tuple(n.end-n.start for n in u.notes)),policy.DEFAULT.theme_unit_alternatives)
|
||||
trace['retained']+=len(chosen)
|
||||
context.diagnostics['generated_candidates']+=len(chosen)
|
||||
context.results[key]=chosen
|
||||
return chosen
|
||||
|
||||
|
||||
def home_reference(home,operation):
|
||||
@@ -400,6 +357,18 @@ def make_home(unit,harmony,start=None,end=None):
|
||||
return dataclasses.replace(home,degree_steps=relative_steps(unit.notes,harmony),signature=home.notes[:len(unit.reference.notes)])
|
||||
|
||||
|
||||
def operation_choices(home,incoming,cursor,phrase_start,closing):
|
||||
available=generator.vocabulary.data('grammar')['operations']
|
||||
selected=[]
|
||||
for rule in available:
|
||||
op=rule['id']
|
||||
if rule.get('entry_only') and cursor!=phrase_start:continue
|
||||
if rule.get('after_statement') and not home:continue
|
||||
if rule.get('needs_recent') and not incoming.notes:continue
|
||||
selected.append(op)
|
||||
return tuple(selected)
|
||||
|
||||
|
||||
def unit_end(source,cursor,home,ending,bar):
|
||||
"""Bound search by time without cutting the heard signature at a barline."""
|
||||
length=2*bar
|
||||
@@ -409,7 +378,7 @@ def unit_end(source,cursor,home,ending,bar):
|
||||
length+=home.signature[-1].end
|
||||
length=min(2*bar,max(bar,length))
|
||||
finish=min(source.end,cursor+length)
|
||||
if source.end-finish<bar+2 or ending.earliest<finish:
|
||||
if source.end-finish<bar+2 or ending and ending.earliest<finish:
|
||||
finish=source.end
|
||||
return finish
|
||||
|
||||
@@ -424,7 +393,8 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
seed_key=('source-seeds',analysis,bar,seed)
|
||||
if seed_key not in context.pools:context.pools[seed_key]=seeds(analysis,bar,seed)
|
||||
roots=context.pools[seed_key]
|
||||
ending_options=phrasing.endings(source,incoming,part,harmony,bar,limit=8*(batch+1),final=final)
|
||||
ending_options=phrasing.endings(source,incoming,part,harmony,bar,limit=6*(batch+1),final=final)
|
||||
if not final:ending_options=(None,*ending_options)
|
||||
states=[(0.,(),incoming.home,incoming,ending) for ending in ending_options]
|
||||
while states and any(not units or units[-1].end<source.end for _,units,_,_,_ in states):
|
||||
next_states=[]
|
||||
@@ -438,15 +408,12 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
if introducing:
|
||||
requests=[(r,'introduce') for r in roots]
|
||||
else:
|
||||
operations=['continue'] if finish==source.end and cursor>source.start else ['develop_contour','develop_rhythm']
|
||||
if cursor==source.start:operations.append('return')
|
||||
operations=operation_choices(home,state,cursor,source.start,finish==source.end)
|
||||
requests=[(home_reference(home,op),op) for op in operations]
|
||||
# A uniform duration alone is not identifying musical evidence.
|
||||
requests=[(r,op) for r,op in requests if op!='develop_rhythm' or len({n.end-n.start for n in r.notes})>1 or any(a.end!=b.start for a,b in zip(r.notes,r.notes[1:]))]
|
||||
if cursor>=8*bar and cursor==source.start and incoming.callbacks<2:
|
||||
requests.extend((dataclasses.replace(r,treatment='callback'),'callback') for r in roots[:1] if r.end-r.start<=bar)
|
||||
for ref,operation in requests:
|
||||
if introducing and source.end-source.start<2*bar and ending.earliest-cursor<ref.notes[-1].end:
|
||||
if introducing and ending and source.end-source.start<2*bar and ending.earliest-cursor<ref.notes[-1].end:
|
||||
# A missing-harmony boundary can leave less than one full statement.
|
||||
# Declare a smaller contour seed; never pretend it proves the full motif.
|
||||
count=min(3,int(2*(ending.earliest-cursor)),len(ref.notes))
|
||||
@@ -465,9 +432,10 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
if len(reduced)<2:continue
|
||||
ref=dataclasses.replace(ref,notes=reduced,treatment='contour_seed')
|
||||
operation='continue'
|
||||
terminal=finish==source.end
|
||||
terminal=bool(ending and finish==source.end)
|
||||
base=state.last.pitch.number() if state.last else ref.notes[0].pitch.number()
|
||||
goal=ending.pitch.number() if terminal else round(base+(ending.pitch.number()-base)*float((finish-cursor)/(source.end-cursor)))
|
||||
destination=ending.pitch.number() if ending else phrasing.register_goal(state,part,base,harmony.profile)
|
||||
goal=destination if finish==source.end else round(base+(destination-base)*float((finish-cursor)/(source.end-cursor)))
|
||||
options=unit_candidates(ref,cursor,finish,state,harmony,library,rhythms,meter,context,home=home,operation=operation,
|
||||
terminal=terminal,batch=batch,ending=ending if terminal else None,goal=goal)
|
||||
for unit in options:
|
||||
@@ -487,22 +455,19 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
elapsed=units[-1].end-source.start
|
||||
return cost/max(.001,float(elapsed)),policy.stable_rank(seed,tuple(u.notes for u in units))
|
||||
states=sequences.diverse(next_states,rank,
|
||||
lambda v:(v[2].id,v[4].pitch.number(),v[4].duration,len(v[1][-1].notes),v[1][-1].operation),policy.DEFAULT.theme_continuations)
|
||||
lambda v:(v[2].id,(v[4].pitch.number(),v[4].duration) if v[4] else 'open',len(v[1][-1].notes),v[1][-1].operation),policy.DEFAULT.theme_continuations)
|
||||
if not states:return ()
|
||||
result=[]
|
||||
for cost,units,home,state,ending in states:
|
||||
plain=tuple(n for u in units for n in u.notes)
|
||||
if similarity.near_copy(plain,head,source.start,source.end)['near_copy']:
|
||||
context.diagnostics['near_copy_rejections']=context.diagnostics.get('near_copy_rejections',0)+1;continue
|
||||
features=tuple(u.feature for u in units)
|
||||
features=tuple(u.feature for u in units if u.feature)
|
||||
# Cell tails are not compulsory melodic arrivals. Only the selected close
|
||||
# has a sounding contract; intermediate turns remain editable.
|
||||
anchors=(ending,)
|
||||
tails=(types.SustainedTail(ending.earliest,ending.hold_until,ending.pitch.number()),)
|
||||
anchors=(ending,) if ending else ()
|
||||
tails=(types.SustainedTail(ending.earliest,ending.hold_until,ending.pitch.number()),) if ending else ()
|
||||
options=[(plain,(),())]
|
||||
if stage=='elaborated':
|
||||
for actual,edit,route in leads.elaborate(plain,features,harmony,library,rhythms,meter,source,sustain_entry=True,tails=tails):
|
||||
options.append((actual,(edit,),(route,)))
|
||||
for notes,edits,selected_routes in options:
|
||||
identifier=part+'_'+source.id+'_'+policy.stable_rank(seed,leads.signature(notes))[:12]
|
||||
transforms=tuple(types.Transformation(identifier+f':{i}',u.reference.id,home.id,u.operation,u.notes[0].start,u.notes[-1].end,
|
||||
@@ -512,9 +477,11 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
features=features,reference=source_ref.id,reference_motif=home,source_phrase=source,source_reference=source_ref,
|
||||
source_links=tuple((n.event_id,n.sources) for n in notes),sustained_tails=tails)
|
||||
motif=types.Motif(home.id,home.notes,home.duration,(), 'realized solo theme from '+source_ref.id)
|
||||
landmark=types.Landmark(ending.earliest,ending.latest,ending.pitch.number(),ending.pitch.number(),0,'sustained destination')
|
||||
landmarks=(types.Landmark(ending.earliest,ending.latest,ending.pitch.number(),ending.pitch.number(),0,'sounding destination'),) if ending else ()
|
||||
closed=bool(ending and ending.role=='terminal')
|
||||
plan=types.PhrasePlan(identifier,source.start,source.end,motif,draft.relationship,'thematic_recomposition',None,harmony.profile.register,F(5,4),
|
||||
source.end-ending.hold_until,phrasing.activity(source,ending),(landmark,), 'sustain','closed',seed,
|
||||
source.end-ending.hold_until if ending else F(),phrasing.activity(source,ending),landmarks,
|
||||
'sustain' if ending else 'connected','closed' if closed else 'open',seed,
|
||||
source.id,source.start,source.end,(anchors,))
|
||||
before_rhythm=draft
|
||||
from generator.solo import gesture_rhythm
|
||||
@@ -523,20 +490,12 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
notes=draft.notes;edits=(*edits,*rhythm_edits);transforms=draft.transformations
|
||||
phrase=realization.checked_phrase(plan,draft,notes,incoming.treatments,incoming,harmony,tempo,edits)
|
||||
if phrase is None:continue
|
||||
score=phrasing.evaluate(notes,incoming,harmony,source.start,source.end,bar)+.1*gesture_rhythm.fragmentation(notes)
|
||||
score+=sum(phrasing.destination_cost(u.anchor.pitch,u.anchor.earliest,u.anchor.hold_until,harmony,incoming,phrasing.register_goal(incoming,part,u.notes[0].pitch.number(),harmony.profile),u.anchor.role=='terminal') for u in units)/len(units)
|
||||
appearance_state=incoming
|
||||
for unit in units:
|
||||
score+=phrasing.appearance_cost(unit.operation,appearance_state,unit.notes[0].start,solo_end)/len(units)
|
||||
if unit.operation=='return':
|
||||
appearance_state=dataclasses.replace(appearance_state,returns=(*appearance_state.returns,unit.notes[0].start))
|
||||
score+=.05*phrase.state.travel/max(1,len(notes))/2000
|
||||
history=incoming.history
|
||||
for transform in transforms:
|
||||
group=tuple(n for n in notes if n.event_id in transform.events)
|
||||
if group:history=phrasing.remember(history,phrasing.heard(group,transform.operation,ending if group[-1].end==ending.hold_until else None,bar),bar)
|
||||
current=dataclasses.replace(phrase.state,next_destination=phrasing.next_destination(ending,harmony),home=home,source_reference=source_ref,callbacks=incoming.callbacks+sum(u.operation=='callback' for u in units),
|
||||
history=history,returns=state.returns,closures=incoming.closures+1,register_peak=max(state.register_peak,*(n.pitch.number() for n in notes)))
|
||||
if group:history=phrasing.remember(history,phrasing.heard(group,transform.operation,ending if ending and group[-1].end==ending.hold_until else None,bar),bar)
|
||||
current=dataclasses.replace(phrase.state,next_destination=phrasing.next_destination(ending,harmony) if ending else incoming.next_destination,home=home,source_reference=source_ref,callbacks=incoming.callbacks+sum(u.operation=='callback' for u in units),
|
||||
history=history,returns=state.returns,closures=incoming.closures+int(closed),register_peak=max(state.register_peak,*(n.pitch.number() for n in notes)))
|
||||
if not incoming.home:
|
||||
introduced=tuple(n for n in notes if n.start<units[0].notes[-1].end)
|
||||
heard=dataclasses.replace(home,notes=tuple(dataclasses.replace(n,start=n.start-source.start,end=n.end-source.start,position=None) for n in introduced),
|
||||
@@ -545,6 +504,30 @@ def phrase_candidates(source,analysis,incoming,part,harmony,library,rhythms,mete
|
||||
source_control=leads.shift(source.notes,next((o for o in (0,1,-1,2,-2) if all(41<=n.pitch.number()+12*o<=76 for n in source.notes)),0))
|
||||
original=dataclasses.replace(draft,id=identifier+':source',notes=source_control,features=(),anchors=(),structural=(),sustained_tails=())
|
||||
refined=dataclasses.replace(draft,id=identifier+':plain',notes=plain)
|
||||
result.append(dataclasses.replace(phrase,score=score,state=current,initial=original,refined=refined,before_rhythm=before_rhythm,routes=(*tuple(r for u in units for r in u.routes if all(any((n.event_id,n.start,n.end,n.pitch)==(a.event_id,a.start,a.end,a.pitch) for a in notes) for n in r.notes)),*selected_routes)))
|
||||
return sequences.diverse(result,lambda p:(p.score,policy.stable_rank(seed,p.draft.id)),
|
||||
lambda p:(p.state.home.id,p.state.last.pitch.number(),p.anchors[-1].duration,len(p.state.returns)),policy.DEFAULT.phrase_alternatives)
|
||||
result.append(dataclasses.replace(phrase,state=current,initial=original,refined=refined,before_rhythm=before_rhythm,routes=(*tuple(r for u in units for r in u.routes if all(any((n.event_id,n.start,n.end,n.pitch)==(a.event_id,a.start,a.end,a.pitch) for a in notes) for n in r.notes)),*selected_routes)))
|
||||
from generator.solo import expressions,gesture_rhythm
|
||||
if stage=='elaborated':
|
||||
revisions=[]
|
||||
for base in result:
|
||||
for changed,edit,route in gesture_rhythm.join_variants(base.draft,harmony,library):
|
||||
revised=realization.checked_phrase(base.plan,changed,changed.notes,incoming.treatments,incoming,harmony,tempo,(*base.edits,edit))
|
||||
if revised is None:continue
|
||||
state=dataclasses.replace(base.state,notes=revised.state.notes,last=revised.state.last,
|
||||
motifs=revised.state.motifs,travel=revised.state.travel)
|
||||
history=incoming.history
|
||||
for t in changed.transformations:
|
||||
heard=tuple(n for n in changed.notes if n.event_id in t.events)
|
||||
if heard:history=phrasing.remember(history,phrasing.heard(heard,t.operation,bar=bar),bar)
|
||||
state=dataclasses.replace(state,history=history)
|
||||
retained=tuple(r for r in base.routes if not any(n.start<edit.end and n.end>edit.start for n in r.notes))
|
||||
revisions.append(dataclasses.replace(revised,state=state,initial=base.initial,refined=base.refined,
|
||||
before_rhythm=base.draft,routes=(*retained,route)))
|
||||
context.diagnostics['join_revision_candidates']=context.diagnostics.get('join_revision_candidates',0)+len(revisions)
|
||||
result.extend(revisions)
|
||||
if stage=='elaborated' and getattr(context,'expressions_enabled',True):
|
||||
result=expressions.joint_candidates(result,incoming,harmony,tempo,context,bar=bar)
|
||||
selected=sequences.diverse(result,lambda p:(p.score,policy.stable_rank(seed,p.draft.id)),
|
||||
lambda p:(p.state.home.id,p.plan.closure,p.state.last.pitch.number(),tuple(e.kind for e in p.draft.expressions)),policy.DEFAULT.phrase_alternatives)
|
||||
context.diagnostics.setdefault('evaluations',[]).extend(
|
||||
{'id':p.draft.id,'retained':p in selected,'evaluation':dataclasses.asdict(p.evaluation)} for p in sorted(result,key=lambda p:p.score)[:12] if p.evaluation)
|
||||
return selected
|
||||
|
||||
@@ -361,6 +361,8 @@ class Phrase:
|
||||
routes: tuple[RouteCandidate, ...] = ()
|
||||
before_enclosure: MelodicDraft | None = None
|
||||
before_rhythm: MelodicDraft | None = None
|
||||
evaluation: object | None = None
|
||||
rhythm_groups: tuple = ()
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Solo:
|
||||
|
||||
@@ -79,6 +79,9 @@ class RhythmCell:
|
||||
duration: F
|
||||
purpose: str
|
||||
difficulty: str | None = None
|
||||
subdivision: str = 'binary'
|
||||
entry: str = 'attack'
|
||||
exit: str = 'continue'
|
||||
|
||||
|
||||
def rhythm_cells(tempo, purpose=None):
|
||||
@@ -100,4 +103,8 @@ def rhythm_cells(tempo, purpose=None):
|
||||
cursor += duration
|
||||
if difficulty and len(notes) > limits['burst_attacks']:
|
||||
continue
|
||||
yield RhythmCell(cell['id'], tuple(notes), cursor, cell['purpose'], difficulty)
|
||||
from generator.solo import groups
|
||||
realized=groups.describe(tuple(notes),source=cell['id'])
|
||||
family=cell.get('subdivision','binary')
|
||||
if family=='triplet' and not any(g.family=='triplet' for g in realized):raise ValueError(cell['id']+': missing complete tuplet group')
|
||||
yield RhythmCell(cell['id'],tuple(notes),cursor,cell['purpose'],difficulty,family,cell.get('entry','attack'),cell.get('exit','continue'))
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
# Independent source excerpts
|
||||
|
||||
These are **evaluation-only original-song inputs**, not expected solos, production vocabulary, or the four target solos. They are deliberately outside `data/` and are never loaded by ordinary generation or required tests. Source provenance is beside each XML. The original 1917/1918 editions are from Johns Hopkins' Levy collection.
|
||||
|
||||
The manually transcribed first four chorus measures retain the vocal rhythm, including tied values. Chord symbols are our declared harmonic reductions of the piano score. These short excerpts do not establish whole-form generalization. Preceding pickups/verses and piano figuration are outside the excerpt scope. Original scans remain in ignored `build/composer_repair/405066e/evaluation_sources/` for review.
|
||||
|
||||
St. Louis Blues was considered, but the institutional original-score download was unavailable (403). Hindustan supplies the third independent source instead; no target arrangement was used to reconstruct missing music.
|
||||
|
||||
Run `python -m audition.transfer_review --output build/transfer_review` through the repository Python runner. This runs the normal independent generators; no tuning/selection result flows back into production.
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"title": "After You\u2019ve Gone",
|
||||
"published": 1918,
|
||||
"source": "https://levysheetmusic.mse.jhu.edu/collection/151/004",
|
||||
"printed_page": 3,
|
||||
"scope": "First four full chorus measures; preceding pickup omitted from this excerpt, not silently folded into the chorus. Not a complete standard/form transcription.",
|
||||
"harmony": "Independently authored chord-symbol reduction of the original piano harmony; ornamental piano bass motion is not transcribed. Not a claim of a definitive modern jazz chart.",
|
||||
"pitch": "Original vocal treble encoding, sounding; no guitar octave shift.",
|
||||
"tempo": "108 quarter notes/minute is a test setting, not inferred performance evidence.",
|
||||
"provenance": "Manual source-melody transcription from the original published score, after production vocabulary was authored. No target solo input.",
|
||||
"rights": "Original 1917/1918 US published composition, public-domain age in the United States. New transcription/reduction: MIT. Original scans are not redistributed. Other jurisdictions not assessed.",
|
||||
"archive_rights": "https://www.library.jhu.edu/policies/rights-and-reproductions/"
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
<?xml version="1.0"?><score-partwise version="4.0"><work><work-title>After You’ve Gone</work-title></work><part-list><score-part id="P1"><part-name>Source melody</part-name></score-part></part-list><part id="P1">
|
||||
<measure number="1">
|
||||
<attributes><divisions>4</divisions><key><fifths>0</fifths></key><time><beats>4</beats><beat-type>4</beat-type></time><clef><sign>G</sign><line>2</line></clef></attributes><direction><direction-type><metronome><beat-unit>quarter</beat-unit><per-minute>108</per-minute></metronome></direction-type><sound tempo="108"/></direction>
|
||||
<harmony><root><root-step>F</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>C</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><tie type="start"/><type>eighth</type><notations><tied type="start"/></notations></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>5</octave></pitch><duration>8</duration><tie type="stop"/><type>half</type><notations><tied type="stop"/></notations></note>
|
||||
</measure>
|
||||
<measure number="2">
|
||||
<harmony><root><root-step>F</root-step></root><kind>minor</kind></harmony>
|
||||
<note><rest/><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>5</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>6</duration><type>quarter</type><dot/></note>
|
||||
</measure>
|
||||
<measure number="3">
|
||||
<harmony><root><root-step>C</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><tie type="start"/><type>eighth</type><notations><tied type="start"/></notations></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>8</duration><tie type="stop"/><type>half</type><notations><tied type="stop"/></notations></note>
|
||||
</measure>
|
||||
<measure number="4">
|
||||
<harmony><root><root-step>E</root-step></root><kind>dominant</kind></harmony>
|
||||
<note><rest/><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>6</duration><type>quarter</type><dot/></note>
|
||||
</measure>
|
||||
</part></score-partwise>
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"title": "Hindustan",
|
||||
"published": 1918,
|
||||
"source": "https://levysheetmusic.mse.jhu.edu/collection/152/084",
|
||||
"printed_page": 3,
|
||||
"scope": "First four full chorus measures; preceding pickup omitted from this excerpt, not silently folded into the chorus. Not a complete standard/form transcription.",
|
||||
"harmony": "Independently authored chord-symbol reduction of the original piano harmony; ornamental piano bass motion is not transcribed. Not a claim of a definitive modern jazz chart.",
|
||||
"pitch": "Original vocal treble encoding, sounding; no guitar octave shift.",
|
||||
"tempo": "108 quarter notes/minute is a test setting, not inferred performance evidence.",
|
||||
"provenance": "Manual source-melody transcription from the original published score, after production vocabulary was authored. No target solo input.",
|
||||
"rights": "Original 1917/1918 US published composition, public-domain age in the United States. New transcription/reduction: MIT. Original scans are not redistributed. Other jurisdictions not assessed.",
|
||||
"archive_rights": "https://www.library.jhu.edu/policies/rights-and-reproductions/"
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
<?xml version="1.0"?><score-partwise version="4.0"><work><work-title>Hindustan</work-title></work><part-list><score-part id="P1"><part-name>Source melody</part-name></score-part></part-list><part id="P1">
|
||||
<measure number="1">
|
||||
<attributes><divisions>4</divisions><key><fifths>0</fifths></key><time><beats>4</beats><beat-type>4</beat-type></time><clef><sign>G</sign><line>2</line></clef></attributes><direction><direction-type><metronome><beat-unit>quarter</beat-unit><per-minute>108</per-minute></metronome></direction-type><sound tempo="108"/></direction>
|
||||
<harmony><root><root-step>C</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>C</step><alter>0</alter><octave>5</octave></pitch><duration>16</duration><tie type="start"/><type>whole</type><notations><tied type="start"/></notations></note>
|
||||
</measure>
|
||||
<measure number="2">
|
||||
<harmony><root><root-step>C</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>C</step><alter>0</alter><octave>5</octave></pitch><duration>8</duration><tie type="stop"/><type>half</type><notations><tied type="stop"/></notations></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>8</duration><type>half</type></note>
|
||||
</measure>
|
||||
<measure number="3">
|
||||
<harmony><root><root-step>G</root-step></root><kind>dominant</kind></harmony>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>16</duration><tie type="start"/><type>whole</type><notations><tied type="start"/></notations></note>
|
||||
</measure>
|
||||
<measure number="4">
|
||||
<harmony><root><root-step>G</root-step></root><kind>dominant</kind></harmony>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>8</duration><tie type="stop"/><type>half</type><notations><tied type="stop"/></notations></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>4</octave></pitch><duration>4</duration><type>quarter</type></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>4</duration><type>quarter</type></note>
|
||||
</measure>
|
||||
</part></score-partwise>
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"title": "Indiana",
|
||||
"published": 1917,
|
||||
"source": "https://levysheetmusic.mse.jhu.edu/collection/152/200",
|
||||
"printed_page": 3,
|
||||
"scope": "First four full chorus measures; preceding pickup omitted from this excerpt, not silently folded into the chorus. Not a complete standard/form transcription.",
|
||||
"harmony": "Independently authored chord-symbol reduction of the original piano harmony; ornamental piano bass motion is not transcribed. Not a claim of a definitive modern jazz chart.",
|
||||
"pitch": "Original vocal treble encoding, sounding; no guitar octave shift.",
|
||||
"tempo": "108 quarter notes/minute is a test setting, not inferred performance evidence.",
|
||||
"provenance": "Manual source-melody transcription from the original published score, after production vocabulary was authored. No target solo input.",
|
||||
"rights": "Original 1917/1918 US published composition, public-domain age in the United States. New transcription/reduction: MIT. Original scans are not redistributed. Other jurisdictions not assessed.",
|
||||
"archive_rights": "https://www.library.jhu.edu/policies/rights-and-reproductions/"
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
<?xml version="1.0"?><score-partwise version="4.0"><work><work-title>Indiana</work-title></work><part-list><score-part id="P1"><part-name>Source melody</part-name></score-part></part-list><part id="P1">
|
||||
<measure number="1">
|
||||
<attributes><divisions>4</divisions><key><fifths>1</fifths></key><time><beats>4</beats><beat-type>4</beat-type></time><clef><sign>G</sign><line>2</line></clef></attributes><direction><direction-type><metronome><beat-unit>quarter</beat-unit><per-minute>108</per-minute></metronome></direction-type><sound tempo="108"/></direction>
|
||||
<harmony><root><root-step>G</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>8</duration><tie type="start"/><type>half</type><notations><tied type="start"/></notations></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>3</duration><tie type="stop"/><type>eighth</type><dot/><notations><tied type="stop"/></notations></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>5</octave></pitch><duration>1</duration><type>16th</type></note>
|
||||
<note><pitch><step>D</step><alter>0</alter><octave>5</octave></pitch><duration>3</duration><type>eighth</type><dot/></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>1</duration><type>16th</type></note>
|
||||
</measure>
|
||||
<measure number="2">
|
||||
<harmony><root><root-step>A</root-step></root><kind>dominant</kind></harmony>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>4</duration><type>quarter</type></note>
|
||||
<note><pitch><step>E</step><alter>0</alter><octave>4</octave></pitch><duration>8</duration><type>half</type></note>
|
||||
<note><pitch><step>F</step><alter>1</alter><octave>4</octave></pitch><duration>3</duration><type>eighth</type><dot/></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>1</duration><type>16th</type></note>
|
||||
</measure>
|
||||
<measure number="3">
|
||||
<harmony><root><root-step>D</root-step></root><kind>dominant</kind></harmony>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>6</duration><type>quarter</type><dot/></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
<note><pitch><step>B</step><alter>0</alter><octave>4</octave></pitch><duration>6</duration><type>quarter</type><dot/></note>
|
||||
<note><pitch><step>A</step><alter>0</alter><octave>4</octave></pitch><duration>2</duration><type>eighth</type></note>
|
||||
</measure>
|
||||
<measure number="4">
|
||||
<harmony><root><root-step>G</root-step></root><kind>major</kind></harmony>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>8</duration><tie type="start"/><type>half</type><notations><tied type="start"/></notations></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>3</duration><tie type="stop"/><type>eighth</type><dot/><notations><tied type="stop"/></notations></note>
|
||||
<note><pitch><step>G</step><alter>0</alter><octave>4</octave></pitch><duration>1</duration><type>16th</type></note>
|
||||
<note><pitch><step>F</step><alter>1</alter><octave>4</octave></pitch><duration>3</duration><type>eighth</type><dot/></note>
|
||||
<note><pitch><step>F</step><alter>0</alter><octave>4</octave></pitch><duration>1</duration><type>16th</type></note>
|
||||
</measure>
|
||||
</part></score-partwise>
|
||||
@@ -0,0 +1,177 @@
|
||||
"""Independent musical fixtures; optional target scores are never read."""
|
||||
import dataclasses
|
||||
from fractions import Fraction as F
|
||||
import unittest
|
||||
from generator.solo import groups, scoring, types, harmonic, themes, realization, profiles
|
||||
from tests.test_solo_development import note
|
||||
from tests.test_solo_passages import choices
|
||||
from tests.test_solo_themes import melody
|
||||
import tests.solo_fixtures
|
||||
import tests.rhythm_fixtures
|
||||
|
||||
|
||||
def evaluated(notes,harmony,**kwargs):
|
||||
motif=types.Motif('authored',(),F(4),(),'test only')
|
||||
plan=types.PhrasePlan('test',F(),F(4),motif,'continue','thematic_recomposition',None,(41,76),F(1),F(),
|
||||
(types.ActivitySpan(F(),F(4),'active',F(1),F()),),ending='connected',closure='open')
|
||||
draft=types.MelodicDraft('test',F(),F(4),tuple(notes),(),(),(),(),None,'continue')
|
||||
return scoring.musical(plan,draft,notes,types.ContinuationState(''),harmony,**kwargs)
|
||||
|
||||
|
||||
class RhythmGroups(unittest.TestCase):
|
||||
def test_complete_triplet_can_be_displaced_without_offsetting_binary_tail(self):
|
||||
pattern=((F(1,2),F(5,6)),(F(5,6),F(7,6)),(F(7,6),F(3,2)),(F(3,2),F(5,2)))
|
||||
result=groups.describe(pattern)
|
||||
self.assertEqual(result[0].family,'triplet')
|
||||
self.assertEqual(result[-1].family,'binary')
|
||||
self.assertEqual(result[0].displacement,F(1,2))
|
||||
|
||||
def test_partial_triplet_does_not_drift_into_binary(self):
|
||||
self.assertFalse(groups.valid(((F(),F(1,3)),(F(1,3),F(5,6)))))
|
||||
self.assertFalse(groups.valid(((F(1,3),F(4,3)),)))
|
||||
self.assertEqual(groups.describe(((F(1,3),F(4,3)),),imported=True)[0].family,'source')
|
||||
|
||||
def test_relative_rhythm_identity_does_not_count_absolute_onsets(self):
|
||||
original=melody(((0,1,'c'),(1,2,'e'),(2,3,'d')))
|
||||
self.assertEqual(len(set(groups.signature(original))),1)
|
||||
moved=tuple(dataclasses.replace(n,start=n.start+13,end=n.end+13) for n in original)
|
||||
self.assertEqual(groups.signature(original),groups.signature(moved))
|
||||
|
||||
def test_broadening_never_cuts_inside_tuplet(self):
|
||||
pattern=((F(),F(1,3)),(F(1,3),F(2,3)),(F(2,3),F(1)))
|
||||
self.assertEqual(groups.broaden(pattern,F(1,2),F(4)),())
|
||||
|
||||
|
||||
class EvaluationContract(unittest.TestCase):
|
||||
def test_sum_and_configured_weights_are_authoritative(self):
|
||||
h=harmonic.Harmony(choices(('C7',)),profiles.Instrument(reference=48))
|
||||
ns=(note(0,1,'g'),note(2,3,'f'),note(3,4,'e'))
|
||||
base=evaluated(ns,h,travel=2000)
|
||||
self.assertTrue(base.valid)
|
||||
self.assertAlmostEqual(base.total,sum(base.contributions.values()))
|
||||
for key,value in base.raw.items():
|
||||
changed=evaluated(ns,h,travel=2000,weights={**base.weights,key:base.weights[key]+1})
|
||||
self.assertAlmostEqual(changed.total-base.total,value)
|
||||
self.assertGreater(base.raw['activity'],0)
|
||||
self.assertGreater(base.raw['harmony'],0)
|
||||
self.assertGreater(base.raw['register'],0)
|
||||
|
||||
def test_ties_are_partition_invariant_and_silence_cannot_win(self):
|
||||
h=harmonic.Harmony(choices(('C7',)))
|
||||
whole=(note(0,4,'e',event_id='a'),)
|
||||
split=(note(0,2,'e',event_id='a'),note(2,4,'e',event_id='a',continuation=True))
|
||||
self.assertEqual(evaluated(whole,h),evaluated(split,h))
|
||||
self.assertFalse(evaluated((),h).valid)
|
||||
|
||||
def test_computational_end_is_not_a_required_chord_member(self):
|
||||
h=harmonic.Harmony(choices(('C7',)))
|
||||
ns=(note(0,1,'g'),note(1,2,'e'),note(2,3,'f'),note(3,4,'a'))
|
||||
self.assertTrue(evaluated(ns,h).valid)
|
||||
|
||||
|
||||
class PendingTreatments(unittest.TestCase):
|
||||
def test_complete_route_can_cross_a_search_frontier(self):
|
||||
from tests.test_independent_generation import TypedExpressionContracts
|
||||
fixture=TypedExpressionContracts();fixture.setUp();notes,contract=fixture.make()
|
||||
partial=fixture.h.evaluate(notes[:2],until=F(2),complete=False,expressions=(contract,))
|
||||
self.assertTrue(partial.valid,partial.error)
|
||||
self.assertEqual(partial.pending,(contract,))
|
||||
self.assertFalse(fixture.h.evaluate(notes[:2],until=F(3),expressions=(contract,)).valid)
|
||||
complete=fixture.h.evaluate(notes,until=F(4),complete=True,expressions=(contract,))
|
||||
self.assertTrue(complete.valid);self.assertFalse(complete.pending)
|
||||
|
||||
|
||||
class Reachability(unittest.TestCase):
|
||||
def test_all_development_operations_are_requested(self):
|
||||
notes=melody(((0,1,'c'),(1,2,'e'),(2,3,'d'),(3,4,'e')))
|
||||
home=types.RealizedMotif('home','source',notes,F(4),'introduce','contour',signature=notes)
|
||||
state=types.ContinuationState('',home=home,notes=notes,last=notes[-1])
|
||||
ops=themes.operation_choices(home,state,F(4),F(4),False)
|
||||
self.assertTrue({'answer','extend','fragment','continue','return'}.issubset(ops))
|
||||
h=harmonic.Harmony(choices(('CM7','CM7')))
|
||||
context=realization.SearchContext()
|
||||
for op in ops:
|
||||
candidates=themes.unit_candidates(themes.home_reference(home,op),F(4),F(8),state,h,
|
||||
tests.solo_fixtures.library(),tests.rhythm_fixtures.library(),'4/4',context,home=home,operation=op)
|
||||
self.assertTrue(candidates,op)
|
||||
self.assertGreater(context.diagnostics['operations'][op]['valid'],0)
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
|
||||
class InputFirewall(unittest.TestCase):
|
||||
def test_read_write_handles_cannot_bypass_boundary(self):
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from generator.input_audit import composition
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
forbidden=Path(folder)/'target.xml';forbidden.write_text('not musical input')
|
||||
for mode in ('r','r+'):
|
||||
with self.assertRaisesRegex(ValueError,'Forbidden composition input'):
|
||||
with composition(Path('data'),'electric_solo'):
|
||||
with forbidden.open(mode) as stream:stream.read()
|
||||
|
||||
class RetrievalIntegrity(unittest.TestCase):
|
||||
def test_diversity_optimization_preserves_stable_old_order(self):
|
||||
from generator.solo.sequences import diverse
|
||||
values=((3,'b'),(1,'a'),(1,'b'),(1,'a'),(2,'c'),(4,'a'))
|
||||
def original(items,limit):
|
||||
families={}
|
||||
for item in sorted(items,key=lambda v:v[0]):families.setdefault(item[1],[]).append(item)
|
||||
out=[];i=0
|
||||
while len(out)<limit:
|
||||
layer=[g[i] for g in families.values() if len(g)>i]
|
||||
if not layer:break
|
||||
out.extend(sorted(layer,key=lambda v:v[0])[:limit-len(out)]);i+=1
|
||||
return tuple(out)
|
||||
for limit in range(9):
|
||||
self.assertEqual(diverse(values,lambda v:v[0],lambda v:v[1],limit),original(values,limit))
|
||||
|
||||
def test_seed_cutoff_preserves_different_feature_contracts(self):
|
||||
from generator.solo import analysis
|
||||
from tests.test_solo import song
|
||||
seeds=themes.seeds(analysis.analyze(song(count=12)),F(4),'independent-test')
|
||||
self.assertGreater(len({s.treatment for s in seeds}),1)
|
||||
|
||||
class NonzeroContributions(unittest.TestCase):
|
||||
def test_rhythm_destination_repetition_are_operational(self):
|
||||
from generator.solo import phrasing
|
||||
h=harmonic.Harmony(choices(('C7',)),profiles.Instrument(reference=55))
|
||||
ns=(note(0,F(1,2),'g'),note(1,F(3,2),'c',octave=5),note(3,4,'e'))
|
||||
motif=types.Motif('fixture',(),F(4),(),'independently authored')
|
||||
plan=types.PhrasePlan('fixture',F(),F(4),motif,'continue','thematic_recomposition',None,(41,76),F(1),F(),
|
||||
(types.ActivitySpan(F(),F(4),'active',F(1),F()),),ending='connected',closure='open')
|
||||
anchor=types.Anchor('arrival',F(3),F(3),ns[-1].pitch,h.members(F(3),F(4)),(41,76),F(1),'intermediate',h.at(F(3)).chord,hold_until=F(4))
|
||||
draft=types.MelodicDraft('fixture',F(),F(4),ns,(),(),(),(anchor,),None,'continue')
|
||||
old=tuple(dataclasses.replace(n,start=n.start-4,end=n.end-4) for n in ns)
|
||||
incoming=types.ContinuationState('',history=(phrasing.heard(old,'continue'),))
|
||||
base=scoring.musical(plan,draft,ns,incoming,h)
|
||||
self.assertTrue(base.valid,base.error)
|
||||
for key in ('rhythm','destination','repetition'):
|
||||
self.assertGreater(base.raw[key],0,key)
|
||||
changed=scoring.musical(plan,draft,ns,incoming,h,weights={**base.weights,key:0})
|
||||
self.assertAlmostEqual(base.total-changed.total,base.contributions[key])
|
||||
|
||||
class PreparedSuspensions(unittest.TestCase):
|
||||
def test_preparation_and_delayed_resolution_are_required(self):
|
||||
h=harmonic.Harmony(choices(('Gm7','C7')))
|
||||
held=note(F(5,2),F(9,2),'f',event_id='held')
|
||||
target=note(F(9,2),6,'e',event_id='resolution')
|
||||
contract=types.ExpressionContract('prepared','suspension','prepared_step_down',(held,),target,'C7',boundary=F(4))
|
||||
self.assertTrue(h.evaluate((held,target),expressions=(contract,)).valid)
|
||||
self.assertFalse(h.evaluate((held,target)).valid)
|
||||
changed=dataclasses.replace(held,start=F(15,4))
|
||||
self.assertFalse(h.evaluate((changed,target),expressions=(dataclasses.replace(contract,events=(changed,)),)).valid)
|
||||
self.assertFalse(h.evaluate((held,),expressions=(contract,)).valid)
|
||||
|
||||
def test_suspension_rule_is_reachable_from_provisional_phrase(self):
|
||||
from generator.solo import expressions
|
||||
h=harmonic.Harmony(choices(('Gm7','C7')))
|
||||
ns=(note(3,4,'f',event_id='held'),note(4,6,'e',event_id='resolution'))
|
||||
motif=types.Motif('fixture',ns,F(8),(),'independent suspension')
|
||||
plan=types.PhrasePlan('fixture',F(),F(8),motif,'continue','thematic_recomposition',None,(41,76),F(1),F(),ending='connected',closure='open')
|
||||
draft=types.MelodicDraft('fixture',F(),F(8),ns,(),(),(),(),None,'continue')
|
||||
phrase=types.Phrase(plan,(),0,draft=draft)
|
||||
candidates=[(notes,c) for notes,c in expressions.proposals(phrase,h) if c.kind=='suspension']
|
||||
self.assertTrue(candidates)
|
||||
self.assertTrue(any(h.evaluate(notes,expressions=(c,)).valid for notes,c in candidates))
|
||||
@@ -68,11 +68,11 @@ class SoloInstrumentAndIdentity(unittest.TestCase):
|
||||
self.assertTrue(any(p.string_number==1 for p in placement.positions(65,electric)))
|
||||
self.assertTrue(any(p.string_number==1 for p in placement.positions(65,acoustic)))
|
||||
|
||||
def test_sounding_melody_reference_and_octave_relation(self):
|
||||
def test_soft_overlapping_registers_do_not_inherit_a_mandatory_octave(self):
|
||||
source=analysis.analyze(generator.parts.prepare_document(song(count=4,chords=('CM7',))))
|
||||
acoustic=profiles.for_part('acoustic',source);electric=profiles.for_part('electric',source)
|
||||
self.assertEqual(electric.reference-acoustic.reference,12)
|
||||
self.assertEqual(electric.reference,profiles.weighted_center(source.melody)+12)
|
||||
self.assertLess(electric.reference-acoustic.reference,12)
|
||||
self.assertEqual(acoustic.melody_range,electric.melody_range)
|
||||
self.assertEqual(acoustic.cost(acoustic.reference+4),0)
|
||||
self.assertGreater(acoustic.cost(acoustic.reference+9),0)
|
||||
|
||||
|
||||
+3
-1
@@ -122,7 +122,9 @@ class SoloTests(unittest.TestCase):
|
||||
self.assertTrue(all(p.draft.source_phrase for p in result.phrases))
|
||||
self.assertFalse(any(d.treatment.startswith('quote') for p in result.phrases for d in p.decisions))
|
||||
original = result.phrases[0].plan
|
||||
explicit = dataclasses.replace(original, treatment='exact_quote', target=None, anchor_options=(), gestures=(), passage_id='', passage_start=None, passage_end=None)
|
||||
explicit = dataclasses.replace(original, treatment='exact_quote', end=original.start+original.motif.duration,
|
||||
target=None, anchor_options=(), gestures=(), passages=(),landmarks=(),release=fractions.Fraction(),ending='connected',closure='open',
|
||||
passage_id='', passage_start=None, passage_end=None)
|
||||
first = generator.solo.realization.compose(explicit, source['staves'][0]['measures'], result.choices, tests.solo_fixtures.library(), tests.rhythm_fixtures.library(), result.tempo)
|
||||
quote = next(d for d in first.decisions if d.treatment.startswith('quote'))
|
||||
self.assertEqual(len(quote.notes), len(first.plan.motif.notes))
|
||||
|
||||
@@ -188,8 +188,7 @@ class DraftCompositionTests(unittest.TestCase):
|
||||
self.assertTrue(draft.transformations)
|
||||
previous = phrase.state.last
|
||||
def test_source_family_survives_phrase_variations(self):
|
||||
first, second = self.solo.phrases
|
||||
self.assertEqual(first.state.home.id, second.state.home.id)
|
||||
self.assertEqual(len({p.state.home.id for p in self.solo.phrases}),1)
|
||||
for phrase in self.solo.phrases:
|
||||
self.assertTrue(all(t.home == phrase.state.home.id for t in phrase.draft.transformations))
|
||||
self.assertTrue(phrase.state.home.chord_degrees)
|
||||
|
||||
@@ -235,7 +235,7 @@ class EnclosureRefinement(unittest.TestCase):
|
||||
|
||||
|
||||
class EnclosureCompositionAPI(unittest.TestCase):
|
||||
def test_disable_only_removes_post_selection_ornaments(self):
|
||||
def test_disable_joint_expressions_selects_a_valid_strict_alternative(self):
|
||||
from generator.solo import analysis
|
||||
import tests.rhythm_fixtures
|
||||
doc=song(count=8,chords=('Gm7','C7','FM7','BbM7','Em7b5','A7','Dm7','Dm7'))
|
||||
@@ -244,12 +244,15 @@ class EnclosureCompositionAPI(unittest.TestCase):
|
||||
kwargs=dict(scales=tests.scale_fixtures.library(),sequences=tests.solo_fixtures.library(),rhythms=tests.rhythm_fixtures.library())
|
||||
decorated=composer.compose(*args,**kwargs)
|
||||
strict=composer.compose(*args,**kwargs,enclosures_enabled=False)
|
||||
self.assertEqual(enclosures.strict(decorated).notes(),strict.notes())
|
||||
self.assertEqual([p.state.home for p in decorated.phrases],[p.state.home for p in strict.phrases])
|
||||
self.assertEqual([p.anchors for p in decorated.phrases],[p.anchors for p in strict.phrases])
|
||||
# A jointly composed color/anticipation can change phrase selection. Its
|
||||
# disabled alternative need not be the selected decorated phrase minus
|
||||
# notes; both versions must retain the same form and valid sounding spans.
|
||||
self.assertEqual(decorated.end,strict.end)
|
||||
composer.validate(decorated)
|
||||
composer.validate(strict)
|
||||
self.assertTrue(harmonic.Harmony(strict.choices).evaluate(strict.notes()).valid)
|
||||
self.assertTrue(all(not p.draft.enclosures for p in strict.phrases))
|
||||
self.assertGreater(decorated.diagnostics["expression_candidates"],0)
|
||||
self.assertGreater(sum(v['proposed'] for v in decorated.diagnostics['expression_operations'].values()),0)
|
||||
self.assertTrue(all(not p.draft.expressions for p in strict.phrases))
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
|
||||
@@ -77,11 +77,12 @@ class CompleteRouteTests(unittest.TestCase):
|
||||
library = sequences.Library((sequences.Sequence('descending', (-1, -1)), sequences.Sequence('wrong', (1, 1))))
|
||||
template = notes(('g', 'c', 'e'))
|
||||
result = routes.candidates(template, {'n0', 'n2'}, harmony, library, (55, 79))
|
||||
self.assertEqual(len(result), 1)
|
||||
self.assertEqual([n.pitch.number() for n in result[0].notes], [67, 65, 64])
|
||||
self.assertEqual(result[0].sources, ('descending',))
|
||||
self.assertEqual(result[0].destination, template[-1])
|
||||
self.assertTrue(harmony.evaluate(result[0].notes).valid)
|
||||
# Explicit repeated-attack primitives can also complete a chord traversal.
|
||||
# The authored route itself must survive intact, without nearest-note repair.
|
||||
selected=next(r for r in result if r.sources==('descending',))
|
||||
self.assertEqual([n.pitch.number() for n in selected.notes], [67, 65, 64])
|
||||
self.assertTrue(all(r.destination==template[-1] for r in result))
|
||||
self.assertTrue(all(harmony.evaluate(r.notes).valid for r in result))
|
||||
def test_route_cannot_repair_a_forbidden_fixed_pitch(self):
|
||||
harmony = harmonic.Harmony(passages.choices(('C7',)))
|
||||
library = sequences.Library((sequences.Sequence('descending', (-1, -1)),))
|
||||
|
||||
@@ -26,8 +26,8 @@ class SustainedPhrasing(unittest.TestCase):
|
||||
whole=(note(0,1,'g'),note(1,F(3,2),'f'),note(F(3,2),4,'e'))
|
||||
split=(whole[0],whole[1],dataclasses.replace(whole[2],end=2),note(2,4,'e',continuation=True))
|
||||
incoming=types.ContinuationState('')
|
||||
self.assertEqual(phrasing.evaluate(whole,incoming,harmony,F(),F(4),F(4)),
|
||||
phrasing.evaluate(split,incoming,harmony,F(),F(4),F(4)))
|
||||
from tests.test_composer_repair import evaluated
|
||||
self.assertEqual(evaluated(whole,harmony),evaluated(split,harmony))
|
||||
|
||||
def test_route_cache_preserves_concrete_provenance_and_uncached_selection(self):
|
||||
from generator.solo import routes,sequences,policy
|
||||
|
||||
@@ -93,14 +93,18 @@ class ThemeProduction(unittest.TestCase):
|
||||
for phrase in self.solo.phrases:
|
||||
self.assertTrue(drafts.contract_valid(phrase.draft,composer.phrase_notes(phrase))[0])
|
||||
self.assertFalse(similarity.near_copy(phrase.refined.notes,themes.source_notes(self.analysis),phrase.plan.start,phrase.plan.end)['near_copy'])
|
||||
self.assertEqual(self.solo.phrases[0].plan.closure,'closed')
|
||||
self.assertTrue(all(a.duration>=2 for a in self.solo.phrases[0].anchors))
|
||||
self.assertIn(self.solo.phrases[0].plan.closure,('open','closed'))
|
||||
self.assertTrue(all(p.evaluation and p.score==p.evaluation.total for p in self.solo.phrases))
|
||||
self.assertEqual(self.solo.phrases[-1].anchors[-1].role,'terminal')
|
||||
self.assertTrue(any(t.operation in ('develop_contour','develop_rhythm','continue','return') for p in self.solo.phrases for t in p.draft.transformations))
|
||||
|
||||
def test_library_routes_match_the_actual_complete_theme(self):
|
||||
self.assertTrue(any(p.routes for p in self.solo.phrases))
|
||||
for phrase in self.solo.phrases:
|
||||
plain=composer.compose(self.analysis,self.document['staves'][0]['measures'],'acoustic',F(32),stage='plain',**self.kw)
|
||||
# Joint rhythm/expression edits can replace every original route in this
|
||||
# particular fixture. Require construction to use complete routes, then
|
||||
# verify all retained provenance in both the plain and edited realizations.
|
||||
self.assertTrue(any(p.routes for p in plain.phrases))
|
||||
for phrase in (*plain.phrases,*self.solo.phrases):
|
||||
heard={n.event_id:n for n in composer.phrase_notes(phrase)}
|
||||
for route in phrase.routes:
|
||||
for note in route.notes:
|
||||
|
||||
Reference in New Issue
Block a user