1TONES = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
  2
  3
  4class Tone:
  5    def __init__(self, entry):
  6        self.tone = entry
  7        self.idx = TONES.index(entry)
  8
  9    def __str__(self):
 10        return self.tone
 11
 12    def __eq__(self, value):
 13        return self.tone == value.tone
 14
 15    def __hash__(self):
 16        return hash(self.tone)
 17
 18    def __add__(self, other):
 19        if type(other) is Chord:
 20            return Chord(self, other)
 21        elif type(other) is Interval:
 22            tone = (self.idx + other.type) % 12
 23            return Tone(TONES[tone])
 24        elif type(other) is Tone:
 25            return Chord(self, other)
 26
 27    def __sub__(self, other):
 28        if type(other) is Tone:
 29            return Interval(self.idx - other.idx)
 30        if type(other) is Interval:
 31            tone = (self.idx - other.type) % 12
 32            return Tone(TONES[tone])
 33
 34
 35INTERVAL_RANGE = [
 36    "unison",
 37    "minor 2nd",
 38    "major 2nd",
 39    "minor 3rd",
 40    "major 3rd",
 41    "perfect 4th",
 42    "diminished 5th",
 43    "perfect 5th",
 44    "minor 6th",
 45    "major 6th",
 46    "minor 7th",
 47    "major 7th",
 48]
 49
 50
 51class Interval:
 52    def __init__(self, number):
 53        self.type = number % 12
 54
 55    def __str__(self):
 56        return INTERVAL_RANGE[self.type]
 57
 58    def __add__(self, other):
 59        if type(other) is Interval:
 60            return Interval((self.type + other.type) % 12)
 61        elif type(other) is Tone:
 62            raise TypeError("Invalid operation")
 63
 64    def __neg__(self):
 65        return Interval(12 - self.type)
 66
 67    def __sub__(self, other):
 68        raise TypeError("Invalid operation")
 69
 70
 71class Chord:
 72    def __init__(self, root, *args):
 73        self.chord_set = set()
 74        self.chord_set.add(root)
 75        self.root = root
 76
 77        self.chord_set.update(args)
 78
 79        if len(self.chord_set) == 1:
 80            raise TypeError("Cannot have a chord made of only 1 unique tone")
 81
 82    def __str__(self):
 83        temp_list = []
 84        for k in range(self.root.idx, self.root.idx + 12):
 85            if Tone(TONES[k % 12]) in self.chord_set:
 86                temp_list.append(str(Tone(TONES[k % 12])))
 87        return "-".join(temp_list)
 88
 89    def is_minor(self):
 90        for elt in self.chord_set:
 91            if not elt == self.root:
 92                if (elt - self.root).type == 3:
 93                    return True
 94        return False
 95
 96    def is_major(self):
 97        for elt in self.chord_set:
 98            if not elt == self.root:
 99                if (elt - self.root).type == 4:
100                    return True
101        return False
102
103    def is_power_chord(self):
104        return not (self.is_major() or self.is_minor())
105
106    def __add__(self, other):
107        if type(other) is Tone:
108            self.chord_set.add(other)
109            return Chord(self.root, *self.chord_set)
110        if type(other) is Chord:
111            return Chord(self.root, *(self.chord_set | other.chord_set))
112
113    def __sub__(self, other):
114        if type(other) is Tone:
115            if other not in self.chord_set:
116                raise TypeError(
117                    f"Cannot remove tone {str(other)} from chord {str(self)}"
118                )
119            elif len(self.chord_set) <= 2:
120                raise TypeError("Cannot have a chord made of only 1 unique tone")
121            else:
122                self.chord_set.remove(other)
123                return Chord(self.root, *self.chord_set)
124
125    def transposed(self, other):
126        return Chord(self.root + other, *list(map(lambda x: x + other, self.chord_set)))