1class Tone:
  2    """Describe the concept of musical tone."""
  3
  4    ORDER = ('C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B')
  5    ALL_TONES = len(ORDER)
  6
  7    def __init__(self, name):
  8        self.name = name
  9
 10    def __str__(self):
 11        return self.name
 12
 13    def index(self):
 14        """Return the index of the name in tone order"""
 15        return Tone.ORDER.index(self.name)
 16    
 17    def __add__(self, other):
 18        if isinstance(other, Tone):
 19            return Chord(self, other)
 20        elif isinstance(other, Interval):
 21            semitones = Tone.ORDER.index(self.name) + other.number_of_semitones
 22            while semitones >= self.ALL_TONES:
 23                semitones -= self.ALL_TONES
 24            return Tone(self.ORDER[semitones])
 25        
 26    def __sub__(self, other):
 27        if isinstance(other, Tone):
 28            return Interval.from_tones(self, other)
 29        elif isinstance(other, Interval):
 30            semitones = Tone.ORDER.index(self.name) - other.number_of_semitones
 31            while semitones < 0:
 32                semitones += self.ALL_TONES
 33            return Tone(self.ORDER[semitones])
 34
 35
 36class Interval:
 37    """Describe the concept of an interval"""
 38
 39    @staticmethod
 40    def interval_name(number_of_semitones):
 41        """Return the name relative to the number of semitones in the interval"""
 42        names_of_intervals = ('unison', 'minor 2nd', 'major 2nd', 'minor 3rd', 'major 3rd', 'perfect 4th', 
 43                              'diminished 5th', 'perfect 5th', 'minor 6th', 'major 6th', 'minor 7th', 'major 7th')
 44        return names_of_intervals[number_of_semitones]
 45        
 46    def __init__(self, number_of_semitones):
 47        while number_of_semitones >= Tone.ALL_TONES:
 48            number_of_semitones -= Tone.ALL_TONES
 49        while number_of_semitones < 0:
 50            number_of_semitones += Tone.ALL_TONES
 51        self.name = Interval.interval_name(number_of_semitones)
 52        self.number_of_semitones = number_of_semitones
 53        self.operator = True #True for +, False for -, used for add and substract
 54
 55    def __str__(self):
 56        return self.name
 57    
 58    def __neg__(self):
 59        self.operator = False
 60        return self
 61    
 62    @classmethod
 63    def from_tones(cls, first, second):
 64        """Return a new interval by two given tones"""
 65        if first.index() >= second.index():
 66            return Interval(first.index() - second.index())
 67        else:
 68            return Interval(second.index() - first.index())
 69        
 70    def __add__(self, other):
 71        if isinstance(other, Tone):
 72            raise TypeError("Invalid operation")
 73        elif isinstance(other, Interval):
 74            semitones = self.number_of_semitones + other.number_of_semitones
 75            return Interval(semitones)
 76
 77    def __sub__(self, other):
 78        if isinstance(other, Tone):
 79            raise TypeError("Invalid operation")
 80            
 81
 82class Chord:
 83    """Describe the concept of a chord"""
 84
 85    @staticmethod
 86    def validate_chord(tones):
 87        """Check if a chord is valid - long enough to be a chord"""
 88        if len(set(tones)) < 2:
 89            raise TypeError("Cannot have a chord made of only 1 unique tone")
 90
 91    @staticmethod
 92    def ordered_name(root, tones):
 93        """Return the sorted name of the chord by the tones associated with - in between"""
 94        start_index = Tone.ORDER.index(root)
 95        custom_order = Tone.ORDER[start_index:] + Tone.ORDER[:start_index]
 96        unique_tones = list(set(tones))
 97        if root in unique_tones:
 98            unique_tones.remove(root)
 99        ordered_tones = sorted(unique_tones, key=lambda tone: custom_order.index(tone))
100        chord_name = root + '-' + '-'.join(tone for tone in ordered_tones)
101        return chord_name
102    
103    def __init__(self, root, *args):
104        self.root = root
105        self.other_tones = list(args)
106        self.other_tones_names = [str(tone) for tone in args]
107        Chord.validate_chord([str(self.root)] + self.other_tones_names)
108        self.chord_name = Chord.ordered_name(str(self.root), self.other_tones_names)
109
110    def __str__(self):
111        return self.chord_name
112    
113    def is_minor(self):
114        """Check if the chord is minor"""
115        for second_tone in self.other_tones:
116            if str(Interval.from_tones(self.root, second_tone)) == 'minor 3rd':
117                return True
118        return False
119    
120    def is_major(self):
121        """Check if the chord is major"""
122        for second_tone in self.other_tones:
123            if str(Interval.from_tones(self.root, second_tone)) == 'major 3rd':
124                return True
125        return False
126    
127    def is_power_chord(self):
128        """Check if the chord is power chord"""
129        return not self.is_minor() and not self.is_major()
130    
131    def __add__(self, other):
132        if isinstance(other, Tone):
133            tones = self.other_tones
134            tones.append(other)
135            return Chord(self.root, *tones)
136        elif isinstance(other, Chord):
137            new_root = self.root
138            new_tones = self.other_tones + [other.root] + other.other_tones
139            return Chord(new_root, *new_tones)
140
141    def __sub__(self, other):
142        if other.name != self.root.name and other.name not in self.other_tones_names:
143            raise TypeError(f"Cannot remove tone {str(other)} from chord {str(self)}")
144        elif len(self.other_tones) < 2:
145            raise TypeError("Cannot have a chord made of only 1 unique tone")
146        elif other.name is self.root.name:
147            new_root = self.other_tones_names[1]
148            new_tones = [tone for tone in self.other_tones if tone.name != new_root.name]
149            return Chord(new_root, *new_tones)
150        else:
151            new_tones = [tone for tone in self.other_tones if tone.name != other.name]
152            return Chord(self.root, *new_tones)
153        
154    def transposed(self, interval):
155        """Transpose a chord - shift each of its tones by the same interval"""
156        new_root = self.root
157        new_tones = []
158        if interval.operator:
159            new_root += interval
160            for tone in self.other_tones:
161                new_tones.append(tone+interval)
162        else:
163            new_root -= interval
164            for tone in self.other_tones:
165                new_tones.append(tone-interval)
166        return Chord(new_root, *new_tones)