def setUp(self):
        # LilyPond output files are created in current working directory
        self.tempdir = tempfile.mkdtemp()
        self.oldcwd = os.getcwd()
        os.chdir(self.tempdir)

        self.commonbar = Bar()
        self.ebar = Bar("E", (4, 4))
        self.fbar = Bar("F", (6, 8))
        self.tbar = Bar("C", (4, 4))
        self.mbar = Bar("C", (4, 4))
        self.a_minor_bar = Bar("a", (4, 4))
        self.b_flat_minor_bar = Bar("bb", (4, 4))
        self.f_sharp_minor_bar = Bar("f#", (4, 4))
        for y in [self.commonbar, self.ebar, self.fbar]:
            list(map(lambda x: y + x, ["C", "E", "G", "B"]))
        for x in ["C", "E", "G", "B", "C", "E"]:
            self.tbar.place_notes(NoteContainer(x), 6)
        for x in ["C", "E"]:
            self.mbar.place_notes(NoteContainer(x), 4)
        for x in ["G", "B", "C"]:
            self.mbar.place_notes(NoteContainer(x), 6)
        self.track1 = Track()
        self.track1 + self.commonbar
        self.track2 = Track()
        self.track2 + self.commonbar
        self.track2 + self.ebar
        self.composition1 = Composition()
        self.composition1.add_track(self.track1)
        self.composition2 = Composition()
        self.composition2.add_track(self.track1)
        self.composition2.add_track(self.track2)
Exemple #2
0
 def test_diminish(self):
     b = Bar()
     c = Bar()
     b + 'A'
     c + 'Ab'
     b.diminish()
     self.assertEqual(b, c)
Exemple #3
0
 def setUp(self):
     self.commonbar = Bar()
     self.ebar = Bar('E', (4, 4))
     self.fbar = Bar('F', (6, 8))
     self.tbar = Bar('C', (4, 4))
     self.mbar = Bar('C', (4, 4))
     self.a_minor_bar = Bar('a', (4, 4))
     self.b_flat_minor_bar = Bar('bb', (4, 4))
     self.f_sharp_minor_bar = Bar('f#', (4, 4))
     for y in [self.commonbar, self.ebar, self.fbar]:
         map(lambda x: y + x, ['C', 'E', 'G', 'B'])
     map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
         'C',
         'E',
         'G',
         'B',
         'C',
         'E',
         ])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
         ])
     self.track1 = Track()
     self.track1 + self.commonbar
     self.track2 = Track()
     self.track2 + self.commonbar
     self.track2 + self.ebar
     self.composition1 = Composition()
     self.composition1.add_track(self.track1)
     self.composition2 = Composition()
     self.composition2.add_track(self.track1)
     self.composition2.add_track(self.track2)
Exemple #4
0
    def add_notes(self, note, duration=None):
        """Add a Note, note as string or NoteContainer to the last Bar.

        If the Bar is full, a new one will automatically be created.

        If the Bar is not full but the note can't fit in, this method will
        return False. True otherwise.

        An InstrumentRangeError exception will be raised if an Instrument is
        attached to the Track, but the note turns out not to be within the
        range of the Instrument.
        """
        if self.instrument != None:
            if not self.instrument.can_play_notes(note):
                raise InstrumentRangeError(
                    "Note '%s' is not in range of the instrument (%s)" % (note, self.instrument))
        if duration == None:
            duration = 4

        # Check whether the last bar is full, if so create a new bar and add the
        # note there
        if len(self.bars) == 0:
            self.bars.append(Bar())
        last_bar = self.bars[-1]
        if last_bar.is_full():
            self.bars.append(Bar(last_bar.key, last_bar.meter))
            # warning should hold note if it doesn't fit

        return self.bars[-1].place_notes(note, duration)
Exemple #5
0
 def setUp(self):
     self.commonbar = Bar()
     self.ebar = Bar('E', (4, 4))
     self.fbar = Bar('F', (6, 8))
     self.tbar = Bar('C', (4, 4))
     self.mbar = Bar('C', (4, 4))
     for y in [self.commonbar, self.ebar, self.fbar]:
         map(lambda x: y + x, ['C', 'E', 'G', 'B'])
     map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
         'C',
         'E',
         'G',
         'B',
         'C',
         'E',
         ])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
         ])
     self.track1 = Track()
     self.track1 + self.commonbar
     self.track2 = Track()
     self.track2 + self.commonbar
     self.track2 + self.ebar
     self.composition1 = Composition()
     self.composition1.add_track(self.track1)
     self.composition2 = Composition()
     self.composition2.add_track(self.track1)
     self.composition2.add_track(self.track2)
Exemple #6
0
 def test_diminish(self):
     b = Bar()
     c = Bar()
     b + "A"
     c + "Ab"
     b.diminish()
     self.assertEqual(b, c)
Exemple #7
0
 def test_transpose(self):
     b = Bar()
     c = Bar()
     b + ['C', 'E', 'G']
     c + ['E', 'G#', 'B']
     b + ['F', 'A', 'C']
     c + ['A', 'C#', 'E']
     b.transpose('3', True)
     self.assertEqual(b, c)
     b.transpose('3', False)
     b.transpose('3')
     self.assertEqual(b, c)
    def __init__(self):

        self._notes = []
        self._bar = None
        self._durs = []
        self._index = 0
        self._key = ""
        self._bpm = 120
        self._dynamics = {}

        self.paused = False

        self._bar = Bar()

        fs.init("sound.sf2", "oss")
        mixer.init()
