Merge remote-tracking branch 'origin/master' into feature/alex/poll-merged

Conflicts:
	cms/djangoapps/contentstore/tests/test_contentstore.py
	cms/djangoapps/contentstore/views.py
	common/lib/xmodule/xmodule/combined_open_ended_module.py
	common/lib/xmodule/xmodule/open_ended_grading_classes/combined_open_ended_modulev1.py
	common/lib/xmodule/xmodule/open_ended_grading_classes/open_ended_module.py
	common/lib/xmodule/xmodule/open_ended_grading_classes/openendedchild.py
	common/lib/xmodule/xmodule/peer_grading_module.py
	common/lib/xmodule/xmodule/tests/test_combined_open_ended.py
	common/lib/xmodule/xmodule/tests/test_self_assessment.py
	lms/djangoapps/open_ended_grading/tests.py

.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/tests/test_contentstore.py

@@ -114,7 +114,7 @@ class ContentStoreToyCourseTest(ModuleStoreTestCase):
         self.assertTrue(sequential.location.url() in chapter.children)
 
         self.client.post(reverse('delete_item'),
-            json.dumps({'id': sequential.location.url(), 'delete_children': 'true'}),
+            json.dumps({'id': sequential.location.url(), 'delete_children': 'true', 'delete_all_versions': 'true'}),
             "application/json")
 
         found = False

cms/djangoapps/contentstore/views.py

@@ -643,17 +643,17 @@ 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
-
-    parent_locs = modulestore('direct').get_parent_locations(item_loc, None)
-
-    for parent_loc in parent_locs:
-        parent = modulestore('direct').get_item(parent_loc)
-        item_url = item_loc.url()
-        if item_url in parent.children:
-            children = parent.children
-            children.remove(item_url)
-            parent.children = children
-            modulestore('direct').update_children(parent.location, parent.children)
+    if delete_all_versions:
+        parent_locs = modulestore('direct').get_parent_locations(item_loc, None)
+
+        for parent_loc in parent_locs:
+            parent = modulestore('direct').get_item(parent_loc)
+            item_url = item_loc.url()
+            if item_url in parent.children:
+                children = parent.children
+                children.remove(item_url)
+                parent.children = children
+                modulestore('direct').update_children(parent.location, parent.children)
 
     return HttpResponse()
 

common/djangoapps/course_groups/cohorts.py

@@ -65,23 +65,23 @@ def is_commentable_cohorted(course_id, commentable_id):
                                                                ans))
     return ans
 
-    
+
 def get_cohorted_commentables(course_id):
     """
     Given a course_id return a list of strings representing cohorted commentables
     """
 
     course = courses.get_course_by_id(course_id)
-    
+
     if not course.is_cohorted:
         # this is the easy case :)
         ans = []
-    else: 
+    else:
         ans = course.cohorted_discussions
 
     return ans
-    
-    
+
+
 def get_cohort(user, course_id):
     """
     Given a django User and a course_id, return the user's cohort in that
@@ -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,12 +129,19 @@ 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,
         name=group_name)
-    
+
     user.course_groups.add(group)
     return group
 

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

@@ -89,7 +89,6 @@ class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
 
     def __init__(self, system, location, descriptor, model_data):
         XModule.__init__(self, system, location, descriptor, model_data)
-
         """
         Definition file should have one or many task blocks, a rubric block, and a prompt block:
 
@@ -152,13 +151,13 @@ class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
         attributes = self.student_attributes + self.settings_attributes
 
         static_data = {
-            'rewrite_content_links' : self.rewrite_content_links,
+            'rewrite_content_links': self.rewrite_content_links,
         }
-        instance_state = { k: getattr(self,k) for k in attributes}
+        instance_state = {k: getattr(self, k) for k in attributes}
         self.child_descriptor = descriptors[version_index](self.system)
         self.child_definition = descriptors[version_index].definition_from_xml(etree.fromstring(self.data), self.system)
         self.child_module = modules[version_index](self.system, location, self.child_definition, self.child_descriptor,
-            instance_state = instance_state, static_data= static_data, attributes=attributes)
+                                    instance_state=instance_state, static_data=static_data, attributes=attributes)
         self.save_instance_data()
 
     def get_html(self):
