1INPUT_ERROR_MESSAGE = 'Invalid input type: Expected'
  2INVALID_OPERATION_ERROR_MESSAGE = 'Invalid operation'
  3VALID_TONES = (
  4    'C', 'C#', 'D', 'D#', 'E', 'F',
  5    'F#', 'G', 'G#', 'A', 'A#', 'B'
  6)
  7
  8
  9class Tone:
 10
 11    def __init__(self, tone):
 12        self.tone = tone
 13
 14    @property
 15    def tone(self):
 16        return self._tone
 17
 18    @tone.setter
 19    def tone(self, value):
 20        if value not in VALID_TONES:
 21            raise ValueError(f'{INPUT_ERROR_MESSAGE} one of {VALID_TONES}')
 22        self._tone = value
 23
 24    def __str__(self):
 25        return self.tone
 26
 27    def __add__(self, other):
 28        if isinstance(other, Tone):
 29            return Chord(self, other)
 30        elif isinstance(other, Interval):
 31            starting_index = VALID_TONES.index(self.tone)
 32            shifted_tone = VALID_TONES[(starting_index + other.length) % INTERVALS_COUNT]
 33            return Tone(shifted_tone)
 34
 35        raise TypeError(INVALID_OPERATION_ERROR_MESSAGE)
 36
 37    def __sub__(self, other):
 38        if isinstance(other, Tone):
 39            first_tone_index = VALID_TONES.index(self.tone)
 40            second_tone_index = VALID_TONES.index(other.tone)
 41            interval_len = first_tone_index - second_tone_index
 42
 43            if first_tone_index <= second_tone_index:
 44                interval_len += INTERVALS_COUNT
 45
 46            return Interval(interval_len)
 47        elif isinstance(other, Interval):
 48            starting_index = VALID_TONES.index(self.tone)
 49            shifted_tone = VALID_TONES[starting_index - other.length]
 50            return Tone(shifted_tone)
 51
 52        raise TypeError(INVALID_OPERATION_ERROR_MESSAGE)
 53
 54
 55# The indices correspond to the interval length
 56INTERVAL_NAMES = (
 57    'unison', 'minor 2nd', 'major 2nd', 'minor 3rd',
 58    'major 3rd', 'perfect 4th', 'diminished 5th', 'perfect 5th',
 59    'minor 6th', 'major 6th', 'minor 7th', 'major 7th'
 60)
 61
 62SHORTEST_INTERVAL = 0
 63LONGEST_INTERVAL = 11
 64INTERVALS_COUNT = 12
 65
 66
 67class Interval:
 68
 69    def __init__(self, length, is_direction_forward=True):
 70        self._set_length(length)
 71        self._is_direction_forward = is_direction_forward
 72
 73    def __neg__(self):
 74        return Interval(self.length, False)
 75
 76    @property
 77    def is_direction_forward(self):
 78        return self._is_direction_forward
 79
 80    @property
 81    def length(self):
 82        return self._length
 83
 84    def _set_length(self, value):
 85        if not isinstance(value, int):
 86            raise TypeError(f'{INPUT_ERROR_MESSAGE} {str(int)}')
 87
 88        if value < SHORTEST_INTERVAL:
 89            raise ValueError(f'{INPUT_ERROR_MESSAGE} a non-negative integer')
 90
 91        self._length = value % INTERVALS_COUNT
 92
 93    def __str__(self):
 94        return INTERVAL_NAMES[self.length]
 95
 96    def __add__(self, other):
 97        if isinstance(other, Interval):
 98            return Interval(self.length + other.length)
 99        raise TypeError(INVALID_OPERATION_ERROR_MESSAGE)
