1import math
  2import re
  3from copy import deepcopy
  4
  5
  6class Potion:
  7    def __init__(self, effects, duration):
  8        self._effects = effects
  9        self._duration = duration
 10        self._intensities = {key: 1 for key in effects}
 11        self._depleted_effects = set()
 12        self._has_been_used = False
 13        self._has_been_applied = False
 14
 15    def __getattribute__(self, item):
 16        if object.__getattribute__(self, '_has_been_applied'):
 17            raise TypeError('Potion is depleted.')
 18        if object.__getattribute__(self, '_has_been_used'):
 19            raise TypeError('Potion is now part of something bigger than itself.')
 20
 21        return object.__getattribute__(self, item)
 22
 23    def __getattr__(self, item):
 24        if self._has_been_applied:
 25            raise TypeError('Potion is depleted.')
 26
 27        if item not in self._effects:
 28            raise AttributeError('No such effect.')
 29
 30        if item in self._depleted_effects:
 31            raise TypeError('Effect is depleted.')
 32
 33        effect = self._intensify_effect(self._intensities[item])(self._effects[item])
 34
 35        self._depleted_effects.add(item)
 36
 37        return effect
 38
 39    @staticmethod
 40    def _intensify_effect(times):
 41        def intensifying_decorator(function):
 42            def intensifying_wrapper(*args, **kwargs):
 43                for _ in range(times):
 44                    function(*args, **kwargs)
 45
 46            return intensifying_wrapper
 47
 48        return intensifying_decorator
 49
 50    @property
 51    def has_been_used(self):
 52        return self._has_been_used
 53
 54    @has_been_used.setter
 55    def has_been_used(self, value):
 56        self._has_been_used = value
 57
 58    @property
 59    def has_been_applied(self):
 60        return self._has_been_applied
 61
 62    @has_been_applied.setter
 63    def has_been_applied(self, value):
 64        self._has_been_applied = value
 65
 66    @property
 67    def duration(self):
 68        return self._duration
 69
 70    @duration.setter
 71    def duration(self, value):
 72        self._duration = value
 73
 74    @property
 75    def intensities(self):
 76        return self._intensities
 77
 78    @intensities.setter
 79    def intensities(self, value):
 80        self._intensities = value
 81
 82    @property
 83    def effects(self):
 84        return self._effects
 85
 86    @effects.setter
 87    def effects(self, value):
 88        self._effects = value
 89
 90    def __add__(self, other):
 91        new_effects = self._combine_effects(other)
 92        new_intensities = self._combine_intensities(other)
 93
 94        new_potion = Potion(new_effects, max(self._duration, other.duration))
 95        new_potion._intensities = new_intensities
 96
 97        self.has_been_used = True
 98        other.has_been_used = True
 99
