1def times_decorator(func, times):
  2    def wrapper(target):
  3        for _ in range(times):
  4            func(target)
  5
  6    return wrapper
  7
  8
  9def is_merged_decorator(func):
 10    def wrapper(*args, **kwargs):
 11        self = args[0]
 12        other = args[1]
 13        if self.is_merged or (other.is_merged if isinstance(other, Potion) else False):
 14            raise TypeError('Potion is now part of something bigger than itself.')
 15        try:
 16            return func(*args, **kwargs)
 17        finally:
 18            if func.__name__ != '__getattr__':
 19                """Set both both potions as merged and 'part of something bigger than itself'
 20                    if the function is not __getattr__.
 21                    If the potion is merged, __getattr__ will also raise an exception.
 22                """
 23                self.set_is_merged(True)
 24                other.set_is_merged(True)
 25
 26    return wrapper
 27
 28
 29class Potion:
 30    def __init__(self, effects, duration, intensities=None):
 31        self._effects = effects
 32        self._intensities = intensities or {effect: 1 for effect in effects}
 33        self._depleted = set()
 34        self._duration = duration
 35        self._is_merged = False
 36        self._is_depleted = False
 37
 38    @property
 39    def duration(self):
 40        return self._duration
 41
 42    @property
 43    def is_merged(self):
 44        return self._is_merged
 45
 46    @property
 47    def effects(self):
 48        return list(self._effects.keys())
 49
 50    @property
 51    def depleted(self):
 52        return self._depleted
 53
 54    def __getitem__(self, item):
 55        return self.__getattr__(item)
 56
 57    def set_is_depleted(self):
 58        self._is_depleted = True
 59
 60    def set_is_merged(self, value):
 61        self._is_merged = value
 62
 63    @is_merged_decorator
 64    def __getattr__(self, effect_name):
 65        if effect_name not in self._effects:
 66            raise AttributeError
 67
 68        if effect_name in self._depleted:
 69            raise TypeError('Effect is depleted')
 70
 71        if self._is_depleted:
 72            raise TypeError('Potion is depleted.')
 73
 74        self._depleted.add(effect_name)
 75        return times_decorator(self._effects[effect_name], self._intensities[effect_name])
 76
 77    @is_merged_decorator
 78    def __add__(self, other):
 79        if not isinstance(other, Potion):
 80            raise TypeError('Potions can only be combined with other potions')
 81
 82        effects = {**self._effects, **other._effects}
 83        duration = max(self._duration, other._duration)
 84        intensities = {
 85            effect: (self._intensities.get(effect, 0)) + (other._intensities.get(effect, 0))
 86            for effect in effects
 87        }
 88        return Potion(effects, duration, intensities)
 89
 90    @is_merged_decorator
 91    def __sub__(self, other):
 92        if not isinstance(other, Potion):
 93            raise TypeError('Potions can only be combined with other potions')
 94
 95        if other._effects.keys() - self._effects.keys() != set():
 96            raise TypeError('All effects of the right potion must be present in the left potion')
 97
 98        duration = self._duration
 99        effects = {}
100        intensities = {}
101        for effect in self._effects:
102            if effect in other._effects:
103                new_effect_intensity = self._intensities.get(effect) - other._intensities.get(effect)
104                if new_effect_intensity > 0:
105                    effects[effect] = self._effects[effect]
106                    intensities[effect] = new_effect_intensity
107            else:
108                effects[effect] = self._effects[effect]
109                intensities[effect] = self._intensities[effect]
110
111        return Potion(effects, duration, intensities)
112
113    @is_merged_decorator
114    def __mul__(self, intensity_growth):
115        try:
116            float(intensity_growth)
117        except ValueError:
118            raise TypeError('Potions can only be multiplied by integers')
119
120        effects = {**self._effects}
121        duration = self._duration
122        intensities = {
123            effect: round(self._intensities.get(effect, 0) * intensity_growth)
124            for effect in effects
125        }
126        return Potion(effects, duration, intensities)
127
128    @is_merged_decorator
129    def __truediv__(self, new_potions_count):
130        try:
131            int(new_potions_count)
132        except ValueError:
133            raise TypeError('Potions can only be divided by integers')
134
135        return tuple([Potion({**self._effects},
136                             self._duration,
137                             {effect: round(self._intensities.get(effect, 0) / new_potions_count)
138                              for effect in self._intensities}
139                             ) for _ in range(new_potions_count)])
140
141    def __eq__(self, other):
142        if not isinstance(other, Potion):
143            return False
144
145        return self._effects.keys() - other._effects.keys() == set() and all(
146            [self._intensities[effect] == other._intensities[effect] for effect in self._effects.keys()]
147        )
148
149    def __lt__(self, other):
150        if not isinstance(other, Potion):
151            return False
152
153        return sum(self._intensities.values()) < sum(other._intensities.values())
154
155    def __gt__(self, other):
156        if not isinstance(other, Potion):
157            return False
158
159        return not self == other and not self < other
160
161
162class ГоспожатаПоХимия:
163    def __init__(self):
164        self._target = None
165        self._target_public_attributes = None
166        self._current_tick_duration = None
167
168    def _sort_effects_by_molecule_mass(self, effects):
169        new_effects = list(effects)[:]
170        return sorted(new_effects, key=lambda effect: sum(ord(ch) for ch in effect), reverse=True)
171
172    def _get_public_attributes(self, target):
173        all_attributes = vars(target)
174        return {key: value for key, value in all_attributes.items() if
175                not key.startswith('_')}
176
177    def apply(self, target, potion):
178        self._target_public_attributes = self._get_public_attributes(target)
179        self._target = target
180        self._current_tick_duration = potion.duration
181
182        for effect in self._sort_effects_by_molecule_mass(potion.effects):
183            potion[effect](target)
184
185        if set(potion.depleted) == set(potion.effects):
186            potion.set_is_depleted()
187
188    def tick(self):
189        if not self._current_tick_duration:
190            raise Exception('No potion applied')
191
192        self._current_tick_duration -= 1
193
194        if self._current_tick_duration != 0:
195            return
196
197        current_public_attributes = self._get_public_attributes(self._target)
198        for key in current_public_attributes:
199            if key in self._target_public_attributes:
200                setattr(self._target, key, self._target_public_attributes[key])
201            else:
202                del self._target.__dict__[key]