100
101
102MIN_TONES_COUNT_IN_CHORD = 2
103TONES_COUNT_ERROR_MESSAGE = 'Cannot have a chord made of only 1 unique tone'
104
105
106def rearrange_tuple(input_tuple, skip_index):
107    start_index = skip_index + 1
108    end_index = skip_index - 1
109
110
111    if start_index <= end_index:
112        result_tuple = input_tuple[start_index:end_index + 1]
113    else:
114        result_tuple = input_tuple[start_index:] + input_tuple[:end_index + 1]
115
116    if skip_index is not None:
117        skip_tone = input_tuple[skip_index]
118        result_tuple = [tone for tone in result_tuple if tone != skip_tone]
119
120    return result_tuple
121
122
123class Chord:
124    def __init__(self, main_tone, *args, **kwargs):
125        secondary_tones = list(args) + list(kwargs.values())
126        self.tones = Chord._extract_and_sort_tones(main_tone, secondary_tones)
127
128    @property
129    def tones(self):
130        return self._tones
131
132    @property
133    def main_tone(self):
134        return self._tones[0]
135
136    @property
137    def secondary_tones(self):
138        return self._tones[1:]
139
140    @tones.setter
141    def tones(self, value):
142        if len(value) < MIN_TONES_COUNT_IN_CHORD:
143            raise TypeError(TONES_COUNT_ERROR_MESSAGE)
144
145        self._tones = value
146
147    @staticmethod
148    def _extract_and_sort_tones(main_tone, secondary_tones=None):
149
150        if secondary_tones is None:
151            return list(main_tone)
152
153        unique_secondary_tones = set(filter(lambda tone: str(tone) != str(main_tone), secondary_tones))
154        unique_secondary_tones_strs = [str(tone) for tone in unique_secondary_tones]
155
156        main_tone_index = VALID_TONES.index(str(main_tone))
157        rearranged_tones = rearrange_tuple(VALID_TONES, main_tone_index)
158
159        sorted_tones = [main_tone]
160
161        for tone in rearranged_tones:
162            if tone in unique_secondary_tones_strs:
163                sorted_tones.append(next((t for t in unique_secondary_tones if str(t) == tone)))
164
165        return sorted_tones
166
167    def __str__(self):
168        return '-'.join([str(tone) for tone in self.tones])
169
170    def _contains_interval(self, interval):
171        first_possible_tone = VALID_TONES[self.tones.index(self.main_tone) - interval.length]
172        second_possible_tone = VALID_TONES[self.tones.index(self.main_tone) + interval.length]
173
174        if any(str(tone) in [first_possible_tone, second_possible_tone] for tone in self.tones):
175            return True
176
177        return False
178
179    def is_minor(self):
180        return self._contains_interval(Interval(3))
181
182    def is_major(self):
183        return self._contains_interval(Interval(4))
184
185    def is_power_chord(self):
186        return not self.is_minor() and not self.is_major()
187
188    def __add__(self, other):
189        if isinstance(other, Tone):
190            return Chord(self.main_tone, *self.secondary_tones, other)
191        elif isinstance(other, Chord):
192            return Chord(self.main_tone, *self.secondary_tones, *other.tones)
193
194    def __sub__(self, tone_to_remove):
195        if str(tone_to_remove) not in [str(tone) for tone in self.tones]:
196            raise TypeError(f'Cannot remove tone {str(tone_to_remove)} from chord {str(self)}')
197
198        if len(self.tones) <= MIN_TONES_COUNT_IN_CHORD:
199            raise TypeError(TONES_COUNT_ERROR_MESSAGE)
200
201        if str(self.main_tone) == str(tone_to_remove):
202            return Chord(self.tones[1], *self.secondary_tones)
203
204        updated_tones = [tone for tone in self.secondary_tones if str(tone) != str(tone_to_remove)]
205        return Chord(self.main_tone, *updated_tones)
206
207    def transposed(self, interval):
208        if interval.is_direction_forward:
209            shifted_secondary_tones = [tone + interval for tone in self.secondary_tones]
210            return Chord(self.main_tone + interval, *shifted_secondary_tones)
211
212        shifted_secondary_tones = [tone - interval for tone in self.secondary_tones]
213        return Chord(self.main_tone - interval, *shifted_secondary_tones)