1import math
  2import copy
  3from collections import OrderedDict
  4
  5
  6class Potion:
  7    def __init__(self, effects, duration):
  8        self.effects = {effect: [func, 1] for effect, func in effects.items()}
  9        self.duration = duration
 10        self.used_in_reation = False
 11        self.depleted = False
 12
 13    def __getattr__(self, attribute_name):
 14        if (
 15            attribute_name in self.effects
 16            and self.effects[attribute_name][0] is not None
 17        ):
 18            return lambda target: self._apply_effect(
 19                target, attribute_name, self.effects[attribute_name][0]
 20            )
 21        elif self.depleted == True:
 22            raise TypeError("Potion is depleted.")
 23        elif attribute_name in self.effects and self.effects[attribute_name][0] is None:
 24            raise TypeError("Effect is depleted.")
 25        else:
 26            raise AttributeError(f"Object doesn't have attribute {attribute_name}.")
 27
 28    def _potion_validation_check(func):
 29        def wrapper(*args, **kwargs):
 30            if args[0].used_in_reation == True:
 31                raise TypeError("Potion is now part of something bigger than itself.")
 32            elif isinstance(args[1], Potion) and args[1].used_in_reation == True:
 33                raise TypeError("Potion is now part of something bigger than itself.")
 34            elif args[0].depleted == True:
 35                raise TypeError("Potion is depleted.")
 36            elif isinstance(args[1], Potion) and args[1].depleted == True:
 37                raise TypeError("Potion is depleted.")
 38            return func(*args, **kwargs)
 39
 40        return wrapper
 41
 42    @_potion_validation_check
 43    def _apply_effect(self, target, effect_name, effect):
 44        for _ in range(self.effects[effect_name][1]):
 45            effect(target)
 46        self.effects[effect_name][0] = None
 47        self.effects[effect_name][1] = 0
 48        # we mark the used effect function as None
 49        # and intesity as none
 50
 51    @_potion_validation_check
 52    def __add__(self, other):
 53        if not isinstance(other, Potion):
 54            raise TypeError("Addition is only supported between Potion instances.")
 55        combined_effects = self.effects
 56
 57        for effect_name, effect_intensity in other.effects.items():
 58            if effect_name not in combined_effects:
 59                combined_effects[effect_name] = effect_intensity
 60            else:
 61                if (
 62                    combined_effects[effect_name][0] is None
 63                    and effect_intensity[0] is None
 64                ):
 65                    combined_effects[effect_name] = [
 66                        None,
 67                        combined_effects[effect_name][1] + effect_intensity[1],
 68                    ]
 69                elif (
 70                    combined_effects[effect_name][0] is not None
 71                    and effect_intensity[0] is None
 72                ):
 73                    pass
 74                elif (
 75                    combined_effects[effect_name][0] is None
 76                    and effect_intensity[0] is not None
 77                ):
 78                    combined_effects[effect_name] = [
 79                        effect_intensity[0],
 80                        effect_intensity[1],
 81                    ]
 82                else:
 83                    combined_effects[effect_name][1] = (
 84                        combined_effects[effect_name][1] + effect_intensity[1]
 85                    )
 86
 87        combined_duration = max(self.duration, other.duration)
 88        combined_potion = Potion({}, combined_duration)
 89        combined_potion.effects = combined_effects
 90        self.used_in_reation = True
 91        other.used_in_reation = True
 92        return combined_potion
 93
 94    @_potion_validation_check
 95    def multiplication(self, factor):
 96        effects_multiplied_intesities = {
 97            effect: [func_intensity[0], func_intensity[1] * factor]
 98            for effect, func_intensity in self.effects.items()
 99        }
