1class Tone:
  2    """Implement a tone."""
  3
  4    TONES = ('C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B')
  5
  6    def __key(self):
  7        """Create a private key so tone is hashable."""
  8        return str(self.tone)
  9
 10    def __init__(self, tone):
 11        self.tone = tone
 12
 13    def __str__(self):
 14        return self.tone
 15
 16    def __eq__(self, other):
 17        return str(self) == str(other)
 18
 19    def __hash__(self):
 20        return hash(self.__key())
 21
 22    def __add__(self, other):
 23        """Add Tone + Tone or Tone + Interval."""
 24        if isinstance(other, Tone):
 25            return Chord(self, other)
 26        elif isinstance(other, Interval):
 27            idx = (Tone.TONES.index(self) + other.num_of_semitones) % len(Tone.TONES)
 28            return Tone(Tone.TONES[idx])
 29
 30    def __sub__(self, other):
 31        """Subtract Tone - Tone or Tone - Interval."""
 32        if isinstance(other, Tone):
 33            return Interval((Tone.TONES.index(self) - Tone.TONES.index(other)) % len(Tone.TONES))
 34        elif isinstance(other, Interval):
 35            idx = (Tone.TONES.index(self) - other.num_of_semitones) % len(Tone.TONES)
 36            return Tone(Tone.TONES[idx])
 37
 38
 39class Interval:
 40    """Implement an interval."""
 41
 42    INTERVALS = {
 43        0: 'unison',
 44        1: 'minor 2nd',
 45        2: 'major 2nd',
 46        3: 'minor 3rd',
 47        4: 'major 3rd',
 48        5: 'perfect 4th',
 49        6: 'diminished 5th',
 50        7: 'perfect 5th',
 51        8: 'minor 6th',
 52        9: 'major 6th',
 53        10: 'minor 7th',
 54        11: 'major 7th'
 55    }
 56
 57    def __init__(self, num_of_semitones):
 58        self.num_of_semitones = num_of_semitones % 12
 59
 60    def __str__(self):
 61        return self.INTERVALS[self.num_of_semitones]
 62
 63    def __add__(self, other):
 64        """Add Interval + Interval."""
 65        if isinstance(other, Tone):
 66            raise TypeError("Invalid operation")
 67        elif isinstance(other, Interval):
 68            return Interval(self.num_of_semitones + other.num_of_semitones)
 69
 70    def __sub__(self, other):
 71        """Invalidate subtraction Interval - Tone."""
 72        if isinstance(other, Tone):
 73            raise TypeError("Invalid operation")
 74
 75    def __neg__(self):
 76        """Support the creation of such intervals: -Interval(5)."""
 77        return Interval(len(Tone.TONES) - self.num_of_semitones)
 78
 79    @classmethod
 80    def init_from_tones(cls, tone1, tone2):
 81        """Initialize interval from 2 tones."""
 82        return cls(abs(Tone.TONES.index(tone1) - Tone.TONES.index(tone2)))
 83
 84
 85class Chord:
 86    """Implement a chord."""
 87
 88    INDEX_MINOR = 3 # index in interval.INTERVALS for minor 3rd
 89    INDEX_MAJOR = 4 # index in interval.INTERVALS for major 3rd
 90
 91    def __init__(self, main_tone, *args):
 92        self.main_tone = main_tone
 93        self.tones = list(args)
 94        self.tones.append(self.main_tone)
 95        self._sort_tones()
 96        if len(self.tones) < 2:
 97            raise TypeError('Cannot have a chord made of only 1 unique tone')
 98
 99    def __str__(self):
100        return f'{'-'.join(map(str, self.tones))}'
101
102    def __add__(self, other):
103        """Add Chord + Tone or Chord + Chord."""
104        if isinstance(other, Tone):
105            return Chord(self.main_tone, *(self.tones + [other]))
106        if isinstance(other, Chord):
107            return Chord(self.main_tone, *(self.tones + other.tones))
108
109    def __sub__(self, other):
110        """Subtract Chord - Tone."""
111        if isinstance(other, Tone):
112            if other in self.tones:
113                new_tones = self.tones[:]
114                new_tones.remove(other)
115                new_main_tone = new_tones[0]
116                return Chord(new_main_tone, *new_tones)
117            else:
118                raise TypeError(f'Cannot remove tone {other} from chord {self}')
119
120    def _sort_tones(self):
121        """Sort all tones in chord relative to the main tone."""
122        main_tone_idx = Tone.TONES.index(self.main_tone)
123        tones_unique = set(self.tones) # because of the hash func the tones are saved as strings
124        all_tones_sorted = Tone.TONES[main_tone_idx:] + Tone.TONES[:main_tone_idx]
125        self.tones = list(map(Tone, filter(lambda tone: tone in tones_unique, all_tones_sorted)))
126
127    def _check_for_special_tone(self, idx):
128        """Check if there is any tone that makes a special tone with root based on idx given."""
129        return any(str(Interval.init_from_tones(self.main_tone, tone)) == Interval.INTERVALS[idx] for tone in self.tones)
130
131    def is_minor(self):
132        """Check if chord is minor."""
133        return self._check_for_special_tone(self.INDEX_MINOR)
134
135    def is_major(self):
136        """Check if chord is major."""
137        return self._check_for_special_tone(self.INDEX_MAJOR)
138
139    def is_power_chord(self):
140        """Check if tone is power chord."""
141        return not self.is_minor() and not self.is_major()
142
143    def transposed(self, interval):
144        """Transpose by interval."""
145        return Chord(self.main_tone + interval, *list(map(lambda tone: tone + interval, self.tones)))