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