@@ -190,9 +189,9 @@ class CombinedOpenEndedModule(CombinedOpenEndedFields, XModule):
 
     def save_instance_data(self):
         for attribute in self.student_attributes:
-            child_attr = getattr(self.child_module,attribute)
+            child_attr = getattr(self.child_module, attribute)
             if child_attr != getattr(self, attribute):
-                setattr(self,attribute, getattr(self.child_module,attribute))
+                setattr(self, attribute, getattr(self.child_module, attribute))
 
 
 class CombinedOpenEndedDescriptor(CombinedOpenEndedFields, RawDescriptor):

common/lib/xmodule/xmodule/foldit_module.py

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

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)
@@ -59,7 +60,7 @@ class ControllerQueryService(GradingService):
     def get_flagged_problem_list(self, course_id):
         params = {
             'course_id': course_id,
-            }
+        }
 
         response = self.get(self.flagged_problem_list_url, params)
         return response
@@ -70,20 +71,21 @@ class ControllerQueryService(GradingService):
             'student_id': student_id,
             'submission_id': submission_id,
             'action_type': action_type
-            }
+        }
 
         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']
@@ -34,8 +35,8 @@ class GradingService(object):
         Returns the decoded json dict of the response.
         """
         response = self.session.post(self.login_url,
-            {'username': self.username,
-             'password': self.password, })
+                                     {'username': self.username,
+                                      'password': self.password, })
 
         response.raise_for_status()
 
@@ -47,7 +48,7 @@ class GradingService(object):
         """
         try:
             op = lambda: self.session.post(url, data=data,
-                allow_redirects=allow_redirects)
+                                           allow_redirects=allow_redirects)
             r = self._try_with_login(op)
         except (RequestException, ConnectionError, HTTPError) as err:
             # reraise as promised GradingServiceError, but preserve stacktrace.