Exemple #9
0
 def test_set_item(self):
     b = Bar()
     b + ['A', 'C', 'E']
     c = Bar()
     c + ['A', 'C', 'E']
     self.assertEqual(b, c)
     c[0] = NoteContainer(['A', 'C', 'E'])
     self.assertEqual(b, c)
     c[0] = ['A', 'C', 'E']
     self.assertEqual(b, c)
     c[0] = Note('A')
     c[0] = c[0][2] + NoteContainer(['C', 'E'])
     self.assertEqual(b, c)
     c[0] = Note('A')
     c[0] = c[0][2] + 'C'
     c[0] = c[0][2] + 'E'
     self.assertEqual(b, c)
Exemple #10
0
 def test_set_item(self):
     b = Bar()
     b + ["A", "C", "E"]
     c = Bar()
     c + ["A", "C", "E"]
     self.assertEqual(b, c)
     c[0] = NoteContainer(["A", "C", "E"])
     self.assertEqual(b, c)
     c[0] = ["A", "C", "E"]
     self.assertEqual(b, c)
     c[0] = Note("A")
     c[0] = c[0][2] + NoteContainer(["C", "E"])
     self.assertEqual(b, c)
     c[0] = Note("A")
     c[0] = c[0][2] + "C"
     c[0] = c[0][2] + "E"
     self.assertEqual(b, c)
    def loadSong(self, fn, isTwoHand):
        """Loads in a song from the specified file"""
        header = dict()
        length = 0.0

        self._notes = []
        self._bar = None
        self._durs = []

        with open(fn) as file:
            i = 0
            for line in file:
                if line[0] == "#" or line[0].strip(
                ) == "":  # Skips blank lines and comment lines
                    continue
                if i < 3:  # The first three lines are loaded into the header dictionary
                    vals = line.split('=')
                    header[vals[0]] = vals[1].strip()
                    i += 1
                else:
                    vals = line.split(',')
                    if line[0] == 'r':  # Indicates a rest value
                        self._notes.append(None)
                        dur = vals[1].strip()
                    else:
                        if isTwoHand:  # If isTwoHand is true, then a two note chord is looked for
                            self._notes.append(
                                [vals[0].strip(), vals[1].strip()])
                            dur = vals[2].strip()
                        else:
                            self._notes.append(vals[0].strip())
                            dur = vals[1].strip()
                    if dur[len(dur) - 1] == '.':  # Looks for dotted notes
                        dur = value.dots(int(dur[:-1]))
                    else:
                        dur = int(dur)
                    self._durs.append(dur)
                    length += 1.0 / dur

        self._key = header["key"]
        self._bpm = int(header["bpm"])
        self._beat = int(header["beat"])
        length *= self._bpm
        self._bar = Bar()
        self._bar.set_meter((length, int(header["beat"])))
    def playNextNoteLong(self):
        """Plays the next note in the song and advances the index"""
        tempBar = Bar()
        tempBar.set_meter((1, 1))
        tempBar.key = self._key
        tempBar.place_notes(self._notes[self._index], 1)

        fs.play_Bar(tempBar, 120)
Exemple #13
0
def setup_composition(nbars=64, ntracks=2, quant=16):
	comp = Composition()
	tks =[Track() for i in xrange(ntracks)]
	for i in xrange(ntracks):
		bars = [Bar() for j in xrange(nbars)]
		for j in xrange(nbars):
			init_bar(bars[j], quant)
			tks[i] + bars[j]	
		comp + tks[i]
	return comp
Exemple #14
0
 def test_augment(self):
     b = Bar()
     c = Bar()
     d = Bar()
     b + 'A'
     c + 'A#'
     d + 'A##'
     b.augment()
     self.assertEqual(b, c)
     b.augment()
     self.assertEqual(b, d)
     c.augment()
     self.assertEqual(c, d)
    def playManyNotes(self, notes):
        """Plays the next note in the song and advances the index"""
        tempBar = Bar()
        tempBar.set_meter((len(notes) * 4, 4))
        for n in notes:
            tempBar.place_notes(n, 1)

        fs.play_Bar(tempBar, 1, 200)
    def playNextNote(self):
        """Plays the next note in the song and advances the index"""
        tempBar = Bar()
        beats = 1.0 / (1.0 / self._beat) / (1.0 / self._durs[self._index])
        tempBar.set_meter((beats, self._beat))
        tempBar.key = self._key
        tempBar.place_notes(self._notes[self._index], self._durs[self._index])

        print tempBar

        fs.play_Bar(tempBar, self._bpm)

        return self._index
 def setUp(self):
     self.commonbar = Bar()
     self.ebar = Bar("E", (4, 4))
     self.fbar = Bar("F", (6, 8))
     self.tbar = Bar("C", (4, 4))
     self.mbar = Bar("C", (4, 4))
     self.a_minor_bar = Bar("a", (4, 4))
     self.b_flat_minor_bar = Bar("bb", (4, 4))
     self.f_sharp_minor_bar = Bar("f#", (4, 4))
     for y in [self.commonbar, self.ebar, self.fbar]:
         map(lambda x: y + x, ["C", "E", "G", "B"])
     map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), ["C", "E", "G", "B", "C", "E"])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ["C", "E"])
     map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ["G", "B", "C"])
     self.track1 = Track()
     self.track1 + self.commonbar
     self.track2 = Track()
     self.track2 + self.commonbar
     self.track2 + self.ebar
     self.composition1 = Composition()
     self.composition1.add_track(self.track1)
     self.composition2 = Composition()
     self.composition2.add_track(self.track1)
     self.composition2.add_track(self.track2)
