1import math
  2import copy
  3import re
  4
  5class Potion:
  6    @staticmethod
  7    def round_down(n):
  8        temp = math.floor(n)
  9        if n - temp <= 0.5:
 10            return math.floor(n)
 11        return math.ceil(n)
 12
 13    def _wholeness_check(self, func):
 14        def check(args):
 15            self._validate_not_depleted()
 16            self._validate_not_used()
 17            return func(args)
 18        return check
 19
 20    def _depleted_check(self, effect, func):
 21        def check(args):
 22            if effect in self.depleted_effects:
 23                if self.depleted_effects[effect]:
 24                    raise TypeError("Effect is depleted.")
 25                self.depleted_effects[effect] = True
 26            return func(args)
 27        return check
 28    
 29    def _apply_intensity(self, effect, func):
 30        def apply(args):
 31            if effect in self.intensity:
 32                for _ in range(self.intensity[effect]):
 33                    func(args)
 34        return apply
 35    
 36    def _copy(self):
 37        copy_potion = Potion({}, self.duration)
 38        for effect in self.effects:
 39            copy_potion.effects[effect] = self.effects[effect]
 40            copy_potion.depleted_effects[effect] = self.depleted_effects[effect]
 41            copy_potion.intensity[effect] = self.intensity[effect]
 42            setattr(copy_potion, effect, copy_potion._wholeness_check(
 43                copy_potion._depleted_check(
 44                    effect, copy_potion._apply_intensity(
 45                        effect, copy_potion.effects.get(effect)))))
 46        return copy_potion
 47
 48    def _validate_not_used(self):
 49        if self.used:
 50            raise TypeError("Potion is now part of something bigger than itself.")
 51
 52    def _validate_not_depleted(self):
 53        if self.depleted:
 54            raise TypeError("Potion is depleted.")
 55
 56    def _increase_potential(self, scale):
 57        multiplied_potion = self._copy()
 58        for effect in multiplied_potion.intensity:
 59            multiplied_potion.intensity[effect] *= scale
 60        self.used = True
 61        return multiplied_potion
 62    
 63    def _decrease_potential(self, scale):
 64        divided_potion = self._copy()
 65        for effect in divided_potion.intensity:
 66            divided_potion.intensity[effect] = Potion.round_down(
 67                divided_potion.intensity[effect] * scale)
 68        self.used = True
 69        return divided_potion
 70
 71    def __init__(self, effects, duration):
 72        self.used = False
 73        self.depleted = False
 74        self.effects = effects
 75        self.depleted_effects = {}
 76        self.intensity = {}
 77        for effect in effects:
 78            self.depleted_effects[effect] = False
 79            self.intensity[effect] = 1
 80            setattr(self, effect, self._wholeness_check(
 81                self._depleted_check(
 82                    effect, self._apply_intensity(
 83                        effect, effects.get(effect)))))
 84        self.duration = duration
 85    
 86    def apply(self, target):
 87        self._validate_not_depleted()
 88        self._validate_not_used()
 89        for effect in sorted(self.effects.keys(), 
 90                             key=lambda name: sum(ord(c) for c in name),
 91                             reverse=True):
 92            if not self.depleted_effects[effect]:
 93                getattr(self, effect)(target)
 94        self.depleted = True
 95
 96    def __add__(self, other):
 97        self._validate_not_depleted()
 98        self._validate_not_used()
 99        other._validate_not_depleted()
100        other._validate_not_used()
101        compound = self._copy()
102        for effect in other.effects:
103            if effect in compound.effects:
104                compound.intensity[effect] += other.intensity[effect]
105            else:
106                compound.effects[effect] = other.effects[effect]
107                compound.depleted_effects[effect] = other.depleted_effects[effect]
108                compound.intensity[effect] = other.intensity[effect]
109                setattr(compound, effect, compound._wholeness_check(
110                    compound._depleted_check(
111                        effect, compound._apply_intensity(
112                            effect, compound.effects.get(effect)))))
113        self.used = True
114        other.used = True
115        return compound
116
117    def __mul__(self, scale):
118        self._validate_not_depleted()
119        self._validate_not_used()
120        if scale > 1:
121            return self._increase_potential(scale)
122        return self._decrease_potential(scale)
123    
124    def __sub__(self, other):
125        self._validate_not_depleted()
126        self._validate_not_used()
127        other._validate_not_depleted()
128        other._validate_not_used()
129        purified_potion = self._copy()
130        for effect in other.effects:
131            if effect in purified_potion.effects:
132                if purified_potion.intensity[effect] > other.intensity[effect]:
133                    purified_potion.intensity[effect] -= other.intensity[effect]
134                else:
135                    purified_potion.depleted_effects.pop(effect)
136                    purified_potion.intensity.pop(effect)
137                    purified_potion.effects.pop(effect)
138                    delattr(purified_potion, effect)
139            else:
140                raise TypeError("Cannot remove non-existent effect.")
141        self.used = True
142        other.used = True
143        return purified_potion
144    
145    def __truediv__(self, scale):
146        self._validate_not_depleted()
147        self._validate_not_used()
148        potions = []
149        for _ in range(scale):
150            potion = self._copy()
151            for effect in potion.intensity:
152                potion.intensity[effect] //= scale
153            potions.append(potion)
154        self.used = True
155        return tuple(potions)
156    
157    def __eq__(self, other):
158        return (self.effects == other.effects and self.intensity == other.intensity)
159
160    def __lt__(self, other):
161        return sum(self.intensity.values()) < sum(other.intensity.values())
162    
163    def __gt__(self, other):
164        return sum(self.intensity.values()) > sum(other.intensity.values())
165
166
167class ГоспожатаПоХимия:
168    def __init__(self):
169        self.durations = {}
170        self.targets = {}
171        self.effects = {}
172
173    def apply(self, target, potion):
174        old_target = copy.deepcopy(target)
175        potion.apply(target)
176        self.durations[id(potion)] = potion.duration
177        if id(target) not in self.targets:
178            self.targets[id(target)] = old_target
179        self.effects[id(potion)] = [target, self.targets[id(target)]]
180
181    def tick(self):
182        for effect in self.durations:
183            self.durations[effect] -= 1
184            if  self.durations[effect] == 0:
185                target, old_target = self.effects[effect]
186                for attrib in target.__dir__():
187                    if re.search("^__[A-Za-z_0-9]+__$", attrib):
188                        continue
189                    setattr(target, attrib, getattr(old_target, attrib))