1import math
  2import copy
  3
  4
  5def custom_round(result):
  6    fractional_part = result % 1
  7
  8    if fractional_part == 0:
  9        rounded_result = result
 10    elif fractional_part <= 0.5:
 11        rounded_result = math.floor(result)
 12    else:
 13        rounded_result = math.ceil(result)
 14
 15    return int(rounded_result)
 16
 17
 18class FunctionWrapper:
 19    """A class used to implement function intensities"""
 20
 21    def __init__(self, func, number_of_calls):
 22        self.func = func
 23        self.number_of_calls = number_of_calls
 24
 25    def __call__(self, *args, **kwargs):
 26        for _ in range(self.number_of_calls):
 27            self.func(*args, **kwargs)
 28
 29    def __mul__(self, number):
 30        """Multiply a function with a given number"""
 31        result_function = FunctionWrapper(self.func, self.number_of_calls)
 32        result_function.number_of_calls = custom_round(self.number_of_calls * number)
 33        return result_function
 34
 35    def __add__(self, other):
 36        """Combine effects of functions"""
 37        result_function = FunctionWrapper(self.func, self.number_of_calls)
 38
 39        # if the other function hasn't been wrapped yet
 40        if not isinstance(other, FunctionWrapper):
 41            result_function.number_of_calls += 1
 42        else:
 43            result_function.number_of_calls += other.number_of_calls
 44        return result_function
 45
 46    def __truediv__(self, number):
 47        """Divide effects of a function"""
 48        result_function = FunctionWrapper(self.func, self.number_of_calls)
 49        result_function.number_of_calls = custom_round(result_function.number_of_calls / number)
 50        return result_function
 51
 52
 53class Potion:
 54    def __init__(self, effects, duration):
 55        # since the functions in the dictionary will be changed (wrapped), deep copy it
 56        self.effects = copy.deepcopy(effects)
 57        self.duration = duration
 58
 59        self.usable = True
 60        self.is_depleted = False
 61        # Store keys of depleted effects here
 62        self.depleted_effects = set()
 63
 64        # Wrap all functions that are still not wrapped to make operations on them easier
 65        for key in self.effects:
 66            if not isinstance(self.effects[key], FunctionWrapper):
 67                wrapped_function = FunctionWrapper(self.effects[key], 1)
 68                self.effects[key] = wrapped_function
 69
 70    def perform_checks(self):
 71        if self.is_depleted:
 72            raise TypeError("Potion is depleted.")
 73        if not self.usable:
 74            raise TypeError("Potion is now part of something bigger than itself.")
 75
 76    def __getattribute__(self, item):
 77        if item in object.__getattribute__(self, 'effects'):
 78            self.perform_checks()
 79            if item not in self.depleted_effects:
 80                self.depleted_effects.add(item)
 81                if len(self.effects) == len(self.depleted_effects):
 82                    self.is_depleted = True
 83                return object.__getattribute__(self, 'effects')[item]
 84            else:
 85                raise TypeError("Effect is depleted.")
 86        return object.__getattribute__(self, item)
 87
 88    def __add__(self, other):
 89        self.perform_checks()
 90        other.perform_checks()
 91
 92        max_duration = max(self.duration, other.duration)
 93
 94        # merge the two dictionaries of effects together
 95        effects_merged = other.effects.copy()
 96        # if there are common keys, their values will be overwritten
 97        effects_merged.update(self.effects.copy())
 98
 99        result_potion = Potion(effects_merged, max_duration)