Exemple #18
0
	def gen(self, midifilename):
		dummy = Note('C-0')
		dummy.velocity = 0
		dummy.channel = 9
		dummy.duration = self.dur
		for nb in xrange( self.n_bars ):
			b = Bar('C', (4,4))
			# note "dummy" posizionate su una "griglia di quantizzazione"	
			for i in xrange(self.nsteps):
				b.place_notes(dummy, self.dur)
			# print repr(b) # debug
			# note "vere"	
			for x in self.STRMAP.keys():
				ys = self.STRMAP[x]
				y = self.DRMAP[x]
				if len(ys) > 0:
					if len(self.VARMAP[x]) > 0:
						var = self.VARMAP[x][nb]
					else:
						var = 0
					if self.vartype == self._OR_VAR_: # or = variazione aggiunge !? xor = toggle
						tmps = or_str( ys, gen_bin_str(self.nsteps, var) ) 
					elif self.vartype == self._XOR_VAR_:
						tmps = xor_str( ys, gen_bin_str(self.nsteps, var) )
					else:
						tmps = ys # no var.
					bin_to_bar(b, y, tmps, self.dur)
			# cleanup - tolgo le note "dummy"
			for x in b.bar :
				x[2].remove_note('C', 0)
			# print repr(b) # debug
			self.tk + b
		# "dummy bar"
		db = Bar('C', (4,4))
		db.place_notes(dummy,1)
		self.tk + db
		comp = Composition()
		comp + self.tk
		write_Composition(midifilename, comp, self.tempo)
def rebuild_composition(old, xylo, cutoff):
    lowest = Note.__int__(Note('C', 8))
    highest = Note.__int__(Note('C', 0))
    new = Composition()
    for i in old.selected_tracks:
        t = Track()
        t.instrument = xylo
        for bar in old[i]:
            b = Bar()
            b.key.name = bar.key.name
            b.set_meter(bar.meter)
            # note value per beat == the denominator in time signature
            dem = b.meter[1]
            for lst in bar:
                value = lst[1]
                if (is_garbage(value, dem, cutoff[old.selected_tracks.index(i)])):
                    continue
                # do not include lists without notes
                if (not lst[2]):
                    continue
                nc = NoteContainer()
                for note in lst[2]:
                    if (Note.__int__(note) < lowest): lowest = Note.__int__(note)
                    if (Note.__int__(note) > highest): highest = Note.__int__(note)
                    nc + note
                b.place_notes(nc, value)
            t.add_bar(b)
        new.add_track(t)
    # can't do the transposing until all notes in all tracks have been
    # compared against lowest and highest, which is why it is done here
    n1 = Note()
    n2 = Note()
    low = n1.from_int(lowest)
    high = n2.from_int(highest)
    # print("lowest and highest notes:", low, high)
    if (not xylo.notes_in_range([low, high])):
        new = transposer(new, lowest, highest, xylo)
    return new
