khodowany
209 lines
11 KiB
Python
209 lines
11 KiB
Python
"""Independent counterfactuals: no authored target needed."""
|
|
import dataclasses
|
|
from fractions import Fraction as F
|
|
from unittest.mock import patch
|
|
import unittest
|
|
from generator.solo import construction, operators, selection
|
|
from tests.solo_fixtures import note
|
|
from tests.test_phrase_composer import builder
|
|
|
|
|
|
class CompleteSelection(unittest.TestCase):
|
|
def test_fast_signature_comparison_is_exact(self):
|
|
home=tuple(note(F(i,3),F(i+1,3),('c','e','g')[i%3]) for i in range(12))
|
|
variants=[(),home,home[:1],tuple(dataclasses.replace(n,start=n.start+5,end=n.end+5) for n in home)]
|
|
for i in range(len(home)):
|
|
for field in ('start','end'):
|
|
values=list(home);values[i]=dataclasses.replace(values[i],**{field:getattr(values[i],field)+F(1,12)})
|
|
variants.append(tuple(values))
|
|
values=list(home);values[i]=dataclasses.replace(values[i],pitch=dataclasses.replace(values[i].pitch,octave=5))
|
|
variants.append(tuple(values))
|
|
expected=selection.signature(home)
|
|
for notes in variants:self.assertEqual(selection.matches_signature(notes,expected),selection.signature(notes)==expected)
|
|
|
|
def test_locally_cheaper_opening_can_lose_complete_phrase(self):
|
|
b=builder(('CM7',),count=1)
|
|
# C is locally cheaper. Its only continuation leaps to high C, whereas
|
|
# the more costly E opening reaches nearby G. All notes are chord tones.
|
|
low=operators.Action(F(),F(2),(note(0,2,'c',octave=4),),'tone')
|
|
high=operators.Action(F(),F(2),(note(0,2,'e',octave=4),),'tone')
|
|
bad=operators.Action(F(2),F(4),(note(2,4,'c',octave=5),),'tone')
|
|
good=operators.Action(F(2),F(4),(note(2,4,'g',octave=4),),'tone')
|
|
b.selector.weights={'harmony/major/4/2':1}
|
|
self.assertLess(b.selector.cost(low),b.selector.cost(high))
|
|
def options(at,state):
|
|
xs=(low,high) if at==0 else (bad,) if state.notes[-1].pitch.number()==60 else (good,)
|
|
return tuple((b.selector.evaluate(a),a) for a in xs)
|
|
with patch.object(b,'candidates',side_effect=options):b.compose()
|
|
self.assertEqual(b.selected_actions,(high,good))
|
|
self.assertEqual(len(b.completed),2)
|
|
|
|
def test_constructor_labels_and_segmentation_do_not_change_score(self):
|
|
b=builder(('CM7',),count=1)
|
|
ns=(note(0,1,'c'),note(1,2,'e'),note(3,4,'g'))
|
|
whole=operators.Action(F(),F(4),ns,'arpeggio')
|
|
split=(operators.Action(F(),F(2),ns[:2],'scalar'),operators.Action(F(2),F(5,2),(),'rest'),
|
|
operators.Action(F(5,2),F(3),(),'rest'),operators.Action(F(3),F(4),ns[2:],'answer'))
|
|
self.assertEqual(b.selector.complete((whole,)),b.selector.complete(split))
|
|
self.assertEqual(b.selector.evaluate(whole),b.selector.evaluate(dataclasses.replace(whole,kind='enclosure')))
|
|
held=note(0,4,'e')
|
|
tied=(operators.Action(F(),F(2),(dataclasses.replace(held,end=F(2)),),'tone'),
|
|
operators.Action(F(2),F(4),(dataclasses.replace(held,start=F(2),continuation=True),),'tone'))
|
|
self.assertEqual(b.selector.complete((operators.Action(F(),F(4),(held,),'tone'),)),b.selector.complete(tied))
|
|
|
|
def test_home_belongs_to_complete_opening_not_recent_buffer(self):
|
|
b=builder(('CM7',),count=4);state=construction.State()
|
|
for i in range(16):
|
|
a=operators.Action(F(i),F(i+1),(note(i,i+1,('c','e','g','b')[i%4]),),'tone')
|
|
state=b.advance(state,None,a)
|
|
if i<15:self.assertFalse(state.home)
|
|
self.assertEqual(len(state.home),16);self.assertEqual(len(state.recent),8)
|
|
self.assertEqual(state.home[0].start,0)
|
|
|
|
def test_true_arpeggio_uses_written_chord_members(self):
|
|
b=builder(('C7',),count=1)
|
|
values=b.operators.at(F())
|
|
arps=[a for a in values if a.kind=='arpeggio']
|
|
thirds=[a for a in values if a.kind=='scale_thirds']
|
|
self.assertTrue(arps);self.assertTrue(thirds)
|
|
for a in arps:
|
|
self.assertTrue(all(n.pitch.number()%12 in b.harmony.at(n.start).roles.basic for n in a.notes))
|
|
self.assertTrue(any(any(n.pitch.number()%12 not in b.harmony.at(n.start).roles.basic for n in a.notes) for a in thirds))
|
|
|
|
def test_optional_color_lookahead_rejects_missing_and_no_chord_harmony(self):
|
|
from generator.solo import expressions
|
|
from generator import vocabulary
|
|
b=builder(('CM7',),count=1)
|
|
absent=dataclasses.replace(b.harmony.at(F()),scale=None,chord='N.C.')
|
|
for rule in vocabulary.data('harmony')['colors']:
|
|
self.assertFalse(expressions.eligible_color(rule,None,b.harmony))
|
|
self.assertFalse(expressions.eligible_color(rule,absent,b.harmony))
|
|
|
|
def test_training_features_cannot_encode_role_song_lookup(self):
|
|
for key in ('kind/arpeggio','song/all_of_me','target/pitch_sequence','source/hash'):
|
|
with self.assertRaises(ValueError):selection.validate_weights({key:1})
|
|
with self.assertRaises(ValueError):selection.validate_weights({'duration/1':1025})
|
|
from audition.structured_learning import constraint
|
|
row=constraint('acoustic_solo',({'duration/1':12},F(3)),({'duration/1':12},F(2)),'test')
|
|
self.assertFalse(row['delta']);self.assertEqual(row['prior'],1)
|
|
|
|
def test_contextual_rules_are_bounded_transposable_and_operational(self):
|
|
from audition.structured_learning import contextual_candidates
|
|
b=builder(('C7',),count=1);d=builder(('D7',),count=1)
|
|
ns=(note(0,1,'d'),note(1,2,'e'))
|
|
moved=(note(0,1,'e'),note(1,2,'f',alter=1))
|
|
key='joint/degree=4&motion=2&quality=dominant'
|
|
selection.validate_weights({key:-3})
|
|
left=contextual_candidates(b.selector,ns);right=contextual_candidates(d.selector,moved)
|
|
self.assertEqual(left[key],12);self.assertEqual(left[key],right[key])
|
|
self.assertNotIn(key,contextual_candidates(b.selector,(ns[0],note(1,2,'f'))))
|
|
a=operators.Action(F(),F(2),ns,'tone');plain=b.selector.evaluate(a)
|
|
b.selector.weights={key:-3};changed=b.selector.evaluate(a)
|
|
self.assertEqual(changed.total-plain.total,-18)
|
|
for forbidden in ('joint/degree=4&metric=beat&motion=2&quality=dominant',
|
|
'joint/degree=4&song=all_of_me','joint/absolute_bar=4&quality=dominant'):
|
|
with self.assertRaises(ValueError):selection.validate_weights({forbidden:1})
|
|
|
|
def test_open_route_survives_equal_time_frontier_without_extra_attack(self):
|
|
b=builder(('CM7',),count=1)
|
|
n=note(0,4,'e',event_id='held')
|
|
a=operators.Action(F(),F(4),(n,),'tone')
|
|
with patch.object(b.operators,'at',return_value=(a,)):b.compose()
|
|
self.assertEqual(b.completed[0].notes,(n,))
|
|
self.assertEqual(b.selected_actions,(a,))
|
|
self.assertEqual(b.completed[0].evaluation,b.selector.complete((a,)))
|
|
|
|
def test_deferred_validation_preserves_eager_successor_selection(self):
|
|
b=builder(('C7',),count=1)
|
|
state=construction.State(recent=(note(-1,0,'g'),))
|
|
lazy=b.candidates(F(),state)
|
|
with patch.object(b.operators,'proposals',side_effect=lambda at:b.operators.at(at)):
|
|
eager=b.candidates(F(),state)
|
|
self.assertEqual(tuple(a.key for _,a in lazy),tuple(a.key for _,a in eager))
|
|
|
|
def test_incremental_evaluation_equals_complete_event_evaluation(self):
|
|
b=builder(('CM7','Dm7','G7','CM7'),count=8)
|
|
actions=[];notes=();previous=None;home=();old_home=();cursor=F()
|
|
for i in range(18):
|
|
gap=F(1,2) if i%4==2 else F()
|
|
length=(F(1,2),F(1),F(3,2))[i%3]
|
|
ns=() if i%7==6 else (note(cursor+gap,cursor+gap+length,('c','d','e','g')[i%4]),)
|
|
a=operators.Action(cursor,cursor+gap+length,ns,'arbitrary_label')
|
|
if i==5:home=notes
|
|
contracts=()
|
|
fast=b.selector.extend(previous,notes,a,home,old_home=old_home,contracts=contracts)
|
|
actions.append(a)
|
|
full=b.selector.complete(actions,home)
|
|
self.assertEqual(fast,full,(i,fast.raw,full.raw))
|
|
previous=fast;notes=(*notes,*ns);old_home=home;cursor=a.end
|
|
|
|
def test_cached_retrieval_retains_incoming_rhythm_and_pitch_context(self):
|
|
b=builder(('C7',),count=1)
|
|
incoming=(note(-3,-2,'c'),note(-2,0,'e'))
|
|
b.selector.weights={'space/after_arrival':-2,'motion/3/1':2}
|
|
values=b.operators.at(F())
|
|
selected=[a for a in values if a.kind in ('rest','scalar','arpeggio')][:80]
|
|
for a in selected:
|
|
self.assertEqual(b.selector.fast_cost(a,incoming),b.selector.cost(a,incoming)*(a.end-a.start),a.key)
|
|
|
|
def test_intrinsic_retrieval_matches_reports_for_every_action_family(self):
|
|
from collections import Counter
|
|
b=builder(('C7','FM7'),count=2)
|
|
incoming=(note(0,1,'c'),note(1,F(7,2),'e'))
|
|
b.selector.weights={'duration/1':4,'harmony/dominant/4/1_2':-3,'obligation/step/-1':-2,
|
|
'space/after_arrival':-1,'metric/eighth/1_2':-1,'source/rhythm_match':2,
|
|
'register/1':1,'continuation/up/up':-1,'motion/2/1_2':3}
|
|
checked=Counter()
|
|
for a in b.operators.proposals(F(7,2)):
|
|
if checked[a.kind]>=32:continue
|
|
checked[a.kind]+=1
|
|
self.assertEqual(b.selector.fast_cost(a,incoming),b.selector.cost(a,incoming)*(a.end-a.start),a.key)
|
|
self.assertGreaterEqual(len(checked),9)
|
|
b.selector.weights={'duration/1':-3}
|
|
a=operators.Action(F(7,2),F(9,2),(note(F(7,2),F(9,2),'e'),),'tone')
|
|
self.assertEqual(b.selector.fast_cost(a,incoming),b.selector.cost(a,incoming)*(a.end-a.start))
|
|
|
|
def test_cached_retrieval_treats_tied_fragments_as_one_sounding_event(self):
|
|
b=builder(('CM7',),count=1)
|
|
incoming=(note(-2,-1,'c'),note(-1,0,'d'))
|
|
whole=operators.Action(F(),F(3),(note(0,2,'e'),note(2,3,'g')),'tone')
|
|
tied=dataclasses.replace(whole,notes=(note(0,1,'e'),note(1,2,'e',continuation=True),whole.notes[-1]))
|
|
expected=b.selector.cost(whole,incoming)*3
|
|
self.assertEqual(b.selector.fast_cost(whole,incoming),expected)
|
|
self.assertEqual(b.selector.fast_cost(tied,incoming),expected)
|
|
|
|
def test_successor_cache_preserves_context_and_invalidates_changed_weights(self):
|
|
b=builder(('C7',),count=1)
|
|
state=construction.State(recent=(note(-3,-2,'c'),note(-2,-1,'e'),note(-1,0,'g')))
|
|
with patch.object(b.selector,'fast_cost',wraps=b.selector.fast_cost) as score:
|
|
first=b.candidates(F(),state);calls=score.call_count
|
|
self.assertGreater(calls,0)
|
|
self.assertEqual(first,b.candidates(F(),state));self.assertEqual(score.call_count,calls)
|
|
b.selector.weights={'duration/1':9}
|
|
changed=b.candidates(F(),state);self.assertGreater(score.call_count,calls)
|
|
b.successor_cache.clear()
|
|
self.assertEqual(changed,b.candidates(F(),state))
|
|
before=score.call_count
|
|
# Same pitches and final release; a longer incoming hold changes how
|
|
# leading space is classified, so it is a distinct retrieval context.
|
|
held=dataclasses.replace(state,recent=(note(-4,-3,'c'),note(-3,-2,'e'),note(-2,0,'g')))
|
|
b.candidates(F(),held);self.assertGreater(score.call_count,before)
|
|
|
|
def test_successor_cache_keeps_pending_destinations_distinct(self):
|
|
from generator.solo import types
|
|
b=builder(('C7',),count=1)
|
|
incoming=(note(-1,0,'d',alter=1),)
|
|
state=construction.State(recent=incoming)
|
|
target=next(a.notes[0] for a in b.operators.at(F()) if a.kind=='tone' and a.end==1 and a.notes[0].pitch.number()==64)
|
|
contract=types.ExpressionContract('pending','delayed_approach','bounded_semitone_resolution',incoming,target,'C7')
|
|
with patch.object(b.selector,'fast_cost',wraps=b.selector.fast_cost) as score:
|
|
b.candidates(F(),state);calls=score.call_count
|
|
pending=dataclasses.replace(state,pending=(contract,))
|
|
values=b.candidates(F(),pending)
|
|
self.assertTrue(values);self.assertGreater(score.call_count,calls)
|
|
self.assertTrue(all(b.pending_compatible(pending,a) for _,a in values))
|
|
b.successor_cache.clear()
|
|
self.assertEqual(values,b.candidates(F(),pending))
|
|
|
|
if __name__=='__main__':unittest.main()
|