Merge branch 'master' into feature/abarrett/annotation-styling-fixes

.pylintrc

@@ -12,7 +12,7 @@ profile=no
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
-ignore=CVS
+ignore=CVS, migrations
 
 # Pickle collected data for later comparisons.
 persistent=yes
@@ -33,7 +33,11 @@ load-plugins=
 # can either give multiple identifier separated by comma (,) or put this option
 # multiple time (only on the command line, not in the configuration file where
 # it should appear only once).
-disable=E1102,W0142
+disable=
+# W0141: Used builtin function 'map'
+# W0142: Used * or ** magic
+# R0903: Too few public methods (1/2)
+    W0141,W0142,R0903
 
 
 [REPORTS]
@@ -43,7 +47,7 @@ disable=E1102,W0142
 output-format=text
 
 # Include message's id in output
-include-ids=no
+include-ids=yes
 
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
@@ -97,7 +101,7 @@ bad-functions=map,filter,apply,input
 module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 
 # Regular expression which should only match correct module level names
-const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__)|log|urlpatterns)$
 
 # Regular expression which should only match correct class names
 class-rgx=[A-Z_][a-zA-Z0-9]+$
@@ -106,7 +110,7 @@ class-rgx=[A-Z_][a-zA-Z0-9]+$
 function-rgx=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression which should only match correct method names
-method-rgx=[a-z_][a-z0-9_]{2,30}$
+method-rgx=([a-z_][a-z0-9_]{2,60}|setUp|set[Uu]pClass|tearDown|tear[Dd]ownClass|assert[A-Z]\w*)$
 
 # Regular expression which should only match correct instance attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$

cms/djangoapps/contentstore/views.py

@@ -643,7 +643,7 @@ def delete_item(request):
         modulestore('direct').delete_item(item.location)
 
     # cdodge: we need to remove our parent's pointer to us so that it is no longer dangling
-
+    if delete_all_versions:
         parent_locs = modulestore('direct').get_parent_locations(item_loc, None)
 
         for parent_loc in parent_locs:

common/djangoapps/course_groups/cohorts.py

@@ -120,7 +120,8 @@ def get_cohort(user, course_id):
         return None
 
     choices = course.auto_cohort_groups
-    if len(choices) == 0:
+    n = len(choices)
+    if n == 0:
         # Nowhere to put user
         log.warning("Course %s is auto-cohorted, but there are no"
                     " auto_cohort_groups specified",
@@ -128,7 +129,14 @@ def get_cohort(user, course_id):
         return None
 
     # Put user in a random group, creating it if needed
-    group_name = random.choice(choices)
+    choice = random.randrange(0, n)
+    group_name = choices[choice]
+
+    # Victor: we are seeing very strange behavior on prod, where almost all users
+    # end up in the same group.  Log at INFO to try to figure out what's going on.
+    log.info("DEBUG: adding user {0} to cohort {1}.  choice={2}".format(
+        user, group_name,choice))
+
     group, created = CourseUserGroup.objects.get_or_create(
         course_id=course_id,
         group_type=CourseUserGroup.COHORT,

common/djangoapps/course_groups/tests/tests.py

@@ -6,7 +6,7 @@ from django.test.utils import override_settings
 
 from course_groups.models import CourseUserGroup
 from course_groups.cohorts import (get_cohort, get_course_cohorts,
-                                   is_commentable_cohorted)
+                                   is_commentable_cohorted, get_cohort_by_name)
 
 from xmodule.modulestore.django import modulestore, _MODULESTORES
 
@@ -180,6 +180,37 @@ class TestCohorts(django.test.TestCase):
                           "user2 should still be in originally placed cohort")
 
 
+    def test_auto_cohorting_randomization(self):
+        """
+        Make sure get_cohort() randomizes properly.
+        """
+        course = modulestore().get_course("edX/toy/2012_Fall")
+        self.assertEqual(course.id, "edX/toy/2012_Fall")
+        self.assertFalse(course.is_cohorted)
+
+        groups = ["group_{0}".format(n) for n in range(5)]
+        self.config_course_cohorts(course, [], cohorted=True,
+                                   auto_cohort=True,
+                                   auto_cohort_groups=groups)
+
+        # Assign 100 users to cohorts
+        for i in range(100):
+            user = User.objects.create(username="test_{0}".format(i),
+                                       email="a@b{0}.com".format(i))
+            get_cohort(user, course.id)
+
+        # Now make sure that the assignment was at least vaguely random:
+        # each cohort should have at least 1, and fewer than 50 students.
+        # (with 5 groups, probability of 0 users in any group is about
+        # .8**100= 2.0e-10)
+        for cohort_name in groups:
+            cohort = get_cohort_by_name(course.id, cohort_name)
+            num_users = cohort.users.count()
+            self.assertGreater(num_users, 1)
+            self.assertLess(num_users, 50)
+
+
+
     def test_get_course_cohorts(self):
         course1_id = 'a/b/c'
         course2_id = 'e/f/g'

common/lib/xmodule/xmodule/combined_open_ended_module.py

@@ -10,7 +10,6 @@ from xmodule.open_ended_grading_classes.combined_open_ended_modulev1 import Comb
 
 log = logging.getLogger("mitx.courseware")
 
-
 VERSION_TUPLES = (
     ('1', CombinedOpenEndedV1Descriptor, CombinedOpenEndedV1Module),
 )
