1# this is test-version while travelling with train, it's very bumpy and hard to see the programs :D :D, code is  not tested
  2# TODO improvements: make private effects and duration, refactor code duplication,
  3#  abstract access through getters/ setters, use function style not for loop
  4class Potion:
  5    def __init__(self, effects_a, duration):
  6        self.effects = effects_a
  7        self.intensity_effects_tracker = dict()
  8        self.is_part_of_something_bigger = False
  9        self.used_effects_tracker = set()
 10        self.depleted_string = "Effect is depleted."
 11
 12        for key, value in effects_a.items():
 13            self.intensity_effects_tracker[key] = 1
 14
 15        for key, value in effects_a.items():
 16            self.__setattr__(key, effects_a[key])
 17        self.duration = duration
 18        self.used = False
 19
 20    def __getattribute__(self, name):
 21        if name in ["effects"]:
 22            return object.__getattribute__(self, name)
 23        elif name in self.effects.keys() and name in self.used_effects_tracker:
 24            raise TypeError(self.depleted_string)
 25        elif name in self.effects.keys():
 26            if self.is_part_of_something_bigger:
 27                raise TypeError("Potion is now part of something bigger than itself.")
 28
 29            def multy_magic(target_a):
 30                for x in range(0, self.intensity_effects_tracker[name], 1):
 31                    self.effects[name](target_a)
 32            self.used_effects_tracker.add(name)
 33            return multy_magic
 34        return object.__getattribute__(self, name)
 35
 36    def __add__(self, other):
 37        self.is_part_of_something_bigger = True
 38        sum_intensity_effects_tracker = dict()
 39        sum_effects = self.effects | other.effects
 40
 41        for effect_name in sum_effects.keys():
 42            if effect_name in self.effects.keys() and effect_name in other.effects.keys():
 43                sum_intensity_effects_tracker[effect_name] = (self.intensity_effects_tracker[effect_name] +
 44                                                              other.intensity_effects_tracker[effect_name])
 45            else:
 46                if effect_name in self.effects.keys():
 47                    sum_intensity_effects_tracker[effect_name] = self.intensity_effects_tracker[effect_name]
 48                else:
 49                    sum_intensity_effects_tracker[effect_name] = other.intensity_effects_tracker[effect_name]
 50
 51        sum_duration = max(self.duration, other.duration)
 52        sum_potion = Potion(sum_effects, sum_duration)
 53        sum_potion.intensity_effects_tracker = sum_intensity_effects_tracker
 54        return sum_potion
 55
 56    def __mul__(self, coefficient):
 57        self.is_part_of_something_bigger = True
 58        if coefficient > 1:
 59            potentiated = self
 60            for x in range(0, coefficient - 1, 1):
 61                potentiated = potentiated + self
 62            return potentiated
 63        else:
 64            for effect in self.effects.keys():
 65                self.intensity_effects_tracker[effect] = round(self.intensity_effects_tracker[effect] * coefficient)
 66
 67    def __sub__(self, other):
 68        self.is_part_of_something_bigger = True
 69        if len(set(other.effects.keys()) - set(self.effects.keys())) > 0:
 70            raise TypeError("Test, Test Presidential alert: Tova e test: Opaa shte umrem bate, "
 71                            "tazi rakiq e dignala mnogo gradus. "
 72                            "Da ne se preporuchva na deca pod 12 godini za 8-mi dekemvri.")
 73        result_potion = Potion({}, self.duration)
 74        for name in self.effects.keys():
 75            if name not in other.effects.keys():
 76                result_potion.intensity_effects_tracker[name] = self.intensity_effects_tracker[name]
 77                result_potion.effects[name] = self.effects[name]
 78                result_potion.__setattr__(name, self.effects[name])
 79            else:
 80                if other.intensity_effects_tracker[name] < self.intensity_effects_tracker[name]:
 81                    result_potion.intensity_effects_tracker[name] = self.intensity_effects_tracker[name] - \
 82                                                                    other.intensity_effects_tracker[name]
 83                    result_potion.effects[name] = other.effects[name]
 84                    result_potion.__setattr__(name, other.effects[name])
 85        return result_potion
 86
 87    def __truediv__(self, n):
 88        self.is_part_of_something_bigger = True
 89        result_potion = Potion(self.effects, self.duration)
 90        for key, value in self.intensity_effects_tracker.items():
 91            result_potion.intensity_effects_tracker[key] = round(value / n)
 92        return (result_potion,)*n
 93
 94    def __eq__(self, other):
 95        if len(set(self.effects.keys()).difference(set(other.effects.keys()))) > 0:
 96            return False
 97        for key, value in self.intensity_effects_tracker.items():
 98            if value != other.intensity_effects_tracker[key]:
 99                return False
100        return True
101
102    def __gt__(self, other):
103        self_intensity_sum = 0
104        for _, value in self.intensity_effects_tracker.items():
105            self_intensity_sum += value
106        other_intensity_sum = 0
107        for _, value in other.intensity_effects_tracker.items():
108            other_intensity_sum += value
109        if self_intensity_sum > other_intensity_sum:
110            return True
111        return False
112
113
114class ГоспожатаПоХимия:
115    def __init__(self):
116        self.ticker = 0
117        self.students_in_gas_chamber = dict()
118
119    def apply(self, target_a, potion):
120        if potion.used:
121            raise TypeError("Potion is depleted.")
122        if potion.is_part_of_something_bigger:
123            raise TypeError("Potion is now part of something bigger than itself.")
124        applicable = dict()
125        for key in potion.effects.keys():
126            if key not in potion.used_effects_tracker:
127                applicable[sum(map(ord, key))] = key
128        if len(applicable) > 0:
129            target_with_head_dict = target_a.__dict__.copy()
130            if self.ticker in self.students_in_gas_chamber.keys():
131                self.students_in_gas_chamber[self.ticker + potion.duration] = (
132                    self.students_in_gas_chamber[self.ticker].append((target_a, target_with_head_dict)))
133            else:
134                self.students_in_gas_chamber[self.ticker + potion.duration] = [(target_a, target_with_head_dict)]
135            for index in sorted(applicable, reverse=True):
136                potion.effects[applicable[index]](target_a)
137            potion.depleted_string = "Potion is depleted."
138
139    def tick(self):
140        self.ticker += 1
141        if self.ticker in self.students_in_gas_chamber.keys():
142            for target_student, previous_head in self.students_in_gas_chamber[self.ticker]:
143                target_student.__dict__ = previous_head