def test_MajorThird_set_musicality(self):
fileloader.load(constants.TEST_MIDI + 'linear_motion.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
trans = transforms.MajorThirdScalarTransform(6 * config.resolution, sequence)
self.assertEqual(trans.intrinsic_musicality, vars.MAJOR_THIRD_SCALAR_CONTINUES_LINEARITY)
def test_MinorThirdScalarTransform_is_applicable(self):
fileloader.load(constants.TEST_MIDI + 'min3_scalar.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C-')
ks_detector.detect_and_set_key_signatures()
self.assertTrue(transforms.MinorThirdScalarTransform.applicable_at(0, sequence))
self.assertFalse(transforms.MinorThirdScalarTransform.applicable_at(2, sequence))
def test_WholeStepNeighborTransform_is_applicable(self):
fileloader.load(constants.TEST_MIDI + 'neighbor.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
self.assertTrue(transforms.WholeStepNeighborTransform.applicable_at(0, sequence))
self.assertTrue(
transforms.WholeStepNeighborTransform.applicable_at(2 * config.resolution, sequence))
def test__Beat_last_beat(self):
fileloader.load(constants.TEST_MIDI + 'mixed_meter.mid', False)
third_measure = 2
last_beat = 5
second_beat = 1
self.assertTrue(
time.measure(third_measure).beat(last_beat).last_beat())
self.assertFalse(
time.measure(third_measure).beat(second_beat).last_beat())
def test_WholeStepNeighborTransform_intermediate_pitch(self):
fileloader.load(constants.TEST_MIDI + 'neighbor.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
trans = transforms.WholeStepNeighborTransform(0, sequence)
whole_step_above = sequence[0].midi() + 2
self.assertEqual(trans.intermediate_pitch, whole_step_above)
def test_MajorThirdScalarTransform_intermediate_pitch(self):
fileloader.load(constants.TEST_MIDI + 'maj3_scalar.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
trans = transforms.MajorThirdScalarTransform(0, sequence)
pitch_should_be = sequence[0].midi() + 2
self.assertEqual(trans.intermediate_pitch, pitch_should_be)
def test_ArpeggialTransform_is_applicable(self):
fileloader.load(constants.TEST_MIDI + 'arpeggial.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
config.chord_progression[5 * config.resolution] = chords.parse('A-')
ks_detector.detect_and_set_key_signatures()
self.assertTrue(transforms.ArpeggialTransform.applicable_at(0, sequence))
self.assertTrue(
transforms.ArpeggialTransform.applicable_at(4 * config.resolution, sequence))
def test_ArpeggialTransform_intermediate_pitch(self):
fileloader.load(constants.TEST_MIDI + 'arpeggial.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
trans = transforms.ArpeggialTransform(0, sequence)
major_third_above = sequence[0].midi() + 4
self.assertEqual(trans.intermediate_pitch, major_third_above)
def test_ApproachTransform_intermediate_pitch(self):
fileloader.load(constants.TEST_MIDI + 'approach.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('A')
config.chord_progression[config.resolution] = chords.parse('D')
ks_detector.detect_and_set_key_signatures()
trans = transforms.ApproachTransform(0, sequence)
c_sharp_below = sequence[0].midi() - 8
self.assertEqual(trans.intermediate_pitch, c_sharp_below)
def test__JoinTransform_crosses_bar_line(self):
fileloader.load(constants.TEST_MIDI + '2beat_join.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
over_bar_line = transforms.JoinTransform(2, config.resolution * 3, sequence)
inside_bar = transforms.JoinTransform(2, config.resolution * 2, sequence)
self.assertTrue(over_bar_line.crosses_bar_line())
self.assertFalse(inside_bar.crosses_bar_line())
def test__get_all_transforms_minimal(self):
fileloader.load(constants.TEST_MIDI + 'maj3_scalar.mid', False)
chords.write('C')
alto = sequences.alto()
g4 = sequences.Note(alto, 0, 96, pitches.MIDI_VALUES['G4'])
b4 = sequences.Note(alto, 96, 192, pitches.MIDI_VALUES['B4'])
alto.add_entities(g4, b4)
self.assertEqual(124, len(transforms.get_all_transforms(0, 96, 4)))
def test__is_syncopation(self):
fileloader.load(constants.TEST_MIDI + '2beat_join.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
syncopation = transforms.JoinTransform(2, config.resolution, sequence)
nonsyncopated = transforms.JoinTransform(2, 0, sequence)
self.assertTrue(syncopation.is_syncopation())
self.assertFalse(nonsyncopated.is_syncopation())
def test_ArpeggialTransform_set_musicality(self):
fileloader.load(constants.TEST_MIDI + 'arpeggial.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
config.chord_progression[5 * config.resolution] = chords.parse('A-')
ks_detector.detect_and_set_key_signatures()
weaker_trans = transforms.ArpeggialTransform(0, sequence)
stronger_trans = transforms.ArpeggialTransform(config.resolution * 4, sequence)
self.assertEqual(weaker_trans.intrinsic_musicality, vars.ARPEGGIAL_SAME_CHORD)
self.assertEqual(stronger_trans.intrinsic_musicality, vars.ARPEGGIAL_NEW_CHORD)
def test__Sequence_note_duration_count(self):
fileloader.load(constants.TEST_MIDI + 'linear_motion.mid', False)
sequence = sequences.soprano()
number_of_sixteenths = 2
number_of_eighths = 5
duration_count = sequence.note_duration_count()
self.assertEqual(duration_count.get(constants.SIXTEENTH_NOTE, 0),
number_of_sixteenths)
self.assertEqual(duration_count.get(constants.EIGHTH_NOTE, 0),
number_of_eighths)
def test__Sequence_add_entities_splits(self):
fileloader.load(constants.TEST_MIDI + 'entities.mid', False)
sequence = sequences.soprano()
new_entity_start = 480
new_entity_end = 576
note = sequences.Rest(sequence, new_entity_start, new_entity_end)
sequence.add_entities(note)
self.assertEqual(new_entity_start,
sequence.entities().values()[3].end())
self.assertEqual(new_entity_end,
sequence.entities().values()[5].start())
def test_MajorThirdScalarTransform_Neighbor_synergy(self):
fileloader.load(constants.TEST_MIDI + 'neighbor.mid', False)
sequence = sequences.soprano
scalar_sequence = sequences.RootSequence(read_pattern(constants.TEST_MIDI + 'maj3_scalar.mid')[0])
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
scalar_trans = transforms.MajorThirdScalarTransform(0, scalar_sequence)
dom_neighbor_trans = transforms.HalfStepNeighborTransform(0, sequence)
subdom_neighbor_trans = transforms.HalfStepNeighborTransform(config.resolution * 4, sequence)
self.assertEqual(scalar_trans.synergy(dom_neighbor_trans), vars.EIGHTH_NOTE_DOMINANT)
self.assertEqual(scalar_trans.synergy(subdom_neighbor_trans), vars.EIGHTH_NOTE_SUBDOMINANT)
def test__Sequence_add_entities_consumes(self):
fileloader.load(constants.TEST_MIDI + 'entities.mid', False)
sequence = sequences.soprano()
new_entity_start = 144
new_entity_end = 528
note = sequences.Note(sequence, new_entity_start, new_entity_end,
pitches.Pitch(61))
sequence.add_entities(note)
self.assertEqual(new_entity_start,
sequence.entities().values()[1].end())
self.assertEqual(new_entity_end,
sequence.entities().values()[3].start())
def loadSession(self, sess, basefilename):
logging.debug('Loading session')
self.sourcesWidget.removeAllFiles()
if 'relative' in sess:
self.act_session_relative.setChecked(sess['relative'])
if 'files' in sess:
from os.path import normpath, join, dirname
for f in sess['files']:
if basefilename:
filename = normpath(
join(dirname(basefilename), f['filename']))
sheets = []
try:
book = fileloader.load(filename)
except:
log.warnException()
continue
for s in f['sheets']:
c = s['enabled']
i = s['index']
sheet = book.getSheet(i)
if 'xformula' in s:
sheet.xFormula.setStrValue(s['xformula'])
if 'yformula' in s:
sheet.yFormula.setStrValue(s['yformula'])
if 'xrange' in s: sheet.xRange.setStrValue(s['xrange'])
if 'errors' in s: sheet.errors = s['errors']
sheets.append((sheet, c))
logging.debug('Add file: %s' % filename)
self.sourcesWidget.show()
self.sourcesWidget.addFile(filename, f.get('enabled', True),
f.get('expanded', True), sheets)
if 'graph' in sess:
graph = sess['graph']
if 'range' in graph:
self.graphWidget.setRange(QRectF(*graph['range']))
if 'tools' in sess:
tools = sess['tools']
for tw in self.toolWidgets:
if tw.tool.name in tools:
try:
tw.restoreState(tools[tw.tool.name])
except:
log.warnException()
if 'cur_tool' in sess:
for tw in self.toolWidgets:
if tw.tool.name == sess['cur_tool']:
tw.raise_()
self.curTool = tw.tool
def test_MajorThirdScalarTransform_Scalar_synergy(self):
fileloader.load(constants.TEST_MIDI + 'maj3_scalar.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
scalar_trans = transforms.MajorThirdScalarTransform(0, sequence)
same_trans = transforms.MajorThirdScalarTransform(0, sequence)
join = transforms.JoinTransform(2, 0, sequence)
join3 = transforms.JoinTransform(3, 0, sequence)
self.assertEqual(scalar_trans.synergy(same_trans), vars.EIGHTH_NOTE_SAME)
self.assertEqual(scalar_trans.synergy(join), 0.0)
self.assertEqual(join.synergy(join), vars.JOIN_SAME)
self.assertEqual(join.synergy(join3), 0.0)
def test__flicker_avoidance_score(self):
fileloader.load(constants.TEST_MIDI + 'flicker.mid', False)
sequence = sequences.soprano()
c = pitches.MIDI_VALUES['C5']
e = pitches.MIDI_VALUES['E5']
beat2 = time.beat_at_index(2)
beat3 = time.beat_at_index(3)
self.assertEqual(
1 * vars.FLICKER_COEF,
note_picker.flicker_avoidance_score(c, beat2, sequence))
self.assertEqual(
2 * vars.FLICKER_COEF,
note_picker.flicker_avoidance_score(e, beat3, sequence))
def test_ApproachTransform_is_applicable(self):
fileloader.load(constants.TEST_MIDI + 'approach.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('A')
config.chord_progression[config.resolution] = chords.parse('D')
config.chord_progression[config.resolution * 4] = chords.parse('E')
config.chord_progression[config.resolution * 5] = chords.parse('F')
config.chord_progression[config.resolution * 6] = chords.parse('A')
ks_detector.detect_and_set_key_signatures()
self.assertTrue(transforms.ApproachTransform.applicable_at(0, sequence))
self.assertTrue(
transforms.ApproachTransform.applicable_at(4 * config.resolution, sequence))
self.assertFalse(
transforms.ApproachTransform.applicable_at(6 * config.resolution, sequence))
def test__motion_tendency_score(self):
fileloader.load(constants.TEST_MIDI + 'quarter_arpeg.mid', False)
zero_tendency = sequences.AccompanimentSequence(
config.song_length, parts.BASS, {'motion_tendency': 0.0})
no_tendency = sequences.AccompanimentSequence(config.song_length,
parts.BASS)
max_tendency = sequences.AccompanimentSequence(
config.song_length, parts.BASS, {'motion_tendency': 1.0})
beat_0_pitch = 59
beat_2_pitch = 62
beat_0_entity = sequences.Note(zero_tendency, 0, 96, beat_0_pitch)
beat_2_entity = sequences.Note(zero_tendency, 192, 288, beat_2_pitch)
zero_tendency.add_entities(beat_0_entity, beat_2_entity)
no_tendency.add_entities(beat_0_entity, beat_2_entity)
max_tendency.add_entities(beat_0_entity, beat_2_entity)
# start of midi clip, no motion, return 0
self.assertEqual(
0.0,
note_picker.motion_tendency_score(beat_0_pitch,
time.beat_at_index(0),
zero_tendency))
# same note as last beat
self.assertEqual(
0.25,
note_picker.motion_tendency_score(beat_0_pitch,
time.beat_at_index(1),
zero_tendency))
# client doesn't care either way
self.assertEqual(
0.0,
note_picker.motion_tendency_score(beat_0_pitch,
time.beat_at_index(1),
no_tendency))
# client much prefers motion
self.assertEqual(
0.25,
note_picker.motion_tendency_score(beat_2_pitch,
time.beat_at_index(1),
max_tendency))
def test__ChordProgression_chords_in_measure(self):
fileloader.load(constants.TEST_MIDI + 'mixed_meter.mid', False)
measure_0 = time.measure(0)
measure_1 = time.measure(1)
measure_3 = time.measure(3)
chords.write('C')
chords.write('A-', measure=0, beat=1)
chords.write('E-', measure=0, beat=2)
chords.write('G', measure=0, beat=3)
chords.write('G', measure=3, beat=0)
chords.write('C', measure=3, beat=3)
self.assertEqual(4, len(chords.in_measure(measure_0)))
self.assertEqual(0, len(chords.in_measure(measure_1)))
self.assertEqual(2, len(chords.in_measure(measure_3)))
def test_ApproachTransform_set_musicality(self):
fileloader.load(constants.TEST_MIDI + 'approach.mid', False)
sequence = sequences.soprano
config.chord_progression[0] = chords.parse('A')
config.chord_progression[config.resolution] = chords.parse('D')
config.chord_progression[config.resolution * 5] = chords.parse('F')
config.chord_progression[config.resolution * 6] = chords.parse('A')
ks_detector.detect_and_set_key_signatures()
ks = config.key_signatures
weaker_trans = transforms.ApproachTransform(11 * config.resolution, sequence)
stronger_trans = transforms.ApproachTransform(0, sequence)
strong_trans = transforms.ApproachTransform(4 * config.resolution, sequence)
self.assertEqual(vars.APPROACH_DEFAULT_MUSICALITY, weaker_trans.intrinsic_musicality)
self.assertEqual(vars.APPROACH_NEW_CHORD_ROOT, stronger_trans.intrinsic_musicality)
self.assertEqual(vars.APPROACH_KEY_CHANGE, strong_trans.intrinsic_musicality)
def test__root_tendency_score(self):
fileloader.load(constants.TEST_MIDI + 'quarter_arpeg.mid', False)
chords.write('G')
chords.write('E-', beat=2)
g = 55
e = 64
beat1 = time.beat_at_index(0)
beat2 = time.beat_at_index(1)
beat3 = time.beat_at_index(2)
self.assertEqual(vars.FIRST_BEAT_BASS_ROOT,
note_picker.bass_note_tendency_score(g, beat1))
self.assertEqual(vars.BASS_ROOT_SAME_CHORD,
note_picker.bass_note_tendency_score(g, beat2))
self.assertEqual(vars.BASS_NOTE_NEW_CHORD,
note_picker.bass_note_tendency_score(e, beat3))
def download(source, output):
# source e o link para o arquivo
# target e onde o arquivo vai ser gravado no disk(incluindo nome do arquivo e extensao)
ff = fileloader.load(source, target='@' + os.getcwd() + '/' + output)
# Se download
if ff.valid:
print '[*] Download {0}'.format(ff.source)
else:
print '[X] Failed to download {0}'.format(ff.source)
exit()
def test__get_all_transforms(self):
fileloader.load(constants.TEST_MIDI + 'maj3_scalar.mid', False)
chords.write('C')
alto = sequences.alto()
tenor = sequences.tenor()
bass = sequences.bass()
g4_alto = sequences.Note(alto, 0, 96, pitches.MIDI_VALUES['G4'])
b4_alto = sequences.Note(alto, 96, 192, pitches.MIDI_VALUES['B4'])
e4_tenor = sequences.Note(tenor, 0, 96, pitches.MIDI_VALUES['E4'])
g4_tenor = sequences.Note(tenor, 96, 192, pitches.MIDI_VALUES['G4'])
c4_bass = sequences.Note(bass, 0, 96, pitches.MIDI_VALUES['C4'])
e4_bass = sequences.Note(bass, 96, 192, pitches.MIDI_VALUES['E4'])
alto.add_entities(g4_alto, b4_alto)
tenor.add_entities(e4_tenor, g4_tenor)
bass.add_entities(c4_bass, e4_bass)
t = transforms.get_all_transforms(0, 96, 3)
e = 1
def test__EighthNoteTransform_causes_flickering(self):
fileloader.load(constants.TEST_MIDI + 'flicker.mid', False)
sequence = sequences.soprano
c = config
config.chord_progression[0] = chords.parse('C')
ks_detector.detect_and_set_key_signatures()
transform1 = transforms.WholeStepNeighborTransform((1 * config.resolution * 4) +
(1 * config.resolution), sequence)
transform2 = transforms.HalfStepNeighborTransform((2 * config.resolution * 4) +
(1 * config.resolution), sequence)
transform3 = transforms.HalfStepNeighborTransform((2 * config.resolution * 4) +
(1 * config.resolution), sequence)
self.assertTrue(transform1.causes_flickering())
self.assertTrue(transform2.causes_flickering())
self.assertTrue(transform3.causes_flickering())
def test__get_motion_score(self):
fileloader.load(constants.TEST_MIDI + 'parallel1.mid', False)
soprano = sequences.soprano()
tenor = sequences.RootSequence(
read_pattern(constants.TEST_MIDI + 'parallel2.mid')[0])
irrelevant_pitch = 11
# [0] = alto, [1] = tenor, [2] = bass
candidate = pitches.MIDI_VALUES['D5'], pitches.MIDI_VALUES[
'A5'], irrelevant_pitch,
self.assertEqual(
0.0,
note_picker.parallel_motion_score(candidate, time.beat_at_index(0),
soprano, sequences.alto(), tenor,
sequences.bass()))
self.assertEqual(
vars.PARALLEL_MOVEMENT,
note_picker.parallel_motion_score(candidate, time.beat_at_index(1),
soprano, sequences.alto(), tenor,
sequences.bass()))
def importFiles(self, filenames):
for filename in filenames:
try:
f = fileloader.load(filename)
except fileloader.UnsupportedFileException as ex:
logging.error('Unsupported file: %s %s' %
(ex.mimetype, ex.filename))
continue
self.addFile(filename, True, True, [(s, True) for s in f])
if self.curTool == self.toolIAD:
self.toolIAD.mode = 'orig'
self.update()
self.sourcesDockWidget.raise_()