@@ -18,6 +17,7 @@ VERSION_TUPLES = (
 DEFAULT_VERSION = 1
 DEFAULT_VERSION = str(DEFAULT_VERSION)
 
+
 class CombinedOpenEndedModule(XModule):
     """
     This is a module that encapsulates all open ended grading (self assessment, peer assessment, etc).
@@ -129,13 +129,15 @@ class CombinedOpenEndedModule(XModule):
             version_index = versions.index(self.version)
 
         static_data = {
-            'rewrite_content_links' : self.rewrite_content_links,
+            'rewrite_content_links': self.rewrite_content_links,
         }
 
         self.child_descriptor = descriptors[version_index](self.system)
-        self.child_definition = descriptors[version_index].definition_from_xml(etree.fromstring(definition['data']), self.system)
+        self.child_definition = descriptors[version_index].definition_from_xml(etree.fromstring(definition['data']),
+                                                                               self.system)
         self.child_module = modules[version_index](self.system, location, self.child_definition, self.child_descriptor,
-            instance_state = json.dumps(instance_state), metadata = self.metadata, static_data= static_data)
+                                                   instance_state=json.dumps(instance_state), metadata=self.metadata,
+                                                   static_data=static_data)
 
     def get_html(self):
         return self.child_module.get_html()

common/lib/xmodule/xmodule/foldit_module.py

@@ -86,7 +86,10 @@ class FolditModule(XModule):
         """
         from foldit.models import Score
 
-        return [(e['username'], e['score']) for e in Score.get_tops_n(10)]
+        leaders = [(e['username'], e['score']) for e in Score.get_tops_n(10)]
+        leaders.sort(key=lambda x: x[1])
+
+        return leaders
 
     def get_html(self):
         """

common/lib/xmodule/xmodule/open_ended_grading_classes/controller_query_service.py

@@ -8,6 +8,7 @@ class ControllerQueryService(GradingService):
     """
     Interface to staff grading backend.
     """
+
     def __init__(self, config, system):
         config['system'] = system
         super(ControllerQueryService, self).__init__(config)
@@ -75,15 +76,16 @@ class ControllerQueryService(GradingService):
         response = self.post(self.take_action_on_flags_url, params)
         return response
 
+
 def convert_seconds_to_human_readable(seconds):
     if seconds < 60:
         human_string = "{0} seconds".format(seconds)
     elif seconds < 60 * 60:
-        human_string = "{0} minutes".format(round(seconds/60,1))
-    elif seconds < (24*60*60):
-        human_string = "{0} hours".format(round(seconds/(60*60),1))
+        human_string = "{0} minutes".format(round(seconds / 60, 1))
+    elif seconds < (24 * 60 * 60):
+        human_string = "{0} hours".format(round(seconds / (60 * 60), 1))
     else:
-        human_string = "{0} days".format(round(seconds/(60*60*24),1))
+        human_string = "{0} days".format(round(seconds / (60 * 60 * 24), 1))
 
     eta_string = "{0}".format(human_string)
     return eta_string

common/lib/xmodule/xmodule/open_ended_grading_classes/grading_service_module.py

@@ -19,6 +19,7 @@ class GradingService(object):
     """
     Interface to staff grading backend.
     """
+
     def __init__(self, config):
         self.username = config['username']
         self.password = config['password']

common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_image_submission.py

@@ -5,6 +5,7 @@ to send them to S3.
 
 try:
     from PIL import Image
+
     ENABLE_PIL = True
 except:
     ENABLE_PIL = False
@@ -51,6 +52,7 @@ class ImageProperties(object):
     """
     Class to check properties of an image and to validate if they are allowed.
     """
+
     def __init__(self, image_data):
         """
         Initializes class variables
@@ -141,6 +143,7 @@ class URLProperties(object):
     Checks to see if a URL points to acceptable content.  Added to check if students are submitting reasonable
     links to the peer grading image functionality of the external grading service.
     """
+
     def __init__(self, url_string):
         self.url_string = url_string
 
@@ -252,7 +255,8 @@ def upload_to_s3(file_to_upload, keyname, s3_interface):
         return True, public_url
     except:
         #This is a dev_facing_error
-        error_message = "Could not connect to S3 to upload peer grading image.  Trying to utilize bucket: {0}".format(bucketname.lower())
+        error_message = "Could not connect to S3 to upload peer grading image.  Trying to utilize bucket: {0}".format(
+            bucketname.lower())
         log.error(error_message)
         return False, error_message
 

common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_module.py

@@ -77,7 +77,6 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             self.send_to_grader(self.latest_answer(), system)
             self.created = False
 
-
     def _parse(self, oeparam, prompt, rubric, system):
         '''
         Parse OpenEndedResponse XML:
@@ -104,7 +103,9 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             # response types)
         except TypeError, ValueError:
             #This is a dev_facing_error
-            log.exception("Grader payload from external open ended grading server is not a json object! Object: {0}".format(grader_payload))
+            log.exception(
+                "Grader payload from external open ended grading server is not a json object! Object: {0}".format(
+                    grader_payload))
 
         self.initial_display = find_with_default(oeparam, 'initial_display', '')
         self.answer = find_with_default(oeparam, 'answer_display', 'No answer given.')
@@ -148,7 +149,9 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
         for tag in ['feedback', 'submission_id', 'grader_id', 'score']:
             if tag not in survey_responses:
                 #This is a student_facing_error
-                return {'success': False, 'msg': "Could not find needed tag {0} in the survey responses.  Please try submitting again.".format(tag)}
+                return {'success': False,
+                        'msg': "Could not find needed tag {0} in the survey responses.  Please try submitting again.".format(
+                            tag)}
         try:
             submission_id = int(survey_responses['submission_id'])
             grader_id = int(survey_responses['grader_id'])
@@ -266,7 +269,6 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
 
         return True
 
-
     def get_answers(self):
         """
         Gets and shows the answer for this problem.
@@ -300,7 +302,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
 
         # We want to display available feedback in a particular order.
         # This dictionary specifies which goes first--lower first.
-        priorities = {  # These go at the start of the feedback
+        priorities = {# These go at the start of the feedback
                       'spelling': 0,
                       'grammar': 1,
                       # needs to be after all the other feedback
@@ -411,7 +413,6 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
 
         return feedback_template, rubric_scores
 
-
     def _parse_score_msg(self, score_msg, system, join_feedback=True):
         """
          Grader reply is a JSON-dump of the following dict
@@ -437,12 +438,12 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             'valid': False,
             'score': 0,
             'feedback': '',
-            'rubric_scores' : [[0]],
-            'grader_types' : [''],
-            'feedback_items' : [''],
-            'feedback_dicts' : [{}],
-            'grader_ids' : [0],
-            'submission_ids' : [0],
+            'rubric_scores': [[0]],
+            'grader_types': [''],
+            'feedback_items': [''],
+            'feedback_dicts': [{}],
+            'grader_ids': [0],
+            'submission_ids': [0],
         }
         try:
             score_result = json.loads(score_msg)
@@ -527,12 +528,12 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             'valid': True,
             'score': score,
             'feedback': feedback,
-            'rubric_scores' : rubric_scores,
-            'grader_types' : grader_types,
-            'feedback_items' : feedback_items,
-            'feedback_dicts' : feedback_dicts,
-            'grader_ids' : grader_ids,
-            'submission_ids' : submission_ids,
+            'rubric_scores': rubric_scores,
+            'grader_types': grader_types,
+            'feedback_items': feedback_items,
+            'feedback_dicts': feedback_dicts,
+            'grader_ids': grader_ids,
+            'submission_ids': submission_ids,
         }
 
     def latest_post_assessment(self, system, short_feedback=False, join_feedback=True):
@@ -585,7 +586,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             #This is a dev_facing_error
             log.error("Cannot find {0} in handlers in handle_ajax function for open_ended_module.py".format(dispatch))
             #This is a dev_facing_error
-            return json.dumps({'error': 'Error handling action.  Please try again.', 'success' : False})
+            return json.dumps({'error': 'Error handling action.  Please try again.', 'success': False})
 
         before = self.get_progress()
         d = handlers[dispatch](get, system)
@@ -679,7 +680,6 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             correct = ""
             previous_answer = self.initial_display
 
-
         context = {
             'prompt': self.prompt,
             'previous_answer': previous_answer,
@@ -692,7 +692,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             'child_type': 'openended',
             'correct': correct,
             'accept_file_upload': self.accept_file_upload,
-            'eta_message' : eta_string,
+            'eta_message': eta_string,
         }
         html = system.render_template('{0}/open_ended.html'.format(self.TEMPLATE_DIR), context)
         return html
@@ -723,7 +723,9 @@ class OpenEndedDescriptor(XmlDescriptor, EditingDescriptor):
         for child in ['openendedparam']:
             if len(xml_object.xpath(child)) != 1:
                 #This is a staff_facing_error
-                raise ValueError("Open Ended definition must include exactly one '{0}' tag. Contact the learning sciences group for assistance.".format(child))
+                raise ValueError(
+                    "Open Ended definition must include exactly one '{0}' tag. Contact the learning sciences group for assistance.".format(
+                        child))
 
         def parse(k):
             """Assumes that xml_object has child k"""

common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py

@@ -108,13 +108,12 @@ class OpenEndedChild(object):
         self._max_score = static_data['max_score']
         if system.open_ended_grading_interface:
             self.peer_gs = PeerGradingService(system.open_ended_grading_interface, system)
-            self.controller_qs = controller_query_service.ControllerQueryService(system.open_ended_grading_interface,system)
+            self.controller_qs = controller_query_service.ControllerQueryService(system.open_ended_grading_interface,
+                                                                                 system)
         else:
             self.peer_gs = MockPeerGradingService()
             self.controller_qs = None
 
-
-
         self.system = system
 
         self.location_string = location
@@ -152,7 +151,8 @@ class OpenEndedChild(object):
             return True, {
                 'success': False,
                 #This is a student_facing_error
-                'error': 'You have attempted this problem {0} times.  You are allowed {1} attempts.'.format(self.attempts, self.max_attempts)
+                'error': 'You have attempted this problem {0} times.  You are allowed {1} attempts.'.format(
+                    self.attempts, self.max_attempts)
             }
         else:
             return False, {}
@@ -308,7 +308,7 @@ class OpenEndedChild(object):
         @return: Boolean correct.
         """
         correct = False
-        if(isinstance(score, (int, long, float, complex))):
+        if (isinstance(score, (int, long, float, complex))):
             score_ratio = int(score) / float(self.max_score())
             correct = (score_ratio >= 0.66)
         return correct
@@ -342,7 +342,8 @@ class OpenEndedChild(object):
 
             try:
                 image_data.seek(0)
-                success, s3_public_url = open_ended_image_submission.upload_to_s3(image_data, image_key, self.s3_interface)
+                success, s3_public_url = open_ended_image_submission.upload_to_s3(image_data, image_key,
+                                                                                  self.s3_interface)
             except:
                 log.exception("Could not upload image to S3.")
 
@@ -454,16 +455,18 @@ class OpenEndedChild(object):
             success = True
         except:
             #This is a dev_facing_error
-            log.error("Could not contact external open ended graders for location {0} and student {1}".format(self.location_string,student_id))
+            log.error("Could not contact external open ended graders for location {0} and student {1}".format(
+                self.location_string, student_id))
             #This is a student_facing_error
             error_message = "Could not contact the graders.  Please notify course staff."
             return success, allowed_to_submit, error_message
-        if count_graded>=count_required:
+        if count_graded >= count_required:
             return success, allowed_to_submit, ""
         else:
             allowed_to_submit = False
             #This is a student_facing_error
-            error_message = error_string.format(count_required-count_graded, count_graded, count_required, student_sub_count)
+            error_message = error_string.format(count_required - count_graded, count_graded, count_required,
+                                                student_sub_count)
             return success, allowed_to_submit, error_message
 
     def get_eta(self):
@@ -478,7 +481,7 @@ class OpenEndedChild(object):
 
         success = response['success']
         if isinstance(success, basestring):
-            success = (success.lower()=="true")
+            success = (success.lower() == "true")
 
         if success:
             eta = controller_query_service.convert_seconds_to_human_readable(response['eta'])
@@ -487,6 +490,3 @@ class OpenEndedChild(object):
             eta_string = ""
 
         return eta_string
-
-
-

common/lib/xmodule/xmodule/open_ended_grading_classes/peer_grading_service.py

@@ -14,6 +14,7 @@ class PeerGradingService(GradingService):
     """
     Interface with the grading controller for peer grading
     """
+
     def __init__(self, config, system):
         config['system'] = system
         super(PeerGradingService, self).__init__(config)
@@ -39,7 +40,8 @@ class PeerGradingService(GradingService):
                             {'location': problem_location, 'grader_id': grader_id})
         return self.try_to_decode(self._render_rubric(response))
 
-    def save_grade(self, location, grader_id, submission_id, score, feedback, submission_key, rubric_scores, submission_flagged):
+    def save_grade(self, location, grader_id, submission_id, score, feedback, submission_key, rubric_scores,
+                   submission_flagged):
         data = {'grader_id': grader_id,
                 'submission_id': submission_id,
                 'score': score,
@@ -89,6 +91,7 @@ class PeerGradingService(GradingService):
             pass
         return text
 
+
 """
 This is a mock peer grading service that can be used for unit tests
 without making actual service calls to the grading controller

common/lib/xmodule/xmodule/open_ended_grading_classes/self_assessment_module.py

@@ -73,7 +73,6 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
         html = system.render_template('{0}/self_assessment_prompt.html'.format(self.TEMPLATE_DIR), context)
         return html
 
-
     def handle_ajax(self, dispatch, get, system):
         """
         This is called by courseware.module_render, to handle an AJAX call.
@@ -95,7 +94,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
             #This is a dev_facing_error
             log.error("Cannot find {0} in handlers in handle_ajax function for open_ended_module.py".format(dispatch))
             #This is a dev_facing_error
-            return json.dumps({'error': 'Error handling action.  Please try again.', 'success' : False})
+            return json.dumps({'error': 'Error handling action.  Please try again.', 'success': False})
 
         before = self.get_progress()
         d = handlers[dispatch](get, system)
@@ -159,7 +158,6 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
 
         return system.render_template('{0}/self_assessment_hint.html'.format(self.TEMPLATE_DIR), context)
 
-
     def save_answer(self, get, system):
         """
         After the answer is submitted, show the rubric.
@@ -224,7 +222,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
         try:
             score = int(get['assessment'])
             score_list = get.getlist('score_list[]')
-            for i in xrange(0,len(score_list)):
+            for i in xrange(0, len(score_list)):
                 score_list[i] = int(score_list[i])
         except ValueError:
             #This is a dev_facing_error
@@ -305,7 +303,9 @@ class SelfAssessmentDescriptor(XmlDescriptor, EditingDescriptor):
         for child in expected_children:
             if len(xml_object.xpath(child)) != 1:
                 #This is a staff_facing_error
-                raise ValueError("Self assessment definition must include exactly one '{0}' tag. Contact the learning sciences group for assistance.".format(child))
+                raise ValueError(
+                    "Self assessment definition must include exactly one '{0}' tag. Contact the learning sciences group for assistance.".format(
+                        child))
 
         def parse(k):
             """Assumes that xml_object has child k"""

common/lib/xmodule/xmodule/peer_grading_module.py

@@ -53,12 +53,11 @@ class PeerGradingModule(XModule):
         #We need to set the location here so the child modules can use it
         system.set('location', location)
         self.system = system
-        if(self.system.open_ended_grading_interface):
+        if (self.system.open_ended_grading_interface):
             self.peer_gs = PeerGradingService(self.system.open_ended_grading_interface, self.system)
         else:
             self.peer_gs = MockPeerGradingService()
 
-
         self.use_for_single_location = self.metadata.get('use_for_single_location', USE_FOR_SINGLE_LOCATION)
         if isinstance(self.use_for_single_location, basestring):
             self.use_for_single_location = (self.use_for_single_location in TRUE_DICT)
@@ -90,7 +89,6 @@ class PeerGradingModule(XModule):
 
         self.display_due_date = self.timeinfo.display_due_date
 
-
         self.ajax_url = self.system.ajax_url
         if not self.ajax_url.endswith("/"):
             self.ajax_url = self.ajax_url + "/"
@@ -154,7 +152,7 @@ class PeerGradingModule(XModule):
             #This is a dev_facing_error
             log.error("Cannot find {0} in handlers in handle_ajax function for open_ended_module.py".format(dispatch))
             #This is a dev_facing_error
-            return json.dumps({'error': 'Error handling action.  Please try again.', 'success' : False})
+            return json.dumps({'error': 'Error handling action.  Please try again.', 'success': False})
 
         d = handlers[dispatch](get)
 
@@ -191,7 +189,8 @@ class PeerGradingModule(XModule):
         except:
             success, response = self.query_data_for_location()
             if not success:
-                log.exception("No instance data found and could not get data from controller for loc {0} student {1}".format(
+                log.exception(
+                    "No instance data found and could not get data from controller for loc {0} student {1}".format(
                         self.system.location.url(), self.system.anonymous_student_id
                     ))
                 return None
@@ -271,7 +270,8 @@ class PeerGradingModule(XModule):
             error: if there was an error in the submission, this is the error message
         """
 
-        required = set(['location', 'submission_id', 'submission_key', 'score', 'feedback', 'rubric_scores[]', 'submission_flagged'])
+        required = set(['location', 'submission_id', 'submission_key', 'score', 'feedback', 'rubric_scores[]',
+                        'submission_flagged'])
         success, message = self._check_required(get, required)
         if not success:
             return self._err_response(message)
@@ -430,7 +430,9 @@ class PeerGradingModule(XModule):
             return response
         except GradingServiceError:
             #This is a dev_facing_error
-            log.exception("Error saving calibration grade, location: {0}, submission_id: {1}, submission_key: {2}, grader_id: {3}".format(location, submission_id, submission_key, grader_id))
+            log.exception(
+                "Error saving calibration grade, location: {0}, submission_id: {1}, submission_key: {2}, grader_id: {3}".format(
+                    location, submission_id, submission_key, grader_id))
             #This is a student_facing_error
             return self._err_response('There was an error saving your score.  Please notify course staff.')
 
@@ -508,7 +510,6 @@ class PeerGradingModule(XModule):
                 problem['due'] = None
                 problem['closed'] = False
 
-
         ajax_url = self.ajax_url
         html = self.system.render_template('peer_grading/peer_grading.html', {
             'course_id': self.system.course_id,
@@ -531,7 +532,8 @@ class PeerGradingModule(XModule):
             if not self.use_for_single_location:
                 #This is an error case, because it must be set to use a single location to be called without get parameters
                 #This is a dev_facing_error
-                log.error("Peer grading problem in peer_grading_module called with no get parameters, but use_for_single_location is False.")
+                log.error(
+                    "Peer grading problem in peer_grading_module called with no get parameters, but use_for_single_location is False.")
                 return {'html': "", 'success': False}
             problem_location = self.link_to_location
 
@@ -596,7 +598,9 @@ class PeerGradingDescriptor(XmlDescriptor, EditingDescriptor):
         for child in expected_children:
             if len(xml_object.xpath(child)) == 0:
                 #This is a staff_facing_error
-                raise ValueError("Peer grading definition must include at least one '{0}' tag.  Contact the learning sciences group for assistance.".format(child))
+                raise ValueError(
+                    "Peer grading definition must include at least one '{0}' tag.  Contact the learning sciences group for assistance.".format(
+                        child))
 
         def parse_task(k):
             """Assumes that xml_object has child k"""

common/lib/xmodule/xmodule/tests/test_combined_open_ended.py

@@ -14,6 +14,7 @@ from datetime import datetime
 from . import test_system
 
 import test_util_open_ended
+
 """
 Tests for the various pieces of the CombinedOpenEndedGrading system
 
@@ -46,9 +47,9 @@ class OpenEndedChildTest(unittest.TestCase):
         'display_name': 'Name',
         'accept_file_upload': False,
         'close_date': None,
-            's3_interface' : "",
-            'open_ended_grading_interface' : {},
-            'skip_basic_checks' : False,
+        's3_interface': "",
+        'open_ended_grading_interface': {},
+        'skip_basic_checks': False,
     }
     definition = Mock()
     descriptor = Mock()
@@ -58,22 +59,18 @@ class OpenEndedChildTest(unittest.TestCase):
         self.openendedchild = OpenEndedChild(self.test_system, self.location,
                                              self.definition, self.descriptor, self.static_data, self.metadata)
 
-
     def test_latest_answer_empty(self):
         answer = self.openendedchild.latest_answer()
         self.assertEqual(answer, "")
 
-
     def test_latest_score_empty(self):
         answer = self.openendedchild.latest_score()
         self.assertEqual(answer, None)
 
-
     def test_latest_post_assessment_empty(self):
         answer = self.openendedchild.latest_post_assessment(self.test_system)
         self.assertEqual(answer, "")
 
-
     def test_new_history_entry(self):
         new_answer = "New Answer"
         self.openendedchild.new_history_entry(new_answer)
@@ -99,7 +96,6 @@ class OpenEndedChildTest(unittest.TestCase):
         score = self.openendedchild.latest_score()
         self.assertEqual(score, 4)
 
-
     def test_record_latest_post_assessment(self):
         new_answer = "New Answer"
         self.openendedchild.new_history_entry(new_answer)
@@ -124,13 +120,11 @@ class OpenEndedChildTest(unittest.TestCase):
         self.assertEqual(score['score'], new_score)
         self.assertEqual(score['total'], self.static_data['max_score'])
 
-
     def test_reset(self):
         self.openendedchild.reset(self.test_system)
         state = json.loads(self.openendedchild.get_instance_state())
         self.assertEqual(state['state'], OpenEndedChild.INITIAL)
 
-
     def test_is_last_response_correct(self):
         new_answer = "New Answer"
         self.openendedchild.new_history_entry(new_answer)
@@ -165,11 +159,11 @@ class OpenEndedModuleTest(unittest.TestCase):
         'max_score': max_score,
         'display_name': 'Name',
         'accept_file_upload': False,
-            'rewrite_content_links' : "",
+        'rewrite_content_links': "",
         'close_date': None,
-            's3_interface' : test_util_open_ended.S3_INTERFACE,
-            'open_ended_grading_interface' : test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
-            'skip_basic_checks' : False,
+        's3_interface': test_util_open_ended.S3_INTERFACE,
+        'open_ended_grading_interface': test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
+        'skip_basic_checks': False,
     }
 
     oeparam = etree.XML('''
@@ -188,7 +182,8 @@ class OpenEndedModuleTest(unittest.TestCase):
         self.test_system.location = self.location
         self.mock_xqueue = MagicMock()
         self.mock_xqueue.send_to_queue.return_value = (None, "Message")
-        self.test_system.xqueue = {'interface': self.mock_xqueue, 'callback_url': '/', 'default_queuename': 'testqueue', 'waittime': 1}
+        self.test_system.xqueue = {'interface': self.mock_xqueue, 'callback_url': '/', 'default_queuename': 'testqueue',
+                                   'waittime': 1}
         self.openendedmodule = OpenEndedModule(self.test_system, self.location,
                                                self.definition, self.descriptor, self.static_data, self.metadata)
 
@@ -301,12 +296,12 @@ class CombinedOpenEndedModuleTest(unittest.TestCase):
         'rubric': rubric,
         'max_score': max_score,
         'display_name': 'Name',
-            'accept_file_upload' : False,
-            'rewrite_content_links' : "",
-            'close_date' : "",
-            's3_interface' : test_util_open_ended.S3_INTERFACE,
-            'open_ended_grading_interface' : test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
-            'skip_basic_checks' : False,
+        'accept_file_upload': False,
+        'rewrite_content_links': "",
+        'close_date': "",
+        's3_interface': test_util_open_ended.S3_INTERFACE,
+        'open_ended_grading_interface': test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
+        'skip_basic_checks': False,
     }
 
     oeparam = etree.XML('''
@@ -344,7 +339,7 @@ class CombinedOpenEndedModuleTest(unittest.TestCase):
                                                     self.location,
                                                     self.definition,
                                                     self.descriptor,
-                                                static_data = self.static_data, 
+                                                    static_data=self.static_data,
                                                     metadata=self.metadata)
 
     def test_get_tag_name(self):

common/lib/xmodule/xmodule/tests/test_self_assessment.py

@@ -10,8 +10,8 @@ from . import test_system
 
 import test_util_open_ended
 
-class SelfAssessmentTest(unittest.TestCase):
 
+class SelfAssessmentTest(unittest.TestCase):
     rubric = '''<rubric><rubric>
         <category>
         <description>Response Quality</description>
@@ -48,9 +48,9 @@ class SelfAssessmentTest(unittest.TestCase):
             'display_name': "Name",
             'accept_file_upload': False,
             'close_date': None,
-                's3_interface' : test_util_open_ended.S3_INTERFACE,
-                'open_ended_grading_interface' : test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
-                'skip_basic_checks' : False,
+            's3_interface': test_util_open_ended.S3_INTERFACE,
+            'open_ended_grading_interface': test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE,
+            'skip_basic_checks': False,
         }
 
         self.module = SelfAssessmentModule(test_system(), self.location,
@@ -64,13 +64,14 @@ class SelfAssessmentTest(unittest.TestCase):
 
     def test_self_assessment_flow(self):
         responses = {'assessment': '0', 'score_list[]': ['0', '0']}
+
         def get_fake_item(name):
             return responses[name]
 
-        def get_data_for_location(self,location,student):
+        def get_data_for_location(self, location, student):
             return {
-            'count_graded' : 0,
-            'count_required' : 0,
+                'count_graded': 0,
+                'count_required': 0,
                 'student_sub_count': 0,
             }
 
@@ -89,7 +90,6 @@ class SelfAssessmentTest(unittest.TestCase):
         self.module.save_assessment(mock_query_dict, self.module.system)
         self.assertEqual(self.module.state, self.module.DONE)
 
-
         d = self.module.reset({})
         self.assertTrue(d['success'])
         self.assertEqual(self.module.state, self.module.INITIAL)

common/lib/xmodule/xmodule/tests/test_util_open_ended.py

 OPEN_ENDED_GRADING_INTERFACE = {
-    'url' : 'http://127.0.0.1:3033/',
-    'username' : 'incorrect',
-    'password' : 'incorrect',
-    'staff_grading' : 'staff_grading',
-    'peer_grading' : 'peer_grading',
-    'grading_controller' : 'grading_controller'
+    'url': 'http://127.0.0.1:3033/',
+    'username': 'incorrect',
+    'password': 'incorrect',
+    'staff_grading': 'staff_grading',
+    'peer_grading': 'peer_grading',
+    'grading_controller': 'grading_controller'
 }
 
 S3_INTERFACE = {
-    'aws_access_key' : "",
-    'aws_secret_key' : "",
-    "aws_bucket_name" : "",
+    'aws_access_key': "",
+    'aws_secret_key': "",
+    "aws_bucket_name": "",
 }
\ No newline at end of file

jenkins/test.sh

@@ -32,10 +32,11 @@ if [ ! -d /mnt/virtualenvs/"$JOB_NAME" ]; then
     virtualenv /mnt/virtualenvs/"$JOB_NAME"
 fi
 
+export PIP_DOWNLOAD_CACHE=/mnt/pip-cache
+
 source /mnt/virtualenvs/"$JOB_NAME"/bin/activate
 pip install -q -r pre-requirements.txt
-pip install -q -r test-requirements.txt
-yes w | pip install -q -r requirements.txt
+yes w | pip install -q -r test-requirements.txt -r requirements.txt
 
 rake clobber
 rake pep8

lms/djangoapps/courseware/management/commands/regrade_partial.py

+'''
+This is a one-off command aimed at fixing a temporary problem encountered where partial credit was awarded for
+code problems, but the resulting score (or grade) was mistakenly set to zero because of a bug in
+CorrectMap.get_npoints().
+'''
+
+import json
+import logging
+from optparse import make_option
+
+from django.core.management.base import BaseCommand
+
+from courseware.models import StudentModule
+from capa.correctmap import CorrectMap
+
+LOG = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    '''
+    The fix here is to recalculate the score/grade based on the partial credit.
+    To narrow down the set of problems that might need fixing, the StudentModule
+    objects to be checked is filtered down to those:
+
+        created < '2013-03-08 15:45:00' (the problem must have been answered before the fix was installed,
+                                         on Prod and Edge)
+        modified > '2013-03-07 20:18:00' (the problem must have been visited after the bug was introduced)
+        state like '%"npoints": 0.%' (the problem must have some form of partial credit).
+    '''
+
+    num_visited = 0
+    num_changed = 0
+
+    option_list = BaseCommand.option_list + (
+        make_option('--save',
+                    action='store_true',
+                    dest='save_changes',
+                    default=False,
+                    help='Persist the changes that were encountered.  If not set, no changes are saved.'), )
+
+    def fix_studentmodules(self, save_changes):
+        '''Identify the list of StudentModule objects that might need fixing, and then fix each one'''
+        modules = StudentModule.objects.filter(modified__gt='2013-03-07 20:18:00',
+                                               created__lt='2013-03-08 15:45:00',
+                                               state__contains='"npoints": 0.')
+
+        for module in modules:
+            self.fix_studentmodule_grade(module, save_changes)
+
+    def fix_studentmodule_grade(self, module, save_changes):
+        ''' Fix the grade assigned to a StudentModule'''
+        module_state = module.state
+        if module_state is None:
+            # not likely, since we filter on it.  But in general...
+            LOG.info("No state found for {type} module {id} for student {student} in course {course_id}"
+                     .format(type=module.module_type, id=module.module_state_key,
+                             student=module.student.username, course_id=module.course_id))
+            return
+
+        state_dict = json.loads(module_state)
+        self.num_visited += 1
+
+        # LoncapaProblem.get_score() checks student_answers -- if there are none, we will return a grade of 0
+        # Check that this is the case, but do so sooner, before we do any of the other grading work.
+        student_answers = state_dict['student_answers']
+        if (not student_answers) or len(student_answers) == 0:
+            # we should not have a grade here:
+            if module.grade != 0:
+                LOG.error("No answer found but grade {grade} exists for {type} module {id} for student {student} "
+                          "in course {course_id}".format(grade=module.grade,
+                                                         type=module.module_type, id=module.module_state_key,
+                                                         student=module.student.username, course_id=module.course_id))
+            else:
+                LOG.debug("No answer and no grade found for {type} module {id} for student {student} "
+                          "in course {course_id}".format(grade=module.grade,
+                                                         type=module.module_type, id=module.module_state_key,
+                                                         student=module.student.username, course_id=module.course_id))
+            return
+
+        # load into a CorrectMap, as done in LoncapaProblem.__init__():
+        correct_map = CorrectMap()
+        if 'correct_map' in state_dict:
+            correct_map.set_dict(state_dict['correct_map'])
+
+        # calculate score the way LoncapaProblem.get_score() works, by deferring to
+        # CorrectMap's get_npoints implementation.
+        correct = 0
+        for key in correct_map:
+            correct += correct_map.get_npoints(key)
+
+        if module.grade == correct:
+            # nothing to change
+            LOG.debug("Grade matches for {type} module {id} for student {student} in course {course_id}"
+                      .format(type=module.module_type, id=module.module_state_key,
+                              student=module.student.username, course_id=module.course_id))
+        elif save_changes:
+            # make the change
+            LOG.info("Grade changing from {0} to {1} for {type} module {id} for student {student} "
+                     "in course {course_id}".format(module.grade, correct,
+                                                    type=module.module_type, id=module.module_state_key,
+                                                    student=module.student.username, course_id=module.course_id))
+            module.grade = correct
+            module.save()
+            self.num_changed += 1
+        else:
+            # don't make the change, but log that the change would be made
+            LOG.info("Grade would change from {0} to {1} for {type} module {id} for student {student} "
+                     "in course {course_id}".format(module.grade, correct,
+                                                    type=module.module_type, id=module.module_state_key,
+                                                    student=module.student.username, course_id=module.course_id))
+            self.num_changed += 1
+
+    def handle(self, **options):
+        '''Handle management command request'''
+
+        save_changes = options['save_changes']
+
+        LOG.info("Starting run: save_changes = {0}".format(save_changes))
+
+        self.fix_studentmodules(save_changes)
+
+        LOG.info("Finished run:  updating {0} of {1} modules".format(self.num_changed, self.num_visited))

lms/djangoapps/foldit/models.py

@@ -59,7 +59,7 @@ class Score(models.Model):
         scores = Score.objects \
             .filter(puzzle_id__in=puzzles) \
             .annotate(total_score=models.Sum('best_score')) \
-            .order_by('-total_score')[:n]
+            .order_by('total_score')[:n]
         num = len(puzzles)
 
         return [{'username': s.user.username,

lms/djangoapps/foldit/tests.py

@@ -143,11 +143,12 @@ class FolditTestCase(TestCase):
     def test_SetPlayerPuzzleScores_manyplayers(self):
         """
         Check that when we send scores from multiple users, the correct order
-        of scores is displayed.
+        of scores is displayed. Note that, before being processed by
+        display_score, lower scores are better.
         """
         puzzle_id = ['1']
-        player1_score = 0.07
-        player2_score = 0.08
+        player1_score = 0.08
+        player2_score = 0.02
         response1 = self.make_puzzle_score_request(puzzle_id, player1_score,
                 self.user)
 
@@ -164,8 +165,12 @@ class FolditTestCase(TestCase):
         self.assertEqual(len(top_10), 2)
 
         # Top score should be player2_score. Second should be player1_score
-        self.assertEqual(top_10[0]['score'], Score.display_score(player2_score))
-        self.assertEqual(top_10[1]['score'], Score.display_score(player1_score))
+        self.assertAlmostEqual(top_10[0]['score'],
+                Score.display_score(player2_score),
+                delta=0.5)
+        self.assertAlmostEqual(top_10[1]['score'],
+                Score.display_score(player1_score),
+                delta=0.5)
 
         # Top score user should be self.user2.username
         self.assertEqual(top_10[0]['username'], self.user2.username)

lms/djangoapps/open_ended_grading/open_ended_notifications.py

@@ -22,7 +22,7 @@ NOTIFICATION_TYPES = (
     ('staff_needs_to_grade', 'staff_grading', 'Staff Grading'),
     ('new_student_grading_to_view', 'open_ended_problems', 'Problems you have submitted'),
     ('flagged_submissions_exist', 'open_ended_flagged_problems', 'Flagged Submissions')
-    )
+)
 
 
 def staff_grading_notifications(course, user):
@@ -46,7 +46,9 @@ def staff_grading_notifications(course, user):
         #Non catastrophic error, so no real action
         notifications = {}
         #This is a dev_facing_error
-        log.info("Problem with getting notifications from staff grading service for course {0} user {1}.".format(course_id, student_id))
+        log.info(
+            "Problem with getting notifications from staff grading service for course {0} user {1}.".format(course_id,
+                                                                                                            student_id))
 
     if pending_grading:
         img_path = "/static/images/grading_notification.png"
@@ -80,7 +82,9 @@ def peer_grading_notifications(course, user):
         #Non catastrophic error, so no real action
         notifications = {}
         #This is a dev_facing_error
-        log.info("Problem with getting notifications from peer grading service for course {0} user {1}.".format(course_id, student_id))
+        log.info(
+            "Problem with getting notifications from peer grading service for course {0} user {1}.".format(course_id,
+                                                                                                           student_id))
 
     if pending_grading:
         img_path = "/static/images/grading_notification.png"
@@ -105,7 +109,9 @@ def combined_notifications(course, user):
         return notification_dict
 
     min_time_to_query = user.last_login
-    last_module_seen = StudentModule.objects.filter(student=user, course_id=course_id, modified__gt=min_time_to_query).values('modified').order_by('-modified')
+    last_module_seen = StudentModule.objects.filter(student=user, course_id=course_id,
+                                                    modified__gt=min_time_to_query).values('modified').order_by(
+        '-modified')
     last_module_seen_count = last_module_seen.count()
 
     if last_module_seen_count > 0:
@@ -117,7 +123,8 @@ def combined_notifications(course, user):
 
     img_path = ""
     try:
-        controller_response = controller_qs.check_combined_notifications(course.id, student_id, user_is_staff, last_time_viewed)
+        controller_response = controller_qs.check_combined_notifications(course.id, student_id, user_is_staff,
+                                                                         last_time_viewed)
         log.debug(controller_response)
         notifications = json.loads(controller_response)
         if notifications['success']:
@@ -127,7 +134,9 @@ def combined_notifications(course, user):
         #Non catastrophic error, so no real action
         notifications = {}
         #This is a dev_facing_error
-        log.exception("Problem with getting notifications from controller query service for course {0} user {1}.".format(course_id, student_id))
+        log.exception(
+            "Problem with getting notifications from controller query service for course {0} user {1}.".format(
+                course_id, student_id))
 
     if pending_grading:
         img_path = "/static/images/grading_notification.png"
@@ -151,7 +160,8 @@ def set_value_in_cache(student_id, course_id, notification_type, value):
 
 
 def create_key_name(student_id, course_id, notification_type):
-    key_name = "{prefix}{type}_{course}_{student}".format(prefix=KEY_PREFIX, type=notification_type, course=course_id, student=student_id)
+    key_name = "{prefix}{type}_{course}_{student}".format(prefix=KEY_PREFIX, type=notification_type, course=course_id,
+                                                          student=student_id)
     return key_name
 
 

lms/djangoapps/open_ended_grading/staff_grading.py

@@ -15,6 +15,7 @@ class StaffGrading(object):
     """
     Wrap up functionality for staff grading of submissions--interface exposes get_html, ajax views.
     """
+
     def __init__(self, course):
         self.course = course
 

lms/djangoapps/open_ended_grading/staff_grading_service.py

@@ -20,10 +20,12 @@ log = logging.getLogger(__name__)
 
 STAFF_ERROR_MESSAGE = 'Could not contact the external grading server.  Please contact the development team.  If you do not have a point of contact, you can contact Vik at vik@edx.org.'
 
+
 class MockStaffGradingService(object):
     """
     A simple mockup of a staff grading service, testing.
     """
+
     def __init__(self):
         self.cnt = 0
 
@@ -45,13 +47,16 @@ class MockStaffGradingService(object):
         return json.dumps({'success': True,
                            'problem_list': [
                                json.dumps({'location': 'i4x://MITx/3.091x/problem/open_ended_demo1',
-            'problem_name': "Problem 1", 'num_graded': 3, 'num_pending': 5, 'min_for_ml': 10}),
+                                           'problem_name': "Problem 1", 'num_graded': 3, 'num_pending': 5,
+                                           'min_for_ml': 10}),
                                json.dumps({'location': 'i4x://MITx/3.091x/problem/open_ended_demo2',
-            'problem_name': "Problem 2", 'num_graded': 1, 'num_pending': 5, 'min_for_ml': 10})
+                                           'problem_name': "Problem 2", 'num_graded': 1, 'num_pending': 5,
+                                           'min_for_ml': 10})
                            ]})
 
 
-    def save_grade(self, course_id, grader_id, submission_id, score, feedback, skipped, rubric_scores, submission_flagged):
+    def save_grade(self, course_id, grader_id, submission_id, score, feedback, skipped, rubric_scores,
+                   submission_flagged):
         return self.get_next(course_id, 'fake location', grader_id)
 
 
@@ -59,6 +64,7 @@ class StaffGradingService(GradingService):
     """
     Interface to staff grading backend.
     """
+
     def __init__(self, config):
         config['system'] = ModuleSystem(None, None, None, render_to_string, None)
         super(StaffGradingService, self).__init__(config)
@@ -114,7 +120,8 @@ class StaffGradingService(GradingService):
         return json.dumps(self._render_rubric(response))
 
 
-    def save_grade(self, course_id, grader_id, submission_id, score, feedback, skipped, rubric_scores, submission_flagged):
+    def save_grade(self, course_id, grader_id, submission_id, score, feedback, skipped, rubric_scores,
+                   submission_flagged):
         """
         Save a score and feedback for a submission.
 
@@ -297,7 +304,7 @@ def save_grade(request, course_id):
     if request.method != 'POST':
         raise Http404
 
-    required = set(['score', 'feedback', 'submission_id', 'location','submission_flagged', 'rubric_scores[]'])
+    required = set(['score', 'feedback', 'submission_id', 'location', 'submission_flagged', 'rubric_scores[]'])
     actual = set(request.POST.keys())
     missing = required - actual
     if len(missing) > 0:
@@ -307,7 +314,6 @@ def save_grade(request, course_id):
     grader_id = unique_id_for_user(request.user)
     p = request.POST
 
-
     location = p['location']
     skipped = 'skipped' in p
 
@@ -322,7 +328,9 @@ def save_grade(request, course_id):
                                                          p['submission_flagged'])
     except GradingServiceError:
         #This is a dev_facing_error
-        log.exception("Error saving grade in the staff grading interface in open ended grading.  Request: {0} Course ID: {1}".format(request, course_id))
+        log.exception(
+            "Error saving grade in the staff grading interface in open ended grading.  Request: {0} Course ID: {1}".format(
+                request, course_id))
         #This is a staff_facing_error
         return _err_response(STAFF_ERROR_MESSAGE)
 
@@ -330,13 +338,16 @@ def save_grade(request, course_id):
         result = json.loads(result_json)
     except ValueError:
         #This is a dev_facing_error
-        log.exception("save_grade returned broken json in the staff grading interface in open ended grading: {0}".format(result_json))
+        log.exception(
+            "save_grade returned broken json in the staff grading interface in open ended grading: {0}".format(
+                result_json))
         #This is a staff_facing_error
         return _err_response(STAFF_ERROR_MESSAGE)
 
     if not result.get('success', False):
         #This is a dev_facing_error
-        log.warning('Got success=False from staff grading service in open ended grading.  Response: {0}'.format(result_json))
+        log.warning(
+            'Got success=False from staff grading service in open ended grading.  Response: {0}'.format(result_json))
         return _err_response(STAFF_ERROR_MESSAGE)
 
     # Ok, save_grade seemed to work.  Get the next submission to grade.

lms/djangoapps/open_ended_grading/tests.py

@@ -22,6 +22,7 @@ from xmodule.x_module import ModuleSystem
 from mitxmako.shortcuts import render_to_string
 
 import logging
+
 log = logging.getLogger(__name__)
 from django.test.utils import override_settings
 from django.http import QueryDict
@@ -36,6 +37,7 @@ class TestStaffGradingService(ct.PageLoader):
     access control and error handling logic -- all the actual work is on the
     backend.
     '''
+
     def setUp(self):
         xmodule.modulestore.django._MODULESTORES = {}
 
@@ -50,6 +52,7 @@ class TestStaffGradingService(ct.PageLoader):
 
         self.course_id = "edX/toy/2012_Fall"
         self.toy = modulestore().get_course(self.course_id)
+
         def make_instructor(course):
             group_name = _course_staff_group_name(course.location)
             g = Group.objects.create(name=group_name)
@@ -130,6 +133,7 @@ class TestPeerGradingService(ct.PageLoader):
     access control and error handling logic -- all the actual work is on the
     backend.
     '''
+
     def setUp(self):
         xmodule.modulestore.django._MODULESTORES = {}
 
@@ -148,11 +152,12 @@ class TestPeerGradingService(ct.PageLoader):
 
         self.mock_service = peer_grading_service.MockPeerGradingService()
         self.system = ModuleSystem(location, None, None, render_to_string, None,
-            s3_interface = test_util_open_ended.S3_INTERFACE,
+                                   s3_interface=test_util_open_ended.S3_INTERFACE,
                                    open_ended_grading_interface=test_util_open_ended.OPEN_ENDED_GRADING_INTERFACE
         )
         self.descriptor = peer_grading_module.PeerGradingDescriptor(self.system)
-        self.peer_module = peer_grading_module.PeerGradingModule(self.system, location, "<peergrading/>", self.descriptor)
+        self.peer_module = peer_grading_module.PeerGradingModule(self.system, location, "<peergrading/>",
+                                                                 self.descriptor)
         self.peer_module.peer_gs = self.mock_service
         self.logout()
 
@@ -185,8 +190,10 @@ class TestPeerGradingService(ct.PageLoader):
         }
 
         qdict = MagicMock()
+
         def fake_get_item(key):
             return data[key]
+
         qdict.__getitem__.side_effect = fake_get_item
         qdict.getlist = fake_get_item
         qdict.keys = data.keys
@@ -247,8 +254,10 @@ class TestPeerGradingService(ct.PageLoader):
         }
 
         qdict = MagicMock()
+
         def fake_get_item(key):
             return data[key]
+
         qdict.__getitem__.side_effect = fake_get_item
         qdict.getlist = fake_get_item
         qdict.keys = data.keys

lms/djangoapps/open_ended_grading/views.py

@@ -50,22 +50,24 @@ def _reverse_without_slash(url_name, course_id):
     ajax_url = reverse(url_name, kwargs={'course_id': course_id})
     return ajax_url
 
+
 DESCRIPTION_DICT = {
     'Peer Grading': "View all problems that require peer assessment in this particular course.",
     'Staff Grading': "View ungraded submissions submitted by students for the open ended problems in the course.",
     'Problems you have submitted': "View open ended problems that you have previously submitted for grading.",
     'Flagged Submissions': "View submissions that have been flagged by students as inappropriate."
-    }
+}
 ALERT_DICT = {
     'Peer Grading': "New submissions to grade",
     'Staff Grading': "New submissions to grade",
     'Problems you have submitted': "New grades have been returned",
     'Flagged Submissions': "Submissions have been flagged for review"
-    }
+}
 
 STUDENT_ERROR_MESSAGE = "Error occured while contacting the grading service.  Please notify course staff."
 STAFF_ERROR_MESSAGE = "Error occured while contacting the grading service.  Please notify the development team.  If you do not have a point of contact, please email Vik at vik@edx.org"
 
