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())