Cleanup

generator/comping.py

@@ -2,26 +2,25 @@
 from __future__ import annotations
 import copy
 import dataclasses
+import fractions
 import functools
 import json
-import fractions
 import typing
 
 import generator.accompaniment
 import generator.acoustic
-import generator.comping_rhythm
-import generator.chord_families
 import generator.acoustic_voicing
 import generator.arrange.form
-import generator.arrange.pickup
+import generator.chord_families
+import generator.comping_rhythm
 import generator.fretboard
 import generator.guitar
 import generator.harmony
 import generator.model
 import generator.parts
 import generator.score
-import generator.vocabulary
 import generator.solo.policy
+import generator.vocabulary
 
 def semantic_key(chord):
   return json.dumps({k: chord[k] for k in ('root', 'kind', 'degrees', 'bass', 'inversion') if k in chord}, sort_keys=True)
@@ -38,12 +37,15 @@ def requirements(chord, part):
     raise ValueError('acoustic accompaniment requires a written bass, root or fifth')
   return dataclasses.replace(result, basses=basses)
 
+def voicings(key, part, *, composition=None):
+  return _voicings(key, part, composition or generator.vocabulary.current())
+
 @functools.lru_cache(maxsize=2048)
-def voicings(key, part):
+def _voicings(key, part, composition):
   chord = json.loads(key)
   required = requirements(chord, part)
   if part == 'electric':
-    options = generator.guitar.chord_positions(required, prune=False, profile='electric')
+    options = generator.guitar.chord_positions(required, prune=False, profile='electric', composition=composition)
   elif part == 'acoustic':
     degrees = generator.harmony.degrees(chord)
     plain = degrees in ({1: 0, 3: 0, 5: 0}, {1: 0, 3: -1, 5: 0})
@@ -77,19 +79,21 @@ class VoicingCost(typing.NamedTuple):
   def moved(self, distance):
     return self._replace(effort=self.effort + distance)
 
-def voicing_preferences(part, grip, center):
-  return generator.guitar.voicing_preferences(grip, generator.guitar.voicing_preference(part + '_accompaniment', center))
+def voicing_preferences(part, grip, center, *, composition=None):
+  composition = composition or generator.vocabulary.current()
+  return generator.guitar.voicing_preferences(grip, generator.guitar.voicing_preference(part + '_accompaniment', center, composition=composition))
 
-def local_cost(part, key, grip, center):
+def local_cost(part, key, grip, center, *, composition=None):
+  composition = composition or generator.vocabulary.current()
   required = requirements(json.loads(key), part)
   register = abs(fractions.Fraction(sum(p.midi for p in grip), len(grip)) - center)
-  preference = sum(voicing_preferences(part, grip, center))
+  preference = sum(voicing_preferences(part, grip, center, composition=composition))
   if part == 'electric':
-    value = generator.guitar.voicing_cost(grip, 'electric', required.allowed)
+    value = generator.guitar.voicing_cost(grip, 'electric', required.allowed, composition=composition)
     return VoicingCost(value.extended_grips, 3 * value.string_shortfall + value.family_penalty, value.effort + preference, value.missing_tones, register)
   # Familiar degree orders on either bass string, then balanced whole-form
   # movement, sounding register and hand position. Neither is an absolute ban.
-  family = generator.chord_families.acoustic(json.loads(key), grip)
+  family = generator.chord_families.acoustic(json.loads(key), grip, composition=composition)
   return VoicingCost(generator.fretboard.span_penalty(grip), int(not family['preferred']), preference, len(set(required.allowed) - {p.midi % 12 for p in grip}), register)
 
 def select_grips(layers, costs, part, seed, *, left=(), right=(), close=False):
@@ -184,9 +188,10 @@ def split_measures(flat, inputs, part):
   return tuple(output)
 
 class Canonical:
-  def __init__(self, document, part, seed):
+  def __init__(self, document, part, seed, *, composition=None, plan=None):
+    self.composition = composition or generator.vocabulary.current()
     self.part, self.seed = part, seed