100        multiplied_potion = Potion({}, self.duration)
101        multiplied_potion.effects = effects_multiplied_intesities
102        self.used_in_reation = True
103        return multiplied_potion
104
105    @staticmethod
106    def round_float(float_number):
107        if isinstance(float_number, float):
108            if float_number - math.floor(float_number) <= 0.5:
109                return math.floor(float_number)
110            else:
111                return math.ceil(float_number)
112        else:
113            raise TypeError("This function works only with float numbers.")
114
115    @_potion_validation_check
116    def delution(self, factor):
117        diluted_effects = {
118            effect_name: [
119                effect_intensity[0],
120                Potion.round_float(effect_intensity[1] * factor),
121            ]
122            for effect_name, effect_intensity in self.effects.items()
123        }
124        diluted_potion = Potion({}, self.duration)
125        diluted_potion.effects = diluted_effects
126        self.used_in_reation = True
127        return diluted_potion
128
129    @_potion_validation_check
130    def __sub__(self, other):
131        if not isinstance(other, Potion):
132            raise TypeError("Subtraction is only supported between Potion instances.")
133
134        if any(effect_name not in self.effects for effect_name in other.effects):
135            raise TypeError(
136                "The right-hand side Potion has effects not present in the left-hand side Potion."
137            )
138
139        subtracted_effects = self.effects
140        for effect_name, effect_intesity in other.effects.items():
141            updated_intesity = subtracted_effects[effect_name][1] - effect_intesity[1]
142            if updated_intesity <= 0:
143                del subtracted_effects[effect_name]
144            else:
145                subtracted_effects[effect_name][1] = updated_intesity
146
147        subtracted_duration = (
148            self.duration
149        )  # Duration remains the same as the left-hand side Potion
150
151        subtracted_potion = Potion({}, subtracted_duration)
152        subtracted_potion.effects = subtracted_effects
153        self.used_in_reation = True
154        other.used_in_reation = True
155        return subtracted_potion
156
157    def __mul__(self, factor):
158        if factor < 0:
159            raise TypeError("Invalid parameter.")
160        elif isinstance(factor, float) and factor > 0 and factor < 1:
161            return self.delution(factor)
162        elif isinstance(factor, int):
163            return self.multiplication(factor)
164        else:
165            raise TypeError("Invalid parameter.")
166
167    @_potion_validation_check
168    def __truediv__(self, number):
169        if not isinstance(number, int):
170            raise TypeError("You can divide the Potion only with whole number.")
171        divided_effects = {
172            effect_name: [
173                effect_intesity[0],
174                Potion.round_float(effect_intesity[1] / number),
175            ]
176            for effect_name, effect_intesity in self.effects.items()
177        }
178        new_potions = []
179        for _ in range(number):
180            potion = Potion({}, self.duration)
181            potion.effects = copy.deepcopy(divided_effects)
182            new_potions.append(potion)
183
184        self.used_in_reation = True
185        return tuple(new_potions)
186
187    @property
188    def _total_intensity(self):
189        return sum(
190            intensity
191            for _, (func, intensity) in self.effects.items()
192            if func is not None
193        )
194
195    @_potion_validation_check
196    def __lt__(self, other):
197        if not isinstance(other, Potion):
198            raise TypeError("Comparison is only supported between Potion instances.")
199        return self._total_intensity < other._total_intensity
200
201    @_potion_validation_check
202    def __eq__(self, other):
203        if not isinstance(other, Potion):
204            return False
205        return all(
206            effect_name in self.effects
207            and effect_intensity[1] == self.effects[effect_name][1]
208            for effect_name, effect_intensity in other.effects.items()
209        )
210
211    def __deepcopy__(self, memo):
212        new_potion = type(self).__new__(type(self))
213        memo[id(self)] = new_potion
214        new_potion.__dict__.update(copy.deepcopy(self.__dict__, memo))
215        return new_potion
216
217    def __dir__(self):
218        return self.effects
219
220
221class ГоспожатаПоХимия:
222    def __init__(self):
223        self.targets = {}
224
225    # calculate the molecular mass of every effect
226    def molecular_mass(self, effect_name):
227        if not isinstance(effect_name, str):
228            raise TypeError("Funtion works only with string.")
229        return sum(ord(char) for char in effect_name)
230
231    # how the target will be if havent taken anything
232    def original_state(self, target):
233        return copy.deepcopy(target.__dict__)
234
235    # Restore the sober state of the target
236    def restore_original_state(self, target_id):
237        target_dict_copy = copy.deepcopy(self.targets[target_id][1])
238        self.targets[target_id][0].__dict__ = target_dict_copy
239
240    # Keep an record for every potion that the target is ON at that moment
241    def poitions_in_the_blood(self, target, potion):
242        if id(target) not in self.targets:
243            self.targets[id(target)] = [
244                target,
245                self.original_state(target),
246                OrderedDict(),
247            ]
248            self.targets[id(target)][2][id(potion)] = copy.deepcopy(potion)
249        else:
250            self.targets[id(target)][2][id(potion)] = copy.deepcopy(potion)
251
252    # special apply by the teacher :)
253    def apply_potions(self, target_id):
254        potions_applied_copy = copy.deepcopy(
255            list(self.targets[target_id][2].values())
256        )  # Use deepcopy
257        target = self.targets[target_id][0]
258        for applied_potion in potions_applied_copy:
259            sorted_effects = sorted(
260                applied_potion.effects.keys(), key=self.molecular_mass, reverse=True
261            )
262            for effect_name in sorted_effects:
263                if applied_potion.effects[effect_name][0] is not None:
264                    getattr(applied_potion, effect_name)(target)
265
266    def update_state(self, targets_to_update):
267        for target_id in targets_to_update:
268            self.restore_original_state(target_id)
269            self.apply_potions(target_id)
270
271    # tick-tac
272    def tick(self):
273        targets_to_update = []
274        for target_id, [
275            target,
276            target_original_state,
277            potions_applied,
278        ] in self.targets.items():
279            potions_to_remove = []
280            for potion_id, potion in list(potions_applied.items()):
281                potion.duration -= 1
282                if potion.duration <= 0:
283                    potions_to_remove.append(potion_id)
284                    targets_to_update.append(target_id)
285            for potion_id in potions_to_remove:
286                del potions_applied[potion_id]
287        self.update_state(targets_to_update)
288
289    def apply(self, target, potion):
290        if not isinstance(potion, Potion):
291            raise TypeError("Object must be of type Potion to be applied.")
292        if potion.depleted:
293            raise TypeError("Potion is depleted.")
294        if potion.used_in_reation:
295            raise TypeError("Potion is now part of something bigger than itself.")
296        if potion.duration > 0:
297            self.poitions_in_the_blood(target, potion)
298            sorted_effects = sorted(
299                potion.effects.keys(), key=self.molecular_mass, reverse=True
300            )
301            for effect_name in sorted_effects:
302                if potion.effects[effect_name][0] is not None:
303                    getattr(potion, effect_name)(target)
304            potion.depleted = True