class Response(models.InheritableModel, models.TimeStampedStatusModel):
"""
Represents a student's response to some activity. The student may submit
many responses for the same object. It is also possible to submit
different responses with different students.
"""
STATUS_PENDING = 'pending'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_PENDING, _('pending')),
(STATUS_WAITING, _('waiting')),
(STATUS_DONE, _('done')),
)
activity = models.ForeignKey(Activity, blank=True, null=True)
user = models.ForeignKey(models.User)
grade = models.DecimalField(
'Percentage of maximum grade',
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
data = models.PickledObjectField(blank=True, null=True)
#
# Visualization
#
ok_message = '*Contratulations!* Your response is correct!'
wrong_message = 'I\'m sorry, your response is wrong.'
partial_message = 'Your answer is partially correct: you made %(grade)d%% of the total grade.'
def as_html(self):
data = {'grade': self.grade * 100}
if self.grade == 1:
return markdown(self.ok_message)
elif self.grade == 0:
return markdown(self.wrong_message)
else:
return markdown(self.partial_message % data)
def __str__(self):
tname = type(self).__name__
return '%s(%s, grade=%s)' % (tname, self.activity, self.grade)
class Choice(models.Orderable):
question = models.ParentalKey(MultipleChoiceQuestion,
related_name='choices')
text = models.RichTextField(_('Choice description'))
uuid = models.UUIDField(default=uuid.uuid4)
value = models.DecimalField(
_('Value'), decimal_places=1, max_digits=4,
validators=[validators.MinValueValidator(0),
validators.MaxValueValidator(100)],
help_text=_(
'Grade given for users that choose these option (value=0, for an '
'incorrect choice and value=100 for a correct one).'
),
default=0,
)
def __repr__(self):
return 'Choice(value=%s, ...)' % self.value
panels = [
panels.FieldPanel('text'),
panels.FieldPanel('value'),
]
class Response(models.CopyMixin, models.InheritableModel,
models.TimeStampedStatusModel):
"""
Represents a student's response to some activity.
Response objects have 4 different states:
pending:
The response has been sent, but was not graded. Grading can be manual or
automatic, depending on the activity.
waiting:
Waiting for manual feedback.
invalid:
The response has been sent, but contains malformed data.
done:
The response was graded and evaluated and it initialized a feedback
object.
A response always starts at pending status. We can request it to be graded
by calling the :func:`Response.autograde` method. This method must raise
an InvalidResponseError if the response is invalid or ManualGradingError if
the response subclass does not implement automatic grading.
"""
class Meta:
verbose_name = _('response')
verbose_name_plural = _('responses')
STATUS_PENDING = 'pending'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_PENDING, _('pending')),
(STATUS_WAITING, _('waiting')),
(STATUS_INVALID, _('invalid')),
(STATUS_DONE, _('done')),
)
activity = models.ForeignKey(
Activity,
blank=True,
null=True,
related_name='responses',
on_delete=models.CASCADE,
)
user = models.ForeignKey(
models.User,
blank=True,
null=True,
)
feedback_data = models.PickledObjectField(blank=True, null=True)
given_grade = models.DecimalField(
_('Percentage of maximum grade'),
help_text=_(
'This grade is given by the auto-grader and represents the grade '
'for the response before accounting for any bonuses or penalties.'
),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
final_grade = models.DecimalField(
_('Final grade'),
help_text=_(
'Similar to given_grade, but can account for additional factors '
'such as delay penalties or for any other reason the teacher may '
'want to override the student\'s grade.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
manual_override = models.BooleanField(default=False)
parent = models.ForeignKey(
'self',
blank=True,
null=True,
on_delete=models.SET_NULL,
related_name='children',
)
is_converted = models.BooleanField(default=False)
# Status properties
is_done = property(lambda x: x.status == x.STATUS_DONE)
is_pending = property(lambda x: x.status == x.STATUS_PENDING)
is_waiting = property(lambda x: x.status == x.STATUS_WAITING)
is_invalid = property(lambda x: x.status == x.STATUS_INVALID)
# Delegate properties
course = property(lambda x: getattr(x.activity, 'course', None))
# Other properties
@property
def grade(self):
if self.final_grade is None:
return self.given_grade or decimal.Decimal(0)
else:
return self.final_grade
grade.setter(lambda x, v: setattr(x, 'final_grade', v))
class InvalidResponseError(Exception):
"""Raised by compute_response() when the response is invalid."""
# Compute grades
def get_response_group(self, user):
"""Return the response group associated to this response."""
def get_feedback(self, commit=True):
"""Return the feedback object associated to the given response.
This method may trigger the autograde() method, if grading was not
performed yet. If you want to defer database access, call it with
commit=False to prevent saving any modifications to the response object
to the database.
"""
if self.status == self.STATUS_PENDING:
self.autograde(commit)
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
elif self.status == self.STATUS_WAITING:
return None
return self.feedback_data
def autograde(self, commit=True, force=False):
"""
Performs automatic grading.
Response subclasses must implement the autograde_compute() method in
order to make automatic grading work. This method may write any
relevant information to the `feedback_data` attribute and must return
a numeric value from 0 to 100 with the given automatic grade.
"""
if self.status == self.STATUS_PENDING or force:
try:
value = self.autograde_compute()
except self.InvalidResponseError as ex:
self.status = self.STATUS_INVALID
self.feedback_data = ex
self.given_grade = self.final_grade = decimal.Decimal(0)
if commit:
self.save()
raise
if value is None:
self.status = self.STATUS_WAITING
else:
self.given_grade = decimal.Decimal(value)
self.final_grade = self.given_grade
self.status = self.STATUS_DONE
if commit and self.pk:
self.save(update_fields=[
'status', 'feedback_data', 'given_grade', 'final_grade'
])
elif commit:
self.save()
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
def autograde_compute(self):
"""This method should be implemented in subclasses."""
raise ImproperlyConfigured(
'Response subclass %r must implement the autograde_compute().'
'This method should perform the automatic grading and return the '
'resulting grade. Any additional relevant feedback data might be '
'saved to the `feedback_data` attribute, which is then is pickled '
'and saved into the database.' % type(self).__name__)
def __str__(self):
return '%s(%s)' % (type(self).__name__, self.status)
# Feedback and visualization
ok_message = _('*Congratulations!* Your response is correct!')
wrong_message = _('I\'m sorry, your response is wrong.')
partial_message = _('Your answer is partially correct: you achieved only '
'%(grade)d%% of the total grade.')
def html_feedback(self):
"""
A string of html source representing the feedback.
"""
if self.is_done:
data = {'grade': (self.grade or 0)}
if self.grade == 100:
return markdown(self.ok_message)
elif not self.grade:
return markdown(self.wrong_message)
else:
return markdown(aself.partial_message % data)
else:
return markdown(_('Your response has not been graded yet!'))
# Permissions
def can_edit(self, user):
return False
def can_view(self, user):
return user == self.user
class FinalResponse(models.CopyMixin, models.Model):
"""
Gather all responses of the same user to a given activity together.
This is useful in grading when e.g., selecting for the average/best/worst/
first/last grade.
"""
class Meta:
unique_together = [('user', 'activity')]
verbose_name = _('final response')
verbose_name_plural = _('final responses')
user = models.ForeignKey(
models.User,
related_name='final_responses',
)
activity = models.ForeignKey(
Activity,
blank=True,
null=True,
related_name='final_responses',
)
final_grade = models.DecimalField(
_('Final grade'),
help_text=_('Final grade given to activity considering all responses, '
'penalties, etc.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
def get_responses(self):
"""
Return a queryset with all responses associated with the user.
"""
return self.activity.get_user_responses(self.user)
def grade(self, method=None, force_update=False):
"""
Return the final grade for the user using the given method.
If not method is given, it uses the default grading method for the
activity.
"""
activity = self.activity
# Choose grading method
if method is None and self.final_grade is not None:
return self.final_grade
elif method is None:
grading_method = activity.grading_method
else:
grading_method = GradingMethod.from_name(activity.owner, method)
# Grade response. We save the result to the final_grade attribute if
# no explicit grading method is given.
grade = grading_method.grade(self)
if method is None and (force_update or self.final_grade is None):
self.final_grade = grade
return grade
def __iter__(self):
return iter(self.get_responses())
def __len__(self):
return self.get_responses().count()
class Deadline(models.Model):
"""
Describes a deadline of an activity.
Users may define soft/hard deadlines.
"""
name = models.CharField(
_('name'),
max_length=140,
blank=True,
help_text=_(
'A unique string identifier. Useful for creating human-friendly '
'references to the deadline object.'))
start = models.DateField(
_('start'),
blank=True,
null=True,
)
deadline = models.DateTimeField(
_('deadline'),
blank=True,
null=True,
)
hard_deadline = models.DateTimeField(
_('hard deadline'),
blank=True,
null=True,
help_text=_(
'If set, responses submitted after the deadline will be accepted '
'with a penalty.'))
penalty = models.DecimalField(
_('delay penalty'),
default=25,
decimal_places=2,
max_digits=6,
help_text=_(
'Sets the percentage of the total grade that will be lost due to '
'delayed responses.'),
)
def get_status(self):
"""
Return one of the strings depending on how the current time relates to
the deadline:
closed:
Activity has not opened yet.
valid:
Current time is within the deadline.
expired:
Hard deadline has expired. Users cannot submit to the activity.
penalty:
Official deadline has expired, but users can still submit with a
penalty.
"""
now = timezone.now()
if self.start is not None and now < self.start:
return 'closed'
elif ((self.hard_deadline is not None and now > self.hard_deadline)
or (self.hard_deadline is None and self.deadline is not None
and now > self.deadline)):
return 'expired'
elif (self.hard_deadline is not None and now < self.hard_deadline
and self.deadline is not None and now > self.deadline):
return 'penalty'
else:
return 'valid'
def get_penalty(self):
"""
Return the penalty value
"""
status = self.get_status()
if status == 'expired':
return Decimal(100)
elif status == 'penalty':
return self.penalty
elif status == 'valid':
return Decimal(0)
else:
raise RuntimeError('cannot get penalty of closed activity')
def revise_grade(self, grade):
"""
Return the update grade considering any possible delay penalty.
"""
return (100 - self.get_penalty()) * Decimal(grade) / 100
class Progress(CommitMixin,
models.CopyMixin,
models.StatusModel,
models.TimeStampedModel,
models.PolymorphicModel):
"""
When an user starts an activity it opens a Progress object which control
all submissions to the given activity.
The Progress object also manages individual submissions that may span
several http requests.
"""
class Meta:
unique_together = [('user', 'activity_page')]
verbose_name = _('student progress')
verbose_name_plural = _('student progress list')
STATUS_OPENED = 'opened'
STATUS_CLOSED = 'closed'
STATUS_INCOMPLETE = 'incomplete'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_OPENED, _('opened')),
(STATUS_CLOSED, _('closed')),
)
user = models.ForeignKey(models.User, on_delete=models.CASCADE)
activity_page = models.ForeignKey(models.Page, on_delete=models.CASCADE)
final_grade_pc = models.DecimalField(
_('final score'),
max_digits=6, decimal_places=3, default=Decimal,
help_text=_(
'Final grade given to considering all submissions, penalties, etc.'
),
)
given_grade_pc = models.DecimalField(
_('grade'),
max_digits=6, decimal_places=3, default=Decimal,
help_text=_('Final grade before applying any modifier.'),
)
finished = models.DateTimeField(blank=True, null=True)
best_submission = models.ForeignKey('Submission', blank=True, null=True,
related_name='+')
points = models.IntegerField(default=0)
score = models.IntegerField(default=0)
stars = models.FloatField(default=0.0)
is_correct = models.BooleanField(default=bool)
has_submissions = models.BooleanField(default=bool)
has_feedback = models.BooleanField(default=bool)
has_post_tests = models.BooleanField(default=bool)
objects = ProgressManager()
#: The number of submissions
num_submissions = property(lambda x: x.submissions.count())
#: Specific activity reference
activity = property(lambda x: x.activity_page.specific)
activity_id = property(lambda x: x.activity_page_id)
#: Has progress mixin interface
username = property(lambda x: x.user.username)
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self)
def __str__(self):
tries = self.num_submissions
user = self.user
activity = self.activity
grade = '%s pts' % (self.final_grade_pc or 0)
fmt = '%s by %s (%s, %s tries)'
return fmt % (activity, user, grade, tries)
def submit(self, request, payload, recycle=True, commit=True):
"""
Creates new submission.
Args:
recycle:
If True, recycle submission objects with the same content as the
current submission. If a submission exists with the same content
as the current submission, it simply returns the previous
submission. If recycled, sets the submission.recycled to True.
"""
submission_class = self.activity.submission_class
submission = submission_class(progress=self, **payload)
submission.ip_address = get_ip(request)
submission.hash = submission.compute_hash()
submission.full_clean()
# Then check if any submission is equal to some past submission and
# then recycle it
recyclable = submission_class.objects.recyclable(submission)
recyclable = recyclable if recycle else ()
for possibly_equal in recyclable:
if submission.is_equal(possibly_equal):
possibly_equal.recycled = True
possibly_equal.bump_recycles()
return possibly_equal
else:
return submission.commit(commit)
def register_feedback(self, feedback, commit=True):
"""
This method is called after a submission is graded and produces a
feedback.
"""
submission = feedback.submission
# Check if it is the best submission
grade = feedback.given_grade_pc
if (self.best_submission is None or
self.best_submission.feedback.given_grade_pc < grade):
self.best_submission = submission
# Update grades for activity considering past submissions
self.update_grades_from_feedback(feedback)
self.commit(commit)
def update_grades_from_feedback(self, feedback):
"""
Update grades from the current progress object from the given feedback.
"""
# Update grades, keeping always the best grade
if self.given_grade_pc < (feedback.given_grade_pc or 0):
self.given_grade_pc = feedback.given_grade_pc
if self.final_grade_pc < feedback.final_grade_pc:
self.final_grade_pc = feedback.final_grade_pc
# Update the is_correct field
self.is_correct = self.is_correct or feedback.is_correct
class Feedback(HasProgressMixin, models.TimeStampedModel,
models.PolymorphicModel):
"""
Feedback for user.
Usually there will be one feedback per submission, but this figure may
vary from case to case.
"""
TITLE_OK = _('Correct answer!')
TITLE_PARTIAL = _('Partially correct.')
TITLE_WRONG = _('Wrong answer.')
TITLE_NOT_GRADED = _('Not graded.')
MESSAGE_OK = _('*Congratulations!* Your response is correct!')
MESSAGE_OK_WITH_PENALTIES = _(
'Your response is correct, but you did not achieved the maximum grade.'
)
MESSAGE_WRONG = _('I\'m sorry. Wrong response response!')
MESSAGE_PARTIAL = _(
'Your answer is partially correct: you achieved %(grade)d%% of '
'the total grade.')
MESSAGE_NOT_GRADED = _('Your response has not been graded yet!')
submission = models.OneToOneField('Submission', related_name='feedback')
manual_grading = models.BooleanField(
default=True,
help_text=_('True if feedback was created manually by a human.'))
grader_user = models.ForeignKey(
models.User,
blank=True,
null=True,
help_text=_('User that performed the manual grading.'))
given_grade_pc = models.DecimalField(
_('percentage of maximum grade'),
help_text=_(
'This grade is given by the auto-grader and represents the grade '
'for the response before accounting for any bonuses or penalties.'
),
max_digits=6,
decimal_places=3,
validators=[grade_validator],
blank=True,
null=True,
)
final_grade_pc = models.DecimalField(
_('final grade'),
help_text=_(
'Similar to given_grade, but can account for additional factors '
'such as delay penalties or for any other reason the teacher may '
'want to override the student\'s grade.'),
max_digits=6,
decimal_places=3,
validators=[grade_validator],
blank=True,
null=True,
)
is_correct = models.BooleanField(default=False)
progress = lazy(lambda x: x.submission.progress)
def get_feedback_title(self):
"""
Return a title summarizing the feedback result. The default set of
titles come from the list:
* Correct answer!
* Partially correct.
* Wrong answer.
* Not graded.
Different question types may define additional values to this list.
"""
grade = self.given_grade_pc
if grade == 100:
return self.TITLE_OK
elif grade is not None and grade > 0:
return self.TITLE_PARTIAL
elif grade == 0:
return self.TITLE_WRONG
else:
return self.TITLE_NOT_GRADED
def update_autograde(self):
"""
Compute and set self.given_grade.
This function may change other states in the feedback object, depending
on the activity.
"""
activity = self.activity
submission = self.submission
self.given_grade_pc = self.get_given_autograde(submission, activity)
def get_given_autograde(self, submission, activity):
"""
Atomic and testable version of autograde_update().
Subclasses should overide this method.
Args:
submission: a submission object
activity: the activity the submission refers to
Returns:
A numeric value between 0 and 100 with the assigned grade.
"""
name = self.__class__.__name__
raise ImproperlyConfigured(
'Class %s must implement the .autograde() method.' % name)
def update_final_grade(self):
"""
Compute final grade applying all possible penalties and bonuses.
"""
self.final_grade_pc = self.given_grade_pc
if self.given_grade_pc == 100:
self.is_correct = True
def render_message(self, **kwargs):
"""
Renders feedback message.
"""
if self.is_correct and self.final_grade_pc >= self.given_grade_pc:
msg = self.MESSAGE_OK
elif self.is_correct and self.final_grade_pc < self.given_grade_pc:
msg = self.MESSAGE_OK_WITH_PENALTIES
elif not self.is_correct and self.given_grade_pc > 0:
msg = self.MESSAGE_PARTIAL
else:
msg = self.MESSAGE_WRONG
return p(msg, cls='cs-feedback-message').render(**kwargs)
class HasScorePage(models.Page):
"""
Mixin abstract page class for Page elements that implement the Score API.
Subclasses define points_value, stars_value, and difficulty fields that
define how activities contribute to Codeschool score system.
"""
class Meta:
abstract = True
DIFFICULTY_TRIVIAL = 0
DIFFICULTY_VERY_EASY = 1
DIFFICULTY_EASY = 2
DIFFICULTY_REGULAR = 3
DIFFICULTY_HARD = 4
DIFFICULTY_VERY_HARD = 5
DIFFICULTY_CHALLENGE = 6
DIFFICULTY_CHOICES = [
(DIFFICULTY_TRIVIAL, _('Trivial')),
(DIFFICULTY_VERY_EASY, _('Very Easy')),
(DIFFICULTY_EASY, _('Easy')),
(DIFFICULTY_REGULAR, _('Regular')),
(DIFFICULTY_HARD, _('Hard')),
(DIFFICULTY_VERY_HARD, _('Very Hard')),
(DIFFICULTY_CHALLENGE, _('Challenge!')),
]
SCORE_FROM_DIFFICULTY = {
DIFFICULTY_TRIVIAL: 10,
DIFFICULTY_VERY_EASY: 30,
DIFFICULTY_EASY: 60,
DIFFICULTY_REGULAR: 100,
DIFFICULTY_HARD: 150,
DIFFICULTY_VERY_HARD: 250,
DIFFICULTY_CHALLENGE: 500,
}
DEFAULT_DIFFICULTY = DIFFICULTY_REGULAR
points_total = models.IntegerField(
_('value'),
blank=True,
help_text=_(
'Points may be awarded in specific contexts (e.g., associated with '
'a quiz or in a list of activities) and in Codeschool\'s generic '
'ranking system.'))
stars_total = models.DecimalField(
_('stars'),
decimal_places=1,
max_digits=5,
blank=True,
help_text=_(
'Number of stars the activity is worth (fractional stars are '
'accepted). Stars are optional bonus points for special '
'accomplishments that can be used to trade "special powers" in '
'codeschool.'),
default=0.0)
difficulty = models.IntegerField(
blank=True,
choices=DIFFICULTY_CHOICES,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if not kwargs:
self._score_memo = self.points_total, self.stars_total
def clean(self):
# Fill default difficulty
if self.difficulty is None:
self.difficulty = self.DEFAULT_DIFFICULTY
# Fill default points value from difficulty
if self.points_total is None:
self.points_total = self.SCORE_FROM_DIFFICULTY[self.difficulty]
super().clean()
def save(self, *args, **kwargs):
scores = getattr(self, '_score_memo', (0, 0))
super().save(*args, **kwargs)
# Update the ScoreTotals table, if necessary.
if scores != (self.points_total, self.stars_total):
points = self.points_total
stars = self.stars_total
TotalScore.update(self, points=points, stars=stars)
def get_score_contributions(self):
"""
Return a dictionary with the score value associated with
points, score, and stars.
"""
return {
'points': self.points_total,
'stars': self.stars_total,
}
class ScoreHandler(models.TimeStampedModel):
"""
Common implementations for TotalScores and UserScores.
"""
class Meta:
abstract = True
page = models.ForeignKey(models.Page, related_name='+')
points = models.IntegerField(default=0)
stars = models.DecimalField(default=Decimal(0),
decimal_places=1,
max_digits=5)
@lazy_classattribute
def _wagtail_root(cls):
return models.Page.objects.get(path='0001')
@lazy
def specific(self):
return self.page.specific
def get_parent(self):
"""
Return parent resource handler.
"""
raise NotImplementedError('must be implemented in subclasses')
def get_children(self):
"""
Return a queryset with all children resource handlers.
"""
raise NotImplementedError('must be implemented in subclasses')
def set_diff(self,
points=0,
stars=0,
propagate=True,
commit=True,
optimistic=False):
"""
Change the given resources by the given amounts and propagate to all
the parents.
"""
# Update fields
kwargs = {}
if points and (points > 0 or not optimistic):
self.points += points
kwargs['points'] = points
if stars and (stars > 0 or not optimistic):
self.stars += stars
kwargs['stars'] = stars
if kwargs and commit:
self.save(update_fields=kwargs.keys())
# Propagate to all parent resources
if propagate and kwargs and commit:
parent = self.get_parent()
kwargs['commit'] = True
kwargs['propagate'] = True
if parent is not None:
parent.set_diff(optimistic=False, **kwargs)
def set_values(self,
points=0,
stars=0,
propagate=True,
optimistic=False,
commit=True):
"""
Register a new value for the resource.
If new value is greater than the current value, update the resource
and propagate.
Args:
points, score, stars, (number):
New value assigned to each specified resource.
propagate (bool):
If True (default), increment all parent nodes.
optimistic (bool):
If True, only update if give value is greater than the
registered value.
commit (bool):
If True (default), commit results to the database.
"""
d_points = points - self.points
d_stars = Decimal(stars) - self.stars
self.set_diff(points=d_points,
stars=d_stars,
propagate=propagate,
commit=commit,
optimistic=optimistic)
class Submission(ResponseDataMixin, FeedbackDataMixin, models.CopyMixin,
models.StatusModel, models.TimeStampedModel,
models.PolymorphicModel):
"""
Represents a student's simple submission in response to some activity.
Submissions can be in 4 different states:
pending:
The response has been sent, but was not graded. Grading can be manual or
automatic, depending on the activity.
waiting:
Waiting for manual feedback.
incomplete:
For long-term activities, this tells that the student started a response
and is completing it gradually, but the final response was not achieved
yet.
invalid:
The response has been sent, but contains malformed data.
done:
The response was graded and evaluated and it initialized a feedback
object.
A response always starts at pending status. We can request it to be graded
by calling the :func:`Response.autograde` method. This method must raise
an InvalidResponseError if the response is invalid or ManualGradingError if
the response subclass does not implement automatic grading.
"""
class Meta:
verbose_name = _('submission')
verbose_name_plural = _('submissions')
# Feedback messages
MESSAGE_OK = _('*Congratulations!* Your response is correct!')
MESSAGE_OK_WITH_PENALTIES = _(
'Your response is correct, but you did not achieved the maximum grade.'
)
MESSAGE_WRONG = _('I\'m sorry, your response is wrong.')
MESSAGE_PARTIAL = _(
'Your answer is partially correct: you achieved only %(grade)d%% of '
'the total grade.')
MESSAGE_NOT_GRADED = _('Your response has not been graded yet!')
# Status
STATUS_PENDING = 'pending'
STATUS_INCOMPLETE = 'incomplete'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
# Fields
STATUS = models.Choices(
(STATUS_PENDING, _('pending')),
(STATUS_INCOMPLETE, _('incomplete')),
(STATUS_WAITING, _('waiting')),
(STATUS_INVALID, _('invalid')),
(STATUS_DONE, _('done')),
)
response = models.ParentalKey(
'Response',
related_name='submissions',
)
given_grade = models.DecimalField(
_('percentage of maximum grade'),
help_text=_(
'This grade is given by the auto-grader and represents the grade '
'for the response before accounting for any bonuses or penalties.'
),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
final_grade = models.DecimalField(
_('final grade'),
help_text=_(
'Similar to given_grade, but can account for additional factors '
'such as delay penalties or for any other reason the teacher may '
'want to override the student\'s grade.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
manual_override = models.BooleanField(default=False)
points = models.IntegerField(default=0)
score = models.IntegerField(default=0)
stars = models.FloatField(default=0)
objects = SubmissionManager()
# Status properties
is_done = property(lambda x: x.status == x.STATUS_DONE)
is_pending = property(lambda x: x.status == x.STATUS_PENDING)
is_waiting = property(lambda x: x.status == x.STATUS_WAITING)
is_invalid = property(lambda x: x.status == x.STATUS_INVALID)
@property
def is_correct(self):
if self.given_grade is None:
raise AttributeError('accessing attribute of non-graded response.')
else:
return self.given_grade == 100
# Delegate properties
activity = delegate_to('response')
activity_id = delegate_to('response')
activity_page = delegate_to('response')
activity_page_id = delegate_to('response')
user = delegate_to('response')
user_id = delegate_to('response')
stars_total = delegate_to('activity')
points_total = delegate_to('activity')
@classmethod
def response_data_hash(cls, response_data):
"""
Computes a hash for the response_data attribute.
Data must be given as a JSON-like structure or as a string of JSON data.
"""
if response_data:
if isinstance(response_data, str):
data = response_data
else:
data = json.dumps(response_data, default=json_default)
return md5hash(data)
return ''
def __init__(self, *args, **kwargs):
# Django is loading object from the database -- we step out the way
if args and not kwargs:
super().__init__(*args, **kwargs)
return
# We create the response_data and feedback_data manually always using
# copies of passed dicts. We save these variables here, init object and
# then copy this data to the initialized dictionaries
response_data = kwargs.pop('response_data', None) or {}
feedback_data = kwargs.pop('feedback_data', None) or {}
# This part makes a Submission instance initialize from a user +
# activity instead of requiring a response object. The response is
# automatically created on demand.
user = kwargs.pop('user', None)
if 'response' in kwargs and user and user != kwargs['response'].user:
response_user = kwargs['response'].user
raise ValueError('Inconsistent user definition: %s vs. %s' %
(user, response_user))
elif 'response' not in kwargs and user:
try:
activity = kwargs.pop('activity')
except KeyError:
raise TypeError(
'%s objects bound to a user must also provide an '
'activity parameter.' % type(self).__name__)
else:
# User-bound constructor tries to obtain the response object by
# searching for an specific (user, activity) tuple.
response, created = Response.objects.get_or_create(
user=user, activity=activity)
kwargs['response'] = response
if 'context' in kwargs or 'activity' in kwargs:
raise TypeError(
'Must provide an user to instantiate a bound submission.')
super().__init__(*args, **kwargs)
# Now that we have initialized the submission, we fill the data
# passed in the response_data and feedback_data dictionaries.
self.response_data = dict(self.response_data or {}, **response_data)
self.feedback_data = dict(self.response_data or {}, **feedback_data)
def __str__(self):
if self.given_grade is None:
grade = self.status
else:
grade = '%s pts' % self.final_grade
user = self.user
activity = self.activity
name = self.__class__.__name__
return '<%s: %s by %s (%s)>' % (name, activity, user, grade)
def __html__(self):
"""
A string of html source representing the feedback.
"""
if self.is_done:
data = {'grade': (self.final_grade or 0)}
if self.final_grade == 100:
return markdown(self.MESSAGE_OK)
elif self.given_grade == 100:
return markdown(self.ok_with_penalties_message)
elif not self.given_grade:
return markdown(self.MESSAGE_WRONG)
else:
return markdown(self.MESSAGE_PARTIAL % data)
else:
return markdown(self.MESSAGE_NOT_GRADED)
def save(self, *args, **kwargs):
if not self.response_hash:
self.response_hash = self.response_hash_from_data(
self.response_hash)
super().save(*args, **kwargs)
def final_points(self):
"""
Return the amount of points awarded to the submission after
considering all penalties and bonuses.
"""
return self.points
def final_stars(self):
"""
Return the amount of stars awarded to the submission after
considering all penalties and bonuses.
"""
return self.stars
def given_stars(self):
"""
Compute the number of stars that should be awarded to the submission
without taking into account bonuses and penalties.
"""
return self.stars_total * (self.given_grade / 100)
def given_points(self):
"""
Compute the number of points that should be awarded to the submission
without taking into account bonuses and penalties.
"""
return int(self.points_total * (self.given_grade / 100))
def feedback(self, commit=True, force=False, silent=False):
"""
Return the feedback object associated to the given response.
This method may trigger the autograde() method, if grading was not
performed yet. If you want to defer database access, call it with
commit=False to prevent saving any modifications to the response object
to the database.
The commit, force and silent arguments have the same meaning as in
the :func:`Submission.autograde` method.
"""
if self.status == self.STATUS_PENDING:
self.autograde(commit=commit, force=force, silent=silent)
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
elif self.status == self.STATUS_WAITING:
return None
return self.feedback_data
def autograde(self, commit=True, force=False, silent=False):
"""
Performs automatic grading.
Response subclasses must implement the autograde_compute() method in
order to make automatic grading work. This method may write any
relevant information to the `feedback_data` attribute and must return
a numeric value from 0 to 100 with the given automatic grade.
Args:
commit:
If false, prevents saving the object when grading is complete.
The user must save the object manually after calling this
method.
force:
If true, force regrading the item even if it has already been
graded. The default behavior is to ignore autograde from a
graded submission.
silent:
Prevents the submission_graded_signal from triggering in the
end of a successful grading.
"""
if self.status == self.STATUS_PENDING or force:
# Evaluate grade using the autograde_value() method of subclass.
try:
value = self.autograde_value()
except self.InvalidSubmissionError as ex:
self.status = self.STATUS_INVALID
self.feedback_data = ex
self.given_grade = self.final_grade = decimal.Decimal(0)
if commit:
self.save()
raise
# If no value is returned, change to STATUS_WAITING. This probably
# means that response is partial and we need other submissions to
# complete the final response
if value is None:
self.status = self.STATUS_WAITING
# A regular submission has a decimal grade value. We save it and
# change state to STATUS_DONE
else:
self.given_grade = decimal.Decimal(value)
if self.final_grade is None:
self.final_grade = self.given_grade
self.status = self.STATUS_DONE
# Commit results
if commit and self.pk:
self.save(update_fields=[
'status', 'feedback_data', 'given_grade', 'final_grade'
])
elif commit:
self.save()
# If STATUS_DONE, we submit the submission_graded signal.
if self.status == self.STATUS_DONE:
self.stars = self.given_stars()
self.points = self.given_points()
self.response.register_submission(self)
if not silent:
submission_graded_signal.send(
Submission,
submission=self,
given_grade=self.given_grade,
automatic=True,
)
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
def manual_grade(self, grade, commit=True, raises=False, silent=False):
"""
Saves result of manual grading.
Args:
grade (number):
Given grade, as a percentage value.
commit:
If false, prevents saving the object when grading is complete.
The user must save the object manually after calling this
method.
raises:
If submission has already been graded, raises a GradingError.
silent:
Prevents the submission_graded_signal from triggering in the
end of a successful grading.
"""
if self.status != self.STATUS_PENDING and raises:
raise GradingError('Submission has already been graded!')
raise NotImplementedError('TODO')
def autograde_value(self):
"""
This method should be implemented in subclasses.
"""
raise ImproperlyConfigured(
'Response subclass %r must implement the autograde_value().'
'This method should perform the automatic grading and return the '
'resulting grade. Any additional relevant feedback data might be '
'saved to the `feedback_data` attribute, which is then is pickled '
'and saved into the database.' % type(self).__name__)
def regrade(self, method, commit=True):
"""
Recompute the grade for the given submission.
If status != 'done', it simply calls the .autograde() method. Otherwise,
it accept different strategies for updating to the new grades:
'update':
Recompute the grades and replace the old values with the new
ones. Only saves the submission if the feedback_data or the
given_grade attributes change.
'best':
Only update if the if the grade increase.
'worst':
Only update if the grades decrease.
'best-feedback':
Like 'best', but updates feedback_data even if the grades
change.
'worst-feedback':
Like 'worst', but updates feedback_data even if the grades
change.
Return a boolean telling if the regrading was necessary.
"""
if self.status != self.STATUS_DONE:
return self.autograde()
# We keep a copy of the state, if necessary. We only have to take some
# action if the state changes.
def rollback():
self.__dict__.clear()
self.__dict__.update(state)
state = self.__dict__.copy()
self.autograde(force=True, commit=False)
# Each method deals with the new state in a different manner
if method == 'update':
if state != self.__dict__:
if commit:
self.save()
return False
return True
elif method in ('best', 'best-feedback'):
if self.given_grade <= state.get('given_grade', 0):
new_feedback_data = self.feedback_data
rollback()
if new_feedback_data != self.feedback_data:
self.feedback_data = new_feedback_data
if commit:
self.save()
return True
return False
elif commit:
self.save()
return True
elif method in ('worst', 'worst-feedback'):
if self.given_grade >= state.get('given_grade', 0):
new_feedback_data = self.feedback_data
rollback()
if new_feedback_data != self.feedback_data:
self.feedback_data = new_feedback_data
if commit:
self.save()
return True
return False
elif commit:
self.save()
return True
else:
rollback()
raise ValueError('invalid method: %s' % method)
class UserScore(ScoreHandler):
"""
Base class for all accumulated resources.
"""
class Meta:
unique_together = [('user', 'page')]
used_stars = models.DecimalField(default=0.0,
decimal_places=1,
max_digits=5)
user = models.ForeignKey(models.User, related_name='+')
@property
def available_stars(self):
return self.stars - self.used_stars
@available_stars.setter
def available_stars(self, value):
self.used_stars = self.stars - value
@classmethod
def load(cls, user, page):
"""
Return UserScore object for the given user/page.
"""
score, created = cls.objects.get_or_create(user=user, page=page)
return score
@classmethod
def update(cls, user, page, diff=False, **kwargs):
"""
Updates the accumulated resources of the given user/page pair.
Accept the same keyword arguments as the .set_values() method.
"""
score = cls.load(user, page)
if diff:
score.set_diff(**kwargs)
else:
score.set_values(**kwargs)
@classmethod
def total_score(cls, user):
"""
Return the total score for the given user.
This is equivalent to the score associated with wagtail's root page.
"""
return cls.objects.get_or_create(user=user, page=cls._wagtail_root)[0]
@classmethod
def leaderboard(cls, page):
"""
Return a (points_counter, starts_counter) pair of Counter() objects
representing a leaderboard for the given page.
"""
stars_counter, points_counter = Counter(), Counter()
values = cls.objects\
.filter(page=page)\
.select_related('user')\
.values_list('user', 'stars', 'points')
for user, stars, points in values:
points_counter[user] += points
stars_counter[user] += stars
return points_counter, stars_counter
def get_parent(self):
parent_page = self.page.get_parent()
if parent_page is None:
return None
return self.__class__.objects.get_or_create(user=self.user,
page=parent_page)[0]
def get_children(self):
children_pages = self.page.get_children()
return [self.load(self.user, page) for page in children_pages]
class Progress(models.CopyMixin, models.StatusModel, models.TimeStampedModel,
models.PolymorphicModel):
"""
When an user starts an activity it opens a Progress object which control
all submissions to the given activity.
The Progress object also manages individual submissions that may span
several http requests.
"""
class Meta:
unique_together = [('user', 'activity_page')]
verbose_name = _('student progress')
verbose_name_plural = _('student progress list')
STATUS_OPENED = 'opened'
STATUS_CLOSED = 'closed'
STATUS_INCOMPLETE = 'incomplete'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_OPENED, _('opened')),
(STATUS_CLOSED, _('closed')),
)
user = models.ForeignKey(models.User, on_delete=models.CASCADE)
activity_page = models.ForeignKey(models.Page, on_delete=models.CASCADE)
final_grade_pc = models.DecimalField(
_('final score'),
max_digits=6,
decimal_places=3,
default=Decimal,
help_text=_(
'Final grade given to considering all submissions, penalties, etc.'
),
)
given_grade_pc = models.DecimalField(
_('grade'),
max_digits=6,
decimal_places=3,
default=Decimal,
help_text=_('Final grade before applying any modifier.'),
)
finished = models.DateTimeField(blank=True, null=True)
best_submission = models.ForeignKey('Submission',
blank=True,
null=True,
related_name='+')
points = models.IntegerField(default=0)
score = models.IntegerField(default=0)
stars = models.FloatField(default=0.0)
is_correct = models.BooleanField(default=bool)
has_submissions = models.BooleanField(default=bool)
has_feedback = models.BooleanField(default=bool)
has_post_tests = models.BooleanField(default=bool)
objects = ProgressManager()
#: The number of submissions
num_submissions = property(lambda x: x.submissions.count())
#: Specific activity reference
activity = property(lambda x: x.activity_page.specific)
activity_id = property(lambda x: x.activity_page_id)
#: Has progress mixin interface
username = property(lambda x: x.user.username)
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self)
def __str__(self):
tries = self.num_submissions
user = self.user
activity = self.activity
grade = '%s pts' % (self.final_grade_pc or 0)
fmt = '%s by %s (%s, %s tries)'
return fmt % (activity, user, grade, tries)
def __hash__(self):
return hash(self.id)
def __eq__(self, other):
if isinstance(other, Progress):
if self.pk is None:
return False
else:
return self.pk == other.pk
return NotImplemented
def submit(self, request, recycle=True, **kwargs):
"""
Creates new submission.
"""
submission_class = self.activity.submission_class
submission = submission_class(progress=self, **kwargs)
submission.ip_address = get_ip(request)
if not recycle:
submission.save()
return submission
# Collect all submissions with the same hash as current one
recyclable = submission_class.objects\
.filter(progress=self, hash=submission.compute_hash()) \
.order_by('created')
# Then check if any submission is actually equal to the current amongst
# all candidates
for possibly_equal in recyclable:
if submission.is_equal(possibly_equal):
possibly_equal.recycled = True
possibly_equal.bump_recycles()
return possibly_equal
else:
submission.save()
return submission
def register_feedback(self, feedback):
"""
This method is called after a submission is graded and produces a
feedback.
"""
submission = feedback.submission
self.update_grades_from_feedback(feedback)
if not self.activity.has_submissions:
print('first submission')
if feedback.is_correct:
print('first correct submission')
def update_grades_from_feedback(self, feedback):
"""
Update grades from the current progress object from the given feedback.
"""
# Update grades
if self.given_grade_pc < (feedback.given_grade_pc or 0):
self.given_grade_pc = feedback.given_grade_pc
# TODO: decide better update strategy
if self.final_grade_pc < feedback.final_grade_pc:
self.final_grade_pc = feedback.final_grade_pc
# # Register points and stars associated with submission.
# score_kwargs = {}
# final_points = feedback.final_points()
# final_stars = feedback.final_stars()
# if final_points > self.points:
# score_kwargs['points'] = final_points - self.points
# self.points = final_points
# if final_stars > self.stars:
# score_kwargs['stars'] = final_stars - self.stars
# self.stars = final_stars
#
# # If some score has changed, we save the update fields and update the
# # corresponding UserScore object
# if score_kwargs:
# from codeschool.gamification.models import UserScore
# self.save(update_fields=score_kwargs.keys())
# score_kwargs['diff'] = True
# UserScore.update(self.user, self.activity_page, **score_kwargs)
# Update the is_correct field
self.is_correct = self.is_correct or feedback.is_correct
self.save()
def update_from_submissions(self,
grades=True,
score=True,
commit=True,
refresh=False):
"""
Update grades and gamification scores for all submissions.
Args:
grades, score (bool):
choose to update final grades and/or final scores.
commit:
if True (default), save changes to database.
refresh:
if True (default), recompute grade from scratch.
"""
submissions = self.submissions.all()
if refresh and submissions.count():
first = submissions.first()
if grades:
self.final_grade_pc = first.given_grade_pc
self.given_grade_pc = first.given_grade_pc
if score:
self.points = first.points
self.stars = first.stars
self.score = first.score
for submission in submissions:
if grades:
submission.update_response_grades(commit=False)
if score:
submission.update_response_score(commit=False)
if commit:
self.save()
def regrade(self, method=None, force_update=False):
"""
Return the final grade for the user using the given method.
If not method is given, it uses the default grading method for the
activity.
"""
activity = self.activity
# Choose grading method
if method is None and self.final_grade_pc is not None:
return self.final_grade_pc
elif method is None:
grading_method = activity.grading_method
else:
grading_method = GradingMethod.from_name(activity.owner, method)
# Grade response. We save the result to the final_grade_pc attribute if
# no explicit grading method is given.
grade = grading_method.grade(self)
if method is None and (force_update or self.final_grade_pc is None):
self.final_grade_pc = grade
return grade
class Response(models.CopyMixin,
models.TimeStampedModel,
models.PolymorphicModel,
models.ClusterableModel):
"""
Gather individual responses.
"""
class Meta:
unique_together = [('user', 'activity', 'context')]
verbose_name = _('final response')
verbose_name_plural = _('final responses')
__updated = False
context = models.ForeignKey(
'cs_core.ResponseContext',
)
activity = models.ForeignKey(
'wagtailcore.Page',
related_name='responses',
on_delete=models.CASCADE,
)
user = models.ForeignKey(
models.User,
related_name='responses',
)
final_grade = models.DecimalField(
_('Final grade'),
help_text=_(
'Final grade given to activity considering all responses, '
'penalties, etc.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
default=0,
)
@property
def num_attempts(self):
"""
The number of attempts made to solve the question.
"""
return self.items.count()
@classmethod
def from_db(cls, *args, **kwargs):
obj = super().from_db(*args, **kwargs)
obj.activity = obj.activity.specific
obj.update()
return obj
@classmethod
def get_response(cls, user, activity, context=None):
"""
Return the response object associated with the given
user/activity/context.
Create a new response object if it does not exist.
"""
if user is None or activity is None:
raise TypeError(
'Response objects must be bound to an user or activity.'
)
response, create = Response.objects.get_or_create(
user=user, activity=activity, context=context
)
return response
def __str__(self):
tries = self.num_attempts
user = self.user
activity = self.activity
grade = '%s pts' % (self.final_grade or 0)
fmt = '<Response: %s by %s (%s, %s tries)>'
return fmt % (activity, user, grade, tries)
def update(self, force=False):
"""
Synchronize object so its state accounts for the latest responses.
"""
if not self.__updated or self.final_grade is None or force:
# We check if any response_item was updated after the main response
# object. If so, we recompute the grades using the maximum grade
# criterium
# TODO: in the future we should use grading_mehod
changed_items = self.items.filter(modified__gte=self.modified)
if changed_items or True:
grades = self.items.values_list('final_grade', flat=True)
self.final_grade = max(grades, default=self.final_grade or 0)
self.save(update_fields=['final_grade'])
elif self.final_grade is None:
self.final_grade = 0.0
self.save(update_fields=['final_grade'])
self.__updated = True
def clean(self):
if not isinstance(self.activity, Activity):
raise ValidationError({'activity': _('Not an activity.')})
if self.context is None:
self.context = getattr(self.activity, 'default_context')
def grade(self, method=None, force_update=False):
"""
Return the final grade for the user using the given method.
If not method is given, it uses the default grading method for the
activity.
"""
activity = self.activity
# Choose grading method
if method is None and self.final_grade is not None:
return self.final_grade
elif method is None:
grading_method = activity.grading_method
else:
grading_method = GradingMethod.from_name(activity.owner, method)
# Grade response. We save the result to the final_grade attribute if
# no explicit grading method is given.
grade = grading_method.grade(self)
if method is None and (force_update or self.final_grade is None):
self.final_grade = grade
return grade
class ResponseItem(models.CopyMixin,
models.TimeStampedStatusModel,
models.PolymorphicModel):
"""
Represents a student's response to some activity.
Response objects have 4 different states:
pending:
The response has been sent, but was not graded. Grading can be manual or
automatic, depending on the activity.
waiting:
Waiting for manual feedback.
incomplete:
For long-term activities, this tells that the student started a response
and is completing it gradually, but the final response was not achieved
yet.
invalid:
The response has been sent, but contains malformed data.
done:
The response was graded and evaluated and it initialized a feedback
object.
A response always starts at pending status. We can request it to be graded
by calling the :func:`Response.autograde` method. This method must raise
an InvalidResponseError if the response is invalid or ManualGradingError if
the response subclass does not implement automatic grading.
"""
class Meta:
verbose_name = _('response')
verbose_name_plural = _('responses')
STATUS_PENDING = 'pending'
STATUS_INCOMPLETE = 'incomplete'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_PENDING, _('pending')),
(STATUS_INCOMPLETE, _('incomplete')),
(STATUS_WAITING, _('waiting')),
(STATUS_INVALID, _('invalid')),
(STATUS_DONE, _('done')),
)
response = models.ParentalKey(
'Response',
verbose_name=_('response'),
related_name='items',
)
feedback_data = models.JSONField(
null=True,
blank=True,
)
response_data = models.JSONField(
null=True,
blank=True,
)
response_hash = models.CharField(
max_length=32,
blank=True,
)
given_grade = models.DecimalField(
_('Percentage of maximum grade'),
help_text=_(
'This grade is given by the auto-grader and represents the grade '
'for the response before accounting for any bonuses or penalties.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
final_grade = models.DecimalField(
_('Final grade'),
help_text=_(
'Similar to given_grade, but can account for additional factors '
'such as delay penalties or for any other reason the teacher may '
'want to override the student\'s grade.'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
)
manual_override = models.BooleanField(
default=False
)
# Status properties
is_done = property(lambda x: x.status == x.STATUS_DONE)
is_pending = property(lambda x: x.status == x.STATUS_PENDING)
is_waiting = property(lambda x: x.status == x.STATUS_WAITING)
is_invalid = property(lambda x: x.status == x.STATUS_INVALID)
# Delegate properties
activity = property(lambda x: x.response.activity.specific)
user = property(lambda x: x.response.user)
context = property(lambda x: x.response.context)
course = property(lambda x: x.activity.course)
def __init__(self, *args, **kwargs):
# Django is loading object from the database -- we step out the way
if args and not kwargs:
super().__init__(*args, **kwargs)
return
# We create the response_data and feedback_data manually always using
# copies of passed dicts. We save these variables here, init object and
# then copy this data to the initialized dictionaries
response_data = kwargs.pop('response_data', None) or {}
feedback_data = kwargs.pop('feedback_data', None) or {}
# This part makes a ResponseItem instance initialize from a user +
# activity + context instead of requiring a response object. The
# response is automatically created on demand.
user = kwargs.pop('user', None)
if user:
context = kwargs.pop('context', None)
try:
activity = kwargs.pop('activity')
except KeyError:
raise TypeError(
'ReponseItem objects bound to a user must also provide an '
'activity parameter.'
)
# User-bound constructor tries to obtain the Response object by
# searching for an specific (user, context, activity) tuple.
response, created = Response.objects.get_or_create(
user=user,
context=context,
activity=activity
)
kwargs['response'] = response
if 'context' in kwargs or 'activity' in kwargs:
raise TypeError(
'Must provide an user to instantiate a bound response item.'
)
super().__init__(*args, **kwargs)
# Now that we have initialized the response item, we fill the data
# passed in the response_data and feedback_data dictionaries.
self.response_data = dict(self.response_data or {}, **response_data)
self.feedback_data = dict(self.response_data or {}, **feedback_data)
def __str__(self):
if self.given_grade is None:
grade = self.status
else:
grade = '%s pts' % self.final_grade
user = self.user
activity = self.activity
return '<ResponseItem: %s by %s (%s)>' % (activity, user, grade)
def save(self, *args, **kwargs):
if not self.response_hash:
self.response_hash = self.get_response_hash(self.response_hash)
super().save(*args, **kwargs)
def get_feedback_data(self, commit=True):
"""Return the feedback object associated to the given response.
This method may trigger the autograde() method, if grading was not
performed yet. If you want to defer database access, call it with
commit=False to prevent saving any modifications to the response object
to the database.
"""
if self.status == self.STATUS_PENDING:
self.autograde(commit)
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
elif self.status == self.STATUS_WAITING:
return None
return self.feedback_data
def autograde(self, commit=True, force=False, silent=False):
"""
Performs automatic grading.
Response subclasses must implement the autograde_compute() method in
order to make automatic grading work. This method may write any
relevant information to the `feedback_data` attribute and must return
a numeric value from 0 to 100 with the given automatic grade.
Args:
commit:
If false, prevents saving the object when grading is complete.
The user must save the object manually after calling this
method.
force:
If true, force regrading the item even if it has already been
graded.
silent:
Prevents the autograde_signal from triggering in the end of
a successful autograde.
"""
if self.status == self.STATUS_PENDING or force:
try:
value = self.autograde_compute()
except self.InvalidResponseError as ex:
self.status = self.STATUS_INVALID
self.feedback_data = ex
self.given_grade = self.final_grade = decimal.Decimal(0)
if commit:
self.save()
raise
if value is None:
self.status = self.STATUS_WAITING
else:
self.given_grade = decimal.Decimal(value)
if self.final_grade is None:
self.final_grade = self.given_grade
self.status = self.STATUS_DONE
if not silent:
autograde_signal.send(
self.__class__,
response_item=self,
given_grade=self.given_grade
)
if commit and self.pk:
self.save(update_fields=['status', 'feedback_data',
'given_grade', 'final_grade'])
elif commit:
self.save()
elif self.status == self.STATUS_INVALID:
raise self.feedback_data
def autograde_compute(self):
"""This method should be implemented in subclasses."""
raise ImproperlyConfigured(
'Response subclass %r must implement the autograde_compute().'
'This method should perform the automatic grading and return the '
'resulting grade. Any additional relevant feedback data might be '
'saved to the `feedback_data` attribute, which is then is pickled '
'and saved into the database.' % type(self).__name__
)
def regrade(self, method, commit=True):
"""
Recompute the grade for the given response item.
If status != 'done', it simply calls the .autograde() method. Otherwise,
it accept different strategies for updating to the new grades:
'update':
Recompute the grades and replace the old values with the new
ones. Only saves the response item if the feedback_data or the
given_grade attributes change.
'best':
Only update if the if the grade increase.
'worst':
Only update if the grades decrease.
'best-feedback':
Like 'best', but updates feedback_data even if the grades
change.
'worst-feedback':
Like 'worst', but updates feedback_data even if the grades
change.
Return a boolean telling if the regrading was necessary.
"""
if self.status != self.STATUS_DONE:
return self.autograde()
# We keep a copy of the state, if necessary. We only have to take some
# action if the state changes.
def rollback():
self.__dict__.clear()
self.__dict__.update(state)
state = self.__dict__.copy()
self.autograde(force=True, commit=False)
# Each method deals with the new state in a different manner
if method == 'update':
if state != self.__dict__:
if commit:
self.save()
return False
return True
elif method in ('best', 'best-feedback'):
if self.given_grade <= state.get('given_grade', 0):
new_feedback_data = self.feedback_data
rollback()
if new_feedback_data != self.feedback_data:
self.feedback_data = new_feedback_data
if commit:
self.save()
return True
return False
elif commit:
self.save()
return True
elif method in ('worst', 'worst-feedback'):
if self.given_grade >= state.get('given_grade', 0):
new_feedback_data = self.feedback_data
rollback()
if new_feedback_data != self.feedback_data:
self.feedback_data = new_feedback_data
if commit:
self.save()
return True
return False
elif commit:
self.save()
return True
else:
rollback()
raise ValueError('invalid method: %s' % method)
@classmethod
def get_response_hash(cls, response_data):
"""
Computes a hash for the response_data attribute.
"""
if response_data:
data = json.dumps(response_data, default=json_default)
return md5hash(data)
return ''
# Feedback and visualization
ok_message = _('*Congratulations!* Your response is correct!')
ok_with_penalties = _('Your response is correct, but you did not achieved '
'the maximum grade.')
wrong_message = _('I\'m sorry, your response is wrong.')
partial_message = _('Your answer is partially correct: you achieved only '
'%(grade)d%% of the total grade.')
def html_feedback(self):
"""
A string of html source representing the feedback.
"""
if self.is_done:
data = {'grade': (self.final_grade or 0)}
if self.final_grade == 100:
return markdown(self.ok_message)
elif self.given_grade == 100:
return markdown(self.ok_with_penalties_message)
elif not self.given_grade:
return markdown(self.wrong_message)
else:
return markdown(self.partial_message % data)
else:
return markdown(_('Your response has not been graded yet!'))
# Permissions
def can_edit(self, user):
return False
def can_view(self, user):
return user == self.user
class ResponseContext(models.PolymorphicModel):
"""
Define a different context for a response object.
The context group responses into explicit groups and may also be used to
define additional constraints on the correct answers.
"""
class Meta:
unique_together = [('activity', 'name')]
# Basic
activity = models.ParentalKey(
'wagtailcore.Page',
related_name='contexts',
)
name = models.CharField(_('name'),
max_length=140,
blank=True,
help_text=_('A unique identifier.'))
description = models.RichTextField(
_('description'),
blank=True,
)
# Grading and submissions
grading_method = models.ForeignKey(
'cs_core.GradingMethod',
on_delete=models.SET_DEFAULT,
default=grading_method_best,
blank=True,
help_text=_('Choose the strategy for grading this activity.'))
single_submission = models.BooleanField(
_('single submission'),
default=False,
help_text=_(
'If set, students will be allowed to send only a single response.',
),
)
# Feedback
delayed_feedback = models.BooleanField(
_('delayed feedback'),
default=False,
help_text=_(
'If set, students will be only be able to see the feedback after '
'the activity expires its deadline.'))
# Deadlines
deadline = models.DateTimeField(
_('deadline'),
blank=True,
null=True,
)
hard_deadline = models.DateTimeField(
_('hard deadline'),
blank=True,
null=True,
help_text=_(
'If set, responses submitted after the deadline will be accepted '
'with a penalty.'))
delay_penalty = models.DecimalField(
_('delay penalty'),
default=25,
decimal_places=2,
max_digits=6,
help_text=_(
'Sets the percentage of the total grade that will be lost due to '
'delayed responses.'),
)
# Programming languages/formats
format = models.ForeignKey(
'cs_core.FileFormat',
blank=True,
null=True,
help_text=_(
'Defines the required file format or programming language for '
'student responses, when applicable.'))
# Extra constraints and resources
constraints = models.StreamField([], default=[])
resources = models.StreamField([], default=[])
def clean(self):
if not isinstance(self.activity, Activity):
return ValidationError({
'parent':
_('Parent is not an Activity subclass'),
})
super().clean()
class Response(models.CopyMixin, models.StatusModel, models.TimeStampedModel,
models.PolymorphicModel, models.ClusterableModel):
"""
When an user starts an activity it opens a Session object that controls
how responses to the given activity will be submitted.
The session object manages individual response submissions that may span
several http requests.
"""
class Meta:
unique_together = [('user', 'activity_page')]
verbose_name = _('final response')
verbose_name_plural = _('final responses')
STATUS_OPENED = 'opened'
STATUS_CLOSED = 'closed'
STATUS_INCOMPLETE = 'incomplete'
STATUS_WAITING = 'waiting'
STATUS_INVALID = 'invalid'
STATUS_DONE = 'done'
STATUS = models.Choices(
(STATUS_OPENED, _('opened')),
(STATUS_CLOSED, _('closed')),
)
user = models.ForeignKey(
models.User,
related_name='responses',
on_delete=models.CASCADE,
)
activity_page = models.ForeignKey(
models.Page,
related_name='responses',
on_delete=models.CASCADE,
)
grade = models.DecimalField(
_('given grade'),
max_digits=6,
decimal_places=3,
blank=True,
null=True,
default=0,
help_text=_(
'Grade given to response considering all submissions, penalties, '
'etc.'),
)
finish_time = models.DateTimeField(
blank=True,
null=True,
)
points = models.IntegerField(default=0)
score = models.IntegerField(default=0)
stars = models.FloatField(default=0.0)
is_finished = models.BooleanField(default=bool)
is_correct = models.BooleanField(default=bool)
objects = ResponseManager()
#: The number of submissions in the current session.
num_submissions = property(lambda x: x.submissions.count())
#: Specific activity reference
activity = property(lambda x: x.activity_page.specific)
activity_id = property(lambda x: x.activity_page_id)
@activity.setter
def activity(self, value):
self.activity_page = value.page_ptr
@classmethod
def _get_response(cls, user, activity):
"""
Return the response object associated with the given
user/activity.
Create a new response object if it does not exist.
"""
if user is None or activity is None:
raise TypeError(
'Response objects must be bound to an user or activity.')
response, create = Response.objects.get_or_create(user=user,
activity=activity)
return response
def __repr__(self):
tries = self.num_submissions
user = self.user
activity = self.activity
class_name = self.__class__.__name__
grade = '%s pts' % (self.grade or 0)
fmt = '<%s: %s by %s (%s, %s tries)>'
return fmt % (class_name, activity, user, grade, tries)
def __str__(self):
return repr(self)
def __hash__(self):
return hash(self.id)
def __eq__(self, other):
if isinstance(other, Response):
if self.pk is None:
return False
else:
return self.pk == other.pk
return NotImplemented
def register_submission(self, submission):
"""
This method is called when a submission is graded.
"""
assert submission.response_id == self.id
# Register points and stars associated with submission.
score_kwargs = {}
final_points = submission.final_points()
final_stars = submission.final_stars()
if final_points > self.points:
score_kwargs['points'] = final_points - self.points
self.points = final_points
if final_stars > self.stars:
score_kwargs['stars'] = final_stars - self.stars
self.stars = final_stars
# If some score has changed, we save the update fields and update the
# corresponding UserScore object
if score_kwargs:
from codeschool.lms.gamification.models import UserScore
self.save(update_fields=score_kwargs.keys())
score_kwargs['diff'] = True
UserScore.update(self.user, self.activity_page, **score_kwargs)
def regrade(self, method=None, force_update=False):
"""
Return the final grade for the user using the given method.
If not method is given, it uses the default grading method for the
activity.
"""
activity = self.activity
# Choose grading method
if method is None and self.final_grade is not None:
return self.final_grade
elif method is None:
grading_method = activity.grading_method
else:
grading_method = GradingMethod.from_name(activity.owner, method)
# Grade response. We save the result to the final_grade attribute if
# no explicit grading method is given.
grade = grading_method.grade(self)
if method is None and (force_update or self.final_grade is None):
self.final_grade = grade
return grade