100
101        # get the common functions for the potions
102        common_names = set(self.effects.keys()) & set(other.effects.keys())
103        for name in common_names:
104            result_potion.effects[name].number_of_calls += other.effects[name].number_of_calls
105
106        self.usable = False
107        other.usable = False
108        return result_potion
109
110    def __mul__(self, number):
111        self.perform_checks()
112
113        multiplied_effects = dict(self.effects)
114
115        for key in multiplied_effects:
116            multiplied_effects[key] = multiplied_effects[key] * number
117
118        multiplied_potion = Potion(multiplied_effects, self.duration)
119
120        self.usable = False
121        return multiplied_potion
122
123    def __sub__(self, other):
124        self.perform_checks()
125        other.perform_checks()
126
127        # Compare the keys of the two potions using set operations
128        if not set(other.effects.keys()).issubset(set(self.effects.keys())):
129            raise TypeError("Different effects in right potion")
130
131        purified = Potion(self.effects, self.duration)
132        common_names = set(self.effects.keys()) & set(other.effects.keys())
133
134        for name in common_names:
135            left_intensity = self.effects[name].number_of_calls
136            right_intensity = other.effects[name].number_of_calls
137
138            if right_intensity >= left_intensity:
139                purified.effects.pop(name)
140            else:
141                purified.effects[name].number_of_calls = left_intensity - right_intensity
142
143        self.usable = False
144        other.usable = False
145        return purified
146
147    def __truediv__(self, number):
148        self.perform_checks()
149
150        divided_effects = {key: value / number for key, value in self.effects.items()}
151        self.usable = False
152        return tuple(Potion(divided_effects, self.duration) for _ in range(number))
153
154    def __eq__(self, other):
155        self.perform_checks()
156        other.perform_checks()
157
158        for key in self.effects:
159            if key not in other.effects:
160                return False
161            if other.effects[key].number_of_calls != self.effects[key].number_of_calls:
162                return False
163        return True
164
165    @staticmethod
166    def calculate_sums(left_potion, right_potion):
167        """Calculate sums of effect intensities for two potions"""
168        sum_left = 0
169        sum_right = 0
170
171        for key in left_potion.effects:
172            sum_left += left_potion.effects[key].number_of_calls
173
174        for key in right_potion.effects:
175            sum_right += right_potion.effects[key].number_of_calls
176
177        return sum_left, sum_right
178
179    def __lt__(self, other):
180        self.perform_checks()
181        other.perform_checks()
182
183        sum_self, sum_other = Potion.calculate_sums(self, other)
184        return sum_self < sum_other
185
186    def __gt__(self, other):
187        self.perform_checks()
188        other.perform_checks()
189
190        sum_self, sum_other = Potion.calculate_sums(self, other)
191        return sum_self > sum_other
192
193    def __ge__(self, other):
194        return NotImplemented
195
196    def __le__(self, other):
197        return NotImplemented
198
199
200class ГоспожатаПоХимия:
201    def __init__(self):
202        # for each target, store its original attributes
203        self.initial_states = dict()
204        # original effects of each potion
205        self.effects = dict()
206        # remaining times for all active potions
207        self.times = dict()
208        # associate each potion with a target
209        self.targets = dict()
210
211    def restore_target_initial_state(self, target):
212        for attribute, value in self.initial_states[id(target)].items():
213            setattr(target, attribute, value)
214
215    def apply(self, target, potion):
216        if potion.is_depleted:
217            raise TypeError("Potion is depleted.")
218
219        if id(target) not in self.initial_states.keys():
220            attributes_before_change = copy.deepcopy(target.__dict__)
221            self.initial_states[id(target)] = attributes_before_change
222
223        self.effects[id(potion)] = []
224        self.times[id(potion)] = potion.duration
225        self.targets[id(potion)] = target
226
227        unused_effects = sorted(set(potion.effects.keys()) - potion.depleted_effects,
228                                key=lambda x: sum(ord(c) for c in x),
229                                reverse=True)
230
231        for unused_effect in unused_effects:
232            effect = potion.__getattribute__(unused_effect)
233            self.effects[id(potion)].append(copy.deepcopy(effect))
234            effect(target)
235
236        potion.is_depleted = True
237
238    def reapply_active_potions(self, target):
239        for key in self.effects:
240            if self.times[key] == 0:
241                continue
242            for effect in self.effects[key]:
243                number_of_calls = effect.number_of_calls
244                effect(target)
245                effect.number_of_calls = number_of_calls
246
247    def tick(self):
248        to_remove = []
249
250        for key in self.times:
251            self.times[key] -= 1
252
253        for key in self.times:
254            # restore the old state of 'target' and remove the potion
255            if self.times[key] <= 0:
256                target = self.targets[key]
257                self.restore_target_initial_state(target)
258                to_remove.append(key)
259                self.reapply_active_potions(target)
260
261        for key in to_remove:
262            self.times.pop(key)
263            self.effects.pop(key)
264            self.targets.pop(key)