1class Tone:
  2    """Represent a musical tone."""
  3    
  4    TONE_SCALE = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
  5    
  6    def __init__(self, name):
  7        self.name = name
  8        
  9    def __str__(self):
 10        return self.name
 11    
 12    def __int__(self):
 13        return Tone.TONE_SCALE.index(self.name)
 14    
 15    def __eq__(self, other):
 16        return self.name == other.name
 17    
 18    def __hash__(self):
 19        """Return a hash value for the Tone object using its name."""
 20        return hash(self.name)
 21    
 22    def __add__(self, other):
 23        if isinstance(other, Tone):
 24            return Chord(self, other)
 25        elif isinstance(other, Interval):
 26            new_tone_index = Tone.TONE_SCALE.index(self.name) + other.semitone
 27            return Tone(Tone.TONE_SCALE[new_tone_index % len(Tone.TONE_SCALE)])
 28        raise TypeError("Invalid operation")
 29    
 30    def __radd__(self, other):
 31        if isinstance(other, Interval):
 32            raise TypeError("Invalid operation")
 33    
 34    def __sub__(self, other):
 35        if isinstance(other, Tone):
 36            return Interval((int(self) - int(other)) % len(Tone.TONE_SCALE))
 37        elif isinstance(other, Interval):
 38            new_tone_index = Tone.TONE_SCALE.index(self.name) - other.semitone
 39            return Tone(Tone.TONE_SCALE[new_tone_index % len(Tone.TONE_SCALE)])
 40        raise TypeError("Invalid operation")
 41    
 42    def __rsub__(self, other):
 43        if isinstance(other, Interval):
 44            raise TypeError("Invalid operation")
 45
 46
 47class Interval:
 48    """Represent a music interval."""
 49    
 50    SEMITONE_NAMES = (
 51        "unison", "minor 2nd", "major 2nd", "minor 3rd", "major 3rd",
 52        "perfect 4th", "diminished 5th", "perfect 5th", "minor 6th",
 53        "major 6th", "minor 7th", "major 7th"
 54    )
 55    
 56    def __init__(self, semitone):
 57        if not isinstance(semitone, int):
 58            raise TypeError("Invalid semitone")
 59            
 60        self.semitone = semitone % len(Interval.SEMITONE_NAMES)
 61        
 62    def __str__(self):
 63        return Interval.SEMITONE_NAMES[self.semitone]
 64      
 65    def __neg__(self):
 66        return Interval(-self.semitone)
 67    
 68    def __add__(self, other):
 69        if isinstance(other, Interval):
 70            return Interval(self.semitone + other.semitone)
 71        raise TypeError("Invalid operation")
 72    
 73    def __sub__(self, other):
 74        if isinstance(other, Interval):
 75            return Interval(self.semitone - other.semitone)
 76        raise TypeError("Invalid operation")
 77
 78
 79class Chord:
 80    """Represent a music chord."""
 81    
 82    def __init__(self, *tones):
 83        
 84        unique_tones = list(set(tones))
 85        if len(unique_tones) <= 1:
 86            raise TypeError("Cannot have a chord made of only 1 unique tone")
 87
 88        if not all(isinstance(tone, Tone) for tone in unique_tones):
 89            raise TypeError("Invalid Tone found")
 90        
 91        self.root = tones[0]
 92        self.tones = list(filter(lambda tone: tone != self.root, unique_tones))
 93
 94    def sort_tones(self):
 95        """Sort the tones relatively."""
 96        
 97        root_index = Tone.TONE_SCALE.index(str(self.root))
 98        relative_scale = Tone.TONE_SCALE[root_index:] + Tone.TONE_SCALE[:root_index]
 99        
100        return sorted(self.tones, key=lambda tone: relative_scale.index(str(tone)))
101
102    def __str__(self):
103        sorted_tones = self.sort_tones()
104        return f'{self.root}-{"-".join(map(str, sorted_tones))}'
105    
106    def find_new_value(self, tone, interval):
107        """Set new values after transpose."""
108        
109        if not isinstance(interval, Interval):
110            raise TypeError("Invalid Interval")
111
112        new_tone_index = Tone.TONE_SCALE.index(str(tone)) + interval.semitone
113        return Tone(Tone.TONE_SCALE[new_tone_index % len(Tone.TONE_SCALE)])
114            
115    def transposed(self, interval):
116        if not isinstance(interval, Interval):
117            raise TypeError("Invalid operation")
118
119        transposed_root = self.find_new_value(self.root, interval)
120        transposed_tones = [self.find_new_value(tone, interval) for tone in self.tones]
121        
122        return Chord(*([transposed_root] + transposed_tones))
123        
124    def is_minor(self):
125        return any(str(tone - self.root) == "minor 3rd" for tone in self.tones)
126    
127    def is_major(self):
128        return any(str(tone - self.root) == "major 3rd" for tone in self.tones)
129    
130    def is_power_chord(self):
131        return not self.is_major() and not self.is_minor()
132    
133    def __add__(self, other):
134        if isinstance(other, Tone):
135            return Chord(*([self.root] + self.tones + [other]))
136        elif isinstance(other, Chord):
137            return Chord(*([self.root] + self.tones + [other.root] + other.tones))
138        raise TypeError("Invalid operation")
139    
140    def __sub__(self, other):
141        if isinstance(other, Tone):
142            new_tones = [self.root] + self.tones
143            if other not in new_tones:
144                raise TypeError (f"Cannot remove tone {other} from chord {self}")
145            
146            new_tones.remove(other)
147            return Chord(*new_tones)
148        raise TypeError("Invalid operation")