1class Tone:
  2    TONES_SCALE = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  3
  4    def __init__(self, tone):
  5        self.tone = tone
  6    
  7    def __str__(self):
  8        return self.tone
  9    
 10    def __add__(self, other):
 11        if isinstance(other, Tone):
 12            return Chord(self, other)
 13        elif isinstance(other, Interval):
 14            start_index = self.TONES_SCALE.index(self.tone)
 15            new_index = (start_index + other.number_of_semitones) % 12
 16            
 17            return Tone(self.TONES_SCALE[new_index])
 18                
 19    def __sub__(self, other):
 20        if isinstance(other, Tone):
 21            self_index = self.TONES_SCALE.index(self.tone)
 22            other_index = self.TONES_SCALE.index(other.tone)
 23            
 24            semitones_count = (self_index - other_index) % 12
 25            
 26            return Interval(semitones_count)
 27        elif isinstance(other, Interval):
 28            start_index = self.TONES_SCALE.index(self.tone)
 29            new_index = (start_index - other.number_of_semitones) % 12
 30            
 31            return Tone(self.TONES_SCALE[new_index])
 32
 33
 34class Interval:
 35    def __init__(self, number_of_semitones):
 36        self.number_of_semitones = number_of_semitones
 37        self.is_positive_direction = True
 38        
 39    def __str__(self):
 40        self.number_of_semitones %= 12
 41        
 42        intervals = (
 43            'unison', 'minor 2nd', 'major 2nd', 'minor 3rd',
 44            'major 3rd', 'perfect 4th', 'diminished 5th', 'perfect 5th',
 45            'minor 6th', 'major 6th', 'minor 7th', 'major 7th'
 46        )
 47        
 48        return intervals[self.number_of_semitones]
 49    
 50    def __add__(self, other):
 51        if isinstance(other, Tone):
 52            raise TypeError("Invalid operation")
 53        elif isinstance(other, Interval):
 54            return Interval(self.number_of_semitones + other.number_of_semitones)
 55    
 56    def __sub__(self, other):
 57        if isinstance(other, Tone):
 58            raise TypeError("Invalid operation")
 59
 60    def __neg__(self):
 61        neg_interval = Interval(self.number_of_semitones)
 62        neg_interval.is_positive_direction = not self.is_positive_direction
 63        return neg_interval
 64
 65
 66class Chord:
 67    TONES_SCALE = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
 68
 69    def __init__(self, first_tone, *args, **kwargs):
 70        all_tones = [str(first_tone)] + [str(tone) for tone in args] + [str(tone) for tone in kwargs.values()]
 71        self.chord = []
 72        
 73        for tone in all_tones:
 74            if tone not in self.chord:
 75                self.chord.append(tone)
 76
 77        if len(self.chord) == 1:
 78            raise TypeError("Cannot have a chord made of only 1 unique tone")
 79
 80        self.root = self.chord[0]
 81        
 82    def __str__(self):
 83        root_index = self.TONES_SCALE.index(self.root)
 84        
 85        #Order the other tones based on the root.
 86        sorted_tones = sorted(self.chord, key=lambda tone: (self.TONES_SCALE.index(tone) - root_index) % 12)
 87        
 88        return "-".join(sorted_tones)
 89    
 90    def __add__(self, other):
 91        if isinstance(other, Tone):
 92            new_tones = self.chord[:]
 93            new_tones.append(other.tone)
 94            return Chord(self.root, *new_tones)
 95        elif isinstance(other, Chord):
 96            return Chord(self.root, *self.chord, *other.chord)
 97            
 98    def __sub__(self, other):
 99        if isinstance(other, Tone):
100            curr_tones = list(self.chord)
101            
102            if other.tone in curr_tones:
103                    curr_tones.remove(other.tone)
104                    self.root = curr_tones[0]
105            else:
106                raise TypeError(f"Cannot remove tone {str(other)} from chord {str(self)}")
107                
108            if len(curr_tones) >= 2:
109                return Chord(self.root, *curr_tones)
110            else:
111                raise TypeError("Cannot have a chord made of only 1 unique tone")
112        
113    def _has_interval(self, interval):
114        """ A private helper method to check if any tone forms a specific interval with the root. """
115        
116        root_index = self.TONES_SCALE.index(self.root)
117        
118        for tone in self.chord[1:]:
119            tone_index = self.TONES_SCALE.index(tone)
120            curr_interval = (tone_index - root_index) % 12
121            
122            if curr_interval == interval:
123                return True
124        return False
125    
126    def is_minor(self):
127       return self._has_interval(3)
128       
129    def is_major(self):
130        return self._has_interval(4)
131
132    def is_power_chord(self):
133        return not self.is_minor() and not self.is_major()
134
135    def transposed(self, interval):
136        if isinstance(interval, Interval):
137            transposed_tones = []
138            
139            for tone in self.chord:
140                curr_index = self.TONES_SCALE.index(tone)
141
142                if interval.is_positive_direction:
143                    new_index = (curr_index + interval.number_of_semitones) % 12
144                else:
145                    new_index = (curr_index - interval.number_of_semitones) % 12
146                transposed_tones.append(self.TONES_SCALE[new_index])
147            
148            return Chord(transposed_tones[0], *transposed_tones[1:])