1class Potion:
  2    
  3    def __init__(self, effects, duration):
  4        self.effects = effects
  5        self.duration = duration
  6        self.applied_effects = set()
  7        self.intensity = {effect_name: 1 for effect_name in self.effects.keys()}
  8        self.used = False
  9
 10    def apply_effect(self, effect, target):
 11        if self.used:
 12            raise TypeError("Potion is now part of something bigger than itself.")
 13        
 14        if effect in self.applied_effects:
 15            raise TypeError("Effect is depleted.")
 16        
 17        self.applied_effects.add(effect)
 18        for _ in range(self.intensity[effect]):
 19            self.effects[effect](target)
 20        self.intensity[effect] = 0
 21
 22    def __getattr__(self, effect):
 23        if self.used:
 24            raise TypeError("Potion is now part of something bigger than itself.")
 25        
 26        if effect not in self.effects:
 27            raise AttributeError(f"'Potion' object has no attribute '{effect}'")
 28        
 29        return lambda target: self.apply_effect(effect, target)
 30    
 31    def __add__(self, other_potion):
 32        if self.used or other_potion.used:
 33            raise TypeError("Potion is now part of something bigger than itself.")
 34        
 35        new_combined_duration = max(self.duration, other_potion.duration)
 36        new_combined_effects = {effect_name: effect_method for effect_name, effect_method in self.effects.items() if effect_name not in self.applied_effects}
 37        new_combined_intensity = {effect_name: effect_intensity for effect_name, effect_intensity in self.intensity.items() if effect_name not in self.applied_effects}
 38
 39        for effect_name in other_potion.effects:
 40            if effect_name in other_potion.applied_effects:
 41                continue
 42            if effect_name in new_combined_effects.keys():
 43                new_combined_intensity[effect_name] += other_potion.intensity[effect_name]
 44            else:
 45                new_combined_intensity[effect_name] = other_potion.intensity[effect_name]
 46                new_combined_effects[effect_name] = other_potion.effects[effect_name]
 47
 48        self.used = True
 49        other_potion.used = True
 50        new_potion = Potion(new_combined_effects, new_combined_duration)
 51        new_potion.intensity = new_combined_intensity
 52        return new_potion
 53    
 54    def round_intensity_by_remainder(self, current_intensity):
 55        """Helper function to round down intensity when the result is <= x.5 and round up when > x.5"""
 56
 57        for effect_name, result in current_intensity.items():
 58            whole_part_of_result = int(result)
 59            diff_results = result - whole_part_of_result
 60            if diff_results <= 0.5:
 61                current_intensity[effect_name] = whole_part_of_result
 62            else:
 63                current_intensity[effect_name] = whole_part_of_result + 1
 64
 65    def __mul__(self, number):
 66        if self.used:
 67            raise TypeError("Potion is now part of something bigger than itself.")
 68        
 69        new_combined_effects = {effect_name: effect_method for effect_name, effect_method in self.effects.items() if effect_name not in self.applied_effects}
 70        new_multiple_intensity = {effect_name: self.intensity[effect_name] * number for effect_name in self.intensity.keys() if effect_name not in self.applied_effects}
 71        new_multiple_duration = self.duration
 72
 73        self.round_intensity_by_remainder(new_multiple_intensity)
 74
 75        self.used = True
 76        new_potion = Potion(new_combined_effects, new_multiple_duration)
 77        new_potion.intensity = new_multiple_intensity
 78        return new_potion
 79    
 80    def __sub__(self, other_potion):
 81        if self.used or other_potion.used:
 82            raise TypeError("Potion is now part of something bigger than itself.")
 83        
 84        if not all(effect in self.effects for effect in other_potion.effects):
 85            raise TypeError("Right potion effects are not in left potion effects ;()")
 86        
 87        new_sub_effects = {effect_name: effect_method for effect_name, effect_method in self.effects.items() if effect_name not in self.applied_effects}
 88        new_sub_intensity = {effect_name: effect_intensity for effect_name, effect_intensity in self.intensity.items() if effect_name not in self.applied_effects}
 89        new_sub_duration = self.duration
 90
 91        for effect_name in self.intensity:
 92            if effect_name in self.applied_effects:
 93                continue
 94            if effect_name in other_potion.effects and effect_name not in other_potion.applied_effects:
 95                if new_sub_intensity[effect_name] - other_potion.intensity[effect_name] <= 0:
 96                    del new_sub_effects[effect_name]
 97                    del new_sub_intensity[effect_name]
 98                else:
 99                    new_sub_intensity[effect_name] -= other_potion.intensity[effect_name]
