1INTERVALS = ['unison','minor 2nd', 'major 2nd', 'minor 3rd', 'major 3rd', 'perfect 4th', 'diminished 5th', 'perfect 5th', 'minor 6th', 'major 6th', 'minor 7th', 'major 7th']
  2ORDER = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
  3MINOR_3RD = 3
  4MAJOR_3RD = 4
  5
  6
  7class Tone:
  8    def __init__(self, name):
  9        self.name = name
 10
 11    def __str__(self):
 12        return self.name
 13
 14    def __add__(self, other):
 15        if type(other) is Tone:
 16            return Chord(self, other)
 17        elif type(other) is Interval:
 18            tone_index = other.number_of_semitones
 19            tone_index += ORDER.index(self.name)
 20            tone_index %= 12
 21            return Tone(ORDER[tone_index]) 
 22
 23    def __sub__(self, other):
 24        if type(other) is Interval:
 25            return Tone(ORDER[(ORDER.index(self.name) - other.number_of_semitones) % 12])
 26        elif type(other) is Tone:
 27            return Interval(abs(ORDER.index(self.name) - ORDER.index(other.name)) % 12)
 28
 29    def __eq__(self, other):
 30        return self.name == other.name
 31        
 32
 33class Interval:
 34    def __init__(self, number_of_semitones):
 35        self.number_of_semitones = number_of_semitones 
 36
 37    def __str__(self):
 38        interval = self.number_of_semitones % 12
 39        return INTERVALS[interval]
 40
 41    def __add__(self, other):
 42        if type(other) is Tone:
 43            raise TypeError('Invalid operation')
 44        elif type(other) is Interval:
 45            res = (self.number_of_semitones + other.number_of_semitones) % 12
 46            return Interval(res)
 47
 48    def __neg__(self):
 49         return Interval(-self.number_of_semitones)
 50
 51
 52
 53def sort_tones(root, tones):
 54    # rotating the ORDER list based on the root index
 55    root_index = ORDER.index(root)
 56    rotated_ORDER = ORDER[root_index:] + ORDER[:root_index]
 57    ORDER_index = {char: idx for idx, char in enumerate(rotated_ORDER)}
 58    return sorted(tones, key = lambda x: ORDER_index[x]) # custom sorting func
 59
 60
 61def remove_duplicates(input_list):
 62    seen = set()
 63    return [x for x in input_list if not (x in seen or seen.add(x))]
 64
 65
 66class Chord:
 67    def __init__(self, main_tone, *args):
 68        tones_names_list = []
 69        for el in args:
 70            tones_names_list.append(el.name)
 71        if main_tone.name in tones_names_list:
 72            tones_names_list.remove(main_tone.name)
 73        tones_names = set(tones_names_list)
 74        if len(tones_names) == 0:
 75            raise TypeError('Cannot have a chord made of only 1 unique tone')
 76        self.root = main_tone
 77        self.tones = args
 78
 79    def __str__(self):
 80        res = self.root.name
 81        tones = []
 82        for el in self.tones: tones.append(el.name)
 83        sorted = remove_duplicates(sort_tones(self.root.name, tones))
 84        for el in sorted: 
 85            if el != self.root.name:
 86               res = f'{res}-{el}'
 87        return res
 88
 89    def is_minor(self):
 90        for el in self.tones:
 91            if abs(ORDER.index(self.root.name) - ORDER.index(el.name)) == MINOR_3RD:
 92                return True
 93        return False
 94
 95    def is_major(self):
 96        for el in self.tones:
 97            if abs(ORDER.index(self.root.name) - ORDER.index(el.name)) == MAJOR_3RD:
 98                return True
 99        return False
100
101    def is_power_chord(self):
102        return not self.is_major() and not self.is_minor()
103
104    def __add__(self, other):
105        if type(other) is Tone:
106            return Chord(self.root, *self.tones, other)
107        elif type(other) is Chord:
108            return Chord(self.root, *self.tones, other.root, *other.tones)
109
110    def __sub__(self, other):
111        if type(other) is Tone:
112            tones = []
113            for el in self.tones: tones.append(el.name)
114            sorted = remove_duplicates(sort_tones(self.root.name, tones))
115            if other not in self.tones and other != self.root:
116                raise TypeError(f'Cannot remove tone {str(other)} from chord {str(self)}')
117            if self.root.name in sorted and len(sorted) < 3 or len(sorted) + 1 < 3:
118                raise TypeError('Cannot have a chord made of only 1 unique tone')
119            if self.root == other:
120                if sorted[0] != self.root:
121                   self.root = Chord(sorted[0])
122                else:
123                   self.root = Chord(sorted[1]) 
124            res = []
125            for el in sorted: 
126                if el != other.name:
127                   res.append(Tone(el)) 
128            return Chord(self.root, *res)
129
130    def transposed(self, interval):
131        tones = []
132        root = self.root
133        for el in self.tones:
134            tones.append(Tone(ORDER[(ORDER.index(el.name) + interval.number_of_semitones) % 12]))
135        root = Tone(ORDER[(ORDER.index(root.name) + interval.number_of_semitones) % 12])
136        return Chord(root, *tones)
137    
138