1import math
  2
  3class Potion:
  4    def __init__(self, effects, duration):
  5        self.effects = effects
  6        self.duration = duration
  7        self.intensities = {}
  8        self.used_effects = set()
  9        self.used = False
 10        self.depleted = False
 11
 12        for name in effects.keys():
 13            self.intensities[name] = self.intensities.get(name, 0) + 1
 14
 15    def __getattr__(self, name):
 16        if name not in self.effects.keys():
 17            raise AttributeError("Attribute not found.")
 18        if self.used:
 19            raise TypeError("Potion is now part of something bigger than itself.")
 20        if self.depleted:
 21            raise TypeError("Potion is depleted.")
 22        if name in self.used_effects:
 23            raise TypeError("Effect is depleted.")
 24
 25        def execute_n_times(func):
 26            def wrapper(target):
 27                for _ in range(int(self.intensities.get(name))):
 28                    func(target)
 29            return wrapper
 30        self.used_effects.add(name)
 31        return execute_n_times(self.effects.get(name))
 32
 33    def __add__(self, other):
 34        validate(self)
 35        validate(other)
 36
 37        new_duration = max(self.duration, other.duration)
 38        combined_effects = {}
 39        intensities = {}
 40        used_effects = set()
 41
 42        for name, usage in self.effects.items():
 43            combined_effects[name] = usage
 44            intensities[name] = intensities.get(name) + 1 if name in intensities else self.intensities.get(name, 0)
 45            used_effects = used_effects.union(self.used_effects)
 46
 47        for name, usage in other.effects.items():
 48            combined_effects[name] = usage
 49            intensities[name] = intensities.get(name) + 1 if name in intensities else other.intensities.get(name, 0)
 50            used_effects = used_effects.union(other.used_effects)
 51
 52        self.used = True
 53        other.used = True
 54        potion = Potion(combined_effects, new_duration)
 55        potion.intensities = intensities
 56        potion.used_effects = used_effects
 57        if len(potion.used_effects) == len(potion.effects):
 58            potion.depleted = True
 59        return potion
 60
 61    def __mul__(self, other):
 62        validate(self)
 63
 64        if isinstance(other, (int, float)):
 65            potion = Potion(self.effects.copy(), self.duration)
 66            intensities = {}
 67
 68            for name, value in self.intensities.items():
 69                intensities[name] = value * other
 70                if 0 < other < 1:
 71                    intensities[name] = self._round_value(intensities[name])
 72
 73            potion.intensities = intensities
 74            potion.used_effects = self.used_effects.copy()
 75            if len(potion.used_effects) == len(potion.effects):
 76                potion.depleted = True
 77            self.used = True
 78            return potion
 79
 80    def __sub__(self, other):
 81        validate(self)
 82        validate(other)
 83
 84        new_duration = other.duration
 85        purified_effects = {}
 86        intensities = {}
 87        used_effects = set()
 88
 89        for name, usage in other.effects.items():
 90            if name not in self.effects:
 91                raise TypeError("Cannot purify potion.")
 92            if other.intensities.get(name) >= self.intensities.get(name):
 93                continue
 94            else:
 95                purified_effects[name] = usage
 96                intensities[name] = self.intensities.get(name) - other.intensities.get(name)
 97                if name in other.used_effects or name in self.used_effects:
 98                    used_effects.add(name)
 99
