1class Tone:
  2    CHROMATIC_SCALE = {
  3        "C": 0,
  4        "C#": 1,
  5        "D": 2,
  6        "D#": 3,
  7        "E": 4,
  8        "F": 5,
  9        "F#": 6,
 10        "G": 7,
 11        "G#": 8,
 12        "A": 9,
 13        "A#": 10,
 14        "B": 11,
 15    }
 16
 17    def __init__(self, value):
 18        self.value = value
 19
 20    def __str__(self):
 21        return str(self.value)
 22
 23    # Need this functions because of the unique_tones set.
 24    def __eq__(self, other):
 25        return self.value == other.value
 26
 27    def __hash__(self):
 28        return hash(self.value)
 29
 30    @property
 31    def index(self):
 32        return Tone.CHROMATIC_SCALE[self.value]
 33
 34    @staticmethod
 35    def get_tone_by_index(index):
 36        """ Helper method to get tone name by index."""
 37        for tone, tone_index in Tone.CHROMATIC_SCALE.items():
 38            if tone_index == index:
 39                return tone
 40
 41    def __add__(self, other):
 42        if isinstance(other, Tone):
 43            """Add two tones."""
 44            return Chord(self, other)
 45        elif isinstance(other, Interval):
 46            """Add tone and interval."""
 47            new_index = (self.index + other.interval) % 12
 48            new_value = Tone.get_tone_by_index(new_index)
 49            return Tone(new_value)
 50
 51    def __sub__(self, other):
 52        if isinstance(other, Tone):
 53            """Subtract two tones."""
 54            semitone_diff = (self.index - other.index) % 12
 55            return Interval(semitone_diff)
 56        else:
 57            """Subtract tone and interval."""
 58            new_index = (self.index - other.interval) % 12
 59            new_value = Tone.get_tone_by_index(new_index)
 60            return Tone(new_value)
 61
 62    def __radd__(self, other):
 63        raise TypeError("Invalid operation")
 64
 65
 66class Interval:
 67    interval_names = {
 68        0: "unison",
 69        1: "minor 2nd",
 70        2: "major 2nd",
 71        3: "minor 3rd",
 72        4: "major 3rd",
 73        5: "perfect 4th",
 74        6: "diminished 5th",
 75        7: "perfect 5th",
 76        8: "minor 6th",
 77        9: "major 6th",
 78        10: "minor 7th",
 79        11: "major 7th"
 80    }
 81
 82    def __init__(self, interval):
 83        self.interval = interval % 12
 84        # Divide the integer by 12 because I want to have a valid output also by 13 for example as given in the rule.
 85        self.name = Interval.interval_names[self.interval]
 86
 87    def __str__(self):
 88        return str(self.name)
 89
 90    def __add__(self, other):
 91        new_interval = (self.interval + other.interval) % 12
 92        return Interval(new_interval)
 93
 94    def __neg__(self):
 95        """Enable unary negation of Interval."""
 96        return Interval(-self.interval)
 97
 98
 99class Chord:
100    minor_third_interval = 3
101    major_third_interval = 4
102
103    def __init__(self, root, *tones):
104        self.root = root
105        unique_tones = {tone for tone in tones if tone != root}
106        " So we solve the problem when one of the tones is equal to root."
107
108        if len(unique_tones) < 1:
109            raise TypeError("Cannot have a chord made of only 1 unique tone")
110
111        self.tones = [self.root] + sorted(unique_tones, key=lambda tone: (tone.index - self.root.index) % 12)
112
113    def __str__(self):
114        return "-".join(str(tone) for tone in self.tones)
115
116    def is_minor(self):
117        root_index = self.root.index
118        for tone in self.tones[1:]:  # Skip the root
119            if (tone.index - root_index) % 12 == self.minor_third_interval:
120                return True
121        return False
122
123    def is_major(self):
124        root_index = self.root.index
125        for tone in self.tones[1:]:
126            if (tone.index - root_index) % 12 == self.major_third_interval:
127                return True
128        return False
129
130    def is_power_chord(self):
131        return not self.is_minor() and not self.is_major()
132
133    def __add__(self, other):
134        if isinstance(other, Tone):
135            new_tones = list(self.tones)
136            new_tones.append(other)
137            return Chord(self.root, *new_tones)
138        else:
139            combined_tones = {tone for tone in self.tones}
140            combined_tones.update(other.tones)
141            return Chord(self.root, *combined_tones)
142
143    def __sub__(self, other):
144        if other not in self.tones:
145            raise TypeError(f"Cannot remove tone {other} from chord {self}")
146
147        new_unique_tones = {tone for tone in self.tones if tone != other}
148
149        if len(new_unique_tones) < 2:
150            raise TypeError("Cannot have a chord made of only 1 unique tone")
151
152        return Chord(self.root, *new_unique_tones)
153
154    def transposed(self, interval):
155        transposed_tones = [tone + interval for tone in self.tones]
156        return Chord(transposed_tones[0], *transposed_tones[1:])