-    self.policy = generator.vocabulary.role(part + '_accompaniment')
+    self.policy = self.composition.role(part + '_accompaniment')
     self.cache, self._reports, self._rhythm_reports = {}, {}, {}
     self.measures = generator.score.source_staff(document)['measures']
     # A held accompaniment chord may continue into the bar containing the
@@ -194,7 +199,8 @@ class Canonical:
     self.voice_id = self.measures[0]['voices'][0]['id']
     self.melody = generator.comping_rhythm.melody_contexts(document)
     self.first = generator.score.body_start_measure_index(self.measures)
-    sections = generator.arrange.form.full_arrangement_sections(self.measures, part)
+    plan = plan or generator.arrange.form.FormPlan.read(document, part)
+    sections = plan.sections
     self.closed = any(a.role == b.role == 'accompaniment' and a.source_measure_index + a.measure_count == len(self.measures)
       and b.source_measure_index == self.first for a, b in zip(sections, sections[1:]))
     carried = generator.accompaniment.carried_chords(self.measures)
@@ -204,7 +210,7 @@ class Canonical:
       size = 1
       if index + 1 < len(self.measures):
         lengths = [generator.model.fraction(m['duration']) for m in self.measures[index:index + 2]]
-        if self.measures[index]['time_signature'] == self.measures[index + 1]['time_signature'] and any(tuple(map(fractions.Fraction, p['lengths'])) == tuple(lengths) for p in generator.vocabulary.accompaniment(part)['patterns']):
+        if self.measures[index]['time_signature'] == self.measures[index + 1]['time_signature'] and any(tuple(map(fractions.Fraction, p['lengths'])) == tuple(lengths) for p in self.composition.accompaniment(part)['patterns']):
           size = 2
       self.groups.append(tuple((self.measures[i], carried[i], i) for i in range(index, index + size)))
       index += size
@@ -214,19 +220,9 @@ class Canonical:
     for section in sections:
       if section.role == 'accompaniment':
         self.pair_breaks.update((section.source_measure_index, section.source_measure_index + section.measure_count))
-    for section, following in zip(sections, sections[1:]):
-      if section.role != 'accompaniment' or not self.first:
-        continue
-      last = section.source_measure_index + section.measure_count - 1
-      pad = generator.arrange.pickup.offset(self.measures[last], self.measures[0])
-      if following.role == 'slash':
-        self.pair_stops.append((last, pad))
-      elif following.role == 'melody' and generator.arrange.pickup.enters(following, self.measures):
-        attacks = [generator.model.fraction(n['onset']) for n in generator.score.measure_notes(self.measures[0]) if n['pitches']]
-        if attacks:
-          self.pair_stops.append((last, pad + min(attacks)))
+    self.pair_stops = [stop for section, stop in zip(sections, plan.stops) if section.role == 'accompaniment' and stop is not None]
     breaks = [(i, fractions.Fraction()) for i in self.pair_breaks] + self.pair_stops
-    choices, locations, self.groove_report = generator.comping_rhythm.choose_cycles(self.groups, part, self.melody, seed, breaks=breaks)
+    choices, locations, self.groove_report = generator.comping_rhythm.choose_cycles(self.groups, part, self.melody, seed, breaks=breaks, composition=self.composition)
     self.patterns = {g[0][2]: (p, a) for g, (p, a, _) in zip(self.groups, choices)}
     self.locations = {g[0][2]: location for g, location in zip(self.groups, locations)}
     selected = [r for _, _, r in choices]
@@ -266,7 +262,7 @@ class Canonical:
       melody.extend((a + cursor, b + cursor) for a, b in self.melody[i])
       lengths.append(generator.model.fraction(m['duration']))
       cursor += lengths[-1]
