1ALL_VALID_TONES = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
  2ALL_VALID_INTERVALS = ["unison", "minor 2nd", "major 2nd", "minor 3rd", "major 3rd", "perfect 4th", "diminished 5th", "perfect 5th", "minor 6th", "major 6th", "minor 7th", "major 7th"]
  3NUMBER_OF_INTERVALS = 12
  4NUMBER_FOR_MINOR_3RD = 3
  5NUMBER_FOR_MAJOR_3RD = 4
  6
  7class Tone:
  8    def __init__(self, tone):
  9        if tone in ALL_VALID_TONES:
 10            self.name = tone
 11            self.index = ALL_VALID_TONES.index(tone)
 12        else:
 13            raise Exception("Invalid input.")
 14
 15    def __str__(self):
 16        return self.name
 17
 18    def __add__(self, other):
 19        if isinstance(other, Tone):
 20            return Chord(self, other)
 21        elif isinstance(other, Interval):
 22            index_of_new_tone = (self.index + other.interval_number) % 12
 23            return Tone(ALL_VALID_TONES[index_of_new_tone])
 24
 25    def __sub__(self, other):
 26        if isinstance(other, Tone):
 27            index_of_first_tone = self.index
 28            index_of_second_tone = other.index
 29            return Interval(index_of_first_tone - index_of_second_tone)
 30        elif isinstance(other, Interval):
 31            index_of_new_tone = self.index - other.interval_number
 32            return Tone(ALL_VALID_TONES[index_of_new_tone])
 33
 34
 35class Interval:
 36    def __init__(self, number):
 37        number %= NUMBER_OF_INTERVALS
 38        self.interval_number = number
 39        self.interval_name = ALL_VALID_INTERVALS[number]
 40
 41    def __str__(self):
 42        return self.interval_name
 43
 44    def __add__(self, other):
 45        if isinstance(other, Tone):
 46            raise TypeError("Invalid operation")
 47        elif isinstance(other, Interval):
 48            return Interval(self.interval_number + other.interval_number)
 49
 50    def __sub__(self, other):
 51        if isinstance(other, Tone):
 52            raise TypeError("Invalid operation")
 53
 54    def __neg__(self):
 55        return Interval(-self.interval_number)
 56
 57
 58class Chord:
 59    def __init__(self, root, *args):
 60        self.unique_tone_names = {root.name}
 61        self.tones = [root]
 62        self.root = root
 63        for tone in args:
 64            if tone.name not in self.unique_tone_names:
 65                self.tones.append(tone)
 66                self.unique_tone_names.add(tone.name)
 67        if len(self.tones) == 1:
 68            raise TypeError("Cannot have a chord made of only 1 unique tone")
 69        root_num = ALL_VALID_TONES.index(str(root))
 70        self.sorted_tones = sorted(self.tones, key= lambda tone: (ALL_VALID_TONES.index(str(tone)) - root_num) % 12)
 71
 72    def __str__(self):
 73        return "-".join(str(tone) for tone in self.sorted_tones)
 74
 75    def is_minor(self):
 76        for tone in self.sorted_tones:
 77            difference = ALL_VALID_TONES.index((str(tone))) - ALL_VALID_TONES.index((str(self.root)))
 78            if difference < 0:
 79                difference += NUMBER_OF_INTERVALS
 80            if difference == NUMBER_FOR_MINOR_3RD:
 81                return True
 82        return False
 83
 84    def is_major(self):
 85        for tone in self.sorted_tones:
 86            difference = ALL_VALID_TONES.index((str(tone))) - ALL_VALID_TONES.index((str(self.root)))
 87            if difference < 0:
 88                difference += NUMBER_OF_INTERVALS
 89            if difference == NUMBER_FOR_MAJOR_3RD:
 90                return True
 91        return False
 92
 93    def is_power_chord(self):
 94        if self.is_minor() == True or self.is_major() == True:
 95            return False
 96        return True
 97
 98    def __add__(self, other):
 99        if isinstance(other, Tone):
100            return Chord(*self.tones, other)
101        if isinstance(other, Chord):
102            tones_for_new_chord = self.sorted_tones
103            for tone in other.sorted_tones:
104                if not tone in tones_for_new_chord:
105                    tones_for_new_chord.append(tone)
106            return Chord(*tones_for_new_chord)
107
108    def __sub__(self, other):
109        if isinstance(other, Tone):
110            if other.name not in self.unique_tone_names:
111                raise TypeError(f"Cannot remove tone {other.name} from chord {str(self)}")
112            elif len(self.sorted_tones) - 1 == 1:
113                raise TypeError("Cannot have a chord made of only 1 unique tone")
114            else:
115                tones_for_new_chord = list()
116                for tone in self.sorted_tones:
117                    if not tone.name == other.name:
118                        tones_for_new_chord.append(tone)
119                return Chord(*tones_for_new_chord)
120
121    def transposed(self, interval):
122        tones_in_new_chord = list()
123        if interval.interval_number >= 0:
124            for tone in self.sorted_tones:
125                tones_in_new_chord.append(tone + interval)
126            return Chord(*tones_in_new_chord)
127        else:
128            for tone in self.sorted_tones:
129                tones_in_new_chord.append(tone - interval)
130            return Chord(*tones_in_new_chord)