Esempio n. 1
0
 def update(self):
     self.notes = []
     self.intArr = []
     self.intStr = []
     if self.type not in self.chrLst:
         return
     self.intArr = self.chrLst[self.type]
     self.intStr = [self.intLst[n] for n in self.intArr]
     if self.intArr:
         self.notes = [Note(self.root.name, i - 12 if '♭' in iStr else i) for i, iStr in
                       zip(self.intArr, self.intStr)]
     if self.intStr[:3] == ['1', '♭3', '♭5']:
         self.quality = 'dim'
     elif self.intStr[:4] == ['1', '3', '5', '♭7']:
         self.quality = 'dom'
     elif self.intStr[:4] == ['1', '3', '♭5', '♭7']:
         self.quality = 'dom'
     elif self.intStr[:3] == ['1', '♭3', '♯5']:
         self.quality = 'aug'
     elif self.intStr[:3] == ['1', '3', '♯5']:
         self.quality = 'aug'
     elif self.intStr[:3] == ['1', '2', '5']:
         self.quality = 'sus'
     elif self.intStr[:3] == ['1', '4', '5']:
         self.quality = 'sus'
     elif self.intStr[:3] == ['1', '3', '5']:
         self.quality = 'maj'
     elif self.intStr[:3] == ['1', '♭3', '5']:
         self.quality = 'min'
     else:
         self.quality = '?'
         warnings.warn('cannot resolve chord quality for ' + self.name)
Esempio n. 2
0
    def __init__(self, nameOrNotes, checkInv=True):

        self.notes = []
        self.intArr = []
        self.intStr = []
        if isinstance(nameOrNotes, str):
            root, alt, chrType = re.search(self.regexChord, nameOrNotes).groups()
            self.root = Note(root + alt)

            for r in self.chrReplace:
                chrType = chrType.replace(r[0], r[1])

            self.type = chrType

        elif isinstance(nameOrNotes, Chord):
            self.root = nameOrNotes.root
            self.type = nameOrNotes.type
        else:
            nameOrNotes = [str(n) for n in nameOrNotes]
            chrdType = []
            if checkInv:
                seq = list(permutations(nameOrNotes, len(nameOrNotes)))
            else:
                seq = [nameOrNotes]
            for lst in seq:
                intervals = [n if n >= 0 else n + 12 for n in [Note(n) - Note(lst[0]) for n in lst]]
                chrdType.extend([lst[0] + cType for cType in self.chrLst if intervals == self.chrLst[cType]])

            if len(chrdType) > 1:
                chrdType.sort(key=len)  # todo: Best match shouldnt be done this way
                # print('Found {} choosing {}'.format(','.join(chrdType), chrdType[0]))

            if len(chrdType):
                self.root = Chord(chrdType[0]).root
                self.type = Chord(chrdType[0]).type
            else:
                print('Cannot find a chord from ' + ','.join(nameOrNotes))
                self.root = Note(nameOrNotes[0])
                self.type = '?'

        self.name = str(self.root) + self.type
        self.update()
Esempio n. 3
0
def test_basics():
    for note in Note.chrSharp + Note.chrFlat:
        assert Note(note) == note
        assert Note(note).name == note
        assert Note(note) + 12 == note
        assert Note(note) - 12 == note
        assert Note(note + '#b#b#b') == Note(note)