@@ -63,8 +64,8 @@ class GradingService(object):
         """
         log.debug(params)
         op = lambda: self.session.get(url,
-            allow_redirects=allow_redirects,
-            params=params)
+                                      allow_redirects=allow_redirects,
+                                      params=params)
         try:
             r = self._try_with_login(op)
         except (RequestException, ConnectionError, HTTPError) as err:
@@ -92,7 +93,7 @@ class GradingService(object):
             r = self._login()
             if r and not r.get('success'):
                 log.warning("Couldn't log into staff_grading backend. Response: %s",
-                    r)
+                            r)
                 # try again
             response = operation()
             response.raise_for_status()

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
@@ -92,7 +94,7 @@ class ImageProperties(object):
             g = rgb[1]
             b = rgb[2]
             check_r = (r > 60)
-            check_g =  (r * 0.4) < g < (r * 0.85)
+            check_g = (r * 0.4) < g < (r * 0.85)
             check_b = (r * 0.2) < b < (r * 0.7)
             colors_okay = check_r and check_b and check_g
         except:
@@ -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
 
@@ -212,7 +215,7 @@ def run_image_tests(image):
         success = image_properties.run_tests()
     except:
         log.exception("Cannot run image tests in combined open ended xmodule.  May be an issue with a particular image,"
-                    "or an issue with the deployment configuration of PIL/Pillow")
+                      "or an issue with the deployment configuration of PIL/Pillow")
     return success
 
 
@@ -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

@@ -10,7 +10,7 @@ import logging
 from lxml import etree
 import capa.xqueue_interface as xqueue_interface
 
-from xmodule.capa_module import  ComplexEncoder
+from xmodule.capa_module import ComplexEncoder
 from xmodule.editing_module import EditingDescriptor
 from xmodule.progress import Progress
 from xmodule.stringify import stringify_children
@@ -77,7 +77,6 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             self.send_to_grader(self.latest_answer(), system)
             self.child_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'])
@@ -188,7 +191,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
         }
 
         (error, msg) = qinterface.send_to_queue(header=xheader,
-            body=json.dumps(contents))
+                                                body=json.dumps(contents))
 
         #Convert error to a success value
         success = True
@@ -222,8 +225,8 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
                                                  str(len(self.child_history)))
 
         xheader = xqueue_interface.make_xheader(lms_callback_url=system.xqueue['callback_url'],
-            lms_key=queuekey,
-            queue_name=self.queue_name)
+                                                lms_key=queuekey,
+                                                queue_name=self.queue_name)
 
         contents = self.payload.copy()
 
@@ -241,7 +244,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
 
         # Submit request. When successful, 'msg' is the prior length of the queue
         (error, msg) = qinterface.send_to_queue(header=xheader,
-            body=json.dumps(contents))
+                                                body=json.dumps(contents))
 
         # State associated with the queueing request
         queuestate = {'key': queuekey,
@@ -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
@@ -400,7 +402,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
 
         if not response_items['success']:
             return system.render_template("{0}/open_ended_error.html".format(self.TEMPLATE_DIR),
-                {'errors': feedback})
+                                          {'errors': feedback})
 
         feedback_template = system.render_template("{0}/open_ended_feedback.html".format(self.TEMPLATE_DIR), {
             'grader_type': response_items['grader_type'],
@@ -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,13 +438,13 @@ 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)
         except (TypeError, ValueError):
@@ -470,7 +471,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
                 log.error(error_message)
                 fail['feedback'] = error_message
                 return fail
-            #This is to support peer grading
+                #This is to support peer grading
         if isinstance(score_result['score'], list):
             feedback_items = []
             rubric_scores = []
@@ -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):
@@ -545,7 +546,7 @@ class OpenEndedModule(openendedchild.OpenEndedChild):
             return ""
 
         feedback_dict = self._parse_score_msg(self.child_history[-1].get('post_assessment', ""), system,
-            join_feedback=join_feedback)
+                                              join_feedback=join_feedback)
         if not short_feedback:
             return feedback_dict['feedback'] if feedback_dict['valid'] else ''
         if feedback_dict['valid']:
@@ -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.child_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
@@ -726,7 +726,9 @@ class OpenEndedDescriptor():
         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

@@ -100,7 +100,8 @@ class OpenEndedChild(object):
         # completion (doesn't matter if you self-assessed correct/incorrect).
         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
@@ -142,7 +143,9 @@ 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.child_attempts, self.max_attempts)
+                'error': 'You have attempted this problem {0} times.  You are allowed {1} attempts.'.format(
+                    self.child_attempts, self.max_attempts
+                )
             }
         else:
             return False, {}
@@ -170,8 +173,8 @@ class OpenEndedChild(object):
         try:
             answer = autolink_html(answer)
             cleaner = Cleaner(style=True, links=True, add_nofollow=False, page_structure=True, safe_attrs_only=True,
-                host_whitelist=open_ended_image_submission.TRUSTED_IMAGE_DOMAINS,
-                whitelist_tags=set(['embed', 'iframe', 'a', 'img']))
+                              host_whitelist=open_ended_image_submission.TRUSTED_IMAGE_DOMAINS,
+                              whitelist_tags=set(['embed', 'iframe', 'a', 'img']))
             clean_html = cleaner.clean_html(answer)
             clean_html = re.sub(r'</p>$', '', re.sub(r'^<p>', '', clean_html))
         except:
@@ -272,7 +275,7 @@ class OpenEndedChild(object):
         """
         #This is a dev_facing_error
         log.warning("Open ended child state out sync. state: %r, get: %r. %s",
-            self.child_state, get, msg)
+                    self.child_state, get, msg)
         #This is a student_facing_error
         return {'success': False,
                 'error': 'The problem state got out-of-sync.  Please try reloading the page.'}
@@ -298,7 +301,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
@@ -332,7 +335,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.")
 