Exemple #20
0
class test_Bar(unittest.TestCase):
    def setUp(self):
        self.b = Bar("C", (4, 4))
        self.c = Bar("E", (2, 2))
        self.meterless = Bar("C", (0, 0))

    def test_equality(self):
        self.assertEqual(self.b, self.c)
        self.assertEqual(self.b, self.meterless)
        self.assertEqual(self.c, self.meterless)

        b1 = Bar("C", (4, 4))
        b1 + ["A", "C"]
        b1 + ["D"]
        b2 = Bar("C", (4, 4))
        b2 + ["A", "C"]
        b2 + ["D"]
        self.assertEqual(b1, b2)

        self.assertNotEqual(b1, self.b)

    def test_place_notes_types(self):
        self.assertEqual(True, self.meterless + NoteContainer(["A", "C"]))
        self.assertEqual(True, self.meterless + "A")
        self.assertEqual(True, self.meterless + Note("A"))
        self.assertEqual(True, self.meterless + ["A", "B"])
        self.assertEqual(True, self.meterless + [Note("A"), Note("B")])

    def test_get_range(self):
        self.b + NoteContainer(["C", "E"])
        self.assertEqual((Note("C"), Note("E")), self.b.get_range())

    def test_set_item(self):
        b = Bar()
        b + ["A", "C", "E"]  # A4 C5 E5
        c = Bar()
        c + ["A", "C", "E"]
        self.assertEqual(b, c)
        c[0] = NoteContainer(["A", "C", "E"])
        self.assertEqual(b, c)
        c[0] = ["A", "C", "E"]
        self.assertEqual(b, c)
        c[0] = Note("A")
        c[0] = c[0][2] + NoteContainer(["C", "E"])  # C4 E4
        self.assertNotEqual(b, c)
        c[0] = Note("A")
        c[0] = c[0][2] + NoteContainer(["C-5", "E"])  # C5 E5
        self.assertEqual(b, c)
        c[0] = Note("A")
        c[0] = c[0][2] + "C"
        c[0] = c[0][2] + "E"
        self.assertEqual(b, c)

    def test_key(self):
        self.assertEqual(self.b.key, Key("C"))
        self.assertEqual(self.c.key, Key("E"))

    def test_transpose(self):
        b = Bar()
        c = Bar()
        b + ["C", "E", "G"]
        c + ["E", "G#", "B"]
        b + ["F", "A", "C"]
        c + ["A", "C#", "E"]
        b.transpose("3", True)
        self.assertEqual(b, c)
        b.transpose("3", False)
        b.transpose("3")
        self.assertEqual(b, c)

    def test_transpose_rest(self):
        b = Bar()
        b.place_notes("C-4", 4)
        b.place_rest(4)
        c = Bar()
        c.place_notes("E-4", 4)
        c.place_rest(4)
        b.transpose("3", True)
        self.assertEqual(b, c)

    def test_augment(self):
        b = Bar()
        c = Bar()
        d = Bar()
        b + "A"
        c + "A#"
        d + "A##"
        b.augment()
        self.assertEqual(b, c)
        b.augment()
        self.assertEqual(b, d)
        c.augment()
        self.assertEqual(c, d)

    def test_augment_rest(self):
        b = Bar()
        b.place_notes("C-4", 4)
        b.place_rest(4)
        c = Bar()
        c.place_notes("C#-4", 4)
        c.place_rest(4)
        b.augment()
        self.assertEqual(b, c)

    def test_diminish(self):
        b = Bar()
        c = Bar()
        b + "A"
        c + "Ab"
        b.diminish()
        self.assertEqual(b, c)

    def test_diminish_rest(self):
        b = Bar()
        b.place_notes("C#-4", 4)
        b.place_rest(4)
        c = Bar()
        c.place_notes("C-4", 4)
        c.place_rest(4)
        b.diminish()
        self.assertEqual(b, c)

    #    def test_to_minor(self):
    #        b = Bar()
    #        c = Bar()
    #        b + 'C'
    #        c + 'A'
    #        b.to_minor()
    #        self.assertEqual(b, c)
    #
    #    def test_to_major(self):
    #        b = Bar()
    #        c = Bar()
    #        b + 'C'
    #        c + 'A'
    #        c.to_major()
    #        self.assertEqual(b, c)

    def test_get_note_names(self):
        b = Bar()
        b + "C"
        b + "A"
        self.assertEqual(["C", "A"], b.get_note_names())

    def test_determine_chords(self):
        b = Bar()
        b + ["C", "E", "G"]
        b + ["F", "A", "C"]
        self.assertEqual([[0.0, ["C major triad"]], [0.25, ["F major triad"]]],
                         b.determine_chords())

    def test_determine_progression(self):
        b = Bar()
        b + ["C", "E", "G"]
        b + ["F", "A", "C"]
        self.assertEqual([[0.0, ["I"]], [0.25, ["IV"]]],
                         b.determine_progression(True))
Exemple #21
0
 def test_augment_rest(self):
     b = Bar()
     b.place_notes("C-4", 4)
     b.place_rest(4)
     c = Bar()
     c.place_notes("C#-4", 4)
     c.place_rest(4)
     b.augment()
     self.assertEqual(b, c)
Exemple #22
0
 def test_get_note_names(self):
     b = Bar()
     b + 'C'
     b + 'A'
     self.assertEqual(['C', 'A'], b.get_note_names())
Exemple #23
0
 def test_determine_chords(self):
     b = Bar()
     b + ['C', 'E', 'G']
     b + ['F', 'A', 'C']
     self.assertEqual([[0.0, ['C major triad']], [0.25, ['F major triad']]],
                      b.determine_chords())
