1import copy
  2
  3class Potion:
  4
  5    def __init__(self, effects, duration, intensities=False, sacrificed=False, depleted=False):
  6        self.depleted_effects = set()
  7        self.effects = effects
  8        self.duration = duration
  9        self.sacrificed = sacrificed
 10        self.depleted = depleted
 11        self.intensities = {}
 12        # make the effects methods and add intensity 1 for each name
 13        for name, func in self.effects.items():
 14            setattr(self, name, func)
 15
 16        if not intensities:
 17            for name, func in self.effects.items():
 18                self.intensities.update({name : 1})
 19        else:
 20            self.intensities = intensities
 21
 22    def __add__(self, other):
 23        if self.depleted or other.depleted:
 24            raise TypeError("Potion is depleted.")
 25        if self.sacrificed or other.sacrificed:
 26            raise TypeError("Potion is now part of something bigger than itself.")
 27        self_active_effects = set(self.effects.keys()) - self.depleted_effects
 28        other_active_effects = set(other.effects.keys()) - other.depleted_effects
 29        #union the effects of both
 30        updated_effects_keys = self_active_effects | other_active_effects
 31        updated_effects = {}
 32        updated_intensities = {}
 33        # traverse both intensities dict-s and add to the updated one
 34        for name, intensity in self.intensities.items():
 35            if name in updated_effects_keys and name not in self.depleted_effects:
 36                if updated_intensities.get(name):
 37                    updated_intensities[name] += intensity
 38                else:
 39                    updated_intensities[name] = intensity
 40
 41        for name, intensity in other.intensities.items():
 42            if name in updated_effects_keys and name not in other.depleted_effects:
 43                if updated_intensities.get(name):
 44                    updated_intensities[name] += intensity
 45                else:
 46                    updated_intensities[name] = intensity
 47
 48        for effect, func in self.effects.items():
 49            if effect in updated_effects_keys:
 50                updated_effects.update({effect : func})
 51
 52        for effect, func in other.effects.items():
 53            if effect in updated_effects_keys:
 54                updated_effects.update({effect : func})
 55
 56        self.sacrificed = True
 57        other.sacrificed = True
 58        return Potion(updated_effects, max(self.duration,other.duration), updated_intensities)
 59
 60    def __mul__(self,number):
 61        if self.depleted:
 62            raise TypeError("Potion is depleted.")
 63        if self.sacrificed:
 64            raise TypeError("Potion is now part of something bigger than itself.")
 65        active_effects_keys= set(self.effects.keys()) - self.depleted_effects
 66        updated_effects = {}
 67        updated_intensities = {}
 68        for effect in active_effects_keys:
 69            updated_effects.update({effect : self.effects[effect]})
 70        for name, intensity in self.intensities.items():
 71            if name not in active_effects_keys:
 72                continue
 73            if intensity * number % 1 == 0.5:
 74                updated_intensities.update({name : int(intensity * number)})
 75            else:
 76                updated_intensities.update({name : round(intensity * number)})
 77
 78        self.sacrificed=True
 79        return Potion(updated_effects, self.duration, updated_intensities)
 80
 81    def __sub__(self, other):
 82        if self.depleted or other.depleted:
 83            raise TypeError("Potion is depleted.")
 84        if self.sacrificed or other.sacrificed:
 85            raise TypeError("Potion is now part of something bigger than itself.")
 86        updated_effects = copy.deepcopy(self.effects)
 87        updated_intensities = copy.deepcopy(self.intensities)
 88        if not set(self.effects.keys()) >= set(other.effects.keys()):
 89            raise TypeError("The effects differ in the potions.")
 90        # traverse the effects_intensity pairs and if effect not present in the right remove it 
 91        for name, intensity in self.intensities.items():
 92            if not name in set(other.effects.keys()) or name in other.depleted_effects:
 93                continue
 94            else:
 95                diff = intensity - other.intensities[name]
 96                if diff <= 0:
 97                    del updated_intensities[name]
 98                    del updated_effects[name]
 99                    continue