@@ -394,9 +398,9 @@ class OpenEndedChild(object):
             #In this case, an image was submitted by the student, but the image could not be uploaded to S3.  Likely
             #a config issue (development vs deployment).  For now, just treat this as a "success"
             log.exception("Student AJAX post to combined open ended xmodule indicated that it contained an image, "
-                        "but the image was not able to be uploaded to S3.  This could indicate a config"
-                        "issue with this deployment, but it could also indicate a problem with S3 or with the"
-                        "student image itself.")
+                          "but the image was not able to be uploaded to S3.  This could indicate a config"
+                          "issue with this deployment, but it could also indicate a problem with S3 or with the"
+                          "student image itself.")
             overall_success = True
         elif not has_file_to_upload:
             #If there is no file to upload, probably the student has embedded the link in the answer text
@@ -435,7 +439,7 @@ class OpenEndedChild(object):
         response = {}
         #This is a student_facing_error
         error_string = ("You need to peer grade {0} more in order to make another submission.  "
-        "You have graded {1}, and {2} are required.  You have made {3} successful peer grading submissions.")
+                        "You have graded {1}, and {2} are required.  You have made {3} successful peer grading submissions.")
         try:
             response = self.peer_gs.get_data_for_location(self.location_string, student_id)
             count_graded = response['count_graded']
@@ -444,16 +448,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):
@@ -468,7 +474,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'])
@@ -477,6 +483,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)
@@ -36,10 +37,11 @@ class PeerGradingService(GradingService):
 
     def get_next_submission(self, problem_location, grader_id):
         response = self.get(self.get_next_submission_url,
-            {'location': problem_location, 'grader_id': grader_id})
+                            {'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
@@ -122,7 +125,7 @@ class MockPeerGradingService(object):
                            'max_score': 4})
 
     def save_calibration_essay(self, problem_location, grader_id,
-                               calibration_essay_id, submission_key, score, 
+                               calibration_essay_id, submission_key, score,
                                feedback, rubric_scores):
         return {'success': True, 'actual_score': 2}
 

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

@@ -75,7 +75,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.
@@ -97,7 +96,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)
@@ -161,7 +160,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.
@@ -226,7 +224,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
@@ -270,7 +268,7 @@ class SelfAssessmentModule(openendedchild.OpenEndedChild):
                 'allow_reset': self._allow_reset()}
 
     def latest_post_assessment(self, system):
-        latest_post_assessment =  super(SelfAssessmentModule, self).latest_post_assessment(system)
+        latest_post_assessment = super(SelfAssessmentModule, self).latest_post_assessment(system)
         try:
             rubric_scores = json.loads(latest_post_assessment)
         except:
@@ -310,7 +308,9 @@ class SelfAssessmentDescriptor():
         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

@@ -44,7 +44,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
                      resource_string(__name__, 'js/src/peergrading/peer_grading_problem.coffee'),
                      resource_string(__name__, 'js/src/collapsible.coffee'),
                      resource_string(__name__, 'js/src/javascript_loader.coffee'),
-                     ]}
+    ]}
     js_module_name = "PeerGrading"
 
     css = {'scss': [resource_string(__name__, 'css/combinedopenended/display.scss')]}
@@ -55,7 +55,7 @@ class PeerGradingModule(PeerGradingFields, 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()
@@ -139,13 +139,13 @@ class PeerGradingModule(PeerGradingFields, XModule):
             'save_grade': self.save_grade,
             'save_calibration_essay': self.save_calibration_essay,
             'problem': self.peer_grading_problem,
-            }
+        }
 
         if dispatch not in handlers:
             #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)
 
@@ -182,9 +182,10 @@ class PeerGradingModule(PeerGradingFields, 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(
-                    self.system.location.url(), self.system.anonymous_student_id
-                ))
+                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
             count_graded = response['count_graded']
             count_required = response['count_required']
@@ -195,7 +196,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
         score_dict = {
             'score': int(count_graded >= count_required),
             'total': self.max_grade,
-            }
+        }
 
         return score_dict
 
