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