100        for name, usage in self.effects.items():
101            if name not in other.effects.keys():
102                purified_effects[name] = usage
103                intensities[name] = self.intensities.get(name)
104                if name in self.used_effects:
105                    used_effects.add(name)
106        
107        self.used = True
108        other.used = True
109        potion = Potion(purified_effects, new_duration)
110        potion.intensities = intensities
111        potion.used_effects = used_effects
112        if len(potion.used_effects) == len(potion.effects):
113            potion.depleted = True
114        return potion
115
116    def __truediv__(self, other):
117        validate(self)
118
119        if isinstance(other, (int, float)):
120            intensities = {}
121
122            for name, intensity in self.intensities.items():
123                intensities[name] = self._round_value(intensity / other)
124
125            result = tuple(Potion(self.effects.copy(), self.duration) for _ in range(other))
126            for potion in result:
127                potion.intensities = intensities.copy()
128                potion.used_effects = self.used_effects.copy()
129                if len(potion.used_effects) == len(potion.effects):
130                    potion.depleted = True
131            self.used = True
132            return result
133
134    
135    def __eq__(self, other):
136        validate(self)
137        validate(other)
138
139        if not isinstance(other, Potion):
140            return False
141
142        if len(self.effects) != len(other.effects):
143            return False
144
145        for name in self.effects.keys():
146            if name not in other.effects:
147                return False
148            if self.intensities.get(name) != other.intensities.get(name):
149                if name in self.used_effects and name in other.used_effects:
150                    continue
151                if (name in self.used_effects and other.intensities.get(name) == 0 or
152                    name in other.used_effects and self.intensities.get(name) == 0):
153                    continue
154                return False
155        return True
156
157    def __lt__(self, other):
158        validate(self)
159        validate(other)
160
161        if not isinstance(other, Potion):
162            return False
163
164        first_sum = sum([intensity for name, intensity in self.intensities.items() if name not in self.used_effects])
165        second_sum = sum([intensity for name, intensity in other.intensities.items() if name not in other.used_effects])
166        return first_sum < second_sum
167
168    def __gt__(self, other):
169        validate(self)
170        validate(other)
171
172        if not isinstance(other, Potion):
173            return False
174
175        first_sum = sum([intensity for name, intensity in self.intensities.items() if name not in self.used_effects])
176        second_sum = sum([intensity for name, intensity in other.intensities.items() if name not in other.used_effects])
177        return first_sum > second_sum
178
179    def __hash__(self):
180        return super().__hash__()
181    
182    def _round_value(self, value):
183        if value % 1 > 0.5:
184            return int(math.ceil(value))
185        return int(math.floor(value))
186
187def validate(potion):
188    if potion.depleted:
189        raise TypeError("Potion is depleted.")
190    if potion.used:
191        raise TypeError("Potion is now part of something bigger than itself.")
192    
193def ascii_sum(string):
194    return sum(ord(char) for char in string)
195
196class ГоспожатаПоХимия:
197    # {
198    #   target: { initial_state },
199    #   target2: { initial_state }
200    # }
201    _target_states = {}
202
203    # {
204    #   target: [potion1, potion2],
205    #   target2: [potion3]
206    # }
207    _target_potions = {}
208
209    # {
210    #   target: {
211    #           potion1: time1,
212    #           potion2: time2 
213    #       },
214    #   target2: {
215    #           potion3: time3
216    #       }
217    # }
218    _times = {}
219
220    def apply(self, target, potion):
221        validate(potion)
222
223        if target not in self._target_states:
224            self.save_initial_state(target)
225        if target not in self._times.keys():
226            self._times[target] = {}
227        if target not in self._target_potions.keys():
228            self._target_potions[target] = []
229
230        self._times[target][potion] = potion.duration
231        self._target_potions[target].append(potion)
232        sorted_effects = sorted(list(potion.effects), key=ascii_sum, reverse=True)
233        for effect in sorted_effects:
234            try:
235                getattr(potion, effect)(target)
236            except TypeError:
237                continue
238        potion.depleted = True
239        if potion.duration == 0:
240            self.reset_target(target)
241
242    def _apply_all(self, target):
243        for potion in self._target_potions[target]:
244            if potion.duration <= 0:
245                continue
246            for effect in sorted(list(potion.effects), key=ascii_sum, reverse=True):
247                potion.effects[effect](target)
248
249    def tick(self):
250        for target, potions in self._times.items():
251            for potion, time in potions.items():
252                self._times[target][potion] = time - 1
253        
254        for target, potions in (self._times.copy()).items():
255            for potion, time in (potions.copy()).items():
256                if time <= 0:
257                    self._times[target].pop(potion, None)
258                    self._target_potions[target].remove(potion)
259                    if len(self._times[target]) == 0:
260                        self._times.pop(target, None)
261                    self.reset_target(target)
262                    if target not in self._times:
263                        self._target_potions.pop(target, None)
264                        self._target_states.pop(target, None)
265
266    def save_initial_state(self, target):
267        self._target_states[target] = {attr: getattr(target, attr) for attr in dir(target) if not attr.startswith('_')}
268    
269    def reset_target(self, target):
270        for attr, initial_value in self._target_states[target].items():
271            setattr(target, attr, initial_value)
272        for attr in dir(target):
273            if not attr.startswith('_') and attr not in self._target_states[target].keys():
274                try:
275                    delattr(target, attr)
276                except AttributeError:
277                    continue
278
279        self._apply_all(target)