def evaluate(self, instance): """ Evaluates the `questions` using the number of answers to it. Parameters ---------- instance : Question | Student Question or Student to evaluate Returns ------- float Reputation as evaluated by the criterion Dict[str, Any] Details about the calculation Raises ------ TypeError If `instance` isn't of type Question or Student """ super(NAnswersCriterion, self).evaluate(instance) if instance.__class__.__name__ == "Question": return instance.answer_set.count(), {} elif instance.__class__.__name__ == "Student": return instance.answers.count(), {} else: msg = "`question` has to be of type Question." logger.error("TypeError: {}".format(msg)) raise TypeError(msg)
def evaluate(self, instance): """ Evaluates the how how often a students rationales are chosen by others. Parameters ---------- instance : student student whose rationales are evaluated Returns ------- float Reputation as evaluated by the criterion Raises ------ TypeError If `instance` isn't of type Student """ super(ConvincingRationalesCriterion, self).evaluate(instance) if instance.__class__.__name__ == "Student": return ( instance.answers_chosen_by_others.count(), { "times_shown": instance.answers_shown_to_others.count() }, ) else: msg = "`instance` has to be of type Student." logger.error("TypeError: {}".format(msg)) raise TypeError(msg)
def evaluate(self, teacher): """ Evaluates the `teacher` using the number of rationale evaluations done. Parameters ---------- teacher : Teacher Teacher to evaluate Returns ------- float Reputation as evaluated by the criterion Dict[str, Any] Details about the calculation Raises ------ TypeError If `instance` isn't of type Teacher """ super(RationaleEvaluationCriterion, self).evaluate(teacher) if teacher.__class__.__name__ == "Teacher": return ( teacher.user.answerannotation_set.filter( score__isnull=False).count(), {}, ) else: msg = "`question` has to be of type Teacher." logger.error("TypeError: {}".format(msg)) raise TypeError(msg)
def evaluate(self, model): """ Evaluates the reputation score of the given `model`. Classes inheriting must call the super method. Parameters ---------- model : Model Model being evaluated. Must be in `for_reputation_types` Returns ------- float Reputation as evaluated by the criterion Raises ------ TypeError If the `model` isn't in the for_reputation_types """ if not self.for_reputation_types.filter( type=model.__class__.__name__.lower()): msg = "The criterion {} isn't available ".format( str(self)) + "for reputation type {}.".format( model.__class__.__name__.lower()) logger.error(msg) raise TypeError(msg)
def evaluate(self, teacher): """ Evaluates the `teacher` using the number of questions composed. Parameters ---------- teacher : Teacher Teacher to evaluate Returns ------- float Reputation as evaluated by the criterion Dict[str, Any] Details about the calculation Raises ------ TypeError If `teacher` isn't of type Teacher """ super(NQuestionsCriterion, self).evaluate(teacher) if teacher.__class__.__name__ != "Teacher": msg = "`teacher` has to be of type Teacher." logger.error("TypeError: {}".format(msg)) raise TypeError(msg) return teacher.user.question_set.count(), {}
def evaluate(self, instance): """ Evaluates the `question` using the number of teachers having liked it and using it. If `instance` is a teacher, sums over all their questions. Parameters ---------- instance : Question | Teacher Question or Teacher to evaluate Returns ------- float Reputation as evaluated by the criterion Dict[str, Any] Details about the calculation Raises ------ TypeError If `instance` isn't of type Question or Teacher """ super(QuestionLikedCriterion, self).evaluate(instance) if instance.__class__.__name__ == "Question": return self._evaluate_question(instance) elif instance.__class__.__name__ == "Teacher": question_evaluations = [ self._evaluate_question(question, instance) for question in instance.user.question_set.all() ] if not question_evaluations: return 0, {} return ( sum(evaluation[0] for evaluation in question_evaluations), { key: [ evaluation[1][key] for evaluation in question_evaluations ] for key in list(question_evaluations[0][1].keys()) }, ) else: msg = "`question` has to be of type Question." logger.error("TypeError: {}".format(msg)) raise TypeError(msg)
def evaluate(self, student): """ Evaluates the `student` using the evaluations given by teachers for their rationales. Score is calculated using the different scores in the model fields. Parameters ---------- student : Student Student to evaluate Returns ------- float Reputation as evaluated by the criterion Dict[str, Any] Details about the calculation Raises ------ TypeError If `instance` isn't of type Question or Student """ super(StudentRationaleEvaluationCriterion, self).evaluate(student) if student.__class__.__name__ == "Student": return ( sum( getattr(self, "points_score_{}".format(evaluation.score)) for answer in student.answers.all() for evaluation in answer.answerannotation_set.filter( score__isnull=False).all()), {}, ) else: msg = "`question` has to be of type Student." logger.error("TypeError: {}".format(msg)) raise TypeError(msg)