1TONES = ('C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B')
  2INTERVAL_NAMES = ('unison', 'minor 2nd', 'major 2nd', 'minor 3rd', 'major 3rd', 'perfect 4th', 'diminished 5th', 'perfect 5th', 'minor 6th', 'major 6th', 'minor 7th', 'major 7th')
  3tone_to_index = {tone: index for index, tone in enumerate(TONES)}
  4index_to_tone = {index: tone for index, tone in enumerate(TONES)}
  5
  6
  7class Tone:
  8    def __init__(self, name):
  9        if name not in tone_to_index:
 10            raise ValueError(f"Invalid tone name: {name}")
 11        self.name = name
 12        self.index = tone_to_index[name]
 13
 14    def __str__(self):
 15        return self.name
 16
 17    def __eq__(self, other):
 18        return isinstance(other, Tone) and self.index == other.index
 19
 20    def __hash__(self): # We need it for sorting
 21        return hash(self.index)
 22
 23    def __add__(self, other):
 24        if isinstance(other, Tone):
 25            return Chord(self, other)
 26        elif isinstance(other, Interval):
 27            new_index = (self.index + other.semitones) % 12
 28            new_name = index_to_tone[new_index]
 29            return Tone(new_name)
 30        else:
 31            raise TypeError("Invalid operation")
 32
 33    def __sub__(self, other):
 34        if isinstance(other, Tone):
 35            semitones = (self.index - other.index) % 12
 36            return Interval(semitones)
 37        elif isinstance(other, Interval):
 38            new_index = (self.index - other.semitones) % 12
 39            new_name = index_to_tone[new_index]
 40            return Tone(new_name)
 41        else:
 42            raise TypeError("Invalid operation")
 43
 44
 45class Interval:
 46    def __init__(self, semitones):
 47        self.semitones = semitones
 48
 49    def __str__(self):
 50        semitones_mod = self.semitones % 12
 51        name = INTERVAL_NAMES[semitones_mod]
 52        return name
 53
 54    def __add__(self, other):
 55        if isinstance(other, Interval):
 56            total_semitones = self.semitones + other.semitones
 57            return Interval(total_semitones)
 58        else:
 59            raise TypeError("Invalid operation")
 60
 61    def __neg__(self):
 62        # need it for a_sharp_minor_chord = d_minor_chord.transposed(-Interval(4)) case
 63        return Interval(-self.semitones)
 64
 65
 66class Chord:
 67    def __init__(self, root, *tones):
 68        if not isinstance(root, Tone):
 69            raise TypeError("Root must be a Tone")
 70        self.root = root
 71        all_tones = {root}
 72        for tone in tones:
 73            if not isinstance(tone, Tone):
 74                raise TypeError("All tones must be Tone instances")
 75            all_tones.add(tone)
 76        if len(all_tones) < 2:
 77            raise TypeError("Cannot have a chord made of only 1 unique tone")
 78        self.tones = all_tones
 79
 80    def sort_tone(self, tone):
 81        if tone.index >= self.root.index:
 82            return tone.index - self.root.index
 83
 84        return tone.index + (12 - self.root.index)
 85
 86    def __str__(self):
 87        tones_copy = self.tones.copy()
 88        tones_copy.remove(self.root)
 89        sorted_tones = sorted(tones_copy, key=self.sort_tone)
 90
 91        sorted_tones = [self.root] + list(sorted_tones)
 92        return '-'.join(str(tone) for tone in sorted_tones)
 93
 94    def is_minor(self):
 95        for tone in self.tones:
 96            if tone == self.root:
 97                continue
 98            interval = (tone.index - self.root.index) % 12
 99            if interval == 3:
100                return True
101        return False
102
103    def is_major(self):
104        for tone in self.tones:
105            if tone == self.root:
106                continue
107            interval = (tone.index - self.root.index) % 12
108            if interval == 4:
109                return True
110        return False
111
112    def is_power_chord(self):
113        return not self.is_minor() and not self.is_major()
114
115    def __add__(self, other):
116        if isinstance(other, Tone):
117            new_tones = self.tones.copy()
118            new_tones.add(other)
119            return Chord(self.root, *(new_tones - {self.root}))
120        elif isinstance(other, Chord):
121            new_tones = self.tones.union(other.tones)
122            return Chord(self.root, *(new_tones - {self.root}))
123        else:
124            raise TypeError("Invalid operation")
125
126    def __sub__(self, other):
127        if not isinstance(other, Tone):
128            raise TypeError("Invalid operation")
129        if other not in self.tones:
130            raise TypeError(f"Cannot remove tone {other} from chord {self}")
131        new_tones = self.tones.copy()
132        new_tones.remove(other)
133        if len(new_tones) < 2:
134            raise TypeError("Cannot have a chord made of only 1 unique tone")
135        new_root = self.root
136        if other == self.root:
137            new_root = next(iter(new_tones))
138            new_tones.remove(new_root)
139
140        return Chord(new_root, *(new_tones - {self.root}))
141
142    def transposed(self, interval):
143        if not isinstance(interval, Interval):
144            raise TypeError("Interval must be an Interval instance")
145        semitones = interval.semitones
146        new_tones = set()
147        for tone in self.tones:
148            new_index = (tone.index + semitones) % 12
149            new_tone = Tone(index_to_tone[new_index])
150            new_tones.add(new_tone)
151        new_root_index = (self.root.index + semitones) % 12
152        new_root = Tone(index_to_tone[new_root_index])
153        return Chord(new_root, *(new_tones - {new_root}))