1from operator import truediv
  2
  3CHROMATIC_SCALE = ['C', 'C#', 'D', 'D#',
  4                   'E', 'F', 'F#', 'G',
  5                   'G#', 'A', 'A#', 'B']
  6
  7SEMITONES_TYPES = {0 : 'unison', 1 : 'minor 2nd', 2 : 'major 2nd', 3 : 'minor 3rd', 4 : 'major 3rd',
  8                   5 : 'perfect 4th', 6 : 'diminished 5th', 7 : 'perfect 5th', 8 : 'minor 6th',
  9                   9 : 'major 6th', 10 : 'minor 7th', 11 : 'major 7th'}
 10
 11INTERVAL_LEN = len(CHROMATIC_SCALE)
 12MINOR_IDX = 3
 13MAJOR_IDX = 4
 14
 15class Tone:
 16    def __init__(self, name):
 17        self.name = name
 18
 19    def __str__(self):
 20        return self.name
 21
 22    def __eq__(self, other):
 23        return self.name == other.name
 24
 25    def __add__(self, other):
 26        if isinstance(other, Interval):
 27            new_tone_idx = (CHROMATIC_SCALE.index(self.name) + other.number_of_semitones) % INTERVAL_LEN
 28            return Tone(CHROMATIC_SCALE[new_tone_idx])
 29        return Chord(self, other)
 30
 31    def __sub__(self, other):
 32        first_idx = CHROMATIC_SCALE.index(self.name)
 33        if isinstance(other, Interval):
 34            second_idx = other.number_of_semitones
 35            res_idx = (first_idx - second_idx) % INTERVAL_LEN
 36            return Tone(CHROMATIC_SCALE[res_idx])
 37        second_idx = CHROMATIC_SCALE.index(other.name)
 38        res_idx = (first_idx - second_idx) % INTERVAL_LEN
 39        return Interval(res_idx)
 40
 41
 42class Interval:
 43
 44    def __init__(self, number_of_semitones):
 45        self.number_of_semitones = number_of_semitones
 46
 47    def __str__(self):
 48        return SEMITONES_TYPES[self.number_of_semitones % INTERVAL_LEN]
 49
 50    def __add__(self, other):
 51        if isinstance(other, Tone):
 52            raise TypeError('Invalid operation')
 53        else:
 54            semitones = (self.number_of_semitones + other.number_of_semitones) % INTERVAL_LEN
 55            return Interval(semitones)
 56
 57    def __sub__(self, other):
 58        if isinstance(other, Tone):
 59            raise TypeError('Invalid operation')
 60
 61    def __neg__(self):
 62        return Interval(-self.number_of_semitones)
 63
 64
 65class Chord:
 66    def __init__(self, root, *tones):
 67        self.root = root
 68        self.all_tones = [root, *tones]
 69        self.uniques = self._unique_tones(self.all_tones)
 70        if len(self.uniques) < 2:
 71            raise TypeError("Cannot have a chord made of only 1 unique tone")
 72        #calculates how far is every unique tone from the root and sorts(increase) by this parameter
 73        self.sorted_unique_tones = sorted(self.uniques, key=lambda tone:
 74        (CHROMATIC_SCALE.index(tone.name) - CHROMATIC_SCALE.index(root.name)) % len(CHROMATIC_SCALE))
 75
 76    @staticmethod
 77    def _unique_tones(tones):
 78        unique_list = []
 79        for tone in tones:
 80            if tone not in unique_list:
 81                unique_list.append(tone)
 82        return unique_list
 83
 84    def __str__(self):
 85        return '-'.join(map(str, self.sorted_unique_tones))
 86
 87    def is_minor(self):
 88        return self._minor_major(MINOR_IDX)
 89
 90    def is_major(self):
 91        return self._minor_major(MAJOR_IDX)
 92
 93    def is_power_chord(self):
 94        return not (self.is_minor() or self.is_major())
 95
 96    def _minor_major(self, interval):
 97        index_of_root = CHROMATIC_SCALE.index(self.root.name)
 98        for tone in self.sorted_unique_tones:
 99            curr_tone = CHROMATIC_SCALE.index(tone.name)
100            diff = (curr_tone - index_of_root)
101            if diff == interval:
102                return True
103            elif diff < 0 and (12 + diff == interval):
104                return True
105        return False
106
107    def __add__(self, other):
108        if isinstance(other, Tone):
109            tones = self.all_tones + [other]
110            end_tones = tuple(tones)
111            return Chord(self.root, *end_tones)
112        all_tones = tuple(self.all_tones) + tuple(other.all_tones)
113        return Chord(self.root, *all_tones)
114
115    def __sub__(self, other):
116        if isinstance(other, Tone):
117            if other not in self.uniques:
118                raise TypeError(f'Cannot remove tone {other.name} from chord {str(self)}')
119            elif len(self.uniques) >= 3:
120                tones = []
121                for tone in self.all_tones:
122                    if tone != other:
123                        tones.append(tone)
124                new_root = tones[0]
125                return Chord(new_root, *(tuple(tones)))
126            else:
127                raise TypeError('Cannot have a chord made of only 1 unique tone')
128
129    def transposed(self, interval):
130        interval_num = interval.number_of_semitones
131        tones = []
132        for tone in self.all_tones:
133            curr_idx = (CHROMATIC_SCALE.index(tone.name) + interval_num) % INTERVAL_LEN
134            tones.append(Tone(CHROMATIC_SCALE[curr_idx]))
135        new_root = tones[0]
136        return Chord(new_root, *(tuple(tones[1:])))