1NUMBER_OF_SEMITONES_TO_STR = {
  2    0: "unison",
  3    1: "minor 2nd",
  4    2: "major 2nd",
  5    3: "minor 3rd",
  6    4: "major 3rd",
  7    5: "perfect 4th",
  8    6: "diminished 5th",
  9    7: "perfect 5th",
 10    8: "minor 6th",
 11    9: "major 6th",
 12    10: "minor 7th",
 13    11: "major 7th"
 14}
 15INDEX_TO_TONE_STR = {
 16    0: "C",
 17    1: "C#",
 18    2: "D",
 19    3: "D#",
 20    4: "E",
 21    5: "F",
 22    6: "F#",
 23    7: "G",
 24    8: "G#",
 25    9: "A",
 26    10: "A#",
 27    11: "B",
 28}
 29TONE_STR_TO_INDEX = {item[1]: item[0] for item in INDEX_TO_TONE_STR.items()}
 30TONES_COUNT = 12
 31MINOR_THIRD_INDEX = 3
 32MAJOR_THIRD_INDEX = 4
 33
 34
 35class Tone:
 36
 37    def __init__(self, tone_str: str):
 38        self.__tone_str = tone_str
 39
 40    def __str__(self):
 41        return self.__tone_str
 42
 43    def __hash__(self):
 44        return hash(self.__tone_str)  # това го правя, за да кажа dict.fromkeys(tones)
 45
 46    def __eq__(self, other):
 47        if isinstance(other, Tone):
 48            return self.__tone_str == other.tone_str  # това го правя, за да кажа dict.fromkeys(tones)
 49
 50    def __sub__(self, other):
 51        if isinstance(other, Tone):
 52            if self.get_tone_index() > other.get_tone_index():
 53                return Interval(self.get_tone_index() - other.get_tone_index())
 54            return Interval(TONES_COUNT - other.get_tone_index() - self.get_tone_index())
 55        elif isinstance(other, Interval):
 56            return self + (-other)
 57
 58    def __add__(self, other):
 59        if isinstance(other, Tone):
 60            return Chord(self, other)
 61        elif isinstance(other, Interval):
 62            index = (self.get_tone_index() + other.number_of_semitones) % TONES_COUNT
 63            return Tone(INDEX_TO_TONE_STR[index])
 64
 65    @property
 66    def tone_str(self):
 67        return self.__tone_str
 68
 69    def get_tone_index(self):
 70        return TONE_STR_TO_INDEX[self.__tone_str]
 71
 72
 73class Interval:
 74
 75    def __init__(self, number_of_semitones: int):
 76        self.__number_of_semitones = number_of_semitones % TONES_COUNT
 77
 78    def __neg__(self):
 79        return Interval(-self.__number_of_semitones)
 80
 81    def __str__(self):
 82        return NUMBER_OF_SEMITONES_TO_STR[self.number_of_semitones]
 83
 84    def __add__(self, other):
 85        if isinstance(other, Interval):
 86            return Interval(self.number_of_semitones + other.number_of_semitones)
 87        elif isinstance(other, Tone):
 88            raise TypeError("Invalid operation")
 89
 90    def __sub__(self, other):
 91        if isinstance(other, Tone):
 92            raise TypeError("Invalid operation")
 93
 94    @property
 95    def number_of_semitones(self):
 96        return self.__number_of_semitones
 97
 98
 99class Chord:
100    def __init__(self, root: Tone, *args: [Tone]):
101        self.__root = root
102        self.__initialise_tones(args)
103
104    def __str__(self):
105        return "-".join(map(str, [self.__root, *self.__tones]))
106
107    def __sub__(self, other):
108        if not other.get_tone_index() in ([t.get_tone_index() for t in self.__tones] + [self.__root.get_tone_index()]):
109            raise TypeError(f"Cannot remove tone {str(other)} from chord {self.__str__()}")
110
111        if other.get_tone_index() == self.__root.get_tone_index():
112            return Chord(self.__tones[0], *self.__tones[1:])
113        return Chord(self.__root, *list(filter(lambda cur: str(cur) != str(other), self.__tones)))
114
115    def __add__(self, other):
116        if isinstance(other, Tone):
117            return Chord(self.__root, *self.__tones, other)
118        elif isinstance(other, Chord):
119            return Chord(self.__root, *self.__tones, other.__root, *other.__tones)
120
121    def __initialise_tones(self, new_tones: [Tone]):
122        new_tones = list(dict.fromkeys(filter(lambda cur: str(cur) != str(self.__root), new_tones)))
123        # това ми прави все едно set ,защото пак ползва hash ,но пази реда ,защото dict след python 3.7 e ordered
124
125        if len(new_tones) == 0:
126            raise TypeError("Cannot have a chord made of only 1 unique tone")
127
128        pivot = self.__root.get_tone_index()
129        ordered_tones = list(sorted(new_tones, key=lambda cur: cur.get_tone_index()))
130        upper_bound = list(filter(lambda cur: cur.get_tone_index() > pivot, ordered_tones))
131        lower_bound = list(filter(lambda cur: cur.get_tone_index() < pivot, ordered_tones))
132        self.__tones = [*upper_bound, *lower_bound]
133
134    def is_minor(self) -> bool:
135        return self.__seek_for_interval(MINOR_THIRD_INDEX)
136
137    def is_major(self) -> bool:
138        return self.__seek_for_interval(MAJOR_THIRD_INDEX)
139
140    def is_power_chord(self) -> bool:
141        return not self.is_major() and not self.is_minor()
142
143    def __seek_for_interval(self, number_of_semitones: int) -> bool:
144        for tone in self.__tones:
145            current_interval = tone - self.__root
146            if current_interval.number_of_semitones == number_of_semitones:
147                return True
148        return False
149
150    def transposed(self, interval: Interval):
151        new_root = self.__root + interval
152        new_tones = [tone + interval for tone in self.__tones]
153        return Chord(new_root, *new_tones)