@@ -244,7 +245,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             .format(self.peer_gs.url, location, grader_id))
             #This is a student_facing_error
             return {'success': False,
-                               'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}
+                    'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}
 
     def save_grade(self, get):
         """
@@ -262,7 +263,8 @@ class PeerGradingModule(PeerGradingFields, 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)
@@ -278,14 +280,14 @@ class PeerGradingModule(PeerGradingFields, XModule):
 
         try:
             response = self.peer_gs.save_grade(location, grader_id, submission_id,
-                score, feedback, submission_key, rubric_scores, submission_flagged)
+                                               score, feedback, submission_key, rubric_scores, submission_flagged)
             return response
         except GradingServiceError:
             #This is a dev_facing_error
             log.exception("""Error saving grade to open ended grading service.  server url: {0}, location: {1}, submission_id:{2},
                             submission_key: {3}, score: {4}"""
             .format(self.peer_gs.url,
-                location, submission_id, submission_key, score)
+                    location, submission_id, submission_key, score)
             )
             #This is a student_facing_error
             return {
@@ -373,7 +375,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             .format(self.peer_gs.url, location))
             #This is a student_facing_error
             return {'success': False,
-                               'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}
+                    'error': EXTERNAL_GRADER_NO_CONTACT_ERROR}
         # if we can't parse the rubric into HTML,
         except etree.XMLSyntaxError:
             #This is a dev_facing_error
@@ -381,7 +383,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             .format(rubric))
             #This is a student_facing_error
             return {'success': False,
-                               'error': 'Error displaying submission.  Please notify course staff.'}
+                    'error': 'Error displaying submission.  Please notify course staff.'}
 
 
     def save_calibration_essay(self, get):
@@ -417,11 +419,13 @@ class PeerGradingModule(PeerGradingFields, XModule):
 
         try:
             response = self.peer_gs.save_calibration_essay(location, grader_id, calibration_essay_id,
-                submission_key, score, feedback, rubric_scores)
+                                                           submission_key, score, feedback, rubric_scores)
             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.')
 
@@ -431,7 +435,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
         '''
         html = self.system.render_template('peer_grading/peer_grading_closed.html', {
             'use_for_single_location': self.use_for_single_location
-            })
+        })
         return html
 
 
@@ -501,7 +505,6 @@ class PeerGradingModule(PeerGradingFields, 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,
@@ -512,7 +515,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             # Checked above
             'staff_access': False,
             'use_single_location': self.use_for_single_location,
-            })
+        })
 
         return html
 
@@ -524,7 +527,8 @@ class PeerGradingModule(PeerGradingFields, XModule):
             if self.use_for_single_location not in TRUE_DICT:
                 #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
 
@@ -540,7 +544,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
             # Checked above
             'staff_access': False,
             'use_single_location': self.use_for_single_location,
-            })
+        })
 
         return {'html': html, 'success': True}
 
@@ -553,7 +557,7 @@ class PeerGradingModule(PeerGradingFields, XModule):
 
         state = {
             'student_data_for_location': self.student_data_for_location,
-            }
+        }
 
         return json.dumps(state)
 

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>
@@ -24,7 +24,7 @@ class SelfAssessmentTest(unittest.TestCase):
                   'prompt': prompt,
                   'submitmessage': 'Shall we submit now?',
                   'hintprompt': 'Consider this...',
-                  }
+    }
 
     location = Location(["i4x", "edX", "sa_test", "selfassessment",
                          "SampleQuestion"])
@@ -39,22 +39,22 @@ class SelfAssessmentTest(unittest.TestCase):
                             'attempts': 2})
 
         static_data = {
-                'max_attempts': 10,
-                'rubric': etree.XML(self.rubric),
-                'prompt': self.prompt,
-                'max_score': 1,
-                '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,
-                }
+            'max_attempts': 10,
+            'rubric': etree.XML(self.rubric),
+            'prompt': self.prompt,
+            'max_score': 1,
+            '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,
+        }
 
         self.module = SelfAssessmentModule(test_system(), self.location,
-                                      self.definition,
-                                      self.descriptor,
-                                      static_data)
+                                           self.definition,
+                                           self.descriptor,
+                                           static_data)
 
     def test_get_html(self):
         html = self.module.get_html(self.module.system)
@@ -62,14 +62,15 @@ 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,
-            'student_sub_count': 0,
+                'count_graded': 0,
+                'count_required': 0,
+                'student_sub_count': 0,
             }
 
         mock_query_dict = MagicMock()
@@ -87,7 +88,6 @@ class SelfAssessmentTest(unittest.TestCase):
         self.module.save_assessment(mock_query_dict, self.module.system)
         self.assertEqual(self.module.child_state, self.module.DONE)
 
-
         d = self.module.reset({})
         self.assertTrue(d['success'])
         self.assertEqual(self.module.child_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

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/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"
@@ -87,7 +89,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"
@@ -119,7 +123,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:
@@ -131,7 +137,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']:
@@ -141,7 +148,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"
@@ -165,7 +174,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
 
@@ -43,15 +45,18 @@ class MockStaffGradingService(object):
     def get_problem_list(self, course_id, grader_id):
         self.cnt += 1
         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}),
-          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})
-        ]})
-
-
-    def save_grade(self, course_id, grader_id, submission_id, score, feedback, skipped, rubric_scores, submission_flagged):
+                           '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}),
+                               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})
+                           ]})
+
+
+    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(
             ajax_url=None,
@@ -116,12 +122,13 @@ class StaffGradingService(GradingService):
             GradingServiceError: something went wrong with the connection.
         """
         response = self.get(self.get_next_url,
-                                      params={'location': location,
-                                              'grader_id': grader_id})
+                            params={'location': location,
+                                    'grader_id': grader_id})
         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.
 
