formatting

common/lib/capa/capa/capa_problem.py

@@ -242,11 +242,15 @@ class LoncapaProblem(object):
             return None
 
         # Get a list of timestamps of all queueing requests, then convert it to a DateTime object
-        queuetime_strs = [self.correct_map.get_queuetime_str(answer_id)
-                          for answer_id in self.correct_map
-                          if self.correct_map.is_queued(answer_id)]
-        queuetimes = [datetime.strptime(qt_str, xqueue_interface.dateformat)
-                      for qt_str in queuetime_strs]
+        queuetime_strs = [
+            self.correct_map.get_queuetime_str(answer_id)
+            for answer_id in self.correct_map
+            if self.correct_map.is_queued(answer_id)
+        ]
+        queuetimes = [
+            datetime.strptime(qt_str, xqueue_interface.dateformat)
+            for qt_str in queuetime_strs
+        ]
 
         return max(queuetimes)
 

common/lib/capa/capa/correctmap.py

@@ -37,23 +37,27 @@ class CorrectMap(object):
         return self.cmap.__iter__()
 
     # See the documentation for 'set_dict' for the use of kwargs
-    def set(self,
-            answer_id=None,
-            correctness=None,
-            npoints=None,
-            msg='',
-            hint='',
-            hintmode=None,
-            queuestate=None, **kwargs):
+    def set(
+        self,
+        answer_id=None,
+        correctness=None,
+        npoints=None,
+        msg='',
+        hint='',
+        hintmode=None,
+        queuestate=None,
+        **kwargs
+    ):
 
         if answer_id is not None:
-            self.cmap[str(answer_id)] = {'correctness': correctness,
-                                    'npoints': npoints,
-                                    'msg': msg,
-                                    'hint': hint,
-                                    'hintmode': hintmode,
-                                    'queuestate': queuestate,
-                                    }
+            self.cmap[str(answer_id)] = {
+                'correctness': correctness,
+                'npoints': npoints,
+                'msg': msg,
+                'hint': hint,
+                'hintmode': hintmode,
+                'queuestate': queuestate,
+            }
 
     def __repr__(self):
         return repr(self.cmap)

common/lib/capa/capa/responsetypes.py

@@ -1365,9 +1365,11 @@ class CodeResponse(LoncapaResponse):
             # Note that submission can be a file
             submission = student_answers[self.answer_id]
         except Exception as err:
-            log.error('Error in CodeResponse %s: cannot get student answer for %s;'
-                      ' student_answers=%s' %
-                     (err, self.answer_id, convert_files_to_filenames(student_answers)))
+            log.error(
+                'Error in CodeResponse %s: cannot get student answer for %s;'
+                ' student_answers=%s' %
+                (err, self.answer_id, convert_files_to_filenames(student_answers))
+            )
             raise Exception(err)
 
         # We do not support xqueue within Studio.
@@ -1386,14 +1388,15 @@ class CodeResponse(LoncapaResponse):
         anonymous_student_id = self.system.anonymous_student_id
 
         # Generate header
-        queuekey = xqueue_interface.make_hashkey(str(self.system.seed) + qtime +
-                                                 anonymous_student_id +
-                                                 self.answer_id)
+        queuekey = xqueue_interface.make_hashkey(
+            str(self.system.seed) + qtime + anonymous_student_id + self.answer_id
+        )
         callback_url = self.system.xqueue['construct_callback']()
         xheader = xqueue_interface.make_xheader(
             lms_callback_url=callback_url,
             lms_key=queuekey,
-            queue_name=self.queue_name)
+            queue_name=self.queue_name
+        )
 
         # Generate body
         if is_list_of_files(submission):
@@ -1406,9 +1409,10 @@ class CodeResponse(LoncapaResponse):
 
         # Metadata related to the student submission revealed to the external
         # grader
-        student_info = {'anonymous_student_id': anonymous_student_id,
-                        'submission_time': qtime,
-                        }
+        student_info = {
+            'anonymous_student_id': anonymous_student_id,
+            'submission_time': qtime,
+        }
         contents.update({'student_info': json.dumps(student_info)})
 
         # Submit request. When successful, 'msg' is the prior length of the

common/lib/capa/capa/xqueue_interface.py

@@ -30,9 +30,11 @@ def make_xheader(lms_callback_url, lms_key, queue_name):
           'queue_name': designate a specific queue within xqueue server, e.g. 'MITx-6.00x' (string)
         }
     """
-    return json.dumps({'lms_callback_url': lms_callback_url,
-                        'lms_key': lms_key,
-                        'queue_name': queue_name})
+    return json.dumps({
+        'lms_callback_url': lms_callback_url,
+        'lms_key': lms_key,
+        'queue_name': queue_name
+    })
 
 
 def parse_xreply(xreply):
@@ -60,7 +62,7 @@ class XQueueInterface(object):
     '''
 
     def __init__(self, url, django_auth, requests_auth=None):
-        self.url  = url
+        self.url = url
         self.auth = django_auth
         self.session = requests.session(auth=requests_auth)
 
@@ -95,13 +97,13 @@ class XQueueInterface(object):
 
         return (error, msg)
 
-
     def _login(self):
-        payload = {'username': self.auth['username'],
-                    'password': self.auth['password']}
+        payload = {
+            'username': self.auth['username'],
+            'password': self.auth['password']
+        }
         return self._http_post(self.url + '/xqueue/login/', payload)
 
-
     def _send_to_queue(self, header, body, files_to_upload):
         payload = {'xqueue_header': header,
                    'xqueue_body': body}
@@ -112,7 +114,6 @@ class XQueueInterface(object):
 
         return self._http_post(self.url + '/xqueue/submit/', payload, files=files)
 
-
     def _http_post(self, url, data, files=None):
         try:
             r = self.session.post(url, data=data, files=files)

common/lib/xmodule/xmodule/capa_module.py

@@ -1126,8 +1126,12 @@ class CapaDescriptor(CapaFields, RawDescriptor):
     mako_template = "widgets/problem-edit.html"
     js = {'coffee': [resource_string(__name__, 'js/src/problem/edit.coffee')]}
     js_module_name = "MarkdownEditingDescriptor"
-    css = {'scss': [resource_string(__name__, 'css/editor/edit.scss'),
-                    resource_string(__name__, 'css/problem/edit.scss')]}
+    css = {
+        'scss': [
+            resource_string(__name__, 'css/editor/edit.scss'),
+            resource_string(__name__, 'css/problem/edit.scss')
+        ]
+    }
 
     # Capa modules have some additional metadata:
     # TODO (vshnayder): do problems have any other metadata?  Do they

lms/djangoapps/courseware/module_render.py

@@ -213,22 +213,28 @@ def get_module_for_descriptor_internal(user, descriptor, model_data_cache, cours
         return None
 
     # Setup system context for module instance
-    ajax_url = reverse('modx_dispatch',
-                       kwargs=dict(course_id=course_id,
-                                   location=descriptor.location.url(),
-                                   dispatch=''),
-                       )
+    ajax_url = reverse(
+        'modx_dispatch',
+        kwargs=dict(
+            course_id=course_id,
+            location=descriptor.location.url(),
+            dispatch=''
+        ),
+    )
     # Intended use is as {ajax_url}/{dispatch_command}, so get rid of the trailing slash.
     ajax_url = ajax_url.rstrip('/')
 
     def make_xqueue_callback(dispatch='score_update'):
         # Fully qualified callback URL for external queueing system
-        relative_xqueue_callback_url = reverse('xqueue_callback',
-                                               kwargs=dict(course_id=course_id,
-                                                           userid=str(user.id),
-                                                           mod_id=descriptor.location.url(),
-                                                           dispatch=dispatch),
-                                               )
+        relative_xqueue_callback_url = reverse(
+            'xqueue_callback',
+            kwargs=dict(
+                course_id=course_id,
+                userid=str(user.id),
+                mod_id=descriptor.location.url(),
+                dispatch=dispatch
+            ),
+        )
         return xqueue_callback_url_prefix + relative_xqueue_callback_url
 
     # Default queuename is course-specific and is derived from the course that
@@ -313,10 +319,12 @@ def get_module_for_descriptor_internal(user, descriptor, model_data_cache, cours
         score_bucket = get_score_bucket(student_module.grade, student_module.max_grade)
         org, course_num, run = course_id.split("/")
 
-        tags = ["org:{0}".format(org),
-                "course:{0}".format(course_num),
-                "run:{0}".format(run),
-                "score_bucket:{0}".format(score_bucket)]
+        tags = [
+            "org:{0}".format(org),
+            "course:{0}".format(course_num),
+            "run:{0}".format(run),
+            "score_bucket:{0}".format(score_bucket)
+        ]
 
         if grade_bucket_type is not None:
             tags.append('type:%s' % grade_bucket_type)
@@ -326,38 +334,41 @@ def get_module_for_descriptor_internal(user, descriptor, model_data_cache, cours
     # TODO (cpennington): When modules are shared between courses, the static
     # prefix is going to have to be specific to the module, not the directory
     # that the xml was loaded from
-    system = ModuleSystem(track_function=track_function,
-                          render_template=render_to_string,
-                          ajax_url=ajax_url,
-                          xqueue=xqueue,
-                          # TODO (cpennington): Figure out how to share info between systems
-                          filestore=descriptor.system.resources_fs,
-                          get_module=inner_get_module,
-                          user=user,
-                          # TODO (cpennington): This should be removed when all html from
-                          # a module is coming through get_html and is therefore covered
-                          # by the replace_static_urls code below
-                          replace_urls=partial(
-                              static_replace.replace_static_urls,
-                              data_directory=getattr(descriptor, 'data_dir', None),
-                              course_namespace=descriptor.location._replace(category=None, name=None),
-                          ),
-                          node_path=settings.NODE_PATH,
-                          xblock_model_data=xblock_model_data,
-                          publish=publish,
-                          anonymous_student_id=unique_id_for_user(user),
-                          course_id=course_id,
-                          open_ended_grading_interface=open_ended_grading_interface,
-                          s3_interface=s3_interface,
-                          cache=cache,
-                          can_execute_unsafe_code=(lambda: can_execute_unsafe_code(course_id)),
-                          )
+    system = ModuleSystem(
+        track_function=track_function,
+        render_template=render_to_string,
+        ajax_url=ajax_url,
+        xqueue=xqueue,
+        # TODO (cpennington): Figure out how to share info between systems
+        filestore=descriptor.system.resources_fs,
+        get_module=inner_get_module,
+        user=user,
+        # TODO (cpennington): This should be removed when all html from
+        # a module is coming through get_html and is therefore covered
+        # by the replace_static_urls code below
+        replace_urls=partial(
+            static_replace.replace_static_urls,
+            data_directory=getattr(descriptor, 'data_dir', None),
+            course_namespace=descriptor.location._replace(category=None, name=None),
+        ),
+        node_path=settings.NODE_PATH,
+        xblock_model_data=xblock_model_data,
+        publish=publish,
+        anonymous_student_id=unique_id_for_user(user),
+        course_id=course_id,
+        open_ended_grading_interface=open_ended_grading_interface,
+        s3_interface=s3_interface,
+        cache=cache,
+        can_execute_unsafe_code=(lambda: can_execute_unsafe_code(course_id)),
+    )
     # pass position specified in URL to module through ModuleSystem
     system.set('position', position)
     system.set('DEBUG', settings.DEBUG)
     if settings.MITX_FEATURES.get('ENABLE_PSYCHOMETRICS'):
-        system.set('psychometrics_handler',  # set callback for updating PsychometricsData
-                   make_psychometrics_data_update_handler(course_id, user, descriptor.location.url()))
+        system.set(
+            'psychometrics_handler',  # set callback for updating PsychometricsData
+            make_psychometrics_data_update_handler(course_id, user, descriptor.location.url())
+        )
 
     try:
         module = descriptor.xmodule(system)
@@ -381,13 +392,14 @@ def get_module_for_descriptor_internal(user, descriptor, model_data_cache, cours
     system.set('user_is_staff', has_access(user, descriptor.location, 'staff', course_id))
     _get_html = module.get_html
 
-    if wrap_xmodule_display == True:
+    if wrap_xmodule_display is True:
         _get_html = wrap_xmodule(module.get_html, module, 'xmodule_display.html')
 
     module.get_html = replace_static_urls(
         _get_html,
         getattr(descriptor, 'data_dir', None),
-        course_namespace=module.location._replace(category=None, name=None))
+        course_namespace=module.location._replace(category=None, name=None)
+    )
 
     # Allow URLs of the form '/course/' refer to the root of multicourse directory
     #   hierarchy of this course