1# Updated solution: 4.11.2024, прочетох коментарите по предишното решение, някои неща са оправени, някои не
  2
  3# и с главни букви, ама вече ги бех написал така
  4interval_tuple = ("unison", "minor 2nd", "major 2nd", "minor 3rd",
  5                  "major 3rd", "perfect 4th", "diminished 5th", "perfect 5th",
  6                  "minor 6th", "major 6th", "minor 7th", "major 7th")
  7tones_tuple = ("A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#")
  8# не е само за tuple, а за всички iterable колекции с __getitem__ или квото беше там operator[]
  9def get_position_in_tuple(element, collection):
 10    for i in range(0,len(collection)):
 11        if collection[i] == element:
 12            return i
 13    return -101 # да не ми счупи is_minor и is_major ако ми въведете невалиден тон
 14
 15
 16class Tone:
 17
 18    def __init__(self, data):
 19        # не правя проверка дали е валиден тон, но ако не е не би трябвало да счупи програмата
 20        # или поне функциите, за които го тествах
 21        self.data = data 
 22
 23    def __str__(self):
 24        return self.data
 25
 26    def __eq__(self, other): # трябва да се дефинира, иначе проверката е с is, което не е желаното поведение
 27        return self.data == other.data
 28    
 29    def __add__(self, other):
 30        if type(other) is Tone:
 31            return Chord(self, other)
 32        if type(other) is Interval:
 33            result_tone = get_position_in_tuple(self.data, tones_tuple) + other.data
 34            size_tones = len(tones_tuple)
 35            while result_tone >= size_tones:
 36                result_tone -= size_tones
 37            return Tone(tones_tuple[result_tone])
 38
 39    def __sub__(self, other):
 40        if type(other) is Tone:
 41            left_position = get_position_in_tuple(self.data, tones_tuple)
 42            right_position = get_position_in_tuple(other.data, tones_tuple)
 43            difference = left_position - right_position
 44            # G - C = 7 (perfect 5th), но C - G = 5 (perfect 4th), явно въртим окръжността наобратно?  
 45            if difference >= 0:
 46                return Interval(difference)
 47            else:
 48                return Interval(len(interval_tuple) - abs(difference))
 49        if type(other) is Interval:
 50            result_tone = get_position_in_tuple(self.data, tones_tuple) - other.data
 51            size_tones = len(tones_tuple)
 52            while result_tone < 0:
 53                result_tone += size_tones
 54            return Tone(tones_tuple[result_tone])
 55
 56class Interval:
 57
 58    def __init__(self, data):
 59        size_intervals = len(interval_tuple)
 60        while data >= size_intervals: # може би трябваше с %, чак сега виждам колко зле съм го направил 
 61            data -= size_intervals
 62        self.data = data
 63
 64    def __neg__(self):
 65        return -self.data
 66
 67    def __str__(self):
 68        return interval_tuple[self.data]
 69
 70    def __add__(self, other): # ако имаме Interval + Tone
 71        if type(other) is Tone:
 72            raise TypeError("Invalid operation")
 73        if type(other) is Interval:
 74            result_data = self.data + other.data
 75            return Interval(result_data) # __init__ ще се оправи дори с неща >= 12
 76
 77    def __sub__(self, other): # ако имаме Interval - Tone
 78        if type(other) is Tone:
 79            raise TypeError("Invalid operation")
 80    
 81
 82class Chord:
 83
 84    def __init__(self, *args):
 85        self.tones = set()
 86        self.main_tone = str(args[0])
 87        for item in args: # добавяме всички тонове, включително и main-a
 88            if type(item) is Tone:
 89                self.tones.add(str(item))
 90        if len(self.tones) == 1:
 91            raise TypeError("Cannot have a chord made of only 1 unique tone")
 92            
 93    def _fill_list_from_source(self, source, destination): # може би не е най-доброто име за функцията
 94        for item in source:
 95            if item in self.tones:
 96                destination.append(item)
 97        return destination
 98
 99    def __str__(self):
