1import math
  2from contextlib import suppress
  3from collections import deque
  4from copy import deepcopy
  5
  6TRANSCENDED = 'Potion is now part of something bigger than itself.'
  7DEPLETED_P = 'Potion is depleted.'
  8DEPLETED_E = 'Effect is depleted.'
  9
 10
 11def round_half_down(num):
 12    return math.ceil(num - 0.5)
 13
 14
 15def 使ったら消えてしまう(*msgs):
 16    def decorator(cls):
 17        class UseOnce(cls):
 18            def __init__(self, *args, **kwargs):
 19                super().__init__(*args, **kwargs)
 20                for idx in range(len(msgs)):
 21                    setattr(self, f'__{idx}', False)
 22
 23            def __getattribute__(self, item):
 24                for idx in range(len(msgs)):
 25                    if object.__getattribute__(self, f'__{idx}'):
 26                        raise TypeError(msgs[idx])
 27                return super().__getattribute__(item)
 28
 29        return UseOnce
 30
 31    return decorator
 32
 33
 34def 消えたら伝えろ(idx):
 35    def once(method):
 36        def wrapper(self, other):
 37            res = method(self, other)
 38            setattr(self, f'__{idx}', True)
 39            if type(other) is Potion:
 40                setattr(other, f'__{idx}', True)
 41            return res
 42
 43        return wrapper
 44
 45    return once
 46
 47
 48@使ったら消えてしまう(DEPLETED_E)
 49class Effect:
 50    @staticmethod
 51    def mole_mass(effect):
 52        return sum(ord(char) for char in effect)
 53
 54    def __init__(self, effect):
 55        self.effect = effect
 56        self.intensity = 1
 57
 58    @消えたら伝えろ(0)
 59    def __call__(self, target):
 60        while self.intensity > 0:
 61            self.effect(target)
 62            self.intensity -= 1
 63
 64
 65@使ったら消えてしまう(DEPLETED_P, TRANSCENDED)
 66class Potion:
 67    def __init__(self, effects, duration):
 68        self.effects = effects
 69        self.duration = duration
 70        for effect_name, effect in effects.items():
 71            setattr(self, effect_name, Effect(effect))
 72
 73    def __getitem__(self, effect):
 74        return getattr(self, effect)
 75
 76    def __setitem__(self, effect_name, effect):
 77        self.effects[effect_name] = effect
 78        setattr(self, effect_name, Effect(effect))
 79
 80    def __delitem__(self, key):
 81        delattr(self, key)
 82        del self.effects[key]
 83
 84    @消えたら伝えろ(1)
 85    def __add__(self, other):
 86        potion = Potion({}, max(self.duration, other.duration))
 87        potion._copy_unused_effects(self)
 88        potion._copy_unused_effects(other)
 89        for effect in set(self.effects) & set(other.effects):
 90            with suppress(TypeError):
 91                potion[effect].intensity = self[effect].intensity + other[effect].intensity
 92        return potion
 93
 94    @消えたら伝えろ(1)
 95    def __sub__(self, other):
 96        if set(other.effects) - set(self.effects):
 97            raise TypeError
 98        potion = Potion({}, self.duration)
 99        potion._copy_unused_effects(self)
100        for effect in other.effects:
101            with suppress(TypeError):
102                intensity = self[effect].intensity - other[effect].intensity
103                if intensity <= 0:
104                    del potion[effect]
105                else:
106                    potion[effect].intensity = intensity
107        return potion
108
109    @消えたら伝えろ(1)
110    def __mul__(self, other):
111        potion = Potion({}, self.duration)
112        potion._copy_unused_effects(self)
113        for effect in self.effects:
114            with suppress(TypeError):
115                potion[effect].intensity = round_half_down(self[effect].intensity * other)
116        return potion
117
118    @消えたら伝えろ(1)
119    def __truediv__(self, other):
120        potions = []
121        for _ in range(other):
122            potion = Potion({}, round_half_down(self.duration / other))
123            potion._copy_unused_effects(self)
124            for effect in self.effects:
125                with suppress(TypeError):
126                    potion[effect].intensity = round_half_down(self[effect].intensity / other)
127            potions.append(potion)
128        return potions
129
130    def __eq__(self, other):
131        if self.effects.keys() != other.effects.keys():
132            return False
133        for effect in self.effects:
134            intensity_1, intensity_2 = 0, 0
135            with suppress(TypeError):
136                intensity_1 = self[effect].intensity
137            with suppress(TypeError):
138                intensity_2 = other[effect].intensity
139            if intensity_1 != intensity_2:
140                return False
141        return True
142
143    def __gt__(self, other):
144        return self._total_intensities() > other._total_intensities()
145
146    @消えたら伝えろ(0)
147    def __call__(self, target):
148        for effect in sorted(self.effects, reverse=True, key=Effect.mole_mass):
149            with suppress(TypeError):
150                self[effect](target)
151
152    def __neg__(self):
153        potion = Potion({}, self.duration - 1)
154        potion._copy_unused_effects(self)
155        return potion
156
157    def _total_intensities(self):
158        total = 0
159        for effect in self.effects:
160            with suppress(TypeError):
161                total += self[effect].intensity
162        return total
163
164    def _copy_unused_effects(self, other):
165        for effect in other.effects:
166            with suppress(TypeError):
167                self._add_effect(effect, other.effects[effect], other[effect].intensity)
168
169    def _add_effect(self, effect_name, effect, intensity=1):
170        self[effect_name] = effect
171        self[effect_name].intensity = intensity
172
173
174class ГоспожатаПоХимия:
175    def __init__(self):
176        self.addicts = {}
177        self.drugs = {}
178
179    def apply(self, target, potion):
180        if potion.duration:
181            addict_id = self._make_addict(target)
182            self._add_drug(addict_id, -potion)
183            potion(target)
184
185    def tick(self):
186        for addict in list(self.addicts):
187            self._withdraw(addict)
188
189            if not self.drugs[addict]:
190                self._remove(addict)
191                continue
192
193            self._give_drugs(addict)
194
195    def _make_addict(self, target):
196        if id(target) not in self.addicts:
197            self.addicts[id(target)] = target, deepcopy(target.__dict__)
198            self.drugs[id(target)] = deque()
199        return id(target)
200
201    def _add_drug(self, addict_id, potion):
202        if potion.duration > 0:
203            self.drugs[addict_id].append(potion)
204
205    def _withdraw(self, addict_id):
206        self.addicts[addict_id][0].__dict__ = deepcopy(self.addicts[addict_id][1])
207
208    def _give_drugs(self, addict_id):
209        drugs = self.drugs[addict_id]
210        addict = self.addicts[addict_id][0]
211        drugs_to_take = len(drugs)
212
213        while drugs_to_take > 0:
214            drug = drugs.popleft()
215            self._add_drug(addict_id, -drug)
216            drug(addict)
217            drugs_to_take -= 1
218
219    def _remove(self, addict_id):
220        del self.addicts[addict_id]
221        del self.drugs[addict_id]