1import cmath
  2
  3EFFECT_ERROR_TEXT = "Effect is depleted."
  4POTION_IS_COMPONENT_ERROR_TEXT = "Potion is now part of something bigger than itself."
  5INVALID_SUBSTITUTION_ERROR_TEXT = "Invalid substitution"
  6POTION_IS_USED_ERROR_TEXT = "Potion is depleted."
  7
  8
  9class PotionEffect:
 10    @staticmethod
 11    def custom_round(value):
 12        result = round(value)
 13        if cmath.isclose(
 14            result - value, 0.5
 15        ):  # the edge case where x.5 should be rounded down
 16            result -= 1
 17        return result
 18
 19    def __init__(self, func):
 20        self.func = func
 21        self.times = 1
 22        self.used = False
 23
 24    def __iadd__(self, other):
 25        self.times += other.times
 26        return self
 27
 28    def __isub__(self, other):
 29        self.times -= other.times
 30        return self
 31
 32    def __imul__(self, other):
 33        self.times = PotionEffect.custom_round(self.times * other)
 34        return self
 35
 36    def __itruediv__(self, other):
 37        self.times = PotionEffect.custom_round(self.times / other)
 38        return self
 39
 40    def copy(self):
 41        result = PotionEffect(self.func)
 42        result.times = self.times
 43        result.used = self.used
 44        return result
 45
 46    def __call__(self, target):
 47        if self.used:
 48            raise TypeError(EFFECT_ERROR_TEXT)
 49        for _ in range(self.times):
 50            self.func(target)
 51        self.used = True
 52
 53
 54class meta(type):
 55    def __new__(cls, name, bases, attr_dict):
 56        return type.__new__(cls, name, bases, attr_dict)
 57
 58
 59class Potion(metaclass=meta):
 60    @staticmethod
 61    def fake_func_for_component(target):
 62        raise TypeError(POTION_IS_COMPONENT_ERROR_TEXT)
 63
 64    @staticmethod
 65    def update_dict_with_class_funcs(result_dict):
 66        result_dict.update(
 67            {key: value for key, value in vars(Potion).items() if not key in dir(type)}
 68        )
 69        result_dict["__init__"] = Potion.__init__
 70        result_dict["__eq__"] = Potion.__eq__
 71        result_dict["__lt__"] = Potion.__lt__
 72        result_dict["__gt__"] = Potion.__gt__
 73        result_dict.pop("__weakref__")
 74        return result_dict
 75
 76    def validate_state_on_operation(self):
 77        if self.is_component:
 78            raise TypeError(POTION_IS_COMPONENT_ERROR_TEXT)
 79        if self.is_used():
 80            raise TypeError(POTION_IS_USED_ERROR_TEXT)
 81
 82    def __init__(self, effects, duration):
 83        for key, value in effects.items():
 84            setattr(self, key, PotionEffect(value))
 85        self.duration = duration
 86        self.is_component = False
 87
 88    def is_used(self):
 89        for key in dir(self):
 90            value = getattr(self, key)
 91            if type(value) is PotionEffect and not value.used:
 92                return False
 93        return True
 94
 95    def __getattribute__(self, name):
 96        result = object.__getattribute__(self, name)
 97        if (
 98            object.__getattribute__(self, "is_component")
 99            and type(result) is PotionEffect
100        ):
101            fake_result = PotionEffect(Potion.fake_func_for_component)
102            fake_result.times = result.times
103            fake_result.used = result.used
104            return fake_result
105
106        return result
107
108    def __add__(self, other):
109        self.validate_state_on_operation()
110        other.validate_state_on_operation()
111        # transfering the methods from the object on the left side to dict,
112        # and if there are matching methods in the right side, we increace the intensity
113        result_dict = {}
114        for key in dir(self):
115            value = getattr(self, key)
116            if type(value) is PotionEffect and not value.used:
117                result_dict[key] = value.copy()
118                if key in dir(other):
119                    other_value = getattr(other, key)
120                    if not other_value.used:
121                        result_dict[key] += other_value
122
123        # transfering the methods that are only in the right side to the dict
124        for key in dir(other):
125            value = getattr(other, key)
126            if (
127                type(value) is PotionEffect
128                and not value.used
129                and not key in result_dict.keys()
130            ):
131                result_dict[key] = getattr(other, key).copy()
132
133        Potion.update_dict_with_class_funcs(result_dict)
134        result = type("Potion", (object,), result_dict)(
135            {}, max(self.duration, other.duration)
136        )
137        self.is_component = True
138        other.is_component = True
139
140        return result
141
142    def __mul__(self, other):
143        self.validate_state_on_operation()
144        result_dict = {}
145        # transfering the methods from the object to the dict and multiply them with the number
146        for key in dir(self):
147            value = getattr(self, key)
148            if type(value) is PotionEffect and not value.used:
149                result_dict[key] = value.copy()
150                result_dict[key] *= other
151
152        Potion.update_dict_with_class_funcs(result_dict)
153
154        result = meta("Potion", (object,), result_dict)({}, self.duration)
155        self.is_component = True
156
157        return result
158
159    def __sub__(self, other):
160        self.validate_state_on_operation()
161        other.validate_state_on_operation()
162        result_dict = {}
163        # validation that the substitution is valid
164        for key in dir(other):
165            value = getattr(other, key)
166            if type(value) is PotionEffect and not value.used and not key in dir(self):
167                raise TypeError(INVALID_SUBSTITUTION_ERROR_TEXT)
168        # transfering the methods from the object on the left side to dict,
169        # and if there are matching methods in the right side, we subtract their intensity
170        for key in dir(self):
171            value = getattr(self, key)
172            if not type(value) is PotionEffect or value.used:
173                continue
174            result_dict[key] = value.copy()
175            if key in dir(other):
176                other_value = getattr(other, key)
177                if not other_value.used:
178                    result_dict[key] -= getattr(other, key)
179                    if result_dict[key].times <= 0:
180                        result_dict.pop(key)
181
182        Potion.update_dict_with_class_funcs(result_dict)
183        result = meta("Potion", (object,), result_dict)({}, self.duration)
184        self.is_component = True
185        other.is_component = True
186        return result
187
188    def __truediv__(self, other):
189        self.validate_state_on_operation()
190        # spliting the object into equal parts, where the intensity is devided by the number
191        result_list = []
192        for _ in range(other):
193            result_dict = {}
194            for key in dir(self):
195                value = getattr(self, key)
196                if type(value) is PotionEffect and not value.used:
197                    result_dict[key] = value.copy()
198                    result_dict[key] /= other
199
200            Potion.update_dict_with_class_funcs(result_dict)
201            result = meta("Potion", (object,), result_dict)({}, self.duration)
202            result_list.append(result)
203
204        self.is_component = True
205        return tuple(result_list)
206
207    def __eq__(self, other):
208        self.validate_state_on_operation()
209        other.validate_state_on_operation()
210        for key in dir(self):
211            value = getattr(self, key)
212            if type(value) is PotionEffect and not value.used:
213                if not key in dir(other):
214                    return False
215                other_value = getattr(other, key)
216                if value.times != other_value.times or value.used != other_value.used:
217                    return False
218
219        for key in dir(other):
220            value = getattr(other, key)
221            if type(value) is PotionEffect and not value.used and not key in dir(self):
222                return False
223
224        return True
225
226    def get_sum(self):
227        result = 0
228        for key in dir(self):
229            value = getattr(self, key)
230            if type(value) is PotionEffect and not value.used:
231                result += value.times
232        return result
233
234    def __gt__(self, other):
235        self.validate_state_on_operation()
236        other.validate_state_on_operation()
237        return self.get_sum() > other.get_sum()
238
239    def __lt__(self, other):
240        self.validate_state_on_operation()
241        other.validate_state_on_operation()
242        return self.get_sum() < other.get_sum()
243
244
245class ГоспожатаПоХимия:
246    @staticmethod
247    def calculate_molecular_mass(element):
248        return sum([ord(i) for i in element])
249
250    def __init__(self):
251        # dictionary to store the reverse effectss of potions as a key, and when to be executed as values
252        self.timer = {}
253
254    def apply_effect(self, target, effect):
255        # creating a revrse function to reverse the changes after the effect expires
256        old_attributes = vars(target).copy()
257        effect(target)
258        mid__attributes = vars(target).copy()
259
260        def reverse_effect():
261            new_attributes = vars(target).copy()
262            for key, value in new_attributes.items():
263                if not key in mid__attributes.keys():
264                    continue
265                is_old = key in old_attributes.keys()
266                if type(value) in (int, float):
267                    old_val = 0
268                    if is_old:
269                        old_val = old_attributes[key]
270
271                    if (
272                        value - (mid__attributes[key] - old_val)
273                    ) == old_val and not is_old:
274                        delattr(target, key)
275                    else:
276                        setattr(target, key, value - (mid__attributes[key] - old_val))
277                elif value == mid__attributes[key] and key in old_attributes.keys():
278                    setattr(target, key, old_attributes[key])
279                elif not is_old:
280                    delattr(target, key)
281
282        return reverse_effect
283
284    def apply(self, target, potion):
285        if potion.is_used():
286            raise TypeError(POTION_IS_USED_ERROR_TEXT)
287
288        if potion.is_component:  # this is probably useless, but just to be sure
289            raise TypeError(POTION_IS_COMPONENT_ERROR_TEXT)
290
291        if potion.duration == 0:
292            return
293        ordered_dir = sorted(
294            dir(potion), key=ГоспожатаПоХимия.calculate_molecular_mass, reverse=True
295        )
296        for key in ordered_dir:
297            value = getattr(potion, key)
298            if type(value) is PotionEffect and not value.used:
299                reverse_func = self.apply_effect(target, value)
300                self.timer[reverse_func] = potion.duration
301
302    def tick(self):
303        to_iterate = self.timer.copy().items()
304        for key, value in to_iterate:
305            self.timer[key] -= 1
306            if value <= 1:
307                key()
308                self.timer.pop(key)