100        self.tones = list(self.tones)
101        position_of_main_tone = 0
102        # тъй като въртенето започва от main тона, правя два tuple-a, за тези след него в окръжността
103        # е за тези преди него
104        # целта е да се създаде сортиран лист, който в последствие да join-нем с "-"
105        for i in range(0, len(tones_tuple)):
106            if self.main_tone == tones_tuple[i]:
107                position_of_main_tone = i
108        after_tuple = tones_tuple[position_of_main_tone:]
109        before_tuple = tones_tuple[:position_of_main_tone]
110        to_return = list()
111        to_return = self._fill_list_from_source(after_tuple, to_return)
112        to_return = self._fill_list_from_source(before_tuple, to_return)
113        return "-".join(to_return)
114        
115    def check_for_specific_chord(self, chord_string):
116        main_position = get_position_in_tuple(str(self.main_tone), tones_tuple)
117        wanted_position = get_position_in_tuple(chord_string, interval_tuple)
118        for item in self.tones:
119            curr_position = get_position_in_tuple(str(item), tones_tuple)
120            # ако са на позиции 3 и 6 примерно, ще има minor 3rd
121            # но трябва да проверим и случая ако са на позиции 11 и 2 примерно, разликата м/у тях пак е 3
122            # тогава пак ще има minor 3rd, но за целта трябва 12 - (11-2)
123            current_diff = abs(curr_position - main_position)
124            if current_diff == wanted_position or len(tones_tuple) - current_diff == wanted_position:
125                return True
126        return False
127
128    def is_minor(self):
129        return self.check_for_specific_chord("minor 3rd")
130    
131    def is_major(self):
132        return self.check_for_specific_chord("major 3rd")
133
134    def is_power_chord(self):
135        return not self.is_minor() and not self.is_major()
136
137    def __add__(self, other):
138        if type(other) is Tone:
139            result_chord = Chord(self.main_tone)
140            result_chord.tones.update(self.tones)
141            result_chord.tones.add(other.data)
142            return result_chord
143        if type(other) is Chord:
144            result_chord = Chord(self.main_tone)
145            result_chord.tones.update(self.tones)
146            result_chord.tones.add(other.main_tone)
147            result_chord.tones.update(other.tones)
148            return result_chord
149        
150    def __sub__(self, other):
151        if (not other.data in self.tones) and other.data != self.main_tone:
152            raise TypeError(f"Cannot remove tone {other.data} from chord {self}")
153        if len(self.tones) < 3:
154            raise TypeError("Cannot have a chord made of only 1 unique tone")
155        if type(other) is Tone:
156            result_chord = Chord(self.main_tone)
157            if other.data == self.main_tone: # fix, не работеше правилно
158                main_tone_pos = get_position_in_tuple(self.main_tone, tones_tuple)
159                for item in tones_tuple[main_tone_pos+1:]: # гледаме първо тия след него до края на tuple-a
160                    if item in tuple(self.tones):
161                        result_chord.main_tone = item
162                        break
163                if result_chord.main_tone == other.data: # ако не сме променили main_tone с тези след него
164                    for item in tones_tuple[:main_tone_pos]:
165                        if item in tuple(self.tones):
166                            result_chord.main_tone = item
167                            break
168                result_chord.tones.update(self.tones)
169                result_chord.tones.remove(self.main_tone)
170            else: # и тук пак fix
171                result_chord.tones.update(self.tones)
172                result_chord.tones.remove(other.data)
173            return result_chord
174    
175    def transposed(self, interval):
176        # можеше да използвам и събирането, което дефинирах за тоновете...
177        position = 0
178        if type(interval) is int:
179            position = interval
180        else:
181            position = interval.data
182        result_chord = Chord(self.main_tone)
183        main_tone_pos = get_position_in_tuple(self.main_tone, tones_tuple) + position
184        # имаше някакви бъгове, които всеки път даваха различен main_tone, затова main тона е отделно, нищо че може да се сложи и в долния цикъл
185        if main_tone_pos < 0:
186            main_tone_pos += len(tones_tuple)
187        elif main_tone_pos >= len(tones_tuple):
188            main_tone_pos -= len(tones_tuple)
189        result_chord.main_tone = tones_tuple[main_tone_pos]
190        # а иначе цикъла, в който пак си го има main тона попринцип, ама програмата си прави каквото си иска и всеки път дава различен резултат
191        for item in self.tones:
192            curr_position = get_position_in_tuple(item, tones_tuple) + position
193            if curr_position < 0:
194                curr_position += len(tones_tuple)
195            elif curr_position >= len(tones_tuple):
196                curr_position -= len(tones_tuple)
197            result_chord.tones.add(tones_tuple[curr_position])
198        return result_chord