Soloing & Measures

generator/solo/audition.py

@@ -5,6 +5,7 @@ import argparse
 import array
 import collections
 import copy
+import dataclasses
 import fractions
 import hashlib
 import html
@@ -26,6 +27,7 @@ import generator.scales.library
 import generator.solo.arrangement
 import generator.solo.report
 import generator.solo.sequences
+import generator.solo.realization
 
 STAGES = ('baseline', 'A', 'B', 'C', 'D')
 
@@ -71,13 +73,14 @@ def fingerprint():
     digest.update(path.read_bytes())
   return digest.hexdigest()
 
-def capture(root, stage):
+def resources():
+  return (generator.rhythm.load_library(pathlib.Path('data/rhythms')), generator.scales.library.load_library(pathlib.Path('data/scales')), generator.solo.sequences.load_library(pathlib.Path('data/sequences')))
+
+def capture(root, stage, libraries=None, contexts=None):
   destination = root / stage
   if destination.exists():
     raise ValueError(f'{destination}: snapshot already exists; choose a new output root')
-  rhythms = generator.rhythm.load_library(pathlib.Path('data/rhythms'))
-  scales = generator.scales.library.load_library(pathlib.Path('data/scales'))
-  sequences = generator.solo.sequences.load_library(pathlib.Path('data/sequences'))
+  rhythms, scales, sequences = libraries or resources()
   result = {'stage': stage, 'implementation': fingerprint(), 'songs': {}}
   try:
     result['policy'] = importlib.import_module('generator.solo.policy').describe()
@@ -89,12 +92,37 @@ def capture(root, stage):
     plans = generator.arrange.generate.plan_arrangement(document, rhythms)
     parts = {part: generator.arrange.generate._arrange_document(document, part, plans) for part in generator.parts.PART_TYPES}
     solos = []
-    generator.solo.arrangement.apply(document, parts, rhythms=rhythms, scales=scales, sequences=sequences, solos=solos)
+    shared = contexts.setdefault(path.stem, {p: generator.solo.realization.SearchContext() for p in ('acoustic', 'electric')}) if contexts is not None else None
+    if shared:
+      for context in shared.values():
+        context.diagnostics = generator.solo.realization.SearchContext().diagnostics
+    generator.solo.arrangement.apply(document, parts, rhythms=rhythms, scales=scales, sequences=sequences, solos=solos, revise=stage != 'phrase', contexts=shared)
     song = {'source_sha256': hashlib.sha256(path.read_bytes()).hexdigest(), 'parts': parts, 'solos': {}, 'elapsed_seconds': time.monotonic() - started}
     regions = generator.solo.arrangement.regions(document)
     for solo, index in zip(solos, (3, 4)):
       first, count, offset, length = regions[index]
       song['solos'][solo.part] = {'first': first, 'count': count, 'offset': str(offset), 'length': str(length), 'tempo': str(solo.tempo), 'metrics': metrics(solo), 'report': generator.solo.report.describe(solo, scales), 'structure': generator.solo.report.structure(solo)}
+      drafts = []
+      template = parts[solo.part]['staves'][0]['measures'][first:first + count]
+      boundaries = [fractions.Fraction()]
+      for measure in template:
+        boundaries.append(boundaries[-1] + generator.model.fraction(measure['duration']))
+      for phrase in solo.phrases:
+        if not phrase.draft:
+          continue
+        begin = boundaries.index(phrase.plan.start)
+        stop = next(i for i, boundary in enumerate(boundaries) if boundary >= phrase.plan.end)
+        view = excerpt(parts[solo.part], first + begin, stop - begin)
+        local = tuple(dataclasses.replace(n, start=n.start - phrase.plan.start, end=n.end - phrase.plan.start, continuation=False if i == 0 else n.continuation) for i, n in enumerate(phrase.draft.notes))
+        placed = generator.solo.placement.place(local, solo.tempo)
+        if placed is None:
+          raise ValueError(f'{phrase.plan.id}: draft cannot be placed for independent audition')
+        foreground = generator.solo.notation.measures(view['staves'][0]['measures'], placed[1], 'draft_' + phrase.plan.id)
+        generator.solo.notation.replace_region(view, 0, foreground)
+        generator.model.validate_document(view)
+        generator.fretboard.validate_document(view)
+        drafts.append({'id': phrase.plan.id, 'draft_id': phrase.draft.id, 'first': begin, 'count': stop - begin, 'document': view})
+      song['solos'][solo.part]['draft_documents'] = drafts
       print(path.stem, solo.part, json.dumps(song['solos'][solo.part]['metrics']), flush=True)
     result['songs'][path.stem] = song
   destination.mkdir(parents=True)
@@ -152,7 +180,7 @@ def mix(documents, tempo, root, cache):
   return output
 
 def render(root):