Exemple #24
0
class test_LilyPond(unittest.TestCase):

    def setUp(self):
        self.commonbar = Bar()
        self.ebar = Bar('E', (4, 4))
        self.fbar = Bar('F', (6, 8))
        self.tbar = Bar('C', (4, 4))
        self.mbar = Bar('C', (4, 4))
        self.a_minor_bar = Bar('a', (4, 4))
        self.b_flat_minor_bar = Bar('bb', (4, 4))
        self.f_sharp_minor_bar = Bar('f#', (4, 4))
        for y in [self.commonbar, self.ebar, self.fbar]:
            map(lambda x: y + x, ['C', 'E', 'G', 'B'])
        map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
            'C',
            'E',
            'G',
            'B',
            'C',
            'E',
            ])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
            ])
        self.track1 = Track()
        self.track1 + self.commonbar
        self.track2 = Track()
        self.track2 + self.commonbar
        self.track2 + self.ebar
        self.composition1 = Composition()
        self.composition1.add_track(self.track1)
        self.composition2 = Composition()
        self.composition2.add_track(self.track1)
        self.composition2.add_track(self.track2)

    def test_from_Note(self):
        self.assertEqual(LilyPond.from_Note(Note('C'), standalone=False), "c'")
        self.assertEqual(LilyPond.from_Note(Note('C#'), standalone=False),
                         "cis'")
        self.assertEqual(LilyPond.from_Note(Note('C##'), standalone=False),
                         "cisis'")
        self.assertEqual(LilyPond.from_Note(Note('Cb'), standalone=False),
                         "ces'")
        self.assertEqual(LilyPond.from_Note(Note('Cbb'), standalone=False),
                         "ceses'")
        self.assertEqual(LilyPond.from_Note(Note('C', 0), standalone=False),
                         'c,,,')
        self.assertEqual(LilyPond.from_Note(Note('C', 1), standalone=False),
                         'c,,')
        self.assertEqual(LilyPond.from_Note(Note('C', 2), standalone=False),
                         'c,')
        self.assertEqual(LilyPond.from_Note(Note('C', 3), standalone=False), 'c'
                         )
        self.assertEqual(LilyPond.from_Note(Note('C', 4), standalone=False),
                         "c'")
        self.assertEqual(LilyPond.from_Note(Note('C', 5), standalone=False),
                         "c''")
        self.assertEqual(LilyPond.from_Note(Note('C', 6), standalone=False),
                         "c'''")
        self.assertEqual(LilyPond.from_Note(Note('C', 7), standalone=False),
                         "c''''")

    def test_from_NoteContainer(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         standalone=False), "c'")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 4,
                         standalone=False), "c'4")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
                         standalone=False), "<c' e'>")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
                         4, standalone=False), "<c' e'>4")

        # issue #37

        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16,
                         standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16.0,
                         standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(16), standalone=False), "c'16.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.25,
                         standalone=False), "c'\\longa")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.5,
                         standalone=False), "c'\\breve")

    def test_from_Bar(self):
        self.assertEqual(LilyPond.from_Bar(self.commonbar),
                         "{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.ebar),
                         "{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.fbar),
                         "{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")
        self.assertEqual(LilyPond.from_Bar(self.a_minor_bar),
                         "{ \\time 4/4 \\key a \\minor }")
        self.assertEqual(LilyPond.from_Bar(self.b_flat_minor_bar),
                         "{ \\time 4/4 \\key bes \\minor }")
        self.assertEqual(LilyPond.from_Bar(self.f_sharp_minor_bar),
                         "{ \\time 4/4 \\key fis \\minor }")

    def test_from_Track(self):
        self.assertEqual(LilyPond.from_Track(self.track1),
                         "{ { c'4 e'4 g'4 b'4 } }")
        self.assertEqual(LilyPond.from_Track(self.track2),
                         "{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }"
                         )

    def test_from_Composition(self):
        self.assertEqual(LilyPond.from_Composition(self.composition1),
                         '\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }'
                         )
        self.assertEqual(LilyPond.from_Composition(self.composition2),
                         '\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } } { { c\'4 e\'4 g\'4 b\'4 } { \\key e \\major c\'4 e\'4 g\'4 b\'4 } }'
                         )

    def test_from_Suite(self):
        LilyPond.from_Suite(None)

    def test_dotted_notes(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(8), standalone=False), "c'8.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(4, 2), standalone=False), "c'4..")

    def test_to_pdf(self):
        self.assert_(LilyPond.to_pdf('{ %s }'
                      % LilyPond.from_NoteContainer(NoteContainer('C'),
                     value.dots(8)), 'pdftest first test'))
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), 'pdftest2'))
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), 'pdftest3'))

    def test_to_png(self):
        self.assert_(LilyPond.to_png('{ %s }'
                      % LilyPond.from_NoteContainer(NoteContainer('C'),
                     value.dots(8)), 'pn1'))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.tbar), 'pn2'))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.mbar), 'pn3'))
Exemple #25
0
 def test_determine_progression(self):
     b = Bar()
     b + ['C', 'E', 'G']
     b + ['F', 'A', 'C']
     self.assertEqual([[0.0, ['I']], [0.25, ['IV']]],
                      b.determine_progression(True))
Exemple #26
0
class test_Bar(unittest.TestCase):

    def setUp(self):
        self.b = Bar('C', (4, 4))
        self.c = Bar('E', (2, 2))
        self.meterless = Bar('C', (0, 0))

    def test_place_notes_types(self):
        self.assertEqual(True, self.meterless + NoteContainer(['A', 'C']))
        self.assertEqual(True, self.meterless + 'A')
        self.assertEqual(True, self.meterless + Note('A'))
        self.assertEqual(True, self.meterless + ['A', 'B'])
        self.assertEqual(True, self.meterless + [Note('A'), Note('B')])

    def test_get_range(self):
        self.b + NoteContainer(['C', 'E'])
        self.assertEqual((Note('C'), Note('E')), self.b.get_range())

    def test_set_item(self):
        b = Bar()
        b + ['A', 'C', 'E']
        c = Bar()
        c + ['A', 'C', 'E']
        self.assertEqual(b, c)
        c[0] = NoteContainer(['A', 'C', 'E'])
        self.assertEqual(b, c)
        c[0] = ['A', 'C', 'E']
        self.assertEqual(b, c)
        c[0] = Note('A')
        c[0] = c[0][2] + NoteContainer(['C', 'E'])
        self.assertEqual(b, c)
        c[0] = Note('A')
        c[0] = c[0][2] + 'C'
        c[0] = c[0][2] + 'E'
        self.assertEqual(b, c)

    def test_key(self):
        self.assertEqual(self.b.key, Key('C'))
        self.assertEqual(self.c.key, Key('E'))

    def test_transpose(self):
        b = Bar()
        c = Bar()
        b + ['C', 'E', 'G']
        c + ['E', 'G#', 'B']
        b + ['F', 'A', 'C']
        c + ['A', 'C#', 'E']
        b.transpose('3', True)
        self.assertEqual(b, c)
        b.transpose('3', False)
        b.transpose('3')
        self.assertEqual(b, c)

    def test_augment(self):
        b = Bar()
        c = Bar()
        d = Bar()
        b + 'A'
        c + 'A#'
        d + 'A##'
        b.augment()
        self.assertEqual(b, c)
        b.augment()
        self.assertEqual(b, d)
        c.augment()
        self.assertEqual(c, d)

    def test_diminish(self):
        b = Bar()
        c = Bar()
        b + 'A'
        c + 'Ab'
        b.diminish()
        self.assertEqual(b, c)