+
 @cache_control(no_cache=True, no_store=True, must_revalidate=True)
 def staff_grading(request, course_id):
     """
@@ -92,7 +94,7 @@ def peer_grading(request, course_id):
     #Get the current course
     course = get_course_with_access(request.user, course_id, 'load')
     course_id_parts = course.id.split("/")
-    false_dict = [False,"False", "false", "FALSE"]
+    false_dict = [False, "False", "false", "FALSE"]
 
     #Reverse the base course url
     base_course_url = reverse('courses')
@@ -174,7 +176,7 @@ def student_problem_list(request, course_id):
                 except:
                     #This is a student_facing_error
                     eta_string = "Error getting ETA."
-            problem_list[i].update({'eta_string' : eta_string})
+            problem_list[i].update({'eta_string': eta_string})
 
     except GradingServiceError:
         #This is a student_facing_error
@@ -318,12 +320,13 @@ def take_action_on_flags(request, course_id):
     if request.method != 'POST':
         raise Http404
 
-
     required = ['submission_id', 'action_type', 'student_id']
     for key in required:
         if key not in request.POST:
             #This is a staff_facing_error
-            return HttpResponse(json.dumps({'success': False, 'error': STAFF_ERROR_MESSAGE + 'Missing key {0} from submission.  Please reload and try again.'.format(key)}),
+            return HttpResponse(json.dumps({'success': False,
+                                            'error': STAFF_ERROR_MESSAGE + 'Missing key {0} from submission.  Please reload and try again.'.format(
+                                                key)}),
                                 mimetype="application/json")
 
     p = request.POST
@@ -338,5 +341,7 @@ def take_action_on_flags(request, course_id):
         return HttpResponse(response, mimetype="application/json")
     except GradingServiceError:
         #This is a dev_facing_error
-        log.exception("Error taking action on flagged peer grading submissions, submission_id: {0}, action_type: {1}, grader_id: {2}".format(submission_id, action_type, grader_id))
+        log.exception(
+            "Error taking action on flagged peer grading submissions, submission_id: {0}, action_type: {1}, grader_id: {2}".format(
+                submission_id, action_type, grader_id))
         return _err_response(STAFF_ERROR_MESSAGE)

requirements.txt

-django==1.4.3
-pip
-numpy==1.6.2
-scipy==0.11.0
-Markdown==2.2.1
-pygments==1.5
-lxml==3.0.1
-boto==2.6.0
-mako==0.7.3
-python-memcached==1.48
-python-openid==2.2.5
-path.py
-django_debug_toolbar
-fs==0.4.0
-beautifulsoup==3.2.1
+-r repo-requirements.txt
 beautifulsoup4==4.1.3
-feedparser==5.1.3
-requests==0.14.2
-http://sympy.googlecode.com/files/sympy-0.7.1.tar.gz
-newrelic==1.8.0.13
-glob2==0.3
-pymongo==2.4.1
-django_nose==1.1
-nosexcover==1.0.7
-rednose==0.3.3
-GitPython==0.3.2.RC1
-mock==0.8.0
-PyYAML==3.10
-South==0.7.6
-pytz==2012h
+beautifulsoup==3.2.1
+boto==2.6.0
 django-celery==3.0.11
 django-countries==1.5
-django-kombu==0.9.4
+django-debug-toolbar-mongo
 django-followit==0.0.3
 django-jasmine==0.3.2
 django-keyedcache==1.4-6
+django-kombu==0.9.4
 django-mako==0.1.5pre
 django-masquerade==0.1.6
+django-mptt==0.5.5
 django-openid-auth==0.4
 django-robots==0.9.1
+django-sekizai==0.6.1
 django-ses==0.4.1
 django-storages==1.1.5
 django-threaded-multihost==1.4-1
-django-sekizai==0.6.1
-django-mptt==0.5.5
-sorl-thumbnail==11.12
-networkx==1.7
-pygraphviz==1.1
--r repo-requirements.txt
-nltk==2.0.4
-django-debug-toolbar-mongo
+django==1.4.3
+django_debug_toolbar
+django_nose==1.1
+dogapi==1.2.1
 dogstatsd-python==0.2.1
-MySQL-python==1.2.4c1
-sphinx==1.1.3
 factory_boy
-Shapely==1.2.16
+feedparser==5.1.3
+fs==0.4.0
+GitPython==0.3.2.RC1
+glob2==0.3
+http://sympy.googlecode.com/files/sympy-0.7.1.tar.gz
 ipython==0.13.1
-xmltodict==0.4.1
+lxml==3.0.1
+mako==0.7.3
+Markdown==2.2.1
+mock==0.8.0
+MySQL-python==1.2.4c1
+networkx==1.7
+newrelic==1.8.0.13
+nltk==2.0.4
+nosexcover==1.0.7
+numpy==1.6.2
 paramiko==1.9.0
+path.py
 Pillow==1.7.8
-dogapi==1.2.1
+pip
+pygments==1.5
+pygraphviz==1.1
+pymongo==2.4.1
+python-memcached==1.48
+python-openid==2.2.5
+pytz==2012h
+PyYAML==3.10
+rednose==0.3.3
+requests==0.14.2
+scipy==0.11.0
+Shapely==1.2.16
+sorl-thumbnail==11.12
+South==0.7.6
+sphinx==1.1.3
+xmltodict==0.4.1

test-requirements.txt

-django-nose
 coverage
-nosexcover
 pylint
 pep8
 lettuce
 selenium
-factory_boy
 splinter