-    return generator.comping_rhythm.candidates(flat, None, self.part, tuple(melody), self.seed + '/' + str(inputs[0][2]), lengths=tuple(lengths), limit=limit)
+    return generator.comping_rhythm.candidates(flat, None, self.part, tuple(melody), self.seed + '/' + str(inputs[0][2]), lengths=tuple(lengths), limit=limit, composition=self.composition)
   def acoustic_realizations(self, sources, bounds=None, stop=None):
     """Assign the canonical attack stream once, before splitting it into blocks.
 
@@ -313,14 +309,14 @@ class Canonical:
       offset, index = next((a, i) for a, i in reversed(offsets) if a <= start)
       events = tuple(e for e in rhythm.events if start <= (e.harmonic_time if e.harmonic_time is not None else e.start) < end)
       try:
-        options = voicings(semantic_key(chord), self.part)
+        options = voicings(semantic_key(chord), self.part, composition=self.composition)
       except ValueError as error:
         raise ValueError(f'source measure {inputs[index - inputs[0][2]][0]["number"]}, beat {start - offset + 1}: {error}') from error
       spans.append(HarmonyChoice(index, start, end, chord, events, dict(rhythm.families), options))
     return tuple(spans)
   def select(self, spans, *, left=(), right=(), close=False):
     layers = tuple(s.options for s in spans)
-    costs = tuple({v: local_cost(self.part, semantic_key(s.chord), v, self.policy.get('center', 55)) for v in layer} for s, layer in zip(spans, layers))
+    costs = tuple({v: local_cost(self.part, semantic_key(s.chord), v, self.policy.get('center', 55), composition=self.composition) for v in layer} for s, layer in zip(spans, layers))
     return select_grips(layers, costs, self.part, self.seed, left=left, right=right, close=close)
   def __call__(self, source, prior, index, *, sources=None, bounds=None, stop=None):
     group = next((g for g in self.groups if any(i == index for _, _, i in g)), ((source, prior, index),))
@@ -397,8 +393,8 @@ class Canonical:
       root = int(generator.model.NATURAL[span.chord['root']['letter']] + generator.model.alteration(span.chord['root']['alter']))
       rows.append({'source_index': span.index, 'onset': str(span.start), 'chord': generator.harmony.symbol(span.chord),
         'figure': span.figure, 'pattern_id': rhythm.pattern_id, 'tones': len(grip), 'bass': bool(bass), 'variant': variant,
-        'family': (generator.chord_families.acoustic(span.chord, grip) if self.part == 'acoustic' else generator.chord_families.electric(grip)) if grip else None,
-        'family_coverage': generator.chord_families.coverage(span.chord, span.options, self.part),
+        'family': (generator.chord_families.acoustic(span.chord, grip, composition=self.composition) if self.part == 'acoustic' else generator.chord_families.electric(grip)) if grip else None,
+        'family_coverage': generator.chord_families.coverage(span.chord, span.options, self.part, composition=self.composition),
         'fret_span': generator.fretboard.fret_span(grip),
         'span_group': ('fallback' if generator.fretboard.span_penalty(grip) else 'primary') if grip else None,
         'span_candidates': generator.chord_families.span_coverage(span.options),
@@ -407,9 +403,9 @@ class Canonical:
         'bass_string': bass.string_number if bass else None,
         'movement': movement(self.part, previous, grip), 'voicing_candidates': len(span.options)})
       if grip:
-        register, position = voicing_preferences(self.part, grip, self.policy.get('center', 55))
+        register, position = voicing_preferences(self.part, grip, self.policy.get('center', 55), composition=self.composition)
         travel = movement(self.part, previous, grip)
-        effort = generator.guitar.voicing_cost(grip, 'electric').effort if self.part == 'electric' else 0
+        effort = generator.guitar.voicing_cost(grip, 'electric', composition=self.composition).effort if self.part == 'electric' else 0
         rows[-1]['voicing_cost'] = {'movement': travel, 'grip_effort': str(effort), 'register': str(register), 'position': str(position), 'combined': str(travel + effort + register + position)}
       for event in span.events:
         lanes = ['bass', 'upper'] if event.lane == 'combined' else [event.lane]