1def asciiSort(list_of_names):
  2    return sum(map(ord, list_of_names))
  3
  4
  5class Potion():
  6    def __init__(self, effects, duration):
  7        self.effects = effects
  8        self.duration = duration
  9        self._effects_names = {}
 10        self._set_attributes()
 11        self._used_effects_list = []
 12        self.changed = False
 13        self.depleted = False
 14
 15    def _set_attributes(self):
 16        for name, effect in self.effects.items():
 17            if name not in self._effects_names:
 18                self._effects_names[name] = 1
 19            else:
 20                self._effects_names[name] = self._effects_names[name] + 1
 21            setattr(self, name, lambda argument,
 22                    effect=effect, name=name: self._call_filter(name, argument, effect))
 23
 24    def _call_filter(self, name, argument, effect):
 25        if name in self._used_effects_list:
 26            raise TypeError("Effect is depleted.")
 27
 28        if self.changed:
 29            raise TypeError(
 30                "Potion is now part of something bigger than itself.")
 31
 32        self._used_effects_list.append(name)
 33
 34        for i in range(self._effects_names[name]):
 35            effect(argument)
 36
 37        if len(self._used_effects_list) == len(self._effects_names):
 38            self.depleted = True
 39
 40    def __add__(self, other):
 41        if self.depleted:
 42            raise TypeError("Potion is depleted.")
 43        self.changed = True
 44        combined_effects = self.effects | other.effects
 45        max_duration = max(self.duration, other.duration)
 46
 47        combined_potion = Potion(combined_effects, max_duration)
 48
 49        for name, intensity in self._effects_names.items():
 50            if name in other._effects_names:
 51                combined_potion._effects_names[name] = intensity + \
 52                    other._effects_names[name]
 53
 54        return combined_potion
 55
 56    def __sub__(self, other):
 57        if self.depleted:
 58            raise TypeError("Potion is depleted.")
 59        self.changed = True
 60
 61        # check if other has different effects from self
 62        for name, intensity in other._effects_names.items():
 63            if name not in self._effects_names:
 64                raise TypeError("Invalid subtraction")
 65
 66        new_effects = {}
 67        new_effects_names = {}
 68        for name, action in self.effects.items():
 69            if name in other._effects_names:
 70                new_intensity = self._effects_names[name] - \
 71                    other._effects_names[name]
 72                if new_intensity >= 1:
 73                    new_effects[name] = action
 74                    new_effects_names[name] = new_intensity
 75            else:
 76                new_effects[name] = action
 77                new_effects_names[name] = self._effects_names[name]
 78
 79        new_potion = Potion(new_effects, self.duration)
 80        new_potion._effects_names = new_effects_names
 81
 82        return new_potion
 83
 84    def __mul__(self, multiply_num):
 85        if self.depleted:
 86            raise TypeError("Potion is depleted.")
 87        self.changed = True
 88
 89        if not isinstance(multiply_num, int):
 90            raise TypeError("Multiplier must be an integer")
 91
 92        multiplied_poition = Potion(self.effects, self.duration)
 93
 94        if multiply_num != 0:
 95            for name, intensity in self._effects_names.items():
 96                # if new intensity is zero, set it to one
 97                new_intensity = max(round(intensity * multiply_num), 1)
 98                multiplied_poition._effects_names[name] = new_intensity
 99
100        return multiplied_poition
101
102    def __truediv__(self, devide_num):
103        if self.depleted:
104            raise TypeError("Potion is depleted.")
105        self.changed = True
106
107        if not isinstance(devide_num, int):
108            raise TypeError("Divider must be an integer")
109
110        if devide_num <= 0:
111            raise ValueError("Divider must be a positive integer")
112
113    def __eq__(self, other):
114        return self._effects_names == other._effects_names and self.effects == other.effects
115
116    def __lt__(self, other):
117        self_intensity = 0
118        other_intensity = 0
119
120        for name, intensity in self._effects_names.items():
121            self_intensity = self_intensity + intensity
122
123        for name, intensity in other._effects_names.items():
124            other_intensity = other_intensity + intensity
125
126        return self_intensity < other_intensity
127
128    def __gt__(self, other):
129        self_intensity = 0
130        other_intensity = 0
131
132        for name, intensity in self._effects_names.items():
133            self_intensity = self_intensity + intensity
134
135        for name, intensity in other._effects_names.items():
136            other_intensity = other_intensity + intensity
137
138        return self_intensity > other_intensity
139
140
141class ГоспожатаПоХимия():
142    def __init__(self):
143        self.potion = None
144        self.ticks = None
145
146    def apply(self, target, potion):
147        if potion.depleted:
148            raise TypeError("Potion is depleted.")
149
150        self.potion = potion
151        self.ticks = potion.duration
152
153        # sort by molecular mass
154        list_to_execute = list(potion.effects.keys())
155        list_to_execute = sorted(list_to_execute, key=asciiSort)
156        print(list_to_execute)
157
158        for name in list_to_execute:
159            try:
160                for i in range(potion._effects_names[name]):
161                    effect = getattr(potion, name)
162                    effect(target)
163            except TypeError as error:
164                if "Effect is depleted." in str(error):
165                    pass
166                else:
167                    print(error)
168
169    def tick(self):
170        self.ticks = self.ticks-1