#    def test_to_minor(self):
#        b = Bar()
#        c = Bar()
#        b + 'C'
#        c + 'A'
#        b.to_minor()
#        self.assertEqual(b, c)
#
#    def test_to_major(self):
#        b = Bar()
#        c = Bar()
#        b + 'C'
#        c + 'A'
#        c.to_major()
#        self.assertEqual(b, c)

    def test_get_note_names(self):
        b = Bar()
        b + 'C'
        b + 'A'
        self.assertEqual(['C', 'A'], b.get_note_names())

    def test_determine_chords(self):
        b = Bar()
        b + ['C', 'E', 'G']
        b + ['F', 'A', 'C']
        self.assertEqual([[0.0, ['C major triad']], [0.25, ['F major triad']]],
                         b.determine_chords())

    def test_determine_progression(self):
        b = Bar()
        b + ['C', 'E', 'G']
        b + ['F', 'A', 'C']
        self.assertEqual([[0.0, ['I']], [0.25, ['IV']]],
                         b.determine_progression(True))
Exemple #27
0
 def setUp(self):
     self.b = Bar('C', (4, 4))
     self.c = Bar('E', (2, 2))
     self.meterless = Bar('C', (0, 0))
        for chord in args.chords:
            chord_notes = chords.from_shorthand(chord)
            new_note = reduce_accidentals(tritone(chord_notes[0]))
            new_chord = new_note + '7'

            ii_chord_type_short, chord = reharmonize_v_to_ii_v(new_chord)
            print("{} {}".format(ii_chord_type_short, new_chord))

    elif args.action == 'chord_modes':
        chords = [chords.determine_seventh(mode_func(args.key), shorthand=True)[0]
                  for mode_func in MODE_CHORD_FUNCTIONS]
        print(', '.join(chords))

    elif args.action == '12_bar_blues':
        for four_bars in twelve_bar_blues(args.key):
            print('\t'.join(four_bars))

    elif args.action == 'blues_scale':
        print("{} blues scale: {}".format(args.key, ', '.join(blues_scale(args.key))))

    elif args.action == '12_bar_blues_printout':
        from mingus.containers.note import QuarterNoteFactory as Q
        from mingus.core.chords import WholNoteChordFactory as WNC
        blues_scale = Blues(args.key)
        bar = Bar()
        bar.extend(Q(list(blues_scale.generate(4*12, undulating=True, starting_octave=4))))
        bar.set_chord_notes([WNC(chord) for chord in twelve_bar_blues_chord_progression(args.key)])
        result = from_Bar(bar)
        print(result)
        to_png(result, args.filename)