@@ -260,14 +267,14 @@ def get_problem_list(request, course_id):
     try:
         response = staff_grading_service().get_problem_list(course_id, unique_id_for_user(request.user))
         return HttpResponse(response,
-                mimetype="application/json")
+                            mimetype="application/json")
     except GradingServiceError:
         #This is a dev_facing_error
         log.exception("Error from staff grading service in open ended grading.  server url: {0}"
-                      .format(staff_grading_service().url))
+        .format(staff_grading_service().url))
         #This is a staff_facing_error
         return HttpResponse(json.dumps({'success': False,
-                           'error': STAFF_ERROR_MESSAGE}))
+                                        'error': STAFF_ERROR_MESSAGE}))
 
 
 def _get_next(course_id, grader_id, location):
@@ -279,7 +286,7 @@ def _get_next(course_id, grader_id, location):
     except GradingServiceError:
         #This is a dev facing error
         log.exception("Error from staff grading service in open ended grading.  server url: {0}"
-                      .format(staff_grading_service().url))
+        .format(staff_grading_service().url))
         #This is a staff_facing_error
         return json.dumps({'success': False,
                            'error': STAFF_ERROR_MESSAGE})
@@ -304,7 +311,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:
@@ -314,22 +321,23 @@ def save_grade(request, course_id):
     grader_id = unique_id_for_user(request.user)
     p = request.POST
 
-
     location = p['location']
-    skipped =  'skipped' in p
+    skipped = 'skipped' in p
 
     try:
         result_json = staff_grading_service().save_grade(course_id,
-                                          grader_id,
-                                          p['submission_id'],
-                                          p['score'],
-                                          p['feedback'],
-                                          skipped,
-                                          p.getlist('rubric_scores[]'),
-                                          p['submission_flagged'])
+                                                         grader_id,
+                                                         p['submission_id'],
+                                                         p['score'],
+                                                         p['feedback'],
+                                                         skipped,
+                                                         p.getlist('rubric_scores[]'),
+                                                         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)
 
@@ -337,13 +345,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

@@ -7,7 +7,7 @@ django-admin.py test --settings=lms.envs.test --pythonpath=. lms/djangoapps/open
 from django.test import TestCase
 from open_ended_grading import staff_grading_service
 from xmodule.open_ended_grading_classes import peer_grading_service
-from xmodule import  peer_grading_module
+from xmodule import peer_grading_module
 from django.core.urlresolvers import reverse
 from django.contrib.auth.models import Group
 
@@ -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 = {}
 
@@ -145,16 +149,16 @@ class TestPeerGradingService(ct.PageLoader):
         self.course_id = "edX/toy/2012_Fall"
         self.toy = modulestore().get_course(self.course_id)
         location = "i4x://edX/toy/peergrading/init"
