1class Tone:
  2    TONES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  3
  4    def __init__(self, name):
  5        if name not in self.TONES:
  6            raise ValueError(f"Invalid tone name: {name}")
  7        self.name = name
  8
  9    def __str__(self):
 10        return self.name
 11
 12    def __add__(self, other):
 13        if isinstance(other, Tone):
 14            return Chord(self, other)
 15
 16        elif isinstance(other, Interval):
 17
 18            curr_index = self.TONES.index(self.name)
 19            new_index = (curr_index + other.semitones) % 12
 20            new_name = self.TONES[new_index]
 21            return Tone(new_name)
 22        else:
 23            raise TypeError("Invalid operation")
 24
 25    def __sub__(self, other):
 26        if isinstance(other, Tone):
 27            curr_index = self.TONES.index(self.name)
 28            other_index = other.TONES.index(other.name)
 29            semitones = (curr_index - other_index) % 12
 30            return Interval(semitones)
 31
 32        elif isinstance(other, Interval):
 33            curr_index = self.TONES.index(self.name)
 34            new_index = (curr_index - other.semitones) % 12
 35            new_name = self.TONES[new_index]
 36            return Tone(new_name)
 37
 38        else:
 39            raise TypeError("Invalid operation")
 40
 41    def __eq__(self, other):
 42
 43        return isinstance(other, Tone) and self.name == other.name
 44
 45    def __ne__(self, other):
 46        return not self.__eq__(other)
 47
 48
 49class Interval:
 50    INTERVALS = [
 51        "unison", "minor 2nd", "major 2nd", "minor 3rd",
 52        "major 3rd", "perfect 4th", "diminished 5th",
 53        "perfect 5th", "minor 6th", "major 6th",
 54        "minor 7th", "major 7th"
 55    ]
 56
 57    def __init__(self, number_of_semitones):
 58        if isinstance(number_of_semitones, int):
 59            self.semitones = number_of_semitones % 12
 60        else:
 61            raise ValueError(f"Invalid number of semitones")
 62
 63    def __str__(self):
 64        return self.INTERVALS[self.semitones]
 65
 66    def __add__(self, other):
 67        if isinstance(other, Interval):
 68            return Interval(self.semitones + other.semitones)
 69        raise TypeError("Invalid operation")
 70
 71    def __neg__(self):
 72        return Interval(-self.semitones)
 73
 74
 75class Chord:
 76    def __init__(self, root, *args):
 77        if isinstance(root, Tone):
 78            for tone in args:
 79                if not isinstance(tone, Tone):
 80                    raise ValueError("All arguments must of type Tone")
 81            self.root = root
 82            self.tones = []
 83            self.tones.append(root)
 84            for tone in args:
 85                if tone not in self.tones:
 86                    self.tones.append(tone)
 87        else:
 88            raise ValueError("Root must be type Tone")
 89
 90        if len(self.tones) < 2:
 91            raise TypeError("Cannot have a chord made of only 1 unique tone")
 92
 93    def __str__(self):
 94
 95        tones_no_root = [tone for tone in self.tones if tone != self.root]
 96        root_index = Tone.TONES.index(self.root.name)
 97
 98        def tone_sort_key(tone):
 99            cur_index = Tone.TONES.index(tone.name)
100            return (cur_index - root_index) % 12
101
102        sorted_tones = [self.root] + sorted(tones_no_root, key=tone_sort_key)
103        return '-'.join(str(tone) for tone in sorted_tones)
104
105    def is_minor(self):
106        root_index = Tone.TONES.index(self.root.name)
107        for tone in self.tones:
108            if tone == self.root:
109                continue
110            cur_index = Tone.TONES.index(tone.name)
111            interval = (cur_index - root_index) % 12
112            if interval == 3:
113                return True
114        return False
115
116    def is_major(self):
117        root_index = Tone.TONES.index(self.root.name)
118        for tone in self.tones:
119            if tone == self.root:
120                continue
121            cur_index = Tone.TONES.index(tone.name)
122            interval = (cur_index - root_index) % 12
123            if interval == 4:
124                return True
125        return False
126
127    def is_power_chord(self):
128        return not self.is_minor() and not self.is_major()
129
130    def __add__(self, other):
131        if isinstance(other, Tone):
132            new_tones = self.tones.copy()
133            if other not in new_tones:
134                new_tones.append(other)
135            return Chord(self.root, *[tone for tone in new_tones if tone != self.root])
136        elif isinstance(other, Chord):
137            new_tones = list(self.tones)
138            for tone in other.tones:
139                if tone not in self.tones:
140                    new_tones.append(tone)
141            return Chord(self.root, *[tone for tone in new_tones if tone != self.root])
142        else:
143            raise TypeError("Invalid operation")
144
145    def __sub__(self, other):
146        if isinstance(other, Tone):
147            if other not in self.tones:
148                raise TypeError(f"Cannot remove tone {other} from chord {self}")
149            if other == self.root:
150                raise TypeError(f"Cannot remove tone {other} from chord {self}")
151            new_tones = [tone for tone in self.tones if tone != other]
152            if len(new_tones) <= 1:
153                raise TypeError("Cannot have a chord made of only 1 unique tone")
154            return Chord(self.root, *[tone for tone in new_tones if tone != self.root])
155        else:
156            raise TypeError("Invalid operation")
157
158    def transposed(self, interval):
159        if not isinstance(interval, Interval):
160            raise TypeError("Interval expected")
161        new_tones = []
162        root_index = Tone.TONES.index(self.root.name)
163        for tone in self.tones:
164            cur_index = Tone.TONES.index(tone.name)
165            new_index = (cur_index + interval.semitones) % 12
166            new_name = Tone.TONES[new_index]
167            new_tone = Tone(new_name)
168            if new_tone not in new_tones:
169                new_tones.append(new_tone)
170        new_root_index = (root_index + interval.semitones) % 12
171        new_root_name = Tone.TONES[new_root_index]
172        new_root = Tone(new_root_name)
173        return Chord(new_root, *[tone for tone in new_tones if tone != new_root])