1class Tone:
  2    _NUMBER_OF_TONES = 12
  3
  4    tones = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
  5 
  6    def __init__(self, name):
  7        if name in self.tones:
  8            self.name = name
  9 
 10    def __str__(self):
 11        return self.name
 12 
 13    def __add__(self, other):
 14        if isinstance(other, Tone):
 15            return Chord(self, other)
 16        elif isinstance(other, Interval):
 17            ind = self.tones.index(self.name)
 18            new_ind = (ind+other.number_of_semitones) % self._NUMBER_OF_TONES
 19            return Tone(self.tones[new_ind])
 20 
 21    def __sub__(self, other):
 22        if isinstance(other, Tone):
 23            number_of_semitones = (Tone.tones.index(self.name)-Tone.tones.index(other.name)) % self._NUMBER_OF_TONES
 24            return Interval(number_of_semitones)
 25        elif isinstance(other, Interval):
 26            ind = self.tones.index(self.name)
 27            new_ind = (ind - other.number_of_semitones) % self._NUMBER_OF_TONES
 28            return Tone(self.tones[new_ind])
 29        
 30
 31class Interval:
 32    _NUMBER_OF_SEMITONES = 12
 33    intervals = {
 34        0: "unison", 1: "minor 2nd", 2: "major 2nd", 3: "minor 3rd",
 35        4: "major 3rd", 5: "perfect 4th", 6: "diminished 5th",
 36        7: "perfect 5th", 8: "minor 6th", 9: "major 6th",
 37        10: "minor 7th", 11: "major 7th"
 38        }
 39 
 40    def __init__(self, number_of_semitones):
 41        self.number_of_semitones = number_of_semitones % self._NUMBER_OF_SEMITONES
 42 
 43    def __str__(self):
 44        return self.intervals[self.number_of_semitones]
 45 
 46    def __add__(self, other):
 47        if isinstance(other, Tone):
 48            raise TypeError("Invalid operation")
 49        elif isinstance(other, Interval):
 50            new_num_of_semitones = self.number_of_semitones + other.number_of_semitones
 51            return Interval(new_num_of_semitones)
 52 
 53    def __sub__(self, other):
 54        if isinstance(other, Tone):
 55            raise TypeError("Invalid operation")
 56
 57    #used in the transpose function in order to add a negative interval to a tone 
 58    def __neg__(self): 
 59        """Convert an interval to the negative value."""
 60        return Interval(-self.number_of_semitones)
 61    
 62
 63class Chord:
 64    _NUMBER_OF_SEMITONES = 12
 65    _MIN_UNIQUE_TONES_IN_CHORD = 2
 66    _NUMBER_OF_SEMITONES_IN_MINOR = 3
 67    _NUMBER_OF_SEMITONES_IN_MAJOR = 4
 68    
 69    def __init__(self, main_tone, *other_tones):
 70        unique_tone_names = {main_tone.name}
 71        unique_tones = [main_tone]
 72 
 73        for tone in other_tones:
 74            if tone.name not in unique_tone_names:
 75                unique_tone_names.add(tone.name)
 76                unique_tones.append(tone)
 77 
 78        if len(unique_tone_names) < self._MIN_UNIQUE_TONES_IN_CHORD:
 79            raise TypeError("Cannot have a chord made of only 1 unique tone")
 80 
 81        main_tone_ind = Tone.tones.index(main_tone.name)
 82        self.main_tone_ind = main_tone_ind #so I can use it in _get_distance_from_main_tone
 83        tones_left = list()
 84
 85        for tone in unique_tones:
 86            if tone != main_tone:
 87                tones_left.append(tone)
 88
 89        tones_left.sort(key = self._get_distance_from_main_tone)
 90
 91        self.tones = [main_tone]
 92        for tone in tones_left:
 93            self.tones.append(tone)
 94            
 95    def _get_tones_diff(self, tone, main_tone_ind):
 96        """Return the count of semitones between a tone and the main_tone_ind."""
 97        return (Tone.tones.index(tone.name) - main_tone_ind) % self._NUMBER_OF_SEMITONES
 98    
 99    def _get_distance_from_main_tone(self, tone):
100        """Calculate the difference between the current tone and the main tone of the chord in semitones."""
101        return self._get_tones_diff(tone, self.main_tone_ind)
102         
103    def _get_tone_ind(self, tone_name):
104        """Return the index of a tone."""
105        return Tone.tones.index(tone_name)
106 
107    def __str__(self):
108        return f"{'-'.join(str(tone) for tone in self.tones)}"
109 
110    def _is_interval(self, semitones_count):
111        main_tone = self.tones[0]
112        main_tone_ind = self._get_tone_ind(main_tone.name)
113        tones_count = len(self.tones)
114
115        for t in range(1, tones_count):
116            tone = self.tones[t]
117            tone_ind = self._get_tone_ind(tone.name)
118            if((tone_ind - main_tone_ind) % self._NUMBER_OF_SEMITONES == semitones_count):
119                return True
120 
121        return False
122 
123    def is_minor(self):
124        return self._is_interval(self._NUMBER_OF_SEMITONES_IN_MINOR)
125 
126    def is_major(self):
127        return self._is_interval(self._NUMBER_OF_SEMITONES_IN_MAJOR)
128 
129    def is_power_chord(self):
130        if not self.is_minor() and not self.is_major():
131            return True
132        
133        return False
134    
135    def _create_chord(self, new_tones):
136        """Create a new chord."""
137        new_main_tone = new_tones[0]
138        new_other_tones = new_tones[1:]
139
140        return Chord(new_main_tone, *new_other_tones)
141    
142    def __add__(self, other):
143        tones_in_new_chord = list(self.tones)
144
145        if isinstance(other, Tone):
146            if other not in tones_in_new_chord:
147                tones_in_new_chord.append(other)
148            return self._create_chord(tones_in_new_chord)
149        elif isinstance(other, Chord):
150            for tone in other.tones:
151                if tone not in tones_in_new_chord:
152                    tones_in_new_chord.append(tone)
153
154            return self._create_chord(tones_in_new_chord)
155        
156    def __sub__(self, other):
157        if isinstance(other, Tone):
158            if other.name not in (tone.name for tone in self.tones):
159                raise TypeError(f"Cannot remove tone {other} from chord {self}")
160
161            tones_in_new_chord = list()
162
163            for tone in self.tones:
164                if tone.name != other.name:
165                    tones_in_new_chord.append(tone)
166
167            if len(tones_in_new_chord) < self._MIN_UNIQUE_TONES_IN_CHORD:
168                raise TypeError("Cannot have a chord made of only 1 unique tone")
169
170            return self._create_chord(tones_in_new_chord)
171    
172    def transposed(self, interval):
173        if isinstance(interval, Interval):
174            tones_in_new_chord = list()
175            for tone in self.tones:
176                new_tone = tone + interval
177                tones_in_new_chord.append(new_tone)
178
179            return self._create_chord(tones_in_new_chord)