def getScale(index, keySig, numberOfOctaves):
switcher = {
0: scales.Aeolian(keySig),
1: scales.Bachian(keySig),
2: scales.Chromatic(keySig),
3: scales.Diatonic(keySig, (3,7)),
4: scales.Dorian(keySig),
5: scales.HarmonicMajor(keySig),
6: scales.HarmonicMinor(keySig),
7: scales.Ionian(keySig),
8: scales.Locrian(keySig),
9: scales.Major(keySig),
10: scales.MelodicMinor(keySig),
11: scales.MinorNeapolitan(keySig),
12: scales.Mixolydian(keySig),
13: scales.NaturalMinor(keySig),
14: scales.Octatonic(keySig),
15: scales.Phrygian(keySig),
16: scales.WholeTone(keySig)
}
scale = switcher.get(index, None)
if scale is None:
return None
else:
converted_scale = []
for i in range(numberOfOctaves):
for note in scale.ascending():
#print note
converted_scale.append(str(Note(note,4+i)).replace('-','').replace("'",""))
return converted_scale
def setup(self):
"""Set up the main features"""
# scale
self.tonic = tonic = self.config.scale
self.is_minor = not tonic[0].isupper()
self.scale = [
mcs.NaturalMinor(tonic.upper()),
mcs.MelodicMinor(tonic.upper())
] if self.is_minor else mcs.Major(tonic.upper())
# last notes
self.last_degrees = self.last_degrees_possible = [
degrees.split(',') for degrees in self.config.last_degrees
]
self.first_last_note_pos = self.config.number - max(
[len(seq) for seq in self.last_degrees])
self.last_notes_found = []
self._generate_last_notes()
self.previous_last_notes = []
def __buildScale(self):
octa = int(math.ceil((self.numSteps / 7.0)))
return {
"diatonic":
scales.Diatonic(self.start_key, (3, 7), octa),
"ionian":
scales.Ionian(self.start_key, octa),
"dorian":
scales.Dorian(self.start_key, octa),
"phrygian":
scales.Phrygian(self.start_key, octa),
"lydian":
scales.Lydian(self.start_key, octa),
"mixolydian":
scales.Mixolydian(self.start_key, octa),
"aeolian":
scales.Aeolian(self.start_key, octa),
"locrian":
scales.Locrian(self.start_key, octa),
"major":
scales.Major(self.start_key, octa),
"harmonicmajor":
scales.HarmonicMajor(self.start_key, octa),
"naturalminor":
scales.NaturalMinor(self.start_key, octa),
"harmonicminor":
scales.HarmonicMinor(self.start_key, octa),
"melodicminor":
scales.MelodicMinor(self.start_key, octa),
"bachian":
scales.Bachian(self.start_key, octa),
"minorneapolitan":
scales.MinorNeapolitan(self.start_key, octa),
"chromatic":
scales.Chromatic(self.start_key,
int(math.ceil((self.numSteps / 12.0)))),
"wholetone":
scales.WholeTone(self.start_key,
int(math.ceil((self.numSteps / 6.0)))),
"octatonic":
scales.Octatonic(self.start_key,
int(math.ceil((self.numSteps / 8.0))))
}.get(self.scaleName.lower(), "custom")
def load_chord_progression(chord_progression_file_name,
key=None,
scale="Major"):
if not key:
key = key_finder()
with open(f"songs/{chord_progression_file_name}.csv") as csvfile:
reader = csv.reader(csvfile)
chord_progression_nums = list(reader)[0]
scale_notes = scales.Major(key).ascending()
# scale_notes = scales.NaturalMinor(key).ascending()
song = [
scale_notes[int(chord_num) - 1]
for chord_num in chord_progression_nums
]
chord_chart = convert_roots_to_chord_chart(song, scale_notes[:-1])
chord_progression = progressions.to_chords(chord_chart, key)
return key, scale, chord_progression
def select_scale(self, name, base_note):
"""Let me tell you what I am."""
# TODO: Fix the diatonic arguments
if not isinstance(base_note, str):
return TypeError
if name == "Diatonic":
return self.scales.Diatonic(base_note, (0, 7))
if name == "Ionian":
return scales.Ionian(base_note)
if name == "Dorian":
return scales.Dorian(base_note)
if name == "Phrygian":
return scales.Phrygian(base_note)
if name == "Lydian":
return scales.Lydian(base_note)
if name == "Mixolydian":
return scales.Mixolydian(base_note)
if name == "Aeolian":
return scales.Aeolian(base_note)
if name == "Locrian":
return scales.Locrian(base_note)
if name == "Major":
return scales.Major(base_note)
if name == "HarmonicMajor":
return scales.HarmonicMajor(base_note)
if name == "NaturalMinor":
return scales.NaturalMinor(base_note)
if name == "HarmonicMinor":
return scales.HarmonicMinor(base_note)
if name == "MelodicMinor":
return scales.MelodicMinor(base_note)
if name == "Bachian":
return scales.Bachian(base_note)
if name == "MinorNeapolitan":
return scales.MinorNeapolitan(base_note)
if name == "Chromatic":
return scales.Chromatic(base_note)
if name == "WholeTone":
return scales.WholeTone(base_note)
if name == "Octatonic":
return scales.Octatonic(base_note)
def select_scale(self, name, base_note):
if not isinstance(base_note, str):
return TypeError("Scale Name incorrect.")
if name == "Diatonic":
return self.scales.Diatonic(base_note, (0, 7))
if name == "Ionian":
return scales.Ionian(base_note)
if name == "Dorian":
return scales.Dorian(base_note)
if name == "Phrygian":
return scales.Phrygian(base_note)
if name == "Lydian":
return scales.Lydian(base_note)
if name == "Mixolydian":
return scales.Mixolydian(base_note)
if name == "Aeolian":
return scales.Aeolian(base_note)
if name == "Locrian":
return scales.Locrian(base_note)
if name == "Major":
return scales.Major(base_note)
if name == "HarmonicMajor":
return scales.HarmonicMajor(base_note)
if name == "NaturalMinor":
return scales.NaturalMinor(base_note)
if name == "HarmonicMinor":
return scales.HarmonicMinor(base_note)
if name == "MelodicMinor":
return scales.MelodicMinor(base_note)
if name == "Bachian":
return scales.Bachian(base_note)
if name == "MinorNeapolitan":
return scales.MinorNeapolitan(base_note)
if name == "Chromatic":
return scales.Chromatic(base_note)
if name == "WholeTone":
return scales.WholeTone(base_note)
if name == "Octatonic":
return scales.Octatonic(base_note)
def test_not_equal(self):
self.assertNotEqual(scales.NaturalMinor("C"), scales.NaturalMinor("A"))
self.assertNotEqual(scales.NaturalMinor("A"), scales.MelodicMinor("A"))
self.assertNotEqual(scales.Major("F"), scales.Major("D"))
self.assertNotEqual(scales.Ionian("E"), scales.Dorian("E"))
def test_equal(self):
self.assertEqual(scales.NaturalMinor("C"), scales.NaturalMinor("C"))
self.assertEqual(scales.Major("F"), scales.Major("F"))
self.assertEqual(scales.Major("Bb"), scales.Ionian("Bb"))
self.assertEqual(scales.NaturalMinor("E"), scales.Aeolian("E"))
def get_c_scale(cls):
scale_notes = scales.Major('C').ascending()
return scale_notes
def test_not_equal(self):
self.assertNotEqual(scales.NaturalMinor('C'), scales.NaturalMinor('A'))
self.assertNotEqual(scales.NaturalMinor('A'), scales.MelodicMinor('A'))
self.assertNotEqual(scales.Major('F'), scales.Major('D'))
self.assertNotEqual(scales.Ionian('E'), scales.Dorian('E'))
def test_equal(self):
self.assertEqual(scales.NaturalMinor('C'), scales.NaturalMinor('C'))
self.assertEqual(scales.Major('F'), scales.Major('F'))
self.assertEqual(scales.Major('Bb'), scales.Ionian('Bb'))
self.assertEqual(scales.NaturalMinor('E'), scales.Aeolian('E'))
def init_preset_track(num):
track = Track()
if num == 1: #C-chord
track.add_notes(None)
track.add_notes(None)
nc = NoteContainer(["C", "E"])
track.add_notes(nc)
track + "E-5"
track + "A-3"
track.add_notes(None)
track + "C-5"
track + "E-5"
nc2 = NoteContainer(["F", "G"])
track.add_notes(nc2)
track + "G-5"
track + "C-6"
if num == 2:
track + "E"
track + "D"
track + "E"
track + "A-2"
track + "C"
track + "D"
track + "E"
track + "F-5"
track + "D"
track + "E"
track + "E-5"
if num == 3:
test_scale = scales.Major("C")
for i in range(7):
track + test_scale[i]
if num == 4 or num == 'blinka':
bar = Bar()
bar.place_notes('C-4', 8)
bar.place_notes('C-4', 8)
bar.place_notes('G-4', 8)
bar.place_notes('G-4', 8)
bar.place_notes('A-4', 8)
bar.place_notes('A-4', 8)
bar.place_notes('G-4', 4)
track.add_bar(bar)
if num == "nokia": #scale A
track.add_notes('E-4', 16)
track.add_notes('D-4', 16)
track.add_notes('F#-3', 8)
track.add_notes('G#-3', 8)
track.add_notes('C#-4', 16)
track.add_notes('B-3', 16)
track.add_notes('D-3', 8)
track.add_notes('E-3', 8)
track.add_notes('B-3', 16)
track.add_notes('A-3', 16)
track.add_notes('A-3', 8)
if num == "windows": #scale C#
track.add_notes('D#-5', 4)
track.add_notes('A#-4', 8)
track.add_notes('G#-4', 4)
track.add_notes('D#-5', 8)
track.add_notes(['A#-3', 'D#-4', 'A#-4'], 4)
if num == "brick": #scale C
track.add_notes('E-4', 4)
track.add_notes('B-3', 8)
track.add_notes('C-4', 8)
track.add_notes('D-4', 4)
track.add_notes('C-4', 8)
track.add_notes('B-3', 8)
if num == "panther": #Scale E
track.add_notes('D#-4', 8)
track.add_notes('E-4', 8 / 3)
track.add_notes('F#-4', 8)
track.add_notes('G-4', 8 / 3)
return track
args.extend([
"-t", "5", "-B", "--key", f"{key}", "-N", f"{prefix} - {chords}",
"--output", f"{dir}/{prefix} - {chords}.mid"
])
if not os.path.exists(dir):
os.makedirs(dir)
c2m_obj.handle(args)
num = 1
# Iterate for each key
for key in keys:
root_maj = key[0]
root_min = key[1]
scale_maj = scales.Major(root_maj).ascending()
scale_min = scales.NaturalMinor(root_min).ascending()
base = f'{out}/{num:02} - {root_maj} Major - {root_min} minor'
# Major triads
i = 0
for n in ['', 'm', 'm', '', '', 'm', 'dim']:
chord = scale_maj[i] + n
gen(f'{base}/1 Triad/Major', root_maj, chord, deg_maj[i])
i = i + 1
# Minor triads
i = 0
for n in ['m', 'dim', '', 'm', 'm', '', '']:
chord = scale_min[i] + n
gen(f'{base}/1 Triad/Minor', root_min, chord, deg_min[i])
def buildKeyData(self, root, keyType):
"""
From a given key, build and return the KeyData for that key.
"""
mScales = []
diatonicChordTones = []
mArpeggios = []
cNames = []
if keyType == 'minor':
# We'll be using a natural and harmonic minor scale/chords together
natScale = scales.NaturalMinor(root).ascending()
harmScale = scales.HarmonicMinor(root).ascending()
natScaleExercise = self._getScaleExercise(natScale)
harmScaleExercise = self._getScaleExercise(harmScale)
mScales.append(natScaleExercise)
mScales.append(harmScaleExercise)
natDiatonicChords = self.buildDiatonicChords(natScale)
harmDiatonicChords = self.buildDiatonicChords(harmScale)
fusedDiatonicChords = []
fusedDiatonicChords.append(natDiatonicChords[0])
fusedDiatonicChords.append(harmDiatonicChords[1])
fusedDiatonicChords.append(natDiatonicChords[1])
fusedDiatonicChords.append(harmDiatonicChords[2])
fusedDiatonicChords.append(natDiatonicChords[2])
fusedDiatonicChords.append(natDiatonicChords[3])
fusedDiatonicChords.append(natDiatonicChords[4])
fusedDiatonicChords.append(natDiatonicChords[5])
fusedDiatonicChords.append(harmDiatonicChords[6])
fusedDiatonicChords.append(natDiatonicChords[6])
for index, chord in enumerate(fusedDiatonicChords):
dcInRange = self.getChordTonesInRange(chord, self.lowerLimit,
self.upperLimit)
chordTitle = chord[0] + WorkbookBuilder.chordNames["fused"][
index] + " (" + WorkbookBuilder.romanChordNames["fused"][
index] + ")"
cNames.append(chordTitle)
diatonicChordTones.append(dcInRange)
else:
# Major key. Fairly straightforward
rawScale = scales.Major(root).ascending()
scaleExercise = self._getScaleExercise(rawScale)
mScales.append(scaleExercise)
diatonicChords = self.buildDiatonicChords(rawScale)
for index, chord in enumerate(diatonicChords):
dcInRange = self.getChordTonesInRange(chord, self.lowerLimit,
self.upperLimit)
chordTitle = chord[0] + WorkbookBuilder.chordNames["major"][
index] + " (" + WorkbookBuilder.romanChordNames["major"][
index] + ")"
cNames.append(chordTitle)
diatonicChordTones.append(dcInRange)
for chordToneSet in diatonicChordTones:
mArpeggios.append(self._getArpeggioExercise(chordToneSet))
returnKeyData = KeyData(root, keyType, cNames, mScales, mArpeggios)
returnKeyData.mingusScalesSolfege = self.buildSolfegeFromScales(
Note(root), mScales)
returnKeyData.mingusArpeggiosSolfege = self.buildSolfegeFromScales(
Note(root), mArpeggios)
return returnKeyData
def func_not_found(key):
print(f"No Scale: {scale_name} Found!")
return scales.Major(key)
def get_scale(key,minor=scales.HarmonicMinor):
"""Return a scale, major or minor,
matching with key"""
return scales.Major(key) if key[0].isupper() else minor(key.upper())