-  stages = ('before', 'after') if (root / 'before' / 'snapshot.json').exists() else STAGES
+  stages = ('baseline', 'phrase', 'revised') if (root / 'revised' / 'snapshot.json').exists() else ('before', 'after') if (root / 'before' / 'snapshot.json').exists() else STAGES
   snapshots = {stage: json.loads((root / stage / 'snapshot.json').read_text()) for stage in stages}
   cache, clips, manifest = {}, [], {'sample_rate': generator.playback.SAMPLE_RATE, 'stages': {}, 'clips': []}
   for stage, snapshot in snapshots.items():
@@ -163,7 +191,7 @@ def render(root):
         raise ValueError(f'{song_name}: source changed between audition stages')
       for part, solo in song['solos'].items():
         other = 'electric' if part == 'acoustic' else 'acoustic'
-        windows = [('full', 0, solo['count']), ('opening8', 0, min(8, solo['count'])), ('closing4', max(0, solo['count'] - 4), min(4, solo['count']))] if stages[0] == 'before' else [('', 0, min(8, solo['count']))]
+        windows = [('full', 0, solo['count']), ('opening8', 0, min(8, solo['count'])), ('closing4', max(0, solo['count'] - 4), min(4, solo['count']))] if stages[0] == 'before' or stages[-1] == 'revised' else [('', 0, min(8, solo['count']))]
         for label, offset, count in windows:
           first = solo['first'] + offset
           foreground = excerpt(song['parts'][part], first, count)
@@ -179,6 +207,24 @@ def render(root):
             samples = mix((foreground, backing, vocal), fractions.Fraction(solo['tempo']), root, cache)
             clips.append((path, samples))
             manifest['clips'].append({'path': path.relative_to(root).as_posix(), 'window': label, 'first': offset, 'count': count, 'tempo': solo['tempo'], 'responsive_backing': responsive, 'source_sha256': song['source_sha256'], 'metrics': solo['metrics'], 'elapsed_seconds': song['elapsed_seconds']})
+        for draft in solo.get('draft_documents', ()):
+          prefix = root / stage / f'{song_name}_{part}_draft_{draft["id"]}'
+          generator.musicxml_writer.write_musicxml(prefix.with_suffix('.musicxml'), draft['document'])
+          if draft['first'] < 8:
+            backing = excerpt(baseline['parts'][other], solo['first'] + draft['first'], draft['count'])
+            path = prefix.with_suffix('.wav')
+            clips.append((path, mix((draft['document'], backing), fractions.Fraction(solo['tempo']), root, cache)))
+            manifest['clips'].append({'path': path.relative_to(root).as_posix(), 'kind': 'simple_phrase_draft', 'draft_id': draft['draft_id'], 'first': draft['first'], 'count': draft['count']})
+        if stage in ('phrase', 'revised'):
+          neutral = excerpt(song['parts'][part], solo['first'], min(8, solo['count']))
+          for measure in neutral['staves'][0]['measures']:
+            for voice in measure['voices']:
+              for event in voice['notes']:
+                for pitch in event['pitches']:
+                  pitch.update({'letter': 'c', 'alter': generator.model.rational(0), 'octave': 5, 'tablature': {'string': 2, 'fret': 1}})
+          path = root / stage / f'{song_name}_{part}_rhythm_only.wav'
+          clips.append((path, mix((neutral,), fractions.Fraction(solo['tempo']), root, cache)))
+          manifest['clips'].append({'path': path.relative_to(root).as_posix(), 'kind': 'rhythm_only_diagnostic', 'valid_harmonic_solo': False})
   # One common attenuation preserves relative loudness and identical backing.
   peak = max(abs(value) for _, samples in clips for value in samples)
   gain = min(1, 0.95 / peak) if peak else 1
@@ -186,9 +232,33 @@ def render(root):
   for path, samples in clips:
     generator.playback.write_pcm(path, (value * gain for value in samples))
   (root / 'manifest.json').write_text(json.dumps(manifest, indent=2) + '\n')
-  write_passage_index(root, snapshots) if stages[0] == 'before' else write_index(root, snapshots)
+  write_phrase_index(root, snapshots) if stages[-1] == 'revised' else write_passage_index(root, snapshots) if stages[0] == 'before' else write_index(root, snapshots)
   print(f'Rendered {len(clips)} comparisons under {root}', flush=True)
 