100
101        self.used = True
102        other_potion.used = True
103        new_potion = Potion(new_sub_effects, new_sub_duration)
104        new_potion.intensity = new_sub_intensity
105        return new_potion
106    
107    def __truediv__(self, number):
108        if self.used:
109            raise TypeError("Potion is now part of something bigger than itself.")
110        
111        new_div_effects = {effect_name: effect_method for effect_name, effect_method in self.effects.items() if effect_name not in self.applied_effects}
112        new_div_intensity = {effect_name: self.intensity[effect_name] / number for effect_name in self.intensity.keys() if effect_name not in self.applied_effects}
113        new_div_duration = self.duration
114
115        self.round_intensity_by_remainder(new_div_intensity)
116
117        self.used = True
118        result_potions = []
119        for _ in range(number):
120            new_potion = Potion(new_div_effects, new_div_duration)
121            new_potion.intensity = dict(new_div_intensity)
122            result_potions.append(new_potion)
123
124        return result_potions
125    
126    def __hash__(self):
127        return hash(tuple(sorted(self.effects.items())))
128
129    def __eq__(self, other_potion):
130        if self.used or other_potion.used:
131            raise TypeError("Potion is now part of something bigger than itself.")
132        
133        return self.effects == other_potion.effects and self.intensity == other_potion.intensity
134    
135    def __lt__(self, other_potion):
136        if self.used or other_potion.used:
137            raise TypeError("Potion is now part of something bigger than itself.")
138        
139        return sum(self.intensity.values()) < sum(other_potion.intensity.values())
140    
141    
142class ГоспожатаПоХимия:
143    
144    def __init__(self):
145        self.applied_potions = set()
146        self.targets_variables = {}
147        self.target_potions = {}
148
149    def apply(self, target, potion):
150        if potion in self.applied_potions:
151            raise TypeError("Potion is depleted.")
152
153        if potion.used:
154            raise TypeError("Potion is now part of something bigger than itself.")
155
156        if target not in self.targets_variables.keys():
157            self.targets_variables[target] = dict(vars(target))
158            self.target_potions[target] = set()
159
160        self.applied_potions.add(potion)
161
162        self.target_potions[target].add(potion)
163        effects_sorted = sorted(potion.effects.keys(), key=lambda effect_name: sum(map(ord, effect_name)), reverse=True)
164
165        for effect in effects_sorted:
166            if effect not in potion.applied_effects and potion.duration != 0:
167                potion.apply_effect(effect, target)
168
169        potion.used = True
170
171    def reset_target(self, target):
172        for variable in self.targets_variables[target]:
173            target.__setattr__(variable, self.targets_variables[target][variable])
174
175    def tick(self):
176        """A function that reduces the duration of potions.
177        As soon as the duration of a potion becomes 0, it is removed and the target state reset to its original, 
178        but in order not to lose the magic of the ramaining potions, we apply them again.(Because we have hidden some in our pocket. ;) )"""
179
180        is_poped_potion = False
181        for target, potions in self.target_potions.items():
182            for potion in potions:
183                potion.duration -= 1
184                if potion.duration == 0:
185                    self.reset_target(target)
186                    self.target_potions[target].remove(potion)
187                    is_poped_potion = True
188                if is_poped_potion:
189                    for potion in potions:
190                        potion.duration -= 1
191                        for effect in potion.effects:
192                            potion.effects[effect](target)
193                    break