100        return new_potion
101
102    def _combine_effects(self, other):
103        new_effects = {}
104
105        for key, value in self.effects.items():
106            new_effects[key] = value
107
108        for key, value in other.effects.items():
109            new_effects[key] = value
110
111        return new_effects
112
113    def _combine_intensities(self, other):
114        new_intensities = {}
115
116        for key, value in self._intensities.items():
117            new_intensities[key] = value
118
119        for key, value in other.intensities.items():
120            if key in new_intensities:
121                new_intensities[key] += value
122            else:
123                new_intensities[key] = value
124
125        return new_intensities
126
127    def __mul__(self, other):
128        updated_intensities = {}
129
130        if isinstance(other, int):
131            updated_intensities = {key: value * other for key, value in self._intensities.items()}
132        elif isinstance(other, float) and 0 <= other <= 1:
133            updated_intensities = {key: self._round_to_whole(value * other) for key, value in self._intensities.items()}
134
135        new_potion = Potion(self._effects, self._duration)
136        new_potion._intensities = updated_intensities
137
138        self.has_been_used = True
139
140        return new_potion
141
142    @staticmethod
143    def _round_to_whole(real):
144        fraction = real - math.floor(real)
145
146        return math.floor(real) if fraction <= 0.5 else math.ceil(real)
147
148    def __sub__(self, other):
149        if set(other.effects.keys()) - set(self._effects.keys()):
150            raise TypeError('съдържанието няма значение')
151
152        new_effects = {}
153        new_intensities = {}
154
155        for name, intensity in self._intensities.items():
156            if name not in other.intensities:
157                new_effects[name] = self._effects[name]
158                new_intensities[name] = intensity
159            else:
160                difference = intensity - other.intensities[name]
161                if difference > 0:
162                    new_effects[name] = self._effects[name]
163                    new_intensities[name] = difference
164
165        new_potion = Potion(new_effects, self._duration)
166        new_potion._intensities = new_intensities
167
168        self.has_been_used = True
169        other.has_been_used = True
170
171        return new_potion
172
173    def __truediv__(self, other):
174        updated_intensities = {key: self._round_to_whole(value / other) for key, value in self._intensities.items()}
175
176        new_potion = Potion(self._effects, self._duration)
177        new_potion._intensities = updated_intensities
178
179        self.has_been_used = True
180
181        return tuple(deepcopy(new_potion) for _ in range(other))
182
183    # Not sure which the right convention is here, so I had to check for a __deepcopy__ sample implementation
184    def __deepcopy__(self, memodict={}):
185        cls = self.__class__
186        new_object = cls.__new__(cls)
187        memodict[id(self)] = new_object
188        for key, value in self.__dict__.items():
189            setattr(new_object, key, deepcopy(value, memodict))
190        return new_object
191
192    def __eq__(self, other):
193        return self._effects == other.effects and self.get_comparable_effects() == other.get_comparable_effects()
194
195    def __gt__(self, other):
196        return sum(self.get_comparable_effects().values()) > sum(other.get_comparable_effects().values()) and not self.__eq__(other)
197
198    def __lt__(self, other):
199        return sum(self.get_comparable_effects().values()) < sum(other.get_comparable_effects().values()) and not self.__eq__(other)
200
201    def get_comparable_effects(self):
202        return {effect: intensity for effect, intensity in self._intensities.items() if effect not in self._depleted_effects}
203
204    def get_applied(self, target):
205        effects_map, masses = self._ordered_by_mass()
206
207        for mass in masses:
208            name = effects_map[mass]
209            effect = getattr(self, name)
210            effect(target)
211
212        self.has_been_applied = True
213
214    def _ordered_by_mass(self):
215        effects_map = {self._get_mass(key): key for key in self._effects}
216        masses = list(effects_map.keys())
217        masses.sort(reverse=True)
218
219        return effects_map, masses
220
221    @staticmethod
222    def _get_mass(effect_name):
223        return sum(map(ord, effect_name))
224
225    # Generated by IDE
226    def __hash__(self):
227        return super().__hash__()
228
229
230class ГоспожатаПоХимия:
231    def __init__(self):
232        self._durations = {}
233        self._states = {}
234        self._potions_on_targets = {}
235        self._original_potions = {}
236
237    def apply(self, target, potion):
238        self._durations[potion] = potion.duration
239
240        if target in self._potions_on_targets.values():
241            for key, value in self._potions_on_targets.items():
242                if value == target:
243                    self._states[potion] = self._states[key]
244                    break
245        else:
246            states_names = filter(lambda attribute: bool(re.search('^[^_].*', attribute)), dir(target))
247            self._states[potion] = {name: getattr(target, name) for name in states_names}
248
249        self._potions_on_targets[potion] = target
250        self._original_potions[potion] = deepcopy(potion)
251
252        potion.get_applied(target)
253
254    def tick(self):
255        for potion in self._durations:
256            self._durations[potion] -= 1
257
258        expired_potions = [key for key, value in self._durations.items() if value == 0]
259
260        used_targets = []
261        for potion in expired_potions:
262            for attribute, value in self._states[potion].items():
263                setattr(self._potions_on_targets[potion], attribute, value)
264
265            used_targets.append(self._potions_on_targets[potion])
266
267            del self._durations[potion]
268            del self._potions_on_targets[potion]
269            del self._states[potion]
270            del self._original_potions[potion]
271
272        for used_target in used_targets:
273            for potion, target in self._potions_on_targets.items():
274                if used_target == target:
275                    self._original_potions[potion].get_applied(target)