1ACCEPTED_TONES = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
  2INTERVAL_VALUES = ("unison", "minor 2nd", "major 2nd", "minor 3rd", "major 3rd", "perfect 4th",
  3                   "diminished 5th", "perfect 5th", "minor 6th", "major 6th", "minor 7th", "major 7th")
  4
  5
  6class Tone:
  7
  8    def __init__(self, tone):
  9        if tone not in ACCEPTED_TONES:
 10            raise TypeError("Tone is not accepted")
 11        self.tone = tone
 12
 13    def __str__(self):
 14        return self.tone
 15
 16    def __eq__(self, other):
 17        return self.tone == other.tone
 18
 19    def __hash__(self):
 20        return hash(self.tone)
 21
 22    def __add__(self, other):
 23        if isinstance(other, Tone):
 24            return Chord(self, other)
 25        
 26        if isinstance(other, Interval):
 27            return Tone(ACCEPTED_TONES[(ACCEPTED_TONES.index(self.tone) + other.length) % len(ACCEPTED_TONES)])
 28
 29        raise TypeError("Invalid operation")
 30
 31    def __sub__(self, other):
 32        if isinstance(other, Tone):
 33            return Interval(abs(ACCEPTED_TONES.index(self.tone) - ACCEPTED_TONES.index(other.tone)))
 34
 35        if isinstance(other, Interval):
 36            return Tone(ACCEPTED_TONES[(ACCEPTED_TONES.index(self.tone) - other.length) % len(ACCEPTED_TONES)])
 37
 38        raise TypeError("Invalid operation")
 39
 40
 41class Interval:
 42
 43    def __init__(self, interval_length):
 44        self.length = interval_length % len(INTERVAL_VALUES)
 45
 46    def __str__(self):
 47        return INTERVAL_VALUES[self.length]
 48
 49    def __add__(self, other):
 50
 51        if isinstance(other, Interval):
 52            return Interval(self.length + other.length)
 53
 54        raise TypeError("Invalid operation")
 55
 56    def __neg__(self):
 57        return Interval(-self.length)
 58
 59
 60class Chord:
 61
 62    def __init__(self, root_tone, *other_tone_args):
 63
 64        self.root_tone = root_tone
 65        self.tone_set = set()
 66        self.tone_set.add(root_tone)
 67
 68        for arg in other_tone_args:
 69            if isinstance(arg, set):
 70                for tone in arg:
 71                    self.tone_set.add(tone)
 72            else:
 73                self.tone_set.add(arg)
 74
 75        if len(self.tone_set) < 2:
 76            raise TypeError("Cannot have a chord made of only 1 unique tone")
 77
 78    def __str__(self):
 79        list_of_tone_indexes = list(map(lambda x: ACCEPTED_TONES.index(x.tone), list(self.tone_set)))
 80        list_of_tone_indexes.sort()
 81
 82        root_tone_index = ACCEPTED_TONES.index(self.root_tone.tone)
 83
 84        tone_indexes_before_root = list(filter(lambda x: x < root_tone_index, list_of_tone_indexes))
 85
 86        for tone in tone_indexes_before_root:
 87            list_of_tone_indexes.remove(tone)
 88
 89        result = "-".join(list(map(lambda x: ACCEPTED_TONES[x], list_of_tone_indexes)) +
 90                          list(map(lambda x: ACCEPTED_TONES[x], tone_indexes_before_root)))
 91
 92        return result
 93
 94    def __add__(self, other):
 95
 96        if isinstance(other, Tone):
 97            return Chord(self.root_tone, self.tone_set, other)
 98
 99        if isinstance(other, Chord):
100            return Chord(self.root_tone, self.tone_set, other.tone_set)
101
102        raise TypeError("Invalid operation")
103
104    def find_next_tone(self, reference_tone, tone_set):
105
106        reference_tone_index = ACCEPTED_TONES.index(reference_tone.tone)
107
108        for i in range(reference_tone_index + 1, len(ACCEPTED_TONES)):
109            potential_tone = Tone(ACCEPTED_TONES[i])
110            if potential_tone in tone_set:
111                return potential_tone
112
113        for i in range(0, reference_tone_index):
114            potential_tone = Tone(ACCEPTED_TONES[i])
115            if potential_tone in tone_set:
116                return potential_tone
117
118    def __sub__(self, other):
119        if isinstance(other, Tone):
120            if other not in self.tone_set:
121                raise TypeError(f"Cannot remove tone {other} from chord {self}")
122
123            new_tone_set = self.tone_set.copy()
124            new_tone_set.remove(other)
125
126            if other == self.root_tone:
127                new_root_tone = self.find_next_tone(self.root_tone, self.tone_set)
128                return Chord(new_root_tone, new_tone_set)
129
130            return Chord(self.root_tone, new_tone_set)
131
132        raise TypeError("Invalid operation")
133
134    def is_minor(self):
135        minor_third_index = INTERVAL_VALUES.index("minor 3rd")
136        root_tone_index = ACCEPTED_TONES.index(self.root_tone.tone)
137
138        for tone in self.tone_set:
139            if abs(root_tone_index - ACCEPTED_TONES.index(tone.tone)) == minor_third_index:
140                return True
141
142        return False
143
144    def is_major(self):
145        minor_third_index = INTERVAL_VALUES.index("major 3rd")
146        root_tone_index = ACCEPTED_TONES.index(self.root_tone.tone)
147
148        for tone in self.tone_set:
149            if abs(root_tone_index - ACCEPTED_TONES.index(tone.tone)) == minor_third_index:
150                return True
151
152        return False
153
154    def is_power_chord(self):
155        return not self.is_minor() and not self.is_major()
156
157    def transposed(self, interval):
158        return Chord(self.root_tone + interval, set(map(lambda x: x + interval, list(self.tone_set))))