1import copy
  2
  3CHROMATIC_SCALE = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
  4TONES_COUNT = 12
  5
  6class Tone:
  7    def __init__(self, name):
  8        self._name = name
  9    
 10    def __str__(self):
 11        return self._name
 12
 13    def __eq__(self, other):
 14        return str(self) == str(other)
 15
 16    def __hash__(self):
 17        return hash(self._name)
 18    
 19    def __add__(self, other):
 20        if isinstance(other, Tone):
 21            return Chord(self, other)
 22        elif isinstance(other, Interval):
 23            self_index = CHROMATIC_SCALE.index(str(self))
 24            other_index = other.interval_index
 25            return Tone(CHROMATIC_SCALE[(self_index + other_index) % TONES_COUNT])
 26
 27    
 28    def __sub__(self, other):
 29        if isinstance(other, Tone):
 30            return Interval(CHROMATIC_SCALE.index(str(self)) - CHROMATIC_SCALE.index(str(other)))
 31        elif isinstance(other, Interval):
 32            self_index = CHROMATIC_SCALE.index(str(self))
 33            other_index = other.interval_index
 34            return Tone(CHROMATIC_SCALE[TONES_COUNT - (abs(other_index - self_index) % TONES_COUNT)])
 35    
 36class Interval:
 37    __NUMBER_OF_SEMITONES_TO_STRING = ['unison', 'minor 2nd', 'major 2nd', 'minor 3rd', 'major 3rd', 'perfect 4th',
 38                                        'diminished 5th', 'perfect 5th', 'minor 6th', 'major 6th', 'minor 7th', 'major 7th']
 39
 40    @property
 41    def interval_index(self):
 42        return self._number_of_semitones
 43    
 44    def __init__(self, number_of_semitones):
 45        self._number_of_semitones = number_of_semitones % TONES_COUNT
 46    
 47    def __str__(self):
 48        return self.__NUMBER_OF_SEMITONES_TO_STRING[abs(self._number_of_semitones)]
 49    
 50    def __neg__(self):
 51        return Interval(-self._number_of_semitones)
 52
 53    def __add__(self, other):
 54        if isinstance(other, Tone):
 55            raise TypeError("Invalid operation")
 56        return Interval(self._number_of_semitones + other._number_of_semitones)
 57    
 58    def __sub__(self, other):
 59        if isinstance(other, Tone):
 60            raise TypeError("Invalid operation")
 61
 62class Chord:
 63    def __init__(self, *args):
 64        seen = set()
 65        self._tones = [tone for tone in args if not (tone in seen or seen.add(tone))]
 66        
 67        if len(self._tones) <= 1:
 68            raise TypeError("Cannot have a chord made of only 1 unique tone")
 69
 70        self._main_tone = self[0]
 71        self._main_tone_index = CHROMATIC_SCALE.index(str(self._main_tone))
 72
 73    def add_tone(self, tone):
 74        if tone not in self._tones:
 75            self._tones.append(tone)
 76    
 77    def remove_tone(self, tone):
 78        if tone not in self._tones:
 79            raise TypeError(f"Cannot remove tone {str(tone)} from chord {str(self)}")
 80        
 81        if tone == self._main_tone:
 82            self._main_tone = self[1]
 83            self._main_tone_index = CHROMATIC_SCALE.index(str(self._main_tone))
 84        self._tones = list(filter(lambda t: str(t) != str(tone), self._tones))
 85
 86    def __get_tone_index(self, tone):
 87        return CHROMATIC_SCALE.index(str(tone))
 88
 89    def __str__(self):
 90        return '-'.join(list(filter(lambda tone: str(tone) in self._tones, CHROMATIC_SCALE[self._main_tone_index:] + CHROMATIC_SCALE[:self._main_tone_index])))
 91    
 92    def __add__(self, other):
 93        if isinstance(other, Tone):
 94            new_chord = copy.deepcopy(self)
 95            new_chord.add_tone(other)
 96            return new_chord
 97        elif isinstance(other, Chord):
 98            new_chord = copy.deepcopy(self)
 99
100            for tone in other._tones:
101                if tone not in new_chord._tones:
102                    new_chord._tones.append(tone)
103
104            return new_chord
105
106    def __sub__(self, other):
107        if isinstance(other, Tone):
108            new_chord = copy.deepcopy(self)
109            new_chord.remove_tone(other)
110
111            if len(new_chord._tones) < 2:
112                raise TypeError("Cannot have a chord made of only 1 unique tone")
113            return new_chord
114
115    def __getitem__(self, index):
116        return self._tones[index]
117    
118    def __setitem__(self, index, value):
119        self._tones[index] = value
120    
121    def is_minor(self):
122        for tone in self[1:]:
123            curr_tone_idx = self.__get_tone_index(tone)
124            if(abs(self._main_tone_index - curr_tone_idx) == 3):
125                return True
126        
127        return False
128    
129    def is_major(self):
130        for tone in self[1:]:
131            curr_tone_idx = self.__get_tone_index(tone)
132            if(abs(self._main_tone_index - curr_tone_idx) == 4):
133                return True
134        
135        return False
136    
137    def is_power_chord(self):
138        return not (self.is_major() or self.is_minor())
139        
140    def transposed(self, interval):
141        step = interval.interval_index
142        new_chord = copy.deepcopy(self)
143        new_chord._tones.clear()
144
145        for tone in self._tones:
146            tone_index = self.__get_tone_index(tone)
147            new_tone_index = (tone_index + step) % TONES_COUNT
148            if tone == self._main_tone:
149                new_chord._main_tone = Tone(CHROMATIC_SCALE[new_tone_index])
150                new_chord._main_tone_index = new_tone_index
151            new_chord._tones.append(Tone(CHROMATIC_SCALE[new_tone_index]))
152        
153        return new_chord