+def write_phrase_index(root, snapshots):
+  body = ['<!doctype html><html lang="en"><meta charset="utf-8"><title>Melodic phrase comparisons</title><style>body{font:16px system-ui;max-width:1250px;margin:3rem auto;padding:0 1rem;background:#faf9f5;color:#202820}table{border-collapse:collapse;width:100%;margin-bottom:2rem}td,th{text-align:left;padding:.7rem;border-bottom:1px solid #ccd1c9}audio{width:250px}small{display:block}</style><h1>Melodic phrase comparisons</h1><p>Compare the current baseline, complete phrase construction, and phrase construction with two-sided join revision. Tempo, scale policy, activity targets and seed inputs are unchanged. Fixed mixes use baseline accompaniment and one shared gain. Revised mixes also include the normal responsive backing.</p><p>Draft pools are shared when incoming musical states match; earlier edits can legitimately change later incoming states. Pool fingerprints are recorded in the reports. Simple drafts are auditioned individually, with a held entrance restarted at the excerpt boundary. Rhythm-only clips use a neutral pitch and are not valid harmonic solos.</p><p>Listen for one recognizable idea developing toward a prepared destination. Metrics do not establish musical improvement. <a href="manifest.json">Manifest and diagnostics</a>.</p>']
+  for name, song in snapshots['revised']['songs'].items():
+    for part in song['solos']:
+      body.append('<h2>' + html.escape(name.replace('_', ' ').title() + ' — ' + part.title()) + '</h2>')
+      body.append('<table><tr><th>Excerpt</th><th>Baseline</th><th>Phrase construction</th><th>With join revision</th></tr>')
+      for window in ('opening8', 'full', 'closing4'):
+        body.append(f'<tr><th>{window}</th>')
+        for stage in ('baseline', 'phrase', 'revised'):
+          prefix = f'{stage}/{name}_{part}_{window}'
+          body.append(f'<td><audio controls preload="none" src="{prefix}_fixed.wav"></audio><small><a href="{prefix}.musicxml">MusicXML</a> · <a href="{prefix}.txt">Report</a> · <a href="{prefix}.json">Structure</a></small></td>')
+        body.append('</tr>')
+      body.append('</table>')
+      for stage in ('phrase', 'revised'):
+        detail = snapshots[stage]['songs'][name]['solos'][part]
+        metric = detail['metrics']
+        body.append(f'<p>{stage}: {metric["attacks_per_four_beats"]:.2f} attacks / four beats; {metric["sounding_occupancy"]:.1%} occupancy. Rhythm only: <audio controls preload="none" src="{stage}/{name}_{part}_rhythm_only.wav"></audio></p>')
+        for draft in detail.get('draft_documents', ()):
+          if draft['first'] < 8:
+            prefix = f'{stage}/{name}_{part}_draft_{draft["id"]}'
+            body.append(f'<p>Simple draft {draft["id"]}: <audio controls preload="none" src="{prefix}.wav"></audio> <a href="{prefix}.musicxml">MusicXML</a></p>')
+      body.append(f'<p>Complete solo with responsive backing: <audio controls preload="none" src="revised/{name}_{part}_full_responsive.wav"></audio></p>')
+  (root / 'index.html').write_text(''.join(body) + '</html>\n')
+
 def write_index(root, snapshots):
   labels = {'baseline': 'Original engine', 'A': 'Scoring repair', 'B': 'Activity shapes', 'C': 'Motifs and retrieval', 'D': 'Phrase lookahead'}
   body = ['<!doctype html><html lang="en"><meta charset="utf-8"><title>Solo comparisons</title><style>body{font:16px system-ui;max-width:1200px;margin:3rem auto;padding:0 1rem;background:#faf9f5;color:#202820}table{border-collapse:collapse;width:100%;margin:1rem 0 3rem}td,th{text-align:left;padding:1rem;border-bottom:1px solid #ccd1c9}audio{width:280px}small{display:block;margin-top:.5rem}</style><h1>Solo comparisons</h1><p>Eight bars from the same solo entrance at the source tempo. All stages use the original backing and one shared mix gain. D also includes the normal backing that responds to the new solo.</p><p>A: scoring and register. B: activity and breathing. C: transformation contracts, contextual motifs and diverse paths. D: one-phrase lookahead. Expressive playback is deferred.</p><p>Metrics below describe the complete solo, not just the excerpt. These are diagnostics; listening and playing determine musical quality. <a href="manifest.json">Build fingerprints and diagnostics</a>.</p>']
@@ -225,10 +295,18 @@ def main():
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('--output', type=pathlib.Path, default=pathlib.Path('build/solo_auditions'))
   action = parser.add_mutually_exclusive_group(required=True)
-  action.add_argument('--capture', choices=(*STAGES, 'before', 'after'))
+  action.add_argument('--capture', choices=(*STAGES, 'before', 'after', 'phrase', 'revised'))
+  action.add_argument('--compare-phrases', action='store_true', help='capture both new stages using shared concrete draft pools')
   action.add_argument('--render', action='store_true')
   args = parser.parse_args()
-  capture(args.output, args.capture) if args.capture else render(args.output)
+  if args.compare_phrases:
+    libraries, contexts = resources(), {}
+    capture(args.output, 'phrase', libraries, contexts)
+    capture(args.output, 'revised', libraries, contexts)
+  elif args.capture:
+    capture(args.output, args.capture)
+  else:
+    render(args.output)
 
 if __name__ == '__main__':
   main()