Exemple #29
0
class test_LilyPond(unittest.TestCase):

    def setUp(self):
        self.commonbar = Bar()
        self.ebar = Bar('E', (4, 4))
        self.fbar = Bar('F', (6, 8))
        self.tbar = Bar('C', (4, 4))
        self.mbar = Bar('C', (4, 4))
        for y in [self.commonbar, self.ebar, self.fbar]:
            map(lambda x: y + x, ['C', 'E', 'G', 'B'])
        map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
            'C',
            'E',
            'G',
            'B',
            'C',
            'E',
            ])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
            ])
        self.track1 = Track()
        self.track1 + self.commonbar
        self.track2 = Track()
        self.track2 + self.commonbar
        self.track2 + self.ebar
        self.composition1 = Composition()
        self.composition1.add_track(self.track1)
        self.composition2 = Composition()
        self.composition2.add_track(self.track1)
        self.composition2.add_track(self.track2)

    def test_from_Note(self):
        self.assertEqual(LilyPond.from_Note(Note('C'), standalone=False), "c'")
        self.assertEqual(LilyPond.from_Note(Note('C#'), standalone=False),
                         "cis'")
        self.assertEqual(LilyPond.from_Note(Note('C##'), standalone=False),
                         "cisis'")
        self.assertEqual(LilyPond.from_Note(Note('Cb'), standalone=False),
                         "ces'")
        self.assertEqual(LilyPond.from_Note(Note('Cbb'), standalone=False),
                         "ceses'")
        self.assertEqual(LilyPond.from_Note(Note('C', 0), standalone=False),
                         'c,,,')
        self.assertEqual(LilyPond.from_Note(Note('C', 1), standalone=False),
                         'c,,')
        self.assertEqual(LilyPond.from_Note(Note('C', 2), standalone=False),
                         'c,')
        self.assertEqual(LilyPond.from_Note(Note('C', 3), standalone=False), 'c'
                         )
        self.assertEqual(LilyPond.from_Note(Note('C', 4), standalone=False),
                         "c'")
        self.assertEqual(LilyPond.from_Note(Note('C', 5), standalone=False),
                         "c''")
        self.assertEqual(LilyPond.from_Note(Note('C', 6), standalone=False),
                         "c'''")
        self.assertEqual(LilyPond.from_Note(Note('C', 7), standalone=False),
                         "c''''")

    def test_from_NoteContainer(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         standalone=False), "c'")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 4,
                         standalone=False), "c'4")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
                         standalone=False), "<c' e'>")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
                         4, standalone=False), "<c' e'>4")

        # issue #37

        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16,
                         standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16.0,
                         standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(16), standalone=False), "c'16.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.25,
                         standalone=False), "c'\\longa")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.5,
                         standalone=False), "c'\\breve")

    def test_from_Bar(self):
        self.assertEqual(LilyPond.from_Bar(self.commonbar),
                         "{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.ebar),
                         "{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.fbar),
                         "{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")

    def test_from_Track(self):
        self.assertEqual(LilyPond.from_Track(self.track1),
                         "{ { c'4 e'4 g'4 b'4 } }")
        self.assertEqual(LilyPond.from_Track(self.track2),
                         "{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }"
                         )

    def test_from_Composition(self):
        self.assertEqual(LilyPond.from_Composition(self.composition1),
                         '\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }'
                         )
        self.assertEqual(LilyPond.from_Composition(self.composition2),
                         '\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } } { { c\'4 e\'4 g\'4 b\'4 } { \\key e \\major c\'4 e\'4 g\'4 b\'4 } }'
                         )

    def test_from_Suite(self):
        LilyPond.from_Suite(None)

    def test_dotted_notes(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(8), standalone=False), "c'8.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
                         value.dots(4, 2), standalone=False), "c'4..")

    def test_to_pdf(self):
        self.assert_(LilyPond.to_pdf('{ %s }'
                      % LilyPond.from_NoteContainer(NoteContainer('C'),
                     value.dots(8)), 'pdftest first test'))
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), 'pdftest2'))
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), 'pdftest3'))

    def test_to_png(self):
        self.assert_(LilyPond.to_png('{ %s }'
                      % LilyPond.from_NoteContainer(NoteContainer('C'),
                     value.dots(8)), 'pn1'))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.tbar), 'pn2'))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.mbar), 'pn3'))
class test_LilyPond(unittest.TestCase):
    def setUp(self):
        self.commonbar = Bar()
        self.ebar = Bar("E", (4, 4))
        self.fbar = Bar("F", (6, 8))
        self.tbar = Bar("C", (4, 4))
        self.mbar = Bar("C", (4, 4))
        self.a_minor_bar = Bar("a", (4, 4))
        self.b_flat_minor_bar = Bar("bb", (4, 4))
        self.f_sharp_minor_bar = Bar("f#", (4, 4))
        for y in [self.commonbar, self.ebar, self.fbar]:
            map(lambda x: y + x, ["C", "E", "G", "B"])
        map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), ["C", "E", "G", "B", "C", "E"])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ["C", "E"])
        map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ["G", "B", "C"])
        self.track1 = Track()
        self.track1 + self.commonbar
        self.track2 = Track()
        self.track2 + self.commonbar
        self.track2 + self.ebar
        self.composition1 = Composition()
        self.composition1.add_track(self.track1)
        self.composition2 = Composition()
        self.composition2.add_track(self.track1)
        self.composition2.add_track(self.track2)

    def test_from_Note(self):
        self.assertEqual(LilyPond.from_Note(Note("C"), standalone=False), "c'")
        self.assertEqual(LilyPond.from_Note(Note("C#"), standalone=False), "cis'")
        self.assertEqual(LilyPond.from_Note(Note("C##"), standalone=False), "cisis'")
        self.assertEqual(LilyPond.from_Note(Note("Cb"), standalone=False), "ces'")
        self.assertEqual(LilyPond.from_Note(Note("Cbb"), standalone=False), "ceses'")
        self.assertEqual(LilyPond.from_Note(Note("C", 0), standalone=False), "c,,,")
        self.assertEqual(LilyPond.from_Note(Note("C", 1), standalone=False), "c,,")
        self.assertEqual(LilyPond.from_Note(Note("C", 2), standalone=False), "c,")
        self.assertEqual(LilyPond.from_Note(Note("C", 3), standalone=False), "c")
        self.assertEqual(LilyPond.from_Note(Note("C", 4), standalone=False), "c'")
        self.assertEqual(LilyPond.from_Note(Note("C", 5), standalone=False), "c''")
        self.assertEqual(LilyPond.from_Note(Note("C", 6), standalone=False), "c'''")
        self.assertEqual(LilyPond.from_Note(Note("C", 7), standalone=False), "c''''")

    def test_from_NoteContainer(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), standalone=False), "c'")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 4, standalone=False), "c'4")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(["C", "E"]), standalone=False), "<c' e'>")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(["C", "E"]), 4, standalone=False), "<c' e'>4")

        # issue #37

        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 16, standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 16.0, standalone=False), "c'16")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(16), standalone=False), "c'16.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 0.25, standalone=False), "c'\\longa")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 0.5, standalone=False), "c'\\breve")

    def test_from_Bar(self):
        self.assertEqual(LilyPond.from_Bar(self.commonbar), "{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.ebar), "{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
        self.assertEqual(LilyPond.from_Bar(self.fbar), "{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")
        self.assertEqual(LilyPond.from_Bar(self.a_minor_bar), "{ \\time 4/4 \\key a \\minor }")
        self.assertEqual(LilyPond.from_Bar(self.b_flat_minor_bar), "{ \\time 4/4 \\key bes \\minor }")
        self.assertEqual(LilyPond.from_Bar(self.f_sharp_minor_bar), "{ \\time 4/4 \\key fis \\minor }")

    def test_from_Track(self):
        self.assertEqual(LilyPond.from_Track(self.track1), "{ { c'4 e'4 g'4 b'4 } }")
        self.assertEqual(
            LilyPond.from_Track(self.track2), "{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }"
        )

    def test_from_Composition(self):
        self.assertEqual(
            LilyPond.from_Composition(self.composition1),
            '\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }',
        )
        self.assertEqual(
            LilyPond.from_Composition(self.composition2),
            "\\header { title = \"Untitled\" composer = \"\" opus = \"\" } { { c'4 e'4 g'4 b'4 } } { { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }",
        )

    def test_from_Suite(self):
        LilyPond.from_Suite(None)

    def test_dotted_notes(self):
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8), standalone=False), "c'8.")
        self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(4, 2), standalone=False), "c'4..")

    def test_to_pdf(self):
        self.assert_(
            LilyPond.to_pdf(
                "{ %s }" % LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8)), "pdftest first test"
            )
        )
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), "pdftest2"))
        self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), "pdftest3"))

    def test_to_png(self):
        self.assert_(LilyPond.to_png("{ %s }" % LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8)), "pn1"))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.tbar), "pn2"))
        self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.mbar), "pn3"))
