1from copy import deepcopy
  2from math import ceil
  3
  4class Effect:
  5    def __init__(self, func, intensity=1):
  6        self._func = func
  7        self.intensity = intensity
  8        self._depleted = False
  9
 10    def duplicate(self):
 11        return Effect(self._func, self.intensity)
 12    
 13    def __call__(self, *args,**kwargs):
 14        if self._depleted:
 15            raise TypeError("Effect is depleted.")
 16        else:
 17            self._depleted = True
 18            for _ in range(self.intensity):
 19                self._func(*args, **kwargs)
 20
 21    def __add__(self, other):
 22        return Effect(self._func, self.intensity + other.intensity) if all((self, other)) else self
 23
 24    def __sub__(self, other):
 25        return Effect(self._func, self.intensity - other.intensity) if all((self, other)) else self
 26    
 27    def __mul__(self, other):
 28        return Effect(self._func, ceil(self.intensity * other - 0.5)) if all((self, other)) else self
 29    
 30    def __truediv__(self, other):
 31        return Effect(self._func, ceil(self.intensity / other - 0.5)) if all((self, other)) else self
 32
 33    __radd__ = __add__
 34    __rsub__ = __sub__
 35
 36    def __eq__(self, other):
 37        return self.intensity == other.intensity
 38
 39    def __gt__(self, other):
 40        return self.intensity > other.intensity
 41
 42
 43class Potion:
 44
 45    def __init__(self, effects, duration):
 46        self.effects = {name: func if isinstance(func, Effect) else Effect(func)
 47                        for name, func in effects.items()}
 48        self.duration = duration
 49        self.potent = True
 50        self.depleted = False
 51
 52    def duplicate(self):
 53        return Potion({name: effect.duplicate() for name, effect in self.effects.items()},
 54                      self.duration)
 55
 56    def check_if_potent_or_depleted(self):
 57        if self.depleted:
 58            raise TypeError("Potion is depleted.")
 59        if not self.potent:
 60            raise TypeError("Potion is now part of something bigger than itself.")
 61    
 62    def use(self, target):
 63        self.check_if_potent_or_depleted()
 64        for name in sorted(self.effects.keys(), reverse=True,
 65                           key=lambda name: sum(ord(char) for char in name)):
 66            try: # This method exists becase it's not Dimitrichka's job to try/except this
 67                self.effects[name](target)
 68            except TypeError:
 69                pass # Effect is depleted
 70        self.depleted = True
 71
 72    def __getattr__(self, name):
 73        super().__getattribute__('check_if_potent_or_depleted')()
 74        try:
 75            return super().__getattribute__('effects')[name]
 76        except KeyError:
 77            raise AttributeError
 78
 79    def __add__(self, other):
 80        self.check_if_potent_or_depleted()
 81        effects = {name: self.effects.get(name) + other.effects.get(name)
 82                   for name in list(self.effects.keys()) + list(other.effects.keys())}
 83        self.potent = False
 84        other.potent = False
 85        return Potion(effects, max((self.duration, other.duration)))
 86
 87    def __sub__(self, other):
 88        self.check_if_potent_or_depleted()
 89        if not all(effect in self.effects for effect in other.effects):
 90            raise TypeError
 91        effects = {name: effect
 92                   for name in list(self.effects.keys()) + list(other.effects.keys())
 93                   if (effect:=self.effects.get(name) - other.effects.get(name)).intensity > 0}
 94        self.potent = False
 95        other.potent = False
 96        return Potion(effects, self.duration)
 97
 98    def __mul__(self, multiplier):
 99        self.check_if_potent_or_depleted()
100        effects = {name: self.effects[name] * multiplier for name in self.effects}
101        self.potent = False
102        return Potion(effects, self.duration)
103
104    def __truediv__(self, divisor):
105        self.check_if_potent_or_depleted()
106        potions = [Potion({name: self.effects[name] / divisor for name in self.effects},
107                          self.duration)
108                   for _ in range(divisor)]
109        self.potent = False
110        return potions
111
112    def __eq__(self, other):
113        return self.effects.items() == other.effects.items()
114
115    def __gt__(self, other):
116        return sum(self.effects.values()) > sum(other.effects.values())
117
118
119class ГоспожатаПоХимия:
120
121    def __init__(self):
122        self.target_states = {}
123
124    def apply(self, target, potion):
125        if target not in self.target_states:
126            self.target_states[target] = {'state': deepcopy(target.__dict__),
127                                          'potions_applied': []}
128        self.target_states[target]['potions_applied'].append({'potion': potion,
129                                                              'ticks_left': potion.duration})
130        potion.use(target)
131
132    def tick(self):
133        for target, target_meta in self.target_states.items():
134            # Nasty approach to solve proper state management
135            # But honestly... I'm tired of this homework
136            target.__dict__ = deepcopy(target_meta['state'])
137            for potion_meta in target_meta['potions_applied']:
138                potion_meta['ticks_left'] -= 1
139                if potion_meta['ticks_left'] > 0:
140                    potion_meta['potion'].duplicate().use(target)