1def get_molecule_mass(effect_name):
  2    molecule_mass = 0
  3    for letter in effect_name:
  4        print(letter)
  5        molecule_mass += ord(letter)
  6        
  7    return molecule_mass
  8
  9class Effect:
 10    
 11    def __init__(self, name, effect):
 12        self.name = name
 13        self.effect = effect
 14        self.part_of_something_bigger = False
 15        self.called = False
 16        self.intensity = 1
 17        
 18    def increment_intensity(self):
 19        self.intensity += 1  
 20    
 21    def __call__(self, target):
 22        if self.called:
 23            raise TypeError('Effect is depleted.')
 24        
 25        if self.part_of_something_bigger:
 26            raise TypeError('Potion is now part of something bigger than itself.')
 27        
 28        for _ in range (self.intensity):
 29            self.effect(target)
 30        self.called = True
 31
 32
 33class Potion:
 34    
 35    def __init__(self, effects, duration):
 36        self.effect = {}
 37        self.object_effects = {}
 38        self.duration = duration
 39        self.called = False
 40        self.part_of_something_bigger = False
 41        for effect_name in effects.keys():
 42            if effect_name in self.effect.keys():
 43                self.object_effects[effect_name].increment_intensity()
 44            else:
 45                current_effect = Effect(effect_name, effects[effect_name])
 46                self.effect[effect_name] = effects[effect_name]
 47                self.object_effects[effect_name] = current_effect
 48                setattr(self, effect_name, current_effect)
 49    
 50    def __add__(self, other):
 51        if self.called is True or other.called is True:
 52            raise TypeError('Potion is depleted.')
 53        if self.part_of_something_bigger is True or other.part_of_something_bigger is True:
 54            raise TypeError('Potion is now part of something bigger than itself.')
 55        self.part_of_something_bigger = True
 56        other.part_of_something_bigger = True
 57        new_potion_effects = self.effect | other.effect
 58        new_potion_duration = max(self.duration, other.duration)
 59        new_potion =  Potion(new_potion_effects, new_potion_duration)
 60        
 61        for effect_name in new_potion.object_effects:
 62            new_potion.object_effects[effect_name].intensity = 0
 63            if effect_name in self.object_effects and not self.object_effects[effect_name].called:
 64                new_potion.object_effects[effect_name].intensity += self.object_effects[effect_name].intensity
 65                self.object_effects[effect_name].part_of_something_bigger = True
 66            if effect_name in other.object_effects and not other.object_effects[effect_name].called:
 67                new_potion.object_effects[effect_name].intensity += other.object_effects[effect_name].intensity
 68                other.object_effects[effect_name].part_of_something_bigger = True
 69        
 70        for effect_name in self.object_effects:
 71            if (effect_name in other.object_effects and
 72                self.object_effects[effect_name].called and
 73                other.object_effects[effect_name].called):
 74                new_potion.object_effects.pop(effect_name)
 75                new_potion.effect.pop(effect_name)
 76                delattr(new_potion, effect_name)
 77        
 78        return new_potion
 79    
 80    def __mul__(self, other):
 81        if self.called:
 82            raise TypeError('Potion is depleted.')
 83        if self.part_of_something_bigger:
 84            raise TypeError('Potion is now part of something bigger than itself.')
 85        self.part_of_something_bigger = True
 86        new_potion = Potion(self.effect, self.duration)
 87        
 88        for effect_name in self.object_effects:
 89            if self.object_effects[effect_name].called:
 90                new_potion.object_effects.pop(effect_name)
 91                new_potion.effect.pop(effect_name)
 92                delattr(new_potion, effect_name)
 93                continue
 94            new_potion.object_effects[effect_name].intensity = self.object_effects[effect_name].intensity
 95            self.object_effects[effect_name].part_of_something_bigger = True
 96        for effect_name in new_potion.object_effects:
 97            new_potion.object_effects[effect_name].intensity = int(round(new_potion.object_effects[effect_name].intensity * other, 0))
 98        return new_potion
 99    
100    def __sub__(self, other):
101        if self.called is True or other.called is True:
102            raise TypeError('Potion is depleted.')
103        if self.part_of_something_bigger is True or other.part_of_something_bigger is True:
104            raise TypeError('Potion is now part of something bigger than itself.')
105        self.part_of_something_bigger = True
106        other.part_of_something_bigger = True
107        new_potion = Potion(self.effect, self.duration)
108        
109        for effect_name in self.object_effects:
110            new_potion.object_effects[effect_name].intensity = self.object_effects[effect_name].intensity
111            self.object_effects[effect_name].part_of_something_bigger = True
112            if effect_name in other.object_effects:
113                other.object_effects[effect_name].part_of_something_bigger = True
114
115        for effect_name in other.object_effects:
116            if effect_name not in  new_potion.object_effects.keys():
117                raise TypeError('cannot remove non-existent effects')
118            if other.object_effects[effect_name].called:
119                continue
120            if new_potion.object_effects[effect_name].intensity > other.object_effects[effect_name].intensity:
121                new_potion.object_effects[effect_name].intensity -= other.object_effects[effect_name].intensity
122            else:
123                new_potion.object_effects.pop(effect_name)
124                new_potion.effect.pop(effect_name)
125                delattr(new_potion, effect_name)
126                
127        for effect_name in self.object_effects:
128            if self.object_effects[effect_name].called:
129                new_potion.object_effects.pop(effect_name)
130                new_potion.effect.pop(effect_name)
131                delattr(new_potion, effect_name)
132        return new_potion
133    
134    def __truediv__(self, other): 
135        potions = []
136        for _ in range(other):
137            potions.append(self * (1 / other))
138            self.part_of_something_bigger = False
139            for effect_name in self.object_effects:
140                self.object_effects[effect_name].part_of_something_bigger = False
141        
142        self.part_of_something_bigger = True
143        for effect_name in self.object_effects:
144            self.object_effects[effect_name].part_of_something_bigger = True
145        return potions
146    
147    def __eq__(self, other):
148        if self.called is True or other.called is True:
149            raise TypeError('Potion is depleted.')
150        if self.effect != other.effect:
151            return False
152        for effect_name in self.object_effects:
153            if (effect_name not in other.object_effects or 
154                    other.object_effects[effect_name].intensity != self.object_effects[effect_name].intensity):
155                return False
156        
157        return True
158    
159    def __lt__(self, other):
160        if self.called is True or other.called is True:
161            raise TypeError('Potion is depleted.')
162        self_intensity = 0
163        for effect in self.object_effects.values():
164            self_intensity += effect.intensity
165        other_intensity = 0
166        for effect in other.object_effects.values():
167            other_intensity += effect.intensity
168            
169        return self_intensity < other_intensity
170    
171    def __gt__(self, other):
172        return other < self
173    
174    
175class ГоспожатаПоХимия:
176    
177    def apply(self, target, potion):
178        if potion.called is True:
179            raise TypeError('Potion is depleted.')
180        
181        sorted_effects = list(sorted(potion.object_effects, key=lambda item: get_molecule_mass(item), reverse=True))
182        for effect in sorted_effects:
183            if potion.object_effects[effect].called is not True:
184                potion.object_effects[effect](target)
185        potion.called = True
186        
187    def tick(self):
188        pass
189