502 lines
20 KiB
Python
502 lines
20 KiB
Python
# Compute grades using real division, with no integer truncation
|
|
from __future__ import division
|
|
from collections import defaultdict
|
|
import random
|
|
import logging
|
|
|
|
from contextlib import contextmanager
|
|
from collections import defaultdict
|
|
from django.conf import settings
|
|
from django.contrib.auth.models import User
|
|
from django.db import transaction
|
|
from django.test.client import RequestFactory
|
|
|
|
from dogapi import dog_stats_api
|
|
|
|
from courseware import courses
|
|
from courseware.model_data import FieldDataCache
|
|
from xblock.fields import Scope
|
|
from xmodule import graders
|
|
from xmodule.capa_module import CapaModule
|
|
from xmodule.graders import Score
|
|
from .models import StudentModule
|
|
from .module_render import get_module, get_module_for_descriptor
|
|
|
|
log = logging.getLogger("mitx.courseware")
|
|
|
|
|
|
def yield_module_descendents(module):
|
|
stack = module.get_display_items()
|
|
stack.reverse()
|
|
|
|
while len(stack) > 0:
|
|
next_module = stack.pop()
|
|
stack.extend(next_module.get_display_items())
|
|
yield next_module
|
|
|
|
|
|
def yield_dynamic_descriptor_descendents(descriptor, module_creator):
|
|
"""
|
|
This returns all of the descendants of a descriptor. If the descriptor
|
|
has dynamic children, the module will be created using module_creator
|
|
and the children (as descriptors) of that module will be returned.
|
|
"""
|
|
def get_dynamic_descriptor_children(descriptor):
|
|
if descriptor.has_dynamic_children():
|
|
module = module_creator(descriptor)
|
|
if module is None:
|
|
return []
|
|
return module.get_child_descriptors()
|
|
else:
|
|
return descriptor.get_children()
|
|
|
|
stack = [descriptor]
|
|
|
|
while len(stack) > 0:
|
|
next_descriptor = stack.pop()
|
|
stack.extend(get_dynamic_descriptor_children(next_descriptor))
|
|
yield next_descriptor
|
|
|
|
|
|
def yield_problems(request, course, student):
|
|
"""
|
|
Return an iterator over capa_modules that this student has
|
|
potentially answered. (all that student has answered will definitely be in
|
|
the list, but there may be others as well).
|
|
"""
|
|
grading_context = course.grading_context
|
|
|
|
descriptor_locations = (descriptor.location.url() for descriptor in grading_context['all_descriptors'])
|
|
existing_student_modules = set(StudentModule.objects.filter(
|
|
module_state_key__in=descriptor_locations
|
|
).values_list('module_state_key', flat=True))
|
|
|
|
sections_to_list = []
|
|
for _, sections in grading_context['graded_sections'].iteritems():
|
|
for section in sections:
|
|
|
|
section_descriptor = section['section_descriptor']
|
|
|
|
# If the student hasn't seen a single problem in the section, skip it.
|
|
for moduledescriptor in section['xmoduledescriptors']:
|
|
if moduledescriptor.location.url() in existing_student_modules:
|
|
sections_to_list.append(section_descriptor)
|
|
break
|
|
|
|
field_data_cache = FieldDataCache(sections_to_list, course.id, student)
|
|
for section_descriptor in sections_to_list:
|
|
section_module = get_module(student, request,
|
|
section_descriptor.location, field_data_cache,
|
|
course.id)
|
|
if section_module is None:
|
|
# student doesn't have access to this module, or something else
|
|
# went wrong.
|
|
# log.debug("couldn't get module for student {0} for section location {1}"
|
|
# .format(student.username, section_descriptor.location))
|
|
continue
|
|
|
|
for problem in yield_module_descendents(section_module):
|
|
if isinstance(problem, CapaModule):
|
|
yield problem
|
|
|
|
|
|
def answer_distributions(request, course):
|
|
"""
|
|
Given a course_descriptor, compute frequencies of answers for each problem:
|
|
|
|
Format is:
|
|
|
|
dict: (problem url_name, problem display_name, problem_id) -> (dict : answer -> count)
|
|
|
|
TODO (vshnayder): this is currently doing a full linear pass through all
|
|
students and all problems. This will be just a little slow.
|
|
"""
|
|
|
|
counts = defaultdict(lambda: defaultdict(int))
|
|
|
|
enrolled_students = User.objects.filter(courseenrollment__course_id=course.id)
|
|
|
|
for student in enrolled_students:
|
|
for capa_module in yield_problems(request, course, student):
|
|
for problem_id in capa_module.lcp.student_answers:
|
|
# Answer can be a list or some other unhashable element. Convert to string.
|
|
answer = str(capa_module.lcp.student_answers[problem_id])
|
|
key = (capa_module.url_name, capa_module.display_name_with_default, problem_id)
|
|
counts[key][answer] += 1
|
|
|
|
return counts
|
|
|
|
|
|
@transaction.commit_manually
|
|
def grade(student, request, course, keep_raw_scores=False):
|
|
"""
|
|
Wraps "_grade" with the manual_transaction context manager just in case
|
|
there are unanticipated errors.
|
|
"""
|
|
with manual_transaction():
|
|
return _grade(student, request, course, keep_raw_scores)
|
|
|
|
|
|
def _grade(student, request, course, keep_raw_scores):
|
|
"""
|
|
Unwrapped version of "grade"
|
|
|
|
This grades a student as quickly as possible. It returns the
|
|
output from the course grader, augmented with the final letter
|
|
grade. The keys in the output are:
|
|
|
|
course: a CourseDescriptor
|
|
|
|
- grade : A final letter grade.
|
|
- percent : The final percent for the class (rounded up).
|
|
- section_breakdown : A breakdown of each section that makes
|
|
up the grade. (For display)
|
|
- grade_breakdown : A breakdown of the major components that
|
|
make up the final grade. (For display)
|
|
- keep_raw_scores : if True, then value for key 'raw_scores' contains scores
|
|
for every graded module
|
|
|
|
More information on the format is in the docstring for CourseGrader.
|
|
"""
|
|
grading_context = course.grading_context
|
|
raw_scores = []
|
|
|
|
totaled_scores = {}
|
|
# This next complicated loop is just to collect the totaled_scores, which is
|
|
# passed to the grader
|
|
for section_format, sections in grading_context['graded_sections'].iteritems():
|
|
format_scores = []
|
|
for section in sections:
|
|
section_descriptor = section['section_descriptor']
|
|
section_name = section_descriptor.display_name_with_default
|
|
|
|
# some problems have state that is updated independently of interaction
|
|
# with the LMS, so they need to always be scored. (E.g. foldit.,
|
|
# combinedopenended)
|
|
should_grade_section = any(
|
|
descriptor.always_recalculate_grades for descriptor in section['xmoduledescriptors']
|
|
)
|
|
|
|
# If we haven't seen a single problem in the section, we don't have to grade it at all! We can assume 0%
|
|
if not should_grade_section:
|
|
with manual_transaction():
|
|
should_grade_section = StudentModule.objects.filter(
|
|
student=student,
|
|
module_state_key__in=[
|
|
descriptor.location for descriptor in section['xmoduledescriptors']
|
|
]
|
|
).exists()
|
|
|
|
if should_grade_section:
|
|
scores = []
|
|
|
|
def create_module(descriptor):
|
|
'''creates an XModule instance given a descriptor'''
|
|
# TODO: We need the request to pass into here. If we could forego that, our arguments
|
|
# would be simpler
|
|
with manual_transaction():
|
|
field_data_cache = FieldDataCache([descriptor], course.id, student)
|
|
return get_module_for_descriptor(student, request, descriptor, field_data_cache, course.id)
|
|
|
|
for module_descriptor in yield_dynamic_descriptor_descendents(section_descriptor, create_module):
|
|
|
|
(correct, total) = get_score(course.id, student, module_descriptor, create_module)
|
|
if correct is None and total is None:
|
|
continue
|
|
|
|
if settings.GENERATE_PROFILE_SCORES: # for debugging!
|
|
if total > 1:
|
|
correct = random.randrange(max(total - 2, 1), total + 1)
|
|
else:
|
|
correct = total
|
|
|
|
graded = module_descriptor.graded
|
|
if not total > 0:
|
|
#We simply cannot grade a problem that is 12/0, because we might need it as a percentage
|
|
graded = False
|
|
|
|
scores.append(Score(correct, total, graded, module_descriptor.display_name_with_default))
|
|
|
|
_, graded_total = graders.aggregate_scores(scores, section_name)
|
|
if keep_raw_scores:
|
|
raw_scores += scores
|
|
else:
|
|
graded_total = Score(0.0, 1.0, True, section_name)
|
|
|
|
#Add the graded total to totaled_scores
|
|
if graded_total.possible > 0:
|
|
format_scores.append(graded_total)
|
|
else:
|
|
log.exception("Unable to grade a section with a total possible score of zero. " +
|
|
str(section_descriptor.location))
|
|
|
|
totaled_scores[section_format] = format_scores
|
|
|
|
grade_summary = course.grader.grade(totaled_scores, generate_random_scores=settings.GENERATE_PROFILE_SCORES)
|
|
|
|
# We round the grade here, to make sure that the grade is an whole percentage and
|
|
# doesn't get displayed differently than it gets grades
|
|
grade_summary['percent'] = round(grade_summary['percent'] * 100 + 0.05) / 100
|
|
|
|
letter_grade = grade_for_percentage(course.grade_cutoffs, grade_summary['percent'])
|
|
grade_summary['grade'] = letter_grade
|
|
grade_summary['totaled_scores'] = totaled_scores # make this available, eg for instructor download & debugging
|
|
if keep_raw_scores:
|
|
grade_summary['raw_scores'] = raw_scores # way to get all RAW scores out to instructor
|
|
# so grader can be double-checked
|
|
return grade_summary
|
|
|
|
|
|
def grade_for_percentage(grade_cutoffs, percentage):
|
|
"""
|
|
Returns a letter grade as defined in grading_policy (e.g. 'A' 'B' 'C' for 6.002x) or None.
|
|
|
|
Arguments
|
|
- grade_cutoffs is a dictionary mapping a grade to the lowest
|
|
possible percentage to earn that grade.
|
|
- percentage is the final percent across all problems in a course
|
|
"""
|
|
|
|
letter_grade = None
|
|
|
|
# Possible grades, sorted in descending order of score
|
|
descending_grades = sorted(grade_cutoffs, key=lambda x: grade_cutoffs[x], reverse=True)
|
|
for possible_grade in descending_grades:
|
|
if percentage >= grade_cutoffs[possible_grade]:
|
|
letter_grade = possible_grade
|
|
break
|
|
|
|
return letter_grade
|
|
|
|
|
|
@transaction.commit_manually
|
|
def progress_summary(student, request, course):
|
|
"""
|
|
Wraps "_progress_summary" with the manual_transaction context manager just
|
|
in case there are unanticipated errors.
|
|
"""
|
|
with manual_transaction():
|
|
return _progress_summary(student, request, course)
|
|
|
|
|
|
# TODO: This method is not very good. It was written in the old course style and
|
|
# then converted over and performance is not good. Once the progress page is redesigned
|
|
# to not have the progress summary this method should be deleted (so it won't be copied).
|
|
def _progress_summary(student, request, course):
|
|
"""
|
|
Unwrapped version of "progress_summary".
|
|
|
|
This pulls a summary of all problems in the course.
|
|
|
|
Returns
|
|
- courseware_summary is a summary of all sections with problems in the course.
|
|
It is organized as an array of chapters, each containing an array of sections,
|
|
each containing an array of scores. This contains information for graded and
|
|
ungraded problems, and is good for displaying a course summary with due dates,
|
|
etc.
|
|
|
|
Arguments:
|
|
student: A User object for the student to grade
|
|
course: A Descriptor containing the course to grade
|
|
|
|
If the student does not have access to load the course module, this function
|
|
will return None.
|
|
|
|
"""
|
|
with manual_transaction():
|
|
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
|
|
course.id, student, course, depth=None
|
|
)
|
|
# TODO: We need the request to pass into here. If we could
|
|
# forego that, our arguments would be simpler
|
|
course_module = get_module_for_descriptor(student, request, course, field_data_cache, course.id)
|
|
if not course_module:
|
|
# This student must not have access to the course.
|
|
return None
|
|
|
|
chapters = []
|
|
# Don't include chapters that aren't displayable (e.g. due to error)
|
|
for chapter_module in course_module.get_display_items():
|
|
# Skip if the chapter is hidden
|
|
if chapter_module.hide_from_toc:
|
|
continue
|
|
|
|
sections = []
|
|
|
|
for section_module in chapter_module.get_display_items():
|
|
# Skip if the section is hidden
|
|
with manual_transaction():
|
|
if section_module.hide_from_toc:
|
|
continue
|
|
|
|
graded = section_module.graded
|
|
scores = []
|
|
|
|
module_creator = section_module.xmodule_runtime.get_module
|
|
|
|
for module_descriptor in yield_dynamic_descriptor_descendents(section_module, module_creator):
|
|
course_id = course.id
|
|
(correct, total) = get_score(course_id, student, module_descriptor, module_creator)
|
|
if correct is None and total is None:
|
|
continue
|
|
|
|
scores.append(Score(correct, total, graded, module_descriptor.display_name_with_default))
|
|
|
|
scores.reverse()
|
|
section_total, _ = graders.aggregate_scores(
|
|
scores, section_module.display_name_with_default)
|
|
|
|
module_format = section_module.format if section_module.format is not None else ''
|
|
sections.append({
|
|
'display_name': section_module.display_name_with_default,
|
|
'url_name': section_module.url_name,
|
|
'scores': scores,
|
|
'section_total': section_total,
|
|
'format': module_format,
|
|
'due': section_module.due,
|
|
'graded': graded,
|
|
})
|
|
|
|
chapters.append({
|
|
'course': course.display_name_with_default,
|
|
'display_name': chapter_module.display_name_with_default,
|
|
'url_name': chapter_module.url_name,
|
|
'sections': sections
|
|
})
|
|
|
|
return chapters
|
|
|
|
def get_score(course_id, user, problem_descriptor, module_creator):
|
|
"""
|
|
Return the score for a user on a problem, as a tuple (correct, total).
|
|
e.g. (5,7) if you got 5 out of 7 points.
|
|
|
|
If this problem doesn't have a score, or we couldn't load it, returns (None,
|
|
None).
|
|
|
|
user: a Student object
|
|
problem_descriptor: an XModuleDescriptor
|
|
module_creator: a function that takes a descriptor, and returns the corresponding XModule for this user.
|
|
Can return None if user doesn't have access, or if something else went wrong.
|
|
cache: A FieldDataCache
|
|
"""
|
|
if not user.is_authenticated():
|
|
return (None, None)
|
|
|
|
# some problems have state that is updated independently of interaction
|
|
# with the LMS, so they need to always be scored. (E.g. foldit.)
|
|
if problem_descriptor.always_recalculate_grades:
|
|
problem = module_creator(problem_descriptor)
|
|
if problem is None:
|
|
return (None, None)
|
|
score = problem.get_score()
|
|
if score is not None:
|
|
return (score['score'], score['total'])
|
|
else:
|
|
return (None, None)
|
|
|
|
if not problem_descriptor.has_score:
|
|
# These are not problems, and do not have a score
|
|
return (None, None)
|
|
|
|
try:
|
|
student_module = StudentModule.objects.get(
|
|
student=user,
|
|
course_id=course_id,
|
|
module_state_key=problem_descriptor.location
|
|
)
|
|
except StudentModule.DoesNotExist:
|
|
student_module = None
|
|
|
|
if student_module is not None and student_module.max_grade is not None:
|
|
correct = student_module.grade if student_module.grade is not None else 0
|
|
total = student_module.max_grade
|
|
else:
|
|
# If the problem was not in the cache, or hasn't been graded yet,
|
|
# we need to instantiate the problem.
|
|
# Otherwise, the max score (cached in student_module) won't be available
|
|
problem = module_creator(problem_descriptor)
|
|
if problem is None:
|
|
return (None, None)
|
|
|
|
correct = 0.0
|
|
total = problem.max_score()
|
|
|
|
# Problem may be an error module (if something in the problem builder failed)
|
|
# In which case total might be None
|
|
if total is None:
|
|
return (None, None)
|
|
|
|
# Now we re-weight the problem, if specified
|
|
weight = problem_descriptor.weight
|
|
if weight is not None:
|
|
if total == 0:
|
|
log.exception("Cannot reweight a problem with zero total points. Problem: " + str(student_module))
|
|
return (correct, total)
|
|
correct = correct * weight / total
|
|
total = weight
|
|
|
|
return (correct, total)
|
|
|
|
|
|
@contextmanager
|
|
def manual_transaction():
|
|
"""A context manager for managing manual transactions"""
|
|
try:
|
|
yield
|
|
except Exception:
|
|
transaction.rollback()
|
|
log.exception('Due to an error, this transaction has been rolled back')
|
|
raise
|
|
else:
|
|
transaction.commit()
|
|
|
|
|
|
def iterate_grades_for(course_id, students):
|
|
"""Given a course_id and an iterable of students (User), yield a tuple of:
|
|
|
|
(student, gradeset, err_msg) for every student enrolled in the course.
|
|
|
|
If an error occured, gradeset will be an empty dict and err_msg will be an
|
|
exception message. If there was no error, err_msg is an empty string.
|
|
|
|
The gradeset is a dictionary with the following fields:
|
|
|
|
- grade : A final letter grade.
|
|
- percent : The final percent for the class (rounded up).
|
|
- section_breakdown : A breakdown of each section that makes
|
|
up the grade. (For display)
|
|
- grade_breakdown : A breakdown of the major components that
|
|
make up the final grade. (For display)
|
|
- raw_scores: contains scores for every graded module
|
|
"""
|
|
course = courses.get_course_by_id(course_id)
|
|
|
|
# We make a fake request because grading code expects to be able to look at
|
|
# the request. We have to attach the correct user to the request before
|
|
# grading that student.
|
|
request = RequestFactory().get('/')
|
|
|
|
for student in students:
|
|
with dog_stats_api.timer('lms.grades.iterate_grades_for', tags=['action:{}'.format(course_id)]):
|
|
try:
|
|
request.user = student
|
|
# Grading calls problem rendering, which calls masquerading,
|
|
# which checks session vars -- thus the empty session dict below.
|
|
# It's not pretty, but untangling that is currently beyond the
|
|
# scope of this feature.
|
|
request.session = {}
|
|
gradeset = grade(student, request, course)
|
|
yield student, gradeset, ""
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
# Keep marching on even if this student couldn't be graded for
|
|
# some reason, but log it for future reference.
|
|
log.exception(
|
|
'Cannot grade student %s (%s) in course %s because of exception: %s',
|
|
student.username,
|
|
student.id,
|
|
course_id,
|
|
exc.message
|
|
)
|
|
yield student, {}, exc.message
|