Esempio n. 4
0
def printNotes(notes, fmt='shade'):
    if isinstance(notes[0], str):
        notes = [Note(n) for n in notes]
    if fmt == 'square':
        b, w, spc = [u"\u25A1", u"\u25A0", u"\u2005"]
    elif fmt == 'shade':
        b, w, spc = [u"\u2591", u"\u2588", u"\u2005"]
    else:
        b, w, spc = [u"\u2591", u"\u2588", u"\u2005"]

    N = [b] * 12
    for ni, n in enumerate([
            Note(n) for n in
        ['C', 'C♯', 'D', 'D♯', 'E', 'F', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B']
    ]):
        if n in notes: N[ni] = w

    print(3 * spc + N[1] + 2 * spc + N[3] + 9 * spc + N[6] + 2 * spc + N[8] +
          2 * spc + N[10] + 7 * spc + 3 * spc + N[1] + 2 * spc + N[3] +
          9 * spc + N[6] + 2 * spc + N[8] + 2 * spc + N[10] + '\n' + N[0] +
          2 * spc + N[2] + 2 * spc + N[4] + 4 * spc + N[5] + 2 * spc + N[7] +
          2 * spc + N[9] + 2 * spc + N[11] + 3 * spc + N[0] + 2 * spc + N[2] +
          2 * spc + N[4] + 4 * spc + N[5] + 2 * spc + N[7] + 2 * spc + N[9] +
          2 * spc + N[11])
Esempio n. 5
0
    def __init__(self, root='C', mode='ion'):
        if isinstance(root, Note):
            root = root.name
        if ' ' in root:
            root, mode = root.split(' ')

        if mode in ['Major', 'Maj', 'major', 'maj', 'M']: mode = 'ion'
        if mode in ['Minor', 'Min', 'Nmin', 'm', 'minor', 'min', 'nmin', 'm']:
            mode = 'aeo'
        if mode in ['hmin']: mode = 'hm'

        if mode.lower() not in self.modesIntervals:
            raise ValueError('mode {} not implemented'.format(mode))

        self.root = Note(root)
        self.mode = mode
        self.name = self.root.name + ' ' + self.mode
Esempio n. 6
0
def test_fromNotes():
    assert Chord('C').notes == ['C', Note('E'), 'G']
    from itertools import permutations
    for lst in list(permutations(['C', 'Eb', 'G', 'Bb'], 4)):
        assert (Chord(lst).name in ['Cm7', 'E♭6'])
Esempio n. 7
0
def test_relationships():
    assert Note('C') - Note('D') == 10
    assert Note('D') - Note('C') == 2
    assert Note('B') - Note('C') == 11
    assert Note('C') - Note('B') == 1
    assert Note('C') - Note('C') == 0
    assert Note('G') - Note('C') == 7
    assert Note('C') - Note('G') == 5

    assert Note('A#') == Note('Bb')
    assert Note(Note('C')) == 'C'
Esempio n. 8
0
def test_alterations():
    assert Note('C♯#') == Note('D')
    assert Note('C##') == 'D'
    assert str(Note('C♯♯')) == 'D'
    assert Note('Dbb') == Note('C')
    assert Note('C##♯♯') == Note('E')
    assert Note('C###').name == 'D♯'
    assert Note('Fbb').name == 'E♭'

    # We want to keep alterations
    assert [Note('C') - alt for alt in range(15)] == \
           ['C', 'B', 'B♭', 'A', 'A♭', 'G', 'G♭', 'F', 'E', 'E♭', 'D', 'D♭', 'C', 'B', 'B♭']
    assert [Note('C') + alt for alt in range(15)] == \
           ['C', 'C♯', 'D', 'D♯', 'E', 'F', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B', 'C', 'C♯', 'D']
Esempio n. 9
0
 def parallelMajor(self, asStr=False):
     if self.mode == 'aeo':
         return Scale(Note(self.root), 'ion').name if asStr else Scale(
             Note(self.root), 'ion')
     else:
         return None
Esempio n. 10
0
 def relativeMajor(self, asStr=False):
     if self.mode == 'aeo':  # Relative Minor is 1.5 tone above key
         return Scale(Note(self.root) + 3, 'ion').name if asStr else Scale(
             Note(self.root) + 3, 'ion')
     else:
         return None
Esempio n. 11
0
def plotNotes(notes, pos=None, name='', ax=0, nbOctaves=1):
    if pos is None:
        pos = [0, 0, 100, 40]

    def plotKey(ax, x, y, w, h, keyType, status):
        lw = .5
        pad = 0.5
        # edgeColor = 'w'
        # parms = dict(
        #     black=dict(color=['skyblue', 'steelblue'], z=1),
        #     white=dict(color=['skyblue', 'steelblue'], z=0)
        # )

        edgeColor = 'k'
        parms = dict(black=dict(color=['k', 'skyblue'], z=1),
                     white=dict(color=['w', 'skyblue'], z=0))

        ax.add_patch(
            FancyBboxPatch((x + pad, y + pad),
                           abs(w) - 2 * pad,
                           abs(h) - 2 * pad,
                           boxstyle="round,pad=" + str(pad),
                           fc=parms[keyType]['color'][status],
                           ec=edgeColor,
                           zorder=parms[keyType]['z'],
                           lw=lw))

    nb = int(np.ceil(len(notes) / (nbOctaves * 12)) * (nbOctaves * 12))
    start = 'C' if notes[0] - Note('C') < notes[0] - Note('F') else 'F'
    chromatic = Note.chrSharp * 4
    chromatic = chromatic[chromatic.index(Note(start)):]
    chromatic = chromatic[:nb]
    whites = [
        n for n in chromatic
        if n in [Note(n) for n in ['C', 'D', 'E', 'F', 'G', 'A', 'B']]
    ]
    whiteWidth = pos[2] / len(whites)
    blackWidth = whiteWidth / 2

    if ax == 0:
        figure(figsize=(3, 1))
        ax = gca()
    axis('off')

    nWhites = 0
    for i, n in enumerate(chromatic):
        if n in whites:
            plotKey(ax,
                    pos[0] + (nWhites) * whiteWidth,
                    pos[1],
                    whiteWidth,
                    pos[3],
                    keyType='white',
                    status=n in notes)
            nWhites += 1
        else:
            plotKey(ax,
                    pos[0] + (nWhites) * whiteWidth - blackWidth / 2,
                    pos[1] + pos[3] / 3,
                    blackWidth,
                    2 * pos[3] / 3,
                    keyType='black',
                    status=n in notes)
    plot(0, 0, '.w', zorder=-1)
    if name:
        text(pos[0],
             pos[1] + pos[3] / 2,
             name,
             ha='right',
             va='center',
             rotation=90)