1NOTE_ORDER = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  2
  3
  4def sort_tones(tone_set, root):
  5    note_order = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  6    index = note_order.index(root.tone)
  7
  8    note_order = note_order[index:] + note_order[:index]
  9
 10    order_dict = {tone: index for index, tone in enumerate(note_order)}
 11    sorted_tones = sorted(tone_set, key=lambda tone: order_dict.get(tone.tone, float('inf')))
 12    return sorted_tones
 13
 14class Tone:
 15
 16    def __init__(self, tone):
 17        self.tone = tone
 18
 19    def __str__(self):
 20       return self.tone
 21
 22    def __eq__(self, other):
 23        if isinstance(other, Tone):
 24            return self.tone == other.tone
 25        else:
 26            return self.tone == other
 27
 28    def __hash__(self):
 29        return hash(self.tone)
 30
 31    def __add__(self, other):
 32        if isinstance(other, Tone):
 33            return Chord(self,other)
 34        elif isinstance(other, Interval):
 35            return Tone(NOTE_ORDER[(other.go_back_yourself() + NOTE_ORDER.index(self))%12])
 36
 37    def __sub__(self, other):
 38        if isinstance(other, Tone):
 39            return Interval(NOTE_ORDER.index(self) + NOTE_ORDER.index(other))
 40        elif isinstance(other, Interval):
 41            return Tone(NOTE_ORDER[(NOTE_ORDER.index(self) - other.go_back_yourself()) % 12])
 42
 43
 44class Interval:
 45
 46    def __init__(self, semitone_number):
 47        match semitone_number % 12:
 48            case 0:
 49                self.interval="unison"
 50            case 1:
 51                self.interval = "minor 2nd"
 52            case 2: 
 53                self.interval = "major 2nd"
 54            case 3: 
 55                self.interval = "minor 3rd"
 56            case 4: 
 57                self.interval = "major 3rd"
 58            case 5: 
 59                self.interval = "perfect 4th"
 60            case 6: 
 61                self.interval = "diminished 5th"
 62            case 7: 
 63                self.interval = "perfect 5th"
 64            case 8: 
 65                self.interval = "minor 6th"
 66            case 9: 
 67                self.interval = "major 6th"
 68            case 10: 
 69                self.interval = "minor 7th"
 70            case 11: 
 71                self.interval = "major 7th"
 72            case _: 
 73                self.interval =  '''Живот ли бе — да го опишеш?
 74
 75                                    Живот ли бе — да го разровиш?
 76 
 77                                    Разровиш ли го — ще мирише
 78
 79                                    и ще горчи като отрова.'''
 80
 81    def __str__(self):
 82       return self.interval
 83
 84    def go_back_yourself(self):
 85        match self.interval:
 86            case "unison":
 87                return 0
 88            case "minor 2nd":
 89                return 1
 90            case "major 2nd": 
 91                return 2
 92            case "minor 3rd": 
 93                return 3
 94            case "major 3rd": 
 95                return 4
 96            case "perfect 4th": 
 97                return 5
 98            case "diminished 5th": 
 99                return 6
100            case "perfect 5th": 
101                return 7
102            case "minor 6th": 
103                return 8
104            case "major 6th": 
105                return 9
106            case "minor 7th": 
107                return 10
108            case "major 7th": 
109                return 11
110            case _: 
111                self.interval = "Само онзи, който е живял, страдал и плакал с народа си – само той може да го разбере и да му помогне."+"Христо Ботев" + "He would have hated java"
112
113    def __add__(self, other):
114        if isinstance(other, Tone):
115            raise TypeError("Invalid operation")
116        if isinstance(other, Interval):
117            plc=Interval(self.go_back_yourself() + other.go_back_yourself())
118            return plc
119
120    def __sub__(self, other):
121        if isinstance(other, Tone):
122            raise TypeError("Invalid operation")
123    def __neg__(self):
124        return Interval(12 - self.go_back_yourself())
125
126class Chord:
127
128    def __init__(self, arg, *args, **kwargs):
129        self.root = arg
130        self.set_of_tones = set()
131        self.set_of_tones.add(arg)
132        for item in args:
133            if isinstance(item, tuple):
134                temporary_transition_list = []
135                temporary_transition_list.extend(item)
136                self.set_of_tones.update(temporary_transition_list)
137            else:
138                self.set_of_tones.update(set(args))
139        for value in kwargs.values():
140            self.set_of_tones.add(value)
141        if len(self.set_of_tones) < 2:
142            raise TypeError("Cannot have a chord made of only 1 unique tone")
143
144
145    def __str__(self):
146        return "-".join(t.tone for t in sort_tones(self.set_of_tones, self.root))
147
148    def is_minor(self):
149        for el in self.set_of_tones:
150            interval = self.root - el
151            if el == self.root:
152                continue
153            elif interval.interval == "minor 3rd":
154                return True
155        return False
156
157    def is_major(self):
158        for el in self.set_of_tones:
159            interval = self.root - el
160            if el == self.root:
161                continue
162            elif interval.interval == "major 3rd":
163                return True
164        return False
165
166    def is_power_chord(self):
167        return not self.is_major() and not self.is_minor()
168
169    def __add__(self, other):
170        if isinstance(other, Tone):
171           self.set_of_tones.add(other)
172           sort_tones(self.set_of_tones, self.root)
173           return self
174        if isinstance(other, Chord):
175            self.set_of_tones.update(other.set_of_tones)
176            placeholed = self
177            return placeholed
178
179    def __sub__(self, other):
180        if other not in self.set_of_tones:
181            raise TypeError(f"Cannot remove tone {other} from chord {self}")
182        elif len(self.set_of_tones) < 3:
183            raise TypeError("Cannot have a chord made of only 1 unique tone")
184        else:
185            self.set_of_tones.remove(other)
186            sort_tones(self.set_of_tones, self.root)
187            if self.root == other:
188                self.root = list(self.set_of_tones)[0]
189            return self
190            
191    def transposed(self, inter):
192        notes = sort_tones(self.set_of_tones,self.root)
193        for i in range(0,3):
194            notes[i] = notes[i] + inter
195        return Chord(notes[0], tuple(notes))