1ALLOWED_TONE_NAMES = [
  2    "A", "A#",
  3    "B",
  4    "C", "C#",
  5    "D", "D#",
  6    "E",
  7    "F", "F#",
  8    "G", "G#",
  9]
 10
 11SEMITONE_REPRESENTATION = [
 12    "unison",
 13    "minor 2nd",
 14    "major 2nd",
 15    "minor 3rd",
 16    "major 3rd",
 17    "perfect 4th",
 18    "diminished 5th",
 19    "perfect 5th",
 20    "minor 6th",
 21    "major 6th",
 22    "minor 7th",
 23    "major 7th",
 24]
 25
 26
 27class Tone:
 28    def __init__(self, name):
 29        if name not in ALLOWED_TONE_NAMES:
 30            raise ValueError("Name should be a valid tone.")
 31
 32        self.__name = name
 33
 34    def __str__(self):
 35        return self.__name
 36    
 37    def __eq__(self, other):
 38        if not isinstance(other, Tone):
 39            raise TypeError("Incompatible types. Tone object should be compared only to Tone object.")
 40        
 41        return str(self) == str(other)
 42
 43    def __ne__(self, other):
 44        return not self.__eq__(other)
 45    
 46    def __hash__(self):
 47        return hash(self.__name)
 48    
 49    def __add__(self, other):
 50        if isinstance(other, Tone):
 51            return Chord(self, other)
 52        elif isinstance(other, Interval):
 53            tone_index = ALLOWED_TONE_NAMES.index(str(self))
 54            new_tone_index = tone_index + other.semitone_number
 55
 56            new_tone_name = ALLOWED_TONE_NAMES[new_tone_index % len(ALLOWED_TONE_NAMES)]
 57
 58            return Tone(new_tone_name)
 59        
 60        raise TypeError("Incompatible types. Tone object should be added up only with Tone or Interval objects.")
 61        
 62    
 63    def __sub__(self, other):
 64        if isinstance(other, Tone):
 65            tone_index = ALLOWED_TONE_NAMES.index(str(self))
 66            other_tone_index = ALLOWED_TONE_NAMES.index(str(other))
 67            
 68            diff = abs(tone_index - other_tone_index)
 69
 70            return Interval(diff)
 71        elif isinstance(other, Interval):
 72            tone_index = ALLOWED_TONE_NAMES.index(str(self))
 73            new_tone_index = tone_index - other.semitone_number
 74
 75            new_tone_name = ALLOWED_TONE_NAMES[new_tone_index % len(ALLOWED_TONE_NAMES)]
 76
 77            return Tone(new_tone_name)
 78        
 79        raise TypeError("Incompatible types. Tone object should be subtracted only by Tone object.")
 80
 81
 82class Interval:
 83    def __init__(self, semitone_number):
 84        self.__semitone_number = semitone_number
 85
 86    def __str__(self):
 87        return SEMITONE_REPRESENTATION[self.__semitone_number % len(SEMITONE_REPRESENTATION)]
 88    
 89    def __add__(self, other):
 90        if isinstance(other, Interval):
 91            new_semitone = self.semitone_number + other.semitone_number
 92
 93            return Interval(new_semitone)
 94
 95        raise TypeError("Invalid operation")
 96    
 97    def __sub__(self, other):
 98        raise TypeError("Invalid operation")
 99    
100    def __neg__(self):
101        return Interval(-self.semitone_number)
102    
103    @property
104    def semitone_number(self):
105        return self.__semitone_number
106
107
108class Chord:
109    def __init__(self, main_tone, *args):
110        self.__main_tone = main_tone
111        others_tones = [str(tone) for tone in set([tone for tone in args if tone != main_tone])]
112
113        if len(others_tones) == 0:
114            raise TypeError("Cannot have a chord made of only 1 unique tone")
115        
116        # fix order
117        fixed_order_tones = []
118
119        current_tone_index = ALLOWED_TONE_NAMES.index(str(main_tone))
120        
121        while True:
122            current_tone_index += 1
123            current_tone = ALLOWED_TONE_NAMES[current_tone_index % len(ALLOWED_TONE_NAMES)]
124
125            if current_tone == str(main_tone):
126                break
127
128            if current_tone in others_tones:
129                fixed_order_tones.append(Tone(current_tone))
130
131        self.__other_tones = fixed_order_tones
132
133    def __str__(self):
134        joined_other_tones = "-".join(map(str, self.__other_tones))
135
136        return f"{str(self.__main_tone)}-{joined_other_tones}"
137    
138    def __add__(self, other):
139        if isinstance(other, Tone):
140            return Chord(self.__main_tone, *self.__other_tones, other)
141        elif isinstance(other, Chord):
142            return Chord(self.__main_tone, *self.__other_tones, other.__main_tone, *other.__other_tones)
143        
144        raise TypeError("Incompatible types. Chord object should be added up only with Tone object.")
145    
146    def __sub__(self, other):
147        if not isinstance(other, Tone):
148            raise TypeError("Incompatible types. Chord object should be subtracted only by Tone object.")
149        
150        if other not in self.__other_tones:
151            raise TypeError(f"Cannot remove tone {other} from chord {self}")
152
153        return Chord(self.__main_tone, *[tone for tone in self.__other_tones if tone != other])
154
155    def __check_majority(self, majority="minor"):
156        main_tone_index = ALLOWED_TONE_NAMES.index(str(self.__main_tone))
157
158        for tone in self.__other_tones:
159            tone_index = ALLOWED_TONE_NAMES.index(str(tone))
160            diff = abs(main_tone_index - tone_index)
161
162            if SEMITONE_REPRESENTATION[diff] == f"{majority} 3rd":
163                return True
164        
165        return False
166
167    def is_minor(self):
168        return self.__check_majority("minor")
169    
170    def is_major(self):
171        return self.__check_majority("major")
172    
173    def is_power_chord(self):
174        return not self.is_minor() and not self.is_major()
175    
176    def transposed(self, interval):
177        if not isinstance(interval, Interval):
178            raise TypeError("Function expects Interval object to work properly but other object type was given.")
179        
180        new_main_tone = self.__main_tone + interval
181        new_other_tones = [tone + interval for tone in self.__other_tones]
182
183        return Chord(new_main_tone, *new_other_tones)