1DEFINED_TONES = (
  2    "C", "C#", "D", "D#", "E", "F",
  3    "F#", "G", "G#", "A", "A#", "B"
  4    )
  5DEFINED_INTERVALS = (
  6    "unison", "minor 2nd", "major 2nd",
  7    "minor 3rd", "major 3rd", "perfect 4th",
  8    "diminished 5th", "perfect 5th", "minor 6th",
  9    "major 6th", "minor 7th", "major 7th"
 10    )
 11TOTAL_TONES_COUNT = 12
 12
 13
 14class Tone:
 15
 16    def __init__(self, note):
 17        self.note = note
 18    
 19    def __str__(self):
 20        return self.note
 21       
 22    def __add__(self, other):
 23        if isinstance(other, Tone):
 24            return Chord(self, other)
 25        elif isinstance(other, Interval):
 26            note_idx = (DEFINED_TONES.index(self.note) 
 27                        + other.number_of_semitones)
 28            return Tone(DEFINED_TONES[note_idx % TOTAL_TONES_COUNT])
 29        
 30    def __sub__(self, other):
 31        if isinstance(other, Tone):
 32            return Interval(DEFINED_TONES.index(self.note) 
 33                            - DEFINED_TONES.index(other.note))
 34        elif isinstance(other, Interval):
 35            note_idx = (DEFINED_TONES.index(self.note) 
 36                        - other.number_of_semitones)
 37            return Tone(DEFINED_TONES[note_idx % TOTAL_TONES_COUNT])
 38
 39    def __eq__(self, value):
 40        return self.note == value.note
 41        
 42
 43class Interval:
 44
 45    def __init__(self, number_of_semitones):
 46        self.number_of_semitones = number_of_semitones % TOTAL_TONES_COUNT
 47        self.semitone = DEFINED_INTERVALS[self.number_of_semitones]
 48    
 49    def __str__(self):
 50        return self.semitone
 51    
 52    def __add__(self, other):
 53        if isinstance(other, Interval):
 54            return Interval(self.number_of_semitones 
 55                            + other.number_of_semitones)
 56        elif isinstance(other, Tone):
 57            raise TypeError("Invalid operation")
 58    
 59    def __sub__(self, other):
 60        if isinstance(other, Tone):
 61            raise TypeError("Invalid operation")
 62    
 63    def __neg__(self):
 64        return Interval(-self.number_of_semitones)
 65
 66    
 67class Chord:
 68
 69    def __init__(self, root, *tones):
 70        self.root = root
 71        self.secondary_tones = []
 72        for tone in tones:
 73            if tone not in self.secondary_tones:
 74                self.secondary_tones.append(tone)        
 75        if root in self.secondary_tones:
 76            self.secondary_tones.remove(root)
 77        if not self.secondary_tones:
 78            raise TypeError("Cannot have a chord made of only 1 unique tone")
 79        self.secondary_tones.sort(key=lambda x: DEFINED_TONES.index(x.note))
 80
 81    def __str__(self):
 82        tones_concat = "-".join(tone.note for tone in self.secondary_tones)
 83        return f"{str(self.root)}-{tones_concat}"
 84    
 85    def __add__(self, other):
 86        if isinstance(other, Tone):
 87            return Chord(self.root,
 88                         *self.secondary_tones,
 89                         other)
 90        elif isinstance(other, Chord):
 91            return Chord(self.root,
 92                         *self.secondary_tones,
 93                         other.root,
 94                         *other.secondary_tones)
 95    
 96    def __sub__(self, other):
 97        if not isinstance(other, Tone):
 98            return
 99        if (other not in self.secondary_tones and 
100            not (other == self.root)):
101            raise TypeError(
102                f"Cannot remove tone {str(other)} from chord {str(self)}"
103                )
104        if other == self.root:
105            return Chord(self.secondary_tones[0],
106                         *self.secondary_tones[1:])
107        else:
108            modified_secondary_tones = self.secondary_tones[:]
109            modified_secondary_tones.remove(other)
110            return Chord(self.root,
111                         *modified_secondary_tones)
112
113    def transposed(self, interval):
114        modified_secondary_tones = [
115            (tone + interval) for tone in self.secondary_tones
116            ]
117        return Chord(self.root + interval, *modified_secondary_tones)
118
119    def is_minor(self):
120        root_idx = DEFINED_TONES.index(self.root.note)
121        minor_3rd_diff = DEFINED_INTERVALS.index("minor 3rd")
122        for tone in self.secondary_tones:
123            tone_idx = DEFINED_TONES.index(tone.note)
124            if abs(root_idx - tone_idx) == minor_3rd_diff:
125                return True
126        return False
127
128    def is_major(self):
129        root_idx = DEFINED_TONES.index(self.root.note)
130        major_3rd_diff = DEFINED_INTERVALS.index("major 3rd")
131        for tone in self.secondary_tones:
132            tone_idx = DEFINED_TONES.index(tone.note)
133            if abs(root_idx - tone_idx) == major_3rd_diff:
134                return True
135        return False
136
137    def is_power_chord(self):
138        return not (self.is_major() or self.is_minor())