Exemple #31
0
    def MIDI_to_Composition(self, file):
        (header, track_data) = self.parse_midi_file(file)
        c = Composition()
        if header[2]['fps']:
            print "Don't know how to parse this yet"
            return c
        ticks_per_beat = header[2]['ticks_per_beat']
        for track in track_data:
            t = Track()
            b = Bar()
            metronome = 1  # Tick once every quarter note
            thirtyseconds = 8  # 8 thirtyseconds in a quarter note
            meter = (4, 4)
            key = 'C'
            for e in track:
                (deltatime, event) = e
                duration = float(deltatime) / (ticks_per_beat * 4.0)
                if duration != 0.0:
                    duration = 1.0 / duration
                if deltatime != 0:
                    if not b.place_notes(NoteContainer(), duration):
                        t + b
                        b = Bar(key, meter)
                        b.place_notes(NoteContainer(), duration)

                if event['event'] == 8:
                    if deltatime == 0:
                        pass
                elif event['event'] == 9:
                    # note on
                    n = Note(notes.int_to_note(event['param1'] % 12),
                             event['param1'] / 12 - 1)
                    n.channel = event['channel']
                    n.velocity = event['param2']
                    if len(b.bar) > 0:
                        b.bar[-1][2] + n
                    else:
                        b + n
                elif event['event'] == 10:
                    # note aftertouch
                    pass
                elif event['event'] == 11:
                    # controller select
                    pass
                elif event['event'] == 12:
                    # program change
                    i = MidiInstrument()
                    i.instrument_nr = event['param1']
                    t.instrument = i
                elif event['event'] == 0x0f:
                    # meta event Text
                    if event['meta_event'] == 1:
                        pass
                    elif event['meta_event'] == 3:
                        # Track name
                        t.name = event['data']
                    elif event['meta_event'] == 6:
                        # Marker
                        pass
                    elif event['meta_event'] == 7:
                        # Cue Point
                        pass
                    elif event['meta_event'] == 47:
                        # End of Track
                        pass
                    elif event['meta_event'] == 81:
                        # Set tempo warning Only the last change in bpm will get
                        # saved currently
                        mpqn = self.bytes_to_int(event['data'])
                        bpm = 60000000 / mpqn
                    elif event['meta_event'] == 88:
                        # Time Signature
                        d = event['data']
                        thirtyseconds = self.bytes_to_int(d[3])
                        metronome = self.bytes_to_int(d[2]) / 24.0
                        denom = 2 ** self.bytes_to_int(d[1])
                        numer = self.bytes_to_int(d[0])
                        meter = (numer, denom)
                        b.set_meter(meter)
                    elif event['meta_event'] == 89:
                        # Key Signature
                        d = event['data']
                        sharps = self.bytes_to_int(d[0])
                        minor = self.bytes_to_int(d[0])
                        if minor:
                            key = 'A'
                        else:
                            key = 'C'
                        for i in xrange(abs(sharps)):
                            if sharps < 0:
                                key = intervals.major_fourth(key)
                            else:
                                key = intervals.major_fifth(key)
                        b.key = Note(key)
                    else:
                        print 'Unsupported META event', event['meta_event']
                else:
                    print 'Unsupported MIDI event', event
            t + b
            c.tracks.append(t)
        return (c, bpm)