100                updated_intensities[name] = diff
101        # remove the effects and coresponding intensities of depleted effects in left potion
102        for effect in self.depleted_effects:
103            del updated_effects[effect]
104            del updated_intensities[effect]
105
106        self.sacrificed = True
107        other.sacrificed = True
108        return Potion(updated_effects, self.duration, updated_intensities)
109
110    def __truediv__(self, number):
111        if self.depleted:
112            raise TypeError("Potion is depleted.")
113        if self.sacrificed:
114            raise TypeError("Potion is now part of something bigger than itself.")
115        active_effects_keys= set(self.effects.keys()) - self.depleted_effects
116        updated_effects = {}
117        for effect in active_effects_keys:
118            updated_effects.update({effect : self.effects[effect]})
119        updated_intensities = {}
120        result = []
121        for name, intensity in self.intensities.items():
122            if name not in active_effects_keys:
123                continue
124            if intensity / number % 1 == 0.5:
125                updated_intensities.update({name : int(intensity / number)})
126            else:
127                updated_intensities.update({name : round(intensity / number)})
128
129        for times in range(number):
130            final_effects = copy.deepcopy(updated_effects)
131            final_intensities = copy.deepcopy(updated_intensities)
132            result.append(Potion(final_effects, self.duration, final_intensities))
133
134        self.sacrificed = True
135        return tuple(result)
136
137    def __eq__(self, other):
138        if self.depleted or other.depleted:
139            raise TypeError("Potion is depleted.")
140        if self.sacrificed or other.sacrificed:
141            raise TypeError("Potion is now part of something bigger than itself.")
142        if set(self.intensities.keys()) != set(other.intensities.keys()):
143            return False
144
145        for name, intensity in self.intensities.items():
146            if self.intensities[name] != other.intensities[name]:
147                return False
148        return True
149
150    def __gt__(self, other):
151        if self.depleted or other.depleted:
152            raise TypeError("Potion is depleted.")
153        if self.sacrificed or other.sacrificed:
154            raise TypeError("Potion is now part of something bigger than itself.")
155
156        sum_first = 0
157        sum_second = 0
158        for name, intensity in self.intensities.items():
159            sum_first += intensity
160        for name, intensity in other.intensities.items():
161            sum_second += intensity
162
163        return sum_first > sum_second
164
165    def __lt__(self, other):
166        if self.depleted or other.depleted:
167            raise TypeError("Potion is depleted.")
168        if self.sacrificed or other.sacrificed:
169            raise TypeError("Potion is now part of something bigger than itself.")
170
171        sum_first = 0
172        sum_second = 0
173        for name, intensity in self.intensities.items():
174            sum_first += intensity
175        for name, intensity in other.intensities.items():
176            sum_second += intensity
177
178        return sum_first < sum_second
179
180    @staticmethod
181    def effect_fortifier(func, times):
182        def effect_fortified(target):
183            for _ in range(times):
184                func(target)
185            return target
186        return effect_fortified
187
188    def __getattribute__(self, name):
189        # if it is not a method or not an effect no problem
190        if not callable(object.__getattribute__(self, name)) or not object.__getattribute__(self, "effects").get(name):
191            return object.__getattribute__(self, name)
192        # if potion has been used in something bigger raise the error
193        if object.__getattribute__(self, "sacrificed"):
194            raise TypeError("Potion is now part of something bigger than itself.")
195        # if potion has been applied already raise the error
196        if object.__getattribute__(self, "depleted"):
197            raise TypeError("Potion is depleted.")
198        # if it hasn't been used before add it to the list of depleted then allow it 
199        if name not in object.__getattribute__(self, "depleted_effects"):
200            object.__getattribute__(self, "depleted_effects").add(name)
201            # fortified based on the current intensity
202            return Potion.effect_fortifier(object.__getattribute__(self, name), object.__getattribute__(self, "intensities")[name])
203        # otherwise throw the error
204        raise TypeError("Effect is depleted.")
205
206
207class ГоспожатаПоХимия:
208
209    def __init__(self):
210        self.active_potions = []
211        self.affected_targets = []
212
213    @staticmethod
214    def molecular_mass(name):
215        mass = 0
216        for pos in range(0, len(name)):
217            mass += ord(name[pos])
218        return mass
219
220    def apply(self, target, potion):
221        # check if the potion is depleted first or has been sac-ed
222        if set(potion.effects.keys()) == potion.depleted_effects:
223            raise TypeError("Potion is depleted.")
224        if potion.sacrificed:
225            raise TypeError("Potion is now part of something bigger than itself.")
226        
227        if potion.duration==0:
228            return None
229
230        remaining_effects = list(set(potion.effects.keys()) - potion.depleted_effects)
231        remaining_effects.sort(key=ГоспожатаПоХимия.molecular_mass, reverse=True)
232        #check if target has been affected already
233        seen = False
234        for target_id, original_data in self.affected_targets:
235            if id(target) == target_id:
236                seen = True
237        # save the original data otherwise
238        if not seen:
239            self.affected_targets.append((id(target), copy.deepcopy(target.__dict__)))
240
241        self.active_potions.append((copy.deepcopy(potion), target))
242
243        for effect in remaining_effects:
244            #apply the effect to the target
245            method=getattr(potion,effect)
246            method(target)
247        # deem the potion depleted after the process
248        potion.depleted = True
249
250    def tick(self):
251        for potion, target in self.active_potions:
252            potion.duration -= 1
253            if potion.duration == 0:
254                # Find the original information and normalize the target
255                for target_id, original_data in self.affected_targets:
256                    if id(target) == target_id:
257                        target.__dict__ = copy.deepcopy(original_data)
258                # Reapply effects for remaining active potions
259                for potion_2,target_2 in self.active_potions:
260                    if potion_2.duration != 0 and target == target_2:
261                        for effect in potion_2.effects:
262                            method = getattr(potion_2, effect)
263                            method(target)
264        # Remove the timed-out potion-target pairs from the list of active ones
265        self.active_potions = [(potion, target) for potion, target in self.active_potions if potion.duration != 0]