Skip to content

E
edx-platform
Commit ac2f71df by Eric Fischer
Options

Revert "Merge pull request #13547 from edx/beryl/correct_weight" 

This reverts commit 663fbbba, reversing
changes made to 3f7441c8.
parent ca287c73
Showing with 265 additions and 858 deletions
common/lib/xmodule/xmodule/graders.py
...@@ -10,67 +10,13 @@ import logging ...@@ -10,67 +10,13 @@ import logging
import random import random
import sys import sys
from collections import namedtuple
log = logging.getLogger("edx.courseware") log = logging.getLogger("edx.courseware")
# This is a tuple for holding scores, either from problems or sections.
class ScoreBase(object): # Section either indicates the name of the problem or the name of the section
""" Score = namedtuple("Score", "earned possible graded section module_id")
Abstract base class for encapsulating fields of values scores.
Field common to all scores include:
display_name (string) - the display name of the module
module_id (UsageKey) - the location of the module
graded (boolean) - whether or not this module is graded
"""
__metaclass__ = abc.ABCMeta
def __init__(self, graded, display_name, module_id):
self.graded = graded
self.display_name = display_name
self.module_id = module_id
def __eq__(self, other):
if type(other) is type(self):
return self.__dict__ == other.__dict__
return False
def __ne__(self, other):
return not self.__eq__(other)
def __repr__(self):
return u"{class_name}({fields})".format(class_name=self.__class__.__name__, fields=self.__dict__)
class ProblemScore(ScoreBase):
"""
Encapsulates the fields of a Problem's score.
In addition to the fields in ScoreBase, also includes:
raw_earned (float) - raw points earned on this problem
raw_possible (float) - raw points possible to earn on this problem
weighted_earned = earned (float) - weighted value of the points earned
weighted_possible = possible (float) - weighted possible points on this problem
weight (float) - weight of this problem
"""
def __init__(self, raw_earned, raw_possible, weighted_earned, weighted_possible, weight, *args, **kwargs):
super(ProblemScore, self).__init__(*args, **kwargs)
self.raw_earned = raw_earned
self.raw_possible = raw_possible
self.earned = weighted_earned
self.possible = weighted_possible
self.weight = weight
class AggregatedScore(ScoreBase):
"""
Encapsulates the fields of a Subsection's score.
In addition to the fields in ScoreBase, also includes:
tw_earned = earned - total aggregated sum of all weighted earned values
tw_possible = possible - total aggregated sum of all weighted possible values
"""
def __init__(self, tw_earned, tw_possible, *args, **kwargs):
super(AggregatedScore, self).__init__(*args, **kwargs)
self.earned = tw_earned
self.possible = tw_possible
def float_sum(iterable): def float_sum(iterable):
...@@ -80,14 +26,13 @@ def float_sum(iterable): ...@@ -80,14 +26,13 @@ def float_sum(iterable):
return float(sum(iterable)) return float(sum(iterable))
def aggregate_scores(scores, display_name="summary", location=None): def aggregate_scores(scores, section_name="summary", location=None):
""" """
scores: A list of ScoreBase objects scores: A list of Score objects
display_name: The display name for the score object
location: The location under which all objects in scores are located location: The location under which all objects in scores are located
returns: A tuple (all_total, graded_total). returns: A tuple (all_total, graded_total).
all_total: A ScoreBase representing the total score summed over all input scores all_total: A Score representing the total score summed over all input scores
graded_total: A ScoreBase representing the score summed over all graded input scores graded_total: A Score representing the score summed over all graded input scores
""" """
total_correct_graded = float_sum(score.earned for score in scores if score.graded) total_correct_graded = float_sum(score.earned for score in scores if score.graded)
total_possible_graded = float_sum(score.possible for score in scores if score.graded) total_possible_graded = float_sum(score.possible for score in scores if score.graded)
...@@ -96,10 +41,10 @@ def aggregate_scores(scores, display_name="summary", location=None): ...@@ -96,10 +41,10 @@ def aggregate_scores(scores, display_name="summary", location=None):
total_possible = float_sum(score.possible for score in scores) total_possible = float_sum(score.possible for score in scores)
#regardless of whether it is graded #regardless of whether it is graded
all_total = AggregatedScore(total_correct, total_possible, False, display_name, location) all_total = Score(total_correct, total_possible, False, section_name, location)
#selecting only graded things #selecting only graded things
graded_total = AggregatedScore(total_correct_graded, total_possible_graded, True, display_name, location) graded_total = Score(total_correct_graded, total_possible_graded, True, section_name, location)
return all_total, graded_total return all_total, graded_total
...@@ -275,7 +220,7 @@ class SingleSectionGrader(CourseGrader): ...@@ -275,7 +220,7 @@ class SingleSectionGrader(CourseGrader):
found_score = None found_score = None
if self.type in grade_sheet: if self.type in grade_sheet:
for score in grade_sheet[self.type]: for score in grade_sheet[self.type]:
if score.display_name == self.name: if score.section == self.name:
found_score = score found_score = score
break break
...@@ -397,7 +342,7 @@ class AssignmentFormatGrader(CourseGrader): ...@@ -397,7 +342,7 @@ class AssignmentFormatGrader(CourseGrader):
else: else:
earned = scores[i].earned earned = scores[i].earned
possible = scores[i].possible possible = scores[i].possible
section_name = scores[i].display_name section_name = scores[i].section
percentage = earned / possible percentage = earned / possible
summary_format = u"{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})" summary_format = u"{section_type} {index} - {name} - {percent:.0%} ({earned:.3n}/{possible:.3n})"
......
common/lib/xmodule/xmodule/tests/test_graders.py
...@@ -2,67 +2,42 @@ ...@@ -2,67 +2,42 @@
import unittest import unittest
from xmodule import graders from xmodule import graders
from xmodule.graders import ProblemScore, AggregatedScore, aggregate_scores from xmodule.graders import Score, aggregate_scores
class GradesheetTest(unittest.TestCase): class GradesheetTest(unittest.TestCase):
""" '''Tests the aggregate_scores method'''
Tests the aggregate_scores method
"""
def test_weighted_grading(self): def test_weighted_grading(self):
scores = [] scores = []
agg_fields = dict(display_name="aggregated_score", module_id=None) Score.__sub__ = lambda me, other: (me.earned - other.earned) + (me.possible - other.possible)
prob_fields = dict(display_name="problem_score", module_id=None, raw_earned=0, raw_possible=0, weight=0)
all_total, graded_total = aggregate_scores(scores, display_name=agg_fields['display_name']) all_total, graded_total = aggregate_scores(scores)
self.assertEqual( self.assertEqual(all_total, Score(earned=0, possible=0, graded=False, section="summary", module_id=None))
all_total, self.assertEqual(graded_total, Score(earned=0, possible=0, graded=True, section="summary", module_id=None))
AggregatedScore(tw_earned=0, tw_possible=0, graded=False, **agg_fields),
)
self.assertEqual(
graded_total,
AggregatedScore(tw_earned=0, tw_possible=0, graded=True, **agg_fields),
)
scores.append(ProblemScore(weighted_earned=0, weighted_possible=5, graded=False, **prob_fields)) scores.append(Score(earned=0, possible=5, graded=False, section="summary", module_id=None))
all_total, graded_total = aggregate_scores(scores, display_name=agg_fields['display_name']) all_total, graded_total = aggregate_scores(scores)
self.assertEqual( self.assertEqual(all_total, Score(earned=0, possible=5, graded=False, section="summary", module_id=None))
all_total, self.assertEqual(graded_total, Score(earned=0, possible=0, graded=True, section="summary", module_id=None))
AggregatedScore(tw_earned=0, tw_possible=5, graded=False, **agg_fields),
)
self.assertEqual(
graded_total,
AggregatedScore(tw_earned=0, tw_possible=0, graded=True, **agg_fields),
)
scores.append(ProblemScore(weighted_earned=3, weighted_possible=5, graded=True, **prob_fields)) scores.append(Score(earned=3, possible=5, graded=True, section="summary", module_id=None))
all_total, graded_total = aggregate_scores(scores, display_name=agg_fields['display_name']) all_total, graded_total = aggregate_scores(scores)
self.assertAlmostEqual(all_total, Score(earned=3, possible=10, graded=False, section="summary", module_id=None))
self.assertAlmostEqual( self.assertAlmostEqual(
all_total, graded_total, Score(earned=3, possible=5, graded=True, section="summary", module_id=None)
AggregatedScore(tw_earned=3, tw_possible=10, graded=False, **agg_fields),
)
self.assertAlmostEqual(
graded_total,
AggregatedScore(tw_earned=3, tw_possible=5, graded=True, **agg_fields),
) )
scores.append(ProblemScore(weighted_earned=2, weighted_possible=5, graded=True, **prob_fields)) scores.append(Score(earned=2, possible=5, graded=True, section="summary", module_id=None))
all_total, graded_total = aggregate_scores(scores, display_name=agg_fields['display_name']) all_total, graded_total = aggregate_scores(scores)
self.assertAlmostEqual( self.assertAlmostEqual(all_total, Score(earned=5, possible=15, graded=False, section="summary", module_id=None))
all_total,
AggregatedScore(tw_earned=5, tw_possible=15, graded=False, **agg_fields),
)
self.assertAlmostEqual( self.assertAlmostEqual(
graded_total, graded_total, Score(earned=5, possible=10, graded=True, section="summary", module_id=None)
AggregatedScore(tw_earned=5, tw_possible=10, graded=True, **agg_fields),
) )
class GraderTest(unittest.TestCase): class GraderTest(unittest.TestCase):
""" '''Tests grader implementations'''
Tests grader implementations
"""
empty_gradesheet = { empty_gradesheet = {
} }
...@@ -74,25 +49,19 @@ class GraderTest(unittest.TestCase): ...@@ -74,25 +49,19 @@ class GraderTest(unittest.TestCase):
} }
test_gradesheet = { test_gradesheet = {
'Homework': [ 'Homework': [Score(earned=2, possible=20.0, graded=True, section='hw1', module_id=None),
AggregatedScore(tw_earned=2, tw_possible=20.0, graded=True, display_name='hw1', module_id=None), Score(earned=16, possible=16.0, graded=True, section='hw2', module_id=None)],
AggregatedScore(tw_earned=16, tw_possible=16.0, graded=True, display_name='hw2', module_id=None)
],
# The dropped scores should be from the assignments that don't exist yet # The dropped scores should be from the assignments that don't exist yet
'Lab': [
AggregatedScore(tw_earned=1, tw_possible=2.0, graded=True, display_name='lab1', module_id=None), # Dropped 'Lab': [Score(earned=1, possible=2.0, graded=True, section='lab1', module_id=None), # Dropped
AggregatedScore(tw_earned=1, tw_possible=1.0, graded=True, display_name='lab2', module_id=None), Score(earned=1, possible=1.0, graded=True, section='lab2', module_id=None),
AggregatedScore(tw_earned=1, tw_possible=1.0, graded=True, display_name='lab3', module_id=None), Score(earned=1, possible=1.0, graded=True, section='lab3', module_id=None),
AggregatedScore(tw_earned=5, tw_possible=25.0, graded=True, display_name='lab4', module_id=None), # Dropped Score(earned=5, possible=25.0, graded=True, section='lab4', module_id=None), # Dropped
AggregatedScore(tw_earned=3, tw_possible=4.0, graded=True, display_name='lab5', module_id=None), # Dropped Score(earned=3, possible=4.0, graded=True, section='lab5', module_id=None), # Dropped
AggregatedScore(tw_earned=6, tw_possible=7.0, graded=True, display_name='lab6', module_id=None), Score(earned=6, possible=7.0, graded=True, section='lab6', module_id=None),
AggregatedScore(tw_earned=5, tw_possible=6.0, graded=True, display_name='lab7', module_id=None), Score(earned=5, possible=6.0, graded=True, section='lab7', module_id=None)],
],
'Midterm': [Score(earned=50.5, possible=100, graded=True, section="Midterm Exam", module_id=None), ],
'Midterm': [
AggregatedScore(tw_earned=50.5, tw_possible=100, graded=True, display_name="Midterm Exam", module_id=None),
],
} }
def test_single_section_grader(self): def test_single_section_grader(self):
...@@ -100,11 +69,9 @@ class GraderTest(unittest.TestCase): ...@@ -100,11 +69,9 @@ class GraderTest(unittest.TestCase):
lab4_grader = graders.SingleSectionGrader("Lab", "lab4") lab4_grader = graders.SingleSectionGrader("Lab", "lab4")
bad_lab_grader = graders.SingleSectionGrader("Lab", "lab42") bad_lab_grader = graders.SingleSectionGrader("Lab", "lab42")
for graded in [ for graded in [midterm_grader.grade(self.empty_gradesheet),
midterm_grader.grade(self.empty_gradesheet), midterm_grader.grade(self.incomplete_gradesheet),
midterm_grader.grade(self.incomplete_gradesheet), bad_lab_grader.grade(self.test_gradesheet)]:
bad_lab_grader.grade(self.test_gradesheet),
]:
self.assertEqual(len(graded['section_breakdown']), 1) self.assertEqual(len(graded['section_breakdown']), 1)
self.assertEqual(graded['percent'], 0.0) self.assertEqual(graded['percent'], 0.0)
...@@ -124,12 +91,10 @@ class GraderTest(unittest.TestCase): ...@@ -124,12 +91,10 @@ class GraderTest(unittest.TestCase):
lab_grader = graders.AssignmentFormatGrader("Lab", 7, 3) lab_grader = graders.AssignmentFormatGrader("Lab", 7, 3)
# Test the grading of an empty gradesheet # Test the grading of an empty gradesheet
for graded in [ for graded in [homework_grader.grade(self.empty_gradesheet),
homework_grader.grade(self.empty_gradesheet), no_drop_grader.grade(self.empty_gradesheet),
no_drop_grader.grade(self.empty_gradesheet), homework_grader.grade(self.incomplete_gradesheet),
homework_grader.grade(self.incomplete_gradesheet), no_drop_grader.grade(self.incomplete_gradesheet)]:
no_drop_grader.grade(self.incomplete_gradesheet),
]:
self.assertAlmostEqual(graded['percent'], 0.0) self.assertAlmostEqual(graded['percent'], 0.0)
# Make sure the breakdown includes 12 sections, plus one summary # Make sure the breakdown includes 12 sections, plus one summary
self.assertEqual(len(graded['section_breakdown']), 12 + 1) self.assertEqual(len(graded['section_breakdown']), 12 + 1)
...@@ -153,10 +118,8 @@ class GraderTest(unittest.TestCase): ...@@ -153,10 +118,8 @@ class GraderTest(unittest.TestCase):
def test_assignment_format_grader_on_single_section_entry(self): def test_assignment_format_grader_on_single_section_entry(self):
midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0) midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0)
# Test the grading on a section with one item: # Test the grading on a section with one item:
for graded in [ for graded in [midterm_grader.grade(self.empty_gradesheet),
midterm_grader.grade(self.empty_gradesheet), midterm_grader.grade(self.incomplete_gradesheet)]:
midterm_grader.grade(self.incomplete_gradesheet),
]:
self.assertAlmostEqual(graded['percent'], 0.0) self.assertAlmostEqual(graded['percent'], 0.0)
# Make sure the breakdown includes just the one summary # Make sure the breakdown includes just the one summary
self.assertEqual(len(graded['section_breakdown']), 0 + 1) self.assertEqual(len(graded['section_breakdown']), 0 + 1)
...@@ -174,31 +137,23 @@ class GraderTest(unittest.TestCase): ...@@ -174,31 +137,23 @@ class GraderTest(unittest.TestCase):
# will act like SingleSectionGraders on single sections. # will act like SingleSectionGraders on single sections.
midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0) midterm_grader = graders.AssignmentFormatGrader("Midterm", 1, 0)
weighted_grader = graders.WeightedSubsectionsGrader([ weighted_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.25),
(homework_grader, homework_grader.category, 0.25), (lab_grader, lab_grader.category, 0.25),
(lab_grader, lab_grader.category, 0.25), (midterm_grader, midterm_grader.category, 0.5)])
(midterm_grader, midterm_grader.category, 0.5),
])
over_one_weights_grader = graders.WeightedSubsectionsGrader([ over_one_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.5),
(homework_grader, homework_grader.category, 0.5), (lab_grader, lab_grader.category, 0.5),
(lab_grader, lab_grader.category, 0.5), (midterm_grader, midterm_grader.category, 0.5)])
(midterm_grader, midterm_grader.category, 0.5),
])
# The midterm should have all weight on this one # The midterm should have all weight on this one
zero_weights_grader = graders.WeightedSubsectionsGrader([ zero_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.0),
(homework_grader, homework_grader.category, 0.0), (lab_grader, lab_grader.category, 0.0),
(lab_grader, lab_grader.category, 0.0), (midterm_grader, midterm_grader.category, 0.5)])
(midterm_grader, midterm_grader.category, 0.5),
])
# This should always have a final percent of zero # This should always have a final percent of zero
all_zero_weights_grader = graders.WeightedSubsectionsGrader([ all_zero_weights_grader = graders.WeightedSubsectionsGrader([(homework_grader, homework_grader.category, 0.0),
(homework_grader, homework_grader.category, 0.0), (lab_grader, lab_grader.category, 0.0),
(lab_grader, lab_grader.category, 0.0), (midterm_grader, midterm_grader.category, 0.0)])
(midterm_grader, midterm_grader.category, 0.0),
])
empty_grader = graders.WeightedSubsectionsGrader([]) empty_grader = graders.WeightedSubsectionsGrader([])
...@@ -222,12 +177,10 @@ class GraderTest(unittest.TestCase): ...@@ -222,12 +177,10 @@ class GraderTest(unittest.TestCase):
self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1) self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
self.assertEqual(len(graded['grade_breakdown']), 3) self.assertEqual(len(graded['grade_breakdown']), 3)
for graded in [ for graded in [weighted_grader.grade(self.empty_gradesheet),
weighted_grader.grade(self.empty_gradesheet), weighted_grader.grade(self.incomplete_gradesheet),
weighted_grader.grade(self.incomplete_gradesheet), zero_weights_grader.grade(self.empty_gradesheet),
zero_weights_grader.grade(self.empty_gradesheet), all_zero_weights_grader.grade(self.empty_gradesheet)]:
all_zero_weights_grader.grade(self.empty_gradesheet),
]:
self.assertAlmostEqual(graded['percent'], 0.0) self.assertAlmostEqual(graded['percent'], 0.0)
self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1) self.assertEqual(len(graded['section_breakdown']), (12 + 1) + (7 + 1) + 1)
self.assertEqual(len(graded['grade_breakdown']), 3) self.assertEqual(len(graded['grade_breakdown']), 3)
......
lms/djangoapps/gating/tests/test_api.py
...@@ -166,8 +166,8 @@ class TestGatedContent(GatingTestCase, MilestonesTestCaseMixin): ...@@ -166,8 +166,8 @@ class TestGatedContent(GatingTestCase, MilestonesTestCaseMixin):
""" """
course_grade = CourseGradeFactory(user).create(self.course) course_grade = CourseGradeFactory(user).create(self.course)
for prob in [self.gating_prob1, self.gated_prob2, self.prob3]: for prob in [self.gating_prob1, self.gated_prob2, self.prob3]:
self.assertIn(prob.location, course_grade.locations_to_scores) self.assertIn(prob.location, course_grade.locations_to_weighted_scores)
self.assertNotIn(self.orphan.location, course_grade.locations_to_scores) self.assertNotIn(self.orphan.location, course_grade.locations_to_weighted_scores)
self.assertEquals(course_grade.percent, expected_percent) self.assertEquals(course_grade.percent, expected_percent)
......
lms/djangoapps/grades/models.py
...@@ -27,7 +27,7 @@ BLOCK_RECORD_LIST_VERSION = 1 ...@@ -27,7 +27,7 @@ BLOCK_RECORD_LIST_VERSION = 1
# Used to serialize information about a block at the time it was used in # Used to serialize information about a block at the time it was used in
# grade calculation. # grade calculation.
BlockRecord = namedtuple('BlockRecord', ['locator', 'weight', 'raw_possible', 'graded']) BlockRecord = namedtuple('BlockRecord', ['locator', 'weight', 'max_score'])
class BlockRecordList(tuple): class BlockRecordList(tuple):
...@@ -98,8 +98,7 @@ class BlockRecordList(tuple): ...@@ -98,8 +98,7 @@ class BlockRecordList(tuple):
BlockRecord( BlockRecord(
locator=UsageKey.from_string(block["locator"]).replace(course_key=course_key), locator=UsageKey.from_string(block["locator"]).replace(course_key=course_key),
weight=block["weight"], weight=block["weight"],
raw_possible=block["raw_possible"], max_score=block["max_score"],
graded=block["graded"],
) )
for block in block_dicts for block in block_dicts
) )
......
lms/djangoapps/grades/new/course_grade.py
...@@ -43,15 +43,15 @@ class CourseGrade(object): ...@@ -43,15 +43,15 @@ class CourseGrade(object):
return subsections_by_format return subsections_by_format
@lazy @lazy
def locations_to_scores(self): def locations_to_weighted_scores(self):
""" """
Returns a dict of problem scores keyed by their locations. Returns a dict of problem scores keyed by their locations.
""" """
locations_to_scores = {} locations_to_weighted_scores = {}
for chapter in self.chapter_grades: for chapter in self.chapter_grades:
for subsection_grade in chapter['sections']: for subsection_grade in chapter['sections']:
locations_to_scores.update(subsection_grade.locations_to_scores) locations_to_weighted_scores.update(subsection_grade.locations_to_weighted_scores)
return locations_to_scores return locations_to_weighted_scores
@lazy @lazy
def grade_value(self): def grade_value(self):
...@@ -113,7 +113,7 @@ class CourseGrade(object): ...@@ -113,7 +113,7 @@ class CourseGrade(object):
grade_summary['percent'] = self.percent grade_summary['percent'] = self.percent
grade_summary['grade'] = self.letter_grade grade_summary['grade'] = self.letter_grade
grade_summary['totaled_scores'] = self.subsection_grade_totals_by_format grade_summary['totaled_scores'] = self.subsection_grade_totals_by_format
grade_summary['raw_scores'] = list(self.locations_to_scores.itervalues()) grade_summary['raw_scores'] = list(self.locations_to_weighted_scores.itervalues())
return grade_summary return grade_summary
...@@ -141,7 +141,7 @@ class CourseGrade(object): ...@@ -141,7 +141,7 @@ class CourseGrade(object):
subsections_total = sum(len(x) for x in self.subsection_grade_totals_by_format.itervalues()) subsections_total = sum(len(x) for x in self.subsection_grade_totals_by_format.itervalues())
subsections_read = len(subsection_grade_factory._unsaved_subsection_grades) # pylint: disable=protected-access subsections_read = len(subsection_grade_factory._unsaved_subsection_grades) # pylint: disable=protected-access
subsections_created = subsections_total - subsections_read subsections_created = subsections_total - subsections_read
blocks_total = len(self.locations_to_scores) blocks_total = len(self.locations_to_weighted_scores)
if not read_only: if not read_only:
subsection_grade_factory.bulk_create_unsaved() subsection_grade_factory.bulk_create_unsaved()
...@@ -166,8 +166,8 @@ class CourseGrade(object): ...@@ -166,8 +166,8 @@ class CourseGrade(object):
composite module (a vertical or section ) the scores will be the sums of composite module (a vertical or section ) the scores will be the sums of
all scored problems that are children of the chosen location. all scored problems that are children of the chosen location.
""" """
if location in self.locations_to_scores: if location in self.locations_to_weighted_scores:
score = self.locations_to_scores[location] score, _ = self.locations_to_weighted_scores[location]
return score.earned, score.possible return score.earned, score.possible
children = self.course_structure.get_children(location) children = self.course_structure.get_children(location)
earned = 0.0 earned = 0.0
......
lms/djangoapps/grades/new/subsection_grade.py
...@@ -11,11 +11,12 @@ from courseware.model_data import ScoresClient ...@@ -11,11 +11,12 @@ from courseware.model_data import ScoresClient
from lms.djangoapps.grades.scores import get_score, possibly_scored from lms.djangoapps.grades.scores import get_score, possibly_scored
from lms.djangoapps.grades.models import BlockRecord, PersistentSubsectionGrade from lms.djangoapps.grades.models import BlockRecord, PersistentSubsectionGrade
from lms.djangoapps.grades.config.models import PersistentGradesEnabledFlag from lms.djangoapps.grades.config.models import PersistentGradesEnabledFlag
from lms.djangoapps.grades.transformer import GradesTransformer
from student.models import anonymous_id_for_user, User from student.models import anonymous_id_for_user, User
from submissions import api as submissions_api from submissions import api as submissions_api
from traceback import format_exc from traceback import format_exc
from xmodule import block_metadata_utils, graders from xmodule import block_metadata_utils, graders
from xmodule.graders import AggregatedScore from xmodule.graders import Score
log = getLogger(__name__) log = getLogger(__name__)
...@@ -53,47 +54,62 @@ class SubsectionGrade(object): ...@@ -53,47 +54,62 @@ class SubsectionGrade(object):
self.graded_total = None # aggregated grade for all graded problems self.graded_total = None # aggregated grade for all graded problems
self.all_total = None # aggregated grade for all problems, regardless of whether they are graded self.all_total = None # aggregated grade for all problems, regardless of whether they are graded
self.locations_to_scores = OrderedDict() # dict of problem locations to ProblemScore self.locations_to_weighted_scores = OrderedDict() # dict of problem locations to (Score, weight) tuples
self._scores = None
@property @property
def scores(self): def scores(self):
""" """
List of all problem scores in the subsection. List of all problem scores in the subsection.
""" """
return self.locations_to_scores.values() if self._scores is None:
self._scores = [score for score, _ in self.locations_to_weighted_scores.itervalues()]
return self._scores
def init_from_structure(self, student, course_structure, submissions_scores, csm_scores): def init_from_structure(self, student, course_structure, scores_client, submissions_scores):
""" """
Compute the grade of this subsection for the given student and course. Compute the grade of this subsection for the given student and course.
""" """
assert self._scores is None
for descendant_key in course_structure.post_order_traversal( for descendant_key in course_structure.post_order_traversal(
filter_func=possibly_scored, filter_func=possibly_scored,
start_node=self.location, start_node=self.location,
): ):
self._compute_block_score(descendant_key, course_structure, submissions_scores, csm_scores) self._compute_block_score(
student, descendant_key, course_structure, scores_client, submissions_scores, persisted_values={},
)
self.all_total, self.graded_total = graders.aggregate_scores(self.scores, self.display_name, self.location) self.all_total, self.graded_total = graders.aggregate_scores(self.scores, self.display_name, self.location)
self._log_event(log.debug, u"init_from_structure", student) self._log_event(log.debug, u"init_from_structure", student)
def init_from_model(self, student, model, course_structure, submissions_scores, csm_scores): def init_from_model(self, student, model, course_structure, scores_client, submissions_scores):
""" """
Load the subsection grade from the persisted model. Load the subsection grade from the persisted model.
""" """
assert self._scores is None
for block in model.visible_blocks.blocks: for block in model.visible_blocks.blocks:
self._compute_block_score(block.locator, course_structure, submissions_scores, csm_scores, block) persisted_values = {'weight': block.weight, 'possible': block.max_score}
self._compute_block_score(
student,
block.locator,
course_structure,
scores_client,
submissions_scores,
persisted_values
)
self.graded_total = AggregatedScore( self.graded_total = Score(
tw_earned=model.earned_graded, earned=model.earned_graded,
tw_possible=model.possible_graded, possible=model.possible_graded,
graded=True, graded=True,
display_name=self.display_name, section=self.display_name,
module_id=self.location, module_id=self.location,
) )
self.all_total = AggregatedScore( self.all_total = Score(
tw_earned=model.earned_all, earned=model.earned_all,
tw_possible=model.possible_all, possible=model.possible_all,
graded=False, graded=False,
display_name=self.display_name, section=self.display_name,
module_id=self.location, module_id=self.location,
) )
self._log_event(log.debug, u"init_from_model", student) self._log_event(log.debug, u"init_from_model", student)
...@@ -124,11 +140,12 @@ class SubsectionGrade(object): ...@@ -124,11 +140,12 @@ class SubsectionGrade(object):
def _compute_block_score( def _compute_block_score(
self, self,
student,
block_key, block_key,
course_structure, course_structure,
scores_client,
submissions_scores, submissions_scores,
csm_scores, persisted_values,
persisted_block=None,
): ):
""" """
Compute score for the given block. If persisted_values Compute score for the given block. If persisted_values
...@@ -137,14 +154,54 @@ class SubsectionGrade(object): ...@@ -137,14 +154,54 @@ class SubsectionGrade(object):
block = course_structure[block_key] block = course_structure[block_key]
if getattr(block, 'has_score', False): if getattr(block, 'has_score', False):
problem_score = get_score(
submissions_scores, possible = persisted_values.get('possible', None)
csm_scores, weight = persisted_values.get('weight', getattr(block, 'weight', None))
persisted_block,
(earned, possible) = get_score(
student,
block, block,
scores_client,
submissions_scores,
weight,
possible,
) )
if problem_score:
self.locations_to_scores[block_key] = problem_score if earned is not None or possible is not None:
# There's a chance that the value of graded is not the same
# value when the problem was scored. Since we get the value
# from the block_structure.
#
# Cannot grade a problem with a denominator of 0.
# TODO: None > 0 is not python 3 compatible.
block_graded = self._get_explicit_graded(block, course_structure) if possible > 0 else False
self.locations_to_weighted_scores[block.location] = (
Score(
earned,
possible,
block_graded,
block_metadata_utils.display_name_with_default_escaped(block),
block.location,
),
weight,
)
def _get_explicit_graded(self, block, course_structure):
"""
Returns the explicit graded field value for the given block
"""
field_value = course_structure.get_transformer_block_field(
block.location,
GradesTransformer,
GradesTransformer.EXPLICIT_GRADED_FIELD_NAME
)
# Set to True if grading is not explicitly disabled for
# this block. This allows us to include the block's score
# in the aggregated self.graded_total, regardless of the
# inherited graded value from the subsection. (TNL-5560)
return True if field_value is None else field_value
def _persisted_model_params(self, student): def _persisted_model_params(self, student):
""" """
...@@ -169,9 +226,9 @@ class SubsectionGrade(object): ...@@ -169,9 +226,9 @@ class SubsectionGrade(object):
Returns the list of visible blocks. Returns the list of visible blocks.
""" """
return [ return [
BlockRecord(location, score.weight, score.raw_possible, score.graded) BlockRecord(location, weight, score.possible)
for location, score in for location, (score, weight) in
self.locations_to_scores.iteritems() self.locations_to_weighted_scores.iteritems()
] ]
def _log_event(self, log_func, log_statement, student): def _log_event(self, log_func, log_statement, student):
...@@ -226,7 +283,7 @@ class SubsectionGradeFactory(object): ...@@ -226,7 +283,7 @@ class SubsectionGradeFactory(object):
if not subsection_grade: if not subsection_grade:
subsection_grade = SubsectionGrade(subsection, self.course) subsection_grade = SubsectionGrade(subsection, self.course)
subsection_grade.init_from_structure( subsection_grade.init_from_structure(
self.student, block_structure, self._submissions_scores, self._csm_scores, self.student, block_structure, self._scores_client, self._submissions_scores
) )
if PersistentGradesEnabledFlag.feature_enabled(self.course.id): if PersistentGradesEnabledFlag.feature_enabled(self.course.id):
if read_only: if read_only:
...@@ -256,7 +313,7 @@ class SubsectionGradeFactory(object): ...@@ -256,7 +313,7 @@ class SubsectionGradeFactory(object):
block_structure = self._get_block_structure(block_structure) block_structure = self._get_block_structure(block_structure)
subsection_grade = SubsectionGrade(subsection, self.course) subsection_grade = SubsectionGrade(subsection, self.course)
subsection_grade.init_from_structure( subsection_grade.init_from_structure(
self.student, block_structure, self._submissions_scores, self._csm_scores self.student, block_structure, self._scores_client, self._submissions_scores
) )
if PersistentGradesEnabledFlag.feature_enabled(self.course.id): if PersistentGradesEnabledFlag.feature_enabled(self.course.id):
...@@ -266,7 +323,7 @@ class SubsectionGradeFactory(object): ...@@ -266,7 +323,7 @@ class SubsectionGradeFactory(object):
return subsection_grade return subsection_grade
@lazy @lazy
def _csm_scores(self): def _scores_client(self):
""" """
Lazily queries and returns all the scores stored in the user Lazily queries and returns all the scores stored in the user
state (in CSM) for the course, while caching the result. state (in CSM) for the course, while caching the result.
...@@ -294,7 +351,7 @@ class SubsectionGradeFactory(object): ...@@ -294,7 +351,7 @@ class SubsectionGradeFactory(object):
if saved_subsection_grade: if saved_subsection_grade:
subsection_grade = SubsectionGrade(subsection, self.course) subsection_grade = SubsectionGrade(subsection, self.course)
subsection_grade.init_from_model( subsection_grade.init_from_model(
self.student, saved_subsection_grade, block_structure, self._submissions_scores, self._csm_scores, self.student, saved_subsection_grade, block_structure, self._scores_client, self._submissions_scores
) )
return subsection_grade return subsection_grade
......
lms/djangoapps/grades/scores.py
...@@ -5,246 +5,106 @@ from logging import getLogger ...@@ -5,246 +5,106 @@ from logging import getLogger
from openedx.core.lib.cache_utils import memoized from openedx.core.lib.cache_utils import memoized
from xblock.core import XBlock from xblock.core import XBlock
from xmodule.block_metadata_utils import display_name_with_default_escaped
from xmodule.graders import ProblemScore
from .transformer import GradesTransformer from .transformer import GradesTransformer
log = getLogger(__name__) log = getLogger(__name__)
def possibly_scored(usage_key): @memoized
""" def block_types_possibly_scored():
Returns whether the given block could impact grading (i.e.
has_score or has_children).
""" """
return usage_key.block_type in _block_types_possibly_scored() Returns the block types that could have a score.
def get_score(submissions_scores, csm_scores, persisted_block, block): Something might be a scored item if it is capable of storing a score
""" (has_score=True). We also have to include anything that can have children,
Returns the score for a problem, as a ProblemScore object. It is since those children might have scores. We can avoid things like Videos,
assumed that the provided storages have already been filtered for which have state but cannot ever impact someone's grade.
a single user in question and have user-specific values.
The score is retrieved from the provided storages in the following
order of precedence. If no value for the block is found in a
given storage, the next storage is checked.
submissions_scores (dict of {unicode(usage_key): (earned, possible)}):
A python dictionary of serialized UsageKeys to (earned, possible)
tuples. These values, retrieved using the Submissions API by the
caller (already filtered for the user and course), take precedence
above all other score storages.
When the score is found in this storage, it implies the user's score
for the block was persisted via the submissions API. Typically, this API
is used by ORA.
The returned score includes valid values for:
weighted_earned
weighted_possible
graded - retrieved from the persisted block, if found, else from
the latest block content.
Note: raw_earned and raw_possible are not required when submitting scores
via the submissions API, so those values (along with the unused weight)
are invalid and irrelevant.
csm_scores (ScoresClient):
The ScoresClient object (already filtered for the user and course),
from which a courseware.models.StudentModule object can be retrieved for
the block.
When the score is found from this storage, it implies the user's score
for the block was persisted in the Courseware Student Module. Typically,
this storage is used for all CAPA problems, including scores calculated
by external graders.
The returned score includes valid values for:
raw_earned, raw_possible - retrieved from CSM
weighted_earned, weighted_possible - calculated from the raw scores and weight
weight, graded - retrieved from the persisted block, if found,
else from the latest block content
persisted_block (.models.BlockRecord):
The block values as found in the grades persistence layer. These values
are used only if not found from an earlier storage, and take precedence
over values stored within the latest content-version of the block.
When the score is found from this storage, it implies the user has not
yet attempted this problem, but the user's grade _was_ persisted.
The returned score includes valid values for:
raw_earned - will equal 0.0 since the user's score was not found from
earlier storages
raw_possible - retrieved from the persisted block
weighted_earned, weighted_possible - calculated from the raw scores and weight
weight, graded - retrieved from the persisted block
block (block_structure.BlockData):
Values from the latest content-version of the block are used only if
they were not available from a prior storage.
When the score is found from this storage, it implies the user has not
yet attempted this problem and the user's grade was _not_ yet persisted.
The returned score includes valid values for:
raw_earned - will equal 0.0 since the user's score was not found from
earlier storages
raw_possible - retrieved from the latest block content
weighted_earned, weighted_possible - calculated from the raw scores and weight
weight, graded - retrieved from the latest block content
""" """
weight = _get_weight_from_block(persisted_block, block) return frozenset(
cat for (cat, xblock_class) in XBlock.load_classes() if (
# Priority order for retrieving the scores: getattr(xblock_class, 'has_score', False) or getattr(xblock_class, 'has_children', False)
# submissions API -> CSM -> grades persisted block -> latest block content )
raw_earned, raw_possible, weighted_earned, weighted_possible = (
_get_score_from_submissions(submissions_scores, block) or
_get_score_from_csm(csm_scores, block, weight) or
_get_score_from_persisted_or_latest_block(persisted_block, block, weight)
)
assert weighted_possible is not None
has_valid_denominator = weighted_possible > 0.0
graded = _get_graded_from_block(persisted_block, block) if has_valid_denominator else False
return ProblemScore(
raw_earned,
raw_possible,
weighted_earned,
weighted_possible,
weight,
graded,
display_name=display_name_with_default_escaped(block),
module_id=block.location,
) )
def _get_score_from_submissions(submissions_scores, block): def possibly_scored(usage_key):
"""
Returns the score values from the submissions API if found.
"""
if submissions_scores:
submission_value = submissions_scores.get(unicode(block.location))
if submission_value:
weighted_earned, weighted_possible = submission_value
assert weighted_earned >= 0.0 and weighted_possible > 0.0 # per contract from submissions API
return (None, None) + (weighted_earned, weighted_possible)
def _get_score_from_csm(csm_scores, block, weight):
"""
Returns the score values from the courseware student module, via
ScoresClient, if found.
"""
# If an entry exists and has raw_possible (total) associated with it, we trust
# that value. This is important for cases where a student might have seen an
# older version of the problem -- they're still graded on what was possible
# when they tried the problem, not what it's worth now.
#
# Note: Storing raw_possible in CSM predates the implementation of the grades
# own persistence layer. Hence, we have duplicate storage locations for
# raw_possible, with potentially conflicting values, when a problem is
# attempted. Even though the CSM persistence for this value is now
# superfluous, for backward compatibility, we continue to use its value for
# raw_possible, giving it precedence over the one in the grades data model.
score = csm_scores.get(block.location)
has_valid_score = score and score.total is not None
if has_valid_score:
raw_earned = score.correct if score.correct is not None else 0.0
raw_possible = score.total
return (raw_earned, raw_possible) + _weighted_score(raw_earned, raw_possible, weight)
def _get_score_from_persisted_or_latest_block(persisted_block, block, weight):
""" """
Returns the score values, now assuming the earned score is 0.0 - since a Returns whether the given block could impact grading (i.e. scored, or has children).
score was not found in an earlier storage.
Uses the raw_possible value from the persisted_block if found, else from
the latest block content.
""" """
raw_earned = 0.0 return usage_key.block_type in block_types_possibly_scored()
if persisted_block:
raw_possible = persisted_block.raw_possible
else:
raw_possible = block.transformer_data[GradesTransformer].max_score
return (raw_earned, raw_possible) + _weighted_score(raw_earned, raw_possible, weight)
def _get_weight_from_block(persisted_block, block): def weighted_score(raw_earned, raw_possible, weight=None):
""" """
Returns the weighted value from the persisted_block if found, else from Return a tuple that represents the weighted (earned, possible) score.
the latest block content. If weight is None or raw_possible is 0, returns the original values.
""" """
if persisted_block: if weight is None or raw_possible == 0:
return persisted_block.weight return (raw_earned, raw_possible)
else: return float(raw_earned) * weight / raw_possible, float(weight)
return getattr(block, 'weight', None)
def _get_graded_from_block(persisted_block, block): def get_score(user, block, scores_client, submissions_scores_cache, weight, possible=None):
""" """
Returns the graded value from the persisted_block if found, else from Return the score for a user on a problem, as a tuple (earned, possible).
the latest block content. e.g. (5,7) if you got 5 out of 7 points.
"""
if persisted_block:
return persisted_block.graded
else:
return _get_explicit_graded(block)
If this problem doesn't have a score, or we couldn't load it, returns (None,
None).
def _get_explicit_graded(block): user: a Student object
block: a BlockStructure's BlockData object
scores_client: an initialized ScoresClient
submissions_scores_cache: A dict of location names to (earned, possible)
point tuples. If an entry is found in this cache, it takes precedence.
weight: The weight of the problem to use in the calculation. A value of
None signifies that the weight should not be applied.
possible (optional): The possible maximum score of the problem to use in the
calculation. If None, uses the value found either in scores_client or
from the block.
""" """
Returns the explicit graded field value for the given block. submissions_scores_cache = submissions_scores_cache or {}
"""
field_value = getattr(
block.transformer_data[GradesTransformer],
GradesTransformer.EXPLICIT_GRADED_FIELD_NAME,
None,
)
# Set to True if grading is not explicitly disabled for if not user.is_authenticated():
# this block. This allows us to include the block's score return (None, None)
# in the aggregated self.graded_total, regardless of the
# inherited graded value from the subsection. (TNL-5560)
return True if field_value is None else field_value
location_url = unicode(block.location)
if location_url in submissions_scores_cache:
return submissions_scores_cache[location_url]
def _weighted_score(raw_earned, raw_possible, weight): if not getattr(block, 'has_score', False):
""" # These are not problems, and do not have a score
Returns a tuple that represents the weighted (earned, possible) score. return (None, None)
If weight is None or raw_possible is 0, returns the original values.
When weight is used, it defines the weighted_possible. This allows # Check the score that comes from the ScoresClient (out of CSM).
course authors to specify the exact maximum value for a problem when # If an entry exists and has a total associated with it, we trust that
they provide a weight. # value. This is important for cases where a student might have seen an
""" # older version of the problem -- they're still graded on what was possible
assert raw_possible is not None # when they tried the problem, not what it's worth now.
cannot_compute_with_weight = weight is None or raw_possible == 0 score = scores_client.get(block.location)
if cannot_compute_with_weight: if score and score.total is not None:
return raw_earned, raw_possible # We have a valid score, just use it.
earned = score.correct if score.correct is not None else 0.0
if possible is None:
possible = score.total
elif possible != score.total:
log.error(
u"Persistent Grades: scores.get_score, possible value {} != score.total value {}".format(
possible,
score.total
)
)
else: else:
return float(raw_earned) * weight / raw_possible, float(weight) # This means we don't have a valid score entry and we don't have a
# cached_max_score on hand. We know they've earned 0.0 points on this.
earned = 0.0
@memoized if possible is None:
def _block_types_possibly_scored(): possible = block.transformer_data[GradesTransformer].max_score
"""
Returns the block types that could have a score. # Problem may be an error module (if something in the problem builder failed)
# In which case possible might be None
Something might be a scored item if it is capable of storing a score if possible is None:
(has_score=True). We also have to include anything that can have children, return (None, None)
since those children might have scores. We can avoid things like Videos,
which have state but cannot ever impact someone's grade. return weighted_score(earned, possible, weight)
"""
return frozenset(
category for (category, xblock_class) in XBlock.load_classes() if (
getattr(xblock_class, 'has_score', False) or getattr(xblock_class, 'has_children', False)
)
)
lms/djangoapps/grades/tests/test_grades.py
...@@ -2,29 +2,24 @@ ...@@ -2,29 +2,24 @@
Test grade calculation. Test grade calculation.
""" """
import ddt
from django.http import Http404 from django.http import Http404
import itertools
from mock import patch from mock import patch
from nose.plugins.attrib import attr from nose.plugins.attrib import attr
from opaque_keys.edx.locations import SlashSeparatedCourseKey from opaque_keys.edx.locations import SlashSeparatedCourseKey
from capa.tests.response_xml_factory import MultipleChoiceResponseXMLFactory from courseware.tests.helpers import (
from courseware.tests.helpers import get_request_for_user LoginEnrollmentTestCase,
from lms.djangoapps.course_blocks.api import get_course_blocks get_request_for_user
)
from student.tests.factories import UserFactory from student.tests.factories import UserFactory
from student.models import CourseEnrollment from student.models import CourseEnrollment
from xmodule.block_metadata_utils import display_name_with_default_escaped
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory from xmodule.modulestore.tests.factories import CourseFactory, ItemFactory
from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase
from xmodule.graders import ProblemScore
from .utils import answer_problem from .utils import answer_problem
from .. import course_grades from .. import course_grades
from ..course_grades import summary as grades_summary from ..course_grades import summary as grades_summary
from ..new.course_grade import CourseGradeFactory from ..new.course_grade import CourseGradeFactory
from ..new.subsection_grade import SubsectionGradeFactory
def _grade_with_errors(student, course): def _grade_with_errors(student, course):
...@@ -41,17 +36,6 @@ def _grade_with_errors(student, course): ...@@ -41,17 +36,6 @@ def _grade_with_errors(student, course):
return grades_summary(student, course) return grades_summary(student, course)
def _create_problem_xml():
"""
Creates and returns XML for a multiple choice response problem
"""
return MultipleChoiceResponseXMLFactory().build_xml(
question_text='The correct answer is Choice 3',
choices=[False, False, True, False],
choice_names=['choice_0', 'choice_1', 'choice_2', 'choice_3']
)
@attr(shard=1) @attr(shard=1)
class TestGradeIteration(SharedModuleStoreTestCase): class TestGradeIteration(SharedModuleStoreTestCase):
""" """
...@@ -153,101 +137,6 @@ class TestGradeIteration(SharedModuleStoreTestCase): ...@@ -153,101 +137,6 @@ class TestGradeIteration(SharedModuleStoreTestCase):
return students_to_gradesets, students_to_errors return students_to_gradesets, students_to_errors
@ddt.ddt
class TestWeightedProblems(SharedModuleStoreTestCase):
"""
Test scores and grades with various problem weight values.
"""
@classmethod
def setUpClass(cls):
super(TestWeightedProblems, cls).setUpClass()
cls.course = CourseFactory.create()
cls.chapter = ItemFactory.create(parent=cls.course, category="chapter", display_name="chapter")
cls.sequential = ItemFactory.create(parent=cls.chapter, category="sequential", display_name="sequential")
cls.vertical = ItemFactory.create(parent=cls.sequential, category="vertical", display_name="vertical1")
problem_xml = _create_problem_xml()
cls.problems = []
for i in range(2):
cls.problems.append(
ItemFactory.create(
parent=cls.vertical,
category="problem",
display_name="problem_{}".format(i),
data=problem_xml,
)
)
def setUp(self):
super(TestWeightedProblems, self).setUp()
self.user = UserFactory()
self.request = get_request_for_user(self.user)
def _verify_grades(self, raw_earned, raw_possible, weight, expected_score):
"""
Verifies the computed grades are as expected.
"""
with self.store.branch_setting(ModuleStoreEnum.Branch.draft_preferred):
# pylint: disable=no-member
for problem in self.problems:
problem.weight = weight
self.store.update_item(problem, self.user.id)
self.store.publish(self.course.location, self.user.id)
course_structure = get_course_blocks(self.request.user, self.course.location)
# answer all problems
for problem in self.problems:
answer_problem(self.course, self.request, problem, score=raw_earned, max_value=raw_possible)
# get grade
subsection_grade = SubsectionGradeFactory(
self.request.user, self.course, course_structure
).update(self.sequential)
# verify all problem grades
for problem in self.problems:
problem_score = subsection_grade.locations_to_scores[problem.location]
expected_score.display_name = display_name_with_default_escaped(problem)
expected_score.module_id = problem.location
self.assertEquals(problem_score, expected_score)
# verify subsection grades
self.assertEquals(subsection_grade.all_total.earned, expected_score.earned * len(self.problems))
self.assertEquals(subsection_grade.all_total.possible, expected_score.possible * len(self.problems))
@ddt.data(
*itertools.product(
(0.0, 0.5, 1.0, 2.0), # raw_earned
(-2.0, -1.0, 0.0, 0.5, 1.0, 2.0), # raw_possible
(-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0, 50.0, None), # weight
)
)
@ddt.unpack
def test_problem_weight(self, raw_earned, raw_possible, weight):
use_weight = weight is not None and raw_possible != 0
if use_weight:
expected_w_earned = raw_earned / raw_possible * weight
expected_w_possible = weight
else:
expected_w_earned = raw_earned
expected_w_possible = raw_possible
expected_graded = expected_w_possible > 0
expected_score = ProblemScore(
raw_earned=raw_earned,
raw_possible=raw_possible,
weighted_earned=expected_w_earned,
weighted_possible=expected_w_possible,
weight=weight,
graded=expected_graded,
display_name=None, # problem-specific, filled in by _verify_grades
module_id=None, # problem-specific, filled in by _verify_grades
)
self._verify_grades(raw_earned, raw_possible, weight, expected_score)
class TestScoreForModule(SharedModuleStoreTestCase): class TestScoreForModule(SharedModuleStoreTestCase):
""" """
Test the method that calculates the score for a given block based on the Test the method that calculates the score for a given block based on the
......
lms/djangoapps/grades/tests/test_models.py
...@@ -71,8 +71,8 @@ class GradesModelTestCase(TestCase): ...@@ -71,8 +71,8 @@ class GradesModelTestCase(TestCase):
block_type='problem', block_type='problem',
block_id='block_id_b' block_id='block_id_b'
) )
self.record_a = BlockRecord(locator=self.locator_a, weight=1, raw_possible=10, graded=False) self.record_a = BlockRecord(locator=self.locator_a, weight=1, max_score=10)
self.record_b = BlockRecord(locator=self.locator_b, weight=1, raw_possible=10, graded=True) self.record_b = BlockRecord(locator=self.locator_b, weight=1, max_score=10)
@ddt.ddt @ddt.ddt
...@@ -88,31 +88,29 @@ class BlockRecordTest(GradesModelTestCase): ...@@ -88,31 +88,29 @@ class BlockRecordTest(GradesModelTestCase):
Tests creation of a BlockRecord. Tests creation of a BlockRecord.
""" """
weight = 1 weight = 1
raw_possible = 10 max_score = 10
record = BlockRecord( record = BlockRecord(
self.locator_a, self.locator_a,
weight, weight,
raw_possible, max_score,
graded=False,
) )
self.assertEqual(record.locator, self.locator_a) self.assertEqual(record.locator, self.locator_a)
@ddt.data( @ddt.data(
(0, 0, "0123456789abcdef", True), (0, 0, "0123456789abcdef"),
(1, 10, 'totally_a_real_block_key', False), (1, 10, 'totally_a_real_block_key'),
("BlockRecord is", "a dumb data store", "with no validation", None), ("BlockRecord is", "a dumb data store", "with no validation"),
) )
@ddt.unpack @ddt.unpack
def test_serialization(self, weight, raw_possible, block_key, graded): def test_serialization(self, weight, max_score, block_key):
""" """
Tests serialization of a BlockRecord using the _asdict() method. Tests serialization of a BlockRecord using the _asdict() method.
""" """
record = BlockRecord(block_key, weight, raw_possible, graded) record = BlockRecord(block_key, weight, max_score)
expected = OrderedDict([ expected = OrderedDict([
("locator", block_key), ("locator", block_key),
("weight", weight), ("weight", weight),
("raw_possible", raw_possible), ("max_score", max_score),
("graded", graded),
]) ])
self.assertEqual(expected, record._asdict()) self.assertEqual(expected, record._asdict())
...@@ -136,12 +134,7 @@ class VisibleBlocksTest(GradesModelTestCase): ...@@ -136,12 +134,7 @@ class VisibleBlocksTest(GradesModelTestCase):
for block_dict in list_of_block_dicts: for block_dict in list_of_block_dicts:
block_dict['locator'] = unicode(block_dict['locator']) # BlockUsageLocator is not json-serializable block_dict['locator'] = unicode(block_dict['locator']) # BlockUsageLocator is not json-serializable
expected_data = { expected_data = {
'blocks': [{ 'blocks': [{'locator': unicode(self.record_a.locator), 'max_score': 10, 'weight': 1}],
'locator': unicode(self.record_a.locator),
'raw_possible': 10,
'weight': 1,
'graded': self.record_a.graded,
}],
'course_key': unicode(self.record_a.locator.course_key), 'course_key': unicode(self.record_a.locator.course_key),
'version': BLOCK_RECORD_LIST_VERSION, 'version': BLOCK_RECORD_LIST_VERSION,
} }
......
lms/djangoapps/grades/tests/test_new.py
""" """
Test saved subsection grade functionality. Test saved subsection grade functionality.
""" """
# pylint: disable=protected-access
import ddt import ddt
from django.conf import settings from django.conf import settings
from django.db.utils import DatabaseError from django.db.utils import DatabaseError
...@@ -116,7 +116,7 @@ class SubsectionGradeFactoryTest(GradeTestBase): ...@@ -116,7 +116,7 @@ class SubsectionGradeFactoryTest(GradeTestBase):
) as mock_create_grade: ) as mock_create_grade:
with patch( with patch(
'lms.djangoapps.grades.new.subsection_grade.SubsectionGradeFactory._get_saved_grade', 'lms.djangoapps.grades.new.subsection_grade.SubsectionGradeFactory._get_saved_grade',
wraps=self.subsection_grade_factory._get_saved_grade wraps=self.subsection_grade_factory._get_saved_grade # pylint: disable=protected-access
) as mock_get_saved_grade: ) as mock_get_saved_grade:
with self.assertNumQueries(14): with self.assertNumQueries(14):
grade_a = self.subsection_grade_factory.create(self.sequence) grade_a = self.subsection_grade_factory.create(self.sequence)
...@@ -205,8 +205,8 @@ class SubsectionGradeTest(GradeTestBase): ...@@ -205,8 +205,8 @@ class SubsectionGradeTest(GradeTestBase):
input_grade.init_from_structure( input_grade.init_from_structure(
self.request.user, self.request.user,
self.course_structure, self.course_structure,
self.subsection_grade_factory._submissions_scores, self.subsection_grade_factory._scores_client, # pylint: disable=protected-access
self.subsection_grade_factory._csm_scores, self.subsection_grade_factory._submissions_scores, # pylint: disable=protected-access
) )
self.assertEqual(PersistentSubsectionGrade.objects.count(), 0) self.assertEqual(PersistentSubsectionGrade.objects.count(), 0)
...@@ -224,8 +224,8 @@ class SubsectionGradeTest(GradeTestBase): ...@@ -224,8 +224,8 @@ class SubsectionGradeTest(GradeTestBase):
self.request.user, self.request.user,
saved_model, saved_model,
self.course_structure, self.course_structure,
self.subsection_grade_factory._submissions_scores, self.subsection_grade_factory._scores_client, # pylint: disable=protected-access
self.subsection_grade_factory._csm_scores, self.subsection_grade_factory._submissions_scores, # pylint: disable=protected-access
) )
self.assertEqual(input_grade.url_name, loaded_grade.url_name) self.assertEqual(input_grade.url_name, loaded_grade.url_name)
......
lms/djangoapps/grades/tests/test_scores.py deleted 100644 → 0
"""
Tests for grades.scores module.
"""
# pylint: disable=protected-access
from collections import namedtuple
import ddt
from django.test import TestCase
import itertools
from lms.djangoapps.grades.models import BlockRecord
import lms.djangoapps.grades.scores as scores
from lms.djangoapps.grades.transformer import GradesTransformer
from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
from openedx.core.lib.block_structure.block_structure import BlockData
from xmodule.graders import ProblemScore
class TestScoredBlockTypes(TestCase):
"""
Tests for the possibly_scored function.
"""
possibly_scored_block_types = {
'course', 'chapter', 'sequential', 'vertical',
'library_content', 'split_test', 'conditional', 'library', 'randomize',
'problem', 'drag-and-drop-v2', 'openassessment', 'lti', 'lti_consumer',
'videosequence', 'problemset', 'acid_parent', 'done', 'wrapper', 'edx_sga',
}
def test_block_types_possibly_scored(self):
self.assertSetEqual(
self.possibly_scored_block_types,
scores._block_types_possibly_scored()
)
def test_possibly_scored(self):
course_key = CourseLocator(u'org', u'course', u'run')
for block_type in self.possibly_scored_block_types:
usage_key = BlockUsageLocator(course_key, block_type, 'mock_block_id')
self.assertTrue(scores.possibly_scored(usage_key))
@ddt.ddt
class TestGetScore(TestCase):
"""
Tests for get_score
"""
display_name = 'test_name'
location = 'test_location'
SubmissionValue = namedtuple('SubmissionValue', 'exists, weighted_earned, weighted_possible')
CSMValue = namedtuple('CSMValue', 'exists, raw_earned, raw_possible')
PersistedBlockValue = namedtuple('PersistedBlockValue', 'exists, raw_possible, weight, graded')
ContentBlockValue = namedtuple('ContentBlockValue', 'raw_possible, weight, explicit_graded')
ExpectedResult = namedtuple(
'ExpectedResult', 'raw_earned, raw_possible, weighted_earned, weighted_possible, weight, graded'
)
def _create_submissions_scores(self, submission_value):
"""
Creates a stub result from the submissions API for the given values.
"""
if submission_value.exists:
return {self.location: (submission_value.weighted_earned, submission_value.weighted_possible)}
else:
return {}
def _create_csm_scores(self, csm_value):
"""
Creates a stub result from courseware student module for the given values.
"""
if csm_value.exists:
stub_csm_record = namedtuple('stub_csm_record', 'correct, total')
return {self.location: stub_csm_record(correct=csm_value.raw_earned, total=csm_value.raw_possible)}
else:
return {}
def _create_persisted_block(self, persisted_block_value):
"""
Creates and returns a minimal BlockRecord object with the give values.
"""
if persisted_block_value.exists:
return BlockRecord(
self.location,
persisted_block_value.weight,
persisted_block_value.raw_possible,
persisted_block_value.graded,
)
else:
return None
def _create_block(self, content_block_value):
"""
Creates and returns a minimal BlockData object with the give values.
"""
block = BlockData(self.location)
block.display_name = self.display_name
block.weight = content_block_value.weight
block_grades_transformer_data = block.transformer_data.get_or_create(GradesTransformer)
block_grades_transformer_data.max_score = content_block_value.raw_possible
setattr(
block_grades_transformer_data,
GradesTransformer.EXPLICIT_GRADED_FIELD_NAME,
content_block_value.explicit_graded,
)
return block
@ddt.data(
# submissions _trumps_ other values; weighted and graded from persisted-block _trumps_ latest content values
(
SubmissionValue(exists=True, weighted_earned=50, weighted_possible=100),
CSMValue(exists=True, raw_earned=10, raw_possible=40),
PersistedBlockValue(exists=True, raw_possible=5, weight=40, graded=True),
ContentBlockValue(raw_possible=1, weight=20, explicit_graded=False),
ExpectedResult(
raw_earned=None, raw_possible=None, weighted_earned=50, weighted_possible=100, weight=40, graded=True
),
),
# same as above, except submissions doesn't exist; CSM values used
(
SubmissionValue(exists=False, weighted_earned=50, weighted_possible=100),
CSMValue(exists=True, raw_earned=10, raw_possible=40),
PersistedBlockValue(exists=True, raw_possible=5, weight=40, graded=True),
ContentBlockValue(raw_possible=1, weight=20, explicit_graded=False),
ExpectedResult(
raw_earned=10, raw_possible=40, weighted_earned=10, weighted_possible=40, weight=40, graded=True
),
),
# neither submissions nor CSM exist; Persisted values used
(
SubmissionValue(exists=False, weighted_earned=50, weighted_possible=100),
CSMValue(exists=False, raw_earned=10, raw_possible=40),
PersistedBlockValue(exists=True, raw_possible=5, weight=40, graded=True),
ContentBlockValue(raw_possible=1, weight=20, explicit_graded=False),
ExpectedResult(
raw_earned=0, raw_possible=5, weighted_earned=0, weighted_possible=40, weight=40, graded=True
),
),
# none of submissions, CSM, or persisted exist; Latest content values used
(
SubmissionValue(exists=False, weighted_earned=50, weighted_possible=100),
CSMValue(exists=False, raw_earned=10, raw_possible=40),
PersistedBlockValue(exists=False, raw_possible=5, weight=40, graded=True),
ContentBlockValue(raw_possible=1, weight=20, explicit_graded=False),
ExpectedResult(
raw_earned=0, raw_possible=1, weighted_earned=0, weighted_possible=20, weight=20, graded=False
),
),
)
@ddt.unpack
def test_get_score(self, submission_value, csm_value, persisted_block_value, block_value, expected_result):
score = scores.get_score(
self._create_submissions_scores(submission_value),
self._create_csm_scores(csm_value),
self._create_persisted_block(persisted_block_value),
self._create_block(block_value),
)
expected_score = ProblemScore(
display_name=self.display_name, module_id=self.location, **expected_result._asdict()
)
self.assertEquals(score, expected_score)
@ddt.ddt
class TestInternalWeightedScore(TestCase):
"""
Tests the internal helper method: _weighted_score
"""
@ddt.data(
(0, 0, 1),
(5, 0, 0),
(10, 0, None),
(0, 5, None),
(5, 10, None),
(10, 10, None),
)
@ddt.unpack
def test_cannot_compute(self, raw_earned, raw_possible, weight):
self.assertEquals(
scores._weighted_score(raw_earned, raw_possible, weight),
(raw_earned, raw_possible),
)
@ddt.data(
(0, 5, 0, (0, 0)),
(5, 5, 0, (0, 0)),
(2, 5, 1, (.4, 1)),
(5, 5, 1, (1, 1)),
(5, 5, 3, (3, 3)),
(2, 4, 6, (3, 6)),
)
@ddt.unpack
def test_computed(self, raw_earned, raw_possible, weight, expected_score):
self.assertEquals(
scores._weighted_score(raw_earned, raw_possible, weight),
expected_score,
)
def test_assert_on_invalid_r_possible(self):
with self.assertRaises(AssertionError):
scores._weighted_score(raw_earned=1, raw_possible=None, weight=1)
@ddt.ddt
class TestInternalGetGraded(TestCase):
"""
Tests the internal helper method: _get_explicit_graded
"""
def _create_block(self, explicit_graded_value):
"""
Creates and returns a minimal BlockData object with the give value
for explicit_graded.
"""
block = BlockData('any_key')
setattr(
block.transformer_data.get_or_create(GradesTransformer),
GradesTransformer.EXPLICIT_GRADED_FIELD_NAME,
explicit_graded_value,
)
return block
@ddt.data(None, True, False)
def test_with_no_persisted_block(self, explicitly_graded_value):
block = self._create_block(explicitly_graded_value)
self.assertEquals(
scores._get_graded_from_block(None, block),
explicitly_graded_value is not False, # defaults to True unless explicitly False
)
@ddt.data(
*itertools.product((True, False), (True, False, None))
)
@ddt.unpack
def test_with_persisted_block(self, persisted_block_value, block_value):
block = self._create_block(block_value)
block_record = BlockRecord(block.location, 0, 0, persisted_block_value)
self.assertEquals(
scores._get_graded_from_block(block_record, block),
block_record.graded, # persisted value takes precedence
)
@ddt.ddt
class TestInternalGetScoreFromBlock(TestCase):
"""
Tests the internal helper method: _get_score_from_persisted_or_latest_block
"""
def _create_block(self, raw_possible):
"""
Creates and returns a minimal BlockData object with the give value
for raw_possible.
"""
block = BlockData('any_key')
block.transformer_data.get_or_create(GradesTransformer).max_score = raw_possible
return block
def _verify_score_result(self, persisted_block, block, weight, expected_r_possible):
"""
Verifies the result of _get_score_from_persisted_or_latest_block is as expected.
"""
# pylint: disable=unbalanced-tuple-unpacking
raw_earned, raw_possible, weighted_earned, weighted_possible = scores._get_score_from_persisted_or_latest_block(
persisted_block, block, weight,
)
self.assertEquals(raw_earned, 0.0)
self.assertEquals(raw_possible, expected_r_possible)
self.assertEquals(weighted_earned, 0.0)
if weight is None or expected_r_possible == 0:
self.assertEquals(weighted_possible, expected_r_possible)
else:
self.assertEquals(weighted_possible, weight)
@ddt.data(
*itertools.product((0, 1, 5), (None, 0, 1, 5))
)
@ddt.unpack
def test_with_no_persisted_block(self, block_r_possible, weight):
block = self._create_block(block_r_possible)
self._verify_score_result(None, block, weight, block_r_possible)
@ddt.data(
*itertools.product((0, 1, 5), (None, 0, 1, 5), (None, 0, 1, 5))
)
@ddt.unpack
def test_with_persisted_block(self, persisted_block_r_possible, block_r_possible, weight):
block = self._create_block(block_r_possible)
block_record = BlockRecord(block.location, 0, persisted_block_r_possible, False)
self._verify_score_result(block_record, block, weight, persisted_block_r_possible)
lms/djangoapps/grades/tests/utils.py
...@@ -5,7 +5,6 @@ from contextlib import contextmanager ...@@ -5,7 +5,6 @@ from contextlib import contextmanager
from mock import patch from mock import patch
from courseware.module_render import get_module from courseware.module_render import get_module
from courseware.model_data import FieldDataCache from courseware.model_data import FieldDataCache
from xmodule.graders import ProblemScore
@contextmanager @contextmanager
...@@ -24,7 +23,7 @@ def mock_get_score(earned=0, possible=1): ...@@ -24,7 +23,7 @@ def mock_get_score(earned=0, possible=1):
Mocks the get_score function to return a valid grade. Mocks the get_score function to return a valid grade.
""" """
with patch('lms.djangoapps.grades.new.subsection_grade.get_score') as mock_score: with patch('lms.djangoapps.grades.new.subsection_grade.get_score') as mock_score:
mock_score.return_value = ProblemScore(earned, possible, earned, possible, 1, True, None, None) mock_score.return_value = (earned, possible)
yield mock_score yield mock_score
......
lms/djangoapps/instructor_task/tasks_helper.py
...@@ -948,7 +948,7 @@ def upload_problem_grade_report(_xmodule_instance_args, _entry_id, course_id, _t ...@@ -948,7 +948,7 @@ def upload_problem_grade_report(_xmodule_instance_args, _entry_id, course_id, _t
final_grade = gradeset['percent'] final_grade = gradeset['percent']
# Only consider graded problems # Only consider graded problems
problem_scores = {unicode(score.module_id): score for score in gradeset['raw_scores'] if score.graded} problem_scores = {unicode(score.module_id): score for score, _ in gradeset['raw_scores'] if score.graded}
earned_possible_values = list() earned_possible_values = list()
for problem_id in problems: for problem_id in problems:
try: try:
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment