ScaleFinder.py

#Figure out what scales have chords in common
#Identify scales which have chords in common in order to figure out potential pivot chord
# 1. Emin chord = E G B
# 2. None of notes can be sharps or flats.. 
# 3. It can't be a flat key because Bb is the first flat
# 4. It could be a sharp key but no more than 2 sharps because G# is the third sharp
# 5. Therefore it must be a key with 0, 1, or 2 sharps
# 6. The 6 keys would be C, Am, G, Em, D, Bm
# 7. If you want to include the modes there would be 21 modes

import numpy as np #pip install numpy
import collections

''' DIATONIC SCALES '''
c_major = ['C', 'D', 'E', 'F', 'G', 'A', 'B']
a_minor = c_major
g_major = ['G', 'A', 'B', 'C', 'D', 'E', 'F#']
e_minor = g_major
d_major = ['D', 'E', 'F', 'G', 'A', 'B', 'C#']
b_minor = d_major
a_major = ['A', 'B', 'C#', 'D', 'E', 'F#', 'G#']
fs_minor = a_major
e_major = ['E', 'F#', 'G#', 'A', 'B', 'C#', 'D#']
cs_minor = e_major
b_major = ['B', 'C#', 'D#', 'E', 'F#', 'G#', 'A#']
gs_minor = b_major
cb_major = ['Cb', 'Db', 'Eb', 'E', 'Gb', 'Ab', 'Bb']
ab_minor = cb_major
fs_major = ['F#', 'G#', 'A#', 'B', 'C#', 'D#', 'F']
ds_minor = fs_major
gb_major = ['Gb', 'Ab', 'Bb', 'B', 'Db', 'Eb', 'F']
eb_minor = gb_major
cs_major = ['C#', 'D#', 'F', 'F#', 'G#', 'A#', 'C']
as_minor = cs_major
db_major = ['Db', 'Eb', 'F', 'Gb', 'Ab', 'Bb', 'C']
bb_minor = db_major
ab_major = ['Ab', 'Bb', 'C', 'Db', 'Eb', 'F', 'G']
f_minor = ab_major
eb_major = ['Eb', 'F', 'G', 'Ab', 'Bb', 'C', 'D']
c_minor = eb_major
bb_major = ['Bb', 'C', 'D', 'Eb', 'F', 'G', 'A']
g_minor = bb_major
f_major = ['F', 'G', 'A', 'Bb', 'C', 'D', 'E']
d_minor = f_major

''' DIATONIC CHORDS '''
ab = ['Ab', 'C', 'Eb']
a = ['A', 'C#', 'E']
asharp = ['A#', 'D', 'F']
bb = ['Bb', 'D', 'F']
b = ['B', 'D#', 'F#']
cb = ['Cb', 'Eb', 'Gb']
c = ['C', 'E', 'G']
csharp = ['C#', 'E#', 'G#']
db = ['Db', 'F', 'Ab']
d = ['D', 'F#', 'A']
dsharp = ['D#', 'F#', 'A#']
eb = ['Eb', 'Gb', 'Bb']
e = ['E', 'G#', 'B']
f = ['F', 'A', 'C']
fsharp = ['F#', 'A#', 'C#']
gb = ['Gb', 'Bb', 'Db']
g = ['G', 'B', 'D']
gsharp = ['G#', 'B#', 'D#']
abm = ['Ab', 'Cb', 'Eb']
am = ['A', 'C', 'E']
asharpm = []
bbm = []
bm = ['B', 'D', 'F#']
cbm = []
cm = ['C', 'Eb', 'G']
csharpm = []
dbm = []
dm = ['D', 'F', 'A']
dsharpm = []
ebm = []
em = ['E', 'G', 'B']
fm = ['F', 'Ab', 'C']
fsharpm = []
gbm = []
gm = ['G', 'Bb', 'D']
gsharpm = []
amin7b5 = ['A', 'C', 'Eb', 'G']
bmin7b5 = ['B', 'D', 'F', 'A']
cmin7b5 = ['C', 'D#', 'F#', 'A#']
dmin7b5 = ['D', 'F', 'Ab', 'C']
emin7b5 = ['E', 'G', 'Bb', 'D']

chord_list = [ab, a, asharp, bb, b, cb, c, csharp, db, d, dsharp, eb, e, f, fsharp, gb, g, gsharp, abm, am, asharpm, bbm, bm, cbm, cm, csharpm, dbm, dm, dsharpm, ebm, em, fm, fsharpm, gbm, gm, gsharpm]
scale_map = {
    'Ab Major': ab_major,
    'A Major': a_major,
    'Bb Major': bb_major,
    'B Major': b_major,
    'Cb Major': cb_major,
    'C Major': c_major,
    'C# Major': cs_major,
    'Db Major': db_major,
    'D Major': d_major,
    'Eb Major': eb_major,
    'E Major': e_major,
    'F Major': f_major,
    'F# Major': fs_major,
    'Gb Major': gb_major,
    'G Major': g_major,
    'Ab Minor': ab_minor,
    'A Minor': a_minor,
    'A# Minor': as_minor,
    'Bb Minor': bb_minor,
    'B Minor': b_minor,
    'C Minor': c_minor,
    'C# Minor': cs_minor,
    'D Minor': d_minor,
    'D# Minor': ds_minor,
    'Eb Minor': eb_minor,
    'E Minor': e_minor,
    'F Minor': f_minor,
    'F# Minor': fs_minor,
    'G Minor': g_minor,
    'G# Minor': gs_minor
}

def get_chord_variable(chord):
    ch = chord.split(' ')
    # for c in chord_list:
    #     if (np.array_equiv(ch, c)):
    #         return c
    return ch
        

def find_all_scales(chord):
    scales = []
    for scale in scale_map:
        s = scale_map[scale]
        count = 0
        for note in chord:
            if note in s:
                count += 1
            else:
                break
            if (count == 3):
                scales.append(scale)
    return scales

target_chord = input("Enter your chord as separated notes (Ex. E G B): ")
target_chord = get_chord_variable(target_chord)
scales = find_all_scales(target_chord)
print(scales)