Model company for PRG model; selected methods

model.py

class Company(Model):
    """
    Model of a company; pyramidal structure with n different levels;
    workers at different levels weigh differently on the efficiency of the
    company as a whole.
    """
    def pick_for_promotion_from(self, source_level):
        if self.promotion_strategy == 'best':
            return max(source_level, key=lambda e: e.competency)
        elif self.promotion_strategy == 'worst':
            return min(source_level, key=lambda e: e.competency)
        elif self.promotion_strategy == 'random':
            return self.random.choice(source_level)

    def recalculate_competency(self, employee):
        # Peter hypothesis: competency in new role not dependent on competency
        #                   in previous role
        if self.competency_mechanism == 'peter':
            employee.competency = self.competency_distribution.rvs()
        # Common-sense: competency mostly transferable from previous role
        elif self.competency_mechanism == 'common_sense':
            # TODO: abstract parameters used here
            random_variation = self.random.uniform(-1, 1)
            employee.competency += random_variation
            employee.competency = min(max(0, employee.competency), 10)  # Clip

    def promote_employees(self):
        for upper_level, lower_level, target_size in zip(self.levels,
                                                         self.levels[1:],
                                                         self.level_sizes):
            while len(upper_level) < target_size:
                chosen_employee = self.pick_for_promotion_from(lower_level)
                lower_level.remove(chosen_employee)
                self.recalculate_competency(chosen_employee)
                upper_level.append(chosen_employee)