1class Tone:
  2    NAME_DOMAIN = ("A", "A#", "B", "C", "C#", "D",
  3                   "D#", "E", "F", "F#", "G", "G#")
  4
  5    def __init__(self, tone_name):
  6        self.name_index = Tone.NAME_DOMAIN.index(tone_name)
  7
  8    def __str__(self):
  9        return Tone.NAME_DOMAIN[self.name_index]
 10
 11    def __eq__(self, other):
 12        if isinstance(other, Tone):
 13            return self.name_index == other.name_index
 14        raise TypeError("Invalid operation")
 15
 16    def __hash__(self):
 17        return hash(self.name_index)
 18
 19    def __add__(self, other):
 20        if isinstance(other, Tone):
 21            return Chord(self, other)
 22        elif isinstance(other, Interval):
 23            return Tone(Tone.NAME_DOMAIN[(self.name_index +
 24                                          other.interval_name_index)
 25                                         % len(Tone.NAME_DOMAIN)])
 26        raise TypeError("Invalid operation")
 27
 28    def __sub__(self, other):
 29        if isinstance(other, Tone):
 30            return Interval(abs(self.name_index - other.name_index))
 31        elif isinstance(other, Interval):
 32            return Tone(Tone.NAME_DOMAIN[(self.name_index -
 33                                          other.interval_name_index)
 34                                         % len(Tone.NAME_DOMAIN)])
 35        raise TypeError("Invalid operation")
 36
 37
 38class Interval:
 39    INTERVAL_NAME_DOMAIN = ("unison", "minor 2nd", "major 2nd", "minor 3rd",
 40                            "major 3rd", "perfect 4th", "diminished 5th",
 41                            "perfect 5th", "minor 6th", "major 6th",
 42                            "minor 7th", "major 7th")
 43
 44    def __init__(self, number_of_semitones):
 45        self.interval_name_index = (number_of_semitones %
 46                                    len(Interval.INTERVAL_NAME_DOMAIN))
 47
 48    def __str__(self):
 49        return Interval.INTERVAL_NAME_DOMAIN[self.interval_name_index]
 50
 51    def __eq__(self, other):
 52        if isinstance(other, Interval):
 53            return self.interval_name_index == other.interval_name_index
 54        raise TypeError("Invalid operation")
 55
 56    def __neg__(self):
 57        return Interval(-self.interval_name_index)
 58
 59    def __add__(self, other):
 60        if isinstance(other, Interval):
 61            return Interval(self.interval_name_index +
 62                            other.interval_name_index)
 63        raise TypeError("Invalid operation")
 64
 65
 66class Chord:
 67    major_chord_interval = Interval(4)
 68    minor_chord_interval = Interval(3)
 69
 70    def __init__(self, root_tone: Tone, *additional_tones: Tone):
 71        self.tones = []
 72        self.tones.append(root_tone)
 73
 74        additional_tones = {tone for tone in additional_tones
 75                            if tone != root_tone}
 76
 77        if len(additional_tones) == 0:
 78            raise TypeError("Cannot have a chord made of only 1 unique tone")
 79
 80        temp_tones = []
 81        current_tone = self.tones[0] + Interval(1)
 82
 83        while current_tone != self.tones[0]:
 84            if current_tone in additional_tones:
 85                temp_tones.append(current_tone)
 86            current_tone = current_tone + Interval(1)
 87
 88        self.tones.extend(temp_tones)
 89
 90    def __str__(self):
 91        return "-".join([str(tone) for tone in self.tones])
 92
 93    def __add__(self, other):
 94        if isinstance(other, Tone):
 95            return Chord(*self.tones, other)
 96        elif isinstance(other, Chord):
 97            return Chord(*self.tones, *other.tones)
 98        raise TypeError("Invalid operation")
 99
100    def __sub__(self, other):
101        if isinstance(other, Tone):
102            if other not in self.tones:
103                raise TypeError(f"Cannot remove tone {other} from chord "
104                                f"{self}")
105            elif len(self.tones) == 2:
106                raise TypeError("Cannot have a chord made of only 1 unique "
107                                "tone")
108
109            return Chord(*[tone for tone in self.tones if tone != other])
110        raise TypeError("Invalid operation")
111
112    def is_major(self) -> bool:
113        root_tone_index = self.tones[0].name_index
114
115        for secondary_tone in self.tones[1:]:
116            temp_interval = Interval(abs(root_tone_index -
117                                         secondary_tone.name_index))
118
119            if temp_interval == Chord.major_chord_interval:
120                return True
121
122        return False
123
124    def is_minor(self) -> bool:
125        root_tone_index = self.tones[0].name_index
126
127        for secondary_tone in self.tones[1:]:
128            temp_interval = Interval(abs(root_tone_index -
129                                         secondary_tone.name_index))
130
131            if temp_interval == Chord.minor_chord_interval:
132                return True
133
134        return False
135
136    def is_power_chord(self) -> bool:
137        root_tone_index = self.tones[0].name_index
138
139        for secondary_tone in self.tones[1:]:
140            temp_interval = Interval(abs(root_tone_index -
141                                         secondary_tone.name_index))
142
143            if (temp_interval == Chord.major_chord_interval
144                    or temp_interval == Chord.minor_chord_interval):
145                return False
146
147        return True
148
149    def transposed(self, interval: Interval):
150        return Chord(*[tone + interval for tone in self.tones])