-        model_data = {'data' : "<peergrading/>"}
+        model_data = {'data': "<peergrading/>"}
         self.mock_service = peer_grading_service.MockPeerGradingService()
         self.system = ModuleSystem(
             ajax_url=location,
             track_function=None,
-            get_module = None,
+            get_module=None,
             render_template=render_to_string,
             replace_urls=None,
-            xblock_model_data= {},
-            s3_interface = test_util_open_ended.S3_INTERFACE,
+            xblock_model_data={},
+            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, location, model_data)
@@ -182,18 +186,20 @@ class TestPeerGradingService(ct.PageLoader):
 
     def test_save_grade_success(self):
         data = {
-                'rubric_scores[]': [0, 0],
-                'location': self.location,
-                'submission_id': 1,
-                'submission_key': 'fake key',
-                'score': 2,
-                'feedback': 'feedback',
-                'submission_flagged': 'false'
-                }
+            'rubric_scores[]': [0, 0],
+            'location': self.location,
+            'submission_id': 1,
+            'submission_key': 'fake key',
+            'score': 2,
+            'feedback': 'feedback',
+            'submission_flagged': 'false'
+        }
 
         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
@@ -244,18 +250,20 @@ class TestPeerGradingService(ct.PageLoader):
 
     def test_save_calibration_essay_success(self):
         data = {
-                'rubric_scores[]': [0, 0],
-                'location': self.location,
-                'submission_id': 1,
-                'submission_key': 'fake key',
-                'score': 2,
-                'feedback': 'feedback',
-                'submission_flagged': 'false'
-                }
+            'rubric_scores[]': [0, 0],
+            'location': self.location,
+            'submission_id': 1,
+            'submission_key': 'fake key',
+            'score': 2,
+            'feedback': 'feedback',
+            'submission_flagged': 'false'
+        }
 
         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

@@ -57,22 +57,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."
-    }
+    '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"
-    }
+    '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):
     """
@@ -99,10 +101,10 @@ 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')
+    base_course_url = reverse('courses')
     try:
         #TODO:  This will not work with multiple runs of a course.  Make it work.  The last key in the Location passed
         #to get_items is called revision.  Is this the same as run?
@@ -154,7 +156,7 @@ def student_problem_list(request, course_id):
     success = False
     error_text = ""
     problem_list = []
-    base_course_url  = reverse('courses')
+    base_course_url = reverse('courses')
 
     try:
         problem_list_json = controller_qs.get_grading_status_list(course_id, unique_id_for_user(request.user))
@@ -181,7 +183,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
@@ -222,7 +224,7 @@ def flagged_problem_list(request, course_id):
     success = False
     error_text = ""
     problem_list = []
-    base_course_url  = reverse('courses')
+    base_course_url = reverse('courses')
 
     try:
         problem_list_json = controller_qs.get_flagged_problem_list(course_id)
@@ -250,14 +252,14 @@ def flagged_problem_list(request, course_id):
 
     ajax_url = _reverse_with_slash('open_ended_flagged_problems', course_id)
     context = {
-            'course': course,
-            'course_id': course_id,
-            'ajax_url': ajax_url,
-            'success': success,
-            'problem_list': problem_list,
-            'error_text': error_text,
-            # Checked above
-            'staff_access': True,
+        'course': course,
+        'course_id': course_id,
+        'ajax_url': ajax_url,
+        'success': success,
+        'problem_list': problem_list,
+        'error_text': error_text,
+        # Checked above
+        'staff_access': True,
     }
     return render_to_response('open_ended_problems/open_ended_flagged_problems.html', context)
 
@@ -312,7 +314,7 @@ def combined_notifications(request, course_id):
     }
 
     return render_to_response('open_ended_problems/combined_notifications.html',
-        combined_dict
+                              combined_dict
     )
 
 
@@ -325,13 +327,14 @@ 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)}),
-                mimetype="application/json")
+            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
     submission_id = p['submission_id']
@@ -345,5 +348,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)