1TONES = ('C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B')
  2INTERVALS = ('unison', 'minor 2nd', 'major 2nd', 'minor 3rd', 'major 3rd',
  3             'perfect 4th', 'diminished 5th', 'perfect 5th',
  4             'minor 6th', 'major 6th', 'minor 7th', 'major 7th')
  5
  6
  7class Tone(int):
  8    """Represent a musical tone."""
  9
 10    def __new__(cls, tone):
 11        """Create instance based on string or normalized int."""
 12        if isinstance(tone, str):
 13            tone = TONES.index(tone)
 14        if isinstance(tone, int):
 15            tone = tone % len(TONES)
 16        return super().__new__(cls, tone)
 17    
 18    def __str__(self):
 19        """String representation of a tone."""
 20        return TONES[self]
 21    
 22    def __add__(self, other):
 23        """Define adding something to tone."""
 24        if isinstance(other, Tone):
 25            return Chord(Tone(self), Tone(other))
 26        if isinstance(other, Interval):
 27            return Tone(int(self) + int(other))
 28        return super().__add__(other)
 29    
 30    def __sub__(self, other):
 31        """Define subtracting something from tone."""
 32        if isinstance(other, Tone):
 33            return Interval(int(self) - int(other))
 34        if isinstance(other, Interval):
 35            return Tone(int(self) - int(other))
 36        return super().__sub__(other)
 37
 38
 39class Interval(int):
 40    """Represent a musical interval."""
 41
 42    def __new__(cls, length):
 43        """Create instance based on normalized int."""
 44        if isinstance(length, int):
 45            length = length % len(INTERVALS)
 46        return super().__new__(cls, length)
 47
 48    def __str__(self):
 49        """String representation of an interval."""
 50        return INTERVALS[self]
 51
 52    def __neg__(self):
 53        """Negative value of an interval."""
 54        return Interval(-int(self))
 55
 56    def __add__(self, other):
 57        """Define adding something to interval."""
 58        if isinstance(other, Tone):
 59            raise TypeError('Invalid operation')
 60        if isinstance(other, Interval):
 61            return Interval(int(self) + int(other))
 62        return super().__add__(other)
 63    
 64    def __sub__(self, other):
 65        """Define subtacting something from interval."""
 66        if isinstance(other, Tone):
 67            raise TypeError('Invalid operation')
 68        if isinstance(other, Interval):
 69            return Interval(int(self) - int(other))
 70        return super().__add__(other)
 71
 72
 73class Chord:
 74    """Represent a musical chord."""
 75
 76    MIN_TONES = 2
 77    MINOR_3RD = 'minor 3rd'
 78    MAJOR_3RD = 'major 3rd'
 79    MINOR_3RD_INTERVAL = Interval(INTERVALS.index(MINOR_3RD))
 80    MAJOR_3RD_INTERVAL = Interval(INTERVALS.index(MAJOR_3RD))
 81
 82    def __init__(self, root, *rest):
 83        """Initialize, keeping all tones passed as input."""
 84        sorted_tones = sorted(set((root,) + rest),
 85                              key=lambda tone: TONES.index(str(tone)))
 86        root_index = sorted_tones.index(root)
 87        self.tones = sorted_tones[root_index:] + sorted_tones[:root_index]
 88        if len(self.tones) < self.MIN_TONES:
 89            raise TypeError('Cannot have a chord made of only 1 unique tone')
 90
 91    def __str__(self):
 92        """String representation of the chord."""
 93        return "-".join(map(str, self.tones))
 94    
 95    def __add__(self, other):
 96        """Define adding something to a chord."""
 97        if isinstance(other, Tone):
 98            # Root is also found in self.tones, but who cares...
 99            # Initializing a Chord will remove the duplicates anyway.
100            # No need to duplicate this behaviour here.
101            return Chord(self.root, *(self.tones + [other]))
102        if isinstance(other, Chord):
103            return Chord(*(self.tones + other.tones))
104        raise NotImplementedError
105    
106    def __sub__(self, other):
107        """Define subtracting something from a chord."""
108        if isinstance(other, Tone):
109            if other not in self.tones:
110                raise TypeError(f'Cannot remove tone {other} from chord {self}')
111            return Chord(*list(filter(other.__ne__, self.tones)))
112        raise NotImplementedError
113
114    @property
115    def root(self):
116        """Get root of the chord."""
117        return self.tones[0]
118
119    def transposed(self, interval):
120        """Transpose a chord by an interval."""
121        return Chord(*map(Tone, map(interval.__radd__, self.tones)))
122    
123    def is_minor(self):
124        """Return boolean based on whether the chord is minor."""
125        return self.root + self.MINOR_3RD_INTERVAL in self.tones
126    
127    def is_major(self):
128        """Return boolean based on whether the chord is major."""
129        return self.root + self.MAJOR_3RD_INTERVAL in self.tones
130    
131    def is_power_chord(self):
132        """Return boolean based on whether the chord is power."""
133        return not (self.is_minor() or self.is_major())