diff --git a/openedx/core/djangolib/markup.py b/openedx/core/djangolib/markup.py
index c932fb91b974..b69e10b1f91a 100644
--- a/openedx/core/djangolib/markup.py
+++ b/openedx/core/djangolib/markup.py
@@ -2,7 +2,6 @@
 Utilities for use in Mako markup.
 """
 
-
 import markupsafe
 import nh3
 from lxml.html.clean import Cleaner
@@ -11,10 +10,10 @@
 # Text() can be used to declare a string as plain text, as HTML() is used
 # for HTML.  It simply wraps markupsafe's escape, which will HTML-escape if
 # it isn't already escaped.
-Text = markupsafe.escape                        # pylint: disable=invalid-name
+Text = markupsafe.escape  # pylint: disable=invalid-name
 
 
-def HTML(html):                                 # pylint: disable=invalid-name
+def HTML(html):  # pylint: disable=invalid-name
     """
     Mark a string as already HTML, so that it won't be escaped before output.
 
@@ -53,7 +52,7 @@ def strip_all_tags_but_br(string_to_strip):
         string_to_strip = ""
 
     string_to_strip = decode.utf8(string_to_strip)
-    string_to_strip = nh3.clean(string_to_strip, tags={'br'})
+    string_to_strip = nh3.clean(string_to_strip, tags={"br"})
 
     return HTML(string_to_strip)
 
diff --git a/openedx/core/djangolib/tests/test_markup.py b/openedx/core/djangolib/tests/test_markup.py
index a7a66902af2f..65c47972a2fc 100644
--- a/openedx/core/djangolib/tests/test_markup.py
+++ b/openedx/core/djangolib/tests/test_markup.py
@@ -2,7 +2,6 @@
 Tests for openedx.core.djangolib.markup
 """
 
-
 import unittest
 
 import ddt
@@ -22,7 +21,7 @@ class FormatHtmlTest(unittest.TestCase):
         ("hello", "hello"),
         ("<hello>", "&lt;hello&gt;"),
         ("It's cool", "It&#39;s cool"),
-        ('"cool," she said.', '&#34;cool,&#34; she said.'),
+        ('"cool," she said.', "&#34;cool,&#34; she said."),
         ("Stop & Shop", "Stop &amp; Shop"),
         ("<a>нтмℓ-єѕ¢αρє∂</a>", "&lt;a&gt;нтмℓ-єѕ¢αρє∂&lt;/a&gt;"),
     )
@@ -59,18 +58,18 @@ def test_mako(self):
                 %>
                 ${Text(_(u"A & {BC}")).format(BC=HTML("B & C"))}
             """,
-            default_filters=['decode.utf8', 'h'],
+            default_filters=["decode.utf8", "h"],
         )
         out = template.render()
-        assert out.strip() == 'A &amp; B & C'
+        assert out.strip() == "A &amp; B & C"
 
     def test_ungettext(self):
         for i in [1, 2]:
             out = Text(ngettext("1 & {}", "2 & {}", i)).format(HTML("<>"))
-            assert out == f'{i} &amp; <>'
+            assert out == f"{i} &amp; <>"
 
     def test_strip_all_tags_but_br_filter(self):
-        """ Verify filter removes every tags except br """
+        """Verify filter removes every tags except br"""
         template = Template(
             """
                 <%page expression_filter="h"/>
@@ -82,20 +81,20 @@ def test_strip_all_tags_but_br_filter(self):
         )
         rendered_template = template.render()
 
-        assert '<br>' in rendered_template
-        assert '<script>' not in rendered_template
+        assert "<br>" in rendered_template
+        assert "<script>" not in rendered_template
 
     def test_strip_all_tags_but_br_returns_html(self):
         """
         Verify filter returns HTML Markup safe string object
         """
 
-        html = strip_all_tags_but_br('{name}<br><script>')
-        html = html.format(name='Rock & Roll')
-        assert str(html) == 'Rock &amp; Roll<br>'
+        html = strip_all_tags_but_br("{name}<br><script>")
+        html = html.format(name="Rock & Roll")
+        assert str(html) == "Rock &amp; Roll<br>"
 
     def test_clean_dengers_html_filter(self):
-        """ Verify filter removes expected tags """
+        """Verify filter removes expected tags"""
         template = Template(
             """
                 <%page expression_filter="h"/>
@@ -139,21 +138,21 @@ def test_clean_dengers_html_filter(self):
             """
         )
         rendered_template = template.render()
-        html_soup = BeautifulSoup(rendered_template, 'html.parser')
-
-        assert html_soup.find('a')
-        assert html_soup.find('div')
-        assert html_soup.find('div', attrs={'style': 'display: none'})
-        assert html_soup.find('p')
-        assert html_soup.find('img')
-
-        assert not html_soup.find('a', attrs={'onclick': 'evil_function()'})
-        assert not html_soup.find('html')
-        assert not html_soup.find('head')
-        assert not html_soup.find('script')
-        assert not html_soup.find('style')
-        assert not html_soup.find('link')
-        assert not html_soup.find('iframe')
-        assert not html_soup.find('form')
-        assert not html_soup.find('blink')
-        assert not html_soup.find('object')
+        html_soup = BeautifulSoup(rendered_template, "html.parser")
+
+        assert html_soup.find("a")
+        assert html_soup.find("div")
+        assert html_soup.find("div", attrs={"style": "display: none"})
+        assert html_soup.find("p")
+        assert html_soup.find("img")
+
+        assert not html_soup.find("a", attrs={"onclick": "evil_function()"})
+        assert not html_soup.find("html")
+        assert not html_soup.find("head")
+        assert not html_soup.find("script")
+        assert not html_soup.find("style")
+        assert not html_soup.find("link")
+        assert not html_soup.find("iframe")
+        assert not html_soup.find("form")
+        assert not html_soup.find("blink")
+        assert not html_soup.find("object")
diff --git a/openedx/core/lib/safe_lxml/xmlparser.py b/openedx/core/lib/safe_lxml/xmlparser.py
index f886eac33518..252e9ac04b29 100644
--- a/openedx/core/lib/safe_lxml/xmlparser.py
+++ b/openedx/core/lib/safe_lxml/xmlparser.py
@@ -2,13 +2,12 @@
 #
 """lxml.etree protection"""
 
-from __future__ import print_function, absolute_import
+from __future__ import absolute_import, print_function
 
 import threading
 
-from lxml import etree as _etree
-
 from defusedxml.common import DTDForbidden, EntitiesForbidden, NotSupportedError
+from lxml import etree as _etree
 
 LXML3 = _etree.LXML_VERSION[0] >= 3
 
@@ -18,8 +17,7 @@
 
 
 class RestrictedElement(_etree.ElementBase):
-    """A restricted Element class that filters out instances of some classes
-    """
+    """A restricted Element class that filters out instances of some classes"""
 
     __slots__ = ()
     blacklist = (_etree._Entity, _etree._ProcessingInstruction, _etree._Comment)  # pylint: disable=protected-access
@@ -36,7 +34,9 @@ def __iter__(self):
         return self._filter(iterator)
 
     def iterchildren(self, tag=None, reversed=False):  # pylint: disable=redefined-builtin
-        iterator = super(RestrictedElement, self).iterchildren(tag=tag, reversed=reversed)  # pylint: disable=super-with-arguments
+        iterator = super(RestrictedElement, self).iterchildren(  # pylint: disable=super-with-arguments
+            tag=tag, reversed=reversed
+        )
         return self._filter(iterator)
 
     def iter(self, tag=None, *tags):  # pylint: disable=keyword-arg-before-vararg
@@ -44,11 +44,15 @@ def iter(self, tag=None, *tags):  # pylint: disable=keyword-arg-before-vararg
         return self._filter(iterator)
 
     def iterdescendants(self, tag=None, *tags):  # pylint: disable=keyword-arg-before-vararg
-        iterator = super(RestrictedElement, self).iterdescendants(tag=tag, *tags)  # pylint: disable=super-with-arguments
+        iterator = super(RestrictedElement, self).iterdescendants(  # pylint: disable=super-with-arguments
+            tag=tag, *tags
+        )
         return self._filter(iterator)
 
     def itersiblings(self, tag=None, preceding=False):
-        iterator = super(RestrictedElement, self).itersiblings(tag=tag, preceding=preceding)  # pylint: disable=super-with-arguments
+        iterator = super(RestrictedElement, self).itersiblings(  # pylint: disable=super-with-arguments
+            tag=tag, preceding=preceding
+        )
         return self._filter(iterator)
 
     def getchildren(self):
@@ -61,8 +65,7 @@ def getiterator(self, tag=None):
 
 
 class GlobalParserTLS(threading.local):
-    """Thread local context for custom parser instances
-    """
+    """Thread local context for custom parser instances"""
 
     parser_config = {
         "resolve_entities": False,
@@ -104,7 +107,9 @@ def check_docinfo(elementtree, forbid_dtd=False, forbid_entities=True):
             raise DTDForbidden(docinfo.doctype, docinfo.system_url, docinfo.public_id)
         if forbid_entities and not LXML3:
             # lxml < 3 has no iterentities()
-            raise NotSupportedError("Unable to check for entity declarations " "in lxml 2.x")  # pylint: disable=implicit-str-concat
+            raise NotSupportedError(
+                "Unable to check for entity declarations in lxml 2.x"
+            )  # pylint: disable=implicit-str-concat
 
     if forbid_entities:
         for dtd in docinfo.internalDTD, docinfo.externalDTD:
@@ -114,7 +119,9 @@ def check_docinfo(elementtree, forbid_dtd=False, forbid_entities=True):
                 raise EntitiesForbidden(entity.name, entity.content, None, None, None, None)
 
 
-def parse(source, parser=None, base_url=None, forbid_dtd=False, forbid_entities=True):  # pylint: disable=missing-function-docstring
+def parse(
+    source, parser=None, base_url=None, forbid_dtd=False, forbid_entities=True
+):  # pylint: disable=missing-function-docstring
     if parser is None:
         parser = getDefaultParser()
     elementtree = _etree.parse(source, parser, base_url=base_url)
@@ -122,7 +129,9 @@ def parse(source, parser=None, base_url=None, forbid_dtd=False, forbid_entities=
     return elementtree
 
 
-def fromstring(text, parser=None, base_url=None, forbid_dtd=False, forbid_entities=True):  # pylint: disable=missing-function-docstring
+def fromstring(
+    text, parser=None, base_url=None, forbid_dtd=False, forbid_entities=True
+):  # pylint: disable=missing-function-docstring
     if parser is None:
         parser = getDefaultParser()
     rootelement = _etree.fromstring(text, parser, base_url=base_url)
diff --git a/setup.cfg b/setup.cfg
index 74ae82786ed5..50b7bd080d34 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -40,9 +40,11 @@ python_files = tests.py test_*.py tests_*.py *_tests.py __init__.py
 #   http://nedbatchelder.com/blog/200711/rethrowing_exceptions_in_python.html
 #   It's a little unusual, but we have good reasons for doing so, so we disable
 #   this rule.
+# E203: whitespace before ':'
+#   We ignore this because of black formatter defaults
 # E305,E402,E722,E731,E741,E743,W503,W504: errors and warnings added since pep8/pycodestyle
 # 1.5.7 that we haven't cleaned up yet
-ignore=E265,E266,E305,E402,E501,E722,E731,E741,E743,W503,W504,W602
+ignore=E203,E265,E266,E305,E402,E501,E722,E731,E741,E743,W503,W504,W602
 exclude=migrations,.git,.pycharm_helpers,.tox,test_root/staticfiles,node_modules
 
 [isort]
diff --git a/xmodule/capa/capa_problem.py b/xmodule/capa/capa_problem.py
index dfdf58857209..3203ad6bf1d9 100644
--- a/xmodule/capa/capa_problem.py
+++ b/xmodule/capa/capa_problem.py
@@ -24,7 +24,6 @@
 from xml.sax.saxutils import unescape
 
 from django.conf import settings
-
 from lxml import etree
 from pytz import UTC
 
@@ -32,25 +31,25 @@
 import xmodule.capa.inputtypes as inputtypes
 import xmodule.capa.responsetypes as responsetypes
 import xmodule.capa.xqueue_interface as xqueue_interface
+from openedx.core.djangolib.markup import HTML, Text
+from openedx.core.lib.safe_lxml.xmlparser import XML
 from xmodule.capa.correctmap import CorrectMap
 from xmodule.capa.safe_exec import safe_exec
 from xmodule.capa.util import contextualize_text, convert_files_to_filenames, get_course_id_from_capa_block
-from openedx.core.djangolib.markup import HTML, Text
-from openedx.core.lib.safe_lxml.xmlparser import XML
 from xmodule.stringify import stringify_children
 
 # extra things displayed after "show answers" is pressed
-solution_tags = ['solution']
+solution_tags = ["solution"]
 
 # fully accessible capa input types
 ACCESSIBLE_CAPA_INPUT_TYPES = [
-    'checkboxgroup',
-    'radiogroup',
-    'choicegroup',
-    'optioninput',
-    'textline',
-    'formulaequationinput',
-    'textbox',
+    "checkboxgroup",
+    "radiogroup",
+    "choicegroup",
+    "optioninput",
+    "textline",
+    "formulaequationinput",
+    "textbox",
 ]
 
 # these get captured as student responses
@@ -58,9 +57,9 @@
 
 # special problem tags which should be turned into innocuous HTML
 html_transforms = {
-    'problem': {'tag': 'div'},
-    'text': {'tag': 'span'},
-    'math': {'tag': 'span'},
+    "problem": {"tag": "div"},
+    "text": {"tag": "span"},
+    "math": {"tag": "span"},
 }
 
 # These should be removed from HTML output, including all subelements
@@ -77,7 +76,7 @@
 
 log = logging.getLogger(__name__)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # main class for this module
 
 
@@ -108,21 +107,21 @@ def __init__(
         i18n,
         render_template,
         resources_fs,
-        seed,      # Why do we do this if we have self.seed?
+        seed,  # Why do we do this if we have self.seed?
         xqueue,
-        matlab_api_key=None
+        matlab_api_key=None,
     ):
         self.ajax_url = ajax_url
         self.anonymous_student_id = anonymous_student_id
         self.cache = cache
         self.can_execute_unsafe_code = can_execute_unsafe_code
         self.get_python_lib_zip = get_python_lib_zip
-        self.DEBUG = DEBUG                              # pylint: disable=invalid-name
+        self.DEBUG = DEBUG  # pylint: disable=invalid-name
         self.i18n = i18n
         self.render_template = render_template
         self.resources_fs = resources_fs
-        self.seed = seed                     # Why do we do this if we have self.seed?
-        self.STATIC_URL = settings.STATIC_URL           # pylint: disable=invalid-name
+        self.seed = seed  # Why do we do this if we have self.seed?
+        self.STATIC_URL = settings.STATIC_URL  # pylint: disable=invalid-name
         self.xqueue = xqueue
         self.matlab_api_key = matlab_api_key
 
@@ -132,8 +131,17 @@ class LoncapaProblem(object):
     Main class for capa Problems.
     """
 
-    def __init__(self, problem_text, id, capa_system, capa_block,  # pylint: disable=redefined-builtin
-                 state=None, seed=None, minimal_init=False, extract_tree=True):
+    def __init__(
+        self,
+        problem_text,
+        id,  # pylint: disable=redefined-builtin
+        capa_system,
+        capa_block,
+        state=None,
+        seed=None,
+        minimal_init=False,
+        extract_tree=True,
+    ):
         """
         Initializes capa Problem.
 
@@ -168,21 +176,21 @@ def __init__(self, problem_text, id, capa_system, capa_block,  # pylint: disable
         # Set seed according to the following priority:
         #       1. Contained in problem's state
         #       2. Passed into capa_problem via constructor
-        self.seed = state.get('seed', seed)
+        self.seed = state.get("seed", seed)
         assert self.seed is not None, "Seed must be provided for LoncapaProblem."
 
-        self.student_answers = state.get('student_answers', {})
-        self.has_saved_answers = state.get('has_saved_answers', False)
-        if 'correct_map' in state:
-            self.correct_map.set_dict(state['correct_map'])
+        self.student_answers = state.get("student_answers", {})
+        self.has_saved_answers = state.get("has_saved_answers", False)
+        if "correct_map" in state:
+            self.correct_map.set_dict(state["correct_map"])
             self.correct_map_history = []
-            for cmap in state.get('correct_map_history', []):
+            for cmap in state.get("correct_map_history", []):
                 correct_map = CorrectMap()
                 correct_map.set_dict(cmap)
                 self.correct_map_history.append(correct_map)
 
-        self.done = state.get('done', False)
-        self.input_state = state.get('input_state', {})
+        self.done = state.get("done", False)
+        self.input_state = state.get("input_state", {})
 
         # Convert startouttext and endouttext to proper <text></text>
         problem_text = re.sub(r"startouttext\s*/", "text", problem_text)
@@ -192,7 +200,7 @@ def __init__(self, problem_text, id, capa_system, capa_block,  # pylint: disable
         # parse problem XML file into an element tree
         if isinstance(problem_text, str):
             # etree chokes on Unicode XML with an encoding declaration
-            problem_text = problem_text.encode('utf-8')
+            problem_text = problem_text.encode("utf-8")
         self.tree = XML(problem_text)
 
         try:
@@ -200,10 +208,7 @@ def __init__(self, problem_text, id, capa_system, capa_block,  # pylint: disable
         except Exception:
             capa_block = self.capa_block
             log.exception(
-                "CAPAProblemError: %s, id:%s, data: %s",
-                capa_block.display_name,
-                self.problem_id,
-                capa_block.data
+                "CAPAProblemError: %s, id:%s, data: %s", capa_block.display_name, self.problem_id, capa_block.data
             )
             raise
 
@@ -233,9 +238,9 @@ def __init__(self, problem_text, id, capa_system, capa_block,  # pylint: disable
             # Run response late_transforms last (see MultipleChoiceResponse)
             # Sort the responses to be in *_1 *_2 ... order.
             responses = list(self.responders.values())
-            responses = sorted(responses, key=lambda resp: int(resp.id[resp.id.rindex('_') + 1:]))
+            responses = sorted(responses, key=lambda resp: int(resp.id[resp.id.rindex("_") + 1 :]))
             for response in responses:
-                if hasattr(response, 'late_transforms'):
+                if hasattr(response, "late_transforms"):
                     response.late_transforms(self)
 
             if extract_tree:
@@ -248,7 +253,7 @@ def is_grading_method_enabled(self) -> bool:
         feature is not enabled, the grading method field will not be shown in
         Studio settings and the default grading method will be used.
         """
-        return settings.FEATURES.get('ENABLE_GRADING_METHOD_IN_PROBLEMS', False)
+        return settings.FEATURES.get("ENABLE_GRADING_METHOD_IN_PROBLEMS", False)
 
     def make_xml_compatible(self, tree):
         """
@@ -270,6 +275,7 @@ def make_xml_compatible(self, tree):
         This translation takes in the new format and synthesizes the old option= attribute
         so all downstream logic works unchanged with the new <option> tag format.
         """
+
         def is_optioninput_valid(optioninput):
             """
             Verifies if a given optioninput xml is valid or not.
@@ -281,36 +287,34 @@ def is_optioninput_valid(optioninput):
             Returns:
                 boolean: signifying if the optioninput is valid or not.
             """
-            correct_options = [
-                option.get('correct').upper() == 'TRUE' for option in optioninput.findall('./option')
-            ]
+            correct_options = [option.get("correct").upper() == "TRUE" for option in optioninput.findall("./option")]
             return correct_options.count(True) in (0, 1)
 
-        additionals = tree.xpath('//stringresponse/additional_answer')
+        additionals = tree.xpath("//stringresponse/additional_answer")
         for additional in additionals:
-            answer = additional.get('answer')
+            answer = additional.get("answer")
             text = additional.text
             if not answer and text:  # trigger of old->new conversion
-                additional.set('answer', text)
-                additional.text = ''
-        for optioninput in tree.xpath('//optioninput'):
+                additional.set("answer", text)
+                additional.text = ""
+        for optioninput in tree.xpath("//optioninput"):
             if not is_optioninput_valid(optioninput):
                 raise responsetypes.LoncapaProblemError("Dropdown questions can only have one correct answer.")
             correct_option = None
             child_options = []
-            for option_element in optioninput.findall('./option'):
+            for option_element in optioninput.findall("./option"):
                 text = option_element.text
-                text = text or ''
+                text = text or ""
                 option_name = text.strip()
-                if option_element.get('correct').upper() == 'TRUE':
+                if option_element.get("correct").upper() == "TRUE":
                     correct_option = option_name
                 child_options.append("'" + option_name + "'")
 
             if len(child_options) > 0:
-                options_string = '(' + ','.join(child_options) + ')'
-                optioninput.attrib.update({'options': options_string})
+                options_string = "(" + ",".join(child_options) + ")"
+                optioninput.attrib.update({"options": options_string})
                 if correct_option:
-                    optioninput.attrib.update({'correct': correct_option})
+                    optioninput.attrib.update({"correct": correct_option})
 
     def do_reset(self):
         """
@@ -329,7 +333,7 @@ def set_initial_display(self):
         """
         initial_answers = {}
         for responder in self.responders.values():
-            if hasattr(responder, 'get_initial_display'):
+            if hasattr(responder, "get_initial_display"):
                 initial_answers.update(responder.get_initial_display())
 
         self.student_answers = initial_answers
@@ -344,13 +348,15 @@ def get_state(self):
             2) Populate any student answers.
         """
 
-        return {'seed': self.seed,
-                'student_answers': self.student_answers,
-                'has_saved_answers': self.has_saved_answers,
-                'correct_map': self.correct_map.get_dict(),
-                'correct_map_history': [cmap.get_dict() for cmap in self.correct_map_history],
-                'input_state': self.input_state,
-                'done': self.done}
+        return {
+            "seed": self.seed,
+            "student_answers": self.student_answers,
+            "has_saved_answers": self.has_saved_answers,
+            "correct_map": self.correct_map.get_dict(),
+            "correct_map_history": [cmap.get_dict() for cmap in self.correct_map_history],
+            "input_state": self.input_state,
+            "done": self.done,
+        }
 
     def get_max_score(self):
         """
@@ -376,10 +382,10 @@ def calculate_score(self, correct_map=None):
             try:
                 correct += correct_map.get_npoints(key)
             except Exception:
-                log.error('key=%s, correct_map = %s', key, correct_map)
+                log.error("key=%s, correct_map = %s", key, correct_map)
                 raise
 
-        return {'score': correct, 'total': self.get_max_score()}
+        return {"score": correct, "total": self.get_max_score()}
 
     def update_score(self, score_msg, queuekey):
         """
@@ -391,7 +397,7 @@ def update_score(self, score_msg, queuekey):
         cmap = CorrectMap()
         cmap.update(self.correct_map)
         for responder in self.responders.values():
-            if hasattr(responder, 'update_score'):
+            if hasattr(responder, "update_score"):
                 # Each LoncapaResponse will update its specific entries in cmap
                 #   cmap is passed by reference
                 responder.update_score(score_msg, cmap, queuekey)
@@ -408,7 +414,7 @@ def ungraded_response(self, xqueue_msg, queuekey):
         # check against each inputtype
         for the_input in self.inputs.values():
             # if the input type has an ungraded function, pass in the values
-            if hasattr(the_input, 'ungraded_response'):
+            if hasattr(the_input, "ungraded_response"):
                 the_input.ungraded_response(xqueue_msg, queuekey)
 
     def is_queued(self):
@@ -433,8 +439,7 @@ def get_recentmost_queuetime(self):
             if self.correct_map.is_queued(answer_id)
         ]
         queuetimes = [
-            datetime.strptime(qt_str, xqueue_interface.dateformat).replace(tzinfo=UTC)
-            for qt_str in queuetime_strs
+            datetime.strptime(qt_str, xqueue_interface.dateformat).replace(tzinfo=UTC) for qt_str in queuetime_strs
         ]
 
         return max(queuetimes)
@@ -475,7 +480,7 @@ def supports_rescoring(self):
         that the responsetypes are synchronous.  This is convenient as it
         permits rescoring to be complete when the rescoring call returns.
         """
-        return all('filesubmission' not in responder.allowed_inputfields for responder in self.responders.values())
+        return all("filesubmission" not in responder.allowed_inputfields for responder in self.responders.values())
 
     def get_grade_from_current_answers(self, student_answers, correct_map: Optional[CorrectMap] = None):
         """
@@ -508,7 +513,7 @@ def get_grade_from_current_answers(self, student_answers, correct_map: Optional[
             # student_answers contains a proper answer or the filename of
             # an earlier submission, so for now skip these entirely.
             # TODO: figure out where to get file submissions when rescoring.
-            if 'filesubmission' in responder.allowed_inputfields and student_answers is None:
+            if "filesubmission" in responder.allowed_inputfields and student_answers is None:
                 _ = self.capa_system.i18n.gettext
                 raise Exception(_("Cannot rescore problems with possible file submissions"))
 
@@ -517,8 +522,7 @@ def get_grade_from_current_answers(self, student_answers, correct_map: Optional[
             # If grading method is enabled, we need to pass each student answers and the
             # correct map in the history fields.
             if (
-                "filesubmission" in responder.allowed_inputfields
-                and student_answers is not None
+                "filesubmission" in responder.allowed_inputfields and student_answers is not None
             ) or self.is_grading_method_enabled:
                 results = responder.evaluate_answers(student_answers, oldcmap)
             else:
@@ -542,11 +546,11 @@ def get_question_answers(self):
 
         # include solutions from <solution>...</solution> stanzas
         for entry in self.tree.xpath("//" + "|//".join(solution_tags)):
-            answer = etree.tostring(entry).decode('utf-8')
+            answer = etree.tostring(entry).decode("utf-8")
             if answer:
-                answer_map[entry.get('id')] = contextualize_text(answer, self.context)
+                answer_map[entry.get("id")] = contextualize_text(answer, self.context)
 
-        log.debug('answer_map = %s', answer_map)
+        log.debug("answer_map = %s", answer_map)
         return answer_map
 
     def get_answer_ids(self):
@@ -575,12 +579,12 @@ def find_correct_answer_text(self, answer_id):
         if not xml_elements:
             return
         xml_element = xml_elements[0]
-        answer_text = xml_element.xpath('@answer')
+        answer_text = xml_element.xpath("@answer")
         if answer_text:
             return answer_id[0]
-        if xml_element.tag == 'optioninput':
-            return xml_element.xpath('@correct')[0]
-        return ', '.join(xml_element.xpath('*[@correct="true"]/text()'))
+        if xml_element.tag == "optioninput":
+            return xml_element.xpath("@correct")[0]
+        return ", ".join(xml_element.xpath('*[@correct="true"]/text()'))
 
     def find_question_label(self, answer_id):
         """
@@ -608,13 +612,13 @@ def generate_default_question_label():
             which is used in question number 1 (see example XML in comment above)
             There's no question 0 (question IDs start at 1, answer IDs at 2)
             """
-            question_nr = int(answer_id.split('_')[-2]) - 1
+            question_nr = int(answer_id.split("_")[-2]) - 1
             return _("Question {}").format(question_nr)
 
         _ = self.capa_system.i18n.gettext
         # Some questions define a prompt with this format:   >>This is a prompt<<
         try:
-            prompt = self.problem_data[answer_id].get('label')
+            prompt = self.problem_data[answer_id].get("label")
         except KeyError:
             prompt = None
 
@@ -649,8 +653,8 @@ def generate_default_question_label():
             # then from the first optionresponse we'll end with the <p>.
             # If we start in the second optionresponse, we'll find another response in the way,
             # stop early, and instead of a question we'll report "Question 2".
-            SKIP_ELEMS = ['description']
-            LABEL_ELEMS = ['p', 'label']
+            SKIP_ELEMS = ["description"]
+            LABEL_ELEMS = ["p", "label"]
             while questiontext_elem is not None and questiontext_elem.tag in SKIP_ELEMS:
                 questiontext_elem = questiontext_elem.getprevious()
 
@@ -686,17 +690,16 @@ def find_answer_text(self, answer_id, current_answer):
         """
         if isinstance(current_answer, list):
             # Multiple answers. This case happens e.g. in multiple choice problems
-            answer_text = ", ".join(
-                self.find_answer_text(answer_id, answer) for answer in current_answer
-            )
+            answer_text = ", ".join(self.find_answer_text(answer_id, answer) for answer in current_answer)
 
-        elif isinstance(current_answer, str) and current_answer.startswith('choice_'):
+        elif isinstance(current_answer, str) and current_answer.startswith("choice_"):
             # Many problem (e.g. checkbox) report "choice_0" "choice_1" etc.
             # Here we transform it
-            elems = self.tree.xpath('//*[@id="{answer_id}"]//*[@name="{choice_number}"]'.format(
-                answer_id=answer_id,
-                choice_number=current_answer
-            ))
+            elems = self.tree.xpath(
+                '//*[@id="{answer_id}"]//*[@name="{choice_number}"]'.format(
+                    answer_id=answer_id, choice_number=current_answer
+                )
+            )
             if len(elems) == 0:
                 log.warning("Answer Text Missing for answer id: %s and choice number: %s", answer_id, current_answer)
                 answer_text = "Answer Text Missing"
@@ -726,51 +729,51 @@ def do_targeted_feedback(self, tree):
         """
         _ = self.capa_system.i18n.gettext
         # Note that the modifications has been done, avoiding problems if called twice.
-        if hasattr(self, 'has_targeted'):
+        if hasattr(self, "has_targeted"):
             return
         self.has_targeted = True  # pylint: disable=attribute-defined-outside-init
 
-        for mult_choice_response in tree.xpath('//multiplechoiceresponse[@targeted-feedback]'):
-            show_explanation = mult_choice_response.get('targeted-feedback') == 'alwaysShowCorrectChoiceExplanation'
+        for mult_choice_response in tree.xpath("//multiplechoiceresponse[@targeted-feedback]"):
+            show_explanation = mult_choice_response.get("targeted-feedback") == "alwaysShowCorrectChoiceExplanation"
 
             # Grab the first choicegroup (there should only be one within each <multiplechoiceresponse> tag)
             choicegroup = mult_choice_response.xpath('./choicegroup[@type="MultipleChoice"]')[0]
-            choices_list = list(choicegroup.iter('choice'))
+            choices_list = list(choicegroup.iter("choice"))
 
             # Find the student answer key that matches our <choicegroup> id
-            student_answer = self.student_answers.get(choicegroup.get('id'))
+            student_answer = self.student_answers.get(choicegroup.get("id"))
             expl_id_for_student_answer = None
 
             # Keep track of the explanation-id that corresponds to the student's answer
             # Also, keep track of the solution-id
             solution_id = None
-            choice_correctness_for_student_answer = _('Incorrect')
+            choice_correctness_for_student_answer = _("Incorrect")
             for choice in choices_list:
-                if choice.get('name') == student_answer:
-                    expl_id_for_student_answer = choice.get('explanation-id')
-                    if choice.get('correct') == 'true':
-                        choice_correctness_for_student_answer = _('Correct')
-                if choice.get('correct') == 'true':
-                    solution_id = choice.get('explanation-id')
+                if choice.get("name") == student_answer:
+                    expl_id_for_student_answer = choice.get("explanation-id")
+                    if choice.get("correct") == "true":
+                        choice_correctness_for_student_answer = _("Correct")
+                if choice.get("correct") == "true":
+                    solution_id = choice.get("explanation-id")
 
             # Filter out targetedfeedback that doesn't correspond to the answer the student selected
             # Note: following-sibling will grab all following siblings, so we just want the first in the list
-            targetedfeedbackset = mult_choice_response.xpath('./following-sibling::targetedfeedbackset')
+            targetedfeedbackset = mult_choice_response.xpath("./following-sibling::targetedfeedbackset")
             if len(targetedfeedbackset) != 0:
                 targetedfeedbackset = targetedfeedbackset[0]
-                targetedfeedbacks = targetedfeedbackset.xpath('./targetedfeedback')
+                targetedfeedbacks = targetedfeedbackset.xpath("./targetedfeedback")
                 # find the legend by id in choicegroup.html for aria-describedby
-                problem_legend_id = str(choicegroup.get('id')) + '-legend'
+                problem_legend_id = str(choicegroup.get("id")) + "-legend"
                 for targetedfeedback in targetedfeedbacks:
                     screenreadertext = etree.Element("span")
                     targetedfeedback.insert(0, screenreadertext)
-                    screenreadertext.set('class', 'sr')
+                    screenreadertext.set("class", "sr")
                     screenreadertext.text = choice_correctness_for_student_answer
-                    targetedfeedback.set('role', 'group')
-                    targetedfeedback.set('aria-describedby', problem_legend_id)
+                    targetedfeedback.set("role", "group")
+                    targetedfeedback.set("aria-describedby", problem_legend_id)
                     # Don't show targeted feedback if the student hasn't answer the problem
                     # or if the target feedback doesn't match the student's (incorrect) answer
-                    if not self.done or targetedfeedback.get('explanation-id') != expl_id_for_student_answer:
+                    if not self.done or targetedfeedback.get("explanation-id") != expl_id_for_student_answer:
                         targetedfeedbackset.remove(targetedfeedback)
 
             # Do not displace the solution under these circumstances
@@ -781,12 +784,12 @@ def do_targeted_feedback(self, tree):
             next_element = targetedfeedbackset.getnext()
             parent_element = tree
             solution_element = None
-            if next_element is not None and next_element.tag == 'solution':
+            if next_element is not None and next_element.tag == "solution":
                 solution_element = next_element
-            elif next_element is not None and next_element.tag == 'solutionset':
-                solutions = next_element.xpath('./solution')
+            elif next_element is not None and next_element.tag == "solutionset":
+                solutions = next_element.xpath("./solution")
                 for solution in solutions:
-                    if solution.get('explanation-id') == solution_id:
+                    if solution.get("explanation-id") == solution_id:
                         parent_element = next_element
                         solution_element = solution
 
@@ -800,7 +803,7 @@ def do_targeted_feedback(self, tree):
             parent_element.remove(solution_element)
 
             # Add our solution instead to the targetedfeedbackset and change its tag name
-            solution_element.tag = 'targetedfeedback'
+            solution_element.tag = "targetedfeedback"
 
             targetedfeedbackset.append(solution_element)
 
@@ -809,10 +812,7 @@ def get_html(self):
         Main method called externally to get the HTML to be rendered for this capa Problem.
         """
         self.do_targeted_feedback(self.tree)
-        html = contextualize_text(
-            etree.tostring(self._extract_html(self.tree)).decode('utf-8'),
-            self.context
-        )
+        html = contextualize_text(etree.tostring(self._extract_html(self.tree)).decode("utf-8"), self.context)
         return html
 
     def handle_input_ajax(self, data):
@@ -823,9 +823,9 @@ def handle_input_ajax(self, data):
         """
 
         # pull out the id
-        input_id = data['input_id']
+        input_id = data["input_id"]
         if self.inputs[input_id]:
-            dispatch = data['dispatch']
+            dispatch = data["dispatch"]
             return self.inputs[input_id].handle_ajax(dispatch, data)
         else:
             log.warning("Could not find matching input for id: %s", input_id)
@@ -838,22 +838,16 @@ def _process_includes(self):
         Handle any <include file="foo"> tags by reading in the specified file and inserting it
         into our XML tree.  Fail gracefully if debugging.
         """
-        includes = self.tree.findall('.//include')
+        includes = self.tree.findall(".//include")
         for inc in includes:
-            filename = inc.get('file')
+            filename = inc.get("file")
             if filename is not None:
                 try:
                     # open using LoncapaSystem OSFS filesystem
                     ifp = self.capa_system.resources_fs.open(filename)
                 except Exception as err:  # lint-amnesty, pylint: disable=broad-except
-                    log.warning(
-                        'Error %s in problem xml include: %s',
-                        err,
-                        etree.tostring(inc, pretty_print=True)
-                    )
-                    log.warning(
-                        'Cannot find file %s in %s', filename, self.capa_system.resources_fs
-                    )
+                    log.warning("Error %s in problem xml include: %s", err, etree.tostring(inc, pretty_print=True))
+                    log.warning("Cannot find file %s in %s", filename, self.capa_system.resources_fs)
                     # if debugging, don't fail - just log error
                     # TODO (vshnayder): need real error handling, display to users
                     if not self.capa_system.DEBUG:  # lint-amnesty, pylint: disable=no-else-raise
@@ -864,12 +858,8 @@ def _process_includes(self):
                     # read in and convert to XML
                     incxml = etree.XML(ifp.read())
                 except Exception as err:  # lint-amnesty, pylint: disable=broad-except
-                    log.warning(
-                        'Error %s in problem xml include: %s',
-                        err,
-                        etree.tostring(inc, pretty_print=True)
-                    )
-                    log.warning('Cannot parse XML in %s', (filename))
+                    log.warning("Error %s in problem xml include: %s", err, etree.tostring(inc, pretty_print=True))
+                    log.warning("Cannot parse XML in %s", (filename))
                     # if debugging, don't fail - just log error
                     # TODO (vshnayder): same as above
                     if not self.capa_system.DEBUG:  # lint-amnesty, pylint: disable=no-else-raise
@@ -881,7 +871,7 @@ def _process_includes(self):
                 parent = inc.getparent()
                 parent.insert(parent.index(inc), incxml)
                 parent.remove(inc)
-                log.debug('Included %s into %s', filename, self.problem_id)
+                log.debug("Included %s into %s", filename, self.problem_id)
 
     def _extract_system_path(self, script):
         """
@@ -892,10 +882,10 @@ def _extract_system_path(self, script):
         script : ?? (TODO)
         """
 
-        DEFAULT_PATH = ['code']
+        DEFAULT_PATH = ["code"]
 
         # Separate paths by :, like the system path.
-        raw_path = script.get('system_path', '').split(":") + DEFAULT_PATH
+        raw_path = script.get("system_path", "").split(":") + DEFAULT_PATH
 
         # find additional comma-separated modules search path
         path = []
@@ -926,20 +916,20 @@ def _extract_context(self, tree):
         Problem XML goes to Python execution context. Runs everything in script tags.
         """
         context = {}
-        context['seed'] = self.seed
-        context['anonymous_student_id'] = self.capa_system.anonymous_student_id
-        all_code = ''
+        context["seed"] = self.seed
+        context["anonymous_student_id"] = self.capa_system.anonymous_student_id
+        all_code = ""
 
         python_path = []
 
-        for script in tree.findall('.//script'):
+        for script in tree.findall(".//script"):
 
-            stype = script.get('type')
+            stype = script.get("type")
             if stype:
-                if 'javascript' in stype:
-                    continue    # skip javascript
-                if 'perl' in stype:
-                    continue        # skip perl
+                if "javascript" in stype:
+                    continue  # skip javascript
+                if "perl" in stype:
+                    continue  # skip perl
             # TODO: evaluate only python
 
             for d in self._extract_system_path(script):
@@ -966,21 +956,21 @@ def _extract_context(self, tree):
                     python_path=python_path,
                     extra_files=extra_files,
                     cache=self.capa_system.cache,
-                    limit_overrides_context=get_course_id_from_capa_block(
-                        self.capa_block
-                    ),
+                    limit_overrides_context=get_course_id_from_capa_block(self.capa_block),
                     slug=self.problem_id,
                     unsafely=self.capa_system.can_execute_unsafe_code(),
                 )
             except Exception as err:
-                log.exception("Error while execing script code: " + all_code)  # lint-amnesty, pylint: disable=logging-not-lazy
+                log.exception(  # lint-amnesty, pylint: disable=logging-not-lazy
+                    "Error while execing script code: " + all_code
+                )
                 msg = Text("Error while executing script code: %s" % str(err))
                 raise responsetypes.LoncapaProblemError(msg)
 
         # Store code source in context, along with the Python path needed to run it correctly.
-        context['script_code'] = all_code
-        context['python_path'] = python_path
-        context['extra_files'] = extra_files or None
+        context["script_code"] = all_code
+        context["python_path"] = python_path
+        context["extra_files"] = extra_files or None
         return context
 
     def _extract_html(self, problemtree):  # private
@@ -1000,25 +990,24 @@ def _extract_html(self, problemtree):  # private
             # other than to examine .tag to see if it's a string. :(
             return
 
-        if (problemtree.tag == 'script' and problemtree.get('type')
-                and 'javascript' in problemtree.get('type')):
+        if problemtree.tag == "script" and problemtree.get("type") and "javascript" in problemtree.get("type"):
             # leave javascript intact.
             return deepcopy(problemtree)
 
         if problemtree.tag in html_problem_semantics:
             return
 
-        problemid = problemtree.get('id')    # my ID
+        problemid = problemtree.get("id")  # my ID
 
         if problemtree.tag in inputtypes.registry.registered_tags():
             # If this is an inputtype subtree, let it render itself.
             response_data = self.problem_data[problemid]
 
-            status = 'unsubmitted'
-            msg = ''
-            hint = ''
+            status = "unsubmitted"
+            msg = ""
+            hint = ""
             hintmode = None
-            input_id = problemtree.get('id')
+            input_id = problemtree.get("id")
             answervariable = None
             if problemid in self.correct_map:
                 pid = input_id
@@ -1026,7 +1015,7 @@ def _extract_html(self, problemtree):  # private
                 # If we're withholding correctness, don't show adaptive hints either.
                 # Note that regular, "demand" hints will be shown, if the course author has added them to the problem.
                 if not self.capa_block.correctness_available():
-                    status = 'submitted'
+                    status = "submitted"
                 else:
                     # If the the problem has not been saved since the last submit set the status to the
                     # current correctness value and set the message as expected. Otherwise we do not want to
@@ -1037,9 +1026,9 @@ def _extract_html(self, problemtree):  # private
 
                     hint = self.correct_map.get_hint(pid)
                     hintmode = self.correct_map.get_hintmode(pid)
-                    answervariable = self.correct_map.get_property(pid, 'answervariable')
+                    answervariable = self.correct_map.get_property(pid, "answervariable")
 
-            value = ''
+            value = ""
             if self.student_answers and problemid in self.student_answers:
                 value = self.student_answers[problemid]
 
@@ -1048,18 +1037,18 @@ def _extract_html(self, problemtree):  # private
 
             # do the rendering
             state = {
-                'value': value,
-                'status': status,
-                'id': input_id,
-                'input_state': self.input_state[input_id],
-                'answervariable': answervariable,
-                'response_data': response_data,
-                'has_saved_answers': self.has_saved_answers,
-                'feedback': {
-                    'message': msg,
-                    'hint': hint,
-                    'hintmode': hintmode,
-                }
+                "value": value,
+                "status": status,
+                "id": input_id,
+                "input_state": self.input_state[input_id],
+                "answervariable": answervariable,
+                "response_data": response_data,
+                "has_saved_answers": self.has_saved_answers,
+                "feedback": {
+                    "message": msg,
+                    "hint": hint,
+                    "hintmode": hintmode,
+                },
             }
 
             input_type_cls = inputtypes.registry.get_class_for_tag(problemtree.tag)
@@ -1070,9 +1059,7 @@ def _extract_html(self, problemtree):  # private
         # let each Response render itself
         if problemtree in self.responders:
             overall_msg = self.correct_map.get_overall_message()
-            return self.responders[problemtree].render_html(
-                self._extract_html, response_msg=overall_msg
-            )
+            return self.responders[problemtree].render_html(self._extract_html, response_msg=overall_msg)
 
         # let each custom renderer render itself:
         if problemtree.tag in customrender.registry.registered_tags():
@@ -1088,10 +1075,10 @@ def _extract_html(self, problemtree):  # private
                 tree.append(item_xhtml)
 
         if tree.tag in html_transforms:
-            tree.tag = html_transforms[problemtree.tag]['tag']
+            tree.tag = html_transforms[problemtree.tag]["tag"]
         else:
             # copy attributes over if not innocufying
-            for (key, value) in problemtree.items():
+            for key, value in problemtree.items():
                 tree.set(key, value)
 
         tree.text = problemtree.text
@@ -1113,24 +1100,23 @@ def _preprocess_problem(self, tree, minimal_init):  # private
         response_id = 1
         problem_data = {}
         self.responders = {}
-        for response in tree.xpath('//' + "|//".join(responsetypes.registry.registered_tags())):
+        for response in tree.xpath("//" + "|//".join(responsetypes.registry.registered_tags())):
             responsetype_id = self.problem_id + "_" + str(response_id)
             # create and save ID for this response
-            response.set('id', responsetype_id)
+            response.set("id", responsetype_id)
             response_id += 1
 
             answer_id = 1
             input_tags = inputtypes.registry.registered_tags()
             inputfields = tree.xpath(
-                "|".join(['//' + response.tag + '[@id=$id]//' + x for x in input_tags]),
-                id=responsetype_id
+                "|".join(["//" + response.tag + "[@id=$id]//" + x for x in input_tags]), id=responsetype_id
             )
 
             # assign one answer_id for each input type
             for entry in inputfields:
-                entry.attrib['response_id'] = str(response_id)
-                entry.attrib['answer_id'] = str(answer_id)
-                entry.attrib['id'] = "%s_%i_%i" % (self.problem_id, response_id, answer_id)
+                entry.attrib["response_id"] = str(response_id)
+                entry.attrib["answer_id"] = str(answer_id)
+                entry.attrib["id"] = "%s_%i_%i" % (self.problem_id, response_id, answer_id)
                 answer_id = answer_id + 1
 
             self.response_a11y_data(response, inputfields, responsetype_id, problem_data)
@@ -1151,16 +1137,17 @@ def _preprocess_problem(self, tree, minimal_init):  # private
                 try:
                     self.responder_answers[response] = self.responders[response].get_answers()
                 except:
-                    log.debug('responder %s failed to properly return get_answers()',
-                              self.responders[response])  # FIXME
+                    log.debug(
+                        "responder %s failed to properly return get_answers()", self.responders[response]
+                    )  # FIXME
                     raise
 
             # <solution>...</solution> may not be associated with any specific response; give
             # IDs for those separately
             # TODO: We should make the namespaces consistent and unique (e.g. %s_problem_%i).
             solution_id = 1
-            for solution in tree.findall('.//solution'):
-                solution.attrib['id'] = "%s_solution_%i" % (self.problem_id, solution_id)
+            for solution in tree.findall(".//solution"):
+                solution.attrib["id"] = "%s_solution_%i" % (self.problem_id, solution_id)
                 solution_id += 1
 
         return problem_data
@@ -1180,61 +1167,61 @@ def response_a11y_data(self, response, inputfields, responsetype_id, problem_dat
             return
 
         element_to_be_deleted = None
-        label = ''
+        label = ""
 
         if len(inputfields) > 1:
-            response.set('multiple_inputtypes', 'true')
-            group_label_tag = response.find('label')
-            group_description_tags = response.findall('description')
-            group_label_tag_id = 'multiinput-group-label-{}'.format(responsetype_id)
-            group_label_tag_text = ''
+            response.set("multiple_inputtypes", "true")
+            group_label_tag = response.find("label")
+            group_description_tags = response.findall("description")
+            group_label_tag_id = "multiinput-group-label-{}".format(responsetype_id)
+            group_label_tag_text = ""
             if group_label_tag is not None:
-                group_label_tag.tag = 'p'
-                group_label_tag.set('id', group_label_tag_id)
-                group_label_tag.set('class', 'multi-inputs-group-label')
+                group_label_tag.tag = "p"
+                group_label_tag.set("id", group_label_tag_id)
+                group_label_tag.set("class", "multi-inputs-group-label")
                 group_label_tag_text = stringify_children(group_label_tag)
-                response.set('multiinput-group-label-id', group_label_tag_id)
+                response.set("multiinput-group-label-id", group_label_tag_id)
 
             group_description_ids = []
             for index, group_description_tag in enumerate(group_description_tags):
-                group_description_tag_id = 'multiinput-group-description-{}-{}'.format(responsetype_id, index)
-                group_description_tag.tag = 'p'
-                group_description_tag.set('id', group_description_tag_id)
-                group_description_tag.set('class', 'multi-inputs-group-description question-description')
+                group_description_tag_id = "multiinput-group-description-{}-{}".format(responsetype_id, index)
+                group_description_tag.tag = "p"
+                group_description_tag.set("id", group_description_tag_id)
+                group_description_tag.set("class", "multi-inputs-group-description question-description")
                 group_description_ids.append(group_description_tag_id)
 
             if group_description_ids:
-                response.set('multiinput-group_description_ids', ' '.join(group_description_ids))
+                response.set("multiinput-group_description_ids", " ".join(group_description_ids))
 
             for inputfield in inputfields:
-                problem_data[inputfield.get('id')] = {
-                    'group_label': group_label_tag_text,
-                    'label': HTML(inputfield.attrib.get('label', '')),
-                    'descriptions': {}
+                problem_data[inputfield.get("id")] = {
+                    "group_label": group_label_tag_text,
+                    "label": HTML(inputfield.attrib.get("label", "")),
+                    "descriptions": {},
                 }
         else:
             # Extract label value from <label> tag or label attribute from inside the responsetype
-            responsetype_label_tag = response.find('label')
+            responsetype_label_tag = response.find("label")
             if responsetype_label_tag is not None:
                 label = stringify_children(responsetype_label_tag)
                 # store <label> tag containing question text to delete
                 # it later otherwise question will be rendered twice
                 element_to_be_deleted = responsetype_label_tag
-            elif 'label' in inputfields[0].attrib:
+            elif "label" in inputfields[0].attrib:
                 # in this case we have old problems with label attribute and p tag having question in it
                 # we will pick the first sibling of responsetype if its a p tag and match the text with
                 # the label attribute text. if they are equal then we will use this text as question.
                 # Get first <p> tag before responsetype, this <p> may contains the question text.
-                p_tag = response.xpath('preceding-sibling::*[1][self::p]')
+                p_tag = response.xpath("preceding-sibling::*[1][self::p]")
 
-                if p_tag and p_tag[0].text == inputfields[0].attrib['label']:
+                if p_tag and p_tag[0].text == inputfields[0].attrib["label"]:
                     label = stringify_children(p_tag[0])
                     element_to_be_deleted = p_tag[0]
             else:
                 # In this case the problems don't have tag or label attribute inside the responsetype
                 # so we will get the first preceding label tag w.r.t to this responsetype.
                 # This will take care of those multi-question problems that are not using --- in their markdown.
-                label_tag = response.xpath('preceding-sibling::*[1][self::label]')
+                label_tag = response.xpath("preceding-sibling::*[1][self::label]")
                 if label_tag:
                     label = stringify_children(label_tag[0])
                     element_to_be_deleted = label_tag[0]
@@ -1244,17 +1231,17 @@ def response_a11y_data(self, response, inputfields, responsetype_id, problem_dat
                 element_to_be_deleted.getparent().remove(element_to_be_deleted)
 
             # Extract descriptions and set unique id on each description tag
-            description_tags = response.findall('description')
+            description_tags = response.findall("description")
             description_id = 1
             descriptions = OrderedDict()
             for description in description_tags:
-                descriptions[
-                    "description_%s_%i" % (responsetype_id, description_id)
-                ] = HTML(stringify_children(description))
+                descriptions["description_%s_%i" % (responsetype_id, description_id)] = HTML(
+                    stringify_children(description)
+                )
                 response.remove(description)
                 description_id += 1
 
-            problem_data[inputfields[0].get('id')] = {
-                'label': HTML(label.strip()) if label else '',
-                'descriptions': descriptions
+            problem_data[inputfields[0].get("id")] = {
+                "label": HTML(label.strip()) if label else "",
+                "descriptions": descriptions,
             }
diff --git a/xmodule/capa/checker.py b/xmodule/capa/checker.py
index bcbdd85e5260..1a128cf98e1a 100755
--- a/xmodule/capa/checker.py
+++ b/xmodule/capa/checker.py
@@ -16,12 +16,12 @@
 from xmodule.capa.capa_problem import LoncapaProblem
 
 logging.basicConfig(format="%(levelname)s %(message)s")
-log = logging.getLogger('capa.checker')
+log = logging.getLogger("capa.checker")
 
 
 class DemoSystem(object):  # lint-amnesty, pylint: disable=missing-class-docstring
     def __init__(self):
-        self.lookup = TemplateLookup(directories=[path(__file__).dirname() / 'templates'])
+        self.lookup = TemplateLookup(directories=[path(__file__).dirname() / "templates"])
         self.DEBUG = True
 
     def render_template(self, template_filename, dictionary):
@@ -32,13 +32,16 @@ def render_template(self, template_filename, dictionary):
 
 
 def main():  # lint-amnesty, pylint: disable=missing-function-docstring
-    parser = argparse.ArgumentParser(description='Check Problem Files')
-    parser.add_argument("command", choices=['test', 'show'])  # Watch? Render? Open?
-    parser.add_argument("files", nargs="+", type=argparse.FileType('r'))
+    parser = argparse.ArgumentParser(description="Check Problem Files")
+    parser.add_argument("command", choices=["test", "show"])  # Watch? Render? Open?
+    parser.add_argument("files", nargs="+", type=argparse.FileType("r"))
     parser.add_argument("--seed", required=False, type=int)
-    parser.add_argument("--log-level", required=False, default="INFO",
-                        choices=['info', 'debug', 'warn', 'error',
-                                 'INFO', 'DEBUG', 'WARN', 'ERROR'])
+    parser.add_argument(
+        "--log-level",
+        required=False,
+        default="INFO",
+        choices=["info", "debug", "warn", "error", "INFO", "DEBUG", "WARN", "ERROR"],
+    )
 
     args = parser.parse_args()
     log.setLevel(args.log_level.upper())
@@ -49,15 +52,17 @@ def main():  # lint-amnesty, pylint: disable=missing-function-docstring
         log.info("Opening {0}".format(problem_file.name))
 
         try:
-            problem = LoncapaProblem(problem_file, "fakeid", seed=args.seed, system=system)  # lint-amnesty, pylint: disable=no-value-for-parameter, unexpected-keyword-arg
+            problem = LoncapaProblem(  # lint-amnesty, pylint: disable=no-value-for-parameter, unexpected-keyword-arg
+                problem_file, "fakeid", seed=args.seed, system=system
+            )
         except Exception as ex:  # lint-amnesty, pylint: disable=broad-except
             log.error("Could not parse file {0}".format(problem_file.name))
             log.exception(ex)
             continue
 
-        if args.command == 'test':
+        if args.command == "test":
             command_test(problem)
-        elif args.command == 'show':
+        elif args.command == "show":
             command_show(problem)
 
         problem_file.close()
@@ -80,10 +85,8 @@ def command_test(problem):  # lint-amnesty, pylint: disable=missing-function-doc
         check_that_suggested_answers_work(problem)
         check_that_blanks_fail(problem)
 
-        log_captured_output(sys.stdout,
-                            "captured stdout from {0}".format(problem))
-        log_captured_output(sys.stderr,
-                            "captured stderr from {0}".format(problem))
+        log_captured_output(sys.stdout, "captured stdout from {0}".format(problem))
+        log_captured_output(sys.stderr, "captured stderr from {0}".format(problem))
     except Exception as e:  # lint-amnesty, pylint: disable=broad-except
         log.exception(e)
     finally:
@@ -92,17 +95,16 @@ def command_test(problem):  # lint-amnesty, pylint: disable=missing-function-doc
 
 def check_that_blanks_fail(problem):
     """Leaving it blank should never work. Neither should a space."""
-    blank_answers = dict((answer_id, "")
-                         for answer_id in problem.get_question_answers())
+    blank_answers = dict((answer_id, "") for answer_id in problem.get_question_answers())
     grading_results = problem.grade_answers(blank_answers)
     try:
-        assert all(result == 'incorrect' for result in grading_results.values())
+        assert all(result == "incorrect" for result in grading_results.values())
     except AssertionError:
-        log.error("Blank accepted as correct answer in {0} for {1}"
-                  .format(problem,
-                          [answer_id for answer_id, result
-                           in sorted(grading_results.items())
-                           if result != 'incorrect']))
+        log.error(
+            "Blank accepted as correct answer in {0} for {1}".format(
+                problem, [answer_id for answer_id, result in sorted(grading_results.items()) if result != "incorrect"]
+            )
+        )
 
 
 def check_that_suggested_answers_work(problem):
@@ -122,26 +124,27 @@ def check_that_suggested_answers_work(problem):
     # all_answers is real_answers + blanks for other answer_ids for which the
     # responsetypes can't provide us pre-canned answers (customresponse)
     all_answer_ids = problem.get_answer_ids()
-    all_answers = dict((answer_id, real_answers.get(answer_id, ""))
-                       for answer_id in all_answer_ids)
+    all_answers = dict((answer_id, real_answers.get(answer_id, "")) for answer_id in all_answer_ids)
 
     log.debug("Real answers: {0}".format(real_answers))
     if real_answers:
         try:
-            real_results = dict((answer_id, result) for answer_id, result
-                                in problem.grade_answers(all_answers).items()
-                                if answer_id in real_answers)
+            real_results = dict(
+                (answer_id, result)
+                for answer_id, result in problem.grade_answers(all_answers).items()
+                if answer_id in real_answers
+            )
             log.debug(real_results)
-            assert(all(result == 'correct'
-                       for answer_id, result in real_results.items()))
+            assert all(result == "correct" for answer_id, result in real_results.items())
         except UndefinedVariable as uv_exc:
-            log.error("The variable \"{0}\" specified in the ".format(uv_exc) +  # lint-amnesty, pylint: disable=logging-not-lazy
-                      "solution isn't recognized (is it a units measure?).")
+            log.error(  # lint-amnesty, pylint: disable=logging-not-lazy
+                'The variable "{0}" specified in the '.format(uv_exc)
+                + "solution isn't recognized (is it a units measure?)."
+            )
         except AssertionError:
-            log.error("The following generated answers were not accepted for {0}:"
-                      .format(problem))
+            log.error("The following generated answers were not accepted for {0}:".format(problem))
             for question_id, result in sorted(real_results.items()):
-                if result != 'correct':
+                if result != "correct":
                     log.error("  {0} = {1}".format(question_id, real_answers[question_id]))
         except Exception as ex:  # lint-amnesty, pylint: disable=broad-except
             log.error("Uncaught error in {0}".format(problem))
@@ -152,9 +155,11 @@ def log_captured_output(output_stream, stream_name):  # lint-amnesty, pylint: di
     output_stream.seek(0)
     output_text = output_stream.read()
     if output_text:
-        log.info("##### Begin {0} #####\n".format(stream_name) + output_text)  # lint-amnesty, pylint: disable=logging-not-lazy
+        log.info(
+            "##### Begin {0} #####\n".format(stream_name) + output_text
+        )  # lint-amnesty, pylint: disable=logging-not-lazy
         log.info("##### End {0} #####".format(stream_name))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/xmodule/capa/correctmap.py b/xmodule/capa/correctmap.py
index 8ab1d890f390..5cc370e072f3 100644
--- a/xmodule/capa/correctmap.py
+++ b/xmodule/capa/correctmap.py
@@ -44,8 +44,8 @@ def set(  # lint-amnesty, pylint: disable=missing-function-docstring
         answer_id=None,
         correctness=None,
         npoints=None,
-        msg='',
-        hint='',
+        msg="",
+        hint="",
         hintmode=None,
         queuestate=None,
         answervariable=None,
@@ -54,13 +54,13 @@ def set(  # lint-amnesty, pylint: disable=missing-function-docstring
 
         if answer_id is not None:
             self.cmap[answer_id] = {
-                'correctness': correctness,
-                'npoints': npoints,
-                'msg': msg,
-                'hint': hint,
-                'hintmode': hintmode,
-                'queuestate': queuestate,
-                'answervariable': answervariable,
+                "correctness": correctness,
+                "npoints": npoints,
+                "msg": msg,
+                "hint": hint,
+                "hintmode": hintmode,
+                "queuestate": queuestate,
+                "answervariable": answervariable,
             }
 
     def __repr__(self):
@@ -111,7 +111,7 @@ def is_correct(self, answer_id):
         Returns true if the problem is correct OR partially correct.
         """
         if answer_id in self.cmap:
-            return self.cmap[answer_id]['correctness'] in ['correct', 'partially-correct']
+            return self.cmap[answer_id]["correctness"] in ["correct", "partially-correct"]
         return None
 
     def is_partially_correct(self, answer_id):
@@ -120,24 +120,24 @@ def is_partially_correct(self, answer_id):
         Returns true if the problem is partially correct.
         """
         if answer_id in self.cmap:
-            return self.cmap[answer_id]['correctness'] == 'partially-correct'
+            return self.cmap[answer_id]["correctness"] == "partially-correct"
         return None
 
     def is_queued(self, answer_id):
-        return answer_id in self.cmap and self.cmap[answer_id]['queuestate'] is not None
+        return answer_id in self.cmap and self.cmap[answer_id]["queuestate"] is not None
 
     def is_right_queuekey(self, answer_id, test_key):
-        return self.is_queued(answer_id) and self.cmap[answer_id]['queuestate']['key'] == test_key
+        return self.is_queued(answer_id) and self.cmap[answer_id]["queuestate"]["key"] == test_key
 
     def get_queuetime_str(self, answer_id):
-        if self.cmap[answer_id]['queuestate']:
-            return self.cmap[answer_id]['queuestate']['time']
+        if self.cmap[answer_id]["queuestate"]:
+            return self.cmap[answer_id]["queuestate"]["time"]
         else:
             return None
 
     def get_npoints(self, answer_id):
         """Return the number of points for an answer, used for partial credit."""
-        npoints = self.get_property(answer_id, 'npoints')
+        npoints = self.get_property(answer_id, "npoints")
         if npoints is not None:
             return npoints
         elif self.is_correct(answer_id):
@@ -157,40 +157,40 @@ def get_property(self, answer_id, property, default=None):  # lint-amnesty, pyli
         return default
 
     def get_correctness(self, answer_id):
-        return self.get_property(answer_id, 'correctness')
+        return self.get_property(answer_id, "correctness")
 
     def get_msg(self, answer_id):
-        return self.get_property(answer_id, 'msg', '')
+        return self.get_property(answer_id, "msg", "")
 
     def get_hint(self, answer_id):
-        return self.get_property(answer_id, 'hint', '')
+        return self.get_property(answer_id, "hint", "")
 
     def get_hintmode(self, answer_id):
-        return self.get_property(answer_id, 'hintmode', None)
+        return self.get_property(answer_id, "hintmode", None)
 
     def set_hint_and_mode(self, answer_id, hint, hintmode):
         """
-          - hint     : (string) HTML text for hint
-          - hintmode : (string) mode for hint display ('always' or 'on_request')
+        - hint     : (string) HTML text for hint
+        - hintmode : (string) mode for hint display ('always' or 'on_request')
         """
-        self.set_property(answer_id, 'hint', hint)
-        self.set_property(answer_id, 'hintmode', hintmode)
+        self.set_property(answer_id, "hint", hint)
+        self.set_property(answer_id, "hintmode", hintmode)
 
     def update(self, other_cmap):
         """
         Update this CorrectMap with the contents of another CorrectMap
         """
         if not isinstance(other_cmap, CorrectMap):
-            raise Exception('CorrectMap.update called with invalid argument %s' % other_cmap)
+            raise Exception("CorrectMap.update called with invalid argument %s" % other_cmap)
         self.cmap.update(other_cmap.get_dict())
         self.set_overall_message(other_cmap.get_overall_message())
 
     def set_overall_message(self, message_str):
-        """ Set a message that applies to the question as a whole,
-            rather than to individual inputs. """
+        """Set a message that applies to the question as a whole,
+        rather than to individual inputs."""
         self.overall_message = str(message_str) if message_str else ""
 
     def get_overall_message(self):
-        """ Retrieve a message that applies to the question as a whole.
-        If no message is available, returns the empty string """
+        """Retrieve a message that applies to the question as a whole.
+        If no message is available, returns the empty string"""
         return self.overall_message
diff --git a/xmodule/capa/customrender.py b/xmodule/capa/customrender.py
index b448b3c1239c..621af9fef307 100644
--- a/xmodule/capa/customrender.py
+++ b/xmodule/capa/customrender.py
@@ -6,7 +6,6 @@
 and the xml element.
 """
 
-
 import logging
 import re
 import xml.sax.saxutils as saxutils
@@ -25,7 +24,7 @@
 
 
 class MathRenderer(object):  # lint-amnesty, pylint: disable=missing-class-docstring
-    tags = ['math']
+    tags = ["math"]
 
     def __init__(self, system, xml):
         r"""
@@ -43,13 +42,13 @@ def __init__(self, system, xml):
         self.system = system
         self.xml = xml
 
-        mathstr = re.sub(r'\$(.*)\$', r'[mathjaxinline]\1[/mathjaxinline]', xml.text)
-        mtag = 'mathjax'
-        if r'\displaystyle' not in mathstr:
-            mtag += 'inline'
+        mathstr = re.sub(r"\$(.*)\$", r"[mathjaxinline]\1[/mathjaxinline]", xml.text)
+        mtag = "mathjax"
+        if r"\displaystyle" not in mathstr:
+            mtag += "inline"
         else:
-            mathstr = mathstr.replace(r'\displaystyle', '')
-        self.mathstr = mathstr.replace('mathjaxinline]', '%s]' % mtag)
+            mathstr = mathstr.replace(r"\displaystyle", "")
+        self.mathstr = mathstr.replace("mathjaxinline]", "%s]" % mtag)
 
     def get_html(self):
         """
@@ -57,18 +56,24 @@ def get_html(self):
         """
         # TODO: why are there nested html tags here??  Why are there html tags at all, in fact?
         # xss-lint: disable=python-interpolate-html
-        html = '<html><html>%s</html><html>%s</html></html>' % (  # lint-amnesty, pylint: disable=redefined-outer-name
-            self.mathstr, saxutils.escape(self.xml.tail))
+        html = "<html><html>%s</html><html>%s</html></html>" % (  # lint-amnesty, pylint: disable=redefined-outer-name
+            self.mathstr,
+            saxutils.escape(self.xml.tail),
+        )
         try:
             xhtml = etree.XML(html)
         except Exception as err:  # lint-amnesty, pylint: disable=broad-except
             if self.system.DEBUG:
                 # xss-lint: disable=python-interpolate-html
                 msg = '<html><div class="inline-error"><p>Error %s</p>' % (
-                    str(err).replace('<', '&lt;'))  # xss-lint: disable=python-custom-escape
+                    str(err).replace("<", "&lt;")  # xss-lint: disable=python-custom-escape
+                )
+
                 # xss-lint: disable=python-interpolate-html
-                msg += ('<p>Failed to construct math expression from <pre>%s</pre></p>' %
-                        html.replace('<', '&lt;'))  # xss-lint: disable=python-custom-escape
+                msg += "<p>Failed to construct math expression from <pre>%s</pre></p>" % html.replace(
+                    "<", "&lt;"  # xss-lint: disable=python-custom-escape
+                )
+
                 msg += "</div></html>"
                 log.error(msg)
                 return etree.XML(msg)
@@ -91,15 +96,18 @@ class SolutionRenderer(object):
     Note that the solution content is NOT rendered and returned in the HTML. It is obtained by an
     ajax call.
     """
-    tags = ['solution']
+
+    tags = ["solution"]
 
     def __init__(self, system, xml):
         self.system = system
-        self.id = xml.get('id')
+        self.id = xml.get("id")
 
-    def get_html(self):
-        context = {'id': self.id}
-        html = self.system.render_template("solutionspan.html", context)  # lint-amnesty, pylint: disable=redefined-outer-name
+    def get_html(self):  # pylint: disable=missing-function-docstring
+        context = {"id": self.id}
+        html = self.system.render_template(  # lint-amnesty, pylint: disable=redefined-outer-name
+            "solutionspan.html", context
+        )
         return etree.XML(html)
 
 
@@ -114,7 +122,8 @@ class TargetedFeedbackRenderer(object):
     A targeted feedback is just a <span>...</span> that is used for displaying an
     extended piece of feedback to students if they incorrectly answered a question.
     """
-    tags = ['targetedfeedback']
+
+    tags = ["targetedfeedback"]
 
     def __init__(self, system, xml):
         self.system = system
@@ -126,7 +135,8 @@ def get_html(self):
         """
         # xss-lint: disable=python-wrap-html
         html_str = '<section class="targeted-feedback-span"><span>{}</span></section>'.format(
-            etree.tostring(self.xml, encoding='unicode'))
+            etree.tostring(self.xml, encoding="unicode")
+        )
         try:
             xhtml = etree.XML(html_str)
 
@@ -140,7 +150,9 @@ def get_html(self):
                         <p>Failed to construct targeted feedback from <pre>{html}</pre></p>
                       </div>
                     </html>
-                """.format(err=html.escape(err), html=html.escape(html_str))
+                """.format(
+                    err=html.escape(err), html=html.escape(html_str)
+                )
                 log.error(msg)
                 return etree.XML(msg)
             else:
@@ -161,21 +173,24 @@ class ClarificationRenderer(object):
 
     e.g. <p>Enter the ROA <clarification>Return on Assets</clarification> for 2015:</p>
     """
-    tags = ['clarification']
+
+    tags = ["clarification"]
 
     def __init__(self, system, xml):
         self.system = system
         # Get any text content found inside this tag prior to the first child tag. It may be a string or None type.
-        initial_text = xml.text if xml.text else ''
-        self.inner_html = initial_text + ''.join(etree.tostring(element, encoding='unicode') for element in xml)
+        initial_text = xml.text if xml.text else ""
+        self.inner_html = initial_text + "".join(etree.tostring(element, encoding="unicode") for element in xml)
         self.tail = xml.tail
 
     def get_html(self):
         """
         Return the contents of this tag, rendered to html, as an etree element.
         """
-        context = {'clarification': self.inner_html}
-        html = self.system.render_template("clarification.html", context)  # lint-amnesty, pylint: disable=redefined-outer-name
+        context = {"clarification": self.inner_html}
+        html = self.system.render_template(  # lint-amnesty, pylint: disable=redefined-outer-name
+            "clarification.html", context
+        )
         xml = etree.XML(html)
         # We must include any text that was following our original <clarification>...</clarification> XML node.:
         xml.tail = self.tail
diff --git a/xmodule/capa/errors.py b/xmodule/capa/errors.py
index bb2783f8914e..2ef95cf167e9 100644
--- a/xmodule/capa/errors.py
+++ b/xmodule/capa/errors.py
@@ -10,6 +10,7 @@ class XQueueSubmissionError(Exception):
 
 class JSONParsingError(XQueueSubmissionError):
     """Raised when JSON parsing fails."""
+
     MESSAGE = "Error parsing {name}: {error}"
 
     def __init__(self, name, error):
@@ -18,6 +19,7 @@ def __init__(self, name, error):
 
 class MissingKeyError(XQueueSubmissionError):
     """Raised when a required key is missing."""
+
     MESSAGE = "Missing key: {key}"
 
     def __init__(self, key):
@@ -26,6 +28,7 @@ def __init__(self, key):
 
 class ValidationError(XQueueSubmissionError):
     """Raised when a validation check fails."""
+
     MESSAGE = "Validation error: {error}"
 
     def __init__(self, error):
@@ -34,6 +37,7 @@ def __init__(self, error):
 
 class TypeErrorSubmission(XQueueSubmissionError):
     """Raised when an invalid type is encountered."""
+
     MESSAGE = "Type error: {error}"
 
     def __init__(self, error):
@@ -42,6 +46,7 @@ def __init__(self, error):
 
 class RuntimeErrorSubmission(XQueueSubmissionError):
     """Raised for runtime errors."""
+
     MESSAGE = "Runtime error: {error}"
 
     def __init__(self, error):
@@ -50,6 +55,7 @@ def __init__(self, error):
 
 class GetSubmissionParamsError(XQueueSubmissionError):
     """Raised when there is an issue getting submission parameters."""
+
     MESSAGE = "Submission parameters error: {error}"
 
     def __init__(self, error="Block instance is not defined!"):
diff --git a/xmodule/capa/inputtypes.py b/xmodule/capa/inputtypes.py
index 03a9a59134d0..78b0dfb5b483 100644
--- a/xmodule/capa/inputtypes.py
+++ b/xmodule/capa/inputtypes.py
@@ -47,17 +47,16 @@
 import time
 from datetime import datetime
 
-import nh3
 import html5lib
+import nh3
 import pyparsing
 import six
 from calc.preview import latex_preview
 from chem import chemcalc
-
 from lxml import etree
 
-from xmodule.capa.xqueue_interface import XQUEUE_TIMEOUT
 from openedx.core.djangolib.markup import HTML, Text
+from xmodule.capa.xqueue_interface import XQUEUE_TIMEOUT
 from xmodule.stringify import stringify_children
 
 from . import xqueue_interface
@@ -74,48 +73,45 @@ class Status(object):
     Problem status
     attributes: classname, display_name, display_tooltip
     """
+
     css_classes = {
         # status: css class
-        'unsubmitted': 'unanswered',
-        'incomplete': 'incorrect',
-        'queued': 'processing',
+        "unsubmitted": "unanswered",
+        "incomplete": "incorrect",
+        "queued": "processing",
     }
-    __slots__ = ('classname', '_status', 'display_name', 'display_tooltip')
+    __slots__ = ("classname", "_status", "display_name", "display_tooltip")
 
     def __init__(self, status, gettext_func=str):
         self.classname = self.css_classes.get(status, status)
         _ = gettext_func
         names = {
-            'correct': _('correct'),
-            'incorrect': _('incorrect'),
-            'partially-correct': _('partially correct'),
-            'incomplete': _('incomplete'),
-            'unanswered': _('unanswered'),
-            'unsubmitted': _('unanswered'),
-            'submitted': _('submitted'),
-            'queued': _('processing'),
+            "correct": _("correct"),
+            "incorrect": _("incorrect"),
+            "partially-correct": _("partially correct"),
+            "incomplete": _("incomplete"),
+            "unanswered": _("unanswered"),
+            "unsubmitted": _("unanswered"),
+            "submitted": _("submitted"),
+            "queued": _("processing"),
         }
         tooltips = {
             # Translators: these are tooltips that indicate the state of an assessment question
-            'correct': _('This answer is correct.'),
-            'incorrect': _('This answer is incorrect.'),
-            'partially-correct': _('This answer is partially correct.'),
-            'queued': _('This answer is being processed.'),
+            "correct": _("This answer is correct."),
+            "incorrect": _("This answer is incorrect."),
+            "partially-correct": _("This answer is partially correct."),
+            "queued": _("This answer is being processed."),
         }
-        tooltips.update(
-            dict.fromkeys(
-                ['incomplete', 'unanswered', 'unsubmitted'], _('Not yet answered.')
-            )
-        )
+        tooltips.update(dict.fromkeys(["incomplete", "unanswered", "unsubmitted"], _("Not yet answered.")))
         self.display_name = names.get(status, str(status))
-        self.display_tooltip = tooltips.get(status, '')
-        self._status = status or ''
+        self.display_tooltip = tooltips.get(status, "")
+        self._status = status or ""
 
     def __str__(self):
         return self._status
 
     def __repr__(self):
-        return 'Status(%r)' % self._status
+        return "Status(%r)" % self._status
 
     def __eq__(self, other):
         return self._status == str(other)
@@ -164,9 +160,7 @@ def parse_from_xml(self, element):
         """
         val = element.get(self.name)
         if self.default == self._sentinel and val is None:
-            raise ValueError(
-                'Missing required attribute {0}.'.format(self.name)
-            )
+            raise ValueError("Missing required attribute {0}.".format(self.name))
 
         if val is None:
             # not required, so return default
@@ -218,28 +212,27 @@ def __init__(self, system, xml, state):
         # we can swap this around in the future if there's a more logical
         # order.
 
-        self.input_id = state.get('id', xml.get('id'))
+        self.input_id = state.get("id", xml.get("id"))
         if self.input_id is None:
-            raise ValueError(
-                "input id state is None. xml is {0}".format(etree.tostring(xml))
-            )
+            raise ValueError("input id state is None. xml is {0}".format(etree.tostring(xml)))
 
-        self.value = state.get('value', '')
+        self.value = state.get("value", "")
 
-        feedback = state.get('feedback', {})
-        self.msg = feedback.get('message', '')
-        self.hint = feedback.get('hint', '')
-        self.hintmode = feedback.get('hintmode', None)
-        self.input_state = state.get('input_state', {})
-        self.answervariable = state.get('answervariable', None)
-        self.response_data = state.get('response_data')
+        feedback = state.get("feedback", {})
+        self.msg = feedback.get("message", "")
+        self.hint = feedback.get("hint", "")
+        self.hintmode = feedback.get("hintmode", None)
+        self.input_state = state.get("input_state", {})
+        self.answervariable = state.get("answervariable", None)
+        self.response_data = state.get("response_data")
 
         # put hint above msg if it should be displayed
-        if self.hintmode == 'always':
-            self.msg = HTML('{hint}<br/>{msg}' if self.msg else '{hint}').format(hint=HTML(self.hint),
-                                                                                 msg=HTML(self.msg))
+        if self.hintmode == "always":
+            self.msg = HTML("{hint}<br/>{msg}" if self.msg else "{hint}").format(
+                hint=HTML(self.hint), msg=HTML(self.msg)
+            )
 
-        self.status = state.get('status', 'unanswered')
+        self.status = state.get("status", "unanswered")
 
         try:
             # Pre-parse and process all the declared requirements.
@@ -251,8 +244,7 @@ def __init__(self, system, xml, state):
             self.setup()
         except Exception as err:  # lint-amnesty, pylint: disable=broad-except
             # Something went wrong: add xml to message, but keep the traceback
-            msg = "Error in xml '{x}': {err} ".format(
-                x=etree.tostring(xml), err=str(err))
+            msg = "Error in xml '{x}': {err} ".format(x=etree.tostring(xml), err=str(err))
             six.reraise(Exception, Exception(msg), sys.exc_info()[2])
 
     @classmethod
@@ -321,38 +313,34 @@ def _get_render_context(self):
         and don't need to override this method.
         """
         context = {
-            'id': self.input_id,
-            'value': self.value,
-            'status': Status(self.status, self.capa_system.i18n.gettext),
-            'msg': self.msg,
-            'response_data': self.response_data,
-            'STATIC_URL': self.capa_system.STATIC_URL,
-            'describedby_html': HTML(''),
+            "id": self.input_id,
+            "value": self.value,
+            "status": Status(self.status, self.capa_system.i18n.gettext),
+            "msg": self.msg,
+            "response_data": self.response_data,
+            "STATIC_URL": self.capa_system.STATIC_URL,
+            "describedby_html": HTML(""),
         }
 
         # Generate the list of ids to be used with the aria-describedby field.
         descriptions = []
 
         # If there is trailing text, add the id as the first element to the list before adding the status id
-        if 'trailing_text' in self.loaded_attributes and self.loaded_attributes['trailing_text']:
-            trailing_text_id = 'trailing_text_' + self.input_id
+        if "trailing_text" in self.loaded_attributes and self.loaded_attributes["trailing_text"]:
+            trailing_text_id = "trailing_text_" + self.input_id
             descriptions.append(trailing_text_id)
 
         # Every list should contain the status id
-        status_id = 'status_' + self.input_id
+        status_id = "status_" + self.input_id
         descriptions.append(status_id)
-        descriptions.extend(list(self.response_data.get('descriptions', {}).keys()))
-        description_ids = ' '.join(descriptions)
-        context.update(
-            {'describedby_html': HTML('aria-describedby="{}"').format(description_ids)}
-        )
+        descriptions.extend(list(self.response_data.get("descriptions", {}).keys()))
+        description_ids = " ".join(descriptions)
+        context.update({"describedby_html": HTML('aria-describedby="{}"').format(description_ids)})
 
-        context.update(
-            (a, v) for (a, v) in six.iteritems(self.loaded_attributes) if a in self.to_render
-        )
+        context.update((a, v) for (a, v) in six.iteritems(self.loaded_attributes) if a in self.to_render)
         context.update(self._extra_context())
         if self.answervariable:
-            context.update({'answervariable': self.answervariable})
+            context.update({"answervariable": self.answervariable})
         return context
 
     def _extra_context(self):
@@ -368,8 +356,7 @@ def get_html(self):
         Return the html for this input, as an etree element.
         """
         if self.template is None:
-            raise NotImplementedError("no rendering template specified for class {0}"
-                                      .format(self.__class__))
+            raise NotImplementedError("no rendering template specified for class {0}".format(self.__class__))
 
         context = self._get_render_context()
 
@@ -381,7 +368,7 @@ def get_html(self):
             # If `html` contains attrs with no values, like `controls` in <audio controls src='smth'/>,
             # XML parser will raise exception, so wee fallback to html5parser, which will set empty "" values for such attrs.  # lint-amnesty, pylint: disable=line-too-long
             try:
-                output = html5lib.parseFragment(html, treebuilder='lxml', namespaceHTMLElements=False)[0]
+                output = html5lib.parseFragment(html, treebuilder="lxml", namespaceHTMLElements=False)[0]
             except IndexError:
                 raise ex  # lint-amnesty, pylint: disable=raise-missing-from
 
@@ -396,7 +383,7 @@ def get_user_visible_answer(self, internal_answer):
         return internal_answer
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -412,7 +399,7 @@ class OptionInput(InputTypeBase):
     """
 
     template = "optioninput.html"
-    tags = ['optioninput']
+    tags = ["optioninput"]
 
     @staticmethod
     def parse_options(options):
@@ -442,22 +429,23 @@ def get_attributes(cls):
         """
         Convert options to a convenient format.
         """
-        return [Attribute('options', transform=cls.parse_options),
-                Attribute('inline', False)]
+        return [Attribute("options", transform=cls.parse_options), Attribute("inline", False)]
 
     def _extra_context(self):
         """
         Return extra context.
         """
         _ = self.capa_system.i18n.gettext
-        return {'default_option_text': _('Select an option')}
+        return {"default_option_text": _("Select an option")}
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 # TODO: consolidate choicegroup, radiogroup, checkboxgroup after discussion of
 # desired semantics.
 
+
 @registry.register
 class ChoiceGroup(InputTypeBase):
     """
@@ -480,22 +468,23 @@ class ChoiceGroup(InputTypeBase):
       </choice>
     </choicegroup>
     """
+
     template = "choicegroup.html"
-    tags = ['choicegroup', 'radiogroup', 'checkboxgroup']
+    tags = ["choicegroup", "radiogroup", "checkboxgroup"]
 
     def setup(self):
         i18n = self.capa_system.i18n
         # suffix is '' or [] to change the way the input is handled in --as a scalar or vector
         # value.  (VS: would be nice to make this less hackish).
-        if self.tag == 'choicegroup':
-            self.suffix = ''
+        if self.tag == "choicegroup":
+            self.suffix = ""
             self.html_input_type = "radio"
-        elif self.tag == 'radiogroup':
+        elif self.tag == "radiogroup":
             self.html_input_type = "radio"
-            self.suffix = '[]'
-        elif self.tag == 'checkboxgroup':
+            self.suffix = "[]"
+        elif self.tag == "checkboxgroup":
             self.html_input_type = "checkbox"
-            self.suffix = '[]'
+            self.suffix = "[]"
         else:
             _ = i18n.gettext
             # Translators: 'ChoiceGroup' is an input type and should not be translated.
@@ -503,20 +492,19 @@ def setup(self):
             raise Exception(msg)
 
         self.choices = self.extract_choices(self.xml, i18n)
-        self._choices_map = dict(self.choices, )
+        self._choices_map = dict(
+            self.choices,
+        )
 
     @classmethod
     def get_attributes(cls):
         # Make '_' a no-op so we can scrape strings. Using lambda instead of
         #  `django.utils.translation.ugettext_noop` because Django cannot be imported in this file
         _ = lambda text: text
-        return [Attribute("show_correctness", "always"),
-                Attribute("submitted_message", _("Answer received."))]
+        return [Attribute("show_correctness", "always"), Attribute("submitted_message", _("Answer received."))]
 
     def _extra_context(self):
-        return {'input_type': self.html_input_type,
-                'choices': self.choices,
-                'name_array_suffix': self.suffix}
+        return {"input_type": self.html_input_type, "choices": self.choices, "name_array_suffix": self.suffix}
 
     @staticmethod
     def extract_choices(element, i18n, text_only=False):
@@ -536,20 +524,19 @@ def extract_choices(element, i18n, text_only=False):
         _ = i18n.gettext
 
         for choice in element:
-            if choice.tag == 'choice':
+            if choice.tag == "choice":
                 if not text_only:
                     text = stringify_children(choice)
                 else:
                     text = choice.text
                 choices.append((choice.get("name"), text))
             else:
-                if choice.tag != 'compoundhint':
-                    msg = Text('[capa.inputtypes.extract_choices] {error_message}').format(
+                if choice.tag != "compoundhint":
+                    msg = Text("[capa.inputtypes.extract_choices] {error_message}").format(
                         error_message=Text(
                             # Translators: '<choice>' and '<compoundhint>' are tag names and should not be translated.
-                            _('Expected a <choice> or <compoundhint> tag; got {given_tag} instead')).format(
-                            given_tag=choice.tag
-                        )
+                            _("Expected a <choice> or <compoundhint> tag; got {given_tag} instead")
+                        ).format(given_tag=choice.tag)
                     )
                     raise Exception(msg)
         return choices
@@ -560,7 +547,8 @@ def get_user_visible_answer(self, internal_answer):
 
         return [self._choices_map[i] for i in internal_answer]
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -592,7 +580,7 @@ class JSInput(InputTypeBase):
     """
 
     template = "jsinput.html"
-    tags = ['jsinput']
+    tags = ["jsinput"]
 
     @classmethod
     def get_attributes(cls):
@@ -600,36 +588,35 @@ def get_attributes(cls):
         Register the attributes.
         """
         return [
-            Attribute('params', None),  # extra iframe params
-            Attribute('html_file', None),
-            Attribute('gradefn', "gradefn"),
-            Attribute('get_statefn', None),  # Function to call in iframe
+            Attribute("params", None),  # extra iframe params
+            Attribute("html_file", None),
+            Attribute("gradefn", "gradefn"),
+            Attribute("get_statefn", None),  # Function to call in iframe
             #   to get current state.
-            Attribute('initial_state', None),  # JSON string to be used as initial state
-            Attribute('set_statefn', None),  # Function to call iframe to
+            Attribute("initial_state", None),  # JSON string to be used as initial state
+            Attribute("set_statefn", None),  # Function to call iframe to
             #   set state
-            Attribute('width', "400"),  # iframe width
-            Attribute('height', "300"),  # iframe height
+            Attribute("width", "400"),  # iframe width
+            Attribute("height", "300"),  # iframe height
             # Title for the iframe, which should be supplied by the author of the problem. Not translated
             # because we are in a class method and therefore do not have access to capa_system.i18n.
             # Note that the default "display name" for the problem is also not translated.
-            Attribute('title', "Problem Remote Content"),
+            Attribute("title", "Problem Remote Content"),
             # SOP will be relaxed only if this attribute is set to false.
-            Attribute('sop', None)
+            Attribute("sop", None),
         ]
 
     def _extra_context(self):
         context = {
-            'jschannel_loader': '{static_url}js/capa/src/jschannel.js'.format(
-                static_url=self.capa_system.STATIC_URL),
-            'jsinput_loader': '{static_url}js/capa/src/jsinput.js'.format(
-                static_url=self.capa_system.STATIC_URL),
-            'saved_state': self.value
+            "jschannel_loader": "{static_url}js/capa/src/jschannel.js".format(static_url=self.capa_system.STATIC_URL),
+            "jsinput_loader": "{static_url}js/capa/src/jsinput.js".format(static_url=self.capa_system.STATIC_URL),
+            "saved_state": self.value,
         }
 
         return context
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -655,7 +642,7 @@ class TextLine(InputTypeBase):
     """
 
     template = "textline.html"
-    tags = ['textline']
+    tags = ["textline"]
 
     @classmethod
     def get_attributes(cls):
@@ -663,24 +650,21 @@ def get_attributes(cls):
         Register the attributes.
         """
         return [
-            Attribute('size', None),
-
-            Attribute('hidden', False),
-            Attribute('inline', False),
-
+            Attribute("size", None),
+            Attribute("hidden", False),
+            Attribute("inline", False),
             # Attributes below used in setup(), not rendered directly.
-            Attribute('math', None, render=False),
+            Attribute("math", None, render=False),
             # TODO: 'dojs' flag is temporary, for backwards compatibility with
             # 8.02x
-            Attribute('dojs', None, render=False),
-            Attribute('preprocessorClassName', None, render=False),
-            Attribute('preprocessorSrc', None, render=False),
-            Attribute('trailing_text', ''),
+            Attribute("dojs", None, render=False),
+            Attribute("preprocessorClassName", None, render=False),
+            Attribute("preprocessorSrc", None, render=False),
+            Attribute("trailing_text", ""),
         ]
 
     def setup(self):
-        self.do_math = bool(self.loaded_attributes['math'] or
-                            self.loaded_attributes['dojs'])
+        self.do_math = bool(self.loaded_attributes["math"] or self.loaded_attributes["dojs"])
 
         # TODO: do math checking using ajax instead of using js, so
         # that we only have one math parser.
@@ -688,17 +672,20 @@ def setup(self):
         if self.do_math:
             # Preprocessor to insert between raw input and Mathjax
             self.preprocessor = {
-                'class_name': self.loaded_attributes['preprocessorClassName'],
-                'script_src': self.loaded_attributes['preprocessorSrc'],
+                "class_name": self.loaded_attributes["preprocessorClassName"],
+                "script_src": self.loaded_attributes["preprocessorSrc"],
             }
             if None in list(self.preprocessor.values()):
                 self.preprocessor = None
 
     def _extra_context(self):
-        return {'do_math': self.do_math,
-                'preprocessor': self.preprocessor, }
+        return {
+            "do_math": self.do_math,
+            "preprocessor": self.preprocessor,
+        }
+
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -708,7 +695,7 @@ class FileSubmission(InputTypeBase):
     """
 
     template = "filesubmission.html"
-    tags = ['filesubmission']
+    tags = ["filesubmission"]
 
     @staticmethod
     def parse_files(files):
@@ -722,8 +709,10 @@ def get_attributes(cls):
         """
         Convert the list of allowed files to a convenient format.
         """
-        return [Attribute('allowed_files', '[]', transform=cls.parse_files),
-                Attribute('required_files', '[]', transform=cls.parse_files), ]
+        return [
+            Attribute("allowed_files", "[]", transform=cls.parse_files),
+            Attribute("required_files", "[]", transform=cls.parse_files),
+        ]
 
     def setup(self):
         """
@@ -731,24 +720,29 @@ def setup(self):
         pull queue_len from the msg field.  (TODO: get rid of the queue_len hack).
         """
         _ = self.capa_system.i18n.gettext
-        submitted_msg = _("Your files have been submitted. As soon as your submission is"
-                          " graded, this message will be replaced with the grader's feedback.")
+        submitted_msg = _(
+            "Your files have been submitted. As soon as your submission is"
+            " graded, this message will be replaced with the grader's feedback."
+        )
         self.submitted_msg = submitted_msg
 
         # Check if problem has been queued
         self.queue_len = 0
         # Flag indicating that the problem has been queued, 'msg' is length of
         # queue
-        if self.status == 'incomplete':
-            self.status = 'queued'
+        if self.status == "incomplete":
+            self.status = "queued"
             self.queue_len = self.msg
             self.msg = self.submitted_msg
 
     def _extra_context(self):
-        return {'queue_len': self.queue_len, }
+        return {
+            "queue_len": self.queue_len,
+        }
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 @registry.register
 class CodeInput(InputTypeBase):
@@ -759,8 +753,8 @@ class CodeInput(InputTypeBase):
 
     template = "codeinput.html"
     tags = [
-        'codeinput',
-        'textbox',
+        "codeinput",
+        "textbox",
         # Another (older) name--at some point we may want to make it use a
         # non-codemirror editor.
     ]
@@ -771,15 +765,14 @@ def get_attributes(cls):
         Convert options to a convenient format.
         """
         return [
-            Attribute('rows', '30'),
-            Attribute('cols', '80'),
-            Attribute('hidden', ''),
-
+            Attribute("rows", "30"),
+            Attribute("cols", "80"),
+            Attribute("hidden", ""),
             # For CodeMirror
-            Attribute('mode', 'python'),
-            Attribute('linenumbers', 'true'),
+            Attribute("mode", "python"),
+            Attribute("linenumbers", "true"),
             # Template expects tabsize to be an int it can do math with
-            Attribute('tabsize', 4, transform=int),
+            Attribute("tabsize", 4, transform=int),
         ]
 
     def setup_code_response_rendering(self):
@@ -795,16 +788,18 @@ def setup_code_response_rendering(self):
         self.queue_len = 0  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         # Flag indicating that the problem has been queued, 'msg' is length of
         # queue
-        if self.status == 'incomplete':
-            self.status = 'queued'
+        if self.status == "incomplete":
+            self.status = "queued"
             self.queue_len = self.msg  # lint-amnesty, pylint: disable=attribute-defined-outside-init
             self.msg = nh3.clean(self.submitted_msg)
 
     def setup(self):
-        """ setup this input type """
+        """setup this input type"""
         _ = self.capa_system.i18n.gettext
-        submitted_msg = _("Your answer has been submitted. As soon as your submission is"
-                          " graded, this message will be replaced with the grader's feedback.")
+        submitted_msg = _(
+            "Your answer has been submitted. As soon as your submission is"
+            " graded, this message will be replaced with the grader's feedback."
+        )
         self.submitted_msg = submitted_msg
 
         self.setup_code_response_rendering()
@@ -815,15 +810,15 @@ def _extra_context(self):
         """
         _ = self.capa_system.i18n.gettext
         return {
-            'queue_len': self.queue_len,
-            'aria_label': _('{programming_language} editor').format(
-                programming_language=self.loaded_attributes.get('mode')
+            "queue_len": self.queue_len,
+            "aria_label": _("{programming_language} editor").format(
+                programming_language=self.loaded_attributes.get("mode")
             ),
-            'code_mirror_exit_message': _('Press ESC then TAB or click outside of the code editor to exit')
+            "code_mirror_exit_message": _("Press ESC then TAB or click outside of the code editor to exit"),
         }
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -836,8 +831,9 @@ class MatlabInput(CodeInput):
         Initial Text
      </matlabinput>
     """
+
     template = "matlabinput.html"
-    tags = ['matlabinput']
+    tags = ["matlabinput"]
 
     def setup(self):
         """
@@ -845,35 +841,35 @@ def setup(self):
         """
         _ = self.capa_system.i18n.gettext
 
-        submitted_msg = _("Submitted. As soon as a response is returned, "
-                          "this message will be replaced by that feedback.")
+        submitted_msg = _(
+            "Submitted. As soon as a response is returned, this message will be replaced by that feedback."
+        )
         self.submitted_msg = submitted_msg
 
         self.setup_code_response_rendering()
 
         xml = self.xml
 
-        self.plot_payload = xml.findtext('./plot_payload')
+        self.plot_payload = xml.findtext("./plot_payload")
         # Check if problem has been queued
-        self.queuename = 'matlab'
-        self.queue_msg = ''
+        self.queuename = "matlab"
+        self.queue_msg = ""
         # this is only set if we don't have a graded response
         # the graded response takes precedence
-        if 'queue_msg' in self.input_state and self.status in ['queued', 'incomplete', 'unsubmitted']:
-            self.queue_msg = sanitize_html(self.input_state['queue_msg'])
+        if "queue_msg" in self.input_state and self.status in ["queued", "incomplete", "unsubmitted"]:
+            self.queue_msg = sanitize_html(self.input_state["queue_msg"])
 
-        if 'queuestate' in self.input_state and self.input_state['queuestate'] == 'queued':
-            self.status = 'queued'
+        if "queuestate" in self.input_state and self.input_state["queuestate"] == "queued":
+            self.status = "queued"
             self.queue_len = 1
             self.msg = self.submitted_msg
             # Handle situation if no response from xqueue arrived during specified time.
-            if ('queuetime' not in self.input_state or
-                    time.time() - self.input_state['queuetime'] > XQUEUE_TIMEOUT):
+            if "queuetime" not in self.input_state or time.time() - self.input_state["queuetime"] > XQUEUE_TIMEOUT:
                 self.queue_len = 0
-                self.status = 'unsubmitted'
-                self.msg = _(
-                    'No response from Xqueue within {xqueue_timeout} seconds. Aborted.'
-                ).format(xqueue_timeout=XQUEUE_TIMEOUT)
+                self.status = "unsubmitted"
+                self.msg = _("No response from Xqueue within {xqueue_timeout} seconds. Aborted.").format(
+                    xqueue_timeout=XQUEUE_TIMEOUT
+                )
 
     def handle_ajax(self, dispatch, data):
         """
@@ -887,7 +883,7 @@ def handle_ajax(self, dispatch, data):
                  - 'message' - message to be rendered in case of error
         """
 
-        if dispatch == 'plot':
+        if dispatch == "plot":
             return self._plot_data(data)
         return {}
 
@@ -904,48 +900,52 @@ def ungraded_response(self, queue_msg, queuekey):
             nothing
         """
         # check the queuekey against the saved queuekey
-        if('queuestate' in self.input_state and self.input_state['queuestate'] == 'queued'
-                and self.input_state['queuekey'] == queuekey):
+        if (
+            "queuestate" in self.input_state
+            and self.input_state["queuestate"] == "queued"
+            and self.input_state["queuekey"] == queuekey
+        ):
             msg = self._parse_data(queue_msg)
             # save the queue message so that it can be rendered later
-            self.input_state['queue_msg'] = msg
-            self.input_state['queuestate'] = None
-            self.input_state['queuekey'] = None
+            self.input_state["queue_msg"] = msg
+            self.input_state["queuestate"] = None
+            self.input_state["queuekey"] = None
 
     def button_enabled(self):
-        """ Return whether or not we want the 'Test Code' button visible
+        """Return whether or not we want the 'Test Code' button visible
 
         Right now, we only want this button to show up when a problem has not been
         checked.
         """
-        if self.status in ['correct', 'incorrect', 'partially-correct']:
+        if self.status in ["correct", "incorrect", "partially-correct"]:
             return False
         else:
             return True
 
     def _extra_context(self):
-        """ Set up additional context variables"""
+        """Set up additional context variables"""
 
         _ = self.capa_system.i18n.gettext
 
         queue_msg = self.queue_msg
         if len(self.queue_msg) > 0:  # An empty string cannot be parsed as XML but is okay to include in the template.
             try:
-                etree.XML(HTML('<div>{0}</div>').format(HTML(self.queue_msg)))
+                etree.XML(HTML("<div>{0}</div>").format(HTML(self.queue_msg)))
             except etree.XMLSyntaxError:
                 try:
-                    html5lib.parseFragment(self.queue_msg, treebuilder='lxml', namespaceHTMLElements=False)[0]
+                    html5lib.parseFragment(self.queue_msg, treebuilder="lxml", namespaceHTMLElements=False)[0]
                 except (IndexError, ValueError):
                     # If neither can parse queue_msg, it contains invalid xml.
                     queue_msg = HTML("<span>{0}</span>").format(_("Error running code."))
 
         extra_context = {
-            'queue_len': str(self.queue_len),
-            'queue_msg': queue_msg,
-            'button_enabled': self.button_enabled(),
-            'matlab_editor_js': '{static_url}js/vendor/CodeMirror/octave.js'.format(
-                static_url=self.capa_system.STATIC_URL),
-            'msg': sanitize_html(self.msg)  # sanitize msg before rendering into template
+            "queue_len": str(self.queue_len),
+            "queue_msg": queue_msg,
+            "button_enabled": self.button_enabled(),
+            "matlab_editor_js": "{static_url}js/vendor/CodeMirror/octave.js".format(
+                static_url=self.capa_system.STATIC_URL
+            ),
+            "msg": sanitize_html(self.msg),  # sanitize msg before rendering into template
         }
         return extra_context
 
@@ -960,10 +960,9 @@ def _parse_data(self, queue_msg):
         try:
             result = json.loads(queue_msg)
         except (TypeError, ValueError):
-            log.error("External message should be a JSON serialized dict."
-                      " Received queue_msg = %s", queue_msg)
+            log.error("External message should be a JSON serialized dict. Received queue_msg = %s", queue_msg)
             raise
-        msg = result['msg']
+        msg = result["msg"]
         return msg
 
     def _plot_data(self, data):
@@ -978,51 +977,47 @@ def _plot_data(self, data):
         _ = self.capa_system.i18n.gettext
         # only send data if xqueue exists
         if self.capa_system.xqueue is None:
-            return {'success': False, 'message': _('Cannot connect to the queue')}
+            return {"success": False, "message": _("Cannot connect to the queue")}
 
         # pull relevant info out of get
-        response = data['submission']
+        response = data["submission"]
 
         # construct xqueue headers
         qinterface = self.capa_system.xqueue.interface
         qtime = datetime.utcnow().strftime(xqueue_interface.dateformat)
-        callback_url = self.capa_system.xqueue.construct_callback('ungraded_response')
+        callback_url = self.capa_system.xqueue.construct_callback("ungraded_response")
         anonymous_student_id = self.capa_system.anonymous_student_id
         # TODO: Why is this using self.capa_system.seed when we have self.seed???
-        queuekey = xqueue_interface.make_hashkey(str(self.capa_system.seed) + qtime +
-                                                 anonymous_student_id +
-                                                 self.input_id)
+        queuekey = xqueue_interface.make_hashkey(
+            str(self.capa_system.seed) + qtime + anonymous_student_id + self.input_id
+        )
         xheader = xqueue_interface.make_xheader(
-            lms_callback_url=callback_url,
-            lms_key=queuekey,
-            queue_name=self.queuename)
+            lms_callback_url=callback_url, lms_key=queuekey, queue_name=self.queuename
+        )
 
         # construct xqueue body
-        student_info = {
-            'anonymous_student_id': anonymous_student_id,
-            'submission_time': qtime
-        }
+        student_info = {"anonymous_student_id": anonymous_student_id, "submission_time": qtime}
         contents = {
-            'grader_payload': self.plot_payload,
-            'student_info': json.dumps(student_info),
-            'student_response': response,
-            'token': getattr(self.capa_system, 'matlab_api_key', None),
-            'endpoint_version': "2",
-            'requestor_id': anonymous_student_id,
+            "grader_payload": self.plot_payload,
+            "student_info": json.dumps(student_info),
+            "student_response": response,
+            "token": getattr(self.capa_system, "matlab_api_key", None),
+            "endpoint_version": "2",
+            "requestor_id": anonymous_student_id,
         }
 
-        (error, msg) = qinterface.send_to_queue(header=xheader,
-                                                body=json.dumps(contents))
+        (error, msg) = qinterface.send_to_queue(header=xheader, body=json.dumps(contents))
         # save the input state if successful
         if error == 0:
-            self.input_state['queuekey'] = queuekey
-            self.input_state['queuestate'] = 'queued'
-            self.input_state['queuetime'] = time.time()
+            self.input_state["queuekey"] = queuekey
+            self.input_state["queuestate"] = "queued"
+            self.input_state["queuetime"] = time.time()
+
+        return {"success": error == 0, "message": msg}
 
-        return {'success': error == 0, 'message': msg}
 
+# -----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
 
 @registry.register
 class Schematic(InputTypeBase):
@@ -1031,7 +1026,7 @@ class Schematic(InputTypeBase):
     """
 
     template = "schematicinput.html"
-    tags = ['schematic']
+    tags = ["schematic"]
 
     @classmethod
     def get_attributes(cls):
@@ -1039,23 +1034,23 @@ def get_attributes(cls):
         Convert options to a convenient format.
         """
         return [
-            Attribute('height', None),
-            Attribute('width', None),
-            Attribute('parts', None),
-            Attribute('analyses', None),
-            Attribute('initial_value', None),
-            Attribute('submit_analyses', None),
+            Attribute("height", None),
+            Attribute("width", None),
+            Attribute("parts", None),
+            Attribute("analyses", None),
+            Attribute("initial_value", None),
+            Attribute("submit_analyses", None),
         ]
 
     def _extra_context(self):
         context = {
-            'setup_script': '{static_url}js/capa/schematicinput.js'.format(
-                static_url=self.capa_system.STATIC_URL),
+            "setup_script": "{static_url}js/capa/schematicinput.js".format(static_url=self.capa_system.STATIC_URL),
         }
 
         return context
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1071,23 +1066,24 @@ class ImageInput(InputTypeBase):
     """
 
     template = "imageinput.html"
-    tags = ['imageinput']
+    tags = ["imageinput"]
 
     @classmethod
     def get_attributes(cls):
         """
         Note: src, height, and width are all required.
         """
-        return [Attribute('src'),
-                Attribute('height'),
-                Attribute('width'), ]
+        return [
+            Attribute("src"),
+            Attribute("height"),
+            Attribute("width"),
+        ]
 
     def setup(self):
         """
         if value is of the form [x,y] then parse it and send along coordinates of previous answer
         """
-        m = re.match(r'\[([0-9]+),([0-9]+)]',
-                     self.value.strip().replace(' ', ''))
+        m = re.match(r"\[([0-9]+),([0-9]+)]", self.value.strip().replace(" ", ""))
         if m:
             # Note: we subtract 15 to compensate for the size of the dot on the screen.
             # (is a 30x30 image--lms/static/images/green-pointer.png).
@@ -1097,10 +1093,10 @@ def setup(self):
 
     def _extra_context(self):
 
-        return {'gx': self.gx,
-                'gy': self.gy}
+        return {"gx": self.gx, "gy": self.gy}
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1112,16 +1108,18 @@ class Crystallography(InputTypeBase):
     """
 
     template = "crystallography.html"
-    tags = ['crystallography']
+    tags = ["crystallography"]
 
     @classmethod
     def get_attributes(cls):
         """
         Note: height, width are required.
         """
-        return [Attribute('height'),
-                Attribute('width'),
-                ]
+        return [
+            Attribute("height"),
+            Attribute("width"),
+        ]
+
 
 # -------------------------------------------------------------------------
 
@@ -1133,21 +1131,23 @@ class VseprInput(InputTypeBase):
     pick structure and label positions with atoms or electron pairs.
     """
 
-    template = 'vsepr_input.html'
-    tags = ['vsepr_input']
+    template = "vsepr_input.html"
+    tags = ["vsepr_input"]
 
     @classmethod
     def get_attributes(cls):
         """
         Note: height, width, molecules and geometries are required.
         """
-        return [Attribute('height'),
-                Attribute('width'),
-                Attribute('molecules'),
-                Attribute('geometries'),
-                ]
+        return [
+            Attribute("height"),
+            Attribute("width"),
+            Attribute("molecules"),
+            Attribute("geometries"),
+        ]
 
-#-------------------------------------------------------------------------
+
+# -------------------------------------------------------------------------
 
 
 @registry.register
@@ -1163,22 +1163,25 @@ class ChemicalEquationInput(InputTypeBase):
     """
 
     template = "chemicalequationinput.html"
-    tags = ['chemicalequationinput']
+    tags = ["chemicalequationinput"]
 
     @classmethod
     def get_attributes(cls):
         """
         Can set size of text field.
         """
-        return [Attribute('size', '20'), ]
+        return [
+            Attribute("size", "20"),
+        ]
 
     def _extra_context(self):
         """
         TODO (vshnayder): Get rid of this once we have a standard way of requiring js to be loaded.
         """
         return {
-            'previewer': '{static_url}js/capa/chemical_equation_preview.js'.format(
-                static_url=self.capa_system.STATIC_URL),
+            "previewer": "{static_url}js/capa/chemical_equation_preview.js".format(
+                static_url=self.capa_system.STATIC_URL
+            ),
         }
 
     def handle_ajax(self, dispatch, data):
@@ -1186,7 +1189,7 @@ def handle_ajax(self, dispatch, data):
         Since we only have chemcalc preview this input, check to see if it
         matches the corresponding dispatch and send it through if it does
         """
-        if dispatch == 'preview_chemcalc':
+        if dispatch == "preview_chemcalc":
             return self.preview_chemcalc(data)
         return {}
 
@@ -1203,27 +1206,26 @@ def preview_chemcalc(self, data):
         """
 
         _ = self.capa_system.i18n.gettext
-        result = {'preview': '',
-                  'error': ''}
+        result = {"preview": "", "error": ""}
         try:
-            formula = data['formula']
+            formula = data["formula"]
         except KeyError:
-            result['error'] = _("No formula specified.")
+            result["error"] = _("No formula specified.")
             return result
 
         try:
-            result['preview'] = chemcalc.render_to_html(formula)
+            result["preview"] = chemcalc.render_to_html(formula)
         except pyparsing.ParseException as err:
-            result['error'] = _("Couldn't parse formula: {error_msg}").format(error_msg=err.msg)
+            result["error"] = _("Couldn't parse formula: {error_msg}").format(error_msg=err.msg)
         except Exception:  # lint-amnesty, pylint: disable=broad-except
             # this is unexpected, so log
-            log.warning(
-                "Error while previewing chemical formula", exc_info=True)
-            result['error'] = _("Error while rendering preview")
+            log.warning("Error while previewing chemical formula", exc_info=True)
+            result["error"] = _("Error while rendering preview")
 
         return result
 
-#-------------------------------------------------------------------------
+
+# -------------------------------------------------------------------------
 
 
 @registry.register
@@ -1241,7 +1243,7 @@ class FormulaEquationInput(InputTypeBase):
     """
 
     template = "formulaequationinput.html"
-    tags = ['formulaequationinput']
+    tags = ["formulaequationinput"]
 
     @classmethod
     def get_attributes(cls):
@@ -1249,9 +1251,9 @@ def get_attributes(cls):
         Can set size of text field.
         """
         return [
-            Attribute('size', '20'),
-            Attribute('inline', False),
-            Attribute('trailing_text', ''),
+            Attribute("size", "20"),
+            Attribute("inline", False),
+            Attribute("trailing_text", ""),
         ]
 
     def _extra_context(self):
@@ -1261,8 +1263,9 @@ def _extra_context(self):
         # `reported_status` is basically `status`, except we say 'unanswered'
 
         return {
-            'previewer': '{static_url}js/capa/src/formula_equation_preview.js'.format(
-                static_url=self.capa_system.STATIC_URL),
+            "previewer": "{static_url}js/capa/src/formula_equation_preview.js".format(
+                static_url=self.capa_system.STATIC_URL
+            ),
         }
 
     def handle_ajax(self, dispatch, get):  # lint-amnesty, pylint: disable=arguments-differ
@@ -1270,7 +1273,7 @@ def handle_ajax(self, dispatch, get):  # lint-amnesty, pylint: disable=arguments
         Since we only have formcalc preview this input, check to see if it
         matches the corresponding dispatch and send it through if it does
         """
-        if dispatch == 'preview_formcalc':
+        if dispatch == "preview_formcalc":
             return self.preview_formcalc(get)
         return {}
 
@@ -1287,35 +1290,33 @@ def preview_formcalc(self, get):
         }
         """
         _ = self.capa_system.i18n.gettext
-        result = {'preview': '',
-                  'error': ''}
+        result = {"preview": "", "error": ""}
 
         try:
-            formula = get['formula']
+            formula = get["formula"]
         except KeyError:
-            result['error'] = _("No formula specified.")
+            result["error"] = _("No formula specified.")
             return result
 
-        result['request_start'] = int(get.get('request_start', 0))
+        result["request_start"] = int(get.get("request_start", 0))
 
         try:
             # TODO add references to valid variables and functions
             # At some point, we might want to mark invalid variables as red
             # or something, and this is where we would need to pass those in.
-            result['preview'] = latex_preview(formula)
+            result["preview"] = latex_preview(formula)
         except pyparsing.ParseException:
-            result['error'] = _("Sorry, couldn't parse formula")
-            result['formula'] = formula
+            result["error"] = _("Sorry, couldn't parse formula")
+            result["formula"] = formula
         except Exception:  # lint-amnesty, pylint: disable=broad-except
             # this is unexpected, so log
-            log.warning(
-                "Error while previewing formula", exc_info=True
-            )
-            result['error'] = _("Error while rendering preview")
+            log.warning("Error while previewing formula", exc_info=True)
+            result["error"] = _("Error while rendering preview")
 
         return result
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1325,95 +1326,89 @@ class DragAndDropInput(InputTypeBase):
     labels to base image.
     """
 
-    template = 'drag_and_drop_input.html'
-    tags = ['drag_and_drop_input']
+    template = "drag_and_drop_input.html"
+    tags = ["drag_and_drop_input"]
 
     def setup(self):
 
         def parse(tag, tag_type):
             """Parses <tag ... /> xml element to dictionary. Stores
-                'draggable' and 'target' tags with attributes to dictionary and
-                returns last.
+            'draggable' and 'target' tags with attributes to dictionary and
+            returns last.
 
-                Args:
-                    tag: xml etree element <tag...> with attributes
+            Args:
+                tag: xml etree element <tag...> with attributes
 
-                    tag_type: 'draggable' or 'target'.
+                tag_type: 'draggable' or 'target'.
 
-                    If tag_type is 'draggable' : all attributes except id
-                    (name or label or icon or can_reuse) are optional
+                If tag_type is 'draggable' : all attributes except id
+                (name or label or icon or can_reuse) are optional
 
-                    If tag_type is 'target' all attributes (name, x, y, w, h)
-                    are required. (x, y) - coordinates of center of target,
-                    w, h - weight and height of target.
+                If tag_type is 'target' all attributes (name, x, y, w, h)
+                are required. (x, y) - coordinates of center of target,
+                w, h - weight and height of target.
 
-                Returns:
-                    Dictionary of vaues of attributes:
-                    dict{'name': smth, 'label': smth, 'icon': smth,
-                    'can_reuse': smth}.
+            Returns:
+                Dictionary of vaues of attributes:
+                dict{'name': smth, 'label': smth, 'icon': smth,
+                'can_reuse': smth}.
             """
             tag_attrs = {}
-            tag_attrs['draggable'] = {
-                'id': Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
-                'label': "", 'icon': "",
-                'can_reuse': ""
+            tag_attrs["draggable"] = {
+                "id": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
+                "label": "",
+                "icon": "",
+                "can_reuse": "",
             }
 
-            tag_attrs['target'] = {
-                'id': Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
-                'x': Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
-                'y': Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
-                'w': Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
-                'h': Attribute._sentinel  # lint-amnesty, pylint: disable=protected-access
+            tag_attrs["target"] = {
+                "id": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
+                "x": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
+                "y": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
+                "w": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
+                "h": Attribute._sentinel,  # lint-amnesty, pylint: disable=protected-access
             }
 
             dic = {}
 
             for attr_name in tag_attrs[tag_type].keys():
-                dic[attr_name] = Attribute(attr_name,
-                                           default=tag_attrs[tag_type][attr_name]).parse_from_xml(tag)
+                dic[attr_name] = Attribute(attr_name, default=tag_attrs[tag_type][attr_name]).parse_from_xml(tag)
 
-            if tag_type == 'draggable' and not self.no_labels:
-                dic['label'] = dic['label'] or dic['id']
+            if tag_type == "draggable" and not self.no_labels:
+                dic["label"] = dic["label"] or dic["id"]
 
-            if tag_type == 'draggable':
-                dic['target_fields'] = [parse(target, 'target') for target in
-                                        tag.iterchildren('target')]
+            if tag_type == "draggable":
+                dic["target_fields"] = [parse(target, "target") for target in tag.iterchildren("target")]
 
             return dic
 
         # add labels to images?:
-        self.no_labels = Attribute('no_labels',
-                                   default="False").parse_from_xml(self.xml)
+        self.no_labels = Attribute("no_labels", default="False").parse_from_xml(self.xml)
 
         to_js = {}
 
         # image drag and drop onto
-        to_js['base_image'] = Attribute('img').parse_from_xml(self.xml)
+        to_js["base_image"] = Attribute("img").parse_from_xml(self.xml)
 
         # outline places on image where to drag adn drop
-        to_js['target_outline'] = Attribute('target_outline',
-                                            default="False").parse_from_xml(self.xml)
+        to_js["target_outline"] = Attribute("target_outline", default="False").parse_from_xml(self.xml)
         # one draggable per target?
-        to_js['one_per_target'] = Attribute('one_per_target',
-                                            default="True").parse_from_xml(self.xml)
+        to_js["one_per_target"] = Attribute("one_per_target", default="True").parse_from_xml(self.xml)
         # list of draggables
-        to_js['draggables'] = [parse(draggable, 'draggable') for draggable in
-                               self.xml.iterchildren('draggable')]
+        to_js["draggables"] = [parse(draggable, "draggable") for draggable in self.xml.iterchildren("draggable")]
         # list of targets
-        to_js['targets'] = [parse(target, 'target') for target in
-                            self.xml.iterchildren('target')]
+        to_js["targets"] = [parse(target, "target") for target in self.xml.iterchildren("target")]
 
         # custom background color for labels:
-        label_bg_color = Attribute('label_bg_color',
-                                   default=None).parse_from_xml(self.xml)
+        label_bg_color = Attribute("label_bg_color", default=None).parse_from_xml(self.xml)
         if label_bg_color:
-            to_js['label_bg_color'] = label_bg_color
+            to_js["label_bg_color"] = label_bg_color
+
+        self.loaded_attributes["drag_and_drop_json"] = json.dumps(to_js)
+        self.to_render.add("drag_and_drop_json")
 
-        self.loaded_attributes['drag_and_drop_json'] = json.dumps(to_js)
-        self.to_render.add('drag_and_drop_json')
 
-#-------------------------------------------------------------------------
+# -------------------------------------------------------------------------
 
 
 @registry.register
@@ -1427,61 +1422,56 @@ class DesignProtein2dInput(InputTypeBase):
     """
 
     template = "designprotein2dinput.html"
-    tags = ['designprotein2dinput']
+    tags = ["designprotein2dinput"]
 
     @classmethod
     def get_attributes(cls):
         """
         Note: width, hight, and target_shape are required.
         """
-        return [Attribute('width'),
-                Attribute('height'),
-                Attribute('target_shape')
-                ]
+        return [Attribute("width"), Attribute("height"), Attribute("target_shape")]
 
     def _extra_context(self):
         context = {
-            'applet_loader': '{static_url}js/capa/design-protein-2d.js'.format(
-                static_url=self.capa_system.STATIC_URL),
+            "applet_loader": "{static_url}js/capa/design-protein-2d.js".format(static_url=self.capa_system.STATIC_URL),
         }
 
         return context
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
 class EditAGeneInput(InputTypeBase):
     """
-        An input type for editing a gene.
-        Integrates with the genex GWT application.
+    An input type for editing a gene.
+    Integrates with the genex GWT application.
 
-        Example:
+    Example:
 
-        <editagene genex_dna_sequence="CGAT" genex_problem_number="1"/>
+    <editagene genex_dna_sequence="CGAT" genex_problem_number="1"/>
     """
 
     template = "editageneinput.html"
-    tags = ['editageneinput']
+    tags = ["editageneinput"]
 
     @classmethod
     def get_attributes(cls):
         """
         Note: width, height, and dna_sequencee are required.
         """
-        return [Attribute('genex_dna_sequence'),
-                Attribute('genex_problem_number')
-                ]
+        return [Attribute("genex_dna_sequence"), Attribute("genex_problem_number")]
 
     def _extra_context(self):
         context = {
-            'applet_loader': '{static_url}js/capa/edit-a-gene.js'.format(
-                static_url=self.capa_system.STATIC_URL),
+            "applet_loader": "{static_url}js/capa/edit-a-gene.js".format(static_url=self.capa_system.STATIC_URL),
         }
 
         return context
 
-#---------------------------------------------------------------------
+
+# ---------------------------------------------------------------------
 
 
 @registry.register
@@ -1512,7 +1502,7 @@ class AnnotationInput(InputTypeBase):
     """
 
     template = "annotationinput.html"
-    tags = ['annotationinput']
+    tags = ["annotationinput"]
 
     def setup(self):
         xml = self.xml
@@ -1520,71 +1510,70 @@ def setup(self):
         self.debug = False  # set to True to display extra debug info with input
         self.return_to_annotation = True  # return only works in conjunction with annotatable xmodule
 
-        self.title = xml.findtext('./title', 'Annotation Exercise')
-        self.text = xml.findtext('./text')
-        self.comment = xml.findtext('./comment')
-        self.comment_prompt = xml.findtext(
-            './comment_prompt', 'Type a commentary below:')
-        self.tag_prompt = xml.findtext('./tag_prompt', 'Select one tag:')
+        self.title = xml.findtext("./title", "Annotation Exercise")
+        self.text = xml.findtext("./text")
+        self.comment = xml.findtext("./comment")
+        self.comment_prompt = xml.findtext("./comment_prompt", "Type a commentary below:")
+        self.tag_prompt = xml.findtext("./tag_prompt", "Select one tag:")
         self.options = self._find_options()
 
         # Need to provide a value that JSON can parse if there is no
         # student-supplied value yet.
-        if self.value == '':
-            self.value = 'null'
+        if self.value == "":
+            self.value = "null"
 
         self._validate_options()
 
     def _find_options(self):
-        """ Returns an array of dicts where each dict represents an option. """
-        elements = self.xml.findall('./options/option')
-        return [{
-                'id': index,
-                'description': option.text,
-                'choice': option.get('choice')
-                } for (index, option) in enumerate(elements)]
+        """Returns an array of dicts where each dict represents an option."""
+        elements = self.xml.findall("./options/option")
+        return [
+            {"id": index, "description": option.text, "choice": option.get("choice")}
+            for (index, option) in enumerate(elements)
+        ]
 
     def _validate_options(self):
-        """ Raises a ValueError if the choice attribute is missing or invalid. """
-        valid_choices = ('correct', 'partially-correct', 'incorrect')
+        """Raises a ValueError if the choice attribute is missing or invalid."""
+        valid_choices = ("correct", "partially-correct", "incorrect")
         for option in self.options:
-            choice = option['choice']
+            choice = option["choice"]
             if choice is None:  # lint-amnesty, pylint: disable=no-else-raise
-                raise ValueError('Missing required choice attribute.')
+                raise ValueError("Missing required choice attribute.")
             elif choice not in valid_choices:
-                raise ValueError('Invalid choice attribute: {0}. Must be one of: {1}'.format(
-                    choice, ', '.join(valid_choices)))
+                raise ValueError(
+                    "Invalid choice attribute: {0}. Must be one of: {1}".format(choice, ", ".join(valid_choices))
+                )
 
     def _unpack(self, json_value):
-        """ Unpacks the json input state into a dict. """
+        """Unpacks the json input state into a dict."""
         d = json.loads(json_value)
         if not isinstance(d, dict):
             d = {}
 
-        comment_value = d.get('comment', '')
+        comment_value = d.get("comment", "")
         if not isinstance(comment_value, str):
-            comment_value = ''
+            comment_value = ""
 
-        options_value = d.get('options', [])
+        options_value = d.get("options", [])
         if not isinstance(options_value, list):
             options_value = []
 
         return {
-            'options_value': options_value,
-            'has_options_value': len(options_value) > 0,  # for convenience
-            'comment_value': comment_value,
+            "options_value": options_value,
+            "has_options_value": len(options_value) > 0,  # for convenience
+            "comment_value": comment_value,
         }
 
     def _extra_context(self):
         extra_context = {
-            'title': self.title,
-            'text': self.text,
-            'comment': self.comment,
-            'comment_prompt': self.comment_prompt,
-            'tag_prompt': self.tag_prompt,
-            'options': self.options,
-            'return_to_annotation': self.return_to_annotation,
-            'debug': self.debug
+            "title": self.title,
+            "text": self.text,
+            "comment": self.comment,
+            "comment_prompt": self.comment_prompt,
+            "tag_prompt": self.tag_prompt,
+            "options": self.options,
+            "return_to_annotation": self.return_to_annotation,
+            "debug": self.debug,
         }
 
         extra_context.update(self._unpack(self.value))
@@ -1650,8 +1639,9 @@ class ChoiceTextGroup(InputTypeBase):
     in the problem's display. Since it is inside of an incorrect choice, no answer given
     for it will be correct, and thus specifying an answer for it is not needed.
     """
+
     template = "choicetext.html"
-    tags = ['radiotextgroup', 'checkboxtextgroup']
+    tags = ["radiotextgroup", "checkboxtextgroup"]
 
     def setup(self):
         """
@@ -1666,18 +1656,16 @@ def setup(self):
         `self.extract_choices`
         """
         self.text_input_values = {}
-        if self.tag == 'radiotextgroup':
+        if self.tag == "radiotextgroup":
             self.html_input_type = "radio"
-        elif self.tag == 'checkboxtextgroup':
+        elif self.tag == "checkboxtextgroup":
             self.html_input_type = "checkbox"
         else:
             _ = self.capa_system.i18n.gettext
-            msg = _("{input_type}: unexpected tag {tag_name}").format(
-                input_type="ChoiceTextGroup", tag_name=self.tag
-            )
+            msg = _("{input_type}: unexpected tag {tag_name}").format(input_type="ChoiceTextGroup", tag_name=self.tag)
             raise Exception(msg)
 
-        if self.value == '':
+        if self.value == "":
             # Make `value` an empty dictionary, if it currently has an empty
             # value. This is necessary because the template expects a
             # dictionary.
@@ -1704,10 +1692,7 @@ def _extra_context(self):
         `input_type` is either 'radio' or 'checkbox' indicating whether the choices for
         this problem will have radiobuttons or checkboxes.
         """
-        return {
-            'input_type': self.html_input_type,
-            'choices': self.choices
-        }
+        return {"input_type": self.html_input_type, "choices": self.choices}
 
     @staticmethod
     def extract_choices(element, i18n):
@@ -1754,7 +1739,7 @@ def extract_choices(element, i18n):
         choices = []
 
         for choice in element:
-            if choice.tag != 'choice':
+            if choice.tag != "choice":
                 msg = Text("[capa.inputtypes.extract_choices] {0}").format(
                     # Translators: a "tag" is an XML element, such as "<b>" in HTML
                     Text(_("Expected a {expected_tag} tag; got {given_tag} instead")).format(
@@ -1766,26 +1751,16 @@ def extract_choices(element, i18n):
                 raise Exception(msg)
 
             components = []
-            choice_text = ''
+            choice_text = ""
             if choice.text is not None:
                 choice_text += choice.text
             # Initialize our dict for the next content
-            adder = {
-                'type': 'text',
-                'contents': choice_text,
-                'tail_text': '',
-                'value': ''
-            }
+            adder = {"type": "text", "contents": choice_text, "tail_text": "", "value": ""}
             components.append(adder)
 
             for elt in choice:
                 # for elements in the choice e.g. <text> <numtolerance_input>
-                adder = {
-                    'type': 'text',
-                    'contents': '',
-                    'tail_text': '',
-                    'value': ''
-                }
+                adder = {"type": "text", "contents": "", "tail_text": "", "value": ""}
                 tag_type = elt.tag
                 # If the current `elt` is a <numtolerance_input> set the
                 # `adder`type to 'numtolerance_input', and 'contents' to
@@ -1793,16 +1768,16 @@ def extract_choices(element, i18n):
                 # Treat decoy_inputs and numtolerance_inputs the same in order
                 # to prevent students from reading the Html and figuring out
                 # which inputs are valid
-                if tag_type in ('numtolerance_input', 'decoy_input'):
+                if tag_type in ("numtolerance_input", "decoy_input"):
                     # We set this to textinput, so that we get a textinput html
                     # element.
-                    adder['type'] = 'textinput'
-                    adder['contents'] = elt.get('name')
+                    adder["type"] = "textinput"
+                    adder["contents"] = elt.get("name")
                 else:
-                    adder['contents'] = elt.text
+                    adder["contents"] = elt.text
 
                 # Add any tail text("is the mean" in the example)
-                adder['tail_text'] = elt.tail if elt.tail else ''
+                adder["tail_text"] = elt.tail if elt.tail else ""
                 components.append(adder)
 
             # Add the tuple for the current choice to the list of choices
diff --git a/xmodule/capa/responsetypes.py b/xmodule/capa/responsetypes.py
index 7521adf0cf9d..c3b97f4ff54e 100644
--- a/xmodule/capa/responsetypes.py
+++ b/xmodule/capa/responsetypes.py
@@ -4,6 +4,7 @@
 
 Used by capa_problem.py
 """
+
 # standard library imports
 import abc
 import inspect
@@ -24,10 +25,10 @@
 import random2 as random
 import requests
 import six
+
 # specific library imports
 from calc import UndefinedVariable, UnmatchedParenthesis, evaluator
 from django.utils import html
-
 from lxml import etree
 from lxml.html.soupparser import fromstring as fromstring_bs  # uses Beautiful Soup!!! FIXME?
 from pyparsing import ParseException
@@ -50,7 +51,7 @@
     find_with_default,
     get_course_id_from_capa_block,
     get_inner_html_from_xpath,
-    is_list_of_files
+    is_list_of_files,
 )
 
 log = logging.getLogger(__name__)
@@ -64,13 +65,13 @@
 #  `django.utils.translation.ugettext_noop` because Django cannot be imported in this file
 _ = lambda text: text
 
-QUESTION_HINT_CORRECT_STYLE = 'feedback-hint-correct'
-QUESTION_HINT_INCORRECT_STYLE = 'feedback-hint-incorrect'
-QUESTION_HINT_LABEL_STYLE = 'hint-label'
-QUESTION_HINT_TEXT_STYLE = 'hint-text'
-QUESTION_HINT_MULTILINE = 'feedback-hint-multi'
+QUESTION_HINT_CORRECT_STYLE = "feedback-hint-correct"
+QUESTION_HINT_INCORRECT_STYLE = "feedback-hint-incorrect"
+QUESTION_HINT_LABEL_STYLE = "hint-label"
+QUESTION_HINT_TEXT_STYLE = "hint-text"
+QUESTION_HINT_MULTILINE = "feedback-hint-multi"
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Exceptions
 
 
@@ -78,6 +79,7 @@ class LoncapaProblemError(Exception):
     """
     Error in specification of a problem
     """
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
 
@@ -86,6 +88,7 @@ class ResponseError(Exception):
     Error for failure in processing a response, including
     exceptions that occur when executing a custom script.
     """
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
 
@@ -94,9 +97,11 @@ class StudentInputError(Exception):
     Error for an invalid student input.
     For example, submitting a string when the problem expects a number
     """
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 #
 # Main base class for CAPA responsetypes
 
@@ -169,35 +174,29 @@ def __init__(self, xml, inputfields, context, system, capa_block, minimal_init):
         self.capa_system = system
         self.capa_block = capa_block  # njp, note None
 
-        self.id = xml.get('id')
+        self.id = xml.get("id")
 
         # The LoncapaProblemError messages here do not need to be translated as they are
         # only displayed to the user when settings.DEBUG is True
         for abox in inputfields:
             if abox.tag not in self.allowed_inputfields:
-                msg = "%s: cannot have input field %s" % (
-                    str(self), abox.tag)
-                msg += "\nSee XML source line %s" % getattr(
-                    xml, 'sourceline', '[unavailable]')
+                msg = "%s: cannot have input field %s" % (str(self), abox.tag)
+                msg += "\nSee XML source line %s" % getattr(xml, "sourceline", "[unavailable]")
                 raise LoncapaProblemError(msg)
 
         if self.max_inputfields and len(inputfields) > self.max_inputfields:
-            msg = "%s: cannot have more than %s input fields" % (
-                str(self), self.max_inputfields)
-            msg += "\nSee XML source line %s" % getattr(
-                xml, 'sourceline', '[unavailable]')
+            msg = "%s: cannot have more than %s input fields" % (str(self), self.max_inputfields)
+            msg += "\nSee XML source line %s" % getattr(xml, "sourceline", "[unavailable]")
             raise LoncapaProblemError(msg)
 
         for prop in self.required_attributes:
             if not xml.get(prop):
-                msg = "Error in problem specification: %s missing required attribute %s" % (
-                    str(self), prop)
-                msg += "\nSee XML source line %s" % getattr(
-                    xml, 'sourceline', '[unavailable]')
+                msg = "Error in problem specification: %s missing required attribute %s" % (str(self), prop)
+                msg += "\nSee XML source line %s" % getattr(xml, "sourceline", "[unavailable]")
                 raise LoncapaProblemError(msg)
 
         # ordered list of answer_id values for this response
-        self.answer_ids = [x.get('id') for x in self.inputfields]
+        self.answer_ids = [x.get("id") for x in self.inputfields]
         if self.max_inputfields == 1:
             # for convenience
             self.answer_id = self.answer_ids[0]
@@ -206,31 +205,30 @@ def __init__(self, xml, inputfields, context, system, capa_block, minimal_init):
         self.maxpoints = {}
         for inputfield in self.inputfields:
             # By default, each answerfield is worth 1 point
-            maxpoints = inputfield.get('points', '1')
-            self.maxpoints.update({inputfield.get('id'): int(maxpoints)})
+            maxpoints = inputfield.get("points", "1")
+            self.maxpoints.update({inputfield.get("id"): int(maxpoints)})
 
         if not minimal_init:
             # dict for default answer map (provided in input elements)
             self.default_answer_map = {}
             for entry in self.inputfields:
-                answer = entry.get('correct_answer')
+                answer = entry.get("correct_answer")
                 if answer:
-                    self.default_answer_map[entry.get(
-                        'id')] = contextualize_text(answer, self.context)
+                    self.default_answer_map[entry.get("id")] = contextualize_text(answer, self.context)
 
             # Does this problem have partial credit?
             # If so, what kind? Get it as a list of strings.
-            partial_credit = xml.xpath('.')[0].get('partial_credit', default=False)
+            partial_credit = xml.xpath(".")[0].get("partial_credit", default=False)
 
-            if str(partial_credit).lower().strip() == 'false':
+            if str(partial_credit).lower().strip() == "false":
                 self.has_partial_credit = False
                 self.credit_type = []
             else:
                 self.has_partial_credit = True
-                self.credit_type = partial_credit.split(',')
+                self.credit_type = partial_credit.split(",")
                 self.credit_type = [word.strip().lower() for word in self.credit_type]
 
-            if hasattr(self, 'setup_response'):
+            if hasattr(self, "setup_response"):
                 self.setup_response()
 
     def get_max_score(self):
@@ -239,7 +237,7 @@ def get_max_score(self):
         """
         return sum(self.maxpoints.values())
 
-    def render_html(self, renderer, response_msg=''):
+    def render_html(self, renderer, response_msg=""):
         """
         Return XHTML Element tree representation of this Response.
 
@@ -251,36 +249,36 @@ def render_html(self, renderer, response_msg=''):
         _ = self.capa_system.i18n.gettext
 
         # response_id = problem_id + response index
-        response_id = self.xml.attrib['id']
+        response_id = self.xml.attrib["id"]
 
-        response_index = response_id.split('_')[-1]
+        response_index = response_id.split("_")[-1]
         # Translators: index here could be 1,2,3 and so on
-        response_label = _('Question {index}').format(index=response_index)
+        response_label = _("Question {index}").format(index=response_index)
 
         # wrap the content inside a section
-        tree = etree.Element('div')
-        tree.set('class', 'wrapper-problem-response')
-        tree.set('tabindex', '-1')
-        tree.set('aria-label', response_label)
-        tree.set('role', 'group')
+        tree = etree.Element("div")
+        tree.set("class", "wrapper-problem-response")
+        tree.set("tabindex", "-1")
+        tree.set("aria-label", response_label)
+        tree.set("role", "group")
 
-        if self.xml.get('multiple_inputtypes'):
+        if self.xml.get("multiple_inputtypes"):
             # add <div> to wrap all inputtypes
-            content = etree.SubElement(tree, 'div')
-            content.set('class', 'multi-inputs-group')
-            content.set('role', 'group')
+            content = etree.SubElement(tree, "div")
+            content.set("class", "multi-inputs-group")
+            content.set("role", "group")
 
-            if self.xml.get('multiinput-group-label-id'):
-                content.set('aria-labelledby', self.xml.get('multiinput-group-label-id'))
+            if self.xml.get("multiinput-group-label-id"):
+                content.set("aria-labelledby", self.xml.get("multiinput-group-label-id"))
 
-            if self.xml.get('multiinput-group_description_ids'):
-                content.set('aria-describedby', self.xml.get('multiinput-group_description_ids'))
+            if self.xml.get("multiinput-group_description_ids"):
+                content.set("aria-describedby", self.xml.get("multiinput-group_description_ids"))
         else:
             content = tree
 
         # problem author can make this span display:inline
-        if self.xml.get('inline', ''):
-            tree.set('class', 'inline')
+        if self.xml.get("inline", ""):
+            tree.set("class", "inline")
 
         for item in self.xml:
             # call provided procedure to do the rendering
@@ -303,12 +301,20 @@ def evaluate_answers(self, student_answers, old_cmap):
         Returns the new CorrectMap, with (correctness,msg,hint,hintmode) for each answer_id.
         """
         new_cmap = self.get_score(student_answers)
-        self.get_hints(convert_files_to_filenames(
-            student_answers), new_cmap, old_cmap)
+        self.get_hints(convert_files_to_filenames(student_answers), new_cmap, old_cmap)
         return new_cmap
 
-    def make_hint_div(self, hint_node, correct, student_answer, question_tag,
-                      label=None, hint_log=None, multiline_mode=False, log_extra=None):
+    def make_hint_div(
+        self,
+        hint_node,
+        correct,
+        student_answer,
+        question_tag,
+        label=None,
+        hint_log=None,
+        multiline_mode=False,
+        log_extra=None,
+    ):
         """
         Returns the extended hint div based on the student_answer
         or the empty string if, after processing all the arguments, there is no hint.
@@ -344,55 +350,55 @@ def make_hint_div(self, hint_node, correct, student_answer, question_tag,
         if not hint_log:
             # .text can be None when node has immediate children nodes
             if hint_node is None or (hint_node.text is None and len(hint_node.getchildren()) == 0):
-                return ''
+                return ""
             hint_text = get_inner_html_from_xpath(hint_node)
             if not hint_text:
-                return ''
-            hint_log = [{'text': hint_text}]
+                return ""
+            hint_log = [{"text": hint_text}]
         # invariant: xxxx
 
         # 2. Establish the label:
         # Passed in, or from the node, or the default
         if not label and hint_node is not None:
-            label = hint_node.get('label', None)
+            label = hint_node.get("label", None)
         # Tricky: label None means output defaults, while '' means output empty label
         if label is None:
             if correct:
-                label = _('Correct:')
+                label = _("Correct:")
             else:
-                label = _('Incorrect:')
+                label = _("Incorrect:")
 
         # This is the "feedback hint" event
         event_info = {}
-        event_info['module_id'] = str(self.capa_block.location)
-        event_info['problem_part_id'] = self.id
-        event_info['trigger_type'] = 'single'  # maybe be overwritten by log_extra
-        event_info['hint_label'] = label
-        event_info['hints'] = hint_log
-        event_info['correctness'] = correct
-        event_info['student_answer'] = student_answer
-        event_info['question_type'] = question_tag
+        event_info["module_id"] = str(self.capa_block.location)
+        event_info["problem_part_id"] = self.id
+        event_info["trigger_type"] = "single"  # maybe be overwritten by log_extra
+        event_info["hint_label"] = label
+        event_info["hints"] = hint_log
+        event_info["correctness"] = correct
+        event_info["student_answer"] = student_answer
+        event_info["question_type"] = question_tag
         if log_extra:
             event_info.update(log_extra)
-        self.capa_block.runtime.publish(self.capa_block, 'edx.problem.hint.feedback_displayed', event_info)
+        self.capa_block.runtime.publish(self.capa_block, "edx.problem.hint.feedback_displayed", event_info)
 
         # Form the div-wrapped hint texts
-        hints_wrap = HTML('').join(
-            [HTML('<div class="{question_hint_text_style}">{hint_content}</div>').format(
-                question_hint_text_style=QUESTION_HINT_TEXT_STYLE,
-                hint_content=HTML(dct.get('text'))
-            ) for dct in hint_log]
+        hints_wrap = HTML("").join(
+            [
+                HTML('<div class="{question_hint_text_style}">{hint_content}</div>').format(
+                    question_hint_text_style=QUESTION_HINT_TEXT_STYLE, hint_content=HTML(dct.get("text"))
+                )
+                for dct in hint_log
+            ]
         )
         if multiline_mode:
             hints_wrap = HTML('<div class="{question_hint_multiline}">{hints_wrap}</div>').format(
-                question_hint_multiline=QUESTION_HINT_MULTILINE,
-                hints_wrap=hints_wrap
+                question_hint_multiline=QUESTION_HINT_MULTILINE, hints_wrap=hints_wrap
             )
-        label_wrap = ''
+        label_wrap = ""
         if label:
             label_wrap = HTML('<span class="{question_hint_label_style}">{label} </span>').format(
-                question_hint_label_style=QUESTION_HINT_LABEL_STYLE,
-                label=Text(label)
+                question_hint_label_style=QUESTION_HINT_LABEL_STYLE, label=Text(label)
             )
 
         # Establish the outer style
@@ -403,10 +409,7 @@ def make_hint_div(self, hint_node, correct, student_answer, question_tag,
 
         # Ready to go
         return HTML('<div class="{st}"><div class="explanation-title">{text}</div>{lwrp}{hintswrap}</div>').format(
-            st=style,
-            text=Text(_("Answer")),
-            lwrp=label_wrap,
-            hintswrap=hints_wrap
+            st=style, text=Text(_("Answer")), lwrp=label_wrap, hintswrap=hints_wrap
         )
 
     def get_extended_hints(self, student_answers, new_cmap):
@@ -429,9 +432,9 @@ def get_hints(self, student_answers, new_cmap, old_cmap):
 
         hintfn = None
         hint_function_provided = False
-        hintgroup = self.xml.find('hintgroup')
+        hintgroup = self.xml.find("hintgroup")
         if hintgroup is not None:
-            hintfn = hintgroup.get('hintfn')
+            hintfn = hintgroup.get("hintfn")
             if hintfn is not None:
                 hint_function_provided = True
 
@@ -452,9 +455,12 @@ def get_hints(self, student_answers, new_cmap, old_cmap):
                 CORRECTMAP_PY = inspect.getsource(correctmap)
 
             code = (
-                CORRECTMAP_PY + "\n" +
-                self.context['script_code'] + "\n" +
-                textwrap.dedent("""
+                CORRECTMAP_PY
+                + "\n"
+                + self.context["script_code"]
+                + "\n"
+                + textwrap.dedent(
+                    """
                     new_cmap = CorrectMap()
                     new_cmap.set_dict(new_cmap_dict)
                     old_cmap = CorrectMap()
@@ -462,36 +468,35 @@ def get_hints(self, student_answers, new_cmap, old_cmap):
                     {hintfn}(answer_ids, student_answers, new_cmap, old_cmap)
                     new_cmap_dict.update(new_cmap.get_dict())
                     old_cmap_dict.update(old_cmap.get_dict())
-                    """).format(hintfn=hintfn)
+                    """
+                ).format(hintfn=hintfn)
             )
             globals_dict = {
-                'answer_ids': self.answer_ids,
-                'student_answers': student_answers,
-                'new_cmap_dict': new_cmap.get_dict(),
-                'old_cmap_dict': old_cmap.get_dict(),
+                "answer_ids": self.answer_ids,
+                "student_answers": student_answers,
+                "new_cmap_dict": new_cmap.get_dict(),
+                "old_cmap_dict": old_cmap.get_dict(),
             }
 
             try:
                 safe_exec.safe_exec(
                     code,
                     globals_dict,
-                    python_path=self.context['python_path'],
-                    extra_files=self.context['extra_files'],
-                    limit_overrides_context=get_course_id_from_capa_block(
-                        self.capa_block
-                    ),
+                    python_path=self.context["python_path"],
+                    extra_files=self.context["extra_files"],
+                    limit_overrides_context=get_course_id_from_capa_block(self.capa_block),
                     slug=self.id,
-                    random_seed=self.context['seed'],
+                    random_seed=self.context["seed"],
                     unsafely=self.capa_system.can_execute_unsafe_code(),
                 )
             except Exception as err:
                 _ = self.capa_system.i18n.gettext
-                msg = _('Error {err} in evaluating hint function {hintfn}.').format(err=err, hintfn=hintfn)
-                sourcenum = getattr(self.xml, 'sourceline', _('(Source code line unavailable)'))
+                msg = _("Error {err} in evaluating hint function {hintfn}.").format(err=err, hintfn=hintfn)
+                sourcenum = getattr(self.xml, "sourceline", _("(Source code line unavailable)"))
                 msg += "\n" + _("See XML source line {sourcenum}.").format(sourcenum=sourcenum)
                 raise ResponseError(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
-            new_cmap.set_dict(globals_dict['new_cmap_dict'])
+            new_cmap.set_dict(globals_dict["new_cmap_dict"])
             return
 
         # no hint function provided
@@ -511,25 +516,28 @@ def get_hints(self, student_answers, new_cmap, old_cmap):
         #   </hintgroup>
         # </formularesponse>
 
-        if (self.hint_tag is not None
-                and hintgroup is not None
-                and hintgroup.find(self.hint_tag) is not None
-                and hasattr(self, 'check_hint_condition')):
+        if (
+            self.hint_tag is not None
+            and hintgroup is not None
+            and hintgroup.find(self.hint_tag) is not None
+            and hasattr(self, "check_hint_condition")
+        ):
 
             rephints = hintgroup.findall(self.hint_tag)
             hints_to_show = self.check_hint_condition(  # lint-amnesty, pylint: disable=assignment-from-no-return
-                rephints, student_answers)
+                rephints, student_answers
+            )
             # can be 'on_request' or 'always' (default)
 
-            hintmode = hintgroup.get('mode', 'always')
-            for hintpart in hintgroup.findall('hintpart'):
-                if hintpart.get('on') in hints_to_show:
-                    hint_text = hintpart.find('text').text
+            hintmode = hintgroup.get("mode", "always")
+            for hintpart in hintgroup.findall("hintpart"):
+                if hintpart.get("on") in hints_to_show:
+                    hint_text = hintpart.find("text").text
                     # make the hint appear after the last answer box in this
                     # response
                     aid = self.answer_ids[-1]
                     new_cmap.set_hint_and_mode(aid, hint_text, hintmode)
-            log.debug('after hint: new_cmap = %s', new_cmap)
+            log.debug("after hint: new_cmap = %s", new_cmap)
         else:
             # If no other hint form matches, try extended hints.
             self.get_extended_hints(student_answers, new_cmap)
@@ -570,23 +578,23 @@ def setup_response(self):
         pass
 
     def __str__(self):
-        return 'LoncapaProblem Response %s' % self.xml.tag
+        return "LoncapaProblem Response %s" % self.xml.tag
 
     def _render_response_msg_html(self, response_msg):
-        """ Render a <div> for a message that applies to the entire response.
+        """Render a <div> for a message that applies to the entire response.
 
         *response_msg* is a string, which may contain XHTML markup
 
-        Returns an etree element representing the response message <div> """
+        Returns an etree element representing the response message <div>"""
         # First try wrapping the text in a <div> and parsing
         # it as an XHTML tree
         try:
-            response_msg_div = etree.XML(HTML('<div>{}</div>').format(HTML(str(response_msg))))
+            response_msg_div = etree.XML(HTML("<div>{}</div>").format(HTML(str(response_msg))))
 
         # If we can't do that, create the <div> and set the message
         # as the text of the <div>
         except Exception:  # pylint: disable=broad-except
-            response_msg_div = etree.Element('div')
+            response_msg_div = etree.Element("div")
             response_msg_div.text = str(response_msg)
 
         # Set the css class of the message <div>
@@ -598,18 +606,18 @@ def _render_response_msg_html(self, response_msg):
     # objects without having to call hasattr() directly.
     def has_mask(self):
         """True if the response has masking."""
-        return hasattr(self, '_has_mask')
+        return hasattr(self, "_has_mask")
 
     def has_shuffle(self):
         """True if the response has a shuffle transformation."""
-        return hasattr(self, '_has_shuffle')
+        return hasattr(self, "_has_shuffle")
 
     def has_answerpool(self):
         """True if the response has an answer-pool transformation."""
-        return hasattr(self, '_has_answerpool')
+        return hasattr(self, "_has_answerpool")
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 @registry.register
 class ChoiceResponse(LoncapaResponse):
     """
@@ -658,10 +666,11 @@ class ChoiceResponse(LoncapaResponse):
     and it'd be nice to change this at some point.
 
     """
-    human_name = _('Checkboxes')
-    tags = ['choiceresponse']
+
+    human_name = _("Checkboxes")
+    tags = ["choiceresponse"]
     max_inputfields = 1
-    allowed_inputfields = ['checkboxgroup', 'radiogroup']
+    allowed_inputfields = ["checkboxgroup", "radiogroup"]
     correct_choices = None
     multi_device_support = True
 
@@ -673,18 +682,18 @@ def setup_response(self):
         for choice in self.get_choices():
 
             # contextualize the name and correct attributes
-            name = contextualize_text(choice.get('name'), self.context)
-            correct = contextualize_text(choice.get('correct'), self.context).upper()
+            name = contextualize_text(choice.get("name"), self.context)
+            correct = contextualize_text(choice.get("correct"), self.context).upper()
 
             # divide choices into correct and incorrect
-            if correct == 'TRUE':
+            if correct == "TRUE":
                 self.correct_choices.add(name)
-            elif correct == 'FALSE':
+            elif correct == "FALSE":
                 self.incorrect_choices.add(name)
 
     def get_choices(self):
         """Returns this response's XML choice elements."""
-        return self.xml.xpath('//*[@id=$id]//choice', id=self.xml.get('id'))
+        return self.xml.xpath("//*[@id=$id]//choice", id=self.xml.get("id"))
 
     def assign_choice_names(self):
         """
@@ -694,7 +703,7 @@ def assign_choice_names(self):
         for index, choice in enumerate(self.get_choices()):
             choice.set("name", "choice_" + str(index))
             # If a choice does not have an id, assign 'A' 'B', .. used by CompoundHint
-            if not choice.get('id'):
+            if not choice.get("id"):
                 choice.set("id", chr(ord("A") + index))
 
     def grade_via_every_decision_counts(self, **kwargs):
@@ -709,9 +718,9 @@ def grade_via_every_decision_counts(self, **kwargs):
         Returns a CorrectMap.
         """
 
-        all_choices = kwargs['all_choices']
-        student_answer = kwargs['student_answer']
-        student_non_answers = kwargs['student_non_answers']
+        all_choices = kwargs["all_choices"]
+        student_answer = kwargs["student_answer"]
+        student_non_answers = kwargs["student_non_answers"]
 
         edc_max_grade = len(all_choices)
         edc_current_grade = 0
@@ -723,11 +732,11 @@ def grade_via_every_decision_counts(self, **kwargs):
         return_grade = round_away_from_zero(self.get_max_score() * float(edc_current_grade) / float(edc_max_grade), 2)
 
         if edc_current_grade == edc_max_grade:
-            return CorrectMap(self.answer_id, correctness='correct')
+            return CorrectMap(self.answer_id, correctness="correct")
         elif edc_current_grade > 0:
-            return CorrectMap(self.answer_id, correctness='partially-correct', npoints=return_grade)
+            return CorrectMap(self.answer_id, correctness="partially-correct", npoints=return_grade)
         else:
-            return CorrectMap(self.answer_id, correctness='incorrect', npoints=0)
+            return CorrectMap(self.answer_id, correctness="incorrect", npoints=0)
 
     def grade_via_halves(self, **kwargs):
         """
@@ -743,9 +752,9 @@ def grade_via_halves(self, **kwargs):
         Returns a CorrectMap
         """
 
-        all_choices = kwargs['all_choices']
-        student_answer = kwargs['student_answer']
-        student_non_answers = kwargs['student_non_answers']
+        all_choices = kwargs["all_choices"]
+        student_answer = kwargs["student_answer"]
+        student_non_answers = kwargs["student_non_answers"]
 
         halves_error_count = 0
 
@@ -755,15 +764,15 @@ def grade_via_halves(self, **kwargs):
 
         if halves_error_count == 0:
             return_grade = self.get_max_score()
-            return CorrectMap(self.answer_id, correctness='correct', npoints=return_grade)
+            return CorrectMap(self.answer_id, correctness="correct", npoints=return_grade)
         elif halves_error_count == 1 and len(all_choices) > 2:
             return_grade = round_away_from_zero(self.get_max_score() / 2.0, 2)
-            return CorrectMap(self.answer_id, correctness='partially-correct', npoints=return_grade)
+            return CorrectMap(self.answer_id, correctness="partially-correct", npoints=return_grade)
         elif halves_error_count == 2 and len(all_choices) > 4:
             return_grade = round_away_from_zero(self.get_max_score() / 4.0, 2)
-            return CorrectMap(self.answer_id, correctness='partially-correct', npoints=return_grade)
+            return CorrectMap(self.answer_id, correctness="partially-correct", npoints=return_grade)
         else:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
     def grade_without_partial_credit(self, **kwargs):
         """
@@ -772,7 +781,7 @@ def grade_without_partial_credit(self, **kwargs):
         Arguments: student_answer, which is the items the student actually chose
         """
 
-        student_answer = kwargs['student_answer']
+        student_answer = kwargs["student_answer"]
 
         required_selected = len(self.correct_choices - student_answer) == 0
         no_extra_selected = len(student_answer - self.correct_choices) == 0
@@ -780,9 +789,9 @@ def grade_without_partial_credit(self, **kwargs):
         correct = required_selected & no_extra_selected
 
         if correct:
-            return CorrectMap(self.answer_id, 'correct')
+            return CorrectMap(self.answer_id, "correct")
         else:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
     def get_score(self, student_answers):
 
@@ -807,7 +816,7 @@ def get_score(self, student_answers):
         empty_answer = student_answer == []
 
         if empty_answer:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
         student_answer = set(student_answer)
 
@@ -825,24 +834,22 @@ def get_score(self, student_answers):
         # Translators: 'partial_credit' and the items in the 'graders' object
         # are attribute names or values and should not be translated.
         graders = {
-            'edc': self.grade_via_every_decision_counts,
-            'halves': self.grade_via_halves,
-            'false': self.grade_without_partial_credit
+            "edc": self.grade_via_every_decision_counts,
+            "halves": self.grade_via_halves,
+            "false": self.grade_without_partial_credit,
         }
 
         # Only one type of credit at a time.
         if len(self.credit_type) > 1:
-            raise LoncapaProblemError('Only one type of partial credit is allowed for Checkbox problems.')
+            raise LoncapaProblemError("Only one type of partial credit is allowed for Checkbox problems.")
 
         # Make sure we're using an approved style.
         if self.credit_type[0] not in graders:
-            raise LoncapaProblemError('partial_credit attribute should be one of: ' + ','.join(graders))
+            raise LoncapaProblemError("partial_credit attribute should be one of: " + ",".join(graders))
 
         # Run the appropriate grader.
         return graders[self.credit_type[0]](
-            all_choices=all_choices,
-            student_answer=student_answer,
-            student_non_answers=student_non_answers
+            all_choices=all_choices, student_answer=student_answer, student_non_answers=student_non_answers
         )
 
     def get_answers(self):
@@ -870,7 +877,7 @@ def get_extended_hints(self, student_answers, new_cmap):
             return
 
         # Look at all the choices - each can generate some hint text
-        choices = self.xml.xpath('//checkboxgroup[@id=$id]/choice', id=self.answer_id)
+        choices = self.xml.xpath("//checkboxgroup[@id=$id]/choice", id=self.answer_id)
         hint_log = []
         label = None
         label_count = 0
@@ -881,38 +888,38 @@ def get_extended_hints(self, student_answers, new_cmap):
         student_choice_list = student_answers.get(self.answer_id, [])
         # We build up several hints in hint_divs, then wrap it once at the end.
         for choice in choices:
-            name = choice.get('name')  # generated name, e.g. choice_2
+            name = choice.get("name")  # generated name, e.g. choice_2
             choice_all.append(name)
             selected = name in student_choice_list  # looking for 'true' vs. 'false'
             if selected:
-                selector = 'true'
+                selector = "true"
             else:
-                selector = 'false'
+                selector = "false"
             # We find the matching <choicehint> in python vs xpath so we can be case-insensitive
-            hint_nodes = choice.findall('./choicehint')
+            hint_nodes = choice.findall("./choicehint")
             for hint_node in hint_nodes:
-                if hint_node.get('selected', '').lower() == selector:
+                if hint_node.get("selected", "").lower() == selector:
                     text = get_inner_html_from_xpath(hint_node)
-                    if hint_node.get('label') is not None:  # tricky: label '' vs None is significant
-                        label = hint_node.get('label')
+                    if hint_node.get("label") is not None:  # tricky: label '' vs None is significant
+                        label = hint_node.get("label")
                         label_count += 1
                     if text:
-                        hint_log.append({'text': text, 'trigger': [{'choice': name, 'selected': selected}]})
+                        hint_log.append({"text": text, "trigger": [{"choice": name, "selected": selected}]})
 
         if hint_log:
             # Complication: if there is only a single label specified, we use it.
             # However if there are multiple, we use none.
             if label_count > 1:
                 label = None
-            new_cmap[self.answer_id]['msg'] += self.make_hint_div(
+            new_cmap[self.answer_id]["msg"] += self.make_hint_div(
                 None,
-                new_cmap[self.answer_id]['correctness'] == 'correct',
+                new_cmap[self.answer_id]["correctness"] == "correct",
                 student_choice_list,
                 self.tags[0],
                 label,
                 hint_log,
                 multiline_mode=True,  # the one case where we do this
-                log_extra={'choice_all': choice_all}  # checkbox specific logging
+                log_extra={"choice_all": choice_all},  # checkbox specific logging
             )
 
     def get_compound_hints(self, new_cmap, student_answers):
@@ -928,38 +935,40 @@ def get_compound_hints(self, new_cmap, student_answers):
             student_set = set()
             names = []
             for student_answer in student_answers[self.answer_id]:
-                choice_list = self.xml.xpath('//checkboxgroup[@id=$id]/choice[@name=$name]',
-                                             id=self.answer_id, name=student_answer)
+                choice_list = self.xml.xpath(
+                    "//checkboxgroup[@id=$id]/choice[@name=$name]", id=self.answer_id, name=student_answer
+                )
                 if choice_list:
                     choice = choice_list[0]
-                    student_set.add(choice.get('id').upper())
+                    student_set.add(choice.get("id").upper())
                     names.append(student_answer)
 
-            for compound_hint in self.xml.xpath('//checkboxgroup[@id=$id]/compoundhint', id=self.answer_id):
+            for compound_hint in self.xml.xpath("//checkboxgroup[@id=$id]/compoundhint", id=self.answer_id):
                 # Selector words are space separated and not case-sensitive
-                selectors = compound_hint.get('value').upper().split()
+                selectors = compound_hint.get("value").upper().split()
                 selector_set = set(selectors)
 
                 if selector_set == student_set:
                     # This is the atypical case where the hint text is in an inner div with its own style.
                     hint_text = compound_hint.text.strip()
                     # Compute the choice names just for logging
-                    choices = self.xml.xpath('//checkboxgroup[@id=$id]/choice', id=self.answer_id)
-                    choice_all = [choice.get('name') for choice in choices]
-                    hint_log = [{'text': hint_text, 'trigger': [{'choice': name, 'selected': True} for name in names]}]
-                    new_cmap[self.answer_id]['msg'] += self.make_hint_div(
+                    choices = self.xml.xpath("//checkboxgroup[@id=$id]/choice", id=self.answer_id)
+                    choice_all = [choice.get("name") for choice in choices]
+                    hint_log = [{"text": hint_text, "trigger": [{"choice": name, "selected": True} for name in names]}]
+                    new_cmap[self.answer_id]["msg"] += self.make_hint_div(
                         compound_hint,
-                        new_cmap[self.answer_id]['correctness'] == 'correct',
+                        new_cmap[self.answer_id]["correctness"] == "correct",
                         student_answers[self.answer_id],
                         self.tags[0],
                         hint_log=hint_log,
-                        log_extra={'trigger_type': 'compound', 'choice_all': choice_all}
+                        log_extra={"trigger_type": "compound", "choice_all": choice_all},
                     )
                     compound_hint_matched = True
                     break
         return compound_hint_matched
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -980,12 +989,13 @@ class MultipleChoiceResponse(LoncapaResponse):
     to translate back to choice_0 name style for recording in the logs, so
     the logging is in terms of the regular names.
     """
+
     # TODO: randomize
 
-    human_name = _('Multiple Choice')
-    tags = ['multiplechoiceresponse']
+    human_name = _("Multiple Choice")
+    tags = ["multiplechoiceresponse"]
     max_inputfields = 1
-    allowed_inputfields = ['choicegroup']
+    allowed_inputfields = ["choicegroup"]
     correct_choices = None
     multi_device_support = True
 
@@ -1004,26 +1014,26 @@ def setup_response(self):
 
         # define correct choices (after calling secondary setup)
         xml = self.xml
-        cxml = xml.xpath('//*[@id=$id]//choice', id=xml.get('id'))
+        cxml = xml.xpath("//*[@id=$id]//choice", id=xml.get("id"))
 
         # contextualize correct attribute and then select ones for which
         # correct = "true"
         self.correct_choices = [
-            contextualize_text(choice.get('name'), self.context)
+            contextualize_text(choice.get("name"), self.context)
             for choice in cxml
-            if contextualize_text(choice.get('correct'), self.context).upper() == "TRUE"
+            if contextualize_text(choice.get("correct"), self.context).upper() == "TRUE"
         ]
 
         if self.has_partial_credit:
             self.partial_choices = [
-                contextualize_text(choice.get('name'), self.context)
+                contextualize_text(choice.get("name"), self.context)
                 for choice in cxml
-                if contextualize_text(choice.get('correct'), self.context).lower() == 'partial'
+                if contextualize_text(choice.get("correct"), self.context).lower() == "partial"
             ]
             self.partial_values = [
-                float(choice.get('point_value', default='0.5'))    # Default partial credit: 50%
+                float(choice.get("point_value", default="0.5"))  # Default partial credit: 50%
                 for choice in cxml
-                if contextualize_text(choice.get('correct'), self.context).lower() == 'partial'
+                if contextualize_text(choice.get("correct"), self.context).lower() == "partial"
             ]
 
     def get_extended_hints(self, student_answer_dict, new_cmap):  # lint-amnesty, pylint: disable=arguments-differ
@@ -1045,15 +1055,13 @@ def get_extended_hints(self, student_answer_dict, new_cmap):  # lint-amnesty, py
 
             # Find the named choice used by the student. Silently ignore a non-matching
             # choice name.
-            choice = self.xml.find('./choicegroup[@id="{0}"]/choice[@name="{1}"]'.format(self.answer_id,
-                                                                                         student_answer))
+            choice = self.xml.find(
+                './choicegroup[@id="{0}"]/choice[@name="{1}"]'.format(self.answer_id, student_answer)
+            )
             if choice is not None:
-                hint_node = choice.find('./choicehint')
-                new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                    hint_node,
-                    choice.get('correct').upper() == 'TRUE',
-                    [student_answer],
-                    self.tags[0]
+                hint_node = choice.find("./choicehint")
+                new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                    hint_node, choice.get("correct").upper() == "TRUE", [student_answer], self.tags[0]
                 )
 
     def mc_setup_response(self):
@@ -1065,7 +1073,7 @@ def mc_setup_response(self):
         for response in self.xml.xpath("choicegroup"):
             # Is Masking enabled? -- check for shuffle or answer-pool features
             # Masking (self._has_mask) is off, to be re-enabled with a future PR.
-            rtype = response.get('type')
+            rtype = response.get("type")
             if rtype not in ["MultipleChoice"]:
                 # force choicegroup to be MultipleChoice if not valid
                 response.set("type", "MultipleChoice")
@@ -1106,21 +1114,17 @@ def grade_via_points(self, **kwargs):
         Returns: a CorrectMap
         """
 
-        student_answers = kwargs['student_answers']
+        student_answers = kwargs["student_answers"]
 
-        if (self.answer_id in student_answers
-                and student_answers[self.answer_id] in self.correct_choices):
-            return CorrectMap(self.answer_id, correctness='correct')
+        if self.answer_id in student_answers and student_answers[self.answer_id] in self.correct_choices:
+            return CorrectMap(self.answer_id, correctness="correct")
 
-        elif (
-                self.answer_id in student_answers
-                and student_answers[self.answer_id] in self.partial_choices
-        ):
+        elif self.answer_id in student_answers and student_answers[self.answer_id] in self.partial_choices:
             choice_index = self.partial_choices.index(student_answers[self.answer_id])
             credit_amount = self.partial_values[choice_index]
-            return CorrectMap(self.answer_id, correctness='partially-correct', npoints=credit_amount)
+            return CorrectMap(self.answer_id, correctness="partially-correct", npoints=credit_amount)
         else:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
     def grade_without_partial_credit(self, **kwargs):
         """
@@ -1130,13 +1134,12 @@ def grade_without_partial_credit(self, **kwargs):
         Returns: a CorrectMap
         """
 
-        student_answers = kwargs['student_answers']
+        student_answers = kwargs["student_answers"]
 
-        if (self.answer_id in student_answers
-                and student_answers[self.answer_id] in self.correct_choices):
-            return CorrectMap(self.answer_id, correctness='correct')
+        if self.answer_id in student_answers and student_answers[self.answer_id] in self.correct_choices:
+            return CorrectMap(self.answer_id, correctness="correct")
         else:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
     def get_score(self, student_answers):
         """
@@ -1153,23 +1156,18 @@ def get_score(self, student_answers):
 
         # Translators: 'partial_credit' and the items in the 'graders' object
         # are attribute names or values and should not be translated.
-        graders = {
-            'points': self.grade_via_points,
-            'false': self.grade_without_partial_credit
-        }
+        graders = {"points": self.grade_via_points, "false": self.grade_without_partial_credit}
 
         # Only one type of credit at a time.
         if len(self.credit_type) > 1:
-            raise LoncapaProblemError('Only one type of partial credit is allowed for Multiple Choice problems.')
+            raise LoncapaProblemError("Only one type of partial credit is allowed for Multiple Choice problems.")
 
         # Make sure we're using an approved style.
         if self.credit_type[0] not in graders:
-            raise LoncapaProblemError('partial_credit attribute should be one of: ' + ','.join(graders))
+            raise LoncapaProblemError("partial_credit attribute should be one of: " + ",".join(graders))
 
         # Run the appropriate grader.
-        return graders[self.credit_type[0]](
-            student_answers=student_answers
-        )
+        return graders[self.credit_type[0]](student_answers=student_answers)
 
     def get_answers(self):
         return {self.answer_id: self.correct_choices}
@@ -1194,7 +1192,7 @@ def unmask_order(self):
         """
         # With masking disabled, this computation remains interesting to see
         # the displayed order, even though there is no unmasking.
-        choices = self.xml.xpath('choicegroup/choice')
+        choices = self.xml.xpath("choicegroup/choice")
         return [choice.get("name") for choice in choices]
 
     def do_shuffle(self, tree, problem):
@@ -1210,7 +1208,7 @@ def do_shuffle(self, tree, problem):
         choicegroups = tree.xpath('choicegroup[@shuffle="true"]')
         if choicegroups:
             choicegroup = choicegroups[0]
-            if choicegroup.get('answer-pool') is not None:
+            if choicegroup.get("answer-pool") is not None:
                 _ = self.capa_system.i18n.gettext
                 # Translators: 'shuffle' and 'answer-pool' are attribute names and should not be translated.
                 msg = _("Do not use shuffle and answer-pool at the same time")
@@ -1244,11 +1242,11 @@ def shuffle_choices(self, choices, rng):
         tail = []
         at_head = True
         for choice in choices:
-            if at_head and choice.get('fixed') == 'true':
+            if at_head and choice.get("fixed") == "true":
                 head.append(choice)
                 continue
             at_head = False
-            if choice.get('fixed') == 'true':
+            if choice.get("fixed") == "true":
                 tail.append(choice)
             else:
                 middle.append(choice)
@@ -1268,8 +1266,8 @@ def get_rng(self, problem):
         # The name _shared_rng begins with an _ to suggest that it is not a facility
         # for general use.
         # pylint: disable=protected-access
-        if not hasattr(problem, '_shared_rng'):
-            problem._shared_rng = random.Random(self.context['seed'])
+        if not hasattr(problem, "_shared_rng"):
+            problem._shared_rng = random.Random(self.context["seed"])
         return problem._shared_rng
 
     def do_answer_pool(self, tree, problem):
@@ -1288,8 +1286,8 @@ def do_answer_pool(self, tree, problem):
         choicegroups = tree.xpath("choicegroup[@answer-pool]")
         if choicegroups:
             choicegroup = choicegroups[0]
-            num_str = choicegroup.get('answer-pool')
-            if num_str == '0':
+            num_str = choicegroup.get("answer-pool")
+            if num_str == "0":
                 return
             try:
                 num_choices = int(num_str)
@@ -1321,12 +1319,12 @@ def do_answer_pool(self, tree, problem):
 
             # Filter out solutions that don't correspond to the correct answer we selected to show
             # Note that this means that if the user simply provides a <solution> tag, nothing is filtered
-            solutionset = choicegroup.xpath('../following-sibling::solutionset')
+            solutionset = choicegroup.xpath("../following-sibling::solutionset")
             if len(solutionset) != 0:
                 solutionset = solutionset[0]
-                solutions = solutionset.xpath('./solution')
+                solutions = solutionset.xpath("./solution")
                 for solution in solutions:
-                    if solution.get('explanation-id') != solution_id:
+                    if solution.get("explanation-id") != solution_id:
                         solutionset.remove(solution)
 
     def sample_from_answer_pool(self, choices, rng, num_pool):
@@ -1347,7 +1345,7 @@ def sample_from_answer_pool(self, choices, rng, num_pool):
         incorrect_choices = []
 
         for choice in choices:
-            if choice.get('correct').upper() == 'TRUE':
+            if choice.get("correct").upper() == "TRUE":
                 correct_choices.append(choice)
             else:
                 incorrect_choices.append(choice)
@@ -1373,7 +1371,7 @@ def sample_from_answer_pool(self, choices, rng, num_pool):
         # Select the one correct choice
         index = rng.randint(0, len(correct_choices) - 1)
         correct_choice = correct_choices[index]
-        solution_id = correct_choice.get('explanation-id')
+        solution_id = correct_choice.get("explanation-id")
 
         # Put together the result, pushing most of the work onto rng.shuffle()
         subset_choices = [correct_choice]
@@ -1385,10 +1383,12 @@ def sample_from_answer_pool(self, choices, rng, num_pool):
 
 
 @registry.register
-class TrueFalseResponse(MultipleChoiceResponse):  # lint-amnesty, pylint: disable=abstract-method, missing-class-docstring
+class TrueFalseResponse(
+    MultipleChoiceResponse
+):  # lint-amnesty, pylint: disable=abstract-method, missing-class-docstring
 
-    human_name = _('True/False Choice')
-    tags = ['truefalseresponse']
+    human_name = _("True/False Choice")
+    tags = ["truefalseresponse"]
 
     def mc_setup_response(self):
         i = 0
@@ -1408,11 +1408,12 @@ def get_score(self, student_answers):
             answers = [answers]
 
         if correct == set(answers):
-            return CorrectMap(self.answer_id, 'correct')
+            return CorrectMap(self.answer_id, "correct")
 
-        return CorrectMap(self.answer_id, 'incorrect')
+        return CorrectMap(self.answer_id, "incorrect")
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1421,10 +1422,10 @@ class OptionResponse(LoncapaResponse):
     TODO: handle randomize
     """
 
-    human_name = _('Dropdown')
-    tags = ['optionresponse']
-    hint_tag = 'optionhint'
-    allowed_inputfields = ['optioninput']
+    human_name = _("Dropdown")
+    tags = ["optionresponse"]
+    hint_tag = "optionhint"
+    allowed_inputfields = ["optioninput"]
     answer_fields = None
     multi_device_support = True
 
@@ -1436,17 +1437,27 @@ def get_score(self, student_answers):
         amap = self.get_answers()
         for aid in amap:
             if aid in student_answers and student_answers[aid] == amap[aid]:
-                cmap.set(aid, 'correct')
+                cmap.set(aid, "correct")
             else:
-                cmap.set(aid, 'incorrect')
+                cmap.set(aid, "incorrect")
             answer_variable = self.get_student_answer_variable_name(student_answers, aid)
             if answer_variable:
-                cmap.set_property(aid, 'answervariable', answer_variable)
+                cmap.set_property(aid, "answervariable", answer_variable)
         return cmap
 
     def get_answers(self):
-        amap = dict([(af.get('id'), contextualize_text(af.get(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
-            'correct'), self.context)) for af in self.answer_fields])
+        amap = dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+            [
+                (
+                    af.get("id"),
+                    contextualize_text(
+                        af.get("correct"),
+                        self.context,
+                    ),
+                )
+                for af in self.answer_fields
+            ]
+        )
         return amap
 
     def get_student_answer_variable_name(self, student_answers, aid):
@@ -1458,7 +1469,7 @@ def get_student_answer_variable_name(self, student_answers, aid):
                 # convert val into unicode because student answer always be a unicode string
                 # even it is a list, dict etc.
                 if str(val) == student_answers[aid]:
-                    return '$' + key
+                    return "$" + key
         return None
 
     def get_extended_hints(self, student_answers, new_cmap):
@@ -1471,21 +1482,19 @@ def get_extended_hints(self, student_answers, new_cmap):
         if answer_id in student_answers:
             student_answer = student_answers[answer_id]
             # If we run into an old-style optioninput, there is no <option> tag, so this safely does nothing
-            options = self.xml.xpath('//optioninput[@id=$id]/option', id=answer_id)
+            options = self.xml.xpath("//optioninput[@id=$id]/option", id=answer_id)
             # Extra pass here to ignore whitespace around the answer in the matching
             options = [option for option in options if option.text.strip() == student_answer]
             if options:
                 option = options[0]
-                hint_node = option.find('./optionhint')
+                hint_node = option.find("./optionhint")
                 if hint_node is not None:
-                    new_cmap[answer_id]['msg'] += self.make_hint_div(
-                        hint_node,
-                        option.get('correct').upper() == 'TRUE',
-                        [student_answer],
-                        self.tags[0]
+                    new_cmap[answer_id]["msg"] += self.make_hint_div(
+                        hint_node, option.get("correct").upper() == "TRUE", [student_answer], self.tags[0]
                     )
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1495,16 +1504,16 @@ class NumericalResponse(LoncapaResponse):
     to a number (e.g. `4+5/2^2`), and accepts with a tolerance.
     """
 
-    human_name = _('Numerical Input')
-    tags = ['numericalresponse']
-    hint_tag = 'numericalhint'
-    allowed_inputfields = ['textline', 'formulaequationinput']
-    required_attributes = ['answer']
+    human_name = _("Numerical Input")
+    tags = ["numericalresponse"]
+    hint_tag = "numericalhint"
+    allowed_inputfields = ["textline", "formulaequationinput"]
+    required_attributes = ["answer"]
     max_inputfields = 1
     multi_device_support = True
 
     def __init__(self, *args, **kwargs):
-        self.correct_answer = ''
+        self.correct_answer = ""
         self.additional_answers = []
         self.additional_answer_index = -1
         self.tolerance = default_tolerance
@@ -1515,20 +1524,19 @@ def __init__(self, *args, **kwargs):
     def setup_response(self):
         xml = self.xml
         context = self.context
-        answer = xml.get('answer')
+        answer = xml.get("answer")
 
-        self.additional_answers = (
-            [element.get('answer') for element in xml.findall('additional_answer')]
-        )
+        self.additional_answers = [element.get("answer") for element in xml.findall("additional_answer")]
 
-        if answer.startswith(('[', '(')) and answer.endswith((']', ')')):  # range tolerance case
+        if answer.startswith(("[", "(")) and answer.endswith(("]", ")")):  # range tolerance case
             self.range_tolerance = True
             self.inclusion = (
-                True if answer.startswith('[') else False, True if answer.endswith(']') else False  # lint-amnesty, pylint: disable=simplifiable-if-expression
+                True if answer.startswith("[") else False,  # lint-amnesty, pylint: disable=simplifiable-if-expression
+                True if answer.endswith("]") else False,  # lint-amnesty, pylint: disable=simplifiable-if-expression
             )
             try:
-                self.answer_range = [contextualize_text(x, context) for x in answer[1:-1].split(',')]
-                self.correct_answer = answer[0] + self.answer_range[0] + ', ' + self.answer_range[1] + answer[-1]
+                self.answer_range = [contextualize_text(x, context) for x in answer[1:-1].split(",")]
+                self.correct_answer = answer[0] + self.answer_range[0] + ", " + self.answer_range[1] + answer[-1]
             except Exception:
                 log.debug("Content error--answer '%s' is not a valid range tolerance answer", answer)
                 _ = self.capa_system.i18n.gettext
@@ -1539,10 +1547,7 @@ def setup_response(self):
             self.correct_answer = contextualize_text(answer, context)
 
             # Find the tolerance
-            tolerance_xml = xml.xpath(
-                '//*[@id=$id]//responseparam[@type="tolerance"]/@default',
-                id=xml.get('id')
-            )
+            tolerance_xml = xml.xpath('//*[@id=$id]//responseparam[@type="tolerance"]/@default', id=xml.get("id"))
             if tolerance_xml:  # If it isn't an empty list...
                 self.tolerance = contextualize_text(tolerance_xml[0].strip(), context)
 
@@ -1575,15 +1580,15 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
         Grade a numeric response.
         """
         if self.answer_id not in student_answers:
-            return CorrectMap(self.answer_id, 'incorrect')
+            return CorrectMap(self.answer_id, "incorrect")
 
         # Make sure we're using an approved partial credit style.
         # Currently implemented: 'close' and 'list'
         if self.has_partial_credit:
-            graders = ['list', 'close']
+            graders = ["list", "close"]
             for style in self.credit_type:
                 if style not in graders:
-                    raise LoncapaProblemError('partial_credit attribute should be one of: ' + ','.join(graders))
+                    raise LoncapaProblemError("partial_credit attribute should be one of: " + ",".join(graders))
 
         student_answer = student_answers[self.answer_id]
 
@@ -1597,22 +1602,19 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
         try:
             student_float = evaluator({}, {}, student_answer)
         except UndefinedVariable as err:
-            raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                err.args[0]
-            )
+            raise StudentInputError(err.args[0])  # lint-amnesty, pylint: disable=raise-missing-from
         except UnmatchedParenthesis as err:
-            raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                err.args[0]
-            )
+            raise StudentInputError(err.args[0])  # lint-amnesty, pylint: disable=raise-missing-from
         except ValueError as val_err:
-            if 'factorial' in str(val_err):  # lint-amnesty, pylint: disable=no-else-raise
+            if "factorial" in str(val_err):  # lint-amnesty, pylint: disable=no-else-raise
                 # This is thrown when fact() or factorial() is used in an answer
                 #   that evaluates on negative and/or non-integer inputs
                 # str(ve) will be: `factorial() only accepts integral values` or
                 # `factorial() not defined for negative values`
                 raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                    _("Factorial function evaluated outside its domain:"
-                      "'{student_answer}'").format(student_answer=html.escape(student_answer))
+                    _("Factorial function evaluated outside its domain:'{student_answer}'").format(
+                        student_answer=html.escape(student_answer)
+                    )
                 )
             else:
                 raise general_exception  # lint-amnesty, pylint: disable=raise-missing-from
@@ -1627,16 +1629,16 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
         tree = self.xml
 
         # What multiple of the tolerance is worth partial credit?
-        has_partial_range = tree.xpath('responseparam[@partial_range]')
+        has_partial_range = tree.xpath("responseparam[@partial_range]")
         if has_partial_range:
-            partial_range = float(has_partial_range[0].get('partial_range', default='2'))
+            partial_range = float(has_partial_range[0].get("partial_range", default="2"))
         else:
             partial_range = 2
 
         # Take in alternative answers that are worth partial credit.
-        has_partial_answers = tree.xpath('responseparam[@partial_answers]')
+        has_partial_answers = tree.xpath("responseparam[@partial_answers]")
         if has_partial_answers:
-            partial_answers = has_partial_answers[0].get('partial_answers').split(',')
+            partial_answers = has_partial_answers[0].get("partial_answers").split(",")
             for index, word in enumerate(partial_answers):
                 partial_answers[index] = word.strip()
                 partial_answers[index] = self.get_staff_ans(partial_answers[index])
@@ -1645,7 +1647,7 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
             partial_answers = False
 
         partial_score = 0.5
-        is_correct = 'incorrect'
+        is_correct = "incorrect"
 
         if self.range_tolerance:
             if isinstance(student_float, complex):
@@ -1667,20 +1669,17 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
                     )
                 boundaries.append(boundary.real)
                 if compare_with_tolerance(
-                        student_float,
-                        boundary,
-                        tolerance=float_info.epsilon,
-                        relative_tolerance=True
+                    student_float, boundary, tolerance=float_info.epsilon, relative_tolerance=True
                 ):
-                    is_correct = 'correct' if inclusion else 'incorrect'
+                    is_correct = "correct" if inclusion else "incorrect"
                     break
             else:
                 if boundaries[0] < student_float < boundaries[1]:
-                    is_correct = 'correct'
+                    is_correct = "correct"
                 else:
                     if self.has_partial_credit is False:
                         pass
-                    elif 'close' in self.credit_type:
+                    elif "close" in self.credit_type:
                         # Partial credit: 50% if the student is outside the specified boundaries,
                         # but within an extended set of boundaries.
 
@@ -1689,7 +1688,7 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
                         extended_boundaries.append(boundaries[0] - partial_range * boundary_range)
                         extended_boundaries.append(boundaries[1] + partial_range * boundary_range)
                         if extended_boundaries[0] < student_float < extended_boundaries[1]:
-                            is_correct = 'partially-correct'
+                            is_correct = "partially-correct"
 
         else:
             correct_float = self.get_staff_ans(self.correct_answer)
@@ -1707,47 +1706,47 @@ def get_score(self, student_answers):  # lint-amnesty, pylint: disable=too-many-
             #  the student gets 25%. (We take the 50% and square it, at the moment.)
             #  Set via partial_credit="list,close" or "close, list" or the like.
 
-            if str(self.tolerance).endswith('%'):
-                expanded_tolerance = str(partial_range * float(str(self.tolerance)[:-1])) + '%'
+            if str(self.tolerance).endswith("%"):
+                expanded_tolerance = str(partial_range * float(str(self.tolerance)[:-1])) + "%"
             else:
                 expanded_tolerance = partial_range * float(self.tolerance)
 
             if compare_with_tolerance(student_float, correct_float, self.tolerance):
-                is_correct = 'correct'
+                is_correct = "correct"
             elif self.has_partial_credit is False:
                 pass
-            elif 'list' in self.credit_type:
+            elif "list" in self.credit_type:
                 for value in partial_answers:
                     if compare_with_tolerance(student_float, value, self.tolerance):
-                        is_correct = 'partially-correct'
+                        is_correct = "partially-correct"
                         break
-                    elif 'close' in self.credit_type:
+                    elif "close" in self.credit_type:
                         if compare_with_tolerance(student_float, correct_float, expanded_tolerance):
-                            is_correct = 'partially-correct'
+                            is_correct = "partially-correct"
                             break
                         elif compare_with_tolerance(student_float, value, expanded_tolerance):
-                            is_correct = 'partially-correct'
+                            is_correct = "partially-correct"
                             partial_score = partial_score * partial_score
                             break
-            elif 'close' in self.credit_type:
+            elif "close" in self.credit_type:
                 if compare_with_tolerance(student_float, correct_float, expanded_tolerance):
-                    is_correct = 'partially-correct'
+                    is_correct = "partially-correct"
 
         # Reset self.additional_answer_index to -1 so that we always have a fresh index to look up.
         self.additional_answer_index = -1
 
         # Compare with additional answers.
-        if is_correct == 'incorrect':
+        if is_correct == "incorrect":
             temp_additional_answer_idx = 0
             for additional_answer in self.additional_answers:
                 staff_answer = self.get_staff_ans(additional_answer)
                 if complex(student_float) == staff_answer:
-                    is_correct = 'correct'
+                    is_correct = "correct"
                     self.additional_answer_index = temp_additional_answer_idx
                     break
                 temp_additional_answer_idx += 1
 
-        if is_correct == 'partially-correct':
+        if is_correct == "partially-correct":
             return CorrectMap(self.answer_id, is_correct, npoints=partial_score)
         else:
             return CorrectMap(self.answer_id, is_correct)
@@ -1757,11 +1756,7 @@ def compare_answer(self, ans1, ans2):
         Outside-facing function that lets us compare two numerical answers,
         with this problem's tolerance.
         """
-        return compare_with_tolerance(
-            evaluator({}, {}, ans1),
-            evaluator({}, {}, ans2),
-            self.tolerance
-        )
+        return compare_with_tolerance(evaluator({}, {}, ans1), evaluator({}, {}, ans2), self.tolerance)
 
     def validate_answer(self, answer):
         """
@@ -1776,11 +1771,11 @@ def validate_answer(self, answer):
     def get_answers(self):
         _ = self.capa_system.i18n.gettext
         # Example: "Answer: Answer_1 or Answer_2 or Answer_3".
-        separator = Text(' {b_start}{or_separator}{b_end} ').format(
+        separator = Text(" {b_start}{or_separator}{b_end} ").format(
             # Translators: Separator used in NumericalResponse to display multiple answers.
-            or_separator=_('or'),
-            b_start=HTML('<b>'),
-            b_end=HTML('</b>'),
+            or_separator=_("or"),
+            b_start=HTML("<b>"),
+            b_end=HTML("</b>"),
         )
         return {self.answer_id: separator.join([self.correct_answer] + self.additional_answers)}
 
@@ -1795,16 +1790,13 @@ def set_cmap_msg(self, student_answers, new_cmap, hint_type, hint_index):
             hint_index (int): Index of the hint node
         """
         # Note: using self.id here, not the more typical self.answer_id
-        hint_nodes = self.xml.xpath('//numericalresponse[@id=$id]/' + hint_type, id=self.id)
+        hint_nodes = self.xml.xpath("//numericalresponse[@id=$id]/" + hint_type, id=self.id)
         if hint_nodes:
             hint_node = hint_nodes[hint_index]
-            if hint_type == 'additional_answer':
-                hint_node = hint_nodes[hint_index].find('./correcthint')
-            new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                hint_node,
-                True,
-                [student_answers[self.answer_id]],
-                self.tags[0]
+            if hint_type == "additional_answer":
+                hint_node = hint_nodes[hint_index].find("./correcthint")
+            new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                hint_node, True, [student_answers[self.answer_id]], self.tags[0]
             )
 
     def get_extended_hints(self, student_answers, new_cmap):
@@ -1813,14 +1805,15 @@ def get_extended_hints(self, student_answers, new_cmap):
           <correcthint>Yes, 1+1 IS 2<correcthint>
         """
         if self.answer_id in student_answers:
-            if new_cmap.cmap[self.answer_id]['correctness'] == 'correct':  # if the grader liked the student's answer
+            if new_cmap.cmap[self.answer_id]["correctness"] == "correct":  # if the grader liked the student's answer
                 # Answer is not an additional answer.
                 if self.additional_answer_index == -1:
-                    self.set_cmap_msg(student_answers, new_cmap, 'correcthint', 0)
+                    self.set_cmap_msg(student_answers, new_cmap, "correcthint", 0)
                 else:
-                    self.set_cmap_msg(student_answers, new_cmap, 'additional_answer', self.additional_answer_index)
+                    self.set_cmap_msg(student_answers, new_cmap, "additional_answer", self.additional_answer_index)
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -1856,27 +1849,28 @@ class StringResponse(LoncapaResponse):
             </hintgroup>
         </stringresponse>
     """
-    human_name = _('Text Input')
-    tags = ['stringresponse']
-    hint_tag = 'stringhint'
-    allowed_inputfields = ['textline']
-    required_attributes = ['answer']
+
+    human_name = _("Text Input")
+    tags = ["stringresponse"]
+    hint_tag = "stringhint"
+    allowed_inputfields = ["textline"]
+    required_attributes = ["answer"]
     max_inputfields = 1
     correct_answer = []
     multi_device_support = True
 
     def setup_response_backward(self):
         self.correct_answer = [
-            contextualize_text(answer, self.context).strip() for answer in self.xml.get('answer').split('_or_')
+            contextualize_text(answer, self.context).strip() for answer in self.xml.get("answer").split("_or_")
         ]
 
     def setup_response(self):
-        self.backward = '_or_' in self.xml.get('answer').lower()
+        self.backward = "_or_" in self.xml.get("answer").lower()
         self.regexp = False
         self.case_insensitive = False
-        if self.xml.get('type') is not None:
-            self.regexp = 'regexp' in self.xml.get('type').lower().split(' ')
-            self.case_insensitive = 'ci' in self.xml.get('type').lower().split(' ')
+        if self.xml.get("type") is not None:
+            self.regexp = "regexp" in self.xml.get("type").lower().split(" ")
+            self.case_insensitive = "ci" in self.xml.get("type").lower().split(" ")
 
         # backward compatibility, can be removed in future, it is up to @Lyla Fisher.
         if self.backward:
@@ -1886,20 +1880,19 @@ def setup_response(self):
 
         # XML compatibility note: in 2015, additional_answer switched to having a 'answer' attribute.
         # See make_xml_compatible in capa_problem which translates the old format.
-        correct_answers = (
-            [self.xml.get('answer')] +
-            [element.get('answer') for element in self.xml.findall('additional_answer')]
-        )
+        correct_answers = [self.xml.get("answer")] + [
+            element.get("answer") for element in self.xml.findall("additional_answer")
+        ]
         self.correct_answer = [contextualize_text(answer, self.context).strip() for answer in correct_answers]
 
     def get_score(self, student_answers):
-        """Grade a string response """
+        """Grade a string response"""
         if self.answer_id not in student_answers:
             correct = False
         else:
             student_answer = student_answers[self.answer_id].strip()
             correct = self.check_string(self.correct_answer, student_answer)
-        return CorrectMap(self.answer_id, 'correct' if correct else 'incorrect')
+        return CorrectMap(self.answer_id, "correct" if correct else "incorrect")
 
     def check_string_backward(self, expected, given):
         if self.case_insensitive:
@@ -1923,54 +1916,42 @@ def get_extended_hints(self, student_answers, new_cmap):
         if self.answer_id in student_answers:
             student_answer = student_answers[self.answer_id]
             # Note the atypical case of using self.id instead of self.answer_id
-            responses = self.xml.xpath('//stringresponse[@id=$id]', id=self.id)
+            responses = self.xml.xpath("//stringresponse[@id=$id]", id=self.id)
             if responses:
                 response = responses[0]
 
                 # First call the existing check_string to see if this is a right answer by that test.
                 # It handles the various "ci" "regexp" cases internally.
-                expected = response.get('answer').strip()
+                expected = response.get("answer").strip()
                 if self.check_string([expected], student_answer):
-                    hint_node = response.find('./correcthint')
+                    hint_node = response.find("./correcthint")
                     if hint_node is not None:
-                        new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                            hint_node,
-                            True,
-                            [student_answer],
-                            self.tags[0]
+                        new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                            hint_node, True, [student_answer], self.tags[0]
                         )
                     return
 
                 # Then look for additional answer with an answer= attribute
-                for node in response.findall('./additional_answer'):
+                for node in response.findall("./additional_answer"):
                     if self.match_hint_node(node, student_answer, self.regexp, self.case_insensitive):
-                        hint_node = node.find('./correcthint')
-                        new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                            hint_node,
-                            True,
-                            [student_answer],
-                            self.tags[0]
+                        hint_node = node.find("./correcthint")
+                        new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                            hint_node, True, [student_answer], self.tags[0]
                         )
                         return
 
                 # stringequalhint and regexphint represent wrong answers
-                for hint_node in response.findall('./stringequalhint'):
+                for hint_node in response.findall("./stringequalhint"):
                     if self.match_hint_node(hint_node, student_answer, False, self.case_insensitive):
-                        new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                            hint_node,
-                            False,
-                            [student_answer],
-                            self.tags[0]
+                        new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                            hint_node, False, [student_answer], self.tags[0]
                         )
                         return
 
-                for hint_node in response.findall('./regexphint'):
+                for hint_node in response.findall("./regexphint"):
                     if self.match_hint_node(hint_node, student_answer, True, self.case_insensitive):
-                        new_cmap[self.answer_id]['msg'] += self.make_hint_div(
-                            hint_node,
-                            False,
-                            [student_answer],
-                            self.tags[0]
+                        new_cmap[self.answer_id]["msg"] += self.make_hint_div(
+                            hint_node, False, [student_answer], self.tags[0]
                         )
                         return
 
@@ -1981,7 +1962,7 @@ def match_hint_node(self, node, given, regex_mode, ci_mode):
         The boolean arguments regex_mode and ci_mode control how the answer stored in
         the question is treated for the comparison (analogously to check_string).
         """
-        answer = node.get('answer', '').strip()
+        answer = node.get("answer", "").strip()
         if not answer:
             return False
 
@@ -1991,7 +1972,7 @@ def match_hint_node(self, node, given, regex_mode, ci_mode):
                 flags = re.IGNORECASE
             try:
                 # We follow the check_string convention/exception, adding ^ and $
-                regex = re.compile('^' + answer + '$', flags=flags | re.UNICODE)
+                regex = re.compile("^" + answer + "$", flags=flags | re.UNICODE)
                 return re.search(regex, given)
             except Exception:  # pylint: disable=broad-except
                 return False
@@ -2033,12 +2014,11 @@ def check_string(self, expected, given):
         if self.regexp:  # regexp match
             flags = re.IGNORECASE if self.case_insensitive else 0
             try:
-                regexp = re.compile('^' + '|'.join(expected) + '$', flags=flags | re.UNICODE)
+                regexp = re.compile("^" + "|".join(expected) + "$", flags=flags | re.UNICODE)
                 result = re.search(regexp, given)
             except Exception as err:
-                msg = '[courseware.capa.responsetypes.stringresponse] {error}: {message}'.format(
-                    error=_('error'),
-                    message=str(err)
+                msg = "[courseware.capa.responsetypes.stringresponse] {error}: {message}".format(
+                    error=_("error"), message=str(err)
                 )
                 log.error(msg, exc_info=True)
                 raise ResponseError(msg)  # lint-amnesty, pylint: disable=raise-missing-from
@@ -2053,23 +2033,24 @@ def check_hint_condition(self, hxml_set, student_answers):
         given = student_answers[self.answer_id].strip()
         hints_to_show = []
         for hxml in hxml_set:
-            name = hxml.get('name')
+            name = hxml.get("name")
 
-            hinted_answer = contextualize_text(hxml.get('answer'), self.context).strip()
+            hinted_answer = contextualize_text(hxml.get("answer"), self.context).strip()
 
             if self.check_string([hinted_answer], given):
                 hints_to_show.append(name)
-        log.debug('hints_to_show = %s', hints_to_show)
+        log.debug("hints_to_show = %s", hints_to_show)
         return hints_to_show
 
     def get_answers(self):
         _ = self.capa_system.i18n.gettext
         # Translators: Separator used in StringResponse to display multiple answers.
         # Example: "Answer: Answer_1 or Answer_2 or Answer_3".
-        separator = HTML(' <b>{}</b> ').format(_('or'))
+        separator = HTML(" <b>{}</b> ").format(_("or"))
         return {self.answer_id: separator.join(self.correct_answer)}
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -2079,14 +2060,22 @@ class CustomResponse(LoncapaResponse):
     or in a <script>...</script>
     """
 
-    human_name = _('Custom Evaluated Script')
-    tags = ['customresponse']
+    human_name = _("Custom Evaluated Script")
+    tags = ["customresponse"]
 
-    allowed_inputfields = ['textline', 'textbox', 'crystallography',
-                           'chemicalequationinput', 'vsepr_input',
-                           'drag_and_drop_input', 'designprotein2dinput',
-                           'editageneinput', 'annotationinput',
-                           'jsinput', 'formulaequationinput']
+    allowed_inputfields = [
+        "textline",
+        "textbox",
+        "crystallography",
+        "chemicalequationinput",
+        "vsepr_input",
+        "drag_and_drop_input",
+        "designprotein2dinput",
+        "editageneinput",
+        "annotationinput",
+        "jsinput",
+        "formulaequationinput",
+    ]
     code = None
     expect = None
 
@@ -2098,23 +2087,23 @@ def setup_response(self):
 
         # if <customresponse> has an "expect" (or "answer") attribute then save
         # that
-        self.expect = contextualize_text(xml.get('expect') or xml.get('answer'), self.context)
+        self.expect = contextualize_text(xml.get("expect") or xml.get("answer"), self.context)
 
-        log.debug('answer_ids=%s', self.answer_ids)
+        log.debug("answer_ids=%s", self.answer_ids)
 
         # the <answer>...</answer> stanza should be local to the current <customresponse>.
         # So try looking there first.
         self.code = None
         answer = None
         try:
-            answer = xml.xpath('//*[@id=$id]//answer', id=xml.get('id'))[0]
+            answer = xml.xpath("//*[@id=$id]//answer", id=xml.get("id"))[0]
         except IndexError:
             # print "xml = ",etree.tostring(xml,pretty_print=True)
 
             # if we have a "cfn" attribute then look for the function specified by cfn, in
             # the problem context ie the comparison function is defined in the
             # <script>...</script> stanza instead
-            cfn = xml.get('cfn')
+            cfn = xml.get("cfn")
             if cfn:
                 log.debug("cfn = %s", cfn)
 
@@ -2126,42 +2115,37 @@ def setup_response(self):
                 def make_check_function(script_code, cfn):
                     def check_function(expect, ans, **kwargs):
                         extra_args = "".join(", {0}={0}".format(k) for k in kwargs)
-                        code = (
-                            script_code + "\n" +
-                            "cfn_return = %s(expect, ans%s)\n" % (cfn, extra_args)
-                        )
+                        code = script_code + "\n" + "cfn_return = %s(expect, ans%s)\n" % (cfn, extra_args)
                         globals_dict = {
-                            'expect': expect,
-                            'ans': ans,
+                            "expect": expect,
+                            "ans": ans,
                         }
                         globals_dict.update(kwargs)
                         safe_exec.safe_exec(
                             code,
                             globals_dict,
-                            python_path=self.context['python_path'],
-                            extra_files=self.context['extra_files'],
-                            limit_overrides_context=get_course_id_from_capa_block(
-                                self.capa_block
-                            ),
+                            python_path=self.context["python_path"],
+                            extra_files=self.context["extra_files"],
+                            limit_overrides_context=get_course_id_from_capa_block(self.capa_block),
                             slug=self.id,
-                            random_seed=self.context['seed'],
+                            random_seed=self.context["seed"],
                             unsafely=self.capa_system.can_execute_unsafe_code(),
                         )
-                        return globals_dict['cfn_return']
+                        return globals_dict["cfn_return"]
+
                     return check_function
 
-                self.code = make_check_function(self.context['script_code'], cfn)
+                self.code = make_check_function(self.context["script_code"], cfn)
 
         if not self.code:
             if answer is None:
-                log.error("[courseware.capa.responsetypes.customresponse] missing"
-                          " code checking script! id=%s", self.id)
-                self.code = ''
+                log.error("[courseware.capa.responsetypes.customresponse] missing code checking script! id=%s", self.id)
+                self.code = ""
             else:
-                answer_src = answer.get('src')
+                answer_src = answer.get("src")
                 if answer_src is not None:
                     # TODO: this code seems not to be used any more since self.capa_system.filesystem doesn't exist.
-                    self.code = self.capa_system.filesystem.open('src/' + answer_src).read()
+                    self.code = self.capa_system.filesystem.open("src/" + answer_src).read()
                 else:
                     self.code = answer.text
 
@@ -2172,7 +2156,7 @@ def get_score(self, student_answers):
         """
         _ = self.capa_system.i18n.gettext
 
-        log.debug('%s: student_answers=%s', str(self), student_answers)
+        log.debug("%s: student_answers=%s", str(self), student_answers)
 
         # ordered list of answer id's
         # sort the responses on the bases of the problem's position number
@@ -2188,83 +2172,81 @@ def get_score(self, student_answers):
                     student_answers=student_answers,
                 ),
                 idset=idset,
-                err=err
+                err=err,
             )
 
             log.error(
                 "[courseware.capa.responsetypes.customresponse] error getting"
                 " student answer from %s"
                 "\n idset = %s, error = %s",
-                student_answers, idset, err
+                student_answers,
+                idset,
+                err,
             )
             raise Exception(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
         # global variable in context which holds the Presentation MathML from dynamic math input
         # ordered list of dynamath responses
-        dynamath = [student_answers.get(k + '_dynamath', None) for k in idset]
+        dynamath = [student_answers.get(k + "_dynamath", None) for k in idset]
 
         # if there is only one box, and it's empty, then don't evaluate
         if len(idset) == 1 and not submission[0]:
             # default to no error message on empty answer (to be consistent with other
             # responsetypes) but allow author to still have the old behavior by setting
             # empty_answer_err attribute
-            msg = (HTML('<span class="inline-error">{0}</span>').format(_('No answer entered!'))
-                   if self.xml.get('empty_answer_err') else '')
-            return CorrectMap(idset[0], 'incorrect', msg=msg)
+            msg = (
+                HTML('<span class="inline-error">{0}</span>').format(_("No answer entered!"))
+                if self.xml.get("empty_answer_err")
+                else ""
+            )
+            return CorrectMap(idset[0], "incorrect", msg=msg)
 
         # NOTE: correct = 'unknown' could be dangerous. Inputtypes such as textline are
         # not expecting 'unknown's
-        correct = ['unknown'] * len(idset)
-        messages = [''] * len(idset)
+        correct = ["unknown"] * len(idset)
+        messages = [""] * len(idset)
         overall_message = ""
 
         # put these in the context of the check function evaluator
         # note that this doesn't help the "cfn" version - only the exec version
-        self.context.update({
-            # my ID
-            'response_id': self.id,
-
-            # expected answer (if given as attribute)
-            'expect': self.expect,
-
-            # ordered list of student answers from entry boxes in our subtree
-            'submission': submission,
-
-            # ordered list of ID's of all entry boxes in our subtree
-            'idset': idset,
-
-            # ordered list of all javascript inputs in our subtree
-            'dynamath': dynamath,
-
-            # dict of student's responses, with keys being entry box IDs
-            'answers': student_answers,
-
-            # the list to be filled in by the check function
-            'correct': correct,
-
-            # the list of messages to be filled in by the check function
-            'messages': messages,
-
-            # a message that applies to the entire response
-            # instead of a particular input
-            'overall_message': overall_message,
-
-            # any options to be passed to the cfn
-            'options': self.xml.get('options'),
-            'testdat': 'hello world',
-        })
+        self.context.update(
+            {
+                # my ID
+                "response_id": self.id,
+                # expected answer (if given as attribute)
+                "expect": self.expect,
+                # ordered list of student answers from entry boxes in our subtree
+                "submission": submission,
+                # ordered list of ID's of all entry boxes in our subtree
+                "idset": idset,
+                # ordered list of all javascript inputs in our subtree
+                "dynamath": dynamath,
+                # dict of student's responses, with keys being entry box IDs
+                "answers": student_answers,
+                # the list to be filled in by the check function
+                "correct": correct,
+                # the list of messages to be filled in by the check function
+                "messages": messages,
+                # a message that applies to the entire response
+                # instead of a particular input
+                "overall_message": overall_message,
+                # any options to be passed to the cfn
+                "options": self.xml.get("options"),
+                "testdat": "hello world",
+            }
+        )
 
         # Pass DEBUG to the check function.
-        self.context['debug'] = self.capa_system.DEBUG
+        self.context["debug"] = self.capa_system.DEBUG
 
         # Run the check function
         self.execute_check_function(idset, submission)
 
         # build map giving "correct"ness of the answer(s)
-        correct = self.context['correct']
-        messages = self.context['messages']
-        overall_message = self.clean_message_html(self.context['overall_message'])
-        grade_decimals = self.context.get('grade_decimals')
+        correct = self.context["correct"]
+        messages = self.context["messages"]
+        overall_message = self.clean_message_html(self.context["overall_message"])
+        grade_decimals = self.context.get("grade_decimals")
 
         correct_map = CorrectMap()
         correct_map.set_overall_message(overall_message)
@@ -2274,17 +2256,18 @@ def get_score(self, student_answers):
             if grade_decimals:
                 npoints = max_points * grade_decimals[k]
             else:
-                if correct[k] == 'correct':
+                if correct[k] == "correct":
                     npoints = max_points
-                elif correct[k] == 'partially-correct':
+                elif correct[k] == "partially-correct":
                     npoints = max_points * self.default_pc
                 else:
                     npoints = 0
-            correct_map.set(idset[k], correct[k], msg=messages[k],
-                            npoints=npoints)
+            correct_map.set(idset[k], correct[k], msg=messages[k], npoints=npoints)
         return correct_map
 
-    def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: disable=missing-function-docstring, too-many-statements
+    def execute_check_function(
+        self, idset, submission
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring, too-many-statements
         # exec the check function
         if isinstance(self.code, str):  # lint-amnesty, pylint: disable=too-many-nested-blocks
             try:
@@ -2292,13 +2275,11 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                     self.code,
                     self.context,
                     cache=self.capa_system.cache,
-                    python_path=self.context['python_path'],
-                    extra_files=self.context['extra_files'],
-                    limit_overrides_context=get_course_id_from_capa_block(
-                        self.capa_block
-                    ),
+                    python_path=self.context["python_path"],
+                    extra_files=self.context["extra_files"],
+                    limit_overrides_context=get_course_id_from_capa_block(self.capa_block),
                     slug=self.id,
-                    random_seed=self.context['seed'],
+                    random_seed=self.context["seed"],
                     unsafely=self.capa_system.can_execute_unsafe_code(),
                 )
             except Exception as err:  # pylint: disable=broad-except
@@ -2317,10 +2298,7 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                 ret = tutor_cfn(self.expect, answer_given, **kwargs)
             except Exception as err:  # pylint: disable=broad-except
                 self._handle_exec_exception(err)
-            log.debug(
-                "[courseware.capa.responsetypes.customresponse.get_score] ret = %s",
-                ret
-            )
+            log.debug("[courseware.capa.responsetypes.customresponse.get_score] ret = %s", ret)
             if isinstance(ret, dict):
                 # One kind of dictionary the check function can return has the
                 # form {'ok': BOOLEAN or STRING, 'msg': STRING, 'grade_decimal' (optional): FLOAT (between 0.0 and 1.0)}
@@ -2328,46 +2306,46 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                 # the score the student receives on the response.
                 # If there are multiple inputs, they all get marked
                 # to the same correct/incorrect value
-                if 'ok' in ret:
+                if "ok" in ret:
 
                     # Returning any falsy value or the "false" string for "ok" gives incorrect.
                     # Returning any string that includes "partial" for "ok" gives partial credit.
                     # Returning any other truthy value for "ok" gives correct
 
-                    ok_val = str(ret['ok']).lower().strip() if bool(ret['ok']) else 'false'
+                    ok_val = str(ret["ok"]).lower().strip() if bool(ret["ok"]) else "false"
 
-                    if ok_val == 'false':
-                        correct = 'incorrect'
-                    elif 'partial' in ok_val:
-                        correct = 'partially-correct'
+                    if ok_val == "false":
+                        correct = "incorrect"
+                    elif "partial" in ok_val:
+                        correct = "partially-correct"
                     else:
-                        correct = 'correct'
-                    correct = [correct] * len(idset)   # All inputs share the same mark.
+                        correct = "correct"
+                    correct = [correct] * len(idset)  # All inputs share the same mark.
 
                     # old version, no partial credit:
                     # correct = ['correct' if ret['ok'] else 'incorrect'] * len(idset)
 
-                    msg = ret.get('msg', None)
+                    msg = ret.get("msg", None)
                     msg = self.clean_message_html(msg)
 
                     # If there is only one input, apply the message to that input
                     # Otherwise, apply the message to the whole problem
                     if len(idset) > 1:
-                        self.context['overall_message'] = msg
+                        self.context["overall_message"] = msg
                     else:
-                        self.context['messages'][0] = msg
+                        self.context["messages"][0] = msg
 
-                    if 'grade_decimal' in ret:
-                        decimal = float(ret['grade_decimal'])
+                    if "grade_decimal" in ret:
+                        decimal = float(ret["grade_decimal"])
                     else:
-                        if correct[0] == 'correct':
+                        if correct[0] == "correct":
                             decimal = 1.0
-                        elif correct[0] == 'partially-correct':
+                        elif correct[0] == "partially-correct":
                             decimal = self.default_pc
                         else:
                             decimal = 0.0
                     grade_decimals = [decimal] * len(idset)
-                    self.context['grade_decimals'] = grade_decimals
+                    self.context["grade_decimals"] = grade_decimals
 
                 # Another kind of dictionary the check function can return has
                 # the form:
@@ -2387,9 +2365,9 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                 # This allows the function to return an 'overall message'
                 # that applies to the entire problem, as well as correct/incorrect
                 # status, scaled grades, and messages for individual inputs
-                elif 'input_list' in ret:
-                    overall_message = ret.get('overall_message', '')
-                    input_list = ret['input_list']
+                elif "input_list" in ret:
+                    overall_message = ret.get("overall_message", "")
+                    input_list = ret["input_list"]
 
                     correct = []
                     messages = []
@@ -2400,43 +2378,40 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                     # Returning any other truthy value for "ok" gives correct
 
                     for input_dict in input_list:
-                        if str(input_dict['ok']).lower().strip() == "false" or not input_dict['ok']:
-                            correct.append('incorrect')
-                        elif 'partial' in str(input_dict['ok']).lower().strip():
-                            correct.append('partially-correct')
+                        if str(input_dict["ok"]).lower().strip() == "false" or not input_dict["ok"]:
+                            correct.append("incorrect")
+                        elif "partial" in str(input_dict["ok"]).lower().strip():
+                            correct.append("partially-correct")
                         else:
-                            correct.append('correct')
+                            correct.append("correct")
 
                         # old version, no partial credit
                         # correct.append('correct'
                         #                if input_dict['ok'] else 'incorrect')
 
-                        msg = (self.clean_message_html(input_dict['msg'])
-                               if 'msg' in input_dict else None)
+                        msg = self.clean_message_html(input_dict["msg"]) if "msg" in input_dict else None
                         messages.append(msg)
-                        if 'grade_decimal' in input_dict:
-                            decimal = input_dict['grade_decimal']
+                        if "grade_decimal" in input_dict:
+                            decimal = input_dict["grade_decimal"]
                         else:
-                            if str(input_dict['ok']).lower().strip() == 'true':
+                            if str(input_dict["ok"]).lower().strip() == "true":
                                 decimal = 1.0
-                            elif 'partial' in str(input_dict['ok']).lower().strip():
+                            elif "partial" in str(input_dict["ok"]).lower().strip():
                                 decimal = self.default_pc
                             else:
                                 decimal = 0.0
                         grade_decimals.append(decimal)
 
-                    self.context['messages'] = messages
-                    self.context['overall_message'] = overall_message
-                    self.context['grade_decimals'] = grade_decimals
+                    self.context["messages"] = messages
+                    self.context["overall_message"] = overall_message
+                    self.context["grade_decimals"] = grade_decimals
 
                 # Otherwise, we do not recognize the dictionary
                 # Raise an exception
                 else:
                     log.error(traceback.format_exc())
                     _ = self.capa_system.i18n.gettext
-                    raise ResponseError(
-                        _("CustomResponse: check function returned an invalid dictionary!")
-                    )
+                    raise ResponseError(_("CustomResponse: check function returned an invalid dictionary!"))
 
             else:
 
@@ -2445,17 +2420,17 @@ def execute_check_function(self, idset, submission):  # lint-amnesty, pylint: di
                 # Returning any other truthy value for "ok" gives correct
 
                 if str(ret).lower().strip() == "false" or not bool(ret):
-                    correct = 'incorrect'
-                elif 'partial' in str(ret).lower().strip():
-                    correct = 'partially-correct'
+                    correct = "incorrect"
+                elif "partial" in str(ret).lower().strip():
+                    correct = "partially-correct"
                 else:
-                    correct = 'correct'
+                    correct = "correct"
                 correct = [correct] * len(idset)
 
                 # old version, no partial credit:
                 # correct = ['correct' if ret else 'incorrect'] * len(idset)
 
-            self.context['correct'] = correct
+            self.context["correct"] = correct
 
     def clean_message_html(self, msg):  # lint-amnesty, pylint: disable=missing-function-docstring
 
@@ -2466,19 +2441,19 @@ def clean_message_html(self, msg):  # lint-amnesty, pylint: disable=missing-func
 
             # When we parse *msg* using etree, there needs to be a root
             # element, so we wrap the *msg* text in <html> tags
-            msg = HTML('<html>{msg}</html>').format(msg=HTML(msg))
+            msg = HTML("<html>{msg}</html>").format(msg=HTML(msg))
 
             # Replace < characters
-            msg = msg.replace('&#60;', '&lt;')
+            msg = msg.replace("&#60;", "&lt;")
 
             # Use etree to prettify the HTML
-            msg = etree.tostring(fromstring_bs(msg), pretty_print=True).decode('utf-8')
+            msg = etree.tostring(fromstring_bs(msg), pretty_print=True).decode("utf-8")
 
-            msg = msg.replace('&#13;', '')
+            msg = msg.replace("&#13;", "")
 
             # Remove the <html> tags we introduced earlier, so we're
             # left with just the prettified message markup
-            msg = re.sub('(?ms)<html>(.*)</html>', '\\1', msg)
+            msg = re.sub("(?ms)<html>(.*)</html>", "\\1", msg)
 
             # Strip leading and trailing whitespace
             return msg.strip()
@@ -2512,14 +2487,15 @@ def _handle_exec_exception(self, err):
         """
 
         # Log the error if we are debugging
-        msg = 'Error occurred while evaluating CustomResponse'
+        msg = "Error occurred while evaluating CustomResponse"
         log.warning(msg, exc_info=True)
 
         # Notify student with a student input error
         _, _, traceback_obj = sys.exc_info()
         raise ResponseError(str(err), traceback_obj)
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -2528,31 +2504,33 @@ class SymbolicResponse(CustomResponse):
     Symbolic math response checking, using symmath library.
     """
 
-    human_name = _('Symbolic Math Input')
-    tags = ['symbolicresponse']
+    human_name = _("Symbolic Math Input")
+    tags = ["symbolicresponse"]
     max_inputfields = 1
 
     def setup_response(self):
         # Symbolic response always uses symmath_check()
         # If the XML did not specify this, then set it now
         # Otherwise, we get an error from the superclass
-        self.xml.set('cfn', 'symmath_check')
+        self.xml.set("cfn", "symmath_check")
 
         # Let CustomResponse do its setup
         super(SymbolicResponse, self).setup_response()  # lint-amnesty, pylint: disable=super-with-arguments
 
     def execute_check_function(self, idset, submission):
         from symmath import symmath_check
+
         try:
             # Since we have limited max_inputfields to 1,
             # we can assume that there is only one submission
             answer_given = submission[0]
 
             ret = symmath_check(
-                self.expect, answer_given,
-                dynamath=self.context.get('dynamath'),
-                options=self.context.get('options'),
-                debug=self.context.get('debug'),
+                self.expect,
+                answer_given,
+                dynamath=self.context.get("dynamath"),
+                options=self.context.get("options"),
+                debug=self.context.get("debug"),
             )
         except Exception as err:
             log.error("oops in SymbolicResponse (cfn) error %s", err)
@@ -2563,10 +2541,11 @@ def execute_check_function(self, idset, submission):
                 error_msg=err,
             )
             raise Exception(msg)  # lint-amnesty, pylint: disable=raise-missing-from
-        self.context['messages'][0] = self.clean_message_html(ret['msg'])
-        self.context['correct'] = ['correct' if ret['ok'] else 'incorrect'] * len(idset)
+        self.context["messages"][0] = self.clean_message_html(ret["msg"])
+        self.context["correct"] = ["correct" if ret["ok"] else "incorrect"] * len(idset)
+
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 ## ScoreMessage named tuple ##
 ## valid:       Flag indicating valid score_msg format (Boolean)
@@ -2574,7 +2553,7 @@ def execute_check_function(self, idset, submission):
 ## score:       Points to be assigned (numeric, can be float)
 ## msg:         Message from grader to display to student (string)
 
-ScoreMessage = namedtuple('ScoreMessage', ['valid', 'correct', 'points', 'msg'])
+ScoreMessage = namedtuple("ScoreMessage", ["valid", "correct", "points", "msg"])
 
 
 @registry.register
@@ -2597,9 +2576,9 @@ class CodeResponse(LoncapaResponse):
 
     """
 
-    human_name = _('Code Input')
-    tags = ['coderesponse']
-    allowed_inputfields = ['textbox', 'filesubmission', 'matlabinput']
+    human_name = _("Code Input")
+    tags = ["coderesponse"]
+    allowed_inputfields = ["textbox", "filesubmission", "matlabinput"]
     max_inputfields = 1
     payload = None
     initial_display = None
@@ -2615,19 +2594,19 @@ def setup_response(self):
         """
         xml = self.xml
         # TODO: XML can override external resource (grader/queue) URL
-        self.url = xml.get('url', None)
+        self.url = xml.get("url", None)
 
         # We do not support xqueue within Studio.
         if self.capa_system.xqueue is not None:
             default_queuename = self.capa_system.xqueue.default_queuename
         else:
             default_queuename = None
-        self.queue_name = xml.get('queuename', default_queuename)
+        self.queue_name = xml.get("queuename", default_queuename)
 
         # VS[compat]:
         # Check if XML uses the ExternalResponse format or the generic
         # CodeResponse format
-        codeparam = self.xml.find('codeparam')
+        codeparam = self.xml.find("codeparam")
         assert codeparam is not None, "Unsupported old format! <coderesponse> without <codeparam>"
         self._parse_coderesponse_xml(codeparam)
 
@@ -2638,24 +2617,22 @@ def _parse_coderesponse_xml(self, codeparam):
             self.answer (an answer to display to the student in the LMS)
             self.payload
         """
-        grader_payload = codeparam.find('grader_payload')
-        grader_payload = grader_payload.text if grader_payload is not None else ''
+        grader_payload = codeparam.find("grader_payload")
+        grader_payload = grader_payload.text if grader_payload is not None else ""
         self.payload = {
-            'grader_payload': grader_payload,
+            "grader_payload": grader_payload,
         }
 
         # matlab api key can be defined in course settings. if so, add it to the grader payload
-        api_key = getattr(self.capa_system, 'matlab_api_key', None)
-        if api_key and self.xml.find('matlabinput') is not None:
-            self.payload['token'] = api_key
-            self.payload['endpoint_version'] = "2"
-            self.payload['requestor_id'] = self.capa_system.anonymous_student_id
-
-        self.initial_display = find_with_default(
-            codeparam, 'initial_display', '')
+        api_key = getattr(self.capa_system, "matlab_api_key", None)
+        if api_key and self.xml.find("matlabinput") is not None:
+            self.payload["token"] = api_key
+            self.payload["endpoint_version"] = "2"
+            self.payload["requestor_id"] = self.capa_system.anonymous_student_id
+
+        self.initial_display = find_with_default(codeparam, "initial_display", "")
         _ = self.capa_system.i18n.gettext
-        self.answer = find_with_default(codeparam, 'answer_display',
-                                        _('No answer provided.'))
+        self.answer = find_with_default(codeparam, "answer_display", _("No answer provided."))
 
     def get_score(self, student_answers):
         _ = self.capa_system.i18n.gettext
@@ -2664,21 +2641,21 @@ def get_score(self, student_answers):
             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)
+                "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)  # lint-amnesty, pylint: disable=raise-missing-from
 
         # We do not support xqueue within Studio.
         if self.capa_system.xqueue is None:
             cmap = CorrectMap()
-            cmap.set(self.answer_id, queuestate=None,
-                     msg=_('Error: No grader has been set up for this problem.'))
+            cmap.set(self.answer_id, queuestate=None, msg=_("Error: No grader has been set up for this problem."))
             return cmap
 
         # Prepare xqueue request
-        #------------------------------------------------------------
+        # ------------------------------------------------------------
 
         qinterface = self.capa_system.xqueue.interface
         qtime = datetime.strftime(datetime.now(UTC), xqueue_interface.dateformat)
@@ -2691,52 +2668,52 @@ def get_score(self, student_answers):
         )
         callback_url = self.capa_system.xqueue.construct_callback()
         xheader = xqueue_interface.make_xheader(
-            lms_callback_url=callback_url,
-            lms_key=queuekey,
-            queue_name=self.queue_name
+            lms_callback_url=callback_url, lms_key=queuekey, queue_name=self.queue_name
         )
 
         # Generate body
         if is_list_of_files(submission):
             # TODO: Get S3 pointer from the Queue
-            self.context.update({'submission': ''})
+            self.context.update({"submission": ""})
         else:
-            self.context.update({'submission': submission})
+            self.context.update({"submission": submission})
 
         contents = self.payload.copy()
 
         # Metadata related to the student submission revealed to the external
         # grader
         student_info = {
-            'anonymous_student_id': anonymous_student_id,
-            'submission_time': qtime,
-            'random_seed': self.context['seed'],
+            "anonymous_student_id": anonymous_student_id,
+            "submission_time": qtime,
+            "random_seed": self.context["seed"],
         }
-        contents.update({'student_info': json.dumps(student_info)})
+        contents.update({"student_info": json.dumps(student_info)})
 
         # Submit request. When successful, 'msg' is the prior length of the
         # queue
 
         if is_list_of_files(submission):
             # TODO: Is there any information we want to send here?
-            contents.update({'student_response': ''})
-            (error, msg) = qinterface.send_to_queue(header=xheader,
-                                                    body=json.dumps(contents),
-                                                    files_to_upload=submission)
+            contents.update({"student_response": ""})
+            (error, msg) = qinterface.send_to_queue(
+                header=xheader, body=json.dumps(contents), files_to_upload=submission
+            )
         else:
-            contents.update({'student_response': submission})
-            (error, msg) = qinterface.send_to_queue(header=xheader,
-                                                    body=json.dumps(contents))
+            contents.update({"student_response": submission})
+            (error, msg) = qinterface.send_to_queue(header=xheader, body=json.dumps(contents))
 
         # State associated with the queueing request
-        queuestate = {'key': queuekey,
-                      'time': qtime, }
+        queuestate = {
+            "key": queuekey,
+            "time": qtime,
+        }
 
         cmap = CorrectMap()
         if error:
             _ = self.capa_system.i18n.gettext
-            error_msg = _('Unable to deliver your submission to grader (Reason: {error_msg}).'
-                          ' Please try again later.').format(error_msg=msg)
+            error_msg = _(
+                "Unable to deliver your submission to grader (Reason: {error_msg}). Please try again later."
+            ).format(error_msg=msg)
             cmap.set(self.answer_id, queuestate=None, msg=error_msg)
         else:
             # Queueing mechanism flags:
@@ -2745,8 +2722,7 @@ def get_score(self, student_answers):
             #   2) Frontend: correctness='incomplete' eventually trickles down
             #      through inputtypes.textbox and .filesubmission to inform the
             #      browser to poll the LMS
-            cmap.set(self.answer_id, queuestate=queuestate,
-                     correctness='incomplete', msg=msg)
+            cmap.set(self.answer_id, queuestate=queuestate, correctness="incomplete", msg=msg)
 
         return cmap
 
@@ -2758,14 +2734,14 @@ def update_score(self, score_msg, oldcmap, queuekey):
 
         if not valid_score_msg:
             # Translators: 'grader' refers to the edX automatic code grader.
-            error_msg = _('Invalid grader reply. Please contact the course staff.')
+            error_msg = _("Invalid grader reply. Please contact the course staff.")
             oldcmap.set(self.answer_id, msg=error_msg)
             return oldcmap
 
-        correctness = 'correct' if correct else 'incorrect'
+        correctness = "correct" if correct else "incorrect"
 
         # TODO: Find out how this is used elsewhere, if any
-        self.context['correct'] = correctness
+        self.context["correct"] = correctness
 
         # Replace 'oldcmap' with new grading results if queuekey matches.  If queuekey
         # does not match, we keep waiting for the score_msg whose key actually
@@ -2776,14 +2752,14 @@ def update_score(self, score_msg, oldcmap, queuekey):
                 points = 0
             # Queuestate is consumed
             oldcmap.set(
-                self.answer_id, npoints=points, correctness=correctness,
-                msg=msg.replace('&nbsp;', '&#160;'), queuestate=None)
-        else:
-            log.debug(
-                'CodeResponse: queuekey %s does not match for answer_id=%s.',
-                queuekey,
-                self.answer_id
+                self.answer_id,
+                npoints=points,
+                correctness=correctness,
+                msg=msg.replace("&nbsp;", "&#160;"),
+                queuestate=None,
             )
+        else:
+            log.debug("CodeResponse: queuekey %s does not match for answer_id=%s.", queuekey, self.answer_id)
 
         return oldcmap
 
@@ -2811,21 +2787,20 @@ def _parse_score_msg(self, score_msg):
             score:           Points to be assigned (numeric, can be float)
             msg:             Message from grader to display to student (string)
         """
-        fail = (False, False, 0, '')
+        fail = (False, False, 0, "")
         try:
             score_result = json.loads(score_msg)
         except (TypeError, ValueError):
-            log.error("External grader message should be a JSON-serialized dict."
-                      " Received score_msg = %s", score_msg)
+            log.error("External grader message should be a JSON-serialized dict. Received score_msg = %s", score_msg)
             return fail
         if not isinstance(score_result, dict):
-            log.error("External grader message should be a JSON-serialized dict."
-                      " Received score_result = %s", score_result)
+            log.error(
+                "External grader message should be a JSON-serialized dict. Received score_result = %s", score_result
+            )
             return fail
-        for tag in ['correct', 'score', 'msg']:
+        for tag in ["correct", "score", "msg"]:
             if tag not in score_result:
-                log.error("External grader message is missing one or more required"
-                          " tags: 'correct', 'score', 'msg'")
+                log.error("External grader message is missing one or more required tags: 'correct', 'score', 'msg'")
                 return fail
 
         # Next, we need to check that the contents of the external grader message is safe for the LMS.
@@ -2833,7 +2808,7 @@ def _parse_score_msg(self, score_msg):
         # 2) If it is not valid XML, make sure it is valid HTML.
         #    Note: html5lib parser will try to repair any broken HTML
         #    For example: <aaa></bbb> will become <aaa/>.
-        msg = score_result['msg']
+        msg = score_result["msg"]
 
         try:
             etree.fromstring(msg)
@@ -2842,7 +2817,7 @@ def _parse_score_msg(self, score_msg):
             # XML parser will raise exception, so wee fallback to html5parser,
             # which will set empty "" values for such attrs.
             try:
-                parsed = html5lib.parseFragment(msg, treebuilder='lxml', namespaceHTMLElements=False)
+                parsed = html5lib.parseFragment(msg, treebuilder="lxml", namespaceHTMLElements=False)
             except ValueError:
                 # the parsed message might contain strings that are not
                 # xml compatible, in which case, throw the error message
@@ -2850,16 +2825,15 @@ def _parse_score_msg(self, score_msg):
 
             if not parsed:
                 log.error(
-                    "Unable to parse external grader message as valid"
-                    " XML: score_msg['msg']=%s",
+                    "Unable to parse external grader message as valid XML: score_msg['msg']=%s",
                     msg,
                 )
                 return fail
 
-        return (True, score_result['correct'], score_result['score'], msg)
+        return (True, score_result["correct"], score_result["score"], msg)
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -2871,44 +2845,42 @@ class ExternalResponse(LoncapaResponse):
 
     """
 
-    human_name = _('External Grader')
-    tags = ['externalresponse']
-    allowed_inputfields = ['textline', 'textbox']
+    human_name = _("External Grader")
+    tags = ["externalresponse"]
+    allowed_inputfields = ["textline", "textbox"]
     awdmap = {
-        'EXACT_ANS': 'correct',         # TODO: handle other loncapa responses
-        'WRONG_FORMAT': 'incorrect',
+        "EXACT_ANS": "correct",  # TODO: handle other loncapa responses
+        "WRONG_FORMAT": "incorrect",
     }
 
     def __init__(self, *args, **kwargs):
-        self.url = ''
+        self.url = ""
         self.tests = []
-        self.code = ''
+        self.code = ""
         super(ExternalResponse, self).__init__(*args, **kwargs)  # lint-amnesty, pylint: disable=super-with-arguments
 
     def setup_response(self):
         xml = self.xml
         # FIXME - hardcoded URL
-        self.url = xml.get('url') or "http://qisx.mit.edu:8889/pyloncapa"
+        self.url = xml.get("url") or "http://qisx.mit.edu:8889/pyloncapa"
 
-        answer = xml.find('answer')
+        answer = xml.find("answer")
         if answer is not None:
-            answer_src = answer.get('src')
+            answer_src = answer.get("src")
             if answer_src is not None:
                 # TODO: this code seems not to be used any more since self.capa_system.filesystem doesn't exist.
-                self.code = self.capa_system.filesystem.open('src/' + answer_src).read()
+                self.code = self.capa_system.filesystem.open("src/" + answer_src).read()
             else:
                 self.code = answer.text
         else:
             # no <answer> stanza; get code from <script>
-            self.code = self.context['script_code']
+            self.code = self.context["script_code"]
             if not self.code:
-                msg = '%s: Missing answer script code for externalresponse' % str(
-                    self)
-                msg += "\nSee XML source line %s" % getattr(
-                    self.xml, 'sourceline', '[unavailable]')
+                msg = "%s: Missing answer script code for externalresponse" % str(self)
+                msg += "\nSee XML source line %s" % getattr(self.xml, "sourceline", "[unavailable]")
                 raise LoncapaProblemError(msg)
 
-        self.tests = xml.get('tests')
+        self.tests = xml.get("tests")
 
     def do_external_request(self, cmd, extra_payload):
         """
@@ -2921,10 +2893,10 @@ def do_external_request(self, cmd, extra_payload):
         """
         xmlstr = etree.tostring(self.xml, pretty_print=True)
         payload = {
-            'xml': xmlstr,
-            'edX_cmd': cmd,
-            'edX_tests': self.tests,
-            'processor': self.code,
+            "xml": xmlstr,
+            "edX_cmd": cmd,
+            "edX_tests": self.tests,
+            "processor": self.code,
         }
         payload.update(extra_payload)
 
@@ -2933,22 +2905,21 @@ def do_external_request(self, cmd, extra_payload):
             # long time
             req = requests.post(self.url, data=payload)
         except Exception as err:
-            msg = 'Error {0} - cannot connect to external server url={1}'.format(err, self.url)
+            msg = "Error {0} - cannot connect to external server url={1}".format(err, self.url)
             log.error(msg)
             raise Exception(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
         if self.capa_system.DEBUG:
-            log.info('response = %s', req.text)
+            log.info("response = %s", req.text)
 
         if (not req.text) or (not req.text.strip()):
-            raise Exception(
-                'Error: no response from external server url=%s' % self.url)
+            raise Exception("Error: no response from external server url=%s" % self.url)
 
         try:
             # response is XML; parse it
             rxml = etree.fromstring(req.text)
         except Exception as err:
-            msg = 'Error {0} - cannot parse response from external server req.text={1}'.format(err, req.text)
+            msg = "Error {0} - cannot parse response from external server req.text={1}".format(err, req.text)
             log.error(msg)
             raise Exception(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
@@ -2961,42 +2932,36 @@ def get_score(self, student_answers):
             submission = [student_answers[k] for k in idset]
         except Exception as err:
             log.error(
-                'Error %s: cannot get student answer for %s; student_answers=%s',
-                err,
-                self.answer_ids,
-                student_answers
+                "Error %s: cannot get student answer for %s; student_answers=%s", err, self.answer_ids, student_answers
             )
             raise Exception(err)  # lint-amnesty, pylint: disable=raise-missing-from
 
-        self.context.update({'submission': submission})
+        self.context.update({"submission": submission})
 
-        extra_payload = {'edX_student_response': json.dumps(submission)}
+        extra_payload = {"edX_student_response": json.dumps(submission)}
 
         try:
-            rxml = self.do_external_request('get_score', extra_payload)
+            rxml = self.do_external_request("get_score", extra_payload)
         except Exception as err:  # pylint: disable=broad-except
-            log.error('Error %s', err)
+            log.error("Error %s", err)
             if self.capa_system.DEBUG:
-                cmap.set_dict(dict(list(zip(sorted(
-                    self.answer_ids), ['incorrect'] * len(idset)))))
+                cmap.set_dict(dict(list(zip(sorted(self.answer_ids), ["incorrect"] * len(idset)))))
                 cmap.set_property(
-                    self.answer_ids[0], 'msg',
-                    Text('<span class="inline-error">{}</span>').format(str(err))
+                    self.answer_ids[0], "msg", Text('<span class="inline-error">{}</span>').format(str(err))
                 )
                 return cmap
 
-        awd = rxml.find('awarddetail').text
+        awd = rxml.find("awarddetail").text
 
-        self.context['correct'] = ['correct']
+        self.context["correct"] = ["correct"]
         if awd in self.awdmap:
-            self.context['correct'][0] = self.awdmap[awd]
+            self.context["correct"][0] = self.awdmap[awd]
 
         # create CorrectMap
         for key in idset:
             idx = idset.index(key)
-            msg = rxml.find('message').text.replace(
-                '&nbsp;', '&#160;') if idx == 0 else None
-            cmap.set(key, self.context['correct'][idx], msg=msg)
+            msg = rxml.find("message").text.replace("&nbsp;", "&#160;") if idx == 0 else None
+            cmap.set(key, self.context["correct"][idx], msg=msg)
 
         return cmap
 
@@ -3005,23 +2970,23 @@ def get_answers(self):
         Use external server to get expected answers
         """
         try:
-            rxml = self.do_external_request('get_answers', {})
-            exans = json.loads(rxml.find('expected').text)
+            rxml = self.do_external_request("get_answers", {})
+            exans = json.loads(rxml.find("expected").text)
         except Exception as err:  # pylint: disable=broad-except
-            log.error('Error %s', err)
+            log.error("Error %s", err)
             if self.capa_system.DEBUG:
                 msg = HTML('<span class="inline-error">{}</span>').format(err)
-                exans = [''] * len(self.answer_ids)
+                exans = [""] * len(self.answer_ids)
                 exans[0] = msg
 
         if not len(exans) == len(self.answer_ids):
-            log.error('Expected %s answers from external server, only got %s!',
-                      len(self.answer_ids), len(exans))
-            raise Exception('Short response from external server')
+            log.error("Expected %s answers from external server, only got %s!", len(self.answer_ids), len(exans))
+            raise Exception("Short response from external server")
         return dict(list(zip(self.answer_ids, exans)))
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
 
 @registry.register
 class FormulaResponse(LoncapaResponse):
@@ -3029,17 +2994,17 @@ class FormulaResponse(LoncapaResponse):
     Checking of symbolic math response using numerical sampling.
     """
 
-    human_name = _('Math Expression Input')
-    tags = ['formularesponse']
-    hint_tag = 'formulahint'
-    allowed_inputfields = ['textline', 'formulaequationinput']
-    required_attributes = ['answer', 'samples']
+    human_name = _("Math Expression Input")
+    tags = ["formularesponse"]
+    hint_tag = "formulahint"
+    allowed_inputfields = ["textline", "formulaequationinput"]
+    required_attributes = ["answer", "samples"]
     max_inputfields = 1
     multi_device_support = True
 
     def __init__(self, *args, **kwargs):
-        self.correct_answer = ''
-        self.samples = ''
+        self.correct_answer = ""
+        self.samples = ""
         self.tolerance = default_tolerance
         self.case_sensitive = False
         super(FormulaResponse, self).__init__(*args, **kwargs)  # lint-amnesty, pylint: disable=super-with-arguments
@@ -3047,26 +3012,23 @@ def __init__(self, *args, **kwargs):
     def setup_response(self):
         xml = self.xml
         context = self.context
-        self.correct_answer = contextualize_text(xml.get('answer'), context)
-        self.samples = contextualize_text(xml.get('samples'), context)
+        self.correct_answer = contextualize_text(xml.get("answer"), context)
+        self.samples = contextualize_text(xml.get("samples"), context)
 
         # Find the tolerance
-        tolerance_xml = xml.xpath(
-            '//*[@id=$id]//responseparam[@type="tolerance"]/@default',
-            id=xml.get('id')
-        )
+        tolerance_xml = xml.xpath('//*[@id=$id]//responseparam[@type="tolerance"]/@default', id=xml.get("id"))
         if tolerance_xml:  # If it isn't an empty list...
             self.tolerance = contextualize_text(tolerance_xml[0].strip(), context)
 
-        types = xml.get('type')
+        types = xml.get("type")
         if types is None:
             typeslist = []
         else:
-            typeslist = types.split(',')
-        if 'ci' in typeslist:
+            typeslist = types.split(",")
+        if "ci" in typeslist:
             # Case insensitive
             self.case_sensitive = False
-        elif 'cs' in typeslist:
+        elif "cs" in typeslist:
             # Case sensitive
             self.case_sensitive = True
         else:
@@ -3075,11 +3037,7 @@ def setup_response(self):
 
     def get_score(self, student_answers):
         given = student_answers[self.answer_id]
-        correctness = self.check_formula(
-            self.correct_answer,
-            given,
-            self.samples
-        )
+        correctness = self.check_formula(self.correct_answer, given, self.samples)
         return CorrectMap(self.answer_id, correctness)
 
     def tupleize_answers(self, answer, var_dict_list):
@@ -3093,47 +3051,43 @@ def tupleize_answers(self, answer, var_dict_list):
         out = []
         for var_dict in var_dict_list:
             try:
-                out.append(evaluator(
-                    var_dict,
-                    {},
-                    answer,
-                    case_sensitive=self.case_sensitive,
-                ))
-            except UndefinedVariable as err:
-                log.debug(
-                    'formularesponse: undefined variable in formula=%s',
-                    html.escape(answer)
-                )
-                raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                    err.args[0]
+                out.append(
+                    evaluator(
+                        var_dict,
+                        {},
+                        answer,
+                        case_sensitive=self.case_sensitive,
+                    )
                 )
+            except UndefinedVariable as err:
+                log.debug("formularesponse: undefined variable in formula=%s", html.escape(answer))
+                raise StudentInputError(err.args[0])  # lint-amnesty, pylint: disable=raise-missing-from
             except UnmatchedParenthesis as err:
-                log.debug(
-                    'formularesponse: unmatched parenthesis in formula=%s',
-                    html.escape(answer)
-                )
-                raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                    err.args[0]
-                )
+                log.debug("formularesponse: unmatched parenthesis in formula=%s", html.escape(answer))
+                raise StudentInputError(err.args[0])  # lint-amnesty, pylint: disable=raise-missing-from
             except ValueError as err:
-                if 'factorial' in str(err):
+                if "factorial" in str(err):
                     # This is thrown when fact() or factorial() is used in a formularesponse answer
                     #   that tests on negative and/or non-integer inputs
                     # str(err) will be: `factorial() only accepts integral values` or
                     # `factorial() not defined for negative values`
                     log.debug(
-                        ('formularesponse: factorial function used in response '
-                         'that tests negative and/or non-integer inputs. '
-                         'Provided answer was: %s'),
-                        html.escape(answer)
+                        (
+                            "formularesponse: factorial function used in response "
+                            "that tests negative and/or non-integer inputs. "
+                            "Provided answer was: %s"
+                        ),
+                        html.escape(answer),
                     )
                     raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                        _("Factorial function not permitted in answer "
-                          "for this problem. Provided answer was: "
-                          "{bad_input}").format(bad_input=html.escape(answer))
+                        _(
+                            "Factorial function not permitted in answer "
+                            "for this problem. Provided answer was: "
+                            "{bad_input}"
+                        ).format(bad_input=html.escape(answer))
                     )
                 # If non-factorial related ValueError thrown, handle it the same as any other Exception
-                log.debug('formularesponse: error %s in formula', err)
+                log.debug("formularesponse: error %s in formula", err)
                 raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
                     _("Invalid input: Could not parse '{bad_input}' as a formula.").format(
                         bad_input=html.escape(answer)
@@ -3141,11 +3095,9 @@ def tupleize_answers(self, answer, var_dict_list):
                 )
             except Exception as err:
                 # traceback.print_exc()
-                log.debug('formularesponse: error %s in formula', err)
+                log.debug("formularesponse: error %s in formula", err)
                 raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
-                    _("Invalid input: Could not parse '{bad_input}' as a formula").format(
-                        bad_input=html.escape(answer)
-                    )
+                    _("Invalid input: Could not parse '{bad_input}' as a formula").format(bad_input=html.escape(answer))
                 )
         return out
 
@@ -3154,9 +3106,9 @@ def randomize_variables(self, samples):
         Returns a list of dictionaries mapping variables to random values in range,
         as expected by tupleize_answers.
         """
-        variables = samples.split('@')[0].split(',')
-        numsamples = int(samples.split('@')[1].split('#')[1])
-        sranges = list(zip(*[list(map(float, x.split(","))) for x in samples.split('@')[1].split('#')[0].split(':')]))
+        variables = samples.split("@")[0].split(",")
+        numsamples = int(samples.split("@")[1].split("#")[1])
+        sranges = list(zip(*[list(map(float, x.split(","))) for x in samples.split("@")[1].split("#")[0].split(":")]))
         ranges = dict(list(zip(variables, sranges)))
 
         out = []
@@ -3180,8 +3132,10 @@ def check_formula(self, expected, given, samples):
         student_result = self.tupleize_answers(given, var_dict_list)
         instructor_result = self.tupleize_answers(expected, var_dict_list)
 
-        correct = all(compare_with_tolerance(student, instructor, self.tolerance)
-                      for student, instructor in zip(student_result, instructor_result))
+        correct = all(
+            compare_with_tolerance(student, instructor, self.tolerance)
+            for student, instructor in zip(student_result, instructor_result)
+        )
         if correct:
             return "correct"
         else:
@@ -3211,38 +3165,37 @@ def strip_dict(self, inp_d):
         keys and all non-numeric values stripped out. All values also
         converted to float. Used so we can safely use Python contexts.
         """
-        inp_d = dict([(k, numpy.complex(inp_d[k]))  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
-                      for k in inp_d if isinstance(k, str) and
-                      k.isalnum() and
-                      isinstance(inp_d[k], numbers.Number)])
+        inp_d = dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+            [
+                (k, numpy.complex(inp_d[k]))
+                for k in inp_d
+                if isinstance(k, str) and k.isalnum() and isinstance(inp_d[k], numbers.Number)
+            ]
+        )
         return inp_d
 
     def check_hint_condition(self, hxml_set, student_answers):
         given = student_answers[self.answer_id]
         hints_to_show = []
         for hxml in hxml_set:
-            samples = hxml.get('samples')
-            name = hxml.get('name')
-            correct_answer = contextualize_text(
-                hxml.get('answer'), self.context)
+            samples = hxml.get("samples")
+            name = hxml.get("name")
+            correct_answer = contextualize_text(hxml.get("answer"), self.context)
             # pylint: disable=broad-except
             try:
-                correctness = self.check_formula(
-                    correct_answer,
-                    given,
-                    samples
-                )
+                correctness = self.check_formula(correct_answer, given, samples)
             except Exception:
-                correctness = 'incorrect'
-            if correctness == 'correct':
+                correctness = "incorrect"
+            if correctness == "correct":
                 hints_to_show.append(name)
-        log.debug('hints_to_show = %s', hints_to_show)
+        log.debug("hints_to_show = %s", hints_to_show)
         return hints_to_show
 
     def get_answers(self):
         return {self.answer_id: self.correct_answer}
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -3250,57 +3203,55 @@ class SchematicResponse(LoncapaResponse):
     """
     Circuit schematic response type.
     """
-    human_name = _('Circuit Schematic Builder')
-    tags = ['schematicresponse']
-    allowed_inputfields = ['schematic']
+
+    human_name = _("Circuit Schematic Builder")
+    tags = ["schematicresponse"]
+    allowed_inputfields = ["schematic"]
 
     def __init__(self, *args, **kwargs):
-        self.code = ''
+        self.code = ""
         super(SchematicResponse, self).__init__(*args, **kwargs)  # lint-amnesty, pylint: disable=super-with-arguments
 
     def setup_response(self):
         xml = self.xml
-        answer = xml.xpath('//*[@id=$id]//answer', id=xml.get('id'))[0]
-        answer_src = answer.get('src')
+        answer = xml.xpath("//*[@id=$id]//answer", id=xml.get("id"))[0]
+        answer_src = answer.get("src")
         if answer_src is not None:
             # Untested; never used
-            self.code = self.capa_system.resources_fs.open('src/' + answer_src).read()
+            self.code = self.capa_system.resources_fs.open("src/" + answer_src).read()
         else:
             self.code = answer.text
 
     def get_score(self, student_answers):
-        submission = [
-            json.loads(student_answers[k]) for k in sorted(self.answer_ids)
-        ]
-        self.context.update({'submission': submission})
+        submission = [json.loads(student_answers[k]) for k in sorted(self.answer_ids)]
+        self.context.update({"submission": submission})
         try:
             safe_exec.safe_exec(
                 self.code,
                 self.context,
                 cache=self.capa_system.cache,
-                python_path=self.context['python_path'],
-                extra_files=self.context['extra_files'],
-                limit_overrides_context=get_course_id_from_capa_block(
-                    self.capa_block
-                ),
+                python_path=self.context["python_path"],
+                extra_files=self.context["extra_files"],
+                limit_overrides_context=get_course_id_from_capa_block(self.capa_block),
                 slug=self.id,
-                random_seed=self.context['seed'],
+                random_seed=self.context["seed"],
                 unsafely=self.capa_system.can_execute_unsafe_code(),
             )
         except Exception as err:
             _ = self.capa_system.i18n.gettext
             # Translators: 'SchematicResponse' is a problem type and should not be translated.
-            msg = _('Error in evaluating SchematicResponse. The error was: {error_msg}').format(error_msg=err)
+            msg = _("Error in evaluating SchematicResponse. The error was: {error_msg}").format(error_msg=err)
             raise ResponseError(msg)  # lint-amnesty, pylint: disable=raise-missing-from
         cmap = CorrectMap()
-        cmap.set_dict(dict(list(zip(sorted(self.answer_ids), self.context['correct']))))
+        cmap.set_dict(dict(list(zip(sorted(self.answer_ids), self.context["correct"]))))
         return cmap
 
     def get_answers(self):
         # use answers provided in input elements
         return self.default_answer_map
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -3331,9 +3282,9 @@ class ImageResponse(LoncapaResponse):
         True, if click is inside any region or rectangle. Otherwise False.
     """
 
-    human_name = _('Image Mapped Input')
-    tags = ['imageresponse']
-    allowed_inputfields = ['imageinput']
+    human_name = _("Image Mapped Input")
+    tags = ["imageresponse"]
+    allowed_inputfields = ["imageinput"]
 
     def __init__(self, *args, **kwargs):
         self.ielements = []
@@ -3341,7 +3292,7 @@ def __init__(self, *args, **kwargs):
 
     def setup_response(self):
         self.ielements = self.inputfields
-        self.answer_ids = [ie.get('id') for ie in self.ielements]
+        self.answer_ids = [ie.get("id") for ie in self.ielements]
 
     def get_score(self, student_answers):
         _ = self.capa_system.i18n.gettext
@@ -3350,17 +3301,16 @@ def get_score(self, student_answers):
         for aid in self.answer_ids:  # loop through IDs of <imageinput>
             # Fields in our stanza
             given = student_answers[aid]  # This should be a string of the form '[x,y]'
-            correct_map.set(aid, 'incorrect')
+            correct_map.set(aid, "incorrect")
             if not given:  # No answer to parse. Mark as incorrect and move on
                 continue
             # Parse given answer
-            acoords = re.match(r'\[([0-9]+),([0-9]+)]', given.strip().replace(' ', ''))
+            acoords = re.match(r"\[([0-9]+),([0-9]+)]", given.strip().replace(" ", ""))
             if not acoords:
-                msg = _('error grading {image_input_id} (input={user_input})').format(
-                    image_input_id=aid,
-                    user_input=given
+                msg = _("error grading {image_input_id} (input={user_input})").format(
+                    image_input_id=aid, user_input=given
                 )
-                raise Exception('[capamodule.capa.responsetypes.imageinput] ' + msg)
+                raise Exception("[capamodule.capa.responsetypes.imageinput] " + msg)
 
             (ans_x, ans_y) = [int(x) for x in acoords.groups()]
 
@@ -3368,28 +3318,29 @@ def get_score(self, student_answers):
             if rectangles[aid]:  # Rectangles part - for backward compatibility
                 # Check whether given point lies in any of the solution
                 # rectangles
-                solution_rectangles = rectangles[aid].split(';')
+                solution_rectangles = rectangles[aid].split(";")
                 for solution_rectangle in solution_rectangles:
                     # parse expected answer
                     # TODO: Compile regexp on file load
                     sr_coords = re.match(
-                        r'[\(\[]([0-9]+),([0-9]+)[\)\]]-[\(\[]([0-9]+),([0-9]+)[\)\]]',
-                        solution_rectangle.strip().replace(' ', ''))
+                        r"[\(\[]([0-9]+),([0-9]+)[\)\]]-[\(\[]([0-9]+),([0-9]+)[\)\]]",
+                        solution_rectangle.strip().replace(" ", ""),
+                    )
                     if not sr_coords:
                         # Translators: {sr_coords} are the coordinates of a rectangle
-                        msg = _('Error in problem specification! Cannot parse rectangle in {sr_coords}').format(
+                        msg = _("Error in problem specification! Cannot parse rectangle in {sr_coords}").format(
                             sr_coords=etree.tostring(self.ielements[aid], pretty_print=True)
                         )
-                        raise Exception('[capamodule.capa.responsetypes.imageinput] ' + msg)
+                        raise Exception("[capamodule.capa.responsetypes.imageinput] " + msg)
 
                     (llx, lly, urx, ury) = [int(x) for x in sr_coords.groups()]
 
                     # answer is correct if (x,y) is within the specified
                     # rectangle
                     if (llx <= ans_x <= urx) and (lly <= ans_y <= ury):
-                        correct_map.set(aid, 'correct')
+                        correct_map.set(aid, "correct")
                         break
-            if correct_map[aid]['correctness'] != 'correct' and regions[aid]:
+            if correct_map[aid]["correctness"] != "correct" and regions[aid]:
                 parsed_region = json.loads(regions[aid])
                 if parsed_region:
                     if not isinstance(parsed_region[0][0], list):
@@ -3399,9 +3350,8 @@ def get_score(self, student_answers):
                         parsed_region = [parsed_region]
                     for region in parsed_region:
                         polygon = MultiPoint(region).convex_hull
-                        if (polygon.geom_type == 'Polygon' and
-                                polygon.contains(Point(ans_x, ans_y))):
-                            correct_map.set(aid, 'correct')
+                        if polygon.geom_type == "Polygon" and polygon.contains(Point(ans_x, ans_y)):
+                            correct_map.set(aid, "correct")
                             break
         return correct_map
 
@@ -3417,9 +3367,19 @@ def get_mapped_answers(self):
                 regions (dict) - a map of inputs to the defined region for that input
         """
         answers = (
-            dict([(ie.get('id'), ie.get(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
-                'rectangle')) for ie in self.ielements]),
-            dict([(ie.get('id'), ie.get('regions')) for ie in self.ielements]))  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+            dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+                [
+                    (
+                        ie.get("id"),
+                        ie.get("rectangle"),
+                    )
+                    for ie in self.ielements
+                ]
+            ),
+            dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+                [(ie.get("id"), ie.get("regions")) for ie in self.ielements]
+            ),
+        )
         return answers
 
     def get_answers(self):
@@ -3434,12 +3394,13 @@ def get_answers(self):
         """
         answers = {}
         for ielt in self.ielements:
-            ie_id = ielt.get('id')
-            answers[ie_id] = {'rectangle': ielt.get('rectangle'), 'regions': ielt.get('regions')}
+            ie_id = ielt.get("id")
+            answers[ie_id] = {"rectangle": ielt.get("rectangle"), "regions": ielt.get("regions")}
 
         return answers
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 
 @registry.register
@@ -3450,11 +3411,12 @@ class AnnotationResponse(LoncapaResponse):
     The response contains both a comment (student commentary) and an option (student tag).
     Only the tag is currently graded. Answers may be incorrect, partially correct, or correct.
     """
-    human_name = _('Annotation Input')
-    tags = ['annotationresponse']
-    allowed_inputfields = ['annotationinput']
+
+    human_name = _("Annotation Input")
+    tags = ["annotationresponse"]
+    allowed_inputfields = ["annotationinput"]
     max_inputfields = 1
-    default_scoring = {'incorrect': 0, 'partially-correct': 1, 'correct': 2}
+    default_scoring = {"incorrect": 0, "partially-correct": 1, "correct": 2}
 
     def __init__(self, *args, **kwargs):
         self.scoring_map = {}
@@ -3475,13 +3437,12 @@ def get_score(self, student_answers):
         student_option = self._get_submitted_option_id(student_answer)
 
         scoring = self.scoring_map[self.answer_id]
-        is_valid = student_option is not None and student_option in list(scoring.keys(
-        ))
+        is_valid = student_option is not None and student_option in list(scoring.keys())
 
-        (correctness, points) = ('incorrect', None)
+        (correctness, points) = ("incorrect", None)
         if is_valid:
-            correctness = scoring[student_option]['correctness']
-            points = scoring[student_option]['points']
+            correctness = scoring[student_option]["correctness"]
+            points = scoring[student_option]["points"]
 
         return CorrectMap(self.answer_id, correctness=correctness, npoints=points)
 
@@ -3491,19 +3452,23 @@ def get_answers(self):
     def _get_scoring_map(self):
         """Returns a dict of option->scoring for each input."""
         scoring = self.default_scoring
-        choices = dict([(choice, choice) for choice in scoring])  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+        choices = dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+            [(choice, choice) for choice in scoring]
+        )
         scoring_map = {}
 
         for inputfield in self.inputfields:
-            option_scoring = dict([(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
-                option['id'],
-                {
-                    'correctness': choices.get(option['choice']),
-                    'points': scoring.get(option['choice'])
-                }
-            ) for option in self._find_options(inputfield)])
+            option_scoring = dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+                [
+                    (
+                        option["id"],
+                        {"correctness": choices.get(option["choice"]), "points": scoring.get(option["choice"])},
+                    )
+                    for option in self._find_options(inputfield)
+                ]
+            )
 
-            scoring_map[inputfield.get('id')] = option_scoring
+            scoring_map[inputfield.get("id")] = option_scoring
 
         return scoring_map
 
@@ -3511,34 +3476,32 @@ def _get_answer_map(self):
         """Returns a dict of answers for each input."""
         answer_map = {}
         for inputfield in self.inputfields:
-            correct_option = self._find_option_with_choice(
-                inputfield, 'correct')
+            correct_option = self._find_option_with_choice(inputfield, "correct")
             if correct_option is not None:
-                input_id = inputfield.get('id')
-                answer_map[input_id] = correct_option.get('description')
+                input_id = inputfield.get("id")
+                answer_map[input_id] = correct_option.get("description")
         return answer_map
 
     def _get_max_points(self):
         """Returns a dict of the max points for each input: input id -> maxpoints."""
         scoring = self.default_scoring
-        correct_points = scoring.get('correct')
-        return dict([(inputfield.get('id'), correct_points) for inputfield in self.inputfields])  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+        correct_points = scoring.get("correct")
+        return dict(  # lint-amnesty, pylint: disable=consider-using-dict-comprehension
+            [(inputfield.get("id"), correct_points) for inputfield in self.inputfields]
+        )
 
     def _find_options(self, inputfield):
-        """Returns an array of dicts where each dict represents an option. """
-        elements = inputfield.findall('./options/option')
+        """Returns an array of dicts where each dict represents an option."""
+        elements = inputfield.findall("./options/option")
         return [
-            {
-                'id': index,
-                'description': option.text,
-                'choice': option.get('choice')
-            } for (index, option) in enumerate(elements)
+            {"id": index, "description": option.text, "choice": option.get("choice")}
+            for (index, option) in enumerate(elements)
         ]
 
     def _find_option_with_choice(self, inputfield, choice):
-        """Returns the option with the given choice value, otherwise None. """
+        """Returns the option with the given choice value, otherwise None."""
         for option in self._find_options(inputfield):
-            if option['choice'] == choice:
+            if option["choice"] == choice:
                 return option
 
     def _unpack(self, json_value):
@@ -3547,23 +3510,20 @@ def _unpack(self, json_value):
         if not isinstance(json_d, dict):
             json_d = {}
 
-        comment_value = json_d.get('comment', '')
+        comment_value = json_d.get("comment", "")
         if not isinstance(json_d, str):
-            comment_value = ''
+            comment_value = ""
 
-        options_value = json_d.get('options', [])
+        options_value = json_d.get("options", [])
         if not isinstance(options_value, list):
             options_value = []
 
-        return {
-            'options_value': options_value,
-            'comment_value': comment_value
-        }
+        return {"options_value": options_value, "comment_value": comment_value}
 
     def _get_submitted_option_id(self, student_answer):
         """Return the single option that was selected, otherwise None."""
         submitted = self._unpack(student_answer)
-        option_ids = submitted['options_value']
+        option_ids = submitted["options_value"]
         if len(option_ids) == 1:
             return option_ids[0]
         return None
@@ -3577,13 +3537,13 @@ class ChoiceTextResponse(LoncapaResponse):
     ChoiceResponse.
     """
 
-    human_name = _('Checkboxes With Text Input')
-    tags = ['choicetextresponse']
+    human_name = _("Checkboxes With Text Input")
+    tags = ["choicetextresponse"]
     max_inputfields = 1
     allowed_inputfields = [
-        'choicetextgroup',
-        'checkboxtextgroup',
-        'radiotextgroup',
+        "choicetextgroup",
+        "checkboxtextgroup",
+        "radiotextgroup",
     ]
 
     def __init__(self, *args, **kwargs):
@@ -3610,22 +3570,21 @@ def setup_response(self):
         context = self.context
         self.answer_values = {self.answer_id: []}
         self.assign_choice_names()
-        correct_xml = self.xml.xpath('//*[@id=$id]//choice[@correct="true"]',
-                                     id=self.xml.get('id'))
+        correct_xml = self.xml.xpath('//*[@id=$id]//choice[@correct="true"]', id=self.xml.get("id"))
 
         for node in correct_xml:
             # For each correct choice, set the `parent_name` to the
             # current choice's name
-            parent_name = node.get('name')
+            parent_name = node.get("name")
             # Add the name of the correct binary choice to the
             # correct choices list as a key. The value is not important.
-            self.correct_choices[parent_name] = {'answer': ''}
+            self.correct_choices[parent_name] = {"answer": ""}
             # Add the name of the parent to the list of correct answers
             self.answer_values[self.answer_id].append(parent_name)
             answer_list = []
             # Loop over <numtolerance_input> elements inside of the correct choices
             for child in node:
-                answer = child.get('answer', None)
+                answer = child.get("answer", None)
                 if not answer:
                     # If the question creator does not specify an answer for a
                     # <numtolerance_input> inside of a correct choice, raise an error
@@ -3634,22 +3593,16 @@ def setup_response(self):
                     )
                 # Contextualize the answer to allow script generated answers.
                 answer = contextualize_text(answer, context)
-                input_name = child.get('name')
+                input_name = child.get("name")
                 # Contextualize the tolerance to value.
-                tolerance = contextualize_text(
-                    child.get('tolerance', default_tolerance),
-                    context
-                )
+                tolerance = contextualize_text(child.get("tolerance", default_tolerance), context)
                 # Add the answer and tolerance information for the current
                 # numtolerance_input to `correct_inputs`
-                self.correct_inputs[input_name] = {
-                    'answer': answer,
-                    'tolerance': tolerance
-                }
+                self.correct_inputs[input_name] = {"answer": answer, "tolerance": tolerance}
                 # Add the correct answer for this input to the list for show
                 answer_list.append(answer)
             # Turn the list of numtolerance_input answers into a comma separated string.
-            self.answer_values[parent_name] = ', '.join(answer_list)
+            self.answer_values[parent_name] = ", ".join(answer_list)
         # Turn correct choices into a set. Allows faster grading.
         self.correct_choices = set(self.correct_choices.keys())
 
@@ -3689,21 +3642,18 @@ def assign_choice_names(self):
         </radiotextgroup>
         """
 
-        choices = self.xml.xpath('//*[@id=$id]//choice', id=self.xml.get('id'))
+        choices = self.xml.xpath("//*[@id=$id]//choice", id=self.xml.get("id"))
         for index, choice in enumerate(choices):
             # Set the name attribute for <choices>
             # "bc" is appended at the end to indicate that this is a
             # binary choice as opposed to a numtolerance_input, this convention
             # is used when grading the problem
-            choice.set(
-                "name",
-                self.answer_id + "_choiceinput_" + str(index) + "bc"
-            )
+            choice.set("name", self.answer_id + "_choiceinput_" + str(index) + "bc")
             # Set Name attributes for <numtolerance_input> elements
             # Look for all <numtolerance_inputs> inside this choice.
-            numtolerance_inputs = choice.findall('numtolerance_input')
+            numtolerance_inputs = choice.findall("numtolerance_input")
             # Look for all <decoy_input> inside this choice
-            decoys = choice.findall('decoy_input')
+            decoys = choice.findall("decoy_input")
             # <decoy_input> would only be used in choices which do not contain
             # <numtolerance_input>
             inputs = numtolerance_inputs if numtolerance_inputs else decoys
@@ -3711,11 +3661,7 @@ def assign_choice_names(self):
             # The ordinality of the choice, and the ordinality of the input
             # within that choice e.g. 1_2_1_choiceinput_0_numtolerance_input_1
             for ind, child in enumerate(inputs):
-                child.set(
-                    "name",
-                    self.answer_id + "_choiceinput_" + str(index) +
-                    "_numtolerance_input_" + str(ind)
-                )
+                child.set("name", self.answer_id + "_choiceinput_" + str(index) + "_numtolerance_input_" + str(ind))
 
     def get_score(self, student_answers):
         """
@@ -3740,10 +3686,7 @@ def get_score(self, student_answers):
         # and numtolerance_inputs are correct
         correct = choices_correct and inputs_correct
 
-        return CorrectMap(
-            self.answer_id,
-            'correct' if correct else 'incorrect'
-        )
+        return CorrectMap(self.answer_id, "correct" if correct else "incorrect")
 
     def get_answers(self):
         """
@@ -3815,8 +3758,7 @@ def _split_answers_dict(self, a_dict):
         # the numtolerance_input's parent binary_choice is contained in
         # `selected_choices`.
         selected_numtolerance_inputs = [
-            key for key in a_dict if key.partition("_numtolerance_input_")[0] + "bc"
-            in selected_choices
+            key for key in a_dict if key.partition("_numtolerance_input_")[0] + "bc" in selected_choices
         ]
 
         for key in selected_numtolerance_inputs:
@@ -3862,30 +3804,23 @@ def _check_student_inputs(self, numtolerance_inputs):
             # input's value, and validation of its numericality is the
             # only thing of interest from the later call to
             # `compare_with_tolerance`.
-            params = self.correct_inputs.get(answer_name, {'answer': 0})
+            params = self.correct_inputs.get(answer_name, {"answer": 0})
 
-            correct_ans = params['answer']
+            correct_ans = params["answer"]
             # Set the tolerance to '0' if it was not specified in the xml
-            tolerance = params.get('tolerance', default_tolerance)
+            tolerance = params.get("tolerance", default_tolerance)
             # Make sure that the staff answer is a valid number
             try:
                 correct_ans = complex(correct_ans)
             except ValueError:
-                log.debug(
-                    "Content error--answer '%s' is not a valid complex number",
-                    correct_ans
-                )
+                log.debug("Content error--answer '%s' is not a valid complex number", correct_ans)
                 raise StudentInputError(  # lint-amnesty, pylint: disable=raise-missing-from
                     _("The Staff answer could not be interpreted as a number.")
                 )
             # Compare the student answer to the staff answer/ or to 0
             # if all that is important is verifying numericality
             try:
-                partial_correct = compare_with_tolerance(
-                    evaluator({}, {}, answer_value),
-                    correct_ans,
-                    tolerance
-                )
+                partial_correct = compare_with_tolerance(evaluator({}, {}, answer_value), correct_ans, tolerance)
             except:
                 # Use the traceback-preserving version of re-raising with a
                 # different type
@@ -3903,7 +3838,8 @@ def _check_student_inputs(self, numtolerance_inputs):
                 inputs_correct = False
         return inputs_correct
 
-#-----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
 
 # TEMPORARY: List of all response subclasses
 # FIXME: To be replaced by auto-registration
diff --git a/xmodule/capa/safe_exec/lazymod.py b/xmodule/capa/safe_exec/lazymod.py
index 925d324b9a2f..61a63ae18e74 100644
--- a/xmodule/capa/safe_exec/lazymod.py
+++ b/xmodule/capa/safe_exec/lazymod.py
@@ -12,32 +12,34 @@ class LazyModule(object):
     """A lazy module proxy."""
 
     def __init__(self, modname):
-        self.__dict__['__name__'] = modname
+        self.__dict__["__name__"] = modname
         self._set_mod(None)
 
     def _set_mod(self, mod):
         if mod is not None:
             self.__dict__ = mod.__dict__
-        self.__dict__['_lazymod_mod'] = mod
+        self.__dict__["_lazymod_mod"] = mod
 
     def _load_mod(self):
         __import__(self.__name__)
         self._set_mod(sys.modules[self.__name__])
 
     def __getattr__(self, name):
-        if self.__dict__['_lazymod_mod'] is None:
+        if self.__dict__["_lazymod_mod"] is None:
             self._load_mod()
 
-        mod = self.__dict__['_lazymod_mod']
+        mod = self.__dict__["_lazymod_mod"]
 
         if hasattr(mod, name):
             return getattr(mod, name)
         else:
             try:
-                subname = '%s.%s' % (self.__name__, name)
+                subname = "%s.%s" % (self.__name__, name)
                 __import__(subname)
                 submod = getattr(mod, name)  # lint-amnesty, pylint: disable=unused-variable
             except ImportError:
-                raise AttributeError("'module' object has no attribute %r" % name)  # lint-amnesty, pylint: disable=raise-missing-from
+                raise AttributeError(  # lint-amnesty, pylint: disable=raise-missing-from
+                    "'module' object has no attribute %r" % name
+                )
             self.__dict__[name] = LazyModule(subname)
             return self.__dict__[name]
diff --git a/xmodule/capa/safe_exec/remote_exec.py b/xmodule/capa/safe_exec/remote_exec.py
index fb086b1064e8..3516bde0c690 100644
--- a/xmodule/capa/safe_exec/remote_exec.py
+++ b/xmodule/capa/safe_exec/remote_exec.py
@@ -5,15 +5,15 @@
 import json
 import logging
 from importlib import import_module
-import requests
 
+import requests
 from codejail.safe_exec import SafeExecException, json_safe
 from django.conf import settings
+from django.utils.translation import gettext as _
 from edx_toggles.toggles import SettingToggle
-from requests.exceptions import RequestException, HTTPError
+from requests.exceptions import HTTPError, RequestException
 from simplejson import JSONDecodeError
 
-from django.utils.translation import gettext as _
 from .exceptions import CodejailServiceParseError, CodejailServiceStatusError, CodejailServiceUnavailable
 
 log = logging.getLogger(__name__)
@@ -25,9 +25,7 @@
 #   a separate VM or container and communicate with edx-platform using REST API.
 # .. toggle_use_cases: open_edx
 # .. toggle_creation_date: 2021-08-19
-ENABLE_CODEJAIL_REST_SERVICE = SettingToggle(
-    "ENABLE_CODEJAIL_REST_SERVICE", default=False, module_name=__name__
-)
+ENABLE_CODEJAIL_REST_SERVICE = SettingToggle("ENABLE_CODEJAIL_REST_SERVICE", default=False, module_name=__name__)
 
 # .. toggle_name: ENABLE_CODEJAIL_DARKLAUNCH
 # .. toggle_implementation: SettingToggle
@@ -40,9 +38,7 @@
 # .. toggle_use_cases: temporary
 # .. toggle_creation_date: 2025-04-03
 # .. toggle_target_removal_date: 2025-05-01
-ENABLE_CODEJAIL_DARKLAUNCH = SettingToggle(
-    "ENABLE_CODEJAIL_DARKLAUNCH", default=False, module_name=__name__
-)
+ENABLE_CODEJAIL_DARKLAUNCH = SettingToggle("ENABLE_CODEJAIL_DARKLAUNCH", default=False, module_name=__name__)
 
 
 def is_codejail_rest_service_enabled():
@@ -62,7 +58,7 @@ def get_remote_exec(*args, **kwargs):
     """Get remote exec function based on setting and executes it."""
     remote_exec_function_name = settings.CODE_JAIL_REST_SERVICE_REMOTE_EXEC
     try:
-        mod_name, func_name = remote_exec_function_name.rsplit('.', 1)
+        mod_name, func_name = remote_exec_function_name.rsplit(".", 1)
         remote_exec_module = import_module(mod_name)
         remote_exec_function = getattr(remote_exec_module, func_name)
         if not remote_exec_function:
@@ -102,7 +98,7 @@ def send_safe_exec_request_v0(data):
     # bytes converted to strings) but it is the same lossy operation that
     # codejail will perform anyhow -- and it should be idempotent.
     data_send = {**data}
-    data_send['globals_dict'] = json_safe(data_send['globals_dict'])
+    data_send["globals_dict"] = json_safe(data_send["globals_dict"])
 
     payload = json.dumps(data_send)
 
@@ -110,17 +106,17 @@ def send_safe_exec_request_v0(data):
         response = requests.post(
             codejail_service_endpoint,
             files=extra_files,
-            data={'payload': payload},
-            timeout=(settings.CODE_JAIL_REST_SERVICE_CONNECT_TIMEOUT, settings.CODE_JAIL_REST_SERVICE_READ_TIMEOUT)
+            data={"payload": payload},
+            timeout=(settings.CODE_JAIL_REST_SERVICE_CONNECT_TIMEOUT, settings.CODE_JAIL_REST_SERVICE_READ_TIMEOUT),
         )
 
     except RequestException as err:
-        log.error("Failed to connect to codejail api service: url=%s, params=%s",
-                  codejail_service_endpoint, str(payload))
-        raise CodejailServiceUnavailable(_(
-            "Codejail API Service is unavailable. "
-            "Please try again in a few minutes."
-        )) from err
+        log.error(
+            "Failed to connect to codejail api service: url=%s, params=%s", codejail_service_endpoint, str(payload)
+        )
+        raise CodejailServiceUnavailable(
+            _("Codejail API Service is unavailable. Please try again in a few minutes.")
+        ) from err
 
     try:
         response.raise_for_status()
diff --git a/xmodule/capa/safe_exec/safe_exec.py b/xmodule/capa/safe_exec/safe_exec.py
index cd7b55357901..53ae94081357 100644
--- a/xmodule/capa/safe_exec/safe_exec.py
+++ b/xmodule/capa/safe_exec/safe_exec.py
@@ -1,4 +1,5 @@
 """Capa's specialized use of codejail.safe_exec."""
+
 import copy
 import hashlib
 import logging
@@ -105,7 +106,7 @@ def update_hash(hasher, obj):
         hasher.update(repr(obj).encode())
 
 
-@function_trace('safe_exec')
+@function_trace("safe_exec")
 def safe_exec(
     code,
     globals_dict,
@@ -152,7 +153,7 @@ def safe_exec(
     if cache:
         safe_globals = json_safe(globals_dict)
         md5er = hashlib.md5()
-        md5er.update(repr(code).encode('utf-8'))
+        md5er.update(repr(code).encode("utf-8"))
         update_hash(md5er, safe_globals)
         key = "safe_exec.%r.%s" % (random_seed, md5er.hexdigest())
         cached = cache.get(key)
@@ -181,7 +182,7 @@ def safe_exec(
             "extra_files": extra_files,
         }
 
-        with function_trace('safe_exec.remote_exec'):
+        with function_trace("safe_exec.remote_exec"):
             emsg, exception = get_remote_exec(data)
 
     else:
@@ -199,7 +200,7 @@ def safe_exec(
 
         # Run the code!  Results are side effects in globals_dict.
         try:
-            trace_name = 'safe_exec.local_exec_darklaunch' if is_codejail_in_darklaunch() else 'safe_exec.local_exec'
+            trace_name = "safe_exec.local_exec_darklaunch" if is_codejail_in_darklaunch() else "safe_exec.local_exec"
             with function_trace(trace_name):
                 exec_fn(
                     code_prolog + LAZY_IMPORTS + code,
@@ -235,17 +236,17 @@ def safe_exec(
             # .. custom_attribute_name: codejail.slug
             # .. custom_attribute_description: Value of the slug parameter. This
             #   might be a problem ID, if present.
-            set_custom_attribute('codejail.slug', slug)
+            set_custom_attribute("codejail.slug", slug)
             # .. custom_attribute_name: codejail.limit_overrides_context
             # .. custom_attribute_description: Value of the limit_overrides_context
             #   parameter to this code execution. Generally this will be the
             #   course name, if present at all.
-            set_custom_attribute('codejail.limit_overrides_context', limit_overrides_context)
+            set_custom_attribute("codejail.limit_overrides_context", limit_overrides_context)
             # .. custom_attribute_name: codejail.extra_files_count
             # .. custom_attribute_description: Number of extra_files included
             #   in request. This should be 0 or 1, the latter indicating a
             #   python_lib.zip was present.
-            set_custom_attribute('codejail.extra_files_count', len(extra_files) if extra_files else 0)
+            set_custom_attribute("codejail.extra_files_count", len(extra_files) if extra_files else 0)
 
             try:
                 data = {
@@ -257,7 +258,7 @@ def safe_exec(
                     "unsafely": unsafely,
                     "extra_files": extra_files,
                 }
-                with function_trace('safe_exec.remote_exec_darklaunch'):
+                with function_trace("safe_exec.remote_exec_darklaunch"):
                     # Ignore the returned exception, because it's just a
                     # SafeExecException wrapped around emsg (if present).
                     remote_emsg, _ = get_remote_exec(data)
@@ -272,9 +273,14 @@ def safe_exec(
                 local_exc_unexpected = None if isinstance(exception, SafeExecException) else exception
 
                 report_darklaunch_results(
-                    limit_overrides_context=limit_overrides_context, slug=slug,
-                    globals_local=globals_dict, emsg_local=emsg, unexpected_exc_local=local_exc_unexpected,
-                    globals_remote=darklaunch_globals, emsg_remote=remote_emsg, unexpected_exc_remote=remote_exception,
+                    limit_overrides_context=limit_overrides_context,
+                    slug=slug,
+                    globals_local=globals_dict,
+                    emsg_local=emsg,
+                    unexpected_exc_local=local_exc_unexpected,
+                    globals_remote=darklaunch_globals,
+                    emsg_remote=remote_emsg,
+                    unexpected_exc_remote=remote_exception,
                 )
             except BaseException as e:  # pragma: no cover  # pylint: disable=broad-except
                 log.exception("Error occurred while trying to report codejail darklaunch data.")
@@ -299,13 +305,13 @@ def _compile_normalizers(normalizer_setting):
     """
     compiled = []
     for pair in normalizer_setting:
-        search = re.compile(assert_type(pair['search'], str))
-        replace = assert_type(pair['replace'], str)
+        search = re.compile(assert_type(pair["search"], str))
+        replace = assert_type(pair["replace"], str)
 
         # Test the replacement string (might contain errors)
         re.sub(search, replace, "example")
 
-        compiled.append({'search': search, 'replace': replace})
+        compiled.append({"search": search, "replace": replace})
     return compiled
 
 
@@ -320,37 +326,35 @@ def emsg_normalizers():
     default_setting = [
         {
             # Character range should be at least as broad as what Python's `tempfile` uses.
-            'search': r'/tmp/codejail-[0-9a-zA-Z_]+',
-            'replace': r'/tmp/codejail-<SANDBOX_DIR_NAME>',
+            "search": r"/tmp/codejail-[0-9a-zA-Z_]+",
+            "replace": r"/tmp/codejail-<SANDBOX_DIR_NAME>",
         },
-
         # These are useful for eliding differences in environments due to Python version:
-
         {
             # Python 3.8 doesn't include the dir here, but Python 3.12
             # does. Normalize to the 3.8 version.
-            'search': r'File "/tmp/codejail-<SANDBOX_DIR_NAME>/jailed_code"',
-            'replace': r'File "jailed_code"'
+            "search": r'File "/tmp/codejail-<SANDBOX_DIR_NAME>/jailed_code"',
+            "replace": r'File "jailed_code"',
         },
         {
             # Python version shows up in stack traces in the virtualenv paths
-            'search': r'python3\.[0-9]+',
-            'replace': r'python3.XX'
+            "search": r"python3\.[0-9]+",
+            "replace": r"python3.XX",
         },
         {
             # Line numbers in stack traces differ between Python versions
-            'search': r', line [0-9]+, in ',
-            'replace': r', line XXX, in '
+            "search": r", line [0-9]+, in ",
+            "replace": r", line XXX, in ",
         },
         {
             # Some time after 3.8, Python started adding '^^^' indicators to stack traces
-            'search': r'\\n\s*\^+\s*\\n',
-            'replace': r'\\n'
+            "search": r"\\n\s*\^+\s*\\n",
+            "replace": r"\\n",
         },
         {
             # Python3.8 had these <listcomp> stack trace elements but 3.12 does not
-            'search': r'\\n  File "[^"]+", line [0-9]+, in <listcomp>\\n',
-            'replace': r'\\n'
+            "search": r'\\n  File "[^"]+", line [0-9]+, in <listcomp>\\n',
+            "replace": r"\\n",
         },
     ]
     default_normalizers = _compile_normalizers(default_setting)
@@ -369,7 +373,7 @@ def emsg_normalizers():
     #   or to differences due to Python version. See setting
     #   ``CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS_COMBINE`` for information on how
     #   this setting interacts with the defaults.
-    custom_setting = getattr(settings, 'CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS', [])
+    custom_setting = getattr(settings, "CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS", [])
     try:
         custom_normalizers = _compile_normalizers(custom_setting)
     except BaseException as e:
@@ -383,8 +387,8 @@ def emsg_normalizers():
     #   with the defaults. If the value is 'replace', the defaults will be replaced
     #   with the specified patterns. If the value is 'append' (the default), the
     #   specified replacements will be run after the defaults.
-    combine = getattr(settings, 'CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS_COMBINE', 'append')
-    if combine == 'replace':
+    combine = getattr(settings, "CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS_COMBINE", "append")
+    if combine == "replace":
         return custom_normalizers
     else:  # 'append', or unknown
         return default_normalizers + custom_normalizers
@@ -398,15 +402,21 @@ def normalize_error_message(emsg):
         return None
 
     for replacer in emsg_normalizers():
-        emsg = re.sub(replacer['search'], replacer['replace'], emsg, count=0)
+        emsg = re.sub(replacer["search"], replacer["replace"], emsg, count=0)
 
     return emsg
 
 
 def report_darklaunch_results(
-        *, limit_overrides_context, slug,
-        globals_local, emsg_local, unexpected_exc_local,
-        globals_remote, emsg_remote, unexpected_exc_remote,
+    *,
+    limit_overrides_context,
+    slug,
+    globals_local,
+    emsg_local,
+    unexpected_exc_local,
+    globals_remote,
+    emsg_remote,
+    unexpected_exc_remote,
 ):
     """Send telemetry for results of darklaunch."""
     can_compare_output = True
@@ -424,25 +434,25 @@ def report_arm(arm, emsg, unexpected_exception):
             #   darklaunch comparison. Values can be 'ok' (normal execution),
             #   'safe_error' (submitted code raised an exception), or
             #   'unexpected_error' (uncaught error in submitting or evaluating code).
-            set_custom_attribute(f'codejail.darklaunch.status.{arm}', 'unexpected_error')
+            set_custom_attribute(f"codejail.darklaunch.status.{arm}", "unexpected_error")
             # .. custom_attribute_name: codejail.darklaunch.exception.{local,remote}
             # .. custom_attribute_description: When the status attribute indicates
             #   an unexpected error, this is a string representation of the error,
             #   otherwise None.
-            set_custom_attribute(f'codejail.darklaunch.exception.{arm}', repr(unexpected_exception))
+            set_custom_attribute(f"codejail.darklaunch.exception.{arm}", repr(unexpected_exception))
             can_compare_output = False
         else:
-            set_custom_attribute(f'codejail.darklaunch.status.{arm}', 'ok' if emsg is None else 'safe_error')
-            set_custom_attribute(f'codejail.darklaunch.exception.{arm}', None)
+            set_custom_attribute(f"codejail.darklaunch.status.{arm}", "ok" if emsg is None else "safe_error")
+            set_custom_attribute(f"codejail.darklaunch.exception.{arm}", None)
 
-    report_arm('local', emsg_local, unexpected_exc_local)
-    report_arm('remote', emsg_remote, unexpected_exc_remote)
+    report_arm("local", emsg_local, unexpected_exc_local)
+    report_arm("remote", emsg_remote, unexpected_exc_remote)
 
     # If the arms can't be compared (unexpected errors), stop early -- the rest
     # is about output comparison.
     if not can_compare_output:
-        set_custom_attribute('codejail.darklaunch.globals_match', 'N/A')
-        set_custom_attribute('codejail.darklaunch.emsg_match', 'N/A')
+        set_custom_attribute("codejail.darklaunch.globals_match", "N/A")
+        set_custom_attribute("codejail.darklaunch.emsg_match", "N/A")
         log.info(
             "Codejail darklaunch had unexpected exception for "
             f"course={limit_overrides_context!r}, slug={slug!r}:\n"
@@ -466,14 +476,14 @@ def report_arm(arm, emsg, unexpected_exception):
     # .. custom_attribute_description: True if local and remote globals_dict
     #   values match, False otherwise. 'N/A' when either arm raised an
     #   uncaught error.
-    set_custom_attribute('codejail.darklaunch.globals_match', globals_match)
+    set_custom_attribute("codejail.darklaunch.globals_match", globals_match)
     # .. custom_attribute_name: codejail.darklaunch.emsg_match
     # .. custom_attribute_description: True if the local and remote emsg values
     #   (errors returned from sandbox) match, False otherwise. Differences due
     #   to known irrelevant factors are suppressed in this comparison, such as
     #   the randomized directory names used for sandboxes. 'N/A' when either
     #   arm raised an uncaught error.
-    set_custom_attribute('codejail.darklaunch.emsg_match', emsg_match)
+    set_custom_attribute("codejail.darklaunch.emsg_match", emsg_match)
 
 
 @receiver(setting_changed)
diff --git a/xmodule/capa/safe_exec/tests/test_lazymod.py b/xmodule/capa/safe_exec/tests/test_lazymod.py
index 548422d7c89e..4a7227ed5195 100644
--- a/xmodule/capa/safe_exec/tests/test_lazymod.py
+++ b/xmodule/capa/safe_exec/tests/test_lazymod.py
@@ -1,6 +1,5 @@
 """Test lazymod.py"""
 
-
 import sys
 import unittest
 
@@ -14,6 +13,7 @@ class ModuleIsolation(object):
     Create this object, it will snapshot the currently imported modules. When
     you call `clean_up()`, it will delete any module imported since its creation.
     """
+
     def __init__(self):
         # Save all the names of all the imported modules.
         self.mods = set(sys.modules)
@@ -35,23 +35,23 @@ def setUp(self):
 
     def test_simple(self):
         # Import some stdlib module that has not been imported before
-        module_name = 'colorsys'
+        module_name = "colorsys"
         if module_name in sys.modules:
             # May have been imported during test discovery, remove it again
             del sys.modules[module_name]
         assert module_name not in sys.modules
         colorsys = LazyModule(module_name)
-        hsv = colorsys.rgb_to_hsv(.3, .4, .2)
+        hsv = colorsys.rgb_to_hsv(0.3, 0.4, 0.2)
         assert hsv[0] == 0.25
 
     def test_dotted(self):
         # wsgiref is a module with submodules that is not already imported.
         # Any similar module would do. This test demonstrates that the module
         # is not already imported
-        module_name = 'wsgiref.util'
+        module_name = "wsgiref.util"
         if module_name in sys.modules:
             # May have been imported during test discovery, remove it again
             del sys.modules[module_name]
         assert module_name not in sys.modules
         wsgiref_util = LazyModule(module_name)
-        assert wsgiref_util.guess_scheme({}) == 'http'
+        assert wsgiref_util.guess_scheme({}) == "http"
diff --git a/xmodule/capa/safe_exec/tests/test_remote_exec.py b/xmodule/capa/safe_exec/tests/test_remote_exec.py
index ee1ee493835f..992f2f502fb7 100644
--- a/xmodule/capa/safe_exec/tests/test_remote_exec.py
+++ b/xmodule/capa/safe_exec/tests/test_remote_exec.py
@@ -16,17 +16,19 @@ class TestRemoteExec(TestCase):
 
     @override_settings(
         ENABLE_CODEJAIL_REST_SERVICE=True,
-        CODE_JAIL_REST_SERVICE_HOST='http://localhost',
+        CODE_JAIL_REST_SERVICE_HOST="http://localhost",
     )
-    @patch('requests.post')
+    @patch("requests.post")
     def test_json_encode(self, mock_post):
-        get_remote_exec({
-            'code': "out = 1 + 1",
-            'globals_dict': {'some_data': b'bytes', 'unusable': object()},
-            'extra_files': None,
-        })
+        get_remote_exec(
+            {
+                "code": "out = 1 + 1",
+                "globals_dict": {"some_data": b"bytes", "unusable": object()},
+                "extra_files": None,
+            }
+        )
 
         mock_post.assert_called_once()
-        data_arg = mock_post.call_args_list[0][1]['data']
-        payload = json.loads(data_arg['payload'])
-        assert payload['globals_dict'] == {'some_data': 'bytes'}
+        data_arg = mock_post.call_args_list[0][1]["data"]
+        payload = json.loads(data_arg["payload"])
+        assert payload["globals_dict"] == {"some_data": "bytes"}
diff --git a/xmodule/capa/safe_exec/tests/test_safe_exec.py b/xmodule/capa/safe_exec/tests/test_safe_exec.py
index d7679b66aa5e..f1ec3cb62a3a 100644
--- a/xmodule/capa/safe_exec/tests/test_safe_exec.py
+++ b/xmodule/capa/safe_exec/tests/test_safe_exec.py
@@ -1,6 +1,5 @@
 """Test safe_exec.py"""
 
-
 import copy
 import hashlib
 import os
@@ -32,19 +31,19 @@ class TestSafeExec(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-
     def test_set_values(self):
         g = {}
         safe_exec("a = 17", g)
-        assert g['a'] == 17
+        assert g["a"] == 17
 
     def test_division(self):
         g = {}
         # Future division: 1/2 is 0.5.
         safe_exec("a = 1/2", g)
-        assert g['a'] == 0.5
+        assert g["a"] == 0.5
 
     def test_assumed_imports(self):
         g = {}
         # Math is always available.
         safe_exec("a = int(math.pi)", g)
-        assert g['a'] == 3
+        assert g["a"] == 3
 
     def test_random_seeding(self):
         g = {}
@@ -53,11 +52,11 @@ def test_random_seeding(self):
 
         # Without a seed, the results are unpredictable
         safe_exec("rnums = [random.randint(0, 999) for _ in xrange(100)]", g)
-        assert g['rnums'] != rnums
+        assert g["rnums"] != rnums
 
         # With a seed, the results are predictable
         safe_exec("rnums = [random.randint(0, 999) for _ in xrange(100)]", g, random_seed=17)
-        assert g['rnums'] == rnums
+        assert g["rnums"] == rnums
 
     def test_random_is_still_importable(self):
         g = {}
@@ -65,32 +64,26 @@ def test_random_is_still_importable(self):
         rnums = [r.randint(0, 999) for _ in range(100)]
 
         # With a seed, the results are predictable even from the random module
-        safe_exec(
-            "import random\n"
-            "rnums = [random.randint(0, 999) for _ in xrange(100)]\n",
-            g, random_seed=17)
-        assert g['rnums'] == rnums
+        safe_exec("import random\nrnums = [random.randint(0, 999) for _ in xrange(100)]\n", g, random_seed=17)
+        assert g["rnums"] == rnums
 
     def test_python_lib(self):
         pylib = os.path.dirname(__file__) + "/test_files/pylib"
         g = {}
-        safe_exec(
-            "import constant; a = constant.THE_CONST",
-            g, python_path=[pylib]
-        )
+        safe_exec("import constant; a = constant.THE_CONST", g, python_path=[pylib])
 
     def test_raising_exceptions(self):
         g = {}
         with pytest.raises(SafeExecException) as cm:
             safe_exec("1/0", g)
-        assert 'ZeroDivisionError' in str(cm.value)
+        assert "ZeroDivisionError" in str(cm.value)
 
 
 class TestSafeOrNot(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
 
     @skip_unless_lms
     def test_cant_do_something_forbidden(self):
-        '''
+        """
         Demonstrates that running unsafe code inside the code jail
         throws SafeExecException, protecting the calling process.
 
@@ -103,7 +96,7 @@ def test_cant_do_something_forbidden(self):
         Note on @skip_unless_lms:
         This test can also be run in a CMS context, but that's giving us trouble in CI right now (the skip logic isn't
         working). So, if you're running this locally, feel free to remove @skip_unless_lms and run it against CMS too.
-        '''
+        """
         # If in-platform codejail isn't configured...
         if not jail_code.is_configured("python"):
 
@@ -115,18 +108,18 @@ def test_cant_do_something_forbidden(self):
 
         g = {}
         with pytest.raises(SafeExecException) as cm:
-            safe_exec('import sys; sys.exit(1)', g)
+            safe_exec("import sys; sys.exit(1)", g)
         assert "SystemExit" not in str(cm)
         assert "Couldn't execute jailed code" in str(cm)
 
     def test_can_do_something_forbidden_if_run_unsafely(self):
-        '''
+        """
         Demonstrates that running unsafe code outside the code jail
         can cause issues directly in the calling process.
-        '''
+        """
         g = {}
         with pytest.raises(SystemExit) as cm:
-            safe_exec('import sys; sys.exit(1)', g, unsafely=True)
+            safe_exec("import sys; sys.exit(1)", g, unsafely=True)
         assert "SystemExit" in str(cm)
 
 
@@ -134,45 +127,51 @@ class TestCodeJailDarkLaunch(unittest.TestCase):
     """
     Test that the behavior of the dark launched code behaves as expected.
     """
-    @patch('xmodule.capa.safe_exec.safe_exec.get_remote_exec')
-    @patch('xmodule.capa.safe_exec.safe_exec.codejail_safe_exec')
+
+    @patch("xmodule.capa.safe_exec.safe_exec.get_remote_exec")
+    @patch("xmodule.capa.safe_exec.safe_exec.codejail_safe_exec")
     def test_default_code_execution(self, mock_local_exec, mock_remote_exec):
 
         # Test default only runs local exec.
         g = {}
-        safe_exec('a=1', g)
+        safe_exec("a=1", g)
         assert mock_local_exec.called
         assert not mock_remote_exec.called
 
     @override_settings(ENABLE_CODEJAIL_REST_SERVICE=True)
-    @patch('xmodule.capa.safe_exec.safe_exec.get_remote_exec')
-    @patch('xmodule.capa.safe_exec.safe_exec.codejail_safe_exec')
+    @patch("xmodule.capa.safe_exec.safe_exec.get_remote_exec")
+    @patch("xmodule.capa.safe_exec.safe_exec.codejail_safe_exec")
     def test_code_execution_only_codejail_service(self, mock_local_exec, mock_remote_exec):
         # Set return values to empty values to indicate no error.
         mock_remote_exec.return_value = (None, None)
         # Test with only the service enabled.
         g = {}
-        safe_exec('a=1', g)
+        safe_exec("a=1", g)
         assert not mock_local_exec.called
         assert mock_remote_exec.called
 
     @override_settings(ENABLE_CODEJAIL_DARKLAUNCH=True)
-    @patch('xmodule.capa.safe_exec.safe_exec.get_remote_exec')
-    @patch('xmodule.capa.safe_exec.safe_exec.codejail_safe_exec')
+    @patch("xmodule.capa.safe_exec.safe_exec.get_remote_exec")
+    @patch("xmodule.capa.safe_exec.safe_exec.codejail_safe_exec")
     def test_code_execution_darklaunch_misconfig(self, mock_local_exec, mock_remote_exec):
         """Test that darklaunch doesn't run when remote service is generally enabled."""
         mock_remote_exec.return_value = (None, None)
 
         with override_settings(ENABLE_CODEJAIL_REST_SERVICE=True):
-            safe_exec('a=1', {})
+            safe_exec("a=1", {})
 
         assert not mock_local_exec.called
         assert mock_remote_exec.called
 
     @override_settings(ENABLE_CODEJAIL_DARKLAUNCH=True)
     def run_dark_launch(
-            self, globals_dict, local, remote,
-            expect_attr_calls, expect_log_info_calls, expect_globals_contains,
+        self,
+        globals_dict,
+        local,
+        remote,
+        expect_attr_calls,
+        expect_log_info_calls,
+        expect_globals_contains,
     ):
         """
         Run a darklaunch scenario with mocked out local and remote execution.
@@ -188,18 +187,20 @@ def run_dark_launch(
         assert is_codejail_in_darklaunch()
 
         with (
-                patch('xmodule.capa.safe_exec.safe_exec.codejail_safe_exec') as mock_local_exec,
-                patch('xmodule.capa.safe_exec.safe_exec.get_remote_exec') as mock_remote_exec,
-                patch('xmodule.capa.safe_exec.safe_exec.set_custom_attribute') as mock_set_custom_attribute,
-                patch('xmodule.capa.safe_exec.safe_exec.log.info') as mock_log_info,
+            patch("xmodule.capa.safe_exec.safe_exec.codejail_safe_exec") as mock_local_exec,
+            patch("xmodule.capa.safe_exec.safe_exec.get_remote_exec") as mock_remote_exec,
+            patch("xmodule.capa.safe_exec.safe_exec.set_custom_attribute") as mock_set_custom_attribute,
+            patch("xmodule.capa.safe_exec.safe_exec.log.info") as mock_log_info,
         ):
             mock_local_exec.side_effect = local
             mock_remote_exec.side_effect = remote
 
             try:
                 safe_exec(
-                    "<IGNORED BY MOCKS>", globals_dict,
-                    limit_overrides_context="course-v1:org+course+run", slug="hw1",
+                    "<IGNORED BY MOCKS>",
+                    globals_dict,
+                    limit_overrides_context="course-v1:org+course+run",
+                    slug="hw1",
                 )
             except BaseException as e:
                 safe_exec_e = e
@@ -213,22 +214,22 @@ def run_dark_launch(
         mock_set_custom_attribute.assert_has_calls(expect_attr_calls, any_order=True)
         mock_log_info.assert_has_calls(expect_log_info_calls, any_order=True)
 
-        for (k, v) in expect_globals_contains.items():
+        for k, v in expect_globals_contains.items():
             assert globals_dict[k] == v
 
-        return {'raised': safe_exec_e}
+        return {"raised": safe_exec_e}
 
     # These don't change between the tests
     standard_codejail_attr_calls = [
-        call('codejail.slug', 'hw1'),
-        call('codejail.limit_overrides_context', 'course-v1:org+course+run'),
-        call('codejail.extra_files_count', 0),
+        call("codejail.slug", "hw1"),
+        call("codejail.limit_overrides_context", "course-v1:org+course+run"),
+        call("codejail.extra_files_count", 0),
     ]
 
     def test_separate_globals(self):
         """Test that local and remote globals are isolated from each other's side effects."""
         # Both will attempt to read and write the 'overwrite' key.
-        globals_dict = {'overwrite': 'original'}
+        globals_dict = {"overwrite": "original"}
 
         local_globals = None
         remote_globals = None
@@ -238,26 +239,28 @@ def local_exec(code, globals_dict, **kwargs):
             nonlocal local_globals
             local_globals = copy.deepcopy(globals_dict)
 
-            globals_dict['overwrite'] = 'mock local'
+            globals_dict["overwrite"] = "mock local"
 
         def remote_exec(data):
             # Preserve what remote exec saw
             nonlocal remote_globals
-            remote_globals = copy.deepcopy(data['globals_dict'])
+            remote_globals = copy.deepcopy(data["globals_dict"])
 
-            data['globals_dict']['overwrite'] = 'mock remote'
+            data["globals_dict"]["overwrite"] = "mock remote"
             return (None, None)
 
         results = self.run_dark_launch(
-            globals_dict=globals_dict, local=local_exec, remote=remote_exec,
+            globals_dict=globals_dict,
+            local=local_exec,
+            remote=remote_exec,
             expect_attr_calls=[
                 *self.standard_codejail_attr_calls,
-                call('codejail.darklaunch.status.local', 'ok'),
-                call('codejail.darklaunch.status.remote', 'ok'),
-                call('codejail.darklaunch.exception.local', None),
-                call('codejail.darklaunch.exception.remote', None),
-                call('codejail.darklaunch.globals_match', False),  # mismatch revealed here
-                call('codejail.darklaunch.emsg_match', True),
+                call("codejail.darklaunch.status.local", "ok"),
+                call("codejail.darklaunch.status.remote", "ok"),
+                call("codejail.darklaunch.exception.local", None),
+                call("codejail.darklaunch.exception.remote", None),
+                call("codejail.darklaunch.globals_match", False),  # mismatch revealed here
+                call("codejail.darklaunch.emsg_match", True),
             ],
             expect_log_info_calls=[
                 call(
@@ -269,17 +272,18 @@ def remote_exec(data):
                 ),
             ],
             # Should only see behavior of local exec
-            expect_globals_contains={'overwrite': 'mock local'},
+            expect_globals_contains={"overwrite": "mock local"},
         )
-        assert results['raised'] is None
+        assert results["raised"] is None
 
         # Both arms should have only seen the original globals object, untouched
         # by the other arm.
-        assert local_globals == {'overwrite': 'original'}
-        assert remote_globals == {'overwrite': 'original'}
+        assert local_globals == {"overwrite": "original"}
+        assert remote_globals == {"overwrite": "original"}
 
     def test_remote_runs_even_if_local_raises(self):
         """Test that remote exec runs even if local raises."""
+
         def local_exec(code, globals_dict, **kwargs):
             # Raise something other than a SafeExecException.
             raise BaseException("unexpected")
@@ -288,15 +292,17 @@ def remote_exec(data):
             return (None, None)
 
         results = self.run_dark_launch(
-            globals_dict={}, local=local_exec, remote=remote_exec,
+            globals_dict={},
+            local=local_exec,
+            remote=remote_exec,
             expect_attr_calls=[
                 *self.standard_codejail_attr_calls,
-                call('codejail.darklaunch.status.local', 'unexpected_error'),
-                call('codejail.darklaunch.status.remote', 'ok'),
-                call('codejail.darklaunch.exception.local', "BaseException('unexpected')"),
-                call('codejail.darklaunch.exception.remote', None),
-                call('codejail.darklaunch.globals_match', "N/A"),
-                call('codejail.darklaunch.emsg_match', "N/A"),
+                call("codejail.darklaunch.status.local", "unexpected_error"),
+                call("codejail.darklaunch.status.remote", "ok"),
+                call("codejail.darklaunch.exception.local", "BaseException('unexpected')"),
+                call("codejail.darklaunch.exception.remote", None),
+                call("codejail.darklaunch.globals_match", "N/A"),
+                call("codejail.darklaunch.emsg_match", "N/A"),
             ],
             expect_log_info_calls=[
                 call(
@@ -310,11 +316,12 @@ def remote_exec(data):
         )
 
         # Unexpected errors from local safe_exec propagate up.
-        assert isinstance(results['raised'], BaseException)
-        assert 'unexpected' in repr(results['raised'])
+        assert isinstance(results["raised"], BaseException)
+        assert "unexpected" in repr(results["raised"])
 
     def test_emsg_mismatch(self):
         """Test that local and remote error messages are compared."""
+
         def local_exec(code, globals_dict, **kwargs):
             raise SafeExecException("oops")
 
@@ -322,15 +329,17 @@ def remote_exec(data):
             return ("OH NO", SafeExecException("OH NO"))
 
         results = self.run_dark_launch(
-            globals_dict={}, local=local_exec, remote=remote_exec,
+            globals_dict={},
+            local=local_exec,
+            remote=remote_exec,
             expect_attr_calls=[
                 *self.standard_codejail_attr_calls,
-                call('codejail.darklaunch.status.local', 'safe_error'),
-                call('codejail.darklaunch.status.remote', 'safe_error'),
-                call('codejail.darklaunch.exception.local', None),
-                call('codejail.darklaunch.exception.remote', None),
-                call('codejail.darklaunch.globals_match', True),
-                call('codejail.darklaunch.emsg_match', False),  # mismatch revealed here
+                call("codejail.darklaunch.status.local", "safe_error"),
+                call("codejail.darklaunch.status.remote", "safe_error"),
+                call("codejail.darklaunch.exception.local", None),
+                call("codejail.darklaunch.exception.remote", None),
+                call("codejail.darklaunch.globals_match", True),
+                call("codejail.darklaunch.emsg_match", False),  # mismatch revealed here
             ],
             expect_log_info_calls=[
                 call(
@@ -343,11 +352,12 @@ def remote_exec(data):
             ],
             expect_globals_contains={},
         )
-        assert isinstance(results['raised'], SafeExecException)
-        assert 'oops' in repr(results['raised'])
+        assert isinstance(results["raised"], SafeExecException)
+        assert "oops" in repr(results["raised"])
 
     def test_ignore_sandbox_dir_mismatch(self):
         """Mismatch due only to differences in sandbox directory should be ignored."""
+
         def local_exec(code, globals_dict, **kwargs):
             raise SafeExecException("stack trace involving /tmp/codejail-1234567/whatever.py")
 
@@ -356,21 +366,23 @@ def remote_exec(data):
             return (emsg, SafeExecException(emsg))
 
         results = self.run_dark_launch(
-            globals_dict={}, local=local_exec, remote=remote_exec,
+            globals_dict={},
+            local=local_exec,
+            remote=remote_exec,
             expect_attr_calls=[
                 *self.standard_codejail_attr_calls,
-                call('codejail.darklaunch.status.local', 'safe_error'),
-                call('codejail.darklaunch.status.remote', 'safe_error'),
-                call('codejail.darklaunch.exception.local', None),
-                call('codejail.darklaunch.exception.remote', None),
-                call('codejail.darklaunch.globals_match', True),
-                call('codejail.darklaunch.emsg_match', True),  # even though not exact match
+                call("codejail.darklaunch.status.local", "safe_error"),
+                call("codejail.darklaunch.status.remote", "safe_error"),
+                call("codejail.darklaunch.exception.local", None),
+                call("codejail.darklaunch.exception.remote", None),
+                call("codejail.darklaunch.globals_match", True),
+                call("codejail.darklaunch.emsg_match", True),  # even though not exact match
             ],
             expect_log_info_calls=[],
             expect_globals_contains={},
         )
-        assert isinstance(results['raised'], SafeExecException)
-        assert 'whatever.py' in repr(results['raised'])
+        assert isinstance(results["raised"], SafeExecException)
+        assert "whatever.py" in repr(results["raised"])
 
     def test_default_normalizers(self):
         """
@@ -379,29 +391,31 @@ def test_default_normalizers(self):
         This just provides coverage for some of the more complicated patterns.
         """
         side_1 = (
-            'Couldn\'t execute jailed code: stdout: b\'\', stderr: b\'Traceback'
+            "Couldn't execute jailed code: stdout: b'', stderr: b'Traceback"
             ' (most recent call last):\\n  File "/tmp/codejail-9g9715g_/jailed_code"'
             ', line 19, in <module>\\n    exec(code, g_dict)\\n  File "<string>"'
             ', line 1, in <module>\\n  File "<string>", line 89, in test_add\\n'
             '  File "<string>", line 1\\n    import random random.choice(range(10))'
-            '\\n    ^\\nSyntaxError: invalid syntax\\n\' with status code: 1'
+            "\\n    ^\\nSyntaxError: invalid syntax\\n' with status code: 1"
         )
         side_2 = (
-            'Couldn\'t execute jailed code: stdout: b\'\', stderr: b\'Traceback'
+            "Couldn't execute jailed code: stdout: b'', stderr: b'Traceback"
             ' (most recent call last):\\n  File "jailed_code"'
             ', line 19, in <module>\\n    exec(code, g_dict)\\n  File "<string>"'
             ', line 203, in <module>\\n  File "<string>", line 89, in test_add\\n'
             '  File "<string>", line 1\\n    import random random.choice(range(10))'
-            '\\n    ^^^^^^\\nSyntaxError: invalid syntax\\n\' with status code: 1'
+            "\\n    ^^^^^^\\nSyntaxError: invalid syntax\\n' with status code: 1"
         )
         assert normalize_error_message(side_1) == normalize_error_message(side_2)
 
-    @override_settings(CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS=[
-        {
-            'search': r'[0-9]+',
-            'replace': r'<NUM>',
-        },
-    ])
+    @override_settings(
+        CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS=[
+            {
+                "search": r"[0-9]+",
+                "replace": r"<NUM>",
+            },
+        ]
+    )
     def test_configurable_normalizers(self):
         """We can augment the normalizers, and they run in order."""
         emsg_in = "Error in /tmp/codejail-1234abcd/whatever.py: something 12 34 other"
@@ -411,11 +425,11 @@ def test_configurable_normalizers(self):
     @override_settings(
         CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS=[
             {
-                'search': r'[0-9]+',
-                'replace': r'<NUM>',
+                "search": r"[0-9]+",
+                "replace": r"<NUM>",
             },
         ],
-        CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS_COMBINE='replace',
+        CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS_COMBINE="replace",
     )
     def test_can_replace_normalizers(self):
         """We can replace the normalizers."""
@@ -423,20 +437,20 @@ def test_can_replace_normalizers(self):
         expect_out = "Error in /tmp/codejail-<NUM>abcd/whatever.py: something <NUM> <NUM> other"
         assert expect_out == normalize_error_message(emsg_in)
 
-    @override_settings(CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS=[
-        {
-            'search': r'broken',
-            'replace': r'replace \g<>',  # invalid replacement pattern
-        },
-    ])
-    @patch('xmodule.capa.safe_exec.safe_exec.record_exception')
-    @patch('xmodule.capa.safe_exec.safe_exec.log.error')
+    @override_settings(
+        CODEJAIL_DARKLAUNCH_EMSG_NORMALIZERS=[
+            {
+                "search": r"broken",
+                "replace": r"replace \g<>",  # invalid replacement pattern
+            },
+        ]
+    )
+    @patch("xmodule.capa.safe_exec.safe_exec.record_exception")
+    @patch("xmodule.capa.safe_exec.safe_exec.log.error")
     def test_normalizers_validate(self, mock_log_error, mock_record_exception):
         """Normalizers are validated, and fall back to default list on error."""
         assert len(emsg_normalizers()) > 0  # pylint: disable=use-implicit-booleaness-not-comparison
-        mock_log_error.assert_called_once_with(
-            "Could not load custom codejail darklaunch emsg normalizers"
-        )
+        mock_log_error.assert_called_once_with("Could not load custom codejail darklaunch emsg normalizers")
         mock_record_exception.assert_called_once()
 
 
@@ -455,12 +469,12 @@ def setUpClass(cls):
         # Make a copy of codejail settings just for this test class.
         # Set a global REALTIME limit of 100.
         # Set a REALTIME limit override of 200 for a special course.
-        cls.test_codejail_settings = (getattr(settings, 'CODE_JAIL', None) or {}).copy()
-        cls.test_codejail_settings['limits'] = {
-            'REALTIME': 100,
+        cls.test_codejail_settings = (getattr(settings, "CODE_JAIL", None) or {}).copy()
+        cls.test_codejail_settings["limits"] = {
+            "REALTIME": 100,
         }
-        cls.test_codejail_settings['limit_overrides'] = {
-            'course-v1:my+special+course': {'REALTIME': 200, 'NPROC': 30},
+        cls.test_codejail_settings["limit_overrides"] = {
+            "course-v1:my+special+course": {"REALTIME": 200, "NPROC": 30},
         }
         cls.configure_codejail(cls.test_codejail_settings)
 
@@ -469,7 +483,7 @@ def tearDownClass(cls):
         super().tearDownClass()
 
         # Re-apply original configuration.
-        cls.configure_codejail(getattr(settings, 'CODE_JAIL', None) or {})
+        cls.configure_codejail(getattr(settings, "CODE_JAIL", None) or {})
 
     @staticmethod
     def configure_codejail(codejail_settings):
@@ -497,22 +511,22 @@ def test_effective_limits_reflect_configuration(self):
         """
         # REALTIME has been configured with a global limit.
         # Check it with no overrides context.
-        assert jail_code.get_effective_limits()['REALTIME'] == 100
+        assert jail_code.get_effective_limits()["REALTIME"] == 100
 
         # Now check REALTIME with an overrides context that we haven't configured.
         # Should be the same.
-        assert jail_code.get_effective_limits('random-context-name')['REALTIME'] == 100
+        assert jail_code.get_effective_limits("random-context-name")["REALTIME"] == 100
 
         # Now check REALTIME limit for a special course.
         # It should be overriden.
-        assert jail_code.get_effective_limits('course-v1:my+special+course')['REALTIME'] == 200
+        assert jail_code.get_effective_limits("course-v1:my+special+course")["REALTIME"] == 200
 
         # We haven't configured a limit for NPROC.
         # It should use the codejail default.
-        assert jail_code.get_effective_limits()['NPROC'] == 15
+        assert jail_code.get_effective_limits()["NPROC"] == 15
 
         # But we have configured an NPROC limit override for a special course.
-        assert jail_code.get_effective_limits('course-v1:my+special+course')['NPROC'] == 30
+        assert jail_code.get_effective_limits("course-v1:my+special+course")["NPROC"] == 30
 
 
 class DictCache(object):
@@ -542,16 +556,16 @@ def test_cache_miss_then_hit(self):
 
         # Cache miss
         safe_exec("a = int(math.pi)", g, cache=DictCache(cache))
-        assert g['a'] == 3
+        assert g["a"] == 3
         # A result has been cached
-        assert list(cache.values())[0] == (None, {'a': 3})
+        assert list(cache.values())[0] == (None, {"a": 3})
 
         # Fiddle with the cache, then try it again.
-        cache[list(cache.keys())[0]] = (None, {'a': 17})
+        cache[list(cache.keys())[0]] = (None, {"a": 17})
 
         g = {}
         safe_exec("a = int(math.pi)", g, cache=DictCache(cache))
-        assert g['a'] == 17
+        assert g["a"] == 17
 
     def test_cache_large_code_chunk(self):
         # Caching used to die on memcache with more than 250 bytes of code.
@@ -561,7 +575,7 @@ def test_cache_large_code_chunk(self):
         g = {}
         cache = {}
         safe_exec(code, g, cache=DictCache(cache))
-        assert g['a'] == 12345
+        assert g["a"] == 12345
 
     def test_cache_exceptions(self):
         # Used to be that running code that raised an exception didn't cache
@@ -575,7 +589,7 @@ def test_cache_exceptions(self):
         # The exception should be in the cache now.
         assert len(cache) == 1
         cache_exc_msg, cache_globals = list(cache.values())[0]  # lint-amnesty, pylint: disable=unused-variable
-        assert 'ZeroDivisionError' in cache_exc_msg
+        assert "ZeroDivisionError" in cache_exc_msg
 
         # Change the value stored in the cache, the result should change.
         cache[list(cache.keys())[0]] = ("Hey there!", {})
@@ -585,17 +599,17 @@ def test_cache_exceptions(self):
 
         assert len(cache) == 1
         cache_exc_msg, cache_globals = list(cache.values())[0]
-        assert 'Hey there!' == cache_exc_msg
+        assert "Hey there!" == cache_exc_msg
 
         # Change it again, now no exception!
-        cache[list(cache.keys())[0]] = (None, {'a': 17})
+        cache[list(cache.keys())[0]] = (None, {"a": 17})
         safe_exec(code, g, cache=DictCache(cache))
-        assert g['a'] == 17
+        assert g["a"] == 17
 
     def test_unicode_submission(self):
         # Check that using non-ASCII unicode does not raise an encoding error.
         # Try several non-ASCII unicode characters.
-        for code in [129, 500, 2 ** 8 - 1, 2 ** 16 - 1]:
+        for code in [129, 500, 2**8 - 1, 2**16 - 1]:
             code_with_unichr = str("# ") + unichr(code)
             try:
                 safe_exec(code_with_unichr, {}, cache=DictCache({}))
@@ -638,8 +652,8 @@ def test_simple_cases(self):
         assert h1 != hs1
 
     def test_list_ordering(self):
-        h1 = self.hash_obj({'a': [1, 2, 3]})
-        h2 = self.hash_obj({'a': [3, 2, 1]})
+        h1 = self.hash_obj({"a": [1, 2, 3]})
+        h2 = self.hash_obj({"a": [3, 2, 1]})
         assert h1 != h2
 
     def test_dict_ordering(self):
@@ -650,8 +664,8 @@ def test_dict_ordering(self):
 
     def test_deep_ordering(self):
         d1, d2 = self.equal_but_different_dicts()
-        o1 = {'a': [1, 2, [d1], 3, 4]}
-        o2 = {'a': [1, 2, [d2], 3, 4]}
+        o1 = {"a": [1, 2, [d1], 3, 4]}
+        o2 = {"a": [1, 2, [d2], 3, 4]}
         h1 = self.hash_obj(o1)
         h2 = self.hash_obj(o2)
         assert h1 == h2
@@ -660,7 +674,8 @@ def test_deep_ordering(self):
 @use_unsafe_codejail()
 class TestRealProblems(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
     def test_802x(self):
-        code = textwrap.dedent("""\
+        code = textwrap.dedent(
+            """\
             import math
             import random
             import numpy
@@ -720,7 +735,8 @@ def sign(x):
             aVAP='%.2e' % VAP
             aVPN='%.2e' % VPN
             aVGD='%.2e' % VGD
-            """)
+            """
+        )
         g = {}
         safe_exec(code, g)
-        assert 'aVAP' in g
+        assert "aVAP" in g
diff --git a/xmodule/capa/tests/helpers.py b/xmodule/capa/tests/helpers.py
index 9708f426259e..fe9064ee55f3 100644
--- a/xmodule/capa/tests/helpers.py
+++ b/xmodule/capa/tests/helpers.py
@@ -1,6 +1,5 @@
 """Tools for helping with testing capa."""
 
-
 import gettext
 import io
 import os
@@ -23,8 +22,7 @@ def get_template(template_name):
     Return template for a capa inputtype.
     """
     return TemplateLookup(
-        directories=[Path(__file__).dirname().dirname() / 'templates'],
-        default_filters=['decode.utf8']
+        directories=[Path(__file__).dirname().dirname() / "templates"], default_filters=["decode.utf8"]
     ).get_template(template_name)
 
 
@@ -40,20 +38,21 @@ def tst_render_template(template, context):  # pylint: disable=unused-argument
     A test version of render to template.  Renders to the repr of the context, completely ignoring
     the template name.  To make the output valid xml, quotes the content, and wraps it in a <div>
     """
-    return '<div>{0}</div>'.format(saxutils.escape(repr(context)))
+    return "<div>{0}</div>".format(saxutils.escape(repr(context)))
 
 
 class StubXQueueService:
     """
     Stubs out the XQueueService for Capa problem tests.
     """
+
     def __init__(self):
         self.interface = MagicMock()
-        self.interface.send_to_queue.return_value = (0, 'Success!')
-        self.default_queuename = 'testqueue'
+        self.interface.send_to_queue.return_value = (0, "Success!")
+        self.default_queuename = "testqueue"
         self.waittime = 10
 
-    def construct_callback(self, dispatch='score_update'):
+    def construct_callback(self, dispatch="score_update"):
         """A callback url method to use in tests."""
         return dispatch
 
@@ -64,8 +63,8 @@ def mock_capa_system(render_template=None):
     """
     the_system = Mock(
         spec=LoncapaSystem,
-        ajax_url='/dummy-ajax-url',
-        anonymous_student_id='student',
+        ajax_url="/dummy-ajax-url",
+        anonymous_student_id="student",
         cache=None,
         can_execute_unsafe_code=lambda: False,
         get_python_lib_zip=lambda: None,
@@ -74,7 +73,7 @@ def mock_capa_system(render_template=None):
         render_template=render_template or tst_render_template,
         resources_fs=fs.osfs.OSFS(os.path.join(TEST_DIR, "test_files")),
         seed=0,
-        STATIC_URL='/dummy-static/',
+        STATIC_URL="/dummy-static/",
         STATUS_CLASS=Status,
         xqueue=StubXQueueService(),
     )
@@ -85,11 +84,12 @@ def mock_capa_block():
     """
     capa response types needs just two things from the capa_block: location and publish.
     """
+
     def mock_location_text(self):  # lint-amnesty, pylint: disable=unused-argument
         """
         Mock implementation of __unicode__ or __str__ for the block's location.
         """
-        return 'i4x://Foo/bar/mock/abc'
+        return "i4x://Foo/bar/mock/abc"
 
     capa_block = Mock()
     capa_block.location.__str__ = mock_location_text
@@ -98,11 +98,16 @@ def mock_location_text(self):  # lint-amnesty, pylint: disable=unused-argument
     return capa_block
 
 
-def new_loncapa_problem(xml, problem_id='1', capa_system=None, seed=723, use_capa_render_template=False):
+def new_loncapa_problem(xml, problem_id="1", capa_system=None, seed=723, use_capa_render_template=False):
     """Construct a `LoncapaProblem` suitable for unit tests."""
     render_template = capa_render_template if use_capa_render_template else None
-    return LoncapaProblem(xml, id=problem_id, seed=seed, capa_system=capa_system or mock_capa_system(render_template),
-                          capa_block=mock_capa_block())
+    return LoncapaProblem(
+        xml,
+        id=problem_id,
+        seed=seed,
+        capa_system=capa_system or mock_capa_system(render_template),
+        capa_block=mock_capa_block(),
+    )
 
 
 def load_fixture(relpath):
@@ -111,7 +116,7 @@ def load_fixture(relpath):
     of the fixture file at the given path within a test_files directory
     in the same directory as the test file.
     """
-    abspath = os.path.join(os.path.dirname(__file__), 'test_files', relpath)
+    abspath = os.path.join(os.path.dirname(__file__), "test_files", relpath)
     with io.open(abspath, encoding="utf-8") as fixture_file:
         contents = fixture_file.read()
         return contents
diff --git a/xmodule/capa/tests/response_xml_factory.py b/xmodule/capa/tests/response_xml_factory.py
index 9e85bcbe795a..53b87e700b4a 100644
--- a/xmodule/capa/tests/response_xml_factory.py
+++ b/xmodule/capa/tests/response_xml_factory.py
@@ -8,13 +8,13 @@
 
 
 class ResponseXMLFactory(six.with_metaclass(ABCMeta, object)):
-    """ Abstract base class for capa response XML factories.
+    """Abstract base class for capa response XML factories.
     Subclasses override create_response_element and
     create_input_element to produce XML of particular response types"""
 
     @abstractmethod
     def create_response_element(self, **kwargs):
-        """ Subclasses override to return an etree element
+        """Subclasses override to return an etree element
         representing the capa response XML
         (e.g. <numericalresponse>).
 
@@ -24,12 +24,12 @@ def create_response_element(self, **kwargs):
 
     @abstractmethod
     def create_input_element(self, **kwargs):
-        """ Subclasses override this to return an etree element
+        """Subclasses override this to return an etree element
         representing the capa input XML (such as <textline />)"""
         return None
 
     def build_xml(self, **kwargs):
-        """ Construct an XML string for a capa response
+        """Construct an XML string for a capa response
         based on **kwargs.
 
         **kwargs is a dictionary that will be passed
@@ -59,12 +59,12 @@ def build_xml(self, **kwargs):
         """
 
         # Retrieve keyward arguments
-        question_text = kwargs.get('question_text', '')
-        explanation_text = kwargs.get('explanation_text', '')
-        script = kwargs.get('script', None)
-        num_responses = kwargs.get('num_responses', 1)
-        num_inputs = kwargs.get('num_inputs', 1)
-        credit_type = kwargs.get('credit_type', None)
+        question_text = kwargs.get("question_text", "")
+        explanation_text = kwargs.get("explanation_text", "")
+        script = kwargs.get("script", None)
+        num_responses = kwargs.get("num_responses", 1)
+        num_inputs = kwargs.get("num_inputs", 1)
+        credit_type = kwargs.get("credit_type", None)
 
         # The root is <problem>
         root = etree.Element("problem")
@@ -81,7 +81,7 @@ def build_xml(self, **kwargs):
 
             # Set partial credit
             if credit_type is not None:
-                response_element.set('partial_credit', str(credit_type))
+                response_element.set("partial_credit", str(credit_type))
 
             root.append(response_element)
 
@@ -102,11 +102,11 @@ def build_xml(self, **kwargs):
                 explanation_div.set("class", "detailed-solution")
                 explanation_div.text = explanation_text
 
-        return etree.tostring(root).decode('utf-8')
+        return etree.tostring(root).decode("utf-8")
 
     @staticmethod
     def textline_input_xml(**kwargs):
-        """ Create a <textline/> XML element
+        """Create a <textline/> XML element
 
         Uses **kwargs:
 
@@ -114,26 +114,26 @@ def textline_input_xml(**kwargs):
 
         *size*: An integer representing the width of the text line
         """
-        math_display = kwargs.get('math_display', False)
-        size = kwargs.get('size', None)
-        input_element_label = kwargs.get('input_element_label', '')
+        math_display = kwargs.get("math_display", False)
+        size = kwargs.get("size", None)
+        input_element_label = kwargs.get("input_element_label", "")
 
-        input_element = etree.Element('textline')
+        input_element = etree.Element("textline")
 
         if input_element_label:
-            input_element.set('label', input_element_label)
+            input_element.set("label", input_element_label)
 
         if math_display:
-            input_element.set('math', '1')
+            input_element.set("math", "1")
 
         if size:
-            input_element.set('size', str(size))
+            input_element.set("size", str(size))
 
         return input_element
 
     @staticmethod
     def choicegroup_input_xml(**kwargs):
-        """ Create a <choicegroup> XML element
+        """Create a <choicegroup> XML element
 
         Uses **kwargs:
 
@@ -154,35 +154,31 @@ def choicegroup_input_xml(**kwargs):
                   If specified, ensure len(points) == len(choices)
         """
         # Names of group elements
-        group_element_names = {
-            'checkbox': 'checkboxgroup',
-            'radio': 'radiogroup',
-            'multiple': 'choicegroup'
-        }
+        group_element_names = {"checkbox": "checkboxgroup", "radio": "radiogroup", "multiple": "choicegroup"}
 
         # Retrieve **kwargs
-        choices = kwargs.get('choices', [True])
-        choice_type = kwargs.get('choice_type', 'multiple')
-        choice_names = kwargs.get('choice_names', [None] * len(choices))
-        points = kwargs.get('points', [None] * len(choices))
+        choices = kwargs.get("choices", [True])
+        choice_type = kwargs.get("choice_type", "multiple")
+        choice_names = kwargs.get("choice_names", [None] * len(choices))
+        points = kwargs.get("points", [None] * len(choices))
 
         # Create the <choicegroup>, <checkboxgroup>, or <radiogroup> element
         assert choice_type in group_element_names
         group_element = etree.Element(group_element_names[choice_type])
 
         # Create the <choice> elements
-        for (correct_val, name, pointval) in zip(choices, choice_names, points):
+        for correct_val, name, pointval in zip(choices, choice_names, points):
             choice_element = etree.SubElement(group_element, "choice")
             if correct_val is True:
-                correctness = 'true'
+                correctness = "true"
             elif correct_val is False:
-                correctness = 'false'
-            elif 'partial' in correct_val:
-                correctness = 'partial'
+                correctness = "false"
+            elif "partial" in correct_val:
+                correctness = "partial"
             else:
                 correctness = correct_val
 
-            choice_element.set('correct', correctness)
+            choice_element.set("correct", correctness)
 
             # Add a name identifying the choice, if one exists
             # For simplicity, we use the same string as both the
@@ -199,10 +195,10 @@ def choicegroup_input_xml(**kwargs):
 
 
 class NumericalResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <numericalresponse> XML trees """
+    """Factory for producing <numericalresponse> XML trees"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <numericalresponse> XML element.
+        """Create a <numericalresponse> XML element.
         Uses **kwarg keys:
 
         *answer*: The correct answer (e.g. "5")
@@ -225,43 +221,43 @@ def create_response_element(self, **kwargs):
         answers that will receive partial credit in the "list" style
         """
 
-        answer = kwargs.get('answer', None)
-        correcthint = kwargs.get('correcthint', '')
-        additional_answers = kwargs.get('additional_answers', {})
-        tolerance = kwargs.get('tolerance', None)
-        credit_type = kwargs.get('credit_type', None)
-        partial_range = kwargs.get('partial_range', None)
-        partial_answers = kwargs.get('partial_answers', None)
+        answer = kwargs.get("answer", None)
+        correcthint = kwargs.get("correcthint", "")
+        additional_answers = kwargs.get("additional_answers", {})
+        tolerance = kwargs.get("tolerance", None)
+        credit_type = kwargs.get("credit_type", None)
+        partial_range = kwargs.get("partial_range", None)
+        partial_answers = kwargs.get("partial_answers", None)
 
-        response_element = etree.Element('numericalresponse')
+        response_element = etree.Element("numericalresponse")
 
         if answer:
             if isinstance(answer, float):
-                response_element.set('answer', repr(answer))
+                response_element.set("answer", repr(answer))
             else:
-                response_element.set('answer', str(answer))
+                response_element.set("answer", str(answer))
 
         for additional_answer, additional_correcthint in additional_answers.items():
-            additional_element = etree.SubElement(response_element, 'additional_answer')
-            additional_element.set('answer', str(additional_answer))
+            additional_element = etree.SubElement(response_element, "additional_answer")
+            additional_element.set("answer", str(additional_answer))
             if additional_correcthint:
-                correcthint_element = etree.SubElement(additional_element, 'correcthint')
+                correcthint_element = etree.SubElement(additional_element, "correcthint")
                 correcthint_element.text = str(additional_correcthint)
 
         if tolerance:
-            responseparam_element = etree.SubElement(response_element, 'responseparam')
-            responseparam_element.set('type', 'tolerance')
-            responseparam_element.set('default', str(tolerance))
-            if partial_range is not None and 'close' in credit_type:
-                responseparam_element.set('partial_range', str(partial_range))
+            responseparam_element = etree.SubElement(response_element, "responseparam")
+            responseparam_element.set("type", "tolerance")
+            responseparam_element.set("default", str(tolerance))
+            if partial_range is not None and "close" in credit_type:
+                responseparam_element.set("partial_range", str(partial_range))
 
-        if partial_answers is not None and 'list' in credit_type:
+        if partial_answers is not None and "list" in credit_type:
             # The line below throws a false positive pylint violation, so it's excepted.
-            responseparam_element = etree.SubElement(response_element, 'responseparam')
-            responseparam_element.set('partial_answers', partial_answers)
+            responseparam_element = etree.SubElement(response_element, "responseparam")
+            responseparam_element.set("partial_answers", partial_answers)
 
         if correcthint:
-            correcthint_element = etree.SubElement(response_element, 'correcthint')
+            correcthint_element = etree.SubElement(response_element, "correcthint")
             correcthint_element.text = str(correcthint)
 
         return response_element
@@ -271,10 +267,10 @@ def create_input_element(self, **kwargs):
 
 
 class CustomResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <customresponse> XML trees """
+    """Factory for producing <customresponse> XML trees"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <customresponse> XML element.
+        """Create a <customresponse> XML element.
 
         Uses **kwargs:
 
@@ -296,34 +292,34 @@ def create_response_element(self, **kwargs):
         """
 
         # Retrieve **kwargs
-        cfn = kwargs.get('cfn', None)
-        expect = kwargs.get('expect', None)
-        answer_attr = kwargs.get('answer_attr', None)
-        answer = kwargs.get('answer', None)
-        options = kwargs.get('options', None)
-        cfn_extra_args = kwargs.get('cfn_extra_args', None)
+        cfn = kwargs.get("cfn", None)
+        expect = kwargs.get("expect", None)
+        answer_attr = kwargs.get("answer_attr", None)
+        answer = kwargs.get("answer", None)
+        options = kwargs.get("options", None)
+        cfn_extra_args = kwargs.get("cfn_extra_args", None)
 
         # Create the response element
         response_element = etree.Element("customresponse")
 
         if cfn:
-            response_element.set('cfn', str(cfn))
+            response_element.set("cfn", str(cfn))
 
         if expect:
-            response_element.set('expect', str(expect))
+            response_element.set("expect", str(expect))
 
         if answer_attr:
-            response_element.set('answer', str(answer_attr))
+            response_element.set("answer", str(answer_attr))
 
         if answer:
             answer_element = etree.SubElement(response_element, "answer")
             answer_element.text = str(answer)
 
         if options:
-            response_element.set('options', str(options))
+            response_element.set("options", str(options))
 
         if cfn_extra_args:
-            response_element.set('cfn_extra_args', str(cfn_extra_args))
+            response_element.set("cfn_extra_args", str(cfn_extra_args))
 
         return response_element
 
@@ -332,16 +328,16 @@ def create_input_element(self, **kwargs):
 
 
 class SchematicResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for creating <schematicresponse> XML trees """
+    """Factory for creating <schematicresponse> XML trees"""
 
     def create_response_element(self, **kwargs):
-        """ Create the <schematicresponse> XML element.
+        """Create the <schematicresponse> XML element.
 
         Uses *kwargs*:
 
         *answer*: The Python script used to evaluate the answer.
         """
-        answer_script = kwargs.get('answer', None)
+        answer_script = kwargs.get("answer", None)
 
         # Create the <schematicresponse> element
         response_element = etree.Element("schematicresponse")
@@ -355,7 +351,7 @@ def create_response_element(self, **kwargs):
         return response_element
 
     def create_input_element(self, **kwargs):
-        """ Create the <schematic> XML element.
+        """Create the <schematic> XML element.
 
         Although <schematic> can have several attributes,
         (*height*, *width*, *parts*, *analyses*, *submit_analysis*, and *initial_value*),
@@ -365,14 +361,16 @@ def create_input_element(self, **kwargs):
 
 
 class CodeResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for creating <coderesponse> XML trees """
+    """Factory for creating <coderesponse> XML trees"""
 
     def build_xml(self, **kwargs):
         # Since we are providing an <answer> tag,
         # we should override the default behavior
         # of including a <solution> tag as well
-        kwargs['explanation_text'] = None
-        return super(CodeResponseXMLFactory, self).build_xml(**kwargs)  # lint-amnesty, pylint: disable=super-with-arguments
+        kwargs["explanation_text"] = None
+        return super(CodeResponseXMLFactory, self).build_xml(  # lint-amnesty, pylint: disable=super-with-arguments
+            **kwargs
+        )
 
     def create_response_element(self, **kwargs):
         """
@@ -395,7 +393,7 @@ def create_response_element(self, **kwargs):
         # Get **kwargs
         initial_display = kwargs.get("initial_display", "Enter code here")
         answer_display = kwargs.get("answer_display", "This is the correct answer!")
-        grader_payload = kwargs.get("grader_payload", '{}')
+        grader_payload = kwargs.get("grader_payload", "{}")
         allowed_files = kwargs.get("allowed_files", None)
         required_files = kwargs.get("required_files", None)
 
@@ -440,22 +438,22 @@ def create_input_element(self, **kwargs):
 
 
 class ChoiceResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for creating <choiceresponse> XML trees """
+    """Factory for creating <choiceresponse> XML trees"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <choiceresponse> element """
+        """Create a <choiceresponse> element"""
         return etree.Element("choiceresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create a <checkboxgroup> element."""
+        """Create a <checkboxgroup> element."""
         return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
 
 
 class FormulaResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for creating <formularesponse> XML trees """
+    """Factory for creating <formularesponse> XML trees"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <formularesponse> element.
+        """Create a <formularesponse> element.
 
         *sample_dict*: A dictionary of the form:
                         { VARIABLE_NAME: (MIN, MAX), ....}
@@ -511,7 +509,7 @@ def create_response_element(self, **kwargs):
         if hint_list:
             hintgroup_element = etree.SubElement(response_element, "hintgroup")
 
-            for (hint_prompt, hint_name, hint_text) in hint_list:
+            for hint_prompt, hint_name, hint_text in hint_list:
 
                 # For each hint, create a <formulahint> element
                 formulahint_element = etree.SubElement(hintgroup_element, "formulahint")
@@ -536,7 +534,9 @@ def create_response_element(self, **kwargs):
     def create_input_element(self, **kwargs):
         return ResponseXMLFactory.textline_input_xml(**kwargs)
 
-    def _sample_str(self, sample_dict, num_samples, tolerance):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
+    def _sample_str(
+        self, sample_dict, num_samples, tolerance
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
         # Loncapa uses a special format for sample strings:
         # "x,y,z@4,5,3:10,12,8#4" means plug in values for (x,y,z)
         # from within the box defined by points (4,5,3) and (10,12,8)
@@ -544,23 +544,26 @@ def _sample_str(self, sample_dict, num_samples, tolerance):  # lint-amnesty, pyl
         low_range_vals = [str(f[0]) for f in sample_dict.values()]
         high_range_vals = [str(f[1]) for f in sample_dict.values()]
         sample_str = (
-            ",".join(list(sample_dict.keys())) + "@" +
-            ",".join(low_range_vals) + ":" +
-            ",".join(high_range_vals) +
-            "#" + str(num_samples)
+            ",".join(list(sample_dict.keys()))
+            + "@"
+            + ",".join(low_range_vals)
+            + ":"
+            + ",".join(high_range_vals)
+            + "#"
+            + str(num_samples)
         )
         return sample_str
 
 
 class ImageResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <imageresponse> XML """
+    """Factory for producing <imageresponse> XML"""
 
     def create_response_element(self, **kwargs):
-        """ Create the <imageresponse> element."""
+        """Create the <imageresponse> element."""
         return etree.Element("imageresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create the <imageinput> element.
+        """Create the <imageinput> element.
 
         Uses **kwargs:
 
@@ -591,8 +594,8 @@ def create_input_element(self, **kwargs):
         src = kwargs.get("src", "/static/image.jpg")
         width = kwargs.get("width", 100)
         height = kwargs.get("height", 100)
-        rectangle = kwargs.get('rectangle', None)
-        regions = kwargs.get('regions', None)
+        rectangle = kwargs.get("rectangle", None)
+        regions = kwargs.get("regions", None)
 
         assert rectangle or regions
 
@@ -619,45 +622,45 @@ class JSInputXMLFactory(CustomResponseXMLFactory):
     """
 
     def create_input_element(self, **kwargs):
-        """ Create the <jsinput> element """
+        """Create the <jsinput> element"""
         return etree.Element("jsinput")
 
 
 class MultipleChoiceResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <multiplechoiceresponse> XML """
+    """Factory for producing <multiplechoiceresponse> XML"""
 
     def create_response_element(self, **kwargs):
-        """ Create the <multiplechoiceresponse> element"""
-        return etree.Element('multiplechoiceresponse')
+        """Create the <multiplechoiceresponse> element"""
+        return etree.Element("multiplechoiceresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create the <choicegroup> element"""
-        kwargs['choice_type'] = 'multiple'
+        """Create the <choicegroup> element"""
+        kwargs["choice_type"] = "multiple"
         return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
 
 
 class TrueFalseResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <truefalseresponse> XML """
+    """Factory for producing <truefalseresponse> XML"""
 
     def create_response_element(self, **kwargs):
-        """ Create the <truefalseresponse> element"""
-        return etree.Element('truefalseresponse')
+        """Create the <truefalseresponse> element"""
+        return etree.Element("truefalseresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create the <choicegroup> element"""
-        kwargs['choice_type'] = 'multiple'
+        """Create the <choicegroup> element"""
+        kwargs["choice_type"] = "multiple"
         return ResponseXMLFactory.choicegroup_input_xml(**kwargs)
 
 
 class OptionResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <optionresponse> XML"""
+    """Factory for producing <optionresponse> XML"""
 
     def create_response_element(self, **kwargs):
-        """ Create the <optionresponse> element"""
+        """Create the <optionresponse> element"""
         return etree.Element("optionresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create the <optioninput> element.
+        """Create the <optioninput> element.
 
         Uses **kwargs:
 
@@ -666,8 +669,8 @@ def create_input_element(self, **kwargs):
         *correct_option*: the correct choice from the list of options [REQUIRED]
         """
 
-        options_list = kwargs.get('options', None)
-        correct_option = kwargs.get('correct_option', None)
+        options_list = kwargs.get("options", None)
+        correct_option = kwargs.get("correct_option", None)
 
         assert options_list and correct_option
         assert len(options_list) > 1
@@ -680,50 +683,50 @@ def create_input_element(self, **kwargs):
         # Format: "('first', 'second', 'third')"
         options_attr_string = ",".join(["'{}'".format(o) for o in options_list])
         options_attr_string = "({})".format(options_attr_string)
-        optioninput_element.set('options', options_attr_string)
+        optioninput_element.set("options", options_attr_string)
 
         # Set the "correct" attribute
-        optioninput_element.set('correct', str(correct_option))
+        optioninput_element.set("correct", str(correct_option))
 
         return optioninput_element
 
 
 class StringResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <stringresponse> XML """
+    """Factory for producing <stringresponse> XML"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <stringresponse> XML element.
+        """Create a <stringresponse> XML element.
 
-            Uses **kwargs:
+        Uses **kwargs:
 
-            *answer*: The correct answer (a string) [REQUIRED]
+        *answer*: The correct answer (a string) [REQUIRED]
 
-            *case_sensitive*: Whether the response is case-sensitive (True/False)
-                            [DEFAULT: True]
+        *case_sensitive*: Whether the response is case-sensitive (True/False)
+                        [DEFAULT: True]
 
-            *hints*: List of (hint_prompt, hint_name, hint_text) tuples
-                Where *hint_prompt* is the string for which we show the hint,
-                *hint_name* is an internal identifier for the hint,
-                and *hint_text* is the text we show for the hint.
+        *hints*: List of (hint_prompt, hint_name, hint_text) tuples
+            Where *hint_prompt* is the string for which we show the hint,
+            *hint_name* is an internal identifier for the hint,
+            and *hint_text* is the text we show for the hint.
 
-            *hintfn*: The name of a function in the script to use for hints.
+        *hintfn*: The name of a function in the script to use for hints.
 
-            *regexp*: Whether the response is regexp
+        *regexp*: Whether the response is regexp
 
-            *additional_answers*: list of additional answers.
+        *additional_answers*: list of additional answers.
 
-            *non_attribute_answers*: list of additional answers to be coded in the
-                non-attribute format
+        *non_attribute_answers*: list of additional answers to be coded in the
+            non-attribute format
 
         """
         # Retrieve the **kwargs
         answer = kwargs.get("answer", None)
         case_sensitive = kwargs.get("case_sensitive", None)
-        hint_list = kwargs.get('hints', None)
-        hint_fn = kwargs.get('hintfn', None)
-        regexp = kwargs.get('regexp', None)
-        additional_answers = kwargs.get('additional_answers', [])
-        non_attribute_answers = kwargs.get('non_attribute_answers', [])
+        hint_list = kwargs.get("hints", None)
+        hint_fn = kwargs.get("hintfn", None)
+        regexp = kwargs.get("regexp", None)
+        additional_answers = kwargs.get("additional_answers", [])
+        non_attribute_answers = kwargs.get("non_attribute_answers", [])
         assert answer
 
         # Create the <stringresponse> element
@@ -733,10 +736,10 @@ def create_response_element(self, **kwargs):
         response_element.set("answer", str(answer))
 
         # Set the case sensitivity and regexp:
-        type_value = ''
+        type_value = ""
         if case_sensitive is not None:
             type_value += "cs" if case_sensitive else "ci"
-        type_value += ' regexp' if regexp else ''
+        type_value += " regexp" if regexp else ""
         if type_value:
             response_element.set("type", type_value.strip())
 
@@ -745,7 +748,7 @@ def create_response_element(self, **kwargs):
             hintgroup_element = etree.SubElement(response_element, "hintgroup")
             if hint_list:
                 assert not hint_fn
-                for (hint_prompt, hint_name, hint_text) in hint_list:
+                for hint_prompt, hint_name, hint_text in hint_list:
                     stringhint_element = etree.SubElement(hintgroup_element, "stringhint")
                     stringhint_element.set("answer", str(hint_prompt))
                     stringhint_element.set("name", str(hint_name))
@@ -775,43 +778,44 @@ def create_input_element(self, **kwargs):
 
 
 class AnnotationResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for creating <annotationresponse> XML trees """
+    """Factory for creating <annotationresponse> XML trees"""
+
     def create_response_element(self, **kwargs):
-        """ Create a <annotationresponse> element """
+        """Create a <annotationresponse> element"""
         return etree.Element("annotationresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create a <annotationinput> element."""
+        """Create a <annotationinput> element."""
 
         input_element = etree.Element("annotationinput")
 
         text_children = [
-            {'tag': 'title', 'text': kwargs.get('title', 'super cool annotation')},
-            {'tag': 'text', 'text': kwargs.get('text', 'texty text')},
-            {'tag': 'comment', 'text': kwargs.get('comment', 'blah blah erudite comment blah blah')},
-            {'tag': 'comment_prompt', 'text': kwargs.get('comment_prompt', 'type a commentary below')},
-            {'tag': 'tag_prompt', 'text': kwargs.get('tag_prompt', 'select one tag')}
+            {"tag": "title", "text": kwargs.get("title", "super cool annotation")},
+            {"tag": "text", "text": kwargs.get("text", "texty text")},
+            {"tag": "comment", "text": kwargs.get("comment", "blah blah erudite comment blah blah")},
+            {"tag": "comment_prompt", "text": kwargs.get("comment_prompt", "type a commentary below")},
+            {"tag": "tag_prompt", "text": kwargs.get("tag_prompt", "select one tag")},
         ]
 
         for child in text_children:
-            etree.SubElement(input_element, child['tag']).text = child['text']
+            etree.SubElement(input_element, child["tag"]).text = child["text"]
 
-        default_options = [('green', 'correct'), ('eggs', 'incorrect'), ('ham', 'partially-correct')]
-        options = kwargs.get('options', default_options)
-        options_element = etree.SubElement(input_element, 'options')
+        default_options = [("green", "correct"), ("eggs", "incorrect"), ("ham", "partially-correct")]
+        options = kwargs.get("options", default_options)
+        options_element = etree.SubElement(input_element, "options")
 
-        for (description, correctness) in options:
-            option_element = etree.SubElement(options_element, 'option', {'choice': correctness})
+        for description, correctness in options:
+            option_element = etree.SubElement(options_element, "option", {"choice": correctness})
             option_element.text = description
 
         return input_element
 
 
 class SymbolicResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <symbolicresponse> xml """
+    """Factory for producing <symbolicresponse> xml"""
 
     def create_response_element(self, **kwargs):
-        """ Build the <symbolicresponse> XML element.
+        """Build the <symbolicresponse> XML element.
 
         Uses **kwargs:
 
@@ -821,20 +825,20 @@ def create_response_element(self, **kwargs):
             (e.g. 'matrix', 'qbit', 'imaginary', 'numerical')"""
 
         # Retrieve **kwargs
-        expect = kwargs.get('expect', '')
-        options = kwargs.get('options', [])
+        expect = kwargs.get("expect", "")
+        options = kwargs.get("options", [])
 
         # Symmath check expects a string of options
         options_str = ",".join(options)
 
         # Construct the <symbolicresponse> element
-        response_element = etree.Element('symbolicresponse')
+        response_element = etree.Element("symbolicresponse")
 
         if expect:
-            response_element.set('expect', str(expect))
+            response_element.set("expect", str(expect))
 
         if options_str:
-            response_element.set('options', str(options_str))
+            response_element.set("options", str(options_str))
 
         return response_element
 
@@ -843,14 +847,14 @@ def create_input_element(self, **kwargs):
 
 
 class ChoiceTextResponseXMLFactory(ResponseXMLFactory):
-    """ Factory for producing <choicetextresponse> xml """
+    """Factory for producing <choicetextresponse> xml"""
 
     def create_response_element(self, **kwargs):
-        """ Create a <choicetextresponse> element """
+        """Create a <choicetextresponse> element"""
         return etree.Element("choicetextresponse")
 
     def create_input_element(self, **kwargs):
-        """ Create a <checkboxgroup> element.
+        """Create a <checkboxgroup> element.
         choices can be specified in the following format:
         [("true", [{"answer": "5", "tolerance": 0}]),
         ("false", [{"answer": "5", "tolerance": 0}])
@@ -862,7 +866,7 @@ def create_input_element(self, **kwargs):
         It also indicates that the second has a second incorrect radiobutton
         or checkbox with a numtolerance_input.
         """
-        choices = kwargs.get('choices', [("true", {})])
+        choices = kwargs.get("choices", [("true", {})])
         choice_inputs = []
         # Ensure that the first element of choices is an ordered
         # collection. It will start as a list, a tuple, or not a Container.
@@ -884,19 +888,11 @@ def create_input_element(self, **kwargs):
                 if not isinstance(answers, (list, tuple)):
                     answers = [answers]
 
-                numtolerance_inputs = [
-                    self._create_numtolerance_input_element(answer)
-                    for answer in answers
-                ]
-
-            choice_inputs.append(
-                self._create_choice_element(
-                    correctness=correctness,
-                    inputs=numtolerance_inputs
-                )
-            )
+                numtolerance_inputs = [self._create_numtolerance_input_element(answer) for answer in answers]
+
+            choice_inputs.append(self._create_choice_element(correctness=correctness, inputs=numtolerance_inputs))
         # Default type is 'radiotextgroup'
-        input_type = kwargs.get('type', 'radiotextgroup')
+        input_type = kwargs.get("type", "radiotextgroup")
         input_element = etree.Element(input_type)
 
         for ind, choice in enumerate(choice_inputs):
@@ -911,9 +907,9 @@ def _create_choice_element(self, **kwargs):
         Creates a choice element for a choictextproblem.
         Defaults to a correct choice with no numtolerance_input
         """
-        text = kwargs.get('text', '')
-        correct = kwargs.get('correctness', "true")
-        inputs = kwargs.get('inputs', [])
+        text = kwargs.get("text", "")
+        correct = kwargs.get("correctness", "true")
+        inputs = kwargs.get("inputs", [])
         choice_element = etree.Element("choice")
         choice_element.set("correct", correct)
         choice_element.text = text
@@ -928,19 +924,16 @@ def _create_numtolerance_input_element(self, params):
         Creates a <numtolerance_input/>  or <decoy_input/> element with
         optionally specified tolerance and answer.
         """
-        answer = params['answer'] if 'answer' in params else None
+        answer = params["answer"] if "answer" in params else None
         # If there is not an answer specified, Then create a <decoy_input/>
         # otherwise create a <numtolerance_input/> and set its tolerance
         # and answer attributes.
         if answer:
             text_input = etree.Element("numtolerance_input")
-            text_input.set('answer', answer)
+            text_input.set("answer", answer)
             # If tolerance was specified, was specified use it, otherwise
             # Set the tolerance to "0"
-            text_input.set(
-                'tolerance',
-                params['tolerance'] if 'tolerance' in params else "0"
-            )
+            text_input.set("tolerance", params["tolerance"] if "tolerance" in params else "0")
 
         else:
             text_input = etree.Element("decoy_input")
diff --git a/xmodule/capa/tests/test_answer_pool.py b/xmodule/capa/tests/test_answer_pool.py
index 28de91858074..4614768b6588 100644
--- a/xmodule/capa/tests/test_answer_pool.py
+++ b/xmodule/capa/tests/test_answer_pool.py
@@ -3,12 +3,11 @@
   <choicegroup answer-pool="4">
 """
 
-
 import textwrap
 import unittest
 
 from xmodule.capa.responsetypes import LoncapaProblemError
-from xmodule.capa.tests.helpers import new_loncapa_problem, mock_capa_system
+from xmodule.capa.tests.helpers import mock_capa_system, new_loncapa_problem
 
 
 class CapaAnswerPoolTest(unittest.TestCase):
@@ -19,7 +18,8 @@ def setUp(self):
         self.system = mock_capa_system()
 
     # XML problem setup used by a few tests.
-    common_question_xml = textwrap.dedent("""
+    common_question_xml = textwrap.dedent(
+        """
         <problem>
 
         <p>What is the correct answer?</p>
@@ -51,7 +51,8 @@ def setUp(self):
             </solution>
         </solutionset>
     </problem>
-    """)
+    """
+    )
 
     def test_answer_pool_4_choices_1_multiplechoiceresponse_seed1(self):
         problem = new_loncapa_problem(self.common_question_xml, seed=723)
@@ -59,12 +60,12 @@ def test_answer_pool_4_choices_1_multiplechoiceresponse_seed1(self):
         # [('choice_3', 'wrong-3'), ('choice_5', 'correct-2'), ('choice_1', 'wrong-2'), ('choice_4', 'wrong-4')]
         self.assertRegex(the_html, r"<div>.*\[.*'wrong-3'.*'correct-2'.*'wrong-2'.*'wrong-4'.*\].*</div>")
         self.assertRegex(the_html, r"<div>\{.*'1_solution_2'.*\}</div>")
-        assert the_html == problem.get_html(), 'should be able to call get_html() twice'
+        assert the_html == problem.get_html(), "should be able to call get_html() twice"
         # Check about masking
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
         assert response.has_answerpool()
-        assert response.unmask_order() == ['choice_3', 'choice_5', 'choice_1', 'choice_4']
+        assert response.unmask_order() == ["choice_3", "choice_5", "choice_1", "choice_4"]
 
     def test_answer_pool_4_choices_1_multiplechoiceresponse_seed2(self):
         problem = new_loncapa_problem(self.common_question_xml, seed=9)
@@ -75,11 +76,12 @@ def test_answer_pool_4_choices_1_multiplechoiceresponse_seed2(self):
         # Check about masking
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
-        assert hasattr(response, 'has_answerpool')
-        assert response.unmask_order() == ['choice_0', 'choice_4', 'choice_3', 'choice_2']
+        assert hasattr(response, "has_answerpool")
+        assert response.unmask_order() == ["choice_0", "choice_4", "choice_3", "choice_2"]
 
     def test_no_answer_pool_4_choices_1_multiplechoiceresponse(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -112,20 +114,24 @@ def test_no_answer_pool_4_choices_1_multiplechoiceresponse(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         the_html = problem.get_html()
-        self.assertRegex(the_html, r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*'wrong-3'.*'wrong-4'.*'correct-2'.*\].*</div>")  # lint-amnesty, pylint: disable=line-too-long
+        self.assertRegex(
+            the_html, r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*'wrong-3'.*'wrong-4'.*'correct-2'.*\].*</div>"
+        )  # lint-amnesty, pylint: disable=line-too-long
         self.assertRegex(the_html, r"<div>\{.*'1_solution_1'.*'1_solution_2'.*\}</div>")
-        assert the_html == problem.get_html(), 'should be able to call get_html() twice'
+        assert the_html == problem.get_html(), "should be able to call get_html() twice"
         # Check about masking
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
         assert not response.has_answerpool()
 
     def test_0_answer_pool_4_choices_1_multiplechoiceresponse(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -158,18 +164,22 @@ def test_0_answer_pool_4_choices_1_multiplechoiceresponse(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         the_html = problem.get_html()
-        self.assertRegex(the_html, r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*'wrong-3'.*'wrong-4'.*'correct-2'.*\].*</div>")  # lint-amnesty, pylint: disable=line-too-long
+        self.assertRegex(
+            the_html, r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*'wrong-3'.*'wrong-4'.*'correct-2'.*\].*</div>"
+        )  # lint-amnesty, pylint: disable=line-too-long
         self.assertRegex(the_html, r"<div>\{.*'1_solution_1'.*'1_solution_2'.*\}</div>")
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
         assert not response.has_answerpool()
 
     def test_invalid_answer_pool_value(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -202,13 +212,15 @@ def test_invalid_answer_pool_value(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
 
         with self.assertRaisesRegex(LoncapaProblemError, "answer-pool"):
             new_loncapa_problem(xml_str)
 
     def test_invalid_answer_pool_none_correct(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse>
@@ -221,12 +233,14 @@ def test_invalid_answer_pool_none_correct(self):
               </choicegroup>
             </multiplechoiceresponse>
         </problem>
-        """)
+        """
+        )
         with self.assertRaisesRegex(LoncapaProblemError, "1 correct.*1 incorrect"):
             new_loncapa_problem(xml_str)
 
     def test_invalid_answer_pool_all_correct(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse>
@@ -238,12 +252,14 @@ def test_invalid_answer_pool_all_correct(self):
               </choicegroup>
             </multiplechoiceresponse>
         </problem>
-        """)
+        """
+        )
         with self.assertRaisesRegex(LoncapaProblemError, "1 correct.*1 incorrect"):
             new_loncapa_problem(xml_str)
 
     def test_answer_pool_5_choices_1_multiplechoiceresponse_seed1(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -276,7 +292,8 @@ def test_answer_pool_5_choices_1_multiplechoiceresponse_seed1(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str, seed=723)
         the_html = problem.get_html()
@@ -284,10 +301,11 @@ def test_answer_pool_5_choices_1_multiplechoiceresponse_seed1(self):
         self.assertRegex(the_html, r"<div>\{.*'1_solution_2'.*\}</div>")
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
-        assert response.unmask_order() == ['choice_5', 'choice_0', 'choice_1', 'choice_3', 'choice_4']
+        assert response.unmask_order() == ["choice_5", "choice_0", "choice_1", "choice_3", "choice_4"]
 
     def test_answer_pool_2_multiplechoiceresponses_seed1(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -349,12 +367,13 @@ def test_answer_pool_2_multiplechoiceresponses_seed1(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str)
         the_html = problem.get_html()
 
         str1 = r"<div>.*\[.*'wrong-3'.*'correct-2'.*'wrong-2'.*'wrong-4'.*\].*</div>"
-        str2 = r"<div>.*\[.*'wrong-2'.*'wrong-1'.*'correct-2'.*\].*</div>"    # rng shared
+        str2 = r"<div>.*\[.*'wrong-2'.*'wrong-1'.*'correct-2'.*\].*</div>"  # rng shared
         # str2 = r"<div>.*\[.*'correct-2'.*'wrong-2'.*'wrong-3'.*\].*</div>"  # rng independent
 
         str3 = r"<div>\{.*'1_solution_2'.*\}</div>"
@@ -371,7 +390,8 @@ def test_answer_pool_2_multiplechoiceresponses_seed1(self):
         self.assertRegex(without_new_lines, str3 + r".*" + str4)
 
     def test_answer_pool_2_multiplechoiceresponses_seed2(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -433,7 +453,8 @@ def test_answer_pool_2_multiplechoiceresponses_seed2(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=9)
         the_html = problem.get_html()
 
@@ -457,7 +478,8 @@ def test_answer_pool_random_consistent(self):
         The point of this test is to make sure that the exact randomization
         per seed does not change.
         """
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" answer-pool="2">
@@ -507,19 +529,23 @@ def test_answer_pool_random_consistent(self):
               </choicegroup>
             </multiplechoiceresponse>
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         the_html = problem.get_html()
-        str1 = (r"<div>.*\[.*'correct-2'.*'wrong-2'.*\].*</div>.*" +
-                r"<div>.*\[.*'wrong-1'.*'correct-2'.*'wrong-4'.*\].*</div>.*" +
-                r"<div>.*\[.*'correct-1'.*'wrong-4'.*\].*</div>.*" +
-                r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*\].*</div>")
+        str1 = (
+            r"<div>.*\[.*'correct-2'.*'wrong-2'.*\].*</div>.*"
+            + r"<div>.*\[.*'wrong-1'.*'correct-2'.*'wrong-4'.*\].*</div>.*"
+            + r"<div>.*\[.*'correct-1'.*'wrong-4'.*\].*</div>.*"
+            + r"<div>.*\[.*'wrong-1'.*'wrong-2'.*'correct-1'.*\].*</div>"
+        )
         without_new_lines = the_html.replace("\n", "")
         self.assertRegex(without_new_lines, str1)
 
     def test_no_answer_pool(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -534,7 +560,8 @@ def test_no_answer_pool(self):
             </multiplechoiceresponse>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str, seed=723)
         the_html = problem.get_html()
@@ -548,7 +575,8 @@ def test_no_answer_pool(self):
         assert not response.has_answerpool()
 
     def test_answer_pool_and_no_answer_pool(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -600,7 +628,8 @@ def test_answer_pool_and_no_answer_pool(self):
             </solutionset>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str, seed=723)
         the_html = problem.get_html()
@@ -621,7 +650,8 @@ def test_answer_pool_and_no_answer_pool(self):
         self.assertRegex(without_new_lines, str3 + r".*" + str4)
 
     def test_answer_pool_without_solutionset(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
 
             <p>What is the correct answer?</p>
@@ -645,7 +675,8 @@ def test_answer_pool_without_solutionset(self):
             </solution>
 
         </problem>
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str, seed=723)
         the_html = problem.get_html()
diff --git a/xmodule/capa/tests/test_capa_problem.py b/xmodule/capa/tests/test_capa_problem.py
index 5f42b9184921..473f04461a1a 100644
--- a/xmodule/capa/tests/test_capa_problem.py
+++ b/xmodule/capa/tests/test_capa_problem.py
@@ -1,37 +1,37 @@
 """
 Test capa problem.
 """
+
 import textwrap
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
 
+import ddt
+import pytest
 from django.conf import settings
 from django.test import override_settings
-import pytest
-import ddt
 from lxml import etree
 from markupsafe import Markup
 
+from openedx.core.djangolib.markup import HTML
 from xmodule.capa.correctmap import CorrectMap
 from xmodule.capa.responsetypes import LoncapaProblemError
 from xmodule.capa.tests.helpers import new_loncapa_problem
 from xmodule.capa.tests.test_util import use_unsafe_codejail
-from openedx.core.djangolib.markup import HTML
-
 
 FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS = settings.FEATURES.copy()
-FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS['ENABLE_GRADING_METHOD_IN_PROBLEMS'] = True
+FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS["ENABLE_GRADING_METHOD_IN_PROBLEMS"] = True
 
 
 @ddt.ddt
 @use_unsafe_codejail()
 class CAPAProblemTest(unittest.TestCase):
-    """ CAPA problem related tests"""
+    """CAPA problem related tests"""
 
     @ddt.unpack
     @ddt.data(
-        {'question': 'Select the correct synonym of paranoid?'},
-        {'question': 'Select the correct <em>synonym</em> of <strong>paranoid</strong>?'},
+        {"question": "Select the correct synonym of paranoid?"},
+        {"question": "Select the correct <em>synonym</em> of <strong>paranoid</strong>?"},
     )
     def test_label_and_description_inside_responsetype(self, question):
         """
@@ -53,21 +53,24 @@ def test_label_and_description_inside_responsetype(self, question):
                 </checkboxgroup>
             </choiceresponse>
         </problem>
-        """.format(question=question)
+        """.format(
+            question=question
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'label': question, 'descriptions': {'description_1_1_1': 'Only the paranoid survive.'}}}
-        assert len(problem.tree.xpath('//label')) == 0
+        assert problem.problem_data == {
+            "1_2_1": {"label": question, "descriptions": {"description_1_1_1": "Only the paranoid survive."}}
+        }
+        assert len(problem.tree.xpath("//label")) == 0
 
     @ddt.unpack
     @ddt.data(
         {
-            'question': 'Once we become predictable, we become ______?',
-            'label_attr': 'Once we become predictable, we become ______?'
+            "question": "Once we become predictable, we become ______?",
+            "label_attr": "Once we become predictable, we become ______?",
         },
         {
-            'question': 'Once we become predictable, we become ______?<img src="img/src"/>',
-            'label_attr': 'Once we become predictable, we become ______?'
+            "question": 'Once we become predictable, we become ______?<img src="img/src"/>',
+            "label_attr": "Once we become predictable, we become ______?",
         },
     )
     def test_legacy_problem(self, question, label_attr):
@@ -82,20 +85,22 @@ def test_legacy_problem(self, question, label_attr):
                 <textline label="{}" size="40"/>
             </stringresponse>
         </problem>
-        """.format(question, label_attr)
+        """.format(
+            question, label_attr
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data == {'1_2_1': {'label': question, 'descriptions': {}}}
+        assert problem.problem_data == {"1_2_1": {"label": question, "descriptions": {}}}
         assert len(problem.tree.xpath("//*[normalize-space(text())='{}']".format(question))) == 0
 
     @ddt.unpack
     @ddt.data(
         {
-            'question1': 'People who say they have nothing to ____ almost always do?',
-            'question2': 'Select the correct synonym of paranoid?'
+            "question1": "People who say they have nothing to ____ almost always do?",
+            "question2": "Select the correct synonym of paranoid?",
         },
         {
-            'question1': '<b>People</b> who say they have <mark>nothing</mark> to ____ almost always do?',
-            'question2': 'Select the <sup>correct</sup> synonym of <mark>paranoid</mark>?'
+            "question1": "<b>People</b> who say they have <mark>nothing</mark> to ____ almost always do?",
+            "question2": "Select the <sup>correct</sup> synonym of <mark>paranoid</mark>?",
         },
     )
     def test_neither_label_tag_nor_attribute(self, question1, question2):
@@ -122,10 +127,14 @@ def test_neither_label_tag_nor_attribute(self, question1, question2):
                 </checkboxgroup>
             </choiceresponse>
         </problem>
-        """.format(question1, question2)
+        """.format(
+            question1, question2
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'label': question1, 'descriptions': {}}, '1_3_1': {'label': question2, 'descriptions': {}}}
+        assert problem.problem_data == {
+            "1_2_1": {"label": question1, "descriptions": {}},
+            "1_3_1": {"label": question2, "descriptions": {}},
+        }
         for question in (question1, question2):
             assert len(problem.tree.xpath('//label[text()="{}"]'.format(question))) == 0
 
@@ -145,11 +154,16 @@ def test_multiple_descriptions(self):
                 <textline size="40"/>
             </stringresponse>
         </problem>
-        """.format(desc1, desc2)
+        """.format(
+            desc1, desc2
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'label': '___ requires sacrifices.',
-                          'descriptions': {'description_1_1_1': desc1, 'description_1_1_2': desc2}}}
+        assert problem.problem_data == {
+            "1_2_1": {
+                "label": "___ requires sacrifices.",
+                "descriptions": {"description_1_1_1": desc1, "description_1_1_2": desc2},
+            }
+        }
 
     def test_additional_answer_is_skipped_from_resulting_html(self):
         """Tests that additional_answer element is not present in transformed HTML"""
@@ -165,8 +179,8 @@ def test_additional_answer_is_skipped_from_resulting_html(self):
         </problem>
         """
         problem = new_loncapa_problem(xml)
-        assert len(problem.extracted_tree.xpath('//additional_answer')) == 0
-        assert 'additional_answer' not in problem.get_html()
+        assert len(problem.extracted_tree.xpath("//additional_answer")) == 0
+        assert "additional_answer" not in problem.get_html()
 
     def test_non_accessible_inputtype(self):
         """
@@ -182,9 +196,11 @@ def test_non_accessible_inputtype(self):
                 src="/static/Africa.png" width="600" height="638" rectangle="(338,98)-(412,168)"/>
             </imageresponse>
         </problem>
-        """.format(question, question)
+        """.format(
+            question, question
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data == {'1_2_1': {'label': question, 'descriptions': {}}}
+        assert problem.problem_data == {"1_2_1": {"label": question, "descriptions": {}}}
         # <p> tag with question text should not be deleted
         assert problem.tree.xpath("string(p[text()='{}'])".format(question)) == question
 
@@ -202,9 +218,11 @@ def test_label_is_empty_if_no_label_attribute(self):
                 src="/static/Africa.png" width="600" height="638" rectangle="(338,98)-(412,168)"/>
             </imageresponse>
         </problem>
-        """.format(question)
+        """.format(
+            question
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data == {'1_2_1': {'label': '', 'descriptions': {}}}
+        assert problem.problem_data == {"1_2_1": {"label": "", "descriptions": {}}}
 
     def test_multiple_questions_problem(self):
         """
@@ -237,12 +255,17 @@ def test_multiple_questions_problem(self):
         </problem>
         """
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'label': 'Select the correct synonym of paranoid?',
-                          'descriptions': {'description_1_1_1': 'Only the paranoid survive.'}},
-                '1_3_1': {'label': 'What Apple device competed with the portable CD player?',
-                          'descriptions': {'description_1_2_1': 'Device looks like an egg plant.'}}}
-        assert len(problem.tree.xpath('//label')) == 0
+        assert problem.problem_data == {
+            "1_2_1": {
+                "label": "Select the correct synonym of paranoid?",
+                "descriptions": {"description_1_1_1": "Only the paranoid survive."},
+            },
+            "1_3_1": {
+                "label": "What Apple device competed with the portable CD player?",
+                "descriptions": {"description_1_2_1": "Device looks like an egg plant."},
+            },
+        }
+        assert len(problem.tree.xpath("//label")) == 0
 
     def test_question_title_not_removed_got_children(self):
         """
@@ -252,7 +275,7 @@ def test_question_title_not_removed_got_children(self):
         This is the case when author updated the <p> immediately before
         responsetype to contain other elements. We do not want to delete information in that case.
         """
-        question = 'Is egg plant a fruit?'
+        question = "Is egg plant a fruit?"
         xml = """
         <problem>
             <p>Choose wisely.</p>
@@ -265,22 +288,24 @@ def test_question_title_not_removed_got_children(self):
                 </checkboxgroup>
             </choiceresponse>
         </problem>
-        """.format(question)
+        """.format(
+            question
+        )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data == {'1_2_1': {'label': '', 'descriptions': {}}}
-        assert len(problem.tree.xpath('//p/img')) == 1
+        assert problem.problem_data == {"1_2_1": {"label": "", "descriptions": {}}}
+        assert len(problem.tree.xpath("//p/img")) == 1
 
     @ddt.unpack
     @ddt.data(
-        {'group_label': 'Choose the correct color'},
-        {'group_label': 'Choose the <b>correct</b> <mark>color</mark>'},
+        {"group_label": "Choose the correct color"},
+        {"group_label": "Choose the <b>correct</b> <mark>color</mark>"},
     )
     def test_multiple_inputtypes(self, group_label):
         """
         Verify that group label and labels for individual inputtypes are extracted correctly.
         """
-        input1_label = 'What color is the sky?'
-        input2_label = 'What color are pine needles?'
+        input1_label = "What color is the sky?"
+        input2_label = "What color are pine needles?"
         xml = """
         <problem>
             <optionresponse>
@@ -289,19 +314,23 @@ def test_multiple_inputtypes(self, group_label):
                 <optioninput options="('yellow','blue','green')" correct="green" label="{}"/>
             </optionresponse>
         </problem>
-        """.format(group_label, input1_label, input2_label)
+        """.format(
+            group_label, input1_label, input2_label
+        )
 
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'group_label': group_label, 'label': input1_label, 'descriptions': {}},
-                '1_2_2': {'group_label': group_label, 'label': input2_label, 'descriptions': {}}}
+        assert problem.problem_data == {
+            "1_2_1": {"group_label": group_label, "label": input1_label, "descriptions": {}},
+            "1_2_2": {"group_label": group_label, "label": input2_label, "descriptions": {}},
+        }
 
     def test_single_inputtypes(self):
         """
         Verify that HTML is correctly rendered when there is single inputtype.
         """
-        question = 'Enter sum of 1+2'
-        xml = textwrap.dedent("""
+        question = "Enter sum of 1+2"
+        xml = textwrap.dedent(
+            """
         <problem>
             <customresponse cfn="test_sum" expect="3">
         <script type="loncapa/python">
@@ -312,7 +341,10 @@ def test_sum(expect, ans):
                 <textline size="20" correct_answer="3" />
             </customresponse>
         </problem>
-        """.format(question))
+        """.format(
+                question
+            )
+        )
         problem = new_loncapa_problem(xml, use_capa_render_template=True)
         problem_html = etree.XML(problem.get_html())
 
@@ -328,10 +360,10 @@ def assert_question_tag(self, question1, question2, tag, label_attr=False):
         """
         Verify question tag correctness.
         """
-        question1_tag = '<{tag}>{}</{tag}>'.format(question1, tag=tag) if question1 else ''
-        question2_tag = '<{tag}>{}</{tag}>'.format(question2, tag=tag) if question2 else ''
-        question1_label_attr = 'label="{}"'.format(question1) if label_attr else ''
-        question2_label_attr = 'label="{}"'.format(question2) if label_attr else ''
+        question1_tag = "<{tag}>{}</{tag}>".format(question1, tag=tag) if question1 else ""
+        question2_tag = "<{tag}>{}</{tag}>".format(question2, tag=tag) if question2 else ""
+        question1_label_attr = 'label="{}"'.format(question1) if label_attr else ""
+        question2_label_attr = 'label="{}"'.format(question2) if label_attr else ""
         xml = """
         <problem>
             {question1_tag}
@@ -356,22 +388,24 @@ def assert_question_tag(self, question1, question2, tag, label_attr=False):
             question2_label_attr=question2_label_attr,
         )
         problem = new_loncapa_problem(xml)
-        assert problem.problem_data ==\
-               {'1_2_1': {'label': question1, 'descriptions': {}}, '1_3_1': {'label': question2, 'descriptions': {}}}
-        assert len(problem.tree.xpath('//{}'.format(tag))) == 0
+        assert problem.problem_data == {
+            "1_2_1": {"label": question1, "descriptions": {}},
+            "1_3_1": {"label": question2, "descriptions": {}},
+        }
+        assert len(problem.tree.xpath("//{}".format(tag))) == 0
 
     @ddt.unpack
     @ddt.data(
-        {'question1': 'question 1 label', 'question2': 'question 2 label'},
-        {'question1': '', 'question2': 'question 2 label'},
-        {'question1': 'question 1 label', 'question2': ''}
+        {"question1": "question 1 label", "question2": "question 2 label"},
+        {"question1": "", "question2": "question 2 label"},
+        {"question1": "question 1 label", "question2": ""},
     )
     def test_correct_question_tag_is_picked(self, question1, question2):
         """
         For a problem with multiple questions verify that correct question tag is picked.
         """
-        self.assert_question_tag(question1, question2, tag='label', label_attr=False)
-        self.assert_question_tag(question1, question2, tag='p', label_attr=True)
+        self.assert_question_tag(question1, question2, tag="label", label_attr=False)
+        self.assert_question_tag(question1, question2, tag="p", label_attr=True)
 
     def test_optionresponse_xml_compatibility(self):
         """
@@ -428,7 +462,7 @@ def test_optionresponse_option_with_empty_text(self):
 @ddt.ddt
 @use_unsafe_codejail()
 class CAPAMultiInputProblemTest(unittest.TestCase):
-    """ TestCase for CAPA problems with multiple inputtypes """
+    """TestCase for CAPA problems with multiple inputtypes"""
 
     def capa_problem(self, xml):
         """
@@ -439,7 +473,7 @@ def capa_problem(self, xml):
     def assert_problem_data(self, problem_data):
         """Verify problem data is in expected state"""
         for problem_value in problem_data.values():
-            assert isinstance(problem_value['label'], Markup)
+            assert isinstance(problem_value["label"], Markup)
 
     def assert_problem_html(self, problem_html, group_label, *input_labels):
         """
@@ -453,18 +487,16 @@ def assert_problem_html(self, problem_html, group_label, *input_labels):
         html = etree.XML(problem_html)
 
         # verify that only one multi input group div is present at correct path
-        multi_inputs_group = html.xpath(
-            '//div[@class="wrapper-problem-response"]/div[@class="multi-inputs-group"]'
-        )
+        multi_inputs_group = html.xpath('//div[@class="wrapper-problem-response"]/div[@class="multi-inputs-group"]')
         assert len(multi_inputs_group) == 1
 
         if group_label is None:
             # if multi inputs group label is not present then there shouldn't be `aria-labelledby` attribute
-            assert multi_inputs_group[0].attrib.get('aria-labelledby') is None
+            assert multi_inputs_group[0].attrib.get("aria-labelledby") is None
         else:
             # verify that multi input group label <p> tag exists and its
             # id matches with correct multi input group aria-labelledby
-            multi_inputs_group_label_id = multi_inputs_group[0].attrib.get('aria-labelledby')
+            multi_inputs_group_label_id = multi_inputs_group[0].attrib.get("aria-labelledby")
             multi_inputs_group_label = html.xpath('//p[@id="{}"]'.format(multi_inputs_group_label_id))
             assert len(multi_inputs_group_label) == 1
             assert multi_inputs_group_label[0].text == group_label
@@ -477,15 +509,15 @@ def assert_problem_html(self, problem_html, group_label, *input_labels):
 
     @ddt.unpack
     @ddt.data(
-        {'label_html': '<label>Choose the correct color</label>', 'group_label': 'Choose the correct color'},
-        {'label_html': '', 'group_label': None}
+        {"label_html": "<label>Choose the correct color</label>", "group_label": "Choose the correct color"},
+        {"label_html": "", "group_label": None},
     )
     def test_optionresponse(self, label_html, group_label):
         """
         Verify that optionresponse problem with multiple inputtypes is rendered correctly.
         """
-        input1_label = 'What color is the sky?'
-        input2_label = 'What color are pine needles?'
+        input1_label = "What color is the sky?"
+        input2_label = "What color are pine needles?"
         xml = """
         <problem>
             <optionresponse>
@@ -494,25 +526,25 @@ def test_optionresponse(self, label_html, group_label):
                 <optioninput options="('yellow','blue','green')" correct="green" label="{input2_label}"/>
             </optionresponse>
         </problem>
-        """.format(label_html=label_html, input1_label=input1_label, input2_label=input2_label)
+        """.format(
+            label_html=label_html, input1_label=input1_label, input2_label=input2_label
+        )
         problem = self.capa_problem(xml)
         self.assert_problem_html(problem.get_html(), group_label, input1_label, input2_label)
         self.assert_problem_data(problem.problem_data)
 
     @ddt.unpack
-    @ddt.data(
-        {'inputtype': 'textline'},
-        {'inputtype': 'formulaequationinput'}
-    )
+    @ddt.data({"inputtype": "textline"}, {"inputtype": "formulaequationinput"})
     def test_customresponse(self, inputtype):
         """
         Verify that customresponse problem with multiple textline
         and formulaequationinput inputtypes is rendered correctly.
         """
-        group_label = 'Enter two integers that sum to 10.'
-        input1_label = 'Integer 1'
-        input2_label = 'Integer 2'
-        xml = textwrap.dedent("""
+        group_label = "Enter two integers that sum to 10."
+        input1_label = "Integer 1"
+        input2_label = "Integer 2"
+        xml = textwrap.dedent(
+            """
         <problem>
             <customresponse cfn="test_add_to_ten">
         <script type="loncapa/python">
@@ -524,7 +556,10 @@ def test_add_to_ten(expect, ans):
                 <{inputtype} size="40" correct_answer="7" label="{}" />
             </customresponse>
         </problem>
-        """.format(group_label, input1_label, input2_label, inputtype=inputtype))
+        """.format(
+                group_label, input1_label, input2_label, inputtype=inputtype
+            )
+        )
         problem = self.capa_problem(xml)
         self.assert_problem_html(problem.get_html(), group_label, input1_label, input2_label)
         self.assert_problem_data(problem.problem_data)
@@ -532,13 +567,10 @@ def test_add_to_ten(expect, ans):
     @ddt.unpack
     @ddt.data(
         {
-            'descriptions': ('desc1', 'desc2'),
-            'descriptions_html': '<description>desc1</description><description>desc2</description>'
+            "descriptions": ("desc1", "desc2"),
+            "descriptions_html": "<description>desc1</description><description>desc2</description>",
         },
-        {
-            'descriptions': (),
-            'descriptions_html': ''
-        }
+        {"descriptions": (), "descriptions_html": ""},
     )
     def test_descriptions(self, descriptions, descriptions_html):
         """
@@ -553,12 +585,14 @@ def test_descriptions(self, descriptions, descriptions_html):
                 <optioninput options="('yellow','blue','green')" correct="green" label="second label"/>
             </optionresponse>
         </problem>
-        """.format(descriptions_html=descriptions_html)
+        """.format(
+            descriptions_html=descriptions_html
+        )
         problem = self.capa_problem(xml)
         problem_html = etree.XML(problem.get_html())
 
         multi_inputs_group = problem_html.xpath('//div[@class="multi-inputs-group"]')[0]
-        description_ids = multi_inputs_group.attrib.get('aria-describedby', '').split()
+        description_ids = multi_inputs_group.attrib.get("aria-describedby", "").split()
 
         # Verify that number of descriptions matches description_ids
         assert len(description_ids) == len(descriptions)
@@ -572,42 +606,36 @@ def test_descriptions(self, descriptions, descriptions_html):
 
 @ddt.ddt
 class CAPAProblemReportHelpersTest(unittest.TestCase):
-    """ TestCase for CAPA methods for finding question labels and answer text """
+    """TestCase for CAPA methods for finding question labels and answer text"""
 
     @ddt.data(
-        ('answerid_2_1', 'label', 'label'),
-        ('answerid_2_2', 'label <some>html</some>', 'label html'),
-        ('answerid_2_2', '<more html="yes"/>label <some>html</some>', 'label html'),
-        ('answerid_2_3', None, 'Question 1'),
-        ('answerid_2_3', '', 'Question 1'),
-        ('answerid_3_3', '', 'Question 2'),
+        ("answerid_2_1", "label", "label"),
+        ("answerid_2_2", "label <some>html</some>", "label html"),
+        ("answerid_2_2", '<more html="yes"/>label <some>html</some>', "label html"),
+        ("answerid_2_3", None, "Question 1"),
+        ("answerid_2_3", "", "Question 1"),
+        ("answerid_3_3", "", "Question 2"),
     )
     @ddt.unpack
     def test_find_question_label(self, answer_id, label, stripped_label):
-        problem = new_loncapa_problem(
-            '<problem><some-problem id="{}"/></problem>'.format(answer_id)
-        )
-        mock_problem_data = {
-            answer_id: {
-                'label': HTML(label) if label else ''
-            }
-        }
-        with patch.object(problem, 'problem_data', mock_problem_data):
+        problem = new_loncapa_problem('<problem><some-problem id="{}"/></problem>'.format(answer_id))
+        mock_problem_data = {answer_id: {"label": HTML(label) if label else ""}}
+        with patch.object(problem, "problem_data", mock_problem_data):
             assert problem.find_question_label(answer_id) == stripped_label
 
     @ddt.data(None, {}, [None])
     def test_find_answer_test_not_implemented(self, current_answer):
-        problem = new_loncapa_problem('<problem/>')
-        self.assertRaises(NotImplementedError, problem.find_answer_text, '', current_answer)
+        problem = new_loncapa_problem("<problem/>")
+        self.assertRaises(NotImplementedError, problem.find_answer_text, "", current_answer)
 
     @ddt.data(
-        ('1_2_1', 'choice_0', 'over-suspicious'),
-        ('1_2_1', 'choice_1', 'funny'),
-        ('1_3_1', 'choice_0', 'The iPad'),
-        ('1_3_1', 'choice_2', 'The iPod'),
-        ('1_3_1', ['choice_0', 'choice_1'], 'The iPad, Napster'),
-        ('1_4_1', 'yellow', 'yellow'),
-        ('1_4_1', 'blue', 'blue'),
+        ("1_2_1", "choice_0", "over-suspicious"),
+        ("1_2_1", "choice_1", "funny"),
+        ("1_3_1", "choice_0", "The iPad"),
+        ("1_3_1", "choice_2", "The iPod"),
+        ("1_3_1", ["choice_0", "choice_1"], "The iPad, Napster"),
+        ("1_4_1", "yellow", "yellow"),
+        ("1_4_1", "blue", "blue"),
     )
     @ddt.unpack
     def test_find_answer_text_choices(self, answer_id, choice_id, answer_text):
@@ -637,14 +665,14 @@ def test_find_answer_text_choices(self, answer_id, choice_id, answer_text):
 
     @ddt.data(
         # Test for ChoiceResponse
-        ('1_2_1', 'choice_0', 'Answer Text Missing'),
-        ('1_2_1', 'choice_1', 'funny'),
+        ("1_2_1", "choice_0", "Answer Text Missing"),
+        ("1_2_1", "choice_1", "funny"),
         # Test for MultipleChoiceResponse
-        ('1_3_1', 'choice_0', 'The iPad'),
-        ('1_3_1', 'choice_2', 'Answer Text Missing'),
-        ('1_3_1', ['choice_0', 'choice_1'], 'The iPad, Answer Text Missing'),
+        ("1_3_1", "choice_0", "The iPad"),
+        ("1_3_1", "choice_2", "Answer Text Missing"),
+        ("1_3_1", ["choice_0", "choice_1"], "The iPad, Answer Text Missing"),
         # Test for OptionResponse
-        ('1_4_1', '', 'Answer Text Missing'),
+        ("1_4_1", "", "Answer Text Missing"),
     )
     @ddt.unpack
     def test_find_answer_text_choices_with_missing_text(self, answer_id, choice_id, answer_text):
@@ -674,11 +702,11 @@ def test_find_answer_text_choices_with_missing_text(self, answer_id, choice_id,
 
     @ddt.data(
         # Test for ChoiceResponse
-        ('1_2_1', 'over-suspicious'),
+        ("1_2_1", "over-suspicious"),
         # Test for MultipleChoiceResponse
-        ('1_3_1', 'The iPad, Napster'),
+        ("1_3_1", "The iPad, Napster"),
         # Test for OptionResponse
-        ('1_4_1', 'blue'),
+        ("1_4_1", "blue"),
     )
     @ddt.unpack
     def test_find_correct_answer_text_choices(self, answer_id, answer_text):
@@ -720,7 +748,7 @@ def test_find_answer_text_textinput(self):
             </problem>
             """
         )
-        assert problem.find_answer_text('1_2_1', 'hide') == 'hide'
+        assert problem.find_answer_text("1_2_1", "hide") == "hide"
 
     def test_get_question_answer(self):
         problem = new_loncapa_problem(
@@ -741,7 +769,7 @@ def test_get_question_answer(self):
 
         # Ensure that the answer is a string so that the dict returned from this
         # function can eventualy be serialized to json without issues.
-        assert isinstance(problem.get_question_answers()['1_solution_1'], str)
+        assert isinstance(problem.get_question_answers()["1_solution_1"], str)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
     def test_get_grade_from_current_answers(self):
@@ -751,8 +779,8 @@ def test_get_grade_from_current_answers(self):
 
         When both arguments are provided, means that the problem is being rescored.
         """
-        student_answers = {'1_2_1': 'over-suspicious'}
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=1)
+        student_answers = {"1_2_1": "over-suspicious"}
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=1)
         problem = new_loncapa_problem(
             """
             <problem>
@@ -769,8 +797,8 @@ def test_get_grade_from_current_answers(self):
         )
         responder_mock = MagicMock()
 
-        with patch.object(problem, 'responders', {'responder1': responder_mock}):
-            responder_mock.allowed_inputfields = ['choicegroup']
+        with patch.object(problem, "responders", {"responder1": responder_mock}):
+            responder_mock.allowed_inputfields = ["choicegroup"]
             responder_mock.evaluate_answers.return_value = correct_map
 
             result = problem.get_grade_from_current_answers(student_answers, correct_map)
@@ -785,7 +813,7 @@ def test_get_grade_from_current_answers_without_student_answers(self):
         When `student_answers` is None, `responder.evaluate_answers` should be called with
         the `self.student_answers` instead.
         """
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=1)
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=1)
         problem = new_loncapa_problem(
             """
             <problem>
@@ -802,9 +830,9 @@ def test_get_grade_from_current_answers_without_student_answers(self):
         )
         responder_mock = MagicMock()
 
-        with patch.object(problem, 'responders', {'responder1': responder_mock}):
-            problem.responders['responder1'].allowed_inputfields = ['choicegroup']
-            problem.responders['responder1'].evaluate_answers.return_value = correct_map
+        with patch.object(problem, "responders", {"responder1": responder_mock}):
+            problem.responders["responder1"].allowed_inputfields = ["choicegroup"]
+            problem.responders["responder1"].evaluate_answers.return_value = correct_map
 
             result = problem.get_grade_from_current_answers(None, correct_map)
 
@@ -819,7 +847,7 @@ def test_get_grade_from_current_answers_with_filesubmission(self):
 
         This ensures that rescore is not allowed if the problem has a filesubmission.
         """
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=1)
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=1)
         problem = new_loncapa_problem(
             """
             <problem>
@@ -836,8 +864,8 @@ def test_get_grade_from_current_answers_with_filesubmission(self):
         )
         responder_mock = MagicMock()
 
-        with patch.object(problem, 'responders', {'responder1': responder_mock}):
-            responder_mock.allowed_inputfields = ['filesubmission']
+        with patch.object(problem, "responders", {"responder1": responder_mock}):
+            responder_mock.allowed_inputfields = ["filesubmission"]
             responder_mock.evaluate_answers.return_value = correct_map
 
             with self.assertRaises(Exception):
diff --git a/xmodule/capa/tests/test_correctmap.py b/xmodule/capa/tests/test_correctmap.py
index 1e304ae57991..bb9fed07c869 100644
--- a/xmodule/capa/tests/test_correctmap.py
+++ b/xmodule/capa/tests/test_correctmap.py
@@ -2,10 +2,11 @@
 Tests to verify that CorrectMap behaves correctly
 """
 
-
 import datetime
 import unittest
+
 import pytest
+
 from xmodule.capa.correctmap import CorrectMap
 
 
@@ -21,81 +22,78 @@ def setUp(self):
     def test_set_input_properties(self):
         # Set the correctmap properties for three inputs
         self.cmap.set(
-            answer_id='1_2_1',
-            correctness='correct',
+            answer_id="1_2_1",
+            correctness="correct",
             npoints=5,
-            msg='Test message',
-            hint='Test hint',
-            hintmode='always',
-            queuestate={
-                'key': 'secretstring',
-                'time': '20130228100026'
-            }
+            msg="Test message",
+            hint="Test hint",
+            hintmode="always",
+            queuestate={"key": "secretstring", "time": "20130228100026"},
         )
 
         self.cmap.set(
-            answer_id='2_2_1',
-            correctness='incorrect',
+            answer_id="2_2_1",
+            correctness="incorrect",
             npoints=None,
             msg=None,
             hint=None,
             hintmode=None,
-            queuestate=None
+            queuestate=None,
         )
 
         self.cmap.set(
-            answer_id='3_2_1',
-            correctness='partially-correct',
+            answer_id="3_2_1",
+            correctness="partially-correct",
             npoints=3,
             msg=None,
             hint=None,
             hintmode=None,
-            queuestate=None
+            queuestate=None,
         )
 
         # Assert that each input has the expected properties
-        assert self.cmap.is_correct('1_2_1')
-        assert not self.cmap.is_correct('2_2_1')
-        assert self.cmap.is_correct('3_2_1')
+        assert self.cmap.is_correct("1_2_1")
+        assert not self.cmap.is_correct("2_2_1")
+        assert self.cmap.is_correct("3_2_1")
 
-        assert self.cmap.is_partially_correct('3_2_1')
-        assert not self.cmap.is_partially_correct('2_2_1')
+        assert self.cmap.is_partially_correct("3_2_1")
+        assert not self.cmap.is_partially_correct("2_2_1")
 
         # Intentionally testing an item that's not in cmap.
-        assert not self.cmap.is_partially_correct('9_2_1')
+        assert not self.cmap.is_partially_correct("9_2_1")
 
-        assert self.cmap.get_correctness('1_2_1') == 'correct'
-        assert self.cmap.get_correctness('2_2_1') == 'incorrect'
-        assert self.cmap.get_correctness('3_2_1') == 'partially-correct'
+        assert self.cmap.get_correctness("1_2_1") == "correct"
+        assert self.cmap.get_correctness("2_2_1") == "incorrect"
+        assert self.cmap.get_correctness("3_2_1") == "partially-correct"
 
-        assert self.cmap.get_npoints('1_2_1') == 5
-        assert self.cmap.get_npoints('2_2_1') == 0
-        assert self.cmap.get_npoints('3_2_1') == 3
+        assert self.cmap.get_npoints("1_2_1") == 5
+        assert self.cmap.get_npoints("2_2_1") == 0
+        assert self.cmap.get_npoints("3_2_1") == 3
 
-        assert self.cmap.get_msg('1_2_1') == 'Test message'
-        assert self.cmap.get_msg('2_2_1') is None
+        assert self.cmap.get_msg("1_2_1") == "Test message"
+        assert self.cmap.get_msg("2_2_1") is None
 
-        assert self.cmap.get_hint('1_2_1') == 'Test hint'
-        assert self.cmap.get_hint('2_2_1') is None
+        assert self.cmap.get_hint("1_2_1") == "Test hint"
+        assert self.cmap.get_hint("2_2_1") is None
 
-        assert self.cmap.get_hintmode('1_2_1') == 'always'
-        assert self.cmap.get_hintmode('2_2_1') is None
+        assert self.cmap.get_hintmode("1_2_1") == "always"
+        assert self.cmap.get_hintmode("2_2_1") is None
 
-        assert self.cmap.is_queued('1_2_1')
-        assert not self.cmap.is_queued('2_2_1')
+        assert self.cmap.is_queued("1_2_1")
+        assert not self.cmap.is_queued("2_2_1")
 
-        assert self.cmap.get_queuetime_str('1_2_1') == '20130228100026'
-        assert self.cmap.get_queuetime_str('2_2_1') is None
+        assert self.cmap.get_queuetime_str("1_2_1") == "20130228100026"
+        assert self.cmap.get_queuetime_str("2_2_1") is None
 
-        assert self.cmap.is_right_queuekey('1_2_1', 'secretstring')
-        assert not self.cmap.is_right_queuekey('1_2_1', 'invalidstr')
-        assert not self.cmap.is_right_queuekey('1_2_1', '')
-        assert not self.cmap.is_right_queuekey('1_2_1', None)
+        assert self.cmap.is_right_queuekey("1_2_1", "secretstring")
+        assert not self.cmap.is_right_queuekey("1_2_1", "invalidstr")
+        assert not self.cmap.is_right_queuekey("1_2_1", "")
+        assert not self.cmap.is_right_queuekey("1_2_1", None)
 
-        assert not self.cmap.is_right_queuekey('2_2_1', 'secretstring')
-        assert not self.cmap.is_right_queuekey('2_2_1', 'invalidstr')
-        assert not self.cmap.is_right_queuekey('2_2_1', '')
-        assert not self.cmap.is_right_queuekey('2_2_1', None)
+        assert not self.cmap.is_right_queuekey("2_2_1", "secretstring")
+        assert not self.cmap.is_right_queuekey("2_2_1", "invalidstr")
+        assert not self.cmap.is_right_queuekey("2_2_1", "")
+        assert not self.cmap.is_right_queuekey("2_2_1", None)
 
     def test_get_npoints(self):
         # Set the correctmap properties for 4 inputs
@@ -106,89 +104,58 @@ def test_get_npoints(self):
         # 5) correct, 0 points
         # 4) partially correct, 2.5 points
         # 5) partially correct, None points
-        self.cmap.set(
-            answer_id='1_2_1',
-            correctness='correct',
-            npoints=5.3
-        )
+        self.cmap.set(answer_id="1_2_1", correctness="correct", npoints=5.3)
 
-        self.cmap.set(
-            answer_id='2_2_1',
-            correctness='correct',
-            npoints=None
-        )
+        self.cmap.set(answer_id="2_2_1", correctness="correct", npoints=None)
 
-        self.cmap.set(
-            answer_id='3_2_1',
-            correctness='incorrect',
-            npoints=5
-        )
+        self.cmap.set(answer_id="3_2_1", correctness="incorrect", npoints=5)
 
-        self.cmap.set(
-            answer_id='4_2_1',
-            correctness='incorrect',
-            npoints=None
-        )
+        self.cmap.set(answer_id="4_2_1", correctness="incorrect", npoints=None)
 
-        self.cmap.set(
-            answer_id='5_2_1',
-            correctness='correct',
-            npoints=0
-        )
+        self.cmap.set(answer_id="5_2_1", correctness="correct", npoints=0)
 
-        self.cmap.set(
-            answer_id='6_2_1',
-            correctness='partially-correct',
-            npoints=2.5
-        )
+        self.cmap.set(answer_id="6_2_1", correctness="partially-correct", npoints=2.5)
 
-        self.cmap.set(
-            answer_id='7_2_1',
-            correctness='partially-correct',
-            npoints=None
-        )
+        self.cmap.set(answer_id="7_2_1", correctness="partially-correct", npoints=None)
 
         # Assert that we get the expected points
         # If points assigned --> npoints
         # If no points assigned and correct --> 1 point
         # If no points assigned and partially correct --> 1 point
         # If no points assigned and incorrect --> 0 points
-        assert self.cmap.get_npoints('1_2_1') == 5.3
-        assert self.cmap.get_npoints('2_2_1') == 1
-        assert self.cmap.get_npoints('3_2_1') == 5
-        assert self.cmap.get_npoints('4_2_1') == 0
-        assert self.cmap.get_npoints('5_2_1') == 0
-        assert self.cmap.get_npoints('6_2_1') == 2.5
-        assert self.cmap.get_npoints('7_2_1') == 1
+        assert self.cmap.get_npoints("1_2_1") == 5.3
+        assert self.cmap.get_npoints("2_2_1") == 1
+        assert self.cmap.get_npoints("3_2_1") == 5
+        assert self.cmap.get_npoints("4_2_1") == 0
+        assert self.cmap.get_npoints("5_2_1") == 0
+        assert self.cmap.get_npoints("6_2_1") == 2.5
+        assert self.cmap.get_npoints("7_2_1") == 1
 
     def test_set_overall_message(self):
 
         # Default is an empty string string
-        assert self.cmap.get_overall_message() == ''
+        assert self.cmap.get_overall_message() == ""
 
         # Set a message that applies to the whole question
         self.cmap.set_overall_message("Test message")
 
         # Retrieve the message
-        assert self.cmap.get_overall_message() == 'Test message'
+        assert self.cmap.get_overall_message() == "Test message"
 
         # Setting the message to None --> empty string
         self.cmap.set_overall_message(None)
-        assert self.cmap.get_overall_message() == ''
+        assert self.cmap.get_overall_message() == ""
 
     def test_update_from_correctmap(self):
         # Initialize a CorrectMap with some properties
         self.cmap.set(
-            answer_id='1_2_1',
-            correctness='correct',
+            answer_id="1_2_1",
+            correctness="correct",
             npoints=5,
-            msg='Test message',
-            hint='Test hint',
-            hintmode='always',
-            queuestate={
-                'key': 'secretstring',
-                'time': '20130228100026'
-            }
+            msg="Test message",
+            hint="Test hint",
+            hintmode="always",
+            queuestate={"key": "secretstring", "time": "20130228100026"},
         )
 
         self.cmap.set_overall_message("Test message")
diff --git a/xmodule/capa/tests/test_customrender.py b/xmodule/capa/tests/test_customrender.py
index 0a16f764fe05..bd602d204160 100644
--- a/xmodule/capa/tests/test_customrender.py
+++ b/xmodule/capa/tests/test_customrender.py
@@ -25,57 +25,57 @@ def quote_attr(s):
 
 
 class HelperTest(unittest.TestCase):
-    '''
+    """
     Make sure that our helper function works!
-    '''
+    """
 
     def check(self, d):
-        xml = etree.XML(mock_capa_system().render_template('blah', d))
+        xml = etree.XML(mock_capa_system().render_template("blah", d))
         assert d == extract_context(xml)
 
     def test_extract_context(self):
         self.check({})
         self.check({1, 2})
-        self.check({'id', 'an id'})
+        self.check({"id", "an id"})
         self.check({'with"quote', 'also"quote'})
 
 
 class SolutionRenderTest(unittest.TestCase):
-    '''
+    """
     Make sure solutions render properly.
-    '''
+    """
 
     def test_rendering(self):
-        solution = 'To compute unicorns, count them.'
+        solution = "To compute unicorns, count them."
         xml_str = """<solution id="solution_12">{s}</solution>""".format(s=solution)
         element = etree.fromstring(xml_str)
 
-        renderer = lookup_tag('solution')(mock_capa_system(), element)
+        renderer = lookup_tag("solution")(mock_capa_system(), element)
 
-        assert renderer.id == 'solution_12'
+        assert renderer.id == "solution_12"
 
         # Our test_capa_system "renders" templates to a div with the repr of the context.
         xml = renderer.get_html()
         context = extract_context(xml)
-        assert context == {'id': 'solution_12'}
+        assert context == {"id": "solution_12"}
 
 
 class MathRenderTest(unittest.TestCase):
-    '''
+    """
     Make sure math renders properly.
-    '''
+    """
 
     def check_parse(self, latex_in, mathjax_out):  # lint-amnesty, pylint: disable=missing-function-docstring
         xml_str = """<math>{tex}</math>""".format(tex=latex_in)
         element = etree.fromstring(xml_str)
 
-        renderer = lookup_tag('math')(mock_capa_system(), element)
+        renderer = lookup_tag("math")(mock_capa_system(), element)
 
         assert renderer.mathstr == mathjax_out
 
     def test_parsing(self):
-        self.check_parse('$abc$', '[mathjaxinline]abc[/mathjaxinline]')
-        self.check_parse('$abc', '$abc')
-        self.check_parse(r'$\displaystyle 2+2$', '[mathjax] 2+2[/mathjax]')
+        self.check_parse("$abc$", "[mathjaxinline]abc[/mathjaxinline]")
+        self.check_parse("$abc", "$abc")
+        self.check_parse(r"$\displaystyle 2+2$", "[mathjax] 2+2[/mathjax]")
 
     # NOTE: not testing get_html yet because I don't understand why it's doing what it's doing.
diff --git a/xmodule/capa/tests/test_errors.py b/xmodule/capa/tests/test_errors.py
index 222eef988dc4..002460ca4cba 100644
--- a/xmodule/capa/tests/test_errors.py
+++ b/xmodule/capa/tests/test_errors.py
@@ -3,13 +3,14 @@
 """
 
 import pytest
+
 from xmodule.capa.errors import (
+    GetSubmissionParamsError,
     JSONParsingError,
     MissingKeyError,
-    ValidationError,
-    TypeErrorSubmission,
     RuntimeErrorSubmission,
-    GetSubmissionParamsError
+    TypeErrorSubmission,
+    ValidationError,
 )
 
 
diff --git a/xmodule/capa/tests/test_hint_functionality.py b/xmodule/capa/tests/test_hint_functionality.py
index 4de183e4cf97..6a735266e4cc 100644
--- a/xmodule/capa/tests/test_hint_functionality.py
+++ b/xmodule/capa/tests/test_hint_functionality.py
@@ -5,6 +5,7 @@
 
 
 import unittest
+
 import pytest
 from ddt import data, ddt, unpack
 
@@ -23,18 +24,18 @@ class HintTest(unittest.TestCase):
     def correctness(self, problem_id, choice):
         """Grades the problem and returns the 'correctness' string from cmap."""
         student_answers = {problem_id: choice}
-        cmap = self.problem.grade_answers(answers=student_answers)    # pylint: disable=no-member
-        return cmap[problem_id]['correctness']
+        cmap = self.problem.grade_answers(answers=student_answers)  # pylint: disable=no-member
+        return cmap[problem_id]["correctness"]
 
     def get_hint(self, problem_id, choice):
         """Grades the problem and returns its hint from cmap or the empty string."""
         student_answers = {problem_id: choice}
-        cmap = self.problem.grade_answers(answers=student_answers)    # pylint: disable=no-member
+        cmap = self.problem.grade_answers(answers=student_answers)  # pylint: disable=no-member
         adict = cmap.cmap.get(problem_id)
         if adict:
-            return adict['msg']
+            return adict["msg"]
         else:
-            return ''
+            return ""
 
 
 # It is a little surprising how much more complicated TextInput is than all the other cases.
@@ -43,49 +44,69 @@ class TextInputHintsTest(HintTest):
     """
     Test Text Input Hints Test
     """
-    xml = load_fixture('extended_hints_text_input.xml')
+
+    xml = load_fixture("extended_hints_text_input.xml")
     problem = new_loncapa_problem(xml)
 
     def test_tracking_log(self):
         """Test that the tracking log comes out right."""
         self.problem.capa_block.reset_mock()
-        self.get_hint('1_3_1', 'Blue')
+        self.get_hint("1_3_1", "Blue")
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'module_id': 'i4x://Foo/bar/mock/abc',
-             'problem_part_id': '1_2',
-             'trigger_type': 'single',
-             'hint_label': 'Correct:',
-             'correctness': True,
-             'student_answer': ['Blue'],
-             'question_type': 'stringresponse',
-             'hints': [{'text': 'The red light is scattered by water molecules leaving only blue light.'}]}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_2",
+                "trigger_type": "single",
+                "hint_label": "Correct:",
+                "correctness": True,
+                "student_answer": ["Blue"],
+                "question_type": "stringresponse",
+                "hints": [{"text": "The red light is scattered by water molecules leaving only blue light."}],
+            },
         )
 
     @data(
-        {'problem_id': '1_2_1', 'choice': 'GermanyΩ',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">I do not think so.&#937;</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'franceΩ',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Viva la France!&#937;</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'FranceΩ',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Viva la France!&#937;</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'Mexico',
-         'expected_string': ''},
-        {'problem_id': '1_2_1', 'choice': 'USAΩ',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Less well known, but yes, there is a Paris, Texas.&#937;</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'usaΩ',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Less well known, but yes, there is a Paris, Texas.&#937;</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'uSAxΩ',
-         'expected_string': ''},
-        {'problem_id': '1_2_1', 'choice': 'NICKLANDΩ',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">The country name does not end in LAND&#937;</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'Blue',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">The red light is scattered by water molecules leaving only blue light.</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'blue',
-         'expected_string': ''},
-        {'problem_id': '1_3_1', 'choice': 'b',
-         'expected_string': ''},
+        {
+            "problem_id": "1_2_1",
+            "choice": "GermanyΩ",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">I do not think so.&#937;</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "franceΩ",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Viva la France!&#937;</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "FranceΩ",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Viva la France!&#937;</div></div>',
+        },
+        {"problem_id": "1_2_1", "choice": "Mexico", "expected_string": ""},
+        {
+            "problem_id": "1_2_1",
+            "choice": "USAΩ",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Less well known, but yes, there is a Paris, Texas.&#937;</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "usaΩ",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Less well known, but yes, there is a Paris, Texas.&#937;</div></div>',
+        },
+        {"problem_id": "1_2_1", "choice": "uSAxΩ", "expected_string": ""},
+        {
+            "problem_id": "1_2_1",
+            "choice": "NICKLANDΩ",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">The country name does not end in LAND&#937;</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": "Blue",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">The red light is scattered by water molecules leaving only blue light.</div></div>',
+        },
+        {"problem_id": "1_3_1", "choice": "blue", "expected_string": ""},
+        {"problem_id": "1_3_1", "choice": "b", "expected_string": ""},
     )
     @unpack
     def test_text_input_hints(self, problem_id, choice, expected_string):
@@ -96,28 +117,53 @@ def test_text_input_hints(self, problem_id, choice, expected_string):
 @ddt
 class TextInputExtendedHintsCaseInsensitive(HintTest):
     """Test Text Input Extended hints Case Insensitive"""
-    xml = load_fixture('extended_hints_text_input.xml')
+
+    xml = load_fixture("extended_hints_text_input.xml")
     problem = new_loncapa_problem(xml)
 
     @data(
-        {'problem_id': '1_5_1', 'choice': 'abc', 'expected_string': ''},  # wrong answer yielding no hint
-        {'problem_id': '1_5_1', 'choice': 'A', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Woo Hoo </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'a', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Woo Hoo </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'B', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'b', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'C', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint4</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'c', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint4</div></div>'},
+        {"problem_id": "1_5_1", "choice": "abc", "expected_string": ""},  # wrong answer yielding no hint
+        {
+            "problem_id": "1_5_1",
+            "choice": "A",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Woo Hoo </span><div class="hint-text">hint1</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "a",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Woo Hoo </span><div class="hint-text">hint1</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "B",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">hint2</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "b",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">hint2</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "C",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint4</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "c",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint4</div></div>',
+        },
         # regexp cases
-        {'problem_id': '1_5_1', 'choice': 'FGGG', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint6</div></div>'},
-        {'problem_id': '1_5_1', 'choice': 'fgG', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint6</div></div>'},
+        {
+            "problem_id": "1_5_1",
+            "choice": "FGGG",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint6</div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": "fgG",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">hint6</div></div>',
+        },
     )
     @unpack
     def test_text_input_hints(self, problem_id, choice, expected_string):
@@ -128,24 +174,37 @@ def test_text_input_hints(self, problem_id, choice, expected_string):
 @ddt
 class TextInputExtendedHintsCaseSensitive(HintTest):
     """Sometimes the semantics can be encoded in the class name."""
-    xml = load_fixture('extended_hints_text_input.xml')
+
+    xml = load_fixture("extended_hints_text_input.xml")
     problem = new_loncapa_problem(xml)
 
     @data(
-        {'problem_id': '1_6_1', 'choice': 'abc', 'expected_string': ''},
-        {'problem_id': '1_6_1', 'choice': 'A', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_6_1', 'choice': 'a', 'expected_string': ''},
-        {'problem_id': '1_6_1', 'choice': 'B', 'expected_string':
-         '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_6_1', 'choice': 'b', 'expected_string': ''},
-        {'problem_id': '1_6_1', 'choice': 'C', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>'},
-        {'problem_id': '1_6_1', 'choice': 'c', 'expected_string': ''},
+        {"problem_id": "1_6_1", "choice": "abc", "expected_string": ""},
+        {
+            "problem_id": "1_6_1",
+            "choice": "A",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>',
+        },
+        {"problem_id": "1_6_1", "choice": "a", "expected_string": ""},
+        {
+            "problem_id": "1_6_1",
+            "choice": "B",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>',
+        },
+        {"problem_id": "1_6_1", "choice": "b", "expected_string": ""},
+        {
+            "problem_id": "1_6_1",
+            "choice": "C",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>',
+        },
+        {"problem_id": "1_6_1", "choice": "c", "expected_string": ""},
         # regexp cases
-        {'problem_id': '1_6_1', 'choice': 'FGG', 'expected_string':
-         '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>'},
-        {'problem_id': '1_6_1', 'choice': 'fgG', 'expected_string': ''},
+        {
+            "problem_id": "1_6_1",
+            "choice": "FGG",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>',
+        },
+        {"problem_id": "1_6_1", "choice": "fgG", "expected_string": ""},
     )
     @unpack
     def test_text_input_hints(self, problem_id, choice, expected_string):
@@ -158,18 +217,27 @@ class TextInputExtendedHintsCompatible(HintTest):
     """
     Compatibility test with mixed old and new style additional_answer tags.
     """
-    xml = load_fixture('extended_hints_text_input.xml')
+
+    xml = load_fixture("extended_hints_text_input.xml")
     problem = new_loncapa_problem(xml)
 
     @data(
-        {'problem_id': '1_7_1', 'choice': 'A', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_7_1', 'choice': 'B', 'correct': 'correct', 'expected_string': ''},
-        {'problem_id': '1_7_1', 'choice': 'C', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_7_1', 'choice': 'D', 'correct': 'incorrect', 'expected_string': ''},
+        {
+            "problem_id": "1_7_1",
+            "choice": "A",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>',
+        },
+        {"problem_id": "1_7_1", "choice": "B", "correct": "correct", "expected_string": ""},
+        {
+            "problem_id": "1_7_1",
+            "choice": "C",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>',
+        },
+        {"problem_id": "1_7_1", "choice": "D", "correct": "incorrect", "expected_string": ""},
         # check going through conversion with difficult chars
-        {'problem_id': '1_7_1', 'choice': """<&"'>""", 'correct': 'correct', 'expected_string': ''},
+        {"problem_id": "1_7_1", "choice": """<&"'>""", "correct": "correct", "expected_string": ""},
     )
     @unpack
     def test_text_input_hints(self, problem_id, choice, correct, expected_string):
@@ -183,29 +251,66 @@ class TextInputExtendedHintsRegex(HintTest):
     """
     Extended hints where the answer is regex mode.
     """
-    xml = load_fixture('extended_hints_text_input.xml')
+
+    xml = load_fixture("extended_hints_text_input.xml")
     problem = new_loncapa_problem(xml)
 
     @data(
-        {'problem_id': '1_8_1', 'choice': 'ABwrong', 'correct': 'incorrect', 'expected_string': ''},
-        {'problem_id': '1_8_1', 'choice': 'ABC', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'ABBBBC', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'aBc', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'BBBB', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'bbb', 'correct': 'correct',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'C', 'correct': 'incorrect',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'c', 'correct': 'incorrect',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'D', 'correct': 'incorrect',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>'},
-        {'problem_id': '1_8_1', 'choice': 'd', 'correct': 'incorrect',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>'},
+        {"problem_id": "1_8_1", "choice": "ABwrong", "correct": "incorrect", "expected_string": ""},
+        {
+            "problem_id": "1_8_1",
+            "choice": "ABC",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "ABBBBC",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "aBc",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint1</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "BBBB",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "bbb",
+            "correct": "correct",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">hint2</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "C",
+            "correct": "incorrect",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "c",
+            "correct": "incorrect",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint4</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "D",
+            "correct": "incorrect",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>',
+        },
+        {
+            "problem_id": "1_8_1",
+            "choice": "d",
+            "correct": "incorrect",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">hint6</div></div>',
+        },
     )
     @unpack
     def test_text_input_hints(self, problem_id, choice, correct, expected_string):
@@ -219,35 +324,52 @@ class NumericInputHintsTest(HintTest):
     """
     This class consists of a suite of test cases to be run on the numeric input problem represented by the XML below.
     """
-    xml = load_fixture('extended_hints_numeric_input.xml')
-    problem = new_loncapa_problem(xml)          # this problem is properly constructed
+
+    xml = load_fixture("extended_hints_numeric_input.xml")
+    problem = new_loncapa_problem(xml)  # this problem is properly constructed
 
     def test_tracking_log(self):
-        self.get_hint('1_2_1', '1.141')
+        self.get_hint("1_2_1", "1.141")
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'module_id': 'i4x://Foo/bar/mock/abc', 'problem_part_id': '1_1', 'trigger_type': 'single',
-             'hint_label': 'Nice',
-             'correctness': True,
-             'student_answer': ['1.141'],
-             'question_type': 'numericalresponse',
-             'hints': [{'text': 'The square root of two turns up in the strangest places.'}]}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_1",
+                "trigger_type": "single",
+                "hint_label": "Nice",
+                "correctness": True,
+                "student_answer": ["1.141"],
+                "question_type": "numericalresponse",
+                "hints": [{"text": "The square root of two turns up in the strangest places."}],
+            },
         )
 
     @data(
-        {'problem_id': '1_2_1', 'choice': '1.141',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Nice </span><div class="hint-text">The square root of two turns up in the strangest places.</div></div>'},
+        {
+            "problem_id": "1_2_1",
+            "choice": "1.141",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Nice </span><div class="hint-text">The square root of two turns up in the strangest places.</div></div>',
+        },
         # additional answer
-        {'problem_id': '1_2_1', 'choice': '10',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">This is an additional hint.</div></div>'},
-        {'problem_id': '1_3_1', 'choice': '4',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Pretty easy, uh?.</div></div>'},
+        {
+            "problem_id": "1_2_1",
+            "choice": "10",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">This is an additional hint.</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": "4",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Pretty easy, uh?.</div></div>',
+        },
         # should get hint, when correct via numeric-tolerance
-        {'problem_id': '1_2_1', 'choice': '1.15',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Nice </span><div class="hint-text">The square root of two turns up in the strangest places.</div></div>'},
+        {
+            "problem_id": "1_2_1",
+            "choice": "1.15",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Nice </span><div class="hint-text">The square root of two turns up in the strangest places.</div></div>',
+        },
         # when they answer wrong, nothing
-        {'problem_id': '1_2_1', 'choice': '2', 'expected_string': ''},
+        {"problem_id": "1_2_1", "choice": "2", "expected_string": ""},
     )
     @unpack
     def test_numeric_input_hints(self, problem_id, choice, expected_string):
@@ -260,72 +382,139 @@ class CheckboxHintsTest(HintTest):
     """
     This class consists of a suite of test cases to be run on the checkbox problem represented by the XML below.
     """
-    xml = load_fixture('extended_hints_checkbox.xml')
-    problem = new_loncapa_problem(xml)          # this problem is properly constructed
 
-    @data(
-        {'problem_id': '1_2_1', 'choice': ['choice_0'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">You are right that apple is a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_1'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">Mushroom is a fungus, not a fruit.</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_2'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">You are right that grape is a fruit</div><div class="hint-text">What is a camero anyway?</div></div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_3'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_4'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">I do not know what a Camero is but it is not a fruit.</div></div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_0', 'choice_1'],  # compound
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Almost right </span><div class="hint-text">You are right that apple is a fruit, but there is one you are missing. Also, mushroom is not a fruit.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_1', 'choice_2'],  # compound
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">You are right that grape is a fruit, but there is one you are missing. Also, mushroom is not a fruit.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': ['choice_0', 'choice_2'],
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">You are right that apple is a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">You are right that grape is a fruit</div><div class="hint-text">What is a camero anyway?</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_0'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">No, sorry, a banana is a fruit.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_1'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_2'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_3'],
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprouts are vegetables.</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_0', 'choice_1'],  # compound
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Very funny </span><div class="hint-text">Making a banana split?</div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_1', 'choice_2'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>'},
-        {'problem_id': '1_3_1', 'choice': ['choice_0', 'choice_2'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">No, sorry, a banana is a fruit.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>'},
+    xml = load_fixture("extended_hints_checkbox.xml")
+    problem = new_loncapa_problem(xml)  # this problem is properly constructed
 
+    @data(
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_0"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">You are right that apple is a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_1"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">Mushroom is a fungus, not a fruit.</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_2"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">You are right that grape is a fruit</div><div class="hint-text">What is a camero anyway?</div></div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_3"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">What is a camero anyway?</div></div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_4"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">Remember that apple is also a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">Remember that grape is also a fruit.</div><div class="hint-text">I do not know what a Camero is but it is not a fruit.</div></div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_0", "choice_1"],  # compound
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Almost right </span><div class="hint-text">You are right that apple is a fruit, but there is one you are missing. Also, mushroom is not a fruit.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_1", "choice_2"],  # compound
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">You are right that grape is a fruit, but there is one you are missing. Also, mushroom is not a fruit.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": ["choice_0", "choice_2"],
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">You are right that apple is a fruit.</div><div class="hint-text">You are right that mushrooms are not fruit</div><div class="hint-text">You are right that grape is a fruit</div><div class="hint-text">What is a camero anyway?</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_0"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">No, sorry, a banana is a fruit.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_1"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_2"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_3"],
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">You are right that mushrooms are not vegatbles</div><div class="hint-text">Brussel sprouts are vegetables.</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_0", "choice_1"],  # compound
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Very funny </span><div class="hint-text">Making a banana split?</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_1", "choice_2"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">poor banana.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": ["choice_0", "choice_2"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">No, sorry, a banana is a fruit.</div><div class="hint-text">Mushroom is a fungus, not a vegetable.</div><div class="hint-text">Brussel sprout is the only vegetable in this list.</div></div></div>',
+        },
         # check for interaction between compoundhint and correct/incorrect
-        {'problem_id': '1_4_1', 'choice': ['choice_0', 'choice_1'],  # compound
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">AB</div></div>'},
-        {'problem_id': '1_4_1', 'choice': ['choice_0', 'choice_2'],  # compound
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">AC</div></div>'},
-
+        {
+            "problem_id": "1_4_1",
+            "choice": ["choice_0", "choice_1"],  # compound
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">AB</div></div>',
+        },
+        {
+            "problem_id": "1_4_1",
+            "choice": ["choice_0", "choice_2"],  # compound
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">AC</div></div>',
+        },
         # check for labeling where multiple child hints have labels
         # These are some tricky cases
-        {'problem_id': '1_5_1', 'choice': ['choice_0', 'choice_1'],
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">AA </span><div class="feedback-hint-multi"><div class="hint-text">aa</div></div></div>'},
-        {'problem_id': '1_5_1', 'choice': ['choice_0'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">aa</div><div class="hint-text">bb</div></div></div>'},
-        {'problem_id': '1_5_1', 'choice': ['choice_1'],
-         'expected_string': ''},
-        {'problem_id': '1_5_1', 'choice': [],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">BB </span><div class="feedback-hint-multi"><div class="hint-text">bb</div></div></div>'},
-
-        {'problem_id': '1_6_1', 'choice': ['choice_0'],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="feedback-hint-multi"><div class="hint-text">aa</div></div></div>'},
-        {'problem_id': '1_6_1', 'choice': ['choice_0', 'choice_1'],
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">compoundo</div></div>'},
-
+        {
+            "problem_id": "1_5_1",
+            "choice": ["choice_0", "choice_1"],
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">AA </span><div class="feedback-hint-multi"><div class="hint-text">aa</div></div></div>',
+        },
+        {
+            "problem_id": "1_5_1",
+            "choice": ["choice_0"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">aa</div><div class="hint-text">bb</div></div></div>',
+        },
+        {"problem_id": "1_5_1", "choice": ["choice_1"], "expected_string": ""},
+        {
+            "problem_id": "1_5_1",
+            "choice": [],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">BB </span><div class="feedback-hint-multi"><div class="hint-text">bb</div></div></div>',
+        },
+        {
+            "problem_id": "1_6_1",
+            "choice": ["choice_0"],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="feedback-hint-multi"><div class="hint-text">aa</div></div></div>',
+        },
+        {
+            "problem_id": "1_6_1",
+            "choice": ["choice_0", "choice_1"],
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><div class="hint-text">compoundo</div></div>',
+        },
         # The user selects *nothing*, but can still get "unselected" feedback
-        {'problem_id': '1_7_1', 'choice': [],
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">bb</div></div></div>'},
+        {
+            "problem_id": "1_7_1",
+            "choice": [],
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="feedback-hint-multi"><div class="hint-text">bb</div></div></div>',
+        },
         # 100% not match of sel/unsel feedback
-        {'problem_id': '1_7_1', 'choice': ['choice_1'],
-         'expected_string': ''},
+        {"problem_id": "1_7_1", "choice": ["choice_1"], "expected_string": ""},
         # Here we have the correct combination, and that makes feedback too
-        {'problem_id': '1_7_1', 'choice': ['choice_0'],
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">aa</div><div class="hint-text">bb</div></div></div>'},
+        {
+            "problem_id": "1_7_1",
+            "choice": ["choice_0"],
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="feedback-hint-multi"><div class="hint-text">aa</div><div class="hint-text">bb</div></div></div>',
+        },
     )
     @unpack
     def test_checkbox_hints(self, problem_id, choice, expected_string):
@@ -338,6 +527,7 @@ class CheckboxHintsTestTracking(HintTest):
     """
     Test the rather complicated tracking log output for checkbox cases.
     """
+
     xml = """
     <problem>
         <p>question</p>
@@ -362,59 +552,67 @@ class CheckboxHintsTestTracking(HintTest):
     def test_tracking_log(self):
         """Test checkbox tracking log - by far the most complicated case"""
         # A -> 1 hint
-        self.get_hint('1_2_1', ['choice_0'])
+        self.get_hint("1_2_1", ["choice_0"])
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'hint_label': 'Incorrect:',
-             'module_id': 'i4x://Foo/bar/mock/abc',
-             'problem_part_id': '1_1',
-             'choice_all': ['choice_0', 'choice_1', 'choice_2'],
-             'correctness': False,
-             'trigger_type': 'single',
-             'student_answer': ['choice_0'],
-             'hints': [{'text': 'A true', 'trigger': [{'choice': 'choice_0', 'selected': True}]}],
-             'question_type': 'choiceresponse'}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "hint_label": "Incorrect:",
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_1",
+                "choice_all": ["choice_0", "choice_1", "choice_2"],
+                "correctness": False,
+                "trigger_type": "single",
+                "student_answer": ["choice_0"],
+                "hints": [{"text": "A true", "trigger": [{"choice": "choice_0", "selected": True}]}],
+                "question_type": "choiceresponse",
+            },
         )
 
         # B C -> 2 hints
         self.problem.capa_block.runtime.publish.reset_mock()
-        self.get_hint('1_2_1', ['choice_1', 'choice_2'])
+        self.get_hint("1_2_1", ["choice_1", "choice_2"])
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'hint_label': 'Incorrect:',
-             'module_id': 'i4x://Foo/bar/mock/abc',
-             'problem_part_id': '1_1',
-             'choice_all': ['choice_0', 'choice_1', 'choice_2'],
-             'correctness': False,
-             'trigger_type': 'single',
-             'student_answer': ['choice_1', 'choice_2'],
-             'hints': [
-                 {'text': 'A false', 'trigger': [{'choice': 'choice_0', 'selected': False}]},
-                 {'text': 'C true', 'trigger': [{'choice': 'choice_2', 'selected': True}]}
-             ],
-             'question_type': 'choiceresponse'}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "hint_label": "Incorrect:",
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_1",
+                "choice_all": ["choice_0", "choice_1", "choice_2"],
+                "correctness": False,
+                "trigger_type": "single",
+                "student_answer": ["choice_1", "choice_2"],
+                "hints": [
+                    {"text": "A false", "trigger": [{"choice": "choice_0", "selected": False}]},
+                    {"text": "C true", "trigger": [{"choice": "choice_2", "selected": True}]},
+                ],
+                "question_type": "choiceresponse",
+            },
         )
 
         # A C -> 1 Compound hint
         self.problem.capa_block.runtime.publish.reset_mock()
-        self.get_hint('1_2_1', ['choice_0', 'choice_2'])
+        self.get_hint("1_2_1", ["choice_0", "choice_2"])
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'hint_label': 'Correct:',
-             'module_id': 'i4x://Foo/bar/mock/abc',
-             'problem_part_id': '1_1',
-             'choice_all': ['choice_0', 'choice_1', 'choice_2'],
-             'correctness': True,
-             'trigger_type': 'compound',
-             'student_answer': ['choice_0', 'choice_2'],
-             'hints': [
-                 {'text': 'A C Compound',
-                  'trigger': [{'choice': 'choice_0', 'selected': True}, {'choice': 'choice_2', 'selected': True}]}
-             ],
-             'question_type': 'choiceresponse'}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "hint_label": "Correct:",
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_1",
+                "choice_all": ["choice_0", "choice_1", "choice_2"],
+                "correctness": True,
+                "trigger_type": "compound",
+                "student_answer": ["choice_0", "choice_2"],
+                "hints": [
+                    {
+                        "text": "A C Compound",
+                        "trigger": [{"choice": "choice_0", "selected": True}, {"choice": "choice_2", "selected": True}],
+                    }
+                ],
+                "question_type": "choiceresponse",
+            },
         )
 
 
@@ -423,34 +621,52 @@ class MultpleChoiceHintsTest(HintTest):
     """
     This class consists of a suite of test cases to be run on the multiple choice problem represented by the XML below.
     """
-    xml = load_fixture('extended_hints_multiple_choice.xml')
+
+    xml = load_fixture("extended_hints_multiple_choice.xml")
     problem = new_loncapa_problem(xml)
 
     def test_tracking_log(self):
         """Test that the tracking log comes out right."""
         self.problem.capa_block.reset_mock()
-        self.get_hint('1_3_1', 'choice_2')
+        self.get_hint("1_3_1", "choice_2")
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'module_id': 'i4x://Foo/bar/mock/abc', 'problem_part_id': '1_2', 'trigger_type': 'single',
-             'student_answer': ['choice_2'], 'correctness': False, 'question_type': 'multiplechoiceresponse',
-             'hint_label': 'OOPS', 'hints': [{'text': 'Apple is a fruit.'}]}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_2",
+                "trigger_type": "single",
+                "student_answer": ["choice_2"],
+                "correctness": False,
+                "question_type": "multiplechoiceresponse",
+                "hint_label": "OOPS",
+                "hints": [{"text": "Apple is a fruit."}],
+            },
         )
 
     @data(
-        {'problem_id': '1_2_1', 'choice': 'choice_0',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">Mushroom is a fungus, not a fruit.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'choice_1',
-         'expected_string': ''},
-        {'problem_id': '1_3_1', 'choice': 'choice_1',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Potato is a root vegetable.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'choice_2',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">OUTSTANDING </span><div class="hint-text">Apple is indeed a fruit.</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'choice_2',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">OOPS </span><div class="hint-text">Apple is a fruit.</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'choice_9',
-         'expected_string': ''},
+        {
+            "problem_id": "1_2_1",
+            "choice": "choice_0",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><div class="hint-text">Mushroom is a fungus, not a fruit.</div></div>',
+        },
+        {"problem_id": "1_2_1", "choice": "choice_1", "expected_string": ""},
+        {
+            "problem_id": "1_3_1",
+            "choice": "choice_1",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">Potato is a root vegetable.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "choice_2",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">OUTSTANDING </span><div class="hint-text">Apple is indeed a fruit.</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": "choice_2",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">OOPS </span><div class="hint-text">Apple is a fruit.</div></div>',
+        },
+        {"problem_id": "1_3_1", "choice": "choice_9", "expected_string": ""},
     )
     @unpack
     def test_multiplechoice_hints(self, problem_id, choice, expected_string):
@@ -464,28 +680,45 @@ class MultpleChoiceHintsWithHtmlTest(HintTest):
     This class consists of a suite of test cases to be run on the multiple choice problem represented by the XML below.
 
     """
-    xml = load_fixture('extended_hints_multiple_choice_with_html.xml')
+
+    xml = load_fixture("extended_hints_multiple_choice_with_html.xml")
     problem = new_loncapa_problem(xml)
 
     def test_tracking_log(self):
         """Test that the tracking log comes out right."""
         self.problem.capa_block.reset_mock()
-        self.get_hint('1_2_1', 'choice_0')
+        self.get_hint("1_2_1", "choice_0")
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'module_id': 'i4x://Foo/bar/mock/abc', 'problem_part_id': '1_1', 'trigger_type': 'single',
-             'student_answer': ['choice_0'], 'correctness': False, 'question_type': 'multiplechoiceresponse',
-             'hint_label': 'Incorrect:', 'hints': [{'text': 'Mushroom <img src="#" ale="#"/>is a fungus, not a fruit.'}]}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_1",
+                "trigger_type": "single",
+                "student_answer": ["choice_0"],
+                "correctness": False,
+                "question_type": "multiplechoiceresponse",
+                "hint_label": "Incorrect:",
+                "hints": [{"text": 'Mushroom <img src="#" ale="#"/>is a fungus, not a fruit.'}],
+            },
         )
 
     @data(
-        {'problem_id': '1_2_1', 'choice': 'choice_0',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">Mushroom <img src="#" ale="#"/>is a fungus, not a fruit.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'choice_1',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">Potato is <img src="#" ale="#"/> not a fruit.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'choice_2',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text"><a href="#">Apple</a> is a fruit.</div></div>'}
+        {
+            "problem_id": "1_2_1",
+            "choice": "choice_0",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">Mushroom <img src="#" ale="#"/>is a fungus, not a fruit.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "choice_1",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">Potato is <img src="#" ale="#"/> not a fruit.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "choice_2",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text"><a href="#">Apple</a> is a fruit.</div></div>',
+        },
     )
     @unpack
     def test_multiplechoice_hints(self, problem_id, choice, expected_string):
@@ -498,42 +731,68 @@ class DropdownHintsTest(HintTest):
     """
     This class consists of a suite of test cases to be run on the drop down problem represented by the XML below.
     """
-    xml = load_fixture('extended_hints_dropdown.xml')
+
+    xml = load_fixture("extended_hints_dropdown.xml")
     problem = new_loncapa_problem(xml)
 
     def test_tracking_log(self):
         """Test that the tracking log comes out right."""
         self.problem.capa_block.reset_mock()
-        self.get_hint('1_3_1', 'FACES')
+        self.get_hint("1_3_1", "FACES")
         self.problem.capa_block.runtime.publish.assert_called_with(
             self.problem.capa_block,
-            'edx.problem.hint.feedback_displayed',
-            {'module_id': 'i4x://Foo/bar/mock/abc', 'problem_part_id': '1_2', 'trigger_type': 'single',
-             'student_answer': ['FACES'], 'correctness': True, 'question_type': 'optionresponse',
-             'hint_label': 'Correct:', 'hints': [{'text': 'With lots of makeup, doncha know?'}]}
+            "edx.problem.hint.feedback_displayed",
+            {
+                "module_id": "i4x://Foo/bar/mock/abc",
+                "problem_part_id": "1_2",
+                "trigger_type": "single",
+                "student_answer": ["FACES"],
+                "correctness": True,
+                "question_type": "optionresponse",
+                "hint_label": "Correct:",
+                "hints": [{"text": "With lots of makeup, doncha know?"}],
+            },
         )
 
     @data(
-        {'problem_id': '1_2_1', 'choice': 'Multiple Choice',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Good Job </span><div class="hint-text">Yes, multiple choice is the right answer.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'Text Input',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">No, text input problems do not present options.</div></div>'},
-        {'problem_id': '1_2_1', 'choice': 'Numerical Input',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">No, numerical input problems do not present options.</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'FACES',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">With lots of makeup, doncha know?</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'dogs',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">NOPE </span><div class="hint-text">Not dogs, not cats, not toads</div></div>'},
-        {'problem_id': '1_3_1', 'choice': 'wrongo',
-         'expected_string': ''},
-
+        {
+            "problem_id": "1_2_1",
+            "choice": "Multiple Choice",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Good Job </span><div class="hint-text">Yes, multiple choice is the right answer.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "Text Input",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">No, text input problems do not present options.</div></div>',
+        },
+        {
+            "problem_id": "1_2_1",
+            "choice": "Numerical Input",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">No, numerical input problems do not present options.</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": "FACES",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">With lots of makeup, doncha know?</div></div>',
+        },
+        {
+            "problem_id": "1_3_1",
+            "choice": "dogs",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">NOPE </span><div class="hint-text">Not dogs, not cats, not toads</div></div>',
+        },
+        {"problem_id": "1_3_1", "choice": "wrongo", "expected_string": ""},
         # Regression case where feedback includes answer substring
-        {'problem_id': '1_4_1', 'choice': 'AAA',
-         'expected_string': '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">AAABBB1</div></div>'},
-        {'problem_id': '1_4_1', 'choice': 'BBB',
-         'expected_string': '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">AAABBB2</div></div>'},
-        {'problem_id': '1_4_1', 'choice': 'not going to match',
-         'expected_string': ''},
+        {
+            "problem_id": "1_4_1",
+            "choice": "AAA",
+            "expected_string": '<div class="feedback-hint-incorrect"><div class="explanation-title">Answer</div><span class="hint-label">Incorrect: </span><div class="hint-text">AAABBB1</div></div>',
+        },
+        {
+            "problem_id": "1_4_1",
+            "choice": "BBB",
+            "expected_string": '<div class="feedback-hint-correct"><div class="explanation-title">Answer</div><span class="hint-label">Correct: </span><div class="hint-text">AAABBB2</div></div>',
+        },
+        {"problem_id": "1_4_1", "choice": "not going to match", "expected_string": ""},
     )
     @unpack
     def test_dropdown_hints(self, problem_id, choice, expected_string):
@@ -545,7 +804,8 @@ class ErrorConditionsTest(HintTest):
     """
     Erroneous xml should raise exception.
     """
+
     def test_error_conditions_illegal_element(self):
-        xml_with_errors = load_fixture('extended_hints_with_errors.xml')
+        xml_with_errors = load_fixture("extended_hints_with_errors.xml")
         with pytest.raises(Exception):
-            new_loncapa_problem(xml_with_errors)    # this problem is improperly constructed
+            new_loncapa_problem(xml_with_errors)  # this problem is improperly constructed
diff --git a/xmodule/capa/tests/test_html_render.py b/xmodule/capa/tests/test_html_render.py
index 46ad47d79ad9..322ffd7780ee 100644
--- a/xmodule/capa/tests/test_html_render.py
+++ b/xmodule/capa/tests/test_html_render.py
@@ -2,7 +2,6 @@
 CAPA HTML rendering tests.
 """
 
-
 import os
 import textwrap
 import unittest
@@ -10,9 +9,10 @@
 
 import ddt
 from lxml import etree
-from xmodule.capa.tests.helpers import new_loncapa_problem, mock_capa_system
-from xmodule.capa.tests.test_util import use_unsafe_codejail
+
 from openedx.core.djangolib.markup import HTML
+from xmodule.capa.tests.helpers import mock_capa_system, new_loncapa_problem
+from xmodule.capa.tests.test_util import use_unsafe_codejail
 
 from .response_xml_factory import CustomResponseXMLFactory, StringResponseXMLFactory
 
@@ -44,17 +44,16 @@ def test_blank_problem(self):
 
     def test_include_html(self):
         # Create a test file to include
-        self._create_test_file(
-            'test_include.xml',
-            '<test>Test include</test>'
-        )
+        self._create_test_file("test_include.xml", "<test>Test include</test>")
 
         # Generate some XML with an <include>
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
                 <include file="test_include.xml"/>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str, capa_system=self.capa_system)
@@ -64,16 +63,18 @@ def test_include_html(self):
 
         # Expect that the include file was embedded in the problem
         test_element = rendered_html.find("test")
-        assert test_element.tag == 'test'
-        assert test_element.text == 'Test include'
+        assert test_element.tag == "test"
+        assert test_element.text == "Test include"
 
     def test_process_outtext(self):
         # Generate some XML with <startouttext /> and <endouttext />
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <startouttext/>Test text<endouttext/>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str)
@@ -83,16 +84,18 @@ def test_process_outtext(self):
 
         # Expect that the <startouttext /> and <endouttext />
         # were converted to <span></span> tags
-        span_element = rendered_html.find('span')
-        assert span_element.text == 'Test text'
+        span_element = rendered_html.find("span")
+        assert span_element.text == "Test text"
 
     def test_anonymous_student_id(self):
         # make sure anonymous_student_id is rendered properly as a context variable
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <span>Welcome $anonymous_student_id</span>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str)
@@ -101,16 +104,18 @@ def test_anonymous_student_id(self):
         rendered_html = etree.XML(problem.get_html())
 
         # Expect that the anonymous_student_id was converted to "student"
-        span_element = rendered_html.find('span')
-        assert span_element.text == 'Welcome student'
+        span_element = rendered_html.find("span")
+        assert span_element.text == "Welcome student"
 
     def test_render_script(self):
         # Generate some XML with a <script> tag
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
                 <script>test=True</script>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str)
@@ -119,16 +124,18 @@ def test_render_script(self):
         rendered_html = etree.XML(problem.get_html())
 
         # Expect that the script element has been removed from the rendered HTML
-        script_element = rendered_html.find('script')
+        script_element = rendered_html.find("script")
         assert script_element is None
 
     def test_render_javascript(self):
         # Generate some XML with a <script> tag
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
                 <script type="text/javascript">function(){}</script>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str)
@@ -137,15 +144,15 @@ def test_render_javascript(self):
         rendered_html = etree.XML(problem.get_html())
 
         # expect the javascript is still present in the rendered html
-        assert '<script type="text/javascript">function(){}</script>' in etree.tostring(rendered_html).decode('utf-8')
+        assert '<script type="text/javascript">function(){}</script>' in etree.tostring(rendered_html).decode("utf-8")
 
     def test_render_response_xml(self):
         # Generate some XML for a string response
         kwargs = {
-            'question_text': "Test question",
-            'explanation_text': "Test explanation",
-            'answer': 'Test answer',
-            'hints': [('test prompt', 'test_hint', 'test hint text')]
+            "question_text": "Test question",
+            "explanation_text": "Test explanation",
+            "answer": "Test answer",
+            "hints": [("test prompt", "test_hint", "test hint text")],
         }
         xml_str = StringResponseXMLFactory().build_xml(**kwargs)
 
@@ -158,50 +165,50 @@ def test_render_response_xml(self):
         problem = new_loncapa_problem(xml_str, capa_system=the_system)
         rendered_html = etree.XML(problem.get_html())
         # Expect problem has been turned into a <div>
-        assert rendered_html.tag == 'div'
+        assert rendered_html.tag == "div"
 
         # Expect that the response has been turned into a <div> with correct attributes
-        response_element = rendered_html.find('div')
+        response_element = rendered_html.find("div")
 
-        assert response_element.tag == 'div'
-        assert response_element.attrib['aria-label'] == 'Question 1'
+        assert response_element.tag == "div"
+        assert response_element.attrib["aria-label"] == "Question 1"
 
         # Expect that the response div.wrapper-problem-response
         # that contains a <div> for the textline
-        textline_element = response_element.find('div')
-        assert textline_element.text == 'Input Template Render'
+        textline_element = response_element.find("div")
+        assert textline_element.text == "Input Template Render"
 
         # Expect a child <div> for the solution
         # with the rendered template
         solution_element = rendered_html.xpath('//div[@class="input-template-render"]')[0]
-        assert solution_element.text == 'Input Template Render'
+        assert solution_element.text == "Input Template Render"
 
         # Expect that the template renderer was called with the correct
         # arguments, once for the textline input and once for
         # the solution
         expected_textline_context = {
-            'STATIC_URL': '/dummy-static/',
-            'status': the_system.STATUS_CLASS('unsubmitted'),
-            'value': '',
-            'preprocessor': None,
-            'msg': '',
-            'inline': False,
-            'hidden': False,
-            'do_math': False,
-            'id': '1_2_1',
-            'trailing_text': '',
-            'size': None,
-            'response_data': {'label': 'Test question', 'descriptions': {}},
-            'describedby_html': HTML('aria-describedby="status_1_2_1"')
+            "STATIC_URL": "/dummy-static/",
+            "status": the_system.STATUS_CLASS("unsubmitted"),
+            "value": "",
+            "preprocessor": None,
+            "msg": "",
+            "inline": False,
+            "hidden": False,
+            "do_math": False,
+            "id": "1_2_1",
+            "trailing_text": "",
+            "size": None,
+            "response_data": {"label": "Test question", "descriptions": {}},
+            "describedby_html": HTML('aria-describedby="status_1_2_1"'),
         }
 
-        expected_solution_context = {'id': '1_solution_1'}
+        expected_solution_context = {"id": "1_solution_1"}
 
         expected_calls = [
-            mock.call('textline.html', expected_textline_context),
-            mock.call('solutionspan.html', expected_solution_context),
-            mock.call('textline.html', expected_textline_context),
-            mock.call('solutionspan.html', expected_solution_context)
+            mock.call("textline.html", expected_textline_context),
+            mock.call("solutionspan.html", expected_solution_context),
+            mock.call("textline.html", expected_textline_context),
+            mock.call("solutionspan.html", expected_solution_context),
         ]
 
         assert the_system.render_template.call_args_list == expected_calls
@@ -225,28 +232,30 @@ def test_correct_aria_label(self):
                  """
         problem = new_loncapa_problem(xml)
         rendered_html = etree.XML(problem.get_html())
-        response_elements = rendered_html.findall('div')
-        assert response_elements[0].attrib['aria-label'] == 'Question 1'
-        assert response_elements[1].attrib['aria-label'] == 'Question 2'
+        response_elements = rendered_html.findall("div")
+        assert response_elements[0].attrib["aria-label"] == "Question 1"
+        assert response_elements[1].attrib["aria-label"] == "Question 2"
 
     def test_render_response_with_overall_msg(self):
         # CustomResponse script that sets an overall_message
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(*args):
                 msg = '<p>Test message 1<br /></p><p>Test message 2</p>'
                 return {'overall_message': msg,
                         'input_list': [ {'ok': True, 'msg': '' } ] }
-        """)
+        """
+        )
 
         # Generate some XML for a CustomResponse
-        kwargs = {'script': script, 'cfn': 'check_func'}
+        kwargs = {"script": script, "cfn": "check_func"}
         xml_str = CustomResponseXMLFactory().build_xml(**kwargs)
 
         # Create the problem and render the html
         problem = new_loncapa_problem(xml_str)
 
         # Grade the problem
-        problem.grade_answers({'1_2_1': 'test'})
+        problem.grade_answers({"1_2_1": "test"})
 
         # Render the html
         rendered_html = etree.XML(problem.get_html())
@@ -254,45 +263,49 @@ def check_func(*args):
         # Expect that there is a <div> within the response <div>
         # with css class response_message
         msg_div_element = rendered_html.find(".//div[@class='response_message']")
-        assert msg_div_element.tag == 'div'
-        assert msg_div_element.get('class') == 'response_message'
+        assert msg_div_element.tag == "div"
+        assert msg_div_element.get("class") == "response_message"
 
         # Expect that the <div> contains our message (as part of the XML tree)
-        msg_p_elements = msg_div_element.findall('p')
-        assert msg_p_elements[0].tag == 'p'
-        assert msg_p_elements[0].text == 'Test message 1'
+        msg_p_elements = msg_div_element.findall("p")
+        assert msg_p_elements[0].tag == "p"
+        assert msg_p_elements[0].text == "Test message 1"
 
-        assert msg_p_elements[1].tag == 'p'
-        assert msg_p_elements[1].text == 'Test message 2'
+        assert msg_p_elements[1].tag == "p"
+        assert msg_p_elements[1].text == "Test message 2"
 
     def test_substitute_python_vars(self):
         # Generate some XML with Python variables defined in a script
         # and used later as attributes
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
                 <script>test="TEST"</script>
                 <span attr="$test"></span>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem and render the HTML
         problem = new_loncapa_problem(xml_str)
         rendered_html = etree.XML(problem.get_html())
 
         # Expect that the variable $test has been replaced with its value
-        span_element = rendered_html.find('span')
-        assert span_element.get('attr') == 'TEST'
+        span_element = rendered_html.find("span")
+        assert span_element.get("attr") == "TEST"
 
     def test_xml_comments_and_other_odd_things(self):
         # Comments and processing instructions should be skipped.
-        xml_str = textwrap.dedent("""\
+        xml_str = textwrap.dedent(
+            """\
             <?xml version="1.0" encoding="utf-8"?>
             <!DOCTYPE html []>
             <problem>
             <!-- A commment. -->
             <?ignore this processing instruction. ?>
             </problem>
-        """)
+        """
+        )
 
         # Create the problem
         problem = new_loncapa_problem(xml_str)
diff --git a/xmodule/capa/tests/test_input_templates.py b/xmodule/capa/tests/test_input_templates.py
index 3048f62095de..b47f35f2548d 100644
--- a/xmodule/capa/tests/test_input_templates.py
+++ b/xmodule/capa/tests/test_input_templates.py
@@ -2,7 +2,6 @@
 Tests for the logic in input type mako templates.
 """
 
-
 import json
 import unittest
 from collections import OrderedDict
@@ -11,9 +10,9 @@
 from mako import exceptions
 from six.moves import range
 
+from openedx.core.djangolib.markup import HTML
 from xmodule.capa.inputtypes import Status
 from xmodule.capa.tests.helpers import capa_render_template
-from openedx.core.djangolib.markup import HTML
 from xmodule.stringify import stringify_children
 
 
@@ -21,6 +20,7 @@ class TemplateError(Exception):
     """
     Error occurred while rendering a Mako template.
     """
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
 
@@ -36,16 +36,10 @@ class TemplateTestCase(unittest.TestCase):
     TEMPLATE_NAME = None
     DESCRIBEDBY = 'aria-describedby="desc-1 desc-2"'
     DESCRIPTIONS = OrderedDict(
-        [
-            ('desc-1', 'description text 1'),
-            ('desc-2', '<em>description</em> <mark>text</mark> 2')
-        ]
+        [("desc-1", "description text 1"), ("desc-2", "<em>description</em> <mark>text</mark> 2")]
     )
-    DESCRIPTION_IDS = ' '.join(list(DESCRIPTIONS.keys()))
-    RESPONSE_DATA = {
-        'label': 'question text 101',
-        'descriptions': DESCRIPTIONS
-    }
+    DESCRIPTION_IDS = " ".join(list(DESCRIPTIONS.keys()))
+    RESPONSE_DATA = {"label": "question text 101", "descriptions": DESCRIPTIONS}
 
     def setUp(self):
         """
@@ -64,7 +58,9 @@ def render_to_xml(self, context_dict):
         try:
             xml_str = capa_render_template(self.TEMPLATE_NAME, context_dict)
         except:
-            raise TemplateError(exceptions.text_error_template().render())  # lint-amnesty, pylint: disable=raise-missing-from
+            raise TemplateError(  # lint-amnesty, pylint: disable=raise-missing-from
+                exceptions.text_error_template().render()
+            )
 
         # Attempt to construct an XML tree from the template
         # This makes it easy to use XPath to make assertions, rather
@@ -74,8 +70,9 @@ def render_to_xml(self, context_dict):
         try:
             xml = etree.fromstring("<test>" + xml_str + "</test>")
         except Exception as exc:
-            raise TemplateError("Could not parse XML from '{0}': {1}".format(  # lint-amnesty, pylint: disable=raise-missing-from
-                                xml_str, str(exc)))
+            raise TemplateError(  # lint-amnesty, pylint: disable=raise-missing-from
+                "Could not parse XML from '{0}': {1}".format(xml_str, str(exc))
+            )
         return xml
 
     def assert_has_xpath(self, xml_root, xpath, context_dict, exact_num=1):
@@ -87,8 +84,12 @@ def assert_has_xpath(self, xml_root, xpath, context_dict, exact_num=1):
         `context` is used to print a debugging message
         `exact_num` is the exact number of matches to expect.
         """
-        message = ("XML does not have %d match(es) for xpath '%s'\nXML: %s\nContext: %s"
-                   % (exact_num, str(xpath), etree.tostring(xml_root), str(context_dict)))
+        message = "XML does not have %d match(es) for xpath '%s'\nXML: %s\nContext: %s" % (
+            exact_num,
+            str(xpath),
+            etree.tostring(xml_root),
+            str(context_dict),
+        )
 
         assert len(xml_root.xpath(xpath)) == exact_num, message
 
@@ -116,7 +117,7 @@ def assert_has_text(self, xml_root, xpath, text, exact=True):
         If no elements are found, the assertion fails.
         """
         element_list = xml_root.xpath(xpath)
-        assert len(element_list) > 0, ("Could not find element at '%s'\n%s" % (str(xpath), etree.tostring(xml_root)))
+        assert len(element_list) > 0, "Could not find element at '%s'\n%s" % (str(xpath), etree.tostring(xml_root))
         if exact:
             assert text == element_list[0].text.strip()
         else:
@@ -133,7 +134,7 @@ def assert_description(self, describedby_xpaths):
 
         # Verify that each description <p> tag has correct id, text and order
         descriptions = OrderedDict(
-            (tag.get('id'), stringify_children(tag)) for tag in xml.xpath('//p[@class="question-description"]')
+            (tag.get("id"), stringify_children(tag)) for tag in xml.xpath('//p[@class="question-description"]')
         )
         assert self.DESCRIPTIONS == descriptions
 
@@ -154,7 +155,7 @@ def assert_describedby_attribute(self, describedby_xpaths):
         Arguments:
             describedby_xpaths (list): list of xpaths to check aria-describedby attribute
         """
-        self.context['describedby_html'] = ''
+        self.context["describedby_html"] = ""
         xml = self.render_to_xml(self.context)
 
         # for each xpath verify that description_ids are set correctly
@@ -171,15 +172,15 @@ def assert_status(self, status_div=False, status_class=False):
             status_class (bool): check presence of status class
         """
         cases = [
-            ('correct', 'correct'),
-            ('unsubmitted', 'unanswered'),
-            ('submitted', 'submitted'),
-            ('incorrect', 'incorrect'),
-            ('incomplete', 'incorrect')
+            ("correct", "correct"),
+            ("unsubmitted", "unanswered"),
+            ("submitted", "submitted"),
+            ("incorrect", "incorrect"),
+            ("incomplete", "incorrect"),
         ]
 
         for context_status, div_class in cases:
-            self.context['status'] = Status(context_status)
+            self.context["status"] = Status(context_status)
             xml = self.render_to_xml(self.context)
 
             # Expect that we get a <div> with correct class
@@ -191,10 +192,8 @@ def assert_status(self, status_div=False, status_class=False):
             # (used to by CSS to draw the green check / red x)
             self.assert_has_text(
                 xml,
-                "//span[@class='status {}']/span[@class='sr']".format(
-                    div_class if status_class else ''
-                ),
-                self.context['status'].display_name
+                "//span[@class='status {}']/span[@class='sr']".format(div_class if status_class else ""),
+                self.context["status"].display_name,
             )
 
     def assert_label(self, xpath=None, aria_label=False):
@@ -207,33 +206,28 @@ def assert_label(self, xpath=None, aria_label=False):
         """
         labels = [
             {
-                'actual': "You see, but you do not observe. The distinction is clear.",
-                'expected': "You see, but you do not observe. The distinction is clear.",
+                "actual": "You see, but you do not observe. The distinction is clear.",
+                "expected": "You see, but you do not observe. The distinction is clear.",
             },
             {
-                'actual': "I choose to have <mark>faith</mark> because without that, I have <em>nothing</em>.",
-                'expected': "I choose to have faith because without that, I have nothing.",
-            }
+                "actual": "I choose to have <mark>faith</mark> because without that, I have <em>nothing</em>.",
+                "expected": "I choose to have faith because without that, I have nothing.",
+            },
         ]
 
-        response_data = {
-            'response_data': {
-                'descriptions': {},
-                'label': ''
-            }
-        }
+        response_data = {"response_data": {"descriptions": {}, "label": ""}}
         self.context.update(response_data)
 
         for label in labels:
-            self.context['response_data']['label'] = label['actual']
+            self.context["response_data"]["label"] = label["actual"]
             xml = self.render_to_xml(self.context)
 
             if aria_label:
-                self.assert_has_xpath(xml, "//*[@aria-label='%s']" % label['expected'], self.context)
+                self.assert_has_xpath(xml, "//*[@aria-label='%s']" % label["expected"], self.context)
             else:
                 element_list = xml.xpath(xpath)
                 assert len(element_list) == 1
-                assert stringify_children(element_list[0]) == label['actual']
+                assert stringify_children(element_list[0]) == label["actual"]
 
 
 class ChoiceGroupTemplateTest(TemplateTestCase):
@@ -241,20 +235,20 @@ class ChoiceGroupTemplateTest(TemplateTestCase):
     Test mako template for `<choicegroup>` input.
     """
 
-    TEMPLATE_NAME = 'choicegroup.html'
+    TEMPLATE_NAME = "choicegroup.html"
 
     def setUp(self):
         super(ChoiceGroupTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
-        choices = [('1', 'choice 1'), ('2', 'choice 2'), ('3', 'choice 3')]
+        choices = [("1", "choice 1"), ("2", "choice 2"), ("3", "choice 3")]
         self.context = {
-            'id': '1',
-            'choices': choices,
-            'status': Status('correct'),
-            'input_type': 'checkbox',
-            'name_array_suffix': '1',
-            'value': '3',
-            'response_data': self.RESPONSE_DATA,
-            'describedby_html': HTML(self.DESCRIBEDBY),
+            "id": "1",
+            "choices": choices,
+            "status": Status("correct"),
+            "input_type": "checkbox",
+            "name_array_suffix": "1",
+            "value": "3",
+            "response_data": self.RESPONSE_DATA,
+            "describedby_html": HTML(self.DESCRIBEDBY),
         }
 
     def test_problem_marked_correct(self):
@@ -263,9 +257,9 @@ def test_problem_marked_correct(self):
         (not a particular option) is marked correct.
         """
 
-        self.context['status'] = Status('correct')
-        self.context['input_type'] = 'checkbox'
-        self.context['value'] = ['1', '2']
+        self.context["status"] = Status("correct")
+        self.context["input_type"] = "checkbox"
+        self.context["value"] = ["1", "2"]
 
         # Should mark the entire problem correct
         xml = self.render_to_xml(self.context)
@@ -273,11 +267,9 @@ def test_problem_marked_correct(self):
         self.assert_has_xpath(xml, xpath, self.context)
 
         # Should NOT mark individual options
-        self.assert_no_xpath(xml, "//label[@class='choicegroup_incorrect']",
-                             self.context)
+        self.assert_no_xpath(xml, "//label[@class='choicegroup_incorrect']", self.context)
 
-        self.assert_no_xpath(xml, "//label[@class='choicegroup_correct']",
-                             self.context)
+        self.assert_no_xpath(xml, "//label[@class='choicegroup_correct']", self.context)
 
     def test_problem_marked_incorrect(self):
         """
@@ -285,12 +277,13 @@ def test_problem_marked_incorrect(self):
         (not a particular option) is marked incorrect.
         """
         conditions = [
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': []},
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': ['2']},
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': ['2', '3']},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': []},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': ['2']},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': ['2', '3']}]
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": []},
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": ["2"]},
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": ["2", "3"]},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": []},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": ["2"]},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": ["2", "3"]},
+        ]
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -299,13 +292,9 @@ def test_problem_marked_incorrect(self):
             self.assert_has_xpath(xml, xpath, self.context)
 
             # Should NOT mark individual options
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_incorrect']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_incorrect']", self.context)
 
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_correct']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_correct']", self.context)
 
     def test_problem_marked_unsubmitted(self):
         """
@@ -313,16 +302,17 @@ def test_problem_marked_unsubmitted(self):
         (not a particular option) is marked unanswered.
         """
         conditions = [
-            {'status': Status('unsubmitted'), 'input_type': 'radio', 'value': ''},
-            {'status': Status('unsubmitted'), 'input_type': 'radio', 'value': []},
-            {'status': Status('unsubmitted'), 'input_type': 'checkbox', 'value': []},
-            {'input_type': 'radio', 'value': ''},
-            {'input_type': 'radio', 'value': []},
-            {'input_type': 'checkbox', 'value': []},
-            {'input_type': 'checkbox', 'value': ['1']},
-            {'input_type': 'checkbox', 'value': ['1', '2']}]
+            {"status": Status("unsubmitted"), "input_type": "radio", "value": ""},
+            {"status": Status("unsubmitted"), "input_type": "radio", "value": []},
+            {"status": Status("unsubmitted"), "input_type": "checkbox", "value": []},
+            {"input_type": "radio", "value": ""},
+            {"input_type": "radio", "value": []},
+            {"input_type": "checkbox", "value": []},
+            {"input_type": "checkbox", "value": ["1"]},
+            {"input_type": "checkbox", "value": ["1", "2"]},
+        ]
 
-        self.context['status'] = Status('unanswered')
+        self.context["status"] = Status("unanswered")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -331,24 +321,18 @@ def test_problem_marked_unsubmitted(self):
             self.assert_has_xpath(xml, xpath, self.context)
 
             # Should NOT mark individual options
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_incorrect']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_incorrect']", self.context)
 
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_correct']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_correct']", self.context)
 
     def test_option_marked_correct(self):
         """
         Test conditions under which a particular option
         and the entire problem is marked correct.
         """
-        conditions = [
-            {'input_type': 'radio', 'value': '2'},
-            {'input_type': 'radio', 'value': ['2']}]
+        conditions = [{"input_type": "radio", "value": "2"}, {"input_type": "radio", "value": ["2"]}]
 
-        self.context['status'] = Status('correct')
+        self.context["status"] = Status("correct")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -365,11 +349,9 @@ def test_option_marked_incorrect(self):
         Test conditions under which a particular option
         and the entire problem is marked incorrect.
         """
-        conditions = [
-            {'input_type': 'radio', 'value': '2'},
-            {'input_type': 'radio', 'value': ['2']}]
+        conditions = [{"input_type": "radio", "value": "2"}, {"input_type": "radio", "value": ["2"]}]
 
-        self.context['status'] = Status('incorrect')
+        self.context["status"] = Status("incorrect")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -393,19 +375,20 @@ def test_never_show_correctness(self):
         """
 
         conditions = [
-            {'input_type': 'radio', 'status': Status('correct'), 'value': ''},
-            {'input_type': 'radio', 'status': Status('correct'), 'value': '2'},
-            {'input_type': 'radio', 'status': Status('correct'), 'value': ['2']},
-            {'input_type': 'radio', 'status': Status('incorrect'), 'value': '2'},
-            {'input_type': 'radio', 'status': Status('incorrect'), 'value': []},
-            {'input_type': 'radio', 'status': Status('incorrect'), 'value': ['2']},
-            {'input_type': 'checkbox', 'status': Status('correct'), 'value': []},
-            {'input_type': 'checkbox', 'status': Status('correct'), 'value': ['2']},
-            {'input_type': 'checkbox', 'status': Status('incorrect'), 'value': []},
-            {'input_type': 'checkbox', 'status': Status('incorrect'), 'value': ['2']}]
-
-        self.context['show_correctness'] = 'never'
-        self.context['submitted_message'] = 'Test message'
+            {"input_type": "radio", "status": Status("correct"), "value": ""},
+            {"input_type": "radio", "status": Status("correct"), "value": "2"},
+            {"input_type": "radio", "status": Status("correct"), "value": ["2"]},
+            {"input_type": "radio", "status": Status("incorrect"), "value": "2"},
+            {"input_type": "radio", "status": Status("incorrect"), "value": []},
+            {"input_type": "radio", "status": Status("incorrect"), "value": ["2"]},
+            {"input_type": "checkbox", "status": Status("correct"), "value": []},
+            {"input_type": "checkbox", "status": Status("correct"), "value": ["2"]},
+            {"input_type": "checkbox", "status": Status("incorrect"), "value": []},
+            {"input_type": "checkbox", "status": Status("incorrect"), "value": ["2"]},
+        ]
+
+        self.context["show_correctness"] = "never"
+        self.context["submitted_message"] = "Test message"
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -419,17 +402,12 @@ def test_never_show_correctness(self):
             self.assert_no_xpath(xml, xpath, self.context)
 
             # Should NOT mark individual options
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_incorrect']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_incorrect']", self.context)
 
-            self.assert_no_xpath(xml,
-                                 "//label[@class='choicegroup_correct']",
-                                 self.context)
+            self.assert_no_xpath(xml, "//label[@class='choicegroup_correct']", self.context)
 
             # Expect to see the message
-            self.assert_has_text(xml, "//div[@class='capa_alert']",
-                                 self.context['submitted_message'])
+            self.assert_has_text(xml, "//div[@class='capa_alert']", self.context["submitted_message"])
 
     def test_no_message_before_submission(self):
         """
@@ -438,22 +416,21 @@ def test_no_message_before_submission(self):
         """
 
         conditions = [
-            {'input_type': 'radio', 'status': Status('unsubmitted'), 'value': ''},
-            {'input_type': 'radio', 'status': Status('unsubmitted'), 'value': []},
-            {'input_type': 'checkbox', 'status': Status('unsubmitted'), 'value': []},
-
+            {"input_type": "radio", "status": Status("unsubmitted"), "value": ""},
+            {"input_type": "radio", "status": Status("unsubmitted"), "value": []},
+            {"input_type": "checkbox", "status": Status("unsubmitted"), "value": []},
             # These tests expose bug #365
             # When the bug is fixed, uncomment these cases.
-            #{'input_type': 'radio', 'status': 'unsubmitted', 'value': '2'},
-            #{'input_type': 'radio', 'status': 'unsubmitted', 'value': ['2']},
-            #{'input_type': 'radio', 'status': 'unsubmitted', 'value': '2'},
-            #{'input_type': 'radio', 'status': 'unsubmitted', 'value': ['2']},
-            #{'input_type': 'checkbox', 'status': 'unsubmitted', 'value': ['2']},
-            #{'input_type': 'checkbox', 'status': 'unsubmitted', 'value': ['2']}]
+            # {'input_type': 'radio', 'status': 'unsubmitted', 'value': '2'},
+            # {'input_type': 'radio', 'status': 'unsubmitted', 'value': ['2']},
+            # {'input_type': 'radio', 'status': 'unsubmitted', 'value': '2'},
+            # {'input_type': 'radio', 'status': 'unsubmitted', 'value': ['2']},
+            # {'input_type': 'checkbox', 'status': 'unsubmitted', 'value': ['2']},
+            # {'input_type': 'checkbox', 'status': 'unsubmitted', 'value': ['2']}]
         ]
 
-        self.context['show_correctness'] = 'never'
-        self.context['submitted_message'] = 'Test message'
+        self.context["show_correctness"] = "never"
+        self.context["submitted_message"] = "Test message"
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -472,7 +449,7 @@ def test_description(self):
         """
         Test that correct description information is set on desired elements.
         """
-        xpaths = ['//fieldset/@aria-describedby', '//label/@aria-describedby']
+        xpaths = ["//fieldset/@aria-describedby", "//label/@aria-describedby"]
         self.assert_description(xpaths)
         self.assert_describedby_attribute(xpaths)
 
@@ -488,27 +465,29 @@ class TextlineTemplateTest(TemplateTestCase):
     Test mako template for `<textline>` input.
     """
 
-    TEMPLATE_NAME = 'textline.html'
+    TEMPLATE_NAME = "textline.html"
 
     def setUp(self):
         super(TextlineTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': '1',
-            'status': Status('correct'),
-            'value': '3',
-            'preprocessor': None,
-            'trailing_text': None,
-            'response_data': self.RESPONSE_DATA,
-            'describedby_html': HTML(self.DESCRIBEDBY),
+            "id": "1",
+            "status": Status("correct"),
+            "value": "3",
+            "preprocessor": None,
+            "trailing_text": None,
+            "response_data": self.RESPONSE_DATA,
+            "describedby_html": HTML(self.DESCRIBEDBY),
         }
 
     def test_section_class(self):
-        cases = [({}, ' capa_inputtype  textline'),
-                 ({'do_math': True}, 'text-input-dynamath capa_inputtype  textline'),
-                 ({'inline': True}, ' capa_inputtype inline textline'),
-                 ({'do_math': True, 'inline': True}, 'text-input-dynamath capa_inputtype inline textline'), ]
+        cases = [
+            ({}, " capa_inputtype  textline"),
+            ({"do_math": True}, "text-input-dynamath capa_inputtype  textline"),
+            ({"inline": True}, " capa_inputtype inline textline"),
+            ({"do_math": True, "inline": True}, "text-input-dynamath capa_inputtype inline textline"),
+        ]
 
-        for (context, css_class) in cases:
+        for context, css_class in cases:
             base_context = self.context.copy()
             base_context.update(context)
             xml = self.render_to_xml(base_context)
@@ -528,7 +507,7 @@ def test_label(self):
         self.assert_label(xpath="//label[@class='problem-group-label']")
 
     def test_hidden(self):
-        self.context['hidden'] = True
+        self.context["hidden"] = True
         xml = self.render_to_xml(self.context)
 
         xpath = "//div[@style='display:none;']"
@@ -538,7 +517,7 @@ def test_hidden(self):
         self.assert_has_xpath(xml, xpath, self.context)
 
     def test_do_math(self):
-        self.context['do_math'] = True
+        self.context["do_math"] = True
         xml = self.render_to_xml(self.context)
 
         xpath = "//input[@class='mw-100 math']"
@@ -551,15 +530,14 @@ def test_do_math(self):
         self.assert_has_xpath(xml, xpath, self.context)
 
     def test_size(self):
-        self.context['size'] = '20'
+        self.context["size"] = "20"
         xml = self.render_to_xml(self.context)
 
         xpath = "//input[@size='20']"
         self.assert_has_xpath(xml, xpath, self.context)
 
     def test_preprocessor(self):
-        self.context['preprocessor'] = {'class_name': 'test_class',
-                                        'script_src': 'test_script'}
+        self.context["preprocessor"] = {"class_name": "test_class", "script_src": "test_script"}
         xml = self.render_to_xml(self.context)
 
         xpath = "//div[contains(@class, 'text-input-dynamath_data') and @data-preprocessor='test_class']"
@@ -569,24 +547,25 @@ def test_preprocessor(self):
         self.assert_has_xpath(xml, xpath, self.context)
 
     def test_do_inline_and_preprocessor(self):
-        self.context['preprocessor'] = {'class_name': 'test_class',
-                                        'script_src': 'test_script'}
-        self.context['inline'] = True
+        self.context["preprocessor"] = {"class_name": "test_class", "script_src": "test_script"}
+        self.context["inline"] = True
         xml = self.render_to_xml(self.context)
 
         xpath = "//div[contains(@class, 'text-input-dynamath_data inline') and @data-preprocessor='test_class']"
         self.assert_has_xpath(xml, xpath, self.context)
 
     def test_do_inline(self):
-        cases = [('correct', 'correct'),
-                 ('unsubmitted', 'unanswered'),
-                 ('incorrect', 'incorrect'),
-                 ('incomplete', 'incorrect')]
+        cases = [
+            ("correct", "correct"),
+            ("unsubmitted", "unanswered"),
+            ("incorrect", "incorrect"),
+            ("incomplete", "incorrect"),
+        ]
 
-        self.context['inline'] = True
+        self.context["inline"] = True
 
-        for (context_status, div_class) in cases:
-            self.context['status'] = Status(context_status)
+        for context_status, div_class in cases:
+            self.context["status"] = Status(context_status)
             xml = self.render_to_xml(self.context)
 
             # Expect that we get a <div> with correct class
@@ -594,17 +573,17 @@ def test_do_inline(self):
             self.assert_has_xpath(xml, xpath, self.context)
 
     def test_message(self):
-        self.context['msg'] = "Test message"
+        self.context["msg"] = "Test message"
         xml = self.render_to_xml(self.context)
 
         xpath = "//span[@class='message']"
-        self.assert_has_text(xml, xpath, self.context['msg'])
+        self.assert_has_text(xml, xpath, self.context["msg"])
 
     def test_description(self):
         """
         Test that correct description information is set on desired elements.
         """
-        xpaths = ['//input/@aria-describedby']
+        xpaths = ["//input/@aria-describedby"]
         self.assert_description(xpaths)
         self.assert_describedby_attribute(xpaths)
 
@@ -613,19 +592,20 @@ class FormulaEquationInputTemplateTest(TemplateTestCase):
     """
     Test make template for `<formulaequationinput>`s.
     """
-    TEMPLATE_NAME = 'formulaequationinput.html'
+
+    TEMPLATE_NAME = "formulaequationinput.html"
 
     def setUp(self):
         super(FormulaEquationInputTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': 2,
-            'value': 'PREFILLED_VALUE',
-            'status': Status('unsubmitted'),
-            'previewer': 'file.js',
-            'reported_status': 'REPORTED_STATUS',
-            'trailing_text': None,
-            'response_data': self.RESPONSE_DATA,
-            'describedby_html': HTML(self.DESCRIBEDBY),
+            "id": 2,
+            "value": "PREFILLED_VALUE",
+            "status": Status("unsubmitted"),
+            "previewer": "file.js",
+            "reported_status": "REPORTED_STATUS",
+            "trailing_text": None,
+            "response_data": self.RESPONSE_DATA,
+            "describedby_html": HTML(self.DESCRIBEDBY),
         }
 
     def test_no_size(self):
@@ -633,7 +613,7 @@ def test_no_size(self):
         self.assert_no_xpath(xml, "//input[@size]", self.context)
 
     def test_size(self):
-        self.context['size'] = '40'
+        self.context["size"] = "40"
         xml = self.render_to_xml(self.context)
 
         self.assert_has_xpath(xml, "//input[@size='40']", self.context)
@@ -642,7 +622,7 @@ def test_description(self):
         """
         Test that correct description information is set on desired elements.
         """
-        xpaths = ['//input/@aria-describedby']
+        xpaths = ["//input/@aria-describedby"]
         self.assert_description(xpaths)
         self.assert_describedby_attribute(xpaths)
 
@@ -664,25 +644,25 @@ class AnnotationInputTemplateTest(TemplateTestCase):
     Test mako template for `<annotationinput>` input.
     """
 
-    TEMPLATE_NAME = 'annotationinput.html'
+    TEMPLATE_NAME = "annotationinput.html"
 
     def setUp(self):
         super(AnnotationInputTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': 2,
-            'value': '<p>Test value</p>',
-            'title': '<h1>This is a title</h1>',
-            'text': '<p><b>This</b> is a test.</p>',
-            'comment': '<p>This is a test comment</p>',
-            'comment_prompt': '<p>This is a test comment prompt</p>',
-            'comment_value': '<p>This is the value of a test comment</p>',
-            'tag_prompt': '<p>This is a tag prompt</p>',
-            'options': [],
-            'has_options_value': False,
-            'debug': False,
-            'status': Status('unsubmitted'),
-            'return_to_annotation': False,
-            'msg': '<p>This is a test message</p>',
+            "id": 2,
+            "value": "<p>Test value</p>",
+            "title": "<h1>This is a title</h1>",
+            "text": "<p><b>This</b> is a test.</p>",
+            "comment": "<p>This is a test comment</p>",
+            "comment_prompt": "<p>This is a test comment prompt</p>",
+            "comment_value": "<p>This is the value of a test comment</p>",
+            "tag_prompt": "<p>This is a tag prompt</p>",
+            "options": [],
+            "has_options_value": False,
+            "debug": False,
+            "status": Status("unsubmitted"),
+            "return_to_annotation": False,
+            "msg": "<p>This is a test message</p>",
         }
 
     def test_return_to_annotation(self):
@@ -694,12 +674,12 @@ def test_return_to_annotation(self):
         xpath = "//a[@class='annotation-return']"
 
         # If return_to_annotation set, then show the link
-        self.context['return_to_annotation'] = True
+        self.context["return_to_annotation"] = True
         xml = self.render_to_xml(self.context)
         self.assert_has_xpath(xml, xpath, self.context)
 
         # Otherwise, do not show the links
-        self.context['return_to_annotation'] = False
+        self.context["return_to_annotation"] = False
         xml = self.render_to_xml(self.context)
         self.assert_no_xpath(xml, xpath, self.context)
 
@@ -709,12 +689,11 @@ def test_option_selection(self):
         """
 
         # Create options 0-4 and select option 2
-        self.context['options_value'] = [2]
-        self.context['options'] = [
-            {'id': id_num,
-             'choice': 'correct',
-             'description': '<p>Unescaped <b>HTML {0}</b></p>'.format(id_num)}
-            for id_num in range(5)]
+        self.context["options_value"] = [2]
+        self.context["options"] = [
+            {"id": id_num, "choice": "correct", "description": "<p>Unescaped <b>HTML {0}</b></p>".format(id_num)}
+            for id_num in range(5)
+        ]
 
         xml = self.render_to_xml(self.context)
 
@@ -723,11 +702,11 @@ def test_option_selection(self):
         # Since the HTML is unescaped, we can traverse the XML tree
         for id_num in range(5):
             xpath = "//span[@data-id='{0}']/p/b".format(id_num)
-            self.assert_has_text(xml, xpath, 'HTML {0}'.format(id_num), exact=False)
+            self.assert_has_text(xml, xpath, "HTML {0}".format(id_num), exact=False)
 
         # Expect that the correct option is selected
         xpath = "//span[contains(@class,'selected')]/p/b"
-        self.assert_has_text(xml, xpath, 'HTML 2', exact=False)
+        self.assert_has_text(xml, xpath, "HTML 2", exact=False)
 
     def test_submission_status(self):
         """
@@ -735,12 +714,10 @@ def test_submission_status(self):
         """
 
         # Test cases of `(input_status, expected_css_class)` tuples
-        test_cases = [('unsubmitted', 'unanswered'),
-                      ('incomplete', 'incorrect'),
-                      ('incorrect', 'incorrect')]
+        test_cases = [("unsubmitted", "unanswered"), ("incomplete", "incorrect"), ("incorrect", "incorrect")]
 
-        for (input_status, expected_css_class) in test_cases:
-            self.context['status'] = Status(input_status)
+        for input_status, expected_css_class in test_cases:
+            self.context["status"] = Status(input_status)
             xml = self.render_to_xml(self.context)
 
             xpath = "//span[@class='status {0}']".format(expected_css_class)
@@ -748,8 +725,8 @@ def test_submission_status(self):
 
         # If individual options are being marked, then expect
         # just the option to be marked incorrect, not the whole problem
-        self.context['has_options_value'] = True
-        self.context['status'] = Status('incorrect')
+        self.context["has_options_value"] = True
+        self.context["status"] = Status("incorrect")
         xpath = "//span[@class='incorrect']"
         xml = self.render_to_xml(self.context)
         self.assert_no_xpath(xml, xpath, self.context)
@@ -758,33 +735,33 @@ def test_display_html_comment(self):
         """
         Test that HTML comment and comment prompt render.
         """
-        self.context['comment'] = "<p>Unescaped <b>comment HTML</b></p>"
-        self.context['comment_prompt'] = "<p>Prompt <b>prompt HTML</b></p>"
-        self.context['text'] = "<p>Unescaped <b>text</b></p>"
+        self.context["comment"] = "<p>Unescaped <b>comment HTML</b></p>"
+        self.context["comment_prompt"] = "<p>Prompt <b>prompt HTML</b></p>"
+        self.context["text"] = "<p>Unescaped <b>text</b></p>"
         xml = self.render_to_xml(self.context)
 
         # Because the HTML is unescaped, we should be able to
         # descend to the <b> tag
         xpath = "//div[@class='block']/p/b"
-        self.assert_has_text(xml, xpath, 'prompt HTML')
+        self.assert_has_text(xml, xpath, "prompt HTML")
 
         xpath = "//div[@class='block block-comment']/p/b"
-        self.assert_has_text(xml, xpath, 'comment HTML')
+        self.assert_has_text(xml, xpath, "comment HTML")
 
         xpath = "//div[@class='block block-highlight']/p/b"
-        self.assert_has_text(xml, xpath, 'text')
+        self.assert_has_text(xml, xpath, "text")
 
     def test_display_html_tag_prompt(self):
         """
         Test that HTML tag prompts render.
         """
-        self.context['tag_prompt'] = "<p>Unescaped <b>HTML</b></p>"
+        self.context["tag_prompt"] = "<p>Unescaped <b>HTML</b></p>"
         xml = self.render_to_xml(self.context)
 
         # Because the HTML is unescaped, we should be able to
         # descend to the <b> tag
         xpath = "//div[@class='block']/p/b"
-        self.assert_has_text(xml, xpath, 'HTML')
+        self.assert_has_text(xml, xpath, "HTML")
 
 
 class MathStringTemplateTest(TemplateTestCase):
@@ -792,41 +769,39 @@ class MathStringTemplateTest(TemplateTestCase):
     Test mako template for `<mathstring>` input.
     """
 
-    TEMPLATE_NAME = 'mathstring.html'
+    TEMPLATE_NAME = "mathstring.html"
 
     def setUp(self):
         super(MathStringTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
-        self.context = {'isinline': False, 'mathstr': '', 'tail': ''}
+        self.context = {"isinline": False, "mathstr": "", "tail": ""}
 
     def test_math_string_inline(self):
-        self.context['isinline'] = True
-        self.context['mathstr'] = 'y = ax^2 + bx + c'
+        self.context["isinline"] = True
+        self.context["mathstr"] = "y = ax^2 + bx + c"
 
         xml = self.render_to_xml(self.context)
         xpath = "//section[@class='math-string']/span[1]"
-        self.assert_has_text(xml, xpath,
-                             '[mathjaxinline]y = ax^2 + bx + c[/mathjaxinline]')
+        self.assert_has_text(xml, xpath, "[mathjaxinline]y = ax^2 + bx + c[/mathjaxinline]")
 
     def test_math_string_not_inline(self):
-        self.context['isinline'] = False
-        self.context['mathstr'] = 'y = ax^2 + bx + c'
+        self.context["isinline"] = False
+        self.context["mathstr"] = "y = ax^2 + bx + c"
 
         xml = self.render_to_xml(self.context)
         xpath = "//section[@class='math-string']/span[1]"
-        self.assert_has_text(xml, xpath,
-                             '[mathjax]y = ax^2 + bx + c[/mathjax]')
+        self.assert_has_text(xml, xpath, "[mathjax]y = ax^2 + bx + c[/mathjax]")
 
     def test_tail_html(self):
-        self.context['tail'] = "<p>This is some <b>tail</b> <em>HTML</em></p>"
+        self.context["tail"] = "<p>This is some <b>tail</b> <em>HTML</em></p>"
         xml = self.render_to_xml(self.context)
 
         # HTML from `tail` should NOT be escaped.
         # We should be able to traverse it as part of the XML tree
         xpath = "//section[@class='math-string']/span[2]/p/b"
-        self.assert_has_text(xml, xpath, 'tail')
+        self.assert_has_text(xml, xpath, "tail")
 
         xpath = "//section[@class='math-string']/span[2]/p/em"
-        self.assert_has_text(xml, xpath, 'HTML')
+        self.assert_has_text(xml, xpath, "HTML")
 
 
 class OptionInputTemplateTest(TemplateTestCase):
@@ -834,26 +809,25 @@ class OptionInputTemplateTest(TemplateTestCase):
     Test mako template for `<optioninput>` input.
     """
 
-    TEMPLATE_NAME = 'optioninput.html'
+    TEMPLATE_NAME = "optioninput.html"
 
     def setUp(self):
         super(OptionInputTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': 2,
-            'options': [],
-            'status': Status('unsubmitted'),
-            'value': 0,
-            'default_option_text': 'Select an option',
-            'response_data': self.RESPONSE_DATA,
-            'describedby_html': HTML(self.DESCRIBEDBY),
+            "id": 2,
+            "options": [],
+            "status": Status("unsubmitted"),
+            "value": 0,
+            "default_option_text": "Select an option",
+            "response_data": self.RESPONSE_DATA,
+            "describedby_html": HTML(self.DESCRIBEDBY),
         }
 
     def test_select_options(self):
 
         # Create options 0-4, and select option 2
-        self.context['options'] = [(id_num, 'Option {0}'.format(id_num))
-                                   for id_num in range(5)]
-        self.context['value'] = 2
+        self.context["options"] = [(id_num, "Option {0}".format(id_num)) for id_num in range(5)]
+        self.context["value"] = 2
 
         xml = self.render_to_xml(self.context)
 
@@ -863,11 +837,11 @@ def test_select_options(self):
 
         for id_num in range(5):
             xpath = "//option[@value='{0}']".format(id_num)
-            self.assert_has_text(xml, xpath, 'Option {0}'.format(id_num))
+            self.assert_has_text(xml, xpath, "Option {0}".format(id_num))
 
         # Should have the correct option selected
         xpath = "//option[@selected='true']"
-        self.assert_has_text(xml, xpath, 'Option 2')
+        self.assert_has_text(xml, xpath, "Option 2")
 
     def test_status(self):
         """
@@ -885,7 +859,7 @@ def test_description(self):
         """
         Test that correct description information is set on desired elements.
         """
-        xpaths = ['//select/@aria-describedby']
+        xpaths = ["//select/@aria-describedby"]
         self.assert_description(xpaths)
         self.assert_describedby_attribute(xpaths)
 
@@ -895,27 +869,25 @@ class DragAndDropTemplateTest(TemplateTestCase):
     Test mako template for `<draganddropinput>` input.
     """
 
-    TEMPLATE_NAME = 'drag_and_drop_input.html'
+    TEMPLATE_NAME = "drag_and_drop_input.html"
 
     def setUp(self):
         super(DragAndDropTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
-        self.context = {'id': 2,
-                        'drag_and_drop_json': '',
-                        'value': 0,
-                        'status': Status('unsubmitted'),
-                        'msg': ''}
+        self.context = {"id": 2, "drag_and_drop_json": "", "value": 0, "status": Status("unsubmitted"), "msg": ""}
 
     def test_status(self):
 
         # Test cases, where each tuple represents
         # `(input_status, expected_css_class, expected_text)`
-        test_cases = [('unsubmitted', 'unanswered', 'unanswered'),
-                      ('correct', 'correct', 'correct'),
-                      ('incorrect', 'incorrect', 'incorrect'),
-                      ('incomplete', 'incorrect', 'incomplete')]
+        test_cases = [
+            ("unsubmitted", "unanswered", "unanswered"),
+            ("correct", "correct", "correct"),
+            ("incorrect", "incorrect", "incorrect"),
+            ("incomplete", "incorrect", "incomplete"),
+        ]
 
-        for (input_status, expected_css_class, expected_text) in test_cases:
-            self.context['status'] = Status(input_status)
+        for input_status, expected_css_class, expected_text in test_cases:
+            self.context["status"] = Status(input_status)
             xml = self.render_to_xml(self.context)
 
             # Expect a <div> with the status
@@ -928,57 +900,63 @@ def test_status(self):
 
     def test_drag_and_drop_json_html(self):
 
-        json_with_html = json.dumps({'test': '<p>Unescaped <b>HTML</b></p>'})
-        self.context['drag_and_drop_json'] = json_with_html
+        json_with_html = json.dumps({"test": "<p>Unescaped <b>HTML</b></p>"})
+        self.context["drag_and_drop_json"] = json_with_html
         xml = self.render_to_xml(self.context)
 
         # Assert that the JSON-encoded string was inserted without
         # escaping the HTML.  We should be able to traverse the XML tree.
         xpath = "//div[@class='drag_and_drop_problem_json']/p/b"
-        self.assert_has_text(xml, xpath, 'HTML')
+        self.assert_has_text(xml, xpath, "HTML")
 
 
 class ChoiceTextGroupTemplateTest(TemplateTestCase):
     """Test mako template for `<choicetextgroup>` input"""
 
-    TEMPLATE_NAME = 'choicetext.html'
-    VALUE_DICT = {'1_choiceinput_0bc': '1_choiceinput_0bc', '1_choiceinput_0_textinput_0': '0',
-                  '1_choiceinput_1_textinput_0': '0'}
-    EMPTY_DICT = {'1_choiceinput_0_textinput_0': '',
-                  '1_choiceinput_1_textinput_0': ''}
-    BOTH_CHOICE_CHECKBOX = {'1_choiceinput_0bc': 'choiceinput_0',
-                            '1_choiceinput_1bc': 'choiceinput_1',
-                            '1_choiceinput_0_textinput_0': '0',
-                            '1_choiceinput_1_textinput_0': '0'}
-    WRONG_CHOICE_CHECKBOX = {'1_choiceinput_1bc': 'choiceinput_1',
-                             '1_choiceinput_0_textinput_0': '0',
-                             '1_choiceinput_1_textinput_0': '0'}
+    TEMPLATE_NAME = "choicetext.html"
+    VALUE_DICT = {
+        "1_choiceinput_0bc": "1_choiceinput_0bc",
+        "1_choiceinput_0_textinput_0": "0",
+        "1_choiceinput_1_textinput_0": "0",
+    }
+    EMPTY_DICT = {"1_choiceinput_0_textinput_0": "", "1_choiceinput_1_textinput_0": ""}
+    BOTH_CHOICE_CHECKBOX = {
+        "1_choiceinput_0bc": "choiceinput_0",
+        "1_choiceinput_1bc": "choiceinput_1",
+        "1_choiceinput_0_textinput_0": "0",
+        "1_choiceinput_1_textinput_0": "0",
+    }
+    WRONG_CHOICE_CHECKBOX = {
+        "1_choiceinput_1bc": "choiceinput_1",
+        "1_choiceinput_0_textinput_0": "0",
+        "1_choiceinput_1_textinput_0": "0",
+    }
 
     def setUp(self):
         super(ChoiceTextGroupTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         choices = [
             (
-                '1_choiceinput_0bc',
+                "1_choiceinput_0bc",
                 [
-                    {'tail_text': '', 'type': 'text', 'value': '', 'contents': ''},
-                    {'tail_text': '', 'type': 'textinput', 'value': '', 'contents': 'choiceinput_0_textinput_0'},
-                ]
+                    {"tail_text": "", "type": "text", "value": "", "contents": ""},
+                    {"tail_text": "", "type": "textinput", "value": "", "contents": "choiceinput_0_textinput_0"},
+                ],
             ),
             (
-                '1_choiceinput_1bc',
+                "1_choiceinput_1bc",
                 [
-                    {'tail_text': '', 'type': 'text', 'value': '', 'contents': ''},
-                    {'tail_text': '', 'type': 'textinput', 'value': '', 'contents': 'choiceinput_1_textinput_0'},
-                ]
-            )
+                    {"tail_text": "", "type": "text", "value": "", "contents": ""},
+                    {"tail_text": "", "type": "textinput", "value": "", "contents": "choiceinput_1_textinput_0"},
+                ],
+            ),
         ]
         self.context = {
-            'id': '1',
-            'choices': choices,
-            'status': Status('correct'),
-            'input_type': 'radio',
-            'value': self.VALUE_DICT,
-            'response_data': self.RESPONSE_DATA
+            "id": "1",
+            "choices": choices,
+            "status": Status("correct"),
+            "input_type": "radio",
+            "value": self.VALUE_DICT,
+            "response_data": self.RESPONSE_DATA,
         }
 
     def test_grouping_tag(self):
@@ -986,13 +964,13 @@ def test_grouping_tag(self):
         Tests whether we are using a section or a label to wrap choice elements.
         Section is used for checkbox, so inputting text does not deselect
         """
-        input_tags = ('radio', 'checkbox')
-        self.context['status'] = Status('correct')
+        input_tags = ("radio", "checkbox")
+        self.context["status"] = Status("correct")
         xpath = "//section[@id='forinput1_choiceinput_0bc']"
 
-        self.context['value'] = {}
+        self.context["value"] = {}
         for input_type in input_tags:
-            self.context['input_type'] = input_type
+            self.context["input_type"] = input_type
             xml = self.render_to_xml(self.context)
             self.assert_has_xpath(xml, xpath, self.context)
 
@@ -1000,9 +978,9 @@ def test_problem_marked_correct(self):
         """Test conditions under which the entire problem
         (not a particular option) is marked correct"""
 
-        self.context['status'] = Status('correct')
-        self.context['input_type'] = 'checkbox'
-        self.context['value'] = self.VALUE_DICT
+        self.context["status"] = Status("correct")
+        self.context["input_type"] = "checkbox"
+        self.context["value"] = self.VALUE_DICT
 
         # Should mark the entire problem correct
         xml = self.render_to_xml(self.context)
@@ -1010,25 +988,24 @@ def test_problem_marked_correct(self):
         self.assert_has_xpath(xml, xpath, self.context)
 
         # Should NOT mark individual options
-        self.assert_no_xpath(xml, "//label[@class='choicetextgroup_incorrect']",
-                             self.context)
+        self.assert_no_xpath(xml, "//label[@class='choicetextgroup_incorrect']", self.context)
 
-        self.assert_no_xpath(xml, "//label[@class='choicetextgroup_correct']",
-                             self.context)
+        self.assert_no_xpath(xml, "//label[@class='choicetextgroup_correct']", self.context)
 
     def test_problem_marked_incorrect(self):
         """Test all conditions under which the entire problem
         (not a particular option) is marked incorrect"""
-        grouping_tags = {'radio': 'label', 'checkbox': 'section'}
+        grouping_tags = {"radio": "label", "checkbox": "section"}
         conditions = [
-            {'status': Status('incorrect'), 'input_type': 'radio', 'value': {}},
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': self.WRONG_CHOICE_CHECKBOX},
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': self.BOTH_CHOICE_CHECKBOX},
-            {'status': Status('incorrect'), 'input_type': 'checkbox', 'value': self.VALUE_DICT},
-            {'status': Status('incomplete'), 'input_type': 'radio', 'value': {}},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': self.WRONG_CHOICE_CHECKBOX},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': self.BOTH_CHOICE_CHECKBOX},
-            {'status': Status('incomplete'), 'input_type': 'checkbox', 'value': self.VALUE_DICT}]
+            {"status": Status("incorrect"), "input_type": "radio", "value": {}},
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": self.WRONG_CHOICE_CHECKBOX},
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": self.BOTH_CHOICE_CHECKBOX},
+            {"status": Status("incorrect"), "input_type": "checkbox", "value": self.VALUE_DICT},
+            {"status": Status("incomplete"), "input_type": "radio", "value": {}},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": self.WRONG_CHOICE_CHECKBOX},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": self.BOTH_CHOICE_CHECKBOX},
+            {"status": Status("incomplete"), "input_type": "checkbox", "value": self.VALUE_DICT},
+        ]
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -1037,30 +1014,26 @@ def test_problem_marked_incorrect(self):
             self.assert_has_xpath(xml, xpath, self.context)
 
             # Should NOT mark individual options
-            grouping_tag = grouping_tags[test_conditions['input_type']]
-            self.assert_no_xpath(xml,
-                                 "//{0}[@class='choicetextgroup_incorrect']".format(grouping_tag),
-                                 self.context)
+            grouping_tag = grouping_tags[test_conditions["input_type"]]
+            self.assert_no_xpath(xml, "//{0}[@class='choicetextgroup_incorrect']".format(grouping_tag), self.context)
 
-            self.assert_no_xpath(xml,
-                                 "//{0}[@class='choicetextgroup_correct']".format(grouping_tag),
-                                 self.context)
+            self.assert_no_xpath(xml, "//{0}[@class='choicetextgroup_correct']".format(grouping_tag), self.context)
 
     def test_problem_marked_unsubmitted(self):
         """Test all conditions under which the entire problem
         (not a particular option) is marked unanswered"""
-        grouping_tags = {'radio': 'label', 'checkbox': 'section'}
+        grouping_tags = {"radio": "label", "checkbox": "section"}
 
         conditions = [
-            {'status': Status('unsubmitted'), 'input_type': 'radio', 'value': {}},
-            {'status': Status('unsubmitted'), 'input_type': 'radio', 'value': self.EMPTY_DICT},
-            {'status': Status('unsubmitted'), 'input_type': 'checkbox', 'value': {}},
-            {'status': Status('unsubmitted'), 'input_type': 'checkbox', 'value': self.EMPTY_DICT},
-            {'status': Status('unsubmitted'), 'input_type': 'checkbox', 'value': self.VALUE_DICT},
-            {'status': Status('unsubmitted'), 'input_type': 'checkbox', 'value': self.BOTH_CHOICE_CHECKBOX},
+            {"status": Status("unsubmitted"), "input_type": "radio", "value": {}},
+            {"status": Status("unsubmitted"), "input_type": "radio", "value": self.EMPTY_DICT},
+            {"status": Status("unsubmitted"), "input_type": "checkbox", "value": {}},
+            {"status": Status("unsubmitted"), "input_type": "checkbox", "value": self.EMPTY_DICT},
+            {"status": Status("unsubmitted"), "input_type": "checkbox", "value": self.VALUE_DICT},
+            {"status": Status("unsubmitted"), "input_type": "checkbox", "value": self.BOTH_CHOICE_CHECKBOX},
         ]
 
-        self.context['status'] = Status('unanswered')
+        self.context["status"] = Status("unanswered")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -1069,23 +1042,18 @@ def test_problem_marked_unsubmitted(self):
             self.assert_has_xpath(xml, xpath, self.context)
 
             # Should NOT mark individual options
-            grouping_tag = grouping_tags[test_conditions['input_type']]
-            self.assert_no_xpath(xml,
-                                 "//{0}[@class='choicetextgroup_incorrect']".format(grouping_tag),
-                                 self.context)
+            grouping_tag = grouping_tags[test_conditions["input_type"]]
+            self.assert_no_xpath(xml, "//{0}[@class='choicetextgroup_incorrect']".format(grouping_tag), self.context)
 
-            self.assert_no_xpath(xml,
-                                 "//{0}[@class='choicetextgroup_correct']".format(grouping_tag),
-                                 self.context)
+            self.assert_no_xpath(xml, "//{0}[@class='choicetextgroup_correct']".format(grouping_tag), self.context)
 
     def test_option_marked_correct(self):
         """Test conditions under which a particular option
         (not the entire problem) is marked correct."""
 
-        conditions = [
-            {'input_type': 'radio', 'value': self.VALUE_DICT}]
+        conditions = [{"input_type": "radio", "value": self.VALUE_DICT}]
 
-        self.context['status'] = Status('correct')
+        self.context["status"] = Status("correct")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -1102,10 +1070,9 @@ def test_option_marked_incorrect(self):
         """Test conditions under which a particular option
         (not the entire problem) is marked incorrect."""
 
-        conditions = [
-            {'input_type': 'radio', 'value': self.VALUE_DICT}]
+        conditions = [{"input_type": "radio", "value": self.VALUE_DICT}]
 
-        self.context['status'] = Status('incorrect')
+        self.context["status"] = Status("incorrect")
 
         for test_conditions in conditions:
             self.context.update(test_conditions)
@@ -1128,15 +1095,15 @@ def test_aria_label(self):
 class ChemicalEquationTemplateTest(TemplateTestCase):
     """Test mako template for `<chemicalequationinput>` input"""
 
-    TEMPLATE_NAME = 'chemicalequationinput.html'
+    TEMPLATE_NAME = "chemicalequationinput.html"
 
     def setUp(self):
         super(ChemicalEquationTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': '1',
-            'status': Status('correct'),
-            'previewer': 'dummy.js',
-            'value': '101',
+            "id": "1",
+            "status": Status("correct"),
+            "previewer": "dummy.js",
+            "value": "101",
         }
 
     def test_aria_label(self):
@@ -1149,24 +1116,24 @@ def test_aria_label(self):
 class SchematicInputTemplateTest(TemplateTestCase):
     """Test mako template for `<schematic>` input"""
 
-    TEMPLATE_NAME = 'schematicinput.html'
+    TEMPLATE_NAME = "schematicinput.html"
 
     def setUp(self):
         super(SchematicInputTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': '1',
-            'status': Status('correct'),
-            'previewer': 'dummy.js',
-            'value': '101',
-            'STATIC_URL': '/dummy-static/',
-            'msg': '',
-            'initial_value': 'two large batteries',
-            'width': '100',
-            'height': '100',
-            'parts': 'resistors, capacitors, and flowers',
-            'setup_script': '/dummy-static/js/capa/schematicinput.js',
-            'analyses': 'fast, slow, and pink',
-            'submit_analyses': 'maybe',
+            "id": "1",
+            "status": Status("correct"),
+            "previewer": "dummy.js",
+            "value": "101",
+            "STATIC_URL": "/dummy-static/",
+            "msg": "",
+            "initial_value": "two large batteries",
+            "width": "100",
+            "height": "100",
+            "parts": "resistors, capacitors, and flowers",
+            "setup_script": "/dummy-static/js/capa/schematicinput.js",
+            "analyses": "fast, slow, and pink",
+            "submit_analyses": "maybe",
         }
 
     def test_aria_label(self):
@@ -1181,25 +1148,25 @@ class CodeinputTemplateTest(TemplateTestCase):
     Test mako template for `<textbox>` input
     """
 
-    TEMPLATE_NAME = 'codeinput.html'
+    TEMPLATE_NAME = "codeinput.html"
 
     def setUp(self):
         super(CodeinputTemplateTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.context = {
-            'id': '1',
-            'status': Status('correct'),
-            'mode': 'parrot',
-            'linenumbers': 'false',
-            'rows': '37',
-            'cols': '11',
-            'tabsize': '7',
-            'hidden': '',
-            'msg': '',
-            'value': 'print "good evening"',
-            'aria_label': 'python editor',
-            'code_mirror_exit_message': 'Press ESC then TAB or click outside of the code editor to exit',
-            'response_data': self.RESPONSE_DATA,
-            'describedby': HTML(self.DESCRIBEDBY),
+            "id": "1",
+            "status": Status("correct"),
+            "mode": "parrot",
+            "linenumbers": "false",
+            "rows": "37",
+            "cols": "11",
+            "tabsize": "7",
+            "hidden": "",
+            "msg": "",
+            "value": 'print "good evening"',
+            "aria_label": "python editor",
+            "code_mirror_exit_message": "Press ESC then TAB or click outside of the code editor to exit",
+            "response_data": self.RESPONSE_DATA,
+            "describedby": HTML(self.DESCRIBEDBY),
         }
 
     def test_label(self):
@@ -1213,4 +1180,4 @@ def test_editor_exit_message(self):
         Verify that editor exit message is rendered.
         """
         xml = self.render_to_xml(self.context)
-        self.assert_has_text(xml, '//span[@id="cm-editor-exit-message-1"]', self.context['code_mirror_exit_message'])
+        self.assert_has_text(xml, '//span[@id="cm-editor-exit-message-1"]', self.context["code_mirror_exit_message"])
diff --git a/xmodule/capa/tests/test_inputtypes.py b/xmodule/capa/tests/test_inputtypes.py
index 523f303b45e3..c6b2b705adee 100644
--- a/xmodule/capa/tests/test_inputtypes.py
+++ b/xmodule/capa/tests/test_inputtypes.py
@@ -32,11 +32,11 @@
 from pyparsing import ParseException
 from six.moves import zip
 
+from openedx.core.djangolib.markup import HTML
 from xmodule.capa import inputtypes
 from xmodule.capa.checker import DemoSystem
 from xmodule.capa.tests.helpers import mock_capa_system
 from xmodule.capa.xqueue_interface import XQUEUE_TIMEOUT
-from openedx.core.djangolib.markup import HTML
 
 # just a handy shortcut
 lookup_tag = inputtypes.registry.get_class_for_tag
@@ -45,11 +45,8 @@
 DESCRIBEDBY = HTML('aria-describedby="status_{status_id} desc-1 desc-2"')
 # Use TRAILING_TEXT_DESCRIBEDBY when trailing_text is not null
 TRAILING_TEXT_DESCRIBEDBY = HTML('aria-describedby="trailing_text_{trailing_text_id} status_{status_id} desc-1 desc-2"')
-DESCRIPTIONS = OrderedDict([('desc-1', 'description text 1'), ('desc-2', 'description text 2')])
-RESPONSE_DATA = {
-    'label': 'question text 101',
-    'descriptions': DESCRIPTIONS
-}
+DESCRIPTIONS = OrderedDict([("desc-1", "description text 1"), ("desc-2", "description text 2")])
+RESPONSE_DATA = {"label": "question text 101", "descriptions": DESCRIPTIONS}
 
 
 def quote_attr(s):
@@ -66,27 +63,27 @@ def test_rendering(self):
         element = etree.fromstring(xml_str)
 
         state = {
-            'value': 'Down',
-            'id': 'sky_input',
-            'status': 'answered',
-            'default_option_text': 'Select an option',
-            'response_data': RESPONSE_DATA
+            "value": "Down",
+            "id": "sky_input",
+            "status": "answered",
+            "default_option_text": "Select an option",
+            "response_data": RESPONSE_DATA,
         }
-        option_input = lookup_tag('optioninput')(mock_capa_system(), element, state)
+        option_input = lookup_tag("optioninput")(mock_capa_system(), element, state)
 
         context = option_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'sky_input'
+        prob_id = "sky_input"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'value': 'Down',
-            'options': [('Up', 'Up'), ('Down', 'Down'), ('Don\'t know', 'Don\'t know')],
-            'status': inputtypes.Status('answered'),
-            'msg': '',
-            'inline': False,
-            'id': prob_id,
-            'default_option_text': 'Select an option',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id='sky_input')
+            "STATIC_URL": "/dummy-static/",
+            "value": "Down",
+            "options": [("Up", "Up"), ("Down", "Down"), ("Don't know", "Don't know")],
+            "status": inputtypes.Status("answered"),
+            "msg": "",
+            "inline": False,
+            "id": prob_id,
+            "default_option_text": "Select an option",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id="sky_input"),
         }
 
         assert context == expected
@@ -101,18 +98,18 @@ def check(input, options):  # lint-amnesty, pylint: disable=redefined-builtin
             expected = [(o, o) for o in options]
             assert f(input) == expected
 
-        check("('a','b')", ['a', 'b'])
-        check("('a', 'b')", ['a', 'b'])
-        check("('a b','b')", ['a b', 'b'])
-        check("('My \"quoted\"place','b')", ['My \"quoted\"place', 'b'])
-        check("('б','в')", ['б', 'в'])
-        check("('б', 'в')", ['б', 'в'])
-        check("('б в','в')", ['б в', 'в'])
-        check("('Мой \"кавыки\"место','в')", ['Мой \"кавыки\"место', 'в'])
+        check("('a','b')", ["a", "b"])
+        check("('a', 'b')", ["a", "b"])
+        check("('a b','b')", ["a b", "b"])
+        check("('My \"quoted\"place','b')", ['My "quoted"place', "b"])
+        check("('б','в')", ["б", "в"])
+        check("('б', 'в')", ["б", "в"])
+        check("('б в','в')", ["б в", "в"])
+        check("('Мой \"кавыки\"место','в')", ['Мой "кавыки"место', "в"])
 
         # check that escaping single quotes with leading backslash (\') properly works
         # note: actual input by user will be hasn\'t but json parses it as hasn\\'t
-        check("('hasnt','hasn't')", ['hasnt', 'hasn\'t'])
+        check("('hasnt','hasn't')", ["hasnt", "hasn't"])
 
 
 class ChoiceGroupTest(unittest.TestCase):
@@ -120,7 +117,9 @@ class ChoiceGroupTest(unittest.TestCase):
     Test choice groups, radio groups, and checkbox groups
     """
 
-    def check_group(self, tag, expected_input_type, expected_suffix):  # lint-amnesty, pylint: disable=missing-function-docstring
+    def check_group(
+        self, tag, expected_input_type, expected_suffix
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring
         xml_str = """
   <{tag}>
     <choice correct="false" name="foil1"><text>This is foil One.</text></choice>
@@ -128,48 +127,47 @@ def check_group(self, tag, expected_input_type, expected_suffix):  # lint-amnest
     <choice correct="true" name="foil3">This is foil Three.</choice>
     <choice correct="false" name="foil4">This is <b>foil</b> Four.</choice>
   </{tag}>
-        """.format(tag=tag)
+        """.format(
+            tag=tag
+        )
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': 'foil3',
-            'id': 'sky_input',
-            'status': 'answered',
-            'response_data': RESPONSE_DATA
-        }
+        state = {"value": "foil3", "id": "sky_input", "status": "answered", "response_data": RESPONSE_DATA}
 
         the_input = lookup_tag(tag)(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
 
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': 'sky_input',
-            'value': 'foil3',
-            'status': inputtypes.Status('answered'),
-            'msg': '',
-            'input_type': expected_input_type,
-            'choices': [('foil1', '<text>This is foil One.</text>'),
-                        ('foil2', '<text>This is foil Two.</text>'),
-                        ('foil3', 'This is foil Three.'),
-                        ('foil4', 'This is <b>foil</b> Four.'), ],
-            'show_correctness': 'always',
-            'submitted_message': 'Answer received.',
-            'name_array_suffix': expected_suffix,   # what is this for??
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id='sky_input')
+            "STATIC_URL": "/dummy-static/",
+            "id": "sky_input",
+            "value": "foil3",
+            "status": inputtypes.Status("answered"),
+            "msg": "",
+            "input_type": expected_input_type,
+            "choices": [
+                ("foil1", "<text>This is foil One.</text>"),
+                ("foil2", "<text>This is foil Two.</text>"),
+                ("foil3", "This is foil Three."),
+                ("foil4", "This is <b>foil</b> Four."),
+            ],
+            "show_correctness": "always",
+            "submitted_message": "Answer received.",
+            "name_array_suffix": expected_suffix,  # what is this for??
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id="sky_input"),
         }
 
         assert context == expected
 
     def test_choicegroup(self):
-        self.check_group('choicegroup', 'radio', '')
+        self.check_group("choicegroup", "radio", "")
 
     def test_radiogroup(self):
-        self.check_group('radiogroup', 'radio', '[]')
+        self.check_group("radiogroup", "radio", "[]")
 
     def test_checkboxgroup(self):
-        self.check_group('checkboxgroup', 'checkbox', '[]')
+        self.check_group("checkboxgroup", "checkbox", "[]")
 
 
 class JSInputTest(unittest.TestCase):
@@ -183,15 +181,15 @@ def test_rendering_default_values(self):
         """
         xml_str = '<jsinput id="prob_1_2"/>'
         expected = {
-            'html_file': None,
-            'gradefn': "gradefn",
-            'get_statefn': None,
-            'set_statefn': None,
-            'initial_state': None,
-            'width': "400",
-            'height': "300",
-            'title': "Problem Remote Content",
-            'sop': None
+            "html_file": None,
+            "gradefn": "gradefn",
+            "get_statefn": None,
+            "set_statefn": None,
+            "initial_state": None,
+            "width": "400",
+            "height": "300",
+            "title": "Problem Remote Content",
+            "sop": None,
         }
 
         self._render_context_test(xml_str, expected)
@@ -211,15 +209,15 @@ def test_rendering_provided_values(self):
         """
 
         expected = {
-            'html_file': "https://studio.edx.org/c4x/edX/DemoX/asset/webGLDemo.html",
-            'gradefn': "WebGLDemo.getGrade",
-            'get_statefn': "WebGLDemo.getState",
-            'set_statefn': "WebGLDemo.setState",
-            'initial_state': '{"selectedObjects":{"cube":true,"cylinder":false}}',
-            'width': "1000",
-            'height': "1200",
-            'title': "Awesome and fun!",
-            'sop': 'false'
+            "html_file": "https://studio.edx.org/c4x/edX/DemoX/asset/webGLDemo.html",
+            "gradefn": "WebGLDemo.getGrade",
+            "get_statefn": "WebGLDemo.getState",
+            "set_statefn": "WebGLDemo.setState",
+            "initial_state": '{"selectedObjects":{"cube":true,"cylinder":false}}',
+            "width": "1000",
+            "height": "1200",
+            "title": "Awesome and fun!",
+            "sop": "false",
         }
 
         self._render_context_test(xml_str, expected)
@@ -229,26 +227,23 @@ def _render_context_test(self, xml_str, expected_context):
         Helper method for testing context based on the provided XML string.
         """
         element = etree.fromstring(xml_str)
-        state = {
-            'value': 103,
-            'response_data': RESPONSE_DATA
-        }
-        the_input = lookup_tag('jsinput')(mock_capa_system(), element, state)
+        state = {"value": 103, "response_data": RESPONSE_DATA}
+        the_input = lookup_tag("jsinput")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
 
         full_expected_context = {
-            'STATIC_URL': '/dummy-static/',
-            'id': 'prob_1_2',
-            'status': inputtypes.Status('unanswered'),
-            'describedby_html': DESCRIBEDBY.format(status_id='prob_1_2'),
-            'msg': "",
-            'params': None,
-            'jschannel_loader': '/dummy-static/js/capa/src/jschannel.js',
-            'jsinput_loader': '/dummy-static/js/capa/src/jsinput.js',
-            'saved_state': 103,
-            'response_data': RESPONSE_DATA,
-            'value': 103
+            "STATIC_URL": "/dummy-static/",
+            "id": "prob_1_2",
+            "status": inputtypes.Status("unanswered"),
+            "describedby_html": DESCRIBEDBY.format(status_id="prob_1_2"),
+            "msg": "",
+            "params": None,
+            "jschannel_loader": "/dummy-static/js/capa/src/jschannel.js",
+            "jsinput_loader": "/dummy-static/js/capa/src/jsinput.js",
+            "saved_state": 103,
+            "response_data": RESPONSE_DATA,
+            "value": 103,
         }
         full_expected_context.update(expected_context)
 
@@ -266,28 +261,25 @@ def test_rendering(self):
 
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': 'BumbleBee',
-            'response_data': RESPONSE_DATA
-        }
-        the_input = lookup_tag('textline')(mock_capa_system(), element, state)
+        state = {"value": "BumbleBee", "response_data": RESPONSE_DATA}
+        the_input = lookup_tag("textline")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'BumbleBee',
-            'status': inputtypes.Status('unanswered'),
-            'size': size,
-            'msg': '',
-            'hidden': False,
-            'inline': False,
-            'do_math': False,
-            'trailing_text': '',
-            'preprocessor': None,
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": "BumbleBee",
+            "status": inputtypes.Status("unanswered"),
+            "size": size,
+            "msg": "",
+            "hidden": False,
+            "inline": False,
+            "do_math": False,
+            "trailing_text": "",
+            "preprocessor": None,
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
         assert context == expected
 
@@ -298,35 +290,34 @@ def test_math_rendering(self):
 
         xml_str = """<textline math="True" id="prob_1_2" size="{size}"
         preprocessorClassName="{pp}"
-        preprocessorSrc="{sc}"/>""".format(size=size, pp=preprocessorClass, sc=script)
+        preprocessorSrc="{sc}"/>""".format(
+            size=size, pp=preprocessorClass, sc=script
+        )
 
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': 'BumbleBee',
-            'response_data': RESPONSE_DATA
-        }
-        the_input = lookup_tag('textline')(mock_capa_system(), element, state)
+        state = {"value": "BumbleBee", "response_data": RESPONSE_DATA}
+        the_input = lookup_tag("textline")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'BumbleBee',
-            'status': inputtypes.Status('unanswered'),
-            'size': size,
-            'msg': '',
-            'hidden': False,
-            'inline': False,
-            'trailing_text': '',
-            'do_math': True,
-            'preprocessor': {
-                'class_name': preprocessorClass,
-                'script_src': script,
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": "BumbleBee",
+            "status": inputtypes.Status("unanswered"),
+            "size": size,
+            "msg": "",
+            "hidden": False,
+            "inline": False,
+            "trailing_text": "",
+            "do_math": True,
+            "preprocessor": {
+                "class_name": preprocessorClass,
+                "script_src": script,
             },
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
         assert context == expected
 
@@ -335,43 +326,42 @@ def test_trailing_text_rendering(self):
         # store (xml_text, expected)
         trailing_text = []
         # standard trailing text
-        trailing_text.append(('m/s', 'm/s'))
+        trailing_text.append(("m/s", "m/s"))
         # unicode trailing text
-        trailing_text.append(('\xc3', '\xc3'))
+        trailing_text.append(("\xc3", "\xc3"))
         # html escaped trailing text
         # this is the only one we expect to change
-        trailing_text.append(('a &lt; b', 'a < b'))
+        trailing_text.append(("a &lt; b", "a < b"))
 
         for xml_text, expected_text in trailing_text:
             xml_str = """<textline id="prob_1_2"
                             size="{size}"
                             trailing_text="{tt}"
-                            />""".format(size=size, tt=xml_text)
+                            />""".format(
+                size=size, tt=xml_text
+            )
 
             element = etree.fromstring(xml_str)
 
-            state = {
-                'value': 'BumbleBee',
-                'response_data': RESPONSE_DATA
-            }
-            the_input = lookup_tag('textline')(mock_capa_system(), element, state)
+            state = {"value": "BumbleBee", "response_data": RESPONSE_DATA}
+            the_input = lookup_tag("textline")(mock_capa_system(), element, state)
 
             context = the_input._get_render_context()  # pylint: disable=protected-access
-            prob_id = 'prob_1_2'
+            prob_id = "prob_1_2"
             expected = {
-                'STATIC_URL': '/dummy-static/',
-                'id': prob_id,
-                'value': 'BumbleBee',
-                'status': inputtypes.Status('unanswered'),
-                'size': size,
-                'msg': '',
-                'hidden': False,
-                'inline': False,
-                'do_math': False,
-                'trailing_text': expected_text,
-                'preprocessor': None,
-                'response_data': RESPONSE_DATA,
-                'describedby_html': TRAILING_TEXT_DESCRIBEDBY.format(trailing_text_id=prob_id, status_id=prob_id)
+                "STATIC_URL": "/dummy-static/",
+                "id": prob_id,
+                "value": "BumbleBee",
+                "status": inputtypes.Status("unanswered"),
+                "size": size,
+                "msg": "",
+                "hidden": False,
+                "inline": False,
+                "do_math": False,
+                "trailing_text": expected_text,
+                "preprocessor": None,
+                "response_data": RESPONSE_DATA,
+                "describedby_html": TRAILING_TEXT_DESCRIBEDBY.format(trailing_text_id=prob_id, status_id=prob_id),
             }
             assert context == expected
 
@@ -388,33 +378,35 @@ def test_rendering(self):
         xml_str = """<filesubmission id="prob_1_2"
         allowed_files="{af}"
         required_files="{rf}"
-        />""".format(af=allowed_files,
-                     rf=required_files,)
+        />""".format(
+            af=allowed_files,
+            rf=required_files,
+        )
 
         element = etree.fromstring(xml_str)
 
         state = {
-            'value': 'BumbleBee.py',
-            'status': 'incomplete',
-            'feedback': {'message': '3'},
-            'response_data': RESPONSE_DATA
+            "value": "BumbleBee.py",
+            "status": "incomplete",
+            "feedback": {"message": "3"},
+            "response_data": RESPONSE_DATA,
         }
-        input_class = lookup_tag('filesubmission')
+        input_class = lookup_tag("filesubmission")
         the_input = input_class(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'status': inputtypes.Status('queued'),
-            'msg': the_input.submitted_msg,
-            'value': 'BumbleBee.py',
-            'queue_len': '3',
-            'allowed_files': '["runme.py", "nooooo.rb", "ohai.java"]',
-            'required_files': '["cookies.py"]',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "status": inputtypes.Status("queued"),
+            "msg": the_input.submitted_msg,
+            "value": "BumbleBee.py",
+            "queue_len": "3",
+            "allowed_files": '["runme.py", "nooooo.rb", "ohai.java"]',
+            "required_files": '["cookies.py"]',
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
@@ -427,10 +419,10 @@ class CodeInputTest(unittest.TestCase):
 
     def test_rendering(self):
         mode = "parrot"
-        linenumbers = 'false'
-        rows = '37'
-        cols = '11'
-        tabsize = '7'
+        linenumbers = "false"
+        rows = "37"
+        cols = "11"
+        tabsize = "7"
 
         xml_str = """<codeinput id="prob_1_2"
         mode="{m}"
@@ -438,39 +430,41 @@ def test_rendering(self):
         rows="{r}"
         linenumbers="{ln}"
         tabsize="{ts}"
-        />""".format(m=mode, c=cols, r=rows, ln=linenumbers, ts=tabsize)
+        />""".format(
+            m=mode, c=cols, r=rows, ln=linenumbers, ts=tabsize
+        )
 
         element = etree.fromstring(xml_str)
 
         state = {
-            'value': 'print "good evening"',
-            'status': 'incomplete',
-            'feedback': {'message': '3'},
-            'response_data': RESPONSE_DATA
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "feedback": {"message": "3"},
+            "response_data": RESPONSE_DATA,
         }
 
-        input_class = lookup_tag('codeinput')
+        input_class = lookup_tag("codeinput")
         the_input = input_class(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'print "good evening"',
-            'status': inputtypes.Status('queued'),
-            'msg': the_input.submitted_msg,
-            'mode': mode,
-            'linenumbers': linenumbers,
-            'rows': rows,
-            'cols': cols,
-            'hidden': '',
-            'tabsize': int(tabsize),
-            'queue_len': '3',
-            'aria_label': '{mode} editor'.format(mode=mode),
-            'code_mirror_exit_message': 'Press ESC then TAB or click outside of the code editor to exit',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": 'print "good evening"',
+            "status": inputtypes.Status("queued"),
+            "msg": the_input.submitted_msg,
+            "mode": mode,
+            "linenumbers": linenumbers,
+            "rows": rows,
+            "cols": cols,
+            "hidden": "",
+            "tabsize": int(tabsize),
+            "queue_len": "3",
+            "aria_label": "{mode} editor".format(mode=mode),
+            "code_mirror_exit_message": "Press ESC then TAB or click outside of the code editor to exit",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
@@ -480,14 +474,15 @@ class MatlabTest(unittest.TestCase):
     """
     Test Matlab input types
     """
+
     def setUp(self):
         super(MatlabTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
-        self.rows = '10'
-        self.cols = '80'
-        self.tabsize = '4'
+        self.rows = "10"
+        self.cols = "80"
+        self.tabsize = "4"
         self.mode = ""
         self.payload = "payload"
-        self.linenumbers = 'true'
+        self.linenumbers = "true"
         self.xml = """<matlabinput id="prob_1_2"
             rows="{r}" cols="{c}"
             tabsize="{tabsize}" mode="{m}"
@@ -495,236 +490,237 @@ def setUp(self):
                 <plot_payload>
                     {payload}
                 </plot_payload>
-            </matlabinput>""".format(r=self.rows,
-                                     c=self.cols,
-                                     tabsize=self.tabsize,
-                                     m=self.mode,
-                                     payload=self.payload,
-                                     ln=self.linenumbers)
+            </matlabinput>""".format(
+            r=self.rows, c=self.cols, tabsize=self.tabsize, m=self.mode, payload=self.payload, ln=self.linenumbers
+        )
         elt = etree.fromstring(self.xml)
         state = {
-            'value': 'print "good evening"',
-            'status': 'incomplete',
-            'feedback': {'message': '3'},
-            'response_data': {}
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "feedback": {"message": "3"},
+            "response_data": {},
         }
 
-        self.input_class = lookup_tag('matlabinput')
+        self.input_class = lookup_tag("matlabinput")
         self.the_input = self.input_class(mock_capa_system(), elt, state)
 
     def test_rendering(self):
         context = self.the_input._get_render_context()  # pylint: disable=protected-access
 
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': 'prob_1_2',
-            'value': 'print "good evening"',
-            'status': inputtypes.Status('queued'),
-            'msg': self.the_input.submitted_msg,
-            'mode': self.mode,
-            'rows': self.rows,
-            'cols': self.cols,
-            'queue_msg': '',
-            'linenumbers': 'true',
-            'hidden': '',
-            'tabsize': int(self.tabsize),
-            'button_enabled': True,
-            'queue_len': '3',
-            'matlab_editor_js': '/dummy-static/js/vendor/CodeMirror/octave.js',
-            'response_data': {},
-            'describedby_html': HTML('aria-describedby="status_prob_1_2"')
+            "STATIC_URL": "/dummy-static/",
+            "id": "prob_1_2",
+            "value": 'print "good evening"',
+            "status": inputtypes.Status("queued"),
+            "msg": self.the_input.submitted_msg,
+            "mode": self.mode,
+            "rows": self.rows,
+            "cols": self.cols,
+            "queue_msg": "",
+            "linenumbers": "true",
+            "hidden": "",
+            "tabsize": int(self.tabsize),
+            "button_enabled": True,
+            "queue_len": "3",
+            "matlab_editor_js": "/dummy-static/js/vendor/CodeMirror/octave.js",
+            "response_data": {},
+            "describedby_html": HTML('aria-describedby="status_prob_1_2"'),
         }
 
         assert context == expected
 
     def test_rendering_with_state(self):
         state = {
-            'value': 'print "good evening"',
-            'status': 'incomplete',
-            'input_state': {'queue_msg': 'message'},
-            'feedback': {'message': '3'},
-            'response_data': RESPONSE_DATA
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "input_state": {"queue_msg": "message"},
+            "feedback": {"message": "3"},
+            "response_data": RESPONSE_DATA,
         }
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'print "good evening"',
-            'status': inputtypes.Status('queued'),
-            'msg': the_input.submitted_msg,
-            'mode': self.mode,
-            'rows': self.rows,
-            'cols': self.cols,
-            'queue_msg': 'message',
-            'linenumbers': 'true',
-            'hidden': '',
-            'tabsize': int(self.tabsize),
-            'button_enabled': True,
-            'queue_len': '3',
-            'matlab_editor_js': '/dummy-static/js/vendor/CodeMirror/octave.js',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": 'print "good evening"',
+            "status": inputtypes.Status("queued"),
+            "msg": the_input.submitted_msg,
+            "mode": self.mode,
+            "rows": self.rows,
+            "cols": self.cols,
+            "queue_msg": "message",
+            "linenumbers": "true",
+            "hidden": "",
+            "tabsize": int(self.tabsize),
+            "button_enabled": True,
+            "queue_len": "3",
+            "matlab_editor_js": "/dummy-static/js/vendor/CodeMirror/octave.js",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
 
     def test_rendering_when_completed(self):
-        for status in ['correct', 'incorrect']:
+        for status in ["correct", "incorrect"]:
             state = {
-                'value': 'print "good evening"',
-                'status': status,
-                'input_state': {},
-                'response_data': RESPONSE_DATA
+                "value": 'print "good evening"',
+                "status": status,
+                "input_state": {},
+                "response_data": RESPONSE_DATA,
             }
             elt = etree.fromstring(self.xml)
-            prob_id = 'prob_1_2'
+            prob_id = "prob_1_2"
             the_input = self.input_class(mock_capa_system(), elt, state)
             context = the_input._get_render_context()  # pylint: disable=protected-access
             expected = {
-                'STATIC_URL': '/dummy-static/',
-                'id': prob_id,
-                'value': 'print "good evening"',
-                'status': inputtypes.Status(status),
-                'msg': '',
-                'mode': self.mode,
-                'rows': self.rows,
-                'cols': self.cols,
-                'queue_msg': '',
-                'linenumbers': 'true',
-                'hidden': '',
-                'tabsize': int(self.tabsize),
-                'button_enabled': False,
-                'queue_len': '0',
-                'matlab_editor_js': '/dummy-static/js/vendor/CodeMirror/octave.js',
-                'response_data': RESPONSE_DATA,
-                'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+                "STATIC_URL": "/dummy-static/",
+                "id": prob_id,
+                "value": 'print "good evening"',
+                "status": inputtypes.Status(status),
+                "msg": "",
+                "mode": self.mode,
+                "rows": self.rows,
+                "cols": self.cols,
+                "queue_msg": "",
+                "linenumbers": "true",
+                "hidden": "",
+                "tabsize": int(self.tabsize),
+                "button_enabled": False,
+                "queue_len": "0",
+                "matlab_editor_js": "/dummy-static/js/vendor/CodeMirror/octave.js",
+                "response_data": RESPONSE_DATA,
+                "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
             }
 
             assert context == expected
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=10)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=10)
     def test_rendering_while_queued(self, time):  # lint-amnesty, pylint: disable=unused-argument
         state = {
-            'value': 'print "good evening"',
-            'status': 'incomplete',
-            'input_state': {'queuestate': 'queued', 'queuetime': 5},
-            'response_data': RESPONSE_DATA
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "input_state": {"queuestate": "queued", "queuetime": 5},
+            "response_data": RESPONSE_DATA,
         }
         elt = etree.fromstring(self.xml)
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         the_input = self.input_class(mock_capa_system(), elt, state)
         context = the_input._get_render_context()  # pylint: disable=protected-access
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'print "good evening"',
-            'status': inputtypes.Status('queued'),
-            'msg': the_input.submitted_msg,
-            'mode': self.mode,
-            'rows': self.rows,
-            'cols': self.cols,
-            'queue_msg': '',
-            'linenumbers': 'true',
-            'hidden': '',
-            'tabsize': int(self.tabsize),
-            'button_enabled': True,
-            'queue_len': '1',
-            'matlab_editor_js': '/dummy-static/js/vendor/CodeMirror/octave.js',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": 'print "good evening"',
+            "status": inputtypes.Status("queued"),
+            "msg": the_input.submitted_msg,
+            "mode": self.mode,
+            "rows": self.rows,
+            "cols": self.cols,
+            "queue_msg": "",
+            "linenumbers": "true",
+            "hidden": "",
+            "tabsize": int(self.tabsize),
+            "button_enabled": True,
+            "queue_len": "1",
+            "matlab_editor_js": "/dummy-static/js/vendor/CodeMirror/octave.js",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
 
     def test_plot_data(self):
-        data = {'submission': 'x = 1234;'}
+        data = {"submission": "x = 1234;"}
         response = self.the_input.handle_ajax("plot", data)
         self.the_input.capa_system.xqueue.interface.send_to_queue.assert_called_with(header=ANY, body=ANY)
-        assert response['success']
-        assert self.the_input.input_state['queuekey'] is not None
-        assert self.the_input.input_state['queuestate'] == 'queued'
+        assert response["success"]
+        assert self.the_input.input_state["queuekey"] is not None
+        assert self.the_input.input_state["queuestate"] == "queued"
 
     def test_plot_data_failure(self):
-        data = {'submission': 'x = 1234;'}
-        error_message = 'Error message!'
+        data = {"submission": "x = 1234;"}
+        error_message = "Error message!"
         self.the_input.capa_system.xqueue.interface.send_to_queue.return_value = (1, error_message)
         response = self.the_input.handle_ajax("plot", data)
-        assert not response['success']
-        assert response['message'] == error_message
-        assert 'queuekey' not in self.the_input.input_state
-        assert 'queuestate' not in self.the_input.input_state
+        assert not response["success"]
+        assert response["message"] == error_message
+        assert "queuekey" not in self.the_input.input_state
+        assert "queuestate" not in self.the_input.input_state
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=10)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=10)
     def test_ungraded_response_success(self, time):  # lint-amnesty, pylint: disable=unused-argument
-        queuekey = 'abcd'
-        input_state = {'queuekey': queuekey, 'queuestate': 'queued', 'queuetime': 5}
-        state = {'value': 'print "good evening"',
-                 'status': 'incomplete',
-                 'input_state': input_state,
-                 'feedback': {'message': '3'}, }
+        queuekey = "abcd"
+        input_state = {"queuekey": queuekey, "queuestate": "queued", "queuetime": 5}
+        state = {
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "input_state": input_state,
+            "feedback": {"message": "3"},
+        }
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
-        inner_msg = 'hello!'
-        queue_msg = json.dumps({'msg': inner_msg})
+        inner_msg = "hello!"
+        queue_msg = json.dumps({"msg": inner_msg})
 
         the_input.ungraded_response(queue_msg, queuekey)
-        assert input_state['queuekey'] is None
-        assert input_state['queuestate'] is None
-        assert input_state['queue_msg'] == inner_msg
+        assert input_state["queuekey"] is None
+        assert input_state["queuestate"] is None
+        assert input_state["queue_msg"] == inner_msg
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=10)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=10)
     def test_ungraded_response_key_mismatch(self, time):  # lint-amnesty, pylint: disable=unused-argument
-        queuekey = 'abcd'
-        input_state = {'queuekey': queuekey, 'queuestate': 'queued', 'queuetime': 5}
-        state = {'value': 'print "good evening"',
-                 'status': 'incomplete',
-                 'input_state': input_state,
-                 'feedback': {'message': '3'}, }
+        queuekey = "abcd"
+        input_state = {"queuekey": queuekey, "queuestate": "queued", "queuetime": 5}
+        state = {
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "input_state": input_state,
+            "feedback": {"message": "3"},
+        }
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
-        inner_msg = 'hello!'
-        queue_msg = json.dumps({'msg': inner_msg})
+        inner_msg = "hello!"
+        queue_msg = json.dumps({"msg": inner_msg})
 
-        the_input.ungraded_response(queue_msg, 'abc')
-        assert input_state['queuekey'] == queuekey
-        assert input_state['queuestate'] == 'queued'
-        assert 'queue_msg' not in input_state
+        the_input.ungraded_response(queue_msg, "abc")
+        assert input_state["queuekey"] == queuekey
+        assert input_state["queuestate"] == "queued"
+        assert "queue_msg" not in input_state
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=20)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=20)
     def test_matlab_response_timeout_not_exceeded(self, time):  # lint-amnesty, pylint: disable=unused-argument
 
-        state = {'input_state': {'queuestate': 'queued', 'queuetime': 5}}
+        state = {"input_state": {"queuestate": "queued", "queuetime": 5}}
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
-        assert the_input.status == 'queued'
+        assert the_input.status == "queued"
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=45)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=45)
     def test_matlab_response_timeout_exceeded(self, time):  # lint-amnesty, pylint: disable=unused-argument
 
-        state = {'input_state': {'queuestate': 'queued', 'queuetime': 5}}
+        state = {"input_state": {"queuestate": "queued", "queuetime": 5}}
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
-        assert the_input.status == 'unsubmitted'
-        assert the_input.msg == 'No response from Xqueue within {} seconds. Aborted.'.format(XQUEUE_TIMEOUT)
+        assert the_input.status == "unsubmitted"
+        assert the_input.msg == "No response from Xqueue within {} seconds. Aborted.".format(XQUEUE_TIMEOUT)
 
-    @patch('xmodule.capa.inputtypes.time.time', return_value=20)
+    @patch("xmodule.capa.inputtypes.time.time", return_value=20)
     def test_matlab_response_migration_of_queuetime(self, time):  # lint-amnesty, pylint: disable=unused-argument
         """
         Test if problem was saved before queuetime was introduced.
         """
-        state = {'input_state': {'queuestate': 'queued'}}
+        state = {"input_state": {"queuestate": "queued"}}
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
-        assert the_input.status == 'unsubmitted'
+        assert the_input.status == "unsubmitted"
 
     def test_matlab_api_key(self):
         """
@@ -732,28 +728,28 @@ def test_matlab_api_key(self):
         """
         elt = etree.fromstring(self.xml)
         system = mock_capa_system()
-        system.matlab_api_key = 'test_api_key'
-        the_input = lookup_tag('matlabinput')(system, elt, {})
+        system.matlab_api_key = "test_api_key"
+        the_input = lookup_tag("matlabinput")(system, elt, {})
 
-        data = {'submission': 'x = 1234;'}
+        data = {"submission": "x = 1234;"}
         response = the_input.handle_ajax("plot", data)  # lint-amnesty, pylint: disable=unused-variable
 
-        body = system.xqueue.interface.send_to_queue.call_args[1]['body']
+        body = system.xqueue.interface.send_to_queue.call_args[1]["body"]
         payload = json.loads(body)
-        assert 'test_api_key' == payload['token']
-        assert '2' == payload['endpoint_version']
+        assert "test_api_key" == payload["token"]
+        assert "2" == payload["endpoint_version"]
 
     def test_get_html(self):
         # usual output
         output = self.the_input.get_html()
-        output_string = etree.tostring(output).decode('utf-8')
-        assert output_string.startswith('<div>{')
-        assert output_string.endswith('}</div>')
-        output_string = output_string.replace('}</div>', '')
-        output_string = output_string.replace('<div>{', '')
-        output_list = output_string.split(',')
+        output_string = etree.tostring(output).decode("utf-8")
+        assert output_string.startswith("<div>{")
+        assert output_string.endswith("}</div>")
+        output_string = output_string.replace("}</div>", "")
+        output_string = output_string.replace("<div>{", "")
+        output_list = output_string.split(",")
         for index, value in enumerate(output_list):
-            output_list[index] = value.replace('u\'', '\'').strip()
+            output_list[index] = value.replace("u'", "'").strip()
 
         expected_string = """
         \'matlab_editor_js\': \'/dummy-static/js/vendor/CodeMirror/octave.js\',
@@ -763,19 +759,24 @@ def test_get_html(self):
         \'id\': \'prob_1_2\', \'queue_len\': \'3\', \'tabsize\': 4, \'STATIC_URL\': \'/dummy-static/\',
         \'linenumbers\': \'true\', \'cols\': \'80\', \'button_enabled\': True, \'rows\': \'10\',
         \'describedby_html\': Markup(\'aria-describedby="status_prob_1_2"\')"""
-        expected_list = (textwrap.dedent(expected_string).replace('\n', ' ').strip()).split(',')
+        expected_list = (textwrap.dedent(expected_string).replace("\n", " ").strip()).split(",")
         for index, value in enumerate(expected_list):
-            expected_list[index] = value.replace('u\'', '\'').strip()
+            expected_list[index] = value.replace("u'", "'").strip()
         six.assertCountEqual(self, output_list, expected_list)
 
         # test html, that is correct HTML5 html, but is not parsable by XML parser.
         old_render_template = self.the_input.capa_system.render_template
-        self.the_input.capa_system.render_template = lambda *args: textwrap.dedent("""
-                <div class='matlabResponse'><div id='mwAudioPlaceHolder'>
-                <audio controls autobuffer autoplay src='data:audio/wav;base64='>Audio is not supported on this browser.</audio>
-                <div>Right click <a href=https://endpoint.mss-mathworks.com/media/filename.wav>here</a> and click \"Save As\" to download the file</div></div>
-                <div style='white-space:pre' class='commandWindowOutput'></div><ul></ul></div>
-            """).replace('\n', '')
+        self.the_input.capa_system.render_template = lambda *args: textwrap.dedent(
+            (
+                "<div class='matlabResponse'><div id='mwAudioPlaceHolder'>"
+                "<audio controls autobuffer autoplay src='data:audio/wav;base64='>"
+                "Audio is not supported on this browser.</audio>"
+                "<div>Right click "
+                "<a href=https://endpoint.mss-mathworks.com/media/filename.wav>here</a> "
+                'and click "Save As" to download the file</div></div>'
+                "<div style='white-space:pre' class='commandWindowOutput'></div><ul></ul></div>"
+            )
+        ).replace("\n", "")
 
         output = self.the_input.get_html()
         elements = []
@@ -785,18 +786,18 @@ def test_get_html(self):
             elements.append(element)
             element_tags.append(element.tag)
             element_keys.append(element.keys())
-        assert element_tags.count('div') == 4
-        assert element_tags.count('audio') == 1
-        audio_index = element_tags.index('audio')
-
-        six.assertCountEqual(self, element_keys[audio_index], ['autobuffer', 'controls', 'autoplay', 'src'])
-        assert elements[audio_index].get('src') == 'data:audio/wav;base64='
-        assert elements[audio_index].text == 'Audio is not supported on this browser.'
-        href_index = element_keys.index(['href'])
-        assert elements[href_index].get('href') == 'https://endpoint.mss-mathworks.com/media/filename.wav'
-        id_index = element_keys.index(['id'])
-        assert elements[id_index].get('id') == 'mwAudioPlaceHolder'
-        output_string = etree.tostring(output).decode('utf-8')
+        assert element_tags.count("div") == 4
+        assert element_tags.count("audio") == 1
+        audio_index = element_tags.index("audio")
+
+        six.assertCountEqual(self, element_keys[audio_index], ["autobuffer", "controls", "autoplay", "src"])
+        assert elements[audio_index].get("src") == "data:audio/wav;base64="
+        assert elements[audio_index].text == "Audio is not supported on this browser."
+        href_index = element_keys.index(["href"])
+        assert elements[href_index].get("href") == "https://endpoint.mss-mathworks.com/media/filename.wav"
+        id_index = element_keys.index(["id"])
+        assert elements[id_index].get("id") == "mwAudioPlaceHolder"
+        output_string = etree.tostring(output).decode("utf-8")
 
         # check that exception is raised during parsing for html.
         self.the_input.capa_system.render_template = lambda *args: "<aaa"
@@ -807,83 +808,99 @@ def test_get_html(self):
 
     def test_malformed_queue_msg(self):
         # an actual malformed response
-        queue_msg = textwrap.dedent("""
-    <div class='matlabResponse'><div style='white-space:pre' class='commandWindowOutput'> <strong>if</strong> Conditionally execute statements.
-    The general form of the <strong>if</strong> statement is
-
-       <strong>if</strong> expression
-         statements
-       ELSEIF expression
-         statements
-       ELSE
-         statements
-       END
-
-    The statements are executed if the real part of the expression
-    has all non-zero elements. The ELSE and ELSEIF parts are optional.
-    Zero or more ELSEIF parts can be used as well as nested <strong>if</strong>'s.
-    The expression is usually of the form expr rop expr where
-    rop is ==, <, >, <=, >=, or ~=.
-    <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjAAAAGkCAIAAACgj==" />
-
-    Example
-       if I == J
-         A(I,J) = 2;
-       elseif abs(I-J) == 1
-         A(I,J) = -1;
-       else
-         A(I,J) = 0;
-       end
-
-    See also <a href="matlab:help relop">relop</a>, <a href="matlab:help else">else</a>, <a href="matlab:help elseif">elseif</a>, <a href="matlab:help end">end</a>, <a href="matlab:help for">for</a>, <a href="matlab:help while">while</a>, <a href="matlab:help switch">switch</a>.
-
-    Reference page in Help browser
-       <a href="matlab:doc if">doc if</a>
-
-    </div><ul></ul></div>
-        """)
+        queue_msg = textwrap.dedent(
+            """
+        <div class='matlabResponse'>
+            <div style='white-space:pre' class='commandWindowOutput'>
+                <strong>if</strong> Conditionally execute statements.
+                The general form of the <strong>if</strong> statement is
+
+                <strong>if</strong> expression
+                    statements
+                ELSEIF expression
+                    statements
+                ELSE
+                    statements
+                END
+
+                The statements are executed if the real part of the expression
+                has all non-zero elements. The ELSE and ELSEIF parts are optional.
+                Zero or more ELSEIF parts can be used as well as nested <strong>if</strong>'s.
+                The expression is usually of the form expr rop expr where
+                rop is ==, <, >, <=, >=, or ~=.
+                <img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjAAAAGkCAIAAACgj==" />
+
+                Example
+                if I == J
+                    A(I,J) = 2;
+                elseif abs(I-J) == 1
+                    A(I,J) = -1;
+                else
+                    A(I,J) = 0;
+                end
+
+                See also <a href="matlab:help relop">relop</a>,
+                <a href="matlab:help else">else</a>,
+                <a href="matlab:help elseif">elseif</a>,
+                <a href="matlab:help end">end</a>,
+                <a href="matlab:help for">for</a>,
+                <a href="matlab:help while">while</a>,
+                <a href="matlab:help switch">switch</a>.
+
+                Reference page in Help browser
+                <a href="matlab:doc if">doc if</a>
+
+            </div>
+            <ul></ul>
+        </div>
+        """
+        )
 
         state = {
-            'value': 'print "good evening"',
-            'status': 'incomplete',
-            'input_state': {'queue_msg': queue_msg},
-            'feedback': {'message': '3'},
-            'response_data': RESPONSE_DATA
+            "value": 'print "good evening"',
+            "status": "incomplete",
+            "input_state": {"queue_msg": queue_msg},
+            "feedback": {"message": "3"},
+            "response_data": RESPONSE_DATA,
         }
         elt = etree.fromstring(self.xml)
 
         the_input = self.input_class(mock_capa_system(), elt, state)
         context = the_input._get_render_context()  # pylint: disable=protected-access
         self.maxDiff = None
-        expected = fromstring('\n<div class="matlabResponse"><div class="commandWindowOutput" style="white-space: pre;"> <strong>if</strong> Conditionally execute statements.\nThe general form of the <strong>if</strong> statement is\n\n   <strong>if</strong> expression\n     statements\n   ELSEIF expression\n     statements\n   ELSE\n     statements\n   END\n\nThe statements are executed if the real part of the expression \nhas all non-zero elements. The ELSE and ELSEIF parts are optional.\nZero or more ELSEIF parts can be used as well as nested <strong>if</strong>\'s.\nThe expression is usually of the form expr rop expr where \nrop is ==, &lt;, &gt;, &lt;=, &gt;=, or ~=.\n<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjAAAAGkCAIAAACgj==">\n\nExample\n   if I == J\n     A(I,J) = 2;\n   elseif abs(I-J) == 1\n     A(I,J) = -1;\n   else\n     A(I,J) = 0;\n   end\n\nSee also <a>relop</a>, <a>else</a>, <a>elseif</a>, <a>end</a>, <a>for</a>, <a>while</a>, <a>switch</a>.\n\nReference page in Help browser\n   <a>doc if</a>\n\n</div><ul></ul></div>\n')  # lint-amnesty, pylint: disable=line-too-long
-        received = fromstring(context['queue_msg'])
+        expected = fromstring(
+            '\n<div class="matlabResponse"><div class="commandWindowOutput" style="white-space: pre;"> <strong>if</strong> Conditionally execute statements.\nThe general form of the <strong>if</strong> statement is\n\n   <strong>if</strong> expression\n     statements\n   ELSEIF expression\n     statements\n   ELSE\n     statements\n   END\n\nThe statements are executed if the real part of the expression \nhas all non-zero elements. The ELSE and ELSEIF parts are optional.\nZero or more ELSEIF parts can be used as well as nested <strong>if</strong>\'s.\nThe expression is usually of the form expr rop expr where \nrop is ==, &lt;, &gt;, &lt;=, &gt;=, or ~=.\n<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjAAAAGkCAIAAACgj==">\n\nExample\n   if I == J\n     A(I,J) = 2;\n   elseif abs(I-J) == 1\n     A(I,J) = -1;\n   else\n     A(I,J) = 0;\n   end\n\nSee also <a>relop</a>, <a>else</a>, <a>elseif</a>, <a>end</a>, <a>for</a>, <a>while</a>, <a>switch</a>.\n\nReference page in Help browser\n   <a>doc if</a>\n\n</div><ul></ul></div>\n'  # lint-amnesty, pylint: disable=line-too-long
+        )
+        received = fromstring(context["queue_msg"])
         html_tree_equal(received, expected)
 
     def test_rendering_with_invalid_queue_msg(self):
-        self.the_input.queue_msg = ("<div class='matlabResponse'><div style='white-space:pre' class='commandWindowOutput'>"  # lint-amnesty, pylint: disable=line-too-long
-                                    "\nans =\n\n\u0002\n\n</div><ul></ul></div>")
+        self.the_input.queue_msg = (
+            "<div class='matlabResponse'><div style='white-space:pre' class='commandWindowOutput'>"  # lint-amnesty, pylint: disable=line-too-long
+            "\nans =\n\n\u0002\n\n</div><ul></ul></div>"
+        )
         context = self.the_input._get_render_context()  # pylint: disable=protected-access
 
         self.maxDiff = None
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'print "good evening"',
-            'status': inputtypes.Status('queued'),
-            'msg': self.the_input.submitted_msg,
-            'mode': self.mode,
-            'rows': self.rows,
-            'cols': self.cols,
-            'queue_msg': "<span>Error running code.</span>",
-            'linenumbers': 'true',
-            'hidden': '',
-            'tabsize': int(self.tabsize),
-            'button_enabled': True,
-            'queue_len': '3',
-            'matlab_editor_js': '/dummy-static/js/vendor/CodeMirror/octave.js',
-            'response_data': {},
-            'describedby_html': 'aria-describedby="status_{id}"'.format(id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": 'print "good evening"',
+            "status": inputtypes.Status("queued"),
+            "msg": self.the_input.submitted_msg,
+            "mode": self.mode,
+            "rows": self.rows,
+            "cols": self.cols,
+            "queue_msg": "<span>Error running code.</span>",
+            "linenumbers": "true",
+            "hidden": "",
+            "tabsize": int(self.tabsize),
+            "button_enabled": True,
+            "queue_len": "3",
+            "matlab_editor_js": "/dummy-static/js/vendor/CodeMirror/octave.js",
+            "response_data": {},
+            "describedby_html": 'aria-describedby="status_{id}"'.format(id=prob_id),
         }
         assert context == expected
         self.the_input.capa_system.render_template = DemoSystem().render_template
@@ -893,12 +910,12 @@ def test_matlab_queue_message_allowed_tags(self):
         """
         Test allowed tags.
         """
-        allowed_tags = ['div', 'p', 'audio', 'pre', 'span']
+        allowed_tags = ["div", "p", "audio", "pre", "span"]
         for tag in allowed_tags:
             queue_msg = "<{0}>Test message</{0}>".format(tag)
             state = {
-                'input_state': {'queue_msg': queue_msg},
-                'status': 'queued',
+                "input_state": {"queue_msg": queue_msg},
+                "status": "queued",
             }
             elt = etree.fromstring(self.xml)
             the_input = self.input_class(mock_capa_system(), elt, state)
@@ -908,11 +925,11 @@ def test_matlab_queue_message_not_allowed_tag(self):
         """
         Test not allowed tag.
         """
-        not_allowed_tag = 'script'
+        not_allowed_tag = "script"
         queue_msg = "<{0}>Test message</{0}>".format(not_allowed_tag)
         state = {
-            'input_state': {'queue_msg': queue_msg},
-            'status': 'queued',
+            "input_state": {"queue_msg": queue_msg},
+            "status": "queued",
         }
         elt = etree.fromstring(self.xml)
         the_input = self.input_class(mock_capa_system(), elt, state)
@@ -923,17 +940,17 @@ def test_matlab_sanitize_msg(self):
         """
         Check that the_input.msg is sanitized.
         """
-        not_allowed_tag = 'script'
+        not_allowed_tag = "script"
         self.the_input.msg = "<{0}>Test message</{0}>".format(not_allowed_tag)
         expected = ""
-        assert self.the_input._get_render_context()['msg'] == expected  # pylint: disable=protected-access
+        assert self.the_input._get_render_context()["msg"] == expected  # pylint: disable=protected-access
 
 
 def html_tree_equal(received, expected):
     """
     Returns whether two etree Elements are the same, with insensitivity to attribute order.
     """
-    for attr in ('tag', 'attrib', 'text', 'tail'):
+    for attr in ("tag", "attrib", "text", "tail"):
         if getattr(received, attr) != getattr(expected, attr):
             return False
     if len(received) != len(expected):
@@ -947,13 +964,14 @@ class SchematicTest(unittest.TestCase):
     """
     Check that schematic inputs work
     """
+
     def test_rendering(self):
-        height = '12'
-        width = '33'
-        parts = 'resistors, capacitors, and flowers'
-        analyses = 'fast, slow, and pink'
-        initial_value = 'two large batteries'
-        submit_analyses = 'maybe'
+        height = "12"
+        width = "33"
+        parts = "resistors, capacitors, and flowers"
+        analyses = "fast, slow, and pink"
+        initial_value = "two large batteries"
+        submit_analyses = "maybe"
 
         xml_str = """<schematic id="prob_1_2"
         height="{h}"
@@ -962,37 +980,34 @@ def test_rendering(self):
         analyses="{a}"
         initial_value="{iv}"
         submit_analyses="{sa}"
-        />""".format(h=height, w=width, p=parts, a=analyses,
-                     iv=initial_value, sa=submit_analyses)
+        />""".format(
+            h=height, w=width, p=parts, a=analyses, iv=initial_value, sa=submit_analyses
+        )
 
         element = etree.fromstring(xml_str)
 
-        value = 'three resistors and an oscilating pendulum'
-        state = {
-            'value': value,
-            'status': 'unsubmitted',
-            'response_data': RESPONSE_DATA
-        }
+        value = "three resistors and an oscilating pendulum"
+        state = {"value": value, "status": "unsubmitted", "response_data": RESPONSE_DATA}
 
-        the_input = lookup_tag('schematic')(mock_capa_system(), element, state)
+        the_input = lookup_tag("schematic")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': value,
-            'status': inputtypes.Status('unsubmitted'),
-            'msg': '',
-            'initial_value': initial_value,
-            'width': width,
-            'height': height,
-            'parts': parts,
-            'setup_script': '/dummy-static/js/capa/schematicinput.js',
-            'analyses': analyses,
-            'submit_analyses': submit_analyses,
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": value,
+            "status": inputtypes.Status("unsubmitted"),
+            "msg": "",
+            "initial_value": initial_value,
+            "width": width,
+            "height": height,
+            "parts": parts,
+            "setup_script": "/dummy-static/js/capa/schematicinput.js",
+            "analyses": analyses,
+            "submit_analyses": submit_analyses,
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
@@ -1002,97 +1017,95 @@ class ImageInputTest(unittest.TestCase):
     """
     Check that image inputs work
     """
+
     def check(self, value, egx, egy):  # lint-amnesty, pylint: disable=missing-function-docstring
-        height = '78'
-        width = '427'
-        src = 'http://www.edx.org/cowclicker.jpg'
+        height = "78"
+        width = "427"
+        src = "http://www.edx.org/cowclicker.jpg"
 
         xml_str = """<imageinput id="prob_1_2"
         src="{s}"
         height="{h}"
         width="{w}"
-        />""".format(s=src, h=height, w=width)
+        />""".format(
+            s=src, h=height, w=width
+        )
 
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': value,
-            'status': 'unsubmitted',
-            'response_data': RESPONSE_DATA
-        }
+        state = {"value": value, "status": "unsubmitted", "response_data": RESPONSE_DATA}
 
-        the_input = lookup_tag('imageinput')(mock_capa_system(), element, state)
+        the_input = lookup_tag("imageinput")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': value,
-            'status': inputtypes.Status('unsubmitted'),
-            'width': width,
-            'height': height,
-            'src': src,
-            'gx': egx,
-            'gy': egy,
-            'msg': '',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": value,
+            "status": inputtypes.Status("unsubmitted"),
+            "width": width,
+            "height": height,
+            "src": src,
+            "gx": egx,
+            "gy": egy,
+            "msg": "",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
 
     def test_with_value(self):
         # Check that compensating for the dot size works properly.
-        self.check('[50,40]', 35, 25)
+        self.check("[50,40]", 35, 25)
 
     def test_without_value(self):
-        self.check('', 0, 0)
+        self.check("", 0, 0)
 
     def test_corrupt_values(self):
-        self.check('[12', 0, 0)
-        self.check('[12, a]', 0, 0)
-        self.check('[12 10]', 0, 0)
-        self.check('[12]', 0, 0)
-        self.check('[12 13 14]', 0, 0)
+        self.check("[12", 0, 0)
+        self.check("[12, a]", 0, 0)
+        self.check("[12 10]", 0, 0)
+        self.check("[12]", 0, 0)
+        self.check("[12 13 14]", 0, 0)
 
 
 class CrystallographyTest(unittest.TestCase):
     """
     Check that crystallography inputs work
     """
+
     def test_rendering(self):
-        height = '12'
-        width = '33'
+        height = "12"
+        width = "33"
 
         xml_str = """<crystallography id="prob_1_2"
         height="{h}"
         width="{w}"
-        />""".format(h=height, w=width)
+        />""".format(
+            h=height, w=width
+        )
 
         element = etree.fromstring(xml_str)
 
-        value = 'abc'
-        state = {
-            'value': value,
-            'status': 'unsubmitted',
-            'response_data': RESPONSE_DATA
-        }
+        value = "abc"
+        state = {"value": value, "status": "unsubmitted", "response_data": RESPONSE_DATA}
 
-        the_input = lookup_tag('crystallography')(mock_capa_system(), element, state)
+        the_input = lookup_tag("crystallography")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': value,
-            'status': inputtypes.Status('unsubmitted'),
-            'msg': '',
-            'width': width,
-            'height': height,
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": value,
+            "status": inputtypes.Status("unsubmitted"),
+            "msg": "",
+            "width": width,
+            "height": height,
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
@@ -1102,9 +1115,10 @@ class VseprTest(unittest.TestCase):
     """
     Check that vsepr inputs work
     """
+
     def test_rendering(self):
-        height = '12'
-        width = '33'
+        height = "12"
+        width = "33"
         molecules = "H2O, C2O"
         geometries = "AX12,TK421"
 
@@ -1113,33 +1127,31 @@ def test_rendering(self):
         width="{w}"
         molecules="{m}"
         geometries="{g}"
-        />""".format(h=height, w=width, m=molecules, g=geometries)
+        />""".format(
+            h=height, w=width, m=molecules, g=geometries
+        )
 
         element = etree.fromstring(xml_str)
 
-        value = 'abc'
-        state = {
-            'value': value,
-            'status': 'unsubmitted',
-            'response_data': RESPONSE_DATA
-        }
+        value = "abc"
+        state = {"value": value, "status": "unsubmitted", "response_data": RESPONSE_DATA}
 
-        the_input = lookup_tag('vsepr_input')(mock_capa_system(), element, state)
+        the_input = lookup_tag("vsepr_input")(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': value,
-            'status': inputtypes.Status('unsubmitted'),
-            'msg': '',
-            'width': width,
-            'height': height,
-            'molecules': molecules,
-            'geometries': geometries,
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": value,
+            "status": inputtypes.Status("unsubmitted"),
+            "msg": "",
+            "width": width,
+            "height": height,
+            "molecules": molecules,
+            "geometries": geometries,
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         assert context == expected
@@ -1149,6 +1161,7 @@ class ChemicalEquationTest(unittest.TestCase):
     """
     Check that chemical equation inputs work.
     """
+
     def setUp(self):
         super(ChemicalEquationTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.size = "42"
@@ -1156,28 +1169,25 @@ def setUp(self):
 
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': 'H2OYeah',
-            'response_data': RESPONSE_DATA
-        }
-        self.the_input = lookup_tag('chemicalequationinput')(mock_capa_system(), element, state)
+        state = {"value": "H2OYeah", "response_data": RESPONSE_DATA}
+        self.the_input = lookup_tag("chemicalequationinput")(mock_capa_system(), element, state)
 
     def test_rendering(self):
         """
         Verify that the render context matches the expected render context
         """
         context = self.the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'H2OYeah',
-            'status': inputtypes.Status('unanswered'),
-            'msg': '',
-            'size': self.size,
-            'previewer': '/dummy-static/js/capa/chemical_equation_preview.js',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": "H2OYeah",
+            "status": inputtypes.Status("unanswered"),
+            "msg": "",
+            "size": self.size,
+            "previewer": "/dummy-static/js/capa/chemical_equation_preview.js",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
         assert context == expected
 
@@ -1185,12 +1195,12 @@ def test_chemcalc_ajax_sucess(self):
         """
         Verify that using the correct dispatch and valid data produces a valid response
         """
-        data = {'formula': "H"}
+        data = {"formula": "H"}
         response = self.the_input.handle_ajax("preview_chemcalc", data)
 
-        assert 'preview' in response
-        assert response['preview'] != ''
-        assert response['error'] == ''
+        assert "preview" in response
+        assert response["preview"] != ""
+        assert response["error"] == ""
 
     def test_ajax_bad_method(self):
         """
@@ -1204,46 +1214,39 @@ def test_ajax_no_formula(self):
         When we ask for a formula rendering, there should be an error if no formula
         """
         response = self.the_input.handle_ajax("preview_chemcalc", {})
-        assert 'error' in response
-        assert response['error'] == 'No formula specified.'
+        assert "error" in response
+        assert response["error"] == "No formula specified."
 
     def test_ajax_parse_err(self):
         """
         With parse errors, ChemicalEquationInput should give an error message
         """
         # Simulate answering a problem that raises the exception
-        with patch('xmodule.capa.inputtypes.chemcalc.render_to_html') as mock_render:
+        with patch("xmodule.capa.inputtypes.chemcalc.render_to_html") as mock_render:
             mock_render.side_effect = ParseException("ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ")
-            response = self.the_input.handle_ajax(
-                "preview_chemcalc",
-                {'formula': 'H2O + invalid chemistry'}
-            )
+            response = self.the_input.handle_ajax("preview_chemcalc", {"formula": "H2O + invalid chemistry"})
 
-        assert 'error' in response
-        assert "Couldn't parse formula" in response['error']
+        assert "error" in response
+        assert "Couldn't parse formula" in response["error"]
 
-    @patch('xmodule.capa.inputtypes.log')
+    @patch("xmodule.capa.inputtypes.log")
     def test_ajax_other_err(self, mock_log):
         """
         With other errors, test that ChemicalEquationInput also logs it
         """
-        with patch('xmodule.capa.inputtypes.chemcalc.render_to_html') as mock_render:
+        with patch("xmodule.capa.inputtypes.chemcalc.render_to_html") as mock_render:
             mock_render.side_effect = Exception()
-            response = self.the_input.handle_ajax(
-                "preview_chemcalc",
-                {'formula': 'H2O + superterrible chemistry'}
-            )
-        mock_log.warning.assert_called_once_with(
-            "Error while previewing chemical formula", exc_info=True
-        )
-        assert 'error' in response
-        assert response['error'] == 'Error while rendering preview'
+            response = self.the_input.handle_ajax("preview_chemcalc", {"formula": "H2O + superterrible chemistry"})
+        mock_log.warning.assert_called_once_with("Error while previewing chemical formula", exc_info=True)
+        assert "error" in response
+        assert response["error"] == "Error while rendering preview"
 
 
 class FormulaEquationTest(unittest.TestCase):
     """
     Check that formula equation inputs work.
     """
+
     def setUp(self):
         super(FormulaEquationTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.size = "42"
@@ -1251,30 +1254,27 @@ def setUp(self):
 
         element = etree.fromstring(xml_str)
 
-        state = {
-            'value': 'x^2+1/2',
-            'response_data': RESPONSE_DATA
-        }
-        self.the_input = lookup_tag('formulaequationinput')(mock_capa_system(), element, state)
+        state = {"value": "x^2+1/2", "response_data": RESPONSE_DATA}
+        self.the_input = lookup_tag("formulaequationinput")(mock_capa_system(), element, state)
 
     def test_rendering(self):
         """
         Verify that the render context matches the expected render context
         """
         context = self.the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'prob_1_2'
+        prob_id = "prob_1_2"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': 'x^2+1/2',
-            'status': inputtypes.Status('unanswered'),
-            'msg': '',
-            'size': self.size,
-            'previewer': '/dummy-static/js/capa/src/formula_equation_preview.js',
-            'inline': False,
-            'trailing_text': '',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": "x^2+1/2",
+            "status": inputtypes.Status("unanswered"),
+            "msg": "",
+            "size": self.size,
+            "previewer": "/dummy-static/js/capa/src/formula_equation_preview.js",
+            "inline": False,
+            "trailing_text": "",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
         assert context == expected
 
@@ -1286,41 +1286,40 @@ def test_trailing_text_rendering(self):
         # store (xml_text, expected)
         trailing_text = []
         # standard trailing text
-        trailing_text.append(('m/s', 'm/s'))
+        trailing_text.append(("m/s", "m/s"))
         # unicode trailing text
-        trailing_text.append(('\xc3', '\xc3'))
+        trailing_text.append(("\xc3", "\xc3"))
         # html escaped trailing text
         # this is the only one we expect to change
-        trailing_text.append(('a &lt; b', 'a < b'))
+        trailing_text.append(("a &lt; b", "a < b"))
 
         for xml_text, expected_text in trailing_text:
             xml_str = """<formulaequationinput id="prob_1_2"
                             size="{size}"
                             trailing_text="{tt}"
-                            />""".format(size=size, tt=xml_text)
+                            />""".format(
+                size=size, tt=xml_text
+            )
 
             element = etree.fromstring(xml_str)
 
-            state = {
-                'value': 'x^2+1/2',
-                'response_data': RESPONSE_DATA
-            }
-            the_input = lookup_tag('formulaequationinput')(mock_capa_system(), element, state)
+            state = {"value": "x^2+1/2", "response_data": RESPONSE_DATA}
+            the_input = lookup_tag("formulaequationinput")(mock_capa_system(), element, state)
 
             context = the_input._get_render_context()  # pylint: disable=protected-access
-            prob_id = 'prob_1_2'
+            prob_id = "prob_1_2"
             expected = {
-                'STATIC_URL': '/dummy-static/',
-                'id': prob_id,
-                'value': 'x^2+1/2',
-                'status': inputtypes.Status('unanswered'),
-                'msg': '',
-                'size': size,
-                'previewer': '/dummy-static/js/capa/src/formula_equation_preview.js',
-                'inline': False,
-                'trailing_text': expected_text,
-                'response_data': RESPONSE_DATA,
-                'describedby_html': TRAILING_TEXT_DESCRIBEDBY.format(trailing_text_id=prob_id, status_id=prob_id)
+                "STATIC_URL": "/dummy-static/",
+                "id": prob_id,
+                "value": "x^2+1/2",
+                "status": inputtypes.Status("unanswered"),
+                "msg": "",
+                "size": size,
+                "previewer": "/dummy-static/js/capa/src/formula_equation_preview.js",
+                "inline": False,
+                "trailing_text": expected_text,
+                "response_data": RESPONSE_DATA,
+                "describedby_html": TRAILING_TEXT_DESCRIBEDBY.format(trailing_text_id=prob_id, status_id=prob_id),
             }
 
             assert context == expected
@@ -1329,13 +1328,13 @@ def test_formcalc_ajax_sucess(self):
         """
         Verify that using the correct dispatch and valid data produces a valid response
         """
-        data = {'formula': "x^2+1/2", 'request_start': 0}
+        data = {"formula": "x^2+1/2", "request_start": 0}
         response = self.the_input.handle_ajax("preview_formcalc", data)
 
-        assert 'preview' in response
-        assert response['preview'] != ''
-        assert response['error'] == ''
-        assert response['request_start'] == data['request_start']
+        assert "preview" in response
+        assert response["preview"] != ""
+        assert response["error"] == ""
+        assert response["request_start"] == data["request_start"]
 
     def test_ajax_bad_method(self):
         """
@@ -1350,50 +1349,57 @@ def test_ajax_no_formula(self):
         """
         response = self.the_input.handle_ajax(
             "preview_formcalc",
-            {'request_start': 1, }
+            {
+                "request_start": 1,
+            },
         )
-        assert 'error' in response
-        assert response['error'] == 'No formula specified.'
+        assert "error" in response
+        assert response["error"] == "No formula specified."
 
     def test_ajax_parse_err(self):
         """
         With parse errors, FormulaEquationInput should give an error message
         """
         # Simulate answering a problem that raises the exception
-        with patch('xmodule.capa.inputtypes.latex_preview') as mock_preview:
+        with patch("xmodule.capa.inputtypes.latex_preview") as mock_preview:
             mock_preview.side_effect = ParseException("Oopsie")
             response = self.the_input.handle_ajax(
                 "preview_formcalc",
-                {'formula': 'x^2+1/2', 'request_start': 1, }
+                {
+                    "formula": "x^2+1/2",
+                    "request_start": 1,
+                },
             )
 
-        assert 'error' in response
-        assert response['error'] == "Sorry, couldn't parse formula"
+        assert "error" in response
+        assert response["error"] == "Sorry, couldn't parse formula"
 
-    @patch('xmodule.capa.inputtypes.log')
+    @patch("xmodule.capa.inputtypes.log")
     def test_ajax_other_err(self, mock_log):
         """
         With other errors, test that FormulaEquationInput also logs it
         """
-        with patch('xmodule.capa.inputtypes.latex_preview') as mock_preview:
+        with patch("xmodule.capa.inputtypes.latex_preview") as mock_preview:
             mock_preview.side_effect = Exception()
             response = self.the_input.handle_ajax(
                 "preview_formcalc",
-                {'formula': 'x^2+1/2', 'request_start': 1, }
+                {
+                    "formula": "x^2+1/2",
+                    "request_start": 1,
+                },
             )
-        mock_log.warning.assert_called_once_with(
-            "Error while previewing formula", exc_info=True
-        )
-        assert 'error' in response
-        assert response['error'] == 'Error while rendering preview'
+        mock_log.warning.assert_called_once_with("Error while previewing formula", exc_info=True)
+        assert "error" in response
+        assert response["error"] == "Error while rendering preview"
 
 
 class DragAndDropTest(unittest.TestCase):
     """
     Check that drag and drop inputs work
     """
+
     def test_rendering(self):
-        path_to_images = '/dummy-static/images/'
+        path_to_images = "/dummy-static/images/"
 
         xml_str = """
         <drag_and_drop_input id="prob_1_2" img="{path}about_1.png" target_outline="false">
@@ -1410,55 +1416,84 @@ def test_rendering(self):
             <target id="t2" x="370" y="160" w="90" h="90"/>
 
         </drag_and_drop_input>
-        """.format(path=path_to_images)
+        """.format(
+            path=path_to_images
+        )
 
         element = etree.fromstring(xml_str)
 
-        value = 'abc'
-        state = {
-            'value': value,
-            'status': 'unsubmitted',
-            'response_data': RESPONSE_DATA
-        }
+        value = "abc"
+        state = {"value": value, "status": "unsubmitted", "response_data": RESPONSE_DATA}
 
         user_input = {  # order matters, for string comparison
-                        "target_outline": "false",
-                        "base_image": "/dummy-static/images/about_1.png",
-                        "draggables": [
-                            {"can_reuse": "", "label": "Label 1", "id": "1", "icon": "", "target_fields": []},
-                            {"can_reuse": "", "label": "cc", "id": "name_with_icon", "icon": "/dummy-static/images/cc.jpg", "target_fields": []},  # lint-amnesty, pylint: disable=line-too-long
-                            {"can_reuse": "", "label": "arrow-left", "id": "with_icon", "icon": "/dummy-static/images/arrow-left.png", "target_fields": []},  # lint-amnesty, pylint: disable=line-too-long
-                            {"can_reuse": "", "label": "Label2", "id": "5", "icon": "", "target_fields": []},
-                            {"can_reuse": "", "label": "Mute", "id": "2", "icon": "/dummy-static/images/mute.png", "target_fields": []},  # lint-amnesty, pylint: disable=line-too-long
-                            {"can_reuse": "", "label": "spinner", "id": "name_label_icon3", "icon": "/dummy-static/images/spinner.gif", "target_fields": []},  # lint-amnesty, pylint: disable=line-too-long
-                            {"can_reuse": "", "label": "Star", "id": "name4", "icon": "/dummy-static/images/volume.png", "target_fields": []},  # lint-amnesty, pylint: disable=line-too-long
-                            {"can_reuse": "", "label": "Label3", "id": "7", "icon": "", "target_fields": []}],
-                        "one_per_target": "True",
-                        "targets": [
-                            {"y": "90", "x": "210", "id": "t1", "w": "90", "h": "90"},
-                            {"y": "160", "x": "370", "id": "t2", "w": "90", "h": "90"}
-                        ]
+            "target_outline": "false",
+            "base_image": "/dummy-static/images/about_1.png",
+            "draggables": [
+                {"can_reuse": "", "label": "Label 1", "id": "1", "icon": "", "target_fields": []},
+                {
+                    "can_reuse": "",
+                    "label": "cc",
+                    "id": "name_with_icon",
+                    "icon": "/dummy-static/images/cc.jpg",
+                    "target_fields": [],
+                },  # lint-amnesty, pylint: disable=line-too-long
+                {
+                    "can_reuse": "",
+                    "label": "arrow-left",
+                    "id": "with_icon",
+                    "icon": "/dummy-static/images/arrow-left.png",
+                    "target_fields": [],
+                },  # lint-amnesty, pylint: disable=line-too-long
+                {"can_reuse": "", "label": "Label2", "id": "5", "icon": "", "target_fields": []},
+                {
+                    "can_reuse": "",
+                    "label": "Mute",
+                    "id": "2",
+                    "icon": "/dummy-static/images/mute.png",
+                    "target_fields": [],
+                },  # lint-amnesty, pylint: disable=line-too-long
+                {
+                    "can_reuse": "",
+                    "label": "spinner",
+                    "id": "name_label_icon3",
+                    "icon": "/dummy-static/images/spinner.gif",
+                    "target_fields": [],
+                },  # lint-amnesty, pylint: disable=line-too-long
+                {
+                    "can_reuse": "",
+                    "label": "Star",
+                    "id": "name4",
+                    "icon": "/dummy-static/images/volume.png",
+                    "target_fields": [],
+                },  # lint-amnesty, pylint: disable=line-too-long
+                {"can_reuse": "", "label": "Label3", "id": "7", "icon": "", "target_fields": []},
+            ],
+            "one_per_target": "True",
+            "targets": [
+                {"y": "90", "x": "210", "id": "t1", "w": "90", "h": "90"},
+                {"y": "160", "x": "370", "id": "t2", "w": "90", "h": "90"},
+            ],
         }
 
-        the_input = lookup_tag('drag_and_drop_input')(mock_capa_system(), element, state)
-        prob_id = 'prob_1_2'
+        the_input = lookup_tag("drag_and_drop_input")(mock_capa_system(), element, state)
+        prob_id = "prob_1_2"
         context = the_input._get_render_context()  # pylint: disable=protected-access
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'value': value,
-            'status': inputtypes.Status('unsubmitted'),
-            'msg': '',
-            'drag_and_drop_json': json.dumps(user_input),
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "value": value,
+            "status": inputtypes.Status("unsubmitted"),
+            "msg": "",
+            "drag_and_drop_json": json.dumps(user_input),
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         # as we are dumping 'draggables' dicts while dumping user_input, string
         # comparison will fail, as order of keys is random.
-        assert json.loads(context['drag_and_drop_json']) == user_input
-        context.pop('drag_and_drop_json')
-        expected.pop('drag_and_drop_json')
+        assert json.loads(context["drag_and_drop_json"]) == user_input
+        context.pop("drag_and_drop_json")
+        expected.pop("drag_and_drop_json")
         assert context == expected
 
 
@@ -1466,8 +1501,9 @@ class AnnotationInputTest(unittest.TestCase):
     """
     Make sure option inputs work
     """
+
     def test_rendering(self):
-        xml_str = '''
+        xml_str = """
 <annotationinput>
     <title>foo</title>
     <text>bar</text>
@@ -1480,47 +1516,42 @@ def test_rendering(self):
         <option choice="partially-correct">z</option>
     </options>
 </annotationinput>
-'''
+"""
         element = etree.fromstring(xml_str)
 
         value = {"comment": "blah blah", "options": [1]}
         json_value = json.dumps(value)
-        state = {
-            'value': json_value,
-            'id': 'annotation_input',
-            'status': 'answered',
-            'response_data': RESPONSE_DATA
-        }
+        state = {"value": json_value, "id": "annotation_input", "status": "answered", "response_data": RESPONSE_DATA}
 
-        tag = 'annotationinput'
+        tag = "annotationinput"
 
         the_input = lookup_tag(tag)(mock_capa_system(), element, state)
 
         context = the_input._get_render_context()  # pylint: disable=protected-access
-        prob_id = 'annotation_input'
+        prob_id = "annotation_input"
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'id': prob_id,
-            'status': inputtypes.Status('answered'),
-            'msg': '',
-            'title': 'foo',
-            'text': 'bar',
-            'comment': 'my comment',
-            'comment_prompt': 'type a commentary',
-            'tag_prompt': 'select a tag',
-            'options': [
-                {'id': 0, 'description': 'x', 'choice': 'correct'},
-                {'id': 1, 'description': 'y', 'choice': 'incorrect'},
-                {'id': 2, 'description': 'z', 'choice': 'partially-correct'}
+            "STATIC_URL": "/dummy-static/",
+            "id": prob_id,
+            "status": inputtypes.Status("answered"),
+            "msg": "",
+            "title": "foo",
+            "text": "bar",
+            "comment": "my comment",
+            "comment_prompt": "type a commentary",
+            "tag_prompt": "select a tag",
+            "options": [
+                {"id": 0, "description": "x", "choice": "correct"},
+                {"id": 1, "description": "y", "choice": "incorrect"},
+                {"id": 2, "description": "z", "choice": "partially-correct"},
             ],
-            'value': json_value,
-            'options_value': value['options'],
-            'has_options_value': len(value['options']) > 0,
-            'comment_value': value['comment'],
-            'debug': False,
-            'return_to_annotation': True,
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "value": json_value,
+            "options_value": value["options"],
+            "has_options_value": len(value["options"]) > 0,
+            "comment_value": value["comment"],
+            "debug": False,
+            "return_to_annotation": True,
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
 
         self.maxDiff = None
@@ -1531,6 +1562,7 @@ class TestChoiceText(unittest.TestCase):
     """
     Tests for checkboxtextgroup inputs
     """
+
     @staticmethod
     def build_choice_element(node_type, contents, tail_text, value):
         """
@@ -1538,9 +1570,9 @@ def build_choice_element(node_type, contents, tail_text, value):
         """
         # When xml is being parsed numtolerance_input and decoy_input tags map to textinput type
         # in order to provide the template with correct rendering information.
-        if node_type in ('numtolerance_input', 'decoy_input'):
-            node_type = 'textinput'
-        choice = {'type': node_type, 'contents': contents, 'tail_text': tail_text, 'value': value}
+        if node_type in ("numtolerance_input", "decoy_input"):
+            node_type = "textinput"
+        choice = {"type": node_type, "contents": contents, "tail_text": tail_text, "value": value}
         return choice
 
     def check_group(self, tag, choice_tag, expected_input_type):
@@ -1557,35 +1589,32 @@ def check_group(self, tag, choice_tag, expected_input_type):
       <{choice_tag} correct="false" name="choiceinput_0">this is<numtolerance_input name="choiceinput_0_textinput_0"/>false</{choice_tag}>
       <choice correct="true" name="choiceinput_1">Is a number<decoy_input name="choiceinput_1_textinput_0"/><text>!</text></choice>
   </{tag}>
-        """.format(tag=tag, choice_tag=choice_tag)
+        """.format(
+            tag=tag, choice_tag=choice_tag
+        )
         element = etree.fromstring(xml_str)
-        prob_id = 'choicetext_input'
-        state = {
-            'value': '{}',
-            'id': prob_id,
-            'status': inputtypes.Status('answered'),
-            'response_data': RESPONSE_DATA
-        }
+        prob_id = "choicetext_input"
+        state = {"value": "{}", "id": prob_id, "status": inputtypes.Status("answered"), "response_data": RESPONSE_DATA}
 
-        first_input = self.build_choice_element('numtolerance_input', 'choiceinput_0_textinput_0', 'false', '')
-        second_input = self.build_choice_element('decoy_input', 'choiceinput_1_textinput_0', '', '')
-        first_choice_content = self.build_choice_element('text', 'this is', '', '')
-        second_choice_content = self.build_choice_element('text', 'Is a number', '', '')
-        second_choice_text = self.build_choice_element('text', "!", '', '')
+        first_input = self.build_choice_element("numtolerance_input", "choiceinput_0_textinput_0", "false", "")
+        second_input = self.build_choice_element("decoy_input", "choiceinput_1_textinput_0", "", "")
+        first_choice_content = self.build_choice_element("text", "this is", "", "")
+        second_choice_content = self.build_choice_element("text", "Is a number", "", "")
+        second_choice_text = self.build_choice_element("text", "!", "", "")
 
         choices = [
-            ('choiceinput_0', [first_choice_content, first_input]),
-            ('choiceinput_1', [second_choice_content, second_input, second_choice_text])
+            ("choiceinput_0", [first_choice_content, first_input]),
+            ("choiceinput_1", [second_choice_content, second_input, second_choice_text]),
         ]
         expected = {
-            'STATIC_URL': '/dummy-static/',
-            'msg': '',
-            'input_type': expected_input_type,
-            'choices': choices,
-            'show_correctness': 'always',
-            'submitted_message': 'Answer received.',
-            'response_data': RESPONSE_DATA,
-            'describedby_html': DESCRIBEDBY.format(status_id=prob_id)
+            "STATIC_URL": "/dummy-static/",
+            "msg": "",
+            "input_type": expected_input_type,
+            "choices": choices,
+            "show_correctness": "always",
+            "submitted_message": "Answer received.",
+            "response_data": RESPONSE_DATA,
+            "describedby_html": DESCRIBEDBY.format(status_id=prob_id),
         }
         expected.update(state)
         the_input = lookup_tag(tag)(mock_capa_system(), element, state)
@@ -1597,21 +1626,21 @@ def test_radiotextgroup(self):
         Test that a properly formatted radiotextgroup problem generates
         expected ouputs
         """
-        self.check_group('radiotextgroup', 'choice', 'radio')
+        self.check_group("radiotextgroup", "choice", "radio")
 
     def test_checkboxtextgroup(self):
         """
         Test that a properly formatted checkboxtextgroup problem generates
         expected ouput
         """
-        self.check_group('checkboxtextgroup', 'choice', 'checkbox')
+        self.check_group("checkboxtextgroup", "choice", "checkbox")
 
     def test_invalid_tag(self):
         """
         Test to ensure that an unrecognized inputtype tag causes an error
         """
         with pytest.raises(Exception):
-            self.check_group('invalid', 'choice', 'checkbox')
+            self.check_group("invalid", "choice", "checkbox")
 
     def test_invalid_input_tag(self):
         """
@@ -1619,30 +1648,31 @@ def test_invalid_input_tag(self):
         a checkbox or radiotextgroup problem raises an error.
         """
         with self.assertRaisesRegex(Exception, "Error in xml"):
-            self.check_group('checkboxtextgroup', 'invalid', 'checkbox')
+            self.check_group("checkboxtextgroup", "invalid", "checkbox")
 
 
 class TestStatus(unittest.TestCase):
     """
     Tests for Status class
     """
+
     def test_str(self):
         """
         Test stringifing Status objects
         """
-        statobj = inputtypes.Status('test')
-        assert str(statobj) == 'test'
+        statobj = inputtypes.Status("test")
+        assert str(statobj) == "test"
 
     def test_classes(self):
         """
         Test that css classnames are correct
         """
         css_classes = [
-            ('unsubmitted', 'unanswered'),
-            ('incomplete', 'incorrect'),
-            ('queued', 'processing'),
-            ('correct', 'correct'),
-            ('test', 'test'),
+            ("unsubmitted", "unanswered"),
+            ("incomplete", "incorrect"),
+            ("queued", "processing"),
+            ("correct", "correct"),
+            ("test", "test"),
         ]
         for status, classname in css_classes:
             statobj = inputtypes.Status(status)
@@ -1653,13 +1683,13 @@ def test_display_names(self):
         Test that display names are correct
         """
         names = [
-            ('correct', 'correct'),
-            ('incorrect', 'incorrect'),
-            ('incomplete', 'incomplete'),
-            ('unanswered', 'unanswered'),
-            ('unsubmitted', 'unanswered'),
-            ('queued', 'processing'),
-            ('dave', 'dave'),
+            ("correct", "correct"),
+            ("incorrect", "incorrect"),
+            ("incomplete", "incomplete"),
+            ("unanswered", "unanswered"),
+            ("unsubmitted", "unanswered"),
+            ("queued", "processing"),
+            ("dave", "dave"),
         ]
         for status, display_name in names:
             statobj = inputtypes.Status(status)
@@ -1671,11 +1701,11 @@ def test_translated_names(self):
         """
         func = lambda t: t.upper()
         # status is in the mapping
-        statobj = inputtypes.Status('queued', func)
-        assert statobj.display_name == 'PROCESSING'
+        statobj = inputtypes.Status("queued", func)
+        assert statobj.display_name == "PROCESSING"
 
         # status is not in the mapping
-        statobj = inputtypes.Status('test', func)
-        assert statobj.display_name == 'test'
-        assert str(statobj) == 'test'
-        assert statobj.classname == 'test'
+        statobj = inputtypes.Status("test", func)
+        assert statobj.display_name == "test"
+        assert str(statobj) == "test"
+        assert statobj.classname == "test"
diff --git a/xmodule/capa/tests/test_responsetypes.py b/xmodule/capa/tests/test_responsetypes.py
index ca9f5eba59a6..711d6c8e3e70 100644
--- a/xmodule/capa/tests/test_responsetypes.py
+++ b/xmodule/capa/tests/test_responsetypes.py
@@ -11,16 +11,16 @@
 from datetime import datetime
 from unittest import mock
 
-import pytest
 import calc
 import pyparsing
+import pytest
 import random2 as random
 import requests
 from pytz import UTC
 
 from xmodule.capa.correctmap import CorrectMap
 from xmodule.capa.responsetypes import LoncapaProblemError, ResponseError, StudentInputError
-from xmodule.capa.tests.helpers import load_fixture, new_loncapa_problem, mock_capa_system
+from xmodule.capa.tests.helpers import load_fixture, mock_capa_system, new_loncapa_problem
 from xmodule.capa.tests.response_xml_factory import (
     AnnotationResponseXMLFactory,
     ChoiceResponseXMLFactory,
@@ -35,7 +35,7 @@
     SchematicResponseXMLFactory,
     StringResponseXMLFactory,
     SymbolicResponseXMLFactory,
-    TrueFalseResponseXMLFactory
+    TrueFalseResponseXMLFactory,
 )
 from xmodule.capa.tests.test_util import use_unsafe_codejail
 from xmodule.capa.util import convert_files_to_filenames
@@ -61,26 +61,26 @@ def build_problem(self, capa_system=None, **kwargs):
 
     # pylint: disable=missing-function-docstring
     def assert_grade(self, problem, submission, expected_correctness, msg=None):
-        input_dict = {'1_2_1': submission}
+        input_dict = {"1_2_1": submission}
         correct_map = problem.grade_answers(input_dict)
         if msg is None:
-            assert correct_map.get_correctness('1_2_1') == expected_correctness
+            assert correct_map.get_correctness("1_2_1") == expected_correctness
         else:
-            assert correct_map.get_correctness('1_2_1') == expected_correctness, msg
+            assert correct_map.get_correctness("1_2_1") == expected_correctness, msg
 
     def assert_answer_format(self, problem):
         answers = problem.get_question_answers()
-        assert answers['1_2_1'] is not None
+        assert answers["1_2_1"] is not None
 
     # pylint: disable=missing-function-docstring
     def assert_multiple_grade(self, problem, correct_answers, incorrect_answers):
         for input_str in correct_answers:
-            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
-            assert result == 'correct'
+            result = problem.grade_answers({"1_2_1": input_str}).get_correctness("1_2_1")
+            assert result == "correct"
 
         for input_str in incorrect_answers:
-            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
-            assert result == 'incorrect'
+            result = problem.grade_answers({"1_2_1": input_str}).get_correctness("1_2_1")
+            assert result == "incorrect"
 
     def assert_multiple_partial(self, problem, correct_answers, incorrect_answers, partial_answers):
         """
@@ -88,16 +88,16 @@ def assert_multiple_partial(self, problem, correct_answers, incorrect_answers, p
         and partially correct answers, all passed as lists.
         """
         for input_str in correct_answers:
-            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
-            assert result == 'correct'
+            result = problem.grade_answers({"1_2_1": input_str}).get_correctness("1_2_1")
+            assert result == "correct"
 
         for input_str in incorrect_answers:
-            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
-            assert result == 'incorrect'
+            result = problem.grade_answers({"1_2_1": input_str}).get_correctness("1_2_1")
+            assert result == "incorrect"
 
         for input_str in partial_answers:
-            result = problem.grade_answers({'1_2_1': input_str}).get_correctness('1_2_1')
-            assert result == 'partially-correct'
+            result = problem.grade_answers({"1_2_1": input_str}).get_correctness("1_2_1")
+            assert result == "partially-correct"
 
     def _get_random_number_code(self):
         """Returns code to be used to generate a random result."""
@@ -117,61 +117,59 @@ def test_multiple_choice_grade(self):
         problem = self.build_problem(choices=[False, True, False])
 
         # Ensure that we get the expected grades
-        self.assert_grade(problem, 'choice_0', 'incorrect')
-        self.assert_grade(problem, 'choice_1', 'correct')
-        self.assert_grade(problem, 'choice_2', 'incorrect')
+        self.assert_grade(problem, "choice_0", "incorrect")
+        self.assert_grade(problem, "choice_1", "correct")
+        self.assert_grade(problem, "choice_2", "incorrect")
 
     def test_partial_multiple_choice_grade(self):
-        problem = self.build_problem(choices=[False, True, 'partial'], credit_type='points')
+        problem = self.build_problem(choices=[False, True, "partial"], credit_type="points")
 
         # Ensure that we get the expected grades
-        self.assert_grade(problem, 'choice_0', 'incorrect')
-        self.assert_grade(problem, 'choice_1', 'correct')
-        self.assert_grade(problem, 'choice_2', 'partially-correct')
+        self.assert_grade(problem, "choice_0", "incorrect")
+        self.assert_grade(problem, "choice_1", "correct")
+        self.assert_grade(problem, "choice_2", "partially-correct")
 
     def test_named_multiple_choice_grade(self):
-        problem = self.build_problem(choices=[False, True, False],
-                                     choice_names=["foil_1", "foil_2", "foil_3"])
+        problem = self.build_problem(choices=[False, True, False], choice_names=["foil_1", "foil_2", "foil_3"])
 
         # Ensure that we get the expected grades
-        self.assert_grade(problem, 'choice_foil_1', 'incorrect')
-        self.assert_grade(problem, 'choice_foil_2', 'correct')
-        self.assert_grade(problem, 'choice_foil_3', 'incorrect')
+        self.assert_grade(problem, "choice_foil_1", "incorrect")
+        self.assert_grade(problem, "choice_foil_2", "correct")
+        self.assert_grade(problem, "choice_foil_3", "incorrect")
 
     def test_multiple_choice_valid_grading_schemes(self):
         # Multiple Choice problems only allow one partial credit scheme.
         # Change this test if that changes.
-        problem = self.build_problem(choices=[False, True, 'partial'], credit_type='points,points')
+        problem = self.build_problem(choices=[False, True, "partial"], credit_type="points,points")
         with pytest.raises(LoncapaProblemError):
-            input_dict = {'1_2_1': 'choice_1'}
+            input_dict = {"1_2_1": "choice_1"}
             problem.grade_answers(input_dict)
 
         # 'bongo' is not a valid grading scheme.
-        problem = self.build_problem(choices=[False, True, 'partial'], credit_type='bongo')
+        problem = self.build_problem(choices=[False, True, "partial"], credit_type="bongo")
         with pytest.raises(LoncapaProblemError):
-            input_dict = {'1_2_1': 'choice_1'}
+            input_dict = {"1_2_1": "choice_1"}
             problem.grade_answers(input_dict)
 
     def test_partial_points_multiple_choice_grade(self):
         problem = self.build_problem(
-            choices=['partial', 'partial', 'partial'],
-            credit_type='points',
-            points=['1', '0.6', '0']
+            choices=["partial", "partial", "partial"], credit_type="points", points=["1", "0.6", "0"]
         )
 
         # Ensure that we get the expected number of points
         # Using assertAlmostEqual to avoid floating point issues
-        correct_map = problem.grade_answers({'1_2_1': 'choice_0'})
-        assert round(correct_map.get_npoints('1_2_1') - 1, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_0"})
+        assert round(correct_map.get_npoints("1_2_1") - 1, 7) >= 0
 
-        correct_map = problem.grade_answers({'1_2_1': 'choice_1'})
-        assert round(correct_map.get_npoints('1_2_1') - 0.6, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_1"})
+        assert round(correct_map.get_npoints("1_2_1") - 0.6, 7) >= 0
 
-        correct_map = problem.grade_answers({'1_2_1': 'choice_2'})
-        assert round(correct_map.get_npoints('1_2_1') - 0, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_2"})
+        assert round(correct_map.get_npoints("1_2_1") - 0, 7) >= 0
 
     def test_contextualized_choices(self):
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             a = 2
             b = 9
             c = a + b
@@ -184,23 +182,19 @@ def test_contextualized_choices(self):
 
             ok2 = "partial"
             text2 = "infinity may be both"
-        """)
+        """
+        )
         choices = ["$ok0", "$ok1", "$ok2"]
-        choice_names = ["$text0 ... (should be $ok0)",
-                        "$text1 ... (should be $ok1)",
-                        "$text2 ... (should be $ok2)"]
-        problem = self.build_problem(script=script,
-                                     choices=choices,
-                                     choice_names=choice_names,
-                                     credit_type='points')
+        choice_names = ["$text0 ... (should be $ok0)", "$text1 ... (should be $ok1)", "$text2 ... (should be $ok2)"]
+        problem = self.build_problem(script=script, choices=choices, choice_names=choice_names, credit_type="points")
 
         # Ensure the expected correctness and choice names
-        self.assert_grade(problem, 'choice_2 + 9 is even ... (should be False)', 'incorrect')
-        self.assert_grade(problem, 'choice_2 + 9 is odd ... (should be True)', 'correct')
-        self.assert_grade(problem, 'choice_infinity may be both ... (should be partial)', 'partially-correct')
+        self.assert_grade(problem, "choice_2 + 9 is even ... (should be False)", "incorrect")
+        self.assert_grade(problem, "choice_2 + 9 is odd ... (should be True)", "correct")
+        self.assert_grade(problem, "choice_infinity may be both ... (should be partial)", "partially-correct")
 
 
-class TrueFalseResponseTest(ResponseTest):   # pylint: disable=missing-class-docstring
+class TrueFalseResponseTest(ResponseTest):  # pylint: disable=missing-class-docstring
     xml_factory_class = TrueFalseResponseXMLFactory
 
     def test_true_false_grade(self):
@@ -208,40 +202,39 @@ def test_true_false_grade(self):
 
         # Check the results
         # Mark correct if and only if ALL (and only) correct choices selected
-        self.assert_grade(problem, 'choice_0', 'incorrect')
-        self.assert_grade(problem, 'choice_1', 'incorrect')
-        self.assert_grade(problem, 'choice_2', 'incorrect')
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2'], 'incorrect')
-        self.assert_grade(problem, ['choice_0', 'choice_2'], 'incorrect')
-        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
-        self.assert_grade(problem, ['choice_1', 'choice_2'], 'correct')
+        self.assert_grade(problem, "choice_0", "incorrect")
+        self.assert_grade(problem, "choice_1", "incorrect")
+        self.assert_grade(problem, "choice_2", "incorrect")
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_2"], "incorrect")
+        self.assert_grade(problem, ["choice_0", "choice_2"], "incorrect")
+        self.assert_grade(problem, ["choice_0", "choice_1"], "incorrect")
+        self.assert_grade(problem, ["choice_1", "choice_2"], "correct")
 
         # Invalid choices should be marked incorrect (we have no choice 3)
-        self.assert_grade(problem, 'choice_3', 'incorrect')
-        self.assert_grade(problem, 'not_a_choice', 'incorrect')
+        self.assert_grade(problem, "choice_3", "incorrect")
+        self.assert_grade(problem, "not_a_choice", "incorrect")
 
     def test_named_true_false_grade(self):
-        problem = self.build_problem(choices=[False, True, True],
-                                     choice_names=['foil_1', 'foil_2', 'foil_3'])
+        problem = self.build_problem(choices=[False, True, True], choice_names=["foil_1", "foil_2", "foil_3"])
 
         # Check the results
         # Mark correct if and only if ALL (and only) correct chocies selected
-        self.assert_grade(problem, 'choice_foil_1', 'incorrect')
-        self.assert_grade(problem, 'choice_foil_2', 'incorrect')
-        self.assert_grade(problem, 'choice_foil_3', 'incorrect')
-        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_2', 'choice_foil_3'], 'incorrect')
-        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_3'], 'incorrect')
-        self.assert_grade(problem, ['choice_foil_1', 'choice_foil_2'], 'incorrect')
-        self.assert_grade(problem, ['choice_foil_2', 'choice_foil_3'], 'correct')
+        self.assert_grade(problem, "choice_foil_1", "incorrect")
+        self.assert_grade(problem, "choice_foil_2", "incorrect")
+        self.assert_grade(problem, "choice_foil_3", "incorrect")
+        self.assert_grade(problem, ["choice_foil_1", "choice_foil_2", "choice_foil_3"], "incorrect")
+        self.assert_grade(problem, ["choice_foil_1", "choice_foil_3"], "incorrect")
+        self.assert_grade(problem, ["choice_foil_1", "choice_foil_2"], "incorrect")
+        self.assert_grade(problem, ["choice_foil_2", "choice_foil_3"], "correct")
 
         # Invalid choices should be marked incorrect
-        self.assert_grade(problem, 'choice_foil_4', 'incorrect')
-        self.assert_grade(problem, 'not_a_choice', 'incorrect')
+        self.assert_grade(problem, "choice_foil_4", "incorrect")
+        self.assert_grade(problem, "not_a_choice", "incorrect")
 
     def test_single_correct_response(self):
         problem = self.build_problem(choices=[True, False])
-        self.assert_grade(problem, 'choice_0', 'correct')
-        self.assert_grade(problem, ['choice_0'], 'correct')
+        self.assert_grade(problem, "choice_0", "correct")
+        self.assert_grade(problem, ["choice_0"], "correct")
 
 
 class ImageResponseTest(ResponseTest):  # pylint: disable=missing-class-docstring
@@ -253,8 +246,7 @@ def test_rectangle_grade(self):
 
         # Anything inside the rectangle (and along the borders) is correct
         # Everything else is incorrect
-        correct_inputs = ["[12,19]", "[10,10]", "[20,20]",
-                          "[10,15]", "[20,15]", "[15,10]", "[15,20]"]
+        correct_inputs = ["[12,19]", "[10,10]", "[20,20]", "[10,15]", "[20,15]", "[15,10]", "[15,20]"]
         incorrect_inputs = ["[4,6]", "[25,15]", "[15,40]", "[15,4]"]
         self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
 
@@ -265,8 +257,7 @@ def test_multiple_rectangles_grade(self):
         # Expect that only points inside the rectangles are marked correct
         problem = self.build_problem(rectangle=rectangle_str)
         correct_inputs = ["[12,19]", "[120, 130]"]
-        incorrect_inputs = ["[4,6]", "[25,15]", "[15,40]", "[15,4]",
-                            "[50,55]", "[300, 14]", "[120, 400]"]
+        incorrect_inputs = ["[4,6]", "[25,15]", "[15,40]", "[15,4]", "[50,55]", "[300, 14]", "[120, 400]"]
         self.assert_multiple_grade(problem, correct_inputs, incorrect_inputs)
 
     def test_region_grade(self):
@@ -315,33 +306,44 @@ def test_grade_single_input_incorrect(self):
 
         # Incorrect answers
         incorrect_inputs = [
-            ('0', ''),
-            ('4x+3y', textwrap.dedent("""
+            ("0", ""),
+            (
+                "4x+3y",
+                textwrap.dedent(
+                    """
                 <math xmlns="http://www.w3.org/1998/Math/MathML">
                     <mstyle displaystyle="true">
                     <mn>4</mn><mo>*</mo><mi>x</mi><mo>+</mo><mn>3</mn><mo>*</mo><mi>y</mi>
-                    </mstyle></math>""")),
+                    </mstyle></math>"""
+                ),
+            ),
         ]
 
-        for (input_str, input_mathml) in incorrect_inputs:
-            self._assert_symbolic_grade(problem, input_str, input_mathml, 'incorrect')
+        for input_str, input_mathml in incorrect_inputs:
+            self._assert_symbolic_grade(problem, input_str, input_mathml, "incorrect")
 
     def test_complex_number_grade_incorrect(self):
 
-        problem = self.build_problem(math_display=True,
-                                     expect="[[cos(theta),i*sin(theta)],[i*sin(theta),cos(theta)]]",
-                                     options=["matrix", "imaginary"])
+        problem = self.build_problem(
+            math_display=True,
+            expect="[[cos(theta),i*sin(theta)],[i*sin(theta),cos(theta)]]",
+            options=["matrix", "imaginary"],
+        )
 
-        wrong_snuggletex = load_fixture('snuggletex_wrong.html')
-        dynamath_input = textwrap.dedent("""
+        wrong_snuggletex = load_fixture("snuggletex_wrong.html")
+        dynamath_input = textwrap.dedent(
+            """
             <math xmlns="http://www.w3.org/1998/Math/MathML">
               <mstyle displaystyle="true"><mn>2</mn></mstyle>
             </math>
-        """)
+        """
+        )
 
         self._assert_symbolic_grade(
-            problem, "2", dynamath_input,
-            'incorrect',
+            problem,
+            "2",
+            dynamath_input,
+            "incorrect",
             snuggletex_resp=wrong_snuggletex,
         )
 
@@ -352,10 +354,7 @@ def test_multiple_inputs_exception(self):
         with pytest.raises(Exception):
             self.build_problem(math_display=True, expect="2*x+3*y", num_inputs=3)
 
-    def _assert_symbolic_grade(
-        self, problem, student_input, dynamath_input, expected_correctness,
-        snuggletex_resp=""
-    ):
+    def _assert_symbolic_grade(self, problem, student_input, dynamath_input, expected_correctness, snuggletex_resp=""):
         """
         Assert that the symbolic response has a certain grade.
 
@@ -365,16 +364,15 @@ def _assert_symbolic_grade(
         `expected_correctness` is either "correct" or "incorrect"
         `snuggletex_resp` is the simulated response from the Snuggletex server
         """
-        input_dict = {'1_2_1': str(student_input),
-                      '1_2_1_dynamath': str(dynamath_input)}
+        input_dict = {"1_2_1": str(student_input), "1_2_1_dynamath": str(dynamath_input)}
 
         # Simulate what the Snuggletex server would respond
-        with mock.patch.object(requests, 'post') as mock_post:
+        with mock.patch.object(requests, "post") as mock_post:
             mock_post.return_value.text = snuggletex_resp
 
             correct_map = problem.grade_answers(input_dict)
 
-            assert correct_map.get_correctness('1_2_1') == expected_correctness
+            assert correct_map.get_correctness("1_2_1") == expected_correctness
 
 
 @use_unsafe_codejail()
@@ -382,8 +380,7 @@ class OptionResponseTest(ResponseTest):  # pylint: disable=missing-class-docstri
     xml_factory_class = OptionResponseXMLFactory
 
     def test_grade(self):
-        problem = self.build_problem(options=["first", "second", "third"],
-                                     correct_option="second")
+        problem = self.build_problem(options=["first", "second", "third"], correct_option="second")
 
         # Assert that we get the expected grades
         self.assert_grade(problem, "first", "incorrect")
@@ -395,34 +392,31 @@ def test_grade(self):
 
     def test_quote_option(self):
         # Test that option response properly escapes quotes inside options strings
-        problem = self.build_problem(options=["hasnot", "hasn't", "has'nt"],
-                                     correct_option="hasn't")
+        problem = self.build_problem(options=["hasnot", "hasn't", "has'nt"], correct_option="hasn't")
 
         # Assert that correct option with a quote inside is marked correctly
         self.assert_grade(problem, "hasnot", "incorrect")
         self.assert_grade(problem, "hasn't", "correct")
-        self.assert_grade(problem, "hasn\'t", "correct")
+        self.assert_grade(problem, "hasn't", "correct")
         self.assert_grade(problem, "has'nt", "incorrect")
 
     def test_variable_options(self):
         """
         Test that if variable are given in option response then correct map must contain answervariable value.
         """
-        script = textwrap.dedent("""\
+        script = textwrap.dedent(
+            """\
         a = 1000
         b = a*2
         c = a*3
-        """)
-        problem = self.build_problem(
-            options=['$a', '$b', '$c'],
-            correct_option='$a',
-            script=script
+        """
         )
+        problem = self.build_problem(options=["$a", "$b", "$c"], correct_option="$a", script=script)
 
-        input_dict = {'1_2_1': '1000'}
+        input_dict = {"1_2_1": "1000"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_correctness('1_2_1') == 'correct'
-        assert correct_map.get_property('1_2_1', 'answervariable') == '$a'
+        assert correct_map.get_correctness("1_2_1") == "correct"
+        assert correct_map.get_property("1_2_1", "answervariable") == "$a"
 
 
 @use_unsafe_codejail()
@@ -430,6 +424,7 @@ class FormulaResponseTest(ResponseTest):
     """
     Test the FormulaResponse class
     """
+
     xml_factory_class = FormulaResponseXMLFactory
 
     def test_grade(self):
@@ -439,13 +434,10 @@ def test_grade(self):
         Specifically, if it can understand equivalence of formulae
         """
         # Sample variables x and y in the range [-10, 10]
-        sample_dict = {'x': (-10, 10), 'y': (-10, 10)}
+        sample_dict = {"x": (-10, 10), "y": (-10, 10)}
 
         # The expected solution is numerically equivalent to x+2y
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance=0.01,
-                                     answer="x+2*y")
+        problem = self.build_problem(sample_dict=sample_dict, num_samples=10, tolerance=0.01, answer="x+2*y")
 
         # Expect an equivalent formula to be marked correct
         # 2x - x + y + y = x + 2y
@@ -462,29 +454,29 @@ def test_hint(self):
         Test the hint-giving functionality of FormulaResponse
         """
         # Sample variables x and y in the range [-10, 10]
-        sample_dict = {'x': (-10, 10), 'y': (-10, 10)}
+        sample_dict = {"x": (-10, 10), "y": (-10, 10)}
 
         # Give a hint if the user leaves off the coefficient
         # or leaves out x
-        hints = [('x + 3*y', 'y_coefficient', 'Check the coefficient of y'),
-                 ('2*y', 'missing_x', 'Try including the variable x')]
+        hints = [
+            ("x + 3*y", "y_coefficient", "Check the coefficient of y"),
+            ("2*y", "missing_x", "Try including the variable x"),
+        ]
 
         # The expected solution is numerically equivalent to x+2y
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance=0.01,
-                                     answer="x+2*y",
-                                     hints=hints)
+        problem = self.build_problem(
+            sample_dict=sample_dict, num_samples=10, tolerance=0.01, answer="x+2*y", hints=hints
+        )
 
         # Expect to receive a hint  if we add an extra y
-        input_dict = {'1_2_1': "x + 2*y + y"}
+        input_dict = {"1_2_1": "x + 2*y + y"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'Check the coefficient of y'
+        assert correct_map.get_hint("1_2_1") == "Check the coefficient of y"
 
         # Expect to receive a hint if we leave out x
-        input_dict = {'1_2_1': "2*y"}
+        input_dict = {"1_2_1": "2*y"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'Try including the variable x'
+        assert correct_map.get_hint("1_2_1") == "Try including the variable x"
 
     def test_script(self):
         """
@@ -495,18 +487,16 @@ def test_script(self):
         script = "calculated_ans = 'x+x'"
 
         # Sample x in the range [-10,10]
-        sample_dict = {'x': (-10, 10)}
+        sample_dict = {"x": (-10, 10)}
 
         # The expected solution is numerically equivalent to 2*x
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance=0.01,
-                                     answer="$calculated_ans",
-                                     script=script)
+        problem = self.build_problem(
+            sample_dict=sample_dict, num_samples=10, tolerance=0.01, answer="$calculated_ans", script=script
+        )
 
         # Expect that the inputs are graded correctly
-        self.assert_grade(problem, '2*x', 'correct')
-        self.assert_grade(problem, '3*x', 'incorrect')
+        self.assert_grade(problem, "2*x", "correct")
+        self.assert_grade(problem, "3*x", "incorrect")
 
     def test_grade_infinity(self):
         """
@@ -514,13 +504,10 @@ def test_grade_infinity(self):
         erroneously marked as correct.
         """
 
-        sample_dict = {'x': (1, 2)}
+        sample_dict = {"x": (1, 2)}
 
         # Test problem
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance="1%",
-                                     answer="x")
+        problem = self.build_problem(sample_dict=sample_dict, num_samples=10, tolerance="1%", answer="x")
         # Expect such a large answer to be marked incorrect
         input_formula = "x*1e999"
         self.assert_grade(problem, input_formula, "incorrect")
@@ -533,13 +520,10 @@ def test_grade_nan(self):
         Test that expressions that evaluate to NaN are not marked as correct.
         """
 
-        sample_dict = {'x': (1, 2)}
+        sample_dict = {"x": (1, 2)}
 
         # Test problem
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance="1%",
-                                     answer="x")
+        problem = self.build_problem(sample_dict=sample_dict, num_samples=10, tolerance="1%", answer="x")
         # Expect an incorrect answer (+ nan) to be marked incorrect
         # Right now this evaluates to 'nan' for a given x (Python implementation-dependent)
         input_formula = "10*x + 0*1e999"
@@ -552,27 +536,21 @@ def test_raises_zero_division_err(self):
         """
         See if division by zero raises an error.
         """
-        sample_dict = {'x': (1, 2)}
-        problem = self.build_problem(sample_dict=sample_dict,
-                                     num_samples=10,
-                                     tolerance="1%",
-                                     answer="x")  # Answer doesn't matter
-        input_dict = {'1_2_1': '1/0'}
+        sample_dict = {"x": (1, 2)}
+        problem = self.build_problem(
+            sample_dict=sample_dict, num_samples=10, tolerance="1%", answer="x"
+        )  # Answer doesn't matter
+        input_dict = {"1_2_1": "1/0"}
         self.assertRaises(StudentInputError, problem.grade_answers, input_dict)
 
     def test_validate_answer(self):
         """
         Makes sure that validate_answer works.
         """
-        sample_dict = {'x': (1, 2)}
-        problem = self.build_problem(
-            sample_dict=sample_dict,
-            num_samples=10,
-            tolerance="1%",
-            answer="x"
-        )
-        assert list(problem.responders.values())[0].validate_answer('14*x')
-        assert not list(problem.responders.values())[0].validate_answer('3*y+2*x')
+        sample_dict = {"x": (1, 2)}
+        problem = self.build_problem(sample_dict=sample_dict, num_samples=10, tolerance="1%", answer="x")
+        assert list(problem.responders.values())[0].validate_answer("14*x")
+        assert not list(problem.responders.values())[0].validate_answer("3*y+2*x")
 
 
 @use_unsafe_codejail()
@@ -639,7 +617,7 @@ def test_regexp(self):
             "Martin Luther King Junior",
             "Doctor Martin Luther King Junior",
             "Dr. Martin Luther King Jr.",
-            "Martin Luther King"
+            "Martin Luther King",
         ]
 
         problem = self.build_problem(answer=r"\w*\.?.*Luther King\s*.*", case_sensitive=True, regexp=True)
@@ -659,10 +637,7 @@ def test_regexp(self):
             "^4|Four$",
         ]
         problem = self.build_problem(
-            answer="just_sample",
-            case_sensitive=False,
-            regexp=True,
-            additional_answers=regexps
+            answer="just_sample", case_sensitive=False, regexp=True, additional_answers=regexps
         )
 
         self.assert_grade(problem, "One", "correct")
@@ -676,7 +651,7 @@ def test_regexp(self):
         self.assert_grade(problem, "|", "incorrect")
 
         # test unicode
-        problem = self.build_problem(answer="æ", case_sensitive=False, regexp=True, additional_answers=['ö'])
+        problem = self.build_problem(answer="æ", case_sensitive=False, regexp=True, additional_answers=["ö"])
         self.assert_grade(problem, "æ", "correct")
         self.assert_grade(problem, "ö", "correct")
         self.assert_grade(problem, "î", "incorrect")
@@ -732,12 +707,8 @@ def test_case_sensitive(self):
         answers = ["Second", "Third", "Fourth"]
 
         # set up problems
-        problem_specified = self.build_problem(
-            answer="sample_answer", case_sensitive=True, additional_answers=answers
-        )
-        problem_not_specified = self.build_problem(
-            answer="sample_answer", additional_answers=answers
-        )
+        problem_specified = self.build_problem(answer="sample_answer", case_sensitive=True, additional_answers=answers)
+        problem_not_specified = self.build_problem(answer="sample_answer", additional_answers=answers)
         problems = [problem_specified, problem_not_specified]
         for problem in problems:
             for answer in answers:
@@ -791,16 +762,16 @@ def test_compatible_non_attribute_additional_answer_xml(self):
         self.assert_grade(problem, "Meh", "incorrect")
 
     def test_partial_matching(self):
-        problem = self.build_problem(answer="a2", case_sensitive=False, regexp=True, additional_answers=['.?\\d.?'])
+        problem = self.build_problem(answer="a2", case_sensitive=False, regexp=True, additional_answers=[".?\\d.?"])
         self.assert_grade(problem, "a3", "correct")
         self.assert_grade(problem, "3a", "correct")
 
     def test_exception(self):
-        problem = self.build_problem(answer="a2", case_sensitive=False, regexp=True, additional_answers=['?\\d?'])
+        problem = self.build_problem(answer="a2", case_sensitive=False, regexp=True, additional_answers=["?\\d?"])
         with pytest.raises(Exception) as cm:
             self.assert_grade(problem, "a3", "correct")
         exception_message = str(cm.value)
-        assert 'nothing to repeat' in exception_message
+        assert "nothing to repeat" in exception_message
 
     def test_hints(self):
 
@@ -814,24 +785,24 @@ def test_hints(self):
             hints=hints,
         )
         # We should get a hint for Wisconsin
-        input_dict = {'1_2_1': 'Wisconsin'}
+        input_dict = {"1_2_1": "Wisconsin"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'The state capital of Wisconsin is Madison'
+        assert correct_map.get_hint("1_2_1") == "The state capital of Wisconsin is Madison"
 
         # We should get a hint for Minnesota
-        input_dict = {'1_2_1': 'Minnesota'}
+        input_dict = {"1_2_1": "Minnesota"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'The state capital of Minnesota is St. Paul'
+        assert correct_map.get_hint("1_2_1") == "The state capital of Minnesota is St. Paul"
 
         # We should NOT get a hint for Michigan (the correct answer)
-        input_dict = {'1_2_1': 'Michigan'}
+        input_dict = {"1_2_1": "Michigan"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == ''
+        assert correct_map.get_hint("1_2_1") == ""
 
         # We should NOT get a hint for any other string
-        input_dict = {'1_2_1': 'California'}
+        input_dict = {"1_2_1": "California"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == ''
+        assert correct_map.get_hint("1_2_1") == ""
 
     def test_hints_regexp_and_answer_regexp(self):
         different_student_answers = [
@@ -846,84 +817,86 @@ def test_hints_regexp_and_answer_regexp(self):
             ("wisconsin", "wisc", "The state capital of Wisconsin is Madison"),
             ("minnesota", "minn", "The state capital of Minnesota is St. Paul"),
             (".*Boston.*", "bst", "First letter of correct answer is M."),
-            ('^\\d9$', "numbers", "Should not end with 9."),
+            ("^\\d9$", "numbers", "Should not end with 9."),
         ]
 
         additional_answers = [
-            '^\\d[0-8]$',
+            "^\\d[0-8]$",
         ]
         problem = self.build_problem(
-            answer="Michigan",
-            case_sensitive=False,
-            hints=hints,
-            additional_answers=additional_answers,
-            regexp=True
+            answer="Michigan", case_sensitive=False, hints=hints, additional_answers=additional_answers, regexp=True
         )
 
         # We should get a hint for Wisconsin
-        input_dict = {'1_2_1': 'Wisconsin'}
+        input_dict = {"1_2_1": "Wisconsin"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'The state capital of Wisconsin is Madison'
+        assert correct_map.get_hint("1_2_1") == "The state capital of Wisconsin is Madison"
 
         # We should get a hint for Minnesota
-        input_dict = {'1_2_1': 'Minnesota'}
+        input_dict = {"1_2_1": "Minnesota"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'The state capital of Minnesota is St. Paul'
+        assert correct_map.get_hint("1_2_1") == "The state capital of Minnesota is St. Paul"
 
         # We should NOT get a hint for Michigan (the correct answer)
-        input_dict = {'1_2_1': 'Michigan'}
+        input_dict = {"1_2_1": "Michigan"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == ''
+        assert correct_map.get_hint("1_2_1") == ""
 
         # We should NOT get a hint for any other string
-        input_dict = {'1_2_1': 'California'}
+        input_dict = {"1_2_1": "California"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == ''
+        assert correct_map.get_hint("1_2_1") == ""
 
         # We should get the same hint for each answer
         for answer in different_student_answers:
-            input_dict = {'1_2_1': answer}
+            input_dict = {"1_2_1": answer}
             correct_map = problem.grade_answers(input_dict)
-            assert correct_map.get_hint('1_2_1') == 'First letter of correct answer is M.'
+            assert correct_map.get_hint("1_2_1") == "First letter of correct answer is M."
 
-        input_dict = {'1_2_1': '59'}
+        input_dict = {"1_2_1": "59"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'Should not end with 9.'
+        assert correct_map.get_hint("1_2_1") == "Should not end with 9."
 
-        input_dict = {'1_2_1': '57'}
+        input_dict = {"1_2_1": "57"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == ''
+        assert correct_map.get_hint("1_2_1") == ""
 
     def test_computed_hints(self):
         problem = self.build_problem(
             answer="Michigan",
             hintfn="gimme_a_hint",
-            script=textwrap.dedent("""
+            script=textwrap.dedent(
+                """
                 def gimme_a_hint(answer_ids, student_answers, new_cmap, old_cmap):
                     aid = answer_ids[0]
                     answer = student_answers[aid]
                     new_cmap.set_hint_and_mode(aid, answer+"??", "always")
-            """)
+            """
+            ),
         )
 
-        input_dict = {'1_2_1': 'Hello'}
+        input_dict = {"1_2_1": "Hello"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_hint('1_2_1') == 'Hello??'
+        assert correct_map.get_hint("1_2_1") == "Hello??"
 
     def test_hint_function_randomization(self):
         # The hint function should get the seed from the problem.
         problem = self.build_problem(
             answer="1",
             hintfn="gimme_a_random_hint",
-            script=textwrap.dedent("""
+            script=textwrap.dedent(
+                """
                 def gimme_a_random_hint(answer_ids, student_answers, new_cmap, old_cmap):
                     answer = {code}
                     new_cmap.set_hint_and_mode(answer_ids[0], answer, "always")
 
-            """.format(code=self._get_random_number_code()))
+            """.format(
+                    code=self._get_random_number_code()
+                )
+            ),
         )
-        correct_map = problem.grade_answers({'1_2_1': '2'})
-        hint = correct_map.get_hint('1_2_1')
+        correct_map = problem.grade_answers({"1_2_1": "2"})
+        hint = correct_map.get_hint("1_2_1")
         assert hint == self._get_random_number_result(problem.seed)
 
     def test_empty_answer_graded_as_incorrect(self):
@@ -941,16 +914,15 @@ def setUp(self):
         super(CodeResponseTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
 
         grader_payload = json.dumps({"grader": "ps04/grade_square.py"})
-        self.problem = self.build_problem(initial_display="def square(x):",
-                                          answer_display="answer",
-                                          grader_payload=grader_payload,
-                                          num_responses=2)
+        self.problem = self.build_problem(
+            initial_display="def square(x):", answer_display="answer", grader_payload=grader_payload, num_responses=2
+        )
 
     @staticmethod
     def make_queuestate(key, time):
         """Create queuestate dict"""
         timestr = datetime.strftime(time, dateformat)
-        return {'key': key, 'time': timestr}
+        return {"key": key, "time": timestr}
 
     def test_is_queued(self):
         """
@@ -977,9 +949,9 @@ def test_is_queued(self):
         assert self.problem.is_queued() is True
 
     def test_update_score(self):
-        '''
+        """
         Test whether LoncapaProblem.update_score can deliver queued result to the right subproblem
-        '''
+        """
         answer_ids = sorted(self.problem.get_question_answers())
 
         # CodeResponse requires internal CorrectMap state. Build it now in the queued state
@@ -990,15 +962,17 @@ def test_update_score(self):
             old_cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
 
         # Message format common to external graders
-        grader_msg = '<span>MESSAGE</span>'   # Must be valid XML
-        correct_score_msg = json.dumps({'correct': True, 'score': 1, 'msg': grader_msg})
-        incorrect_score_msg = json.dumps({'correct': False, 'score': 0, 'msg': grader_msg})
+        grader_msg = "<span>MESSAGE</span>"  # Must be valid XML
+        correct_score_msg = json.dumps({"correct": True, "score": 1, "msg": grader_msg})
+        incorrect_score_msg = json.dumps({"correct": False, "score": 0, "msg": grader_msg})
 
-        xserver_msgs = {'correct': correct_score_msg,
-                        'incorrect': incorrect_score_msg, }
+        xserver_msgs = {
+            "correct": correct_score_msg,
+            "incorrect": incorrect_score_msg,
+        }
 
         # Incorrect queuekey, state should not be updated
-        for correctness in ['correct', 'incorrect']:
+        for correctness in ["correct", "incorrect"]:
             self.problem.correct_map = CorrectMap()
             self.problem.correct_map.update(old_cmap)  # Deep copy
 
@@ -1011,15 +985,17 @@ def test_update_score(self):
                 # Should be still queued, since message undelivered  # lint-amnesty, pylint: disable=line-too-long
 
         # Correct queuekey, state should be updated
-        for correctness in ['correct', 'incorrect']:
+        for correctness in ["correct", "incorrect"]:
             for i, answer_id in enumerate(answer_ids):
                 self.problem.correct_map = CorrectMap()
                 self.problem.correct_map.update(old_cmap)
 
                 new_cmap = CorrectMap()
                 new_cmap.update(old_cmap)
-                npoints = 1 if correctness == 'correct' else 0
-                new_cmap.set(answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None)  # lint-amnesty, pylint: disable=line-too-long
+                npoints = 1 if correctness == "correct" else 0
+                new_cmap.set(
+                    answer_id=answer_id, npoints=npoints, correctness=correctness, msg=grader_msg, queuestate=None
+                )  # lint-amnesty, pylint: disable=line-too-long
 
                 self.problem.update_score(xserver_msgs[correctness], queuekey=1000 + i)
                 assert self.problem.correct_map.get_dict() == new_cmap.get_dict()
@@ -1033,9 +1009,9 @@ def test_update_score(self):
                         # Should be queued, message undelivered  # lint-amnesty, pylint: disable=line-too-long
 
     def test_recentmost_queuetime(self):
-        '''
+        """
         Test whether the LoncapaProblem knows about the time of queue requests
-        '''
+        """
         answer_ids = sorted(self.problem.get_question_answers())
 
         # CodeResponse requires internal CorrectMap state. Build it now in the unqueued state
@@ -1056,44 +1032,50 @@ def test_recentmost_queuetime(self):
         self.problem.correct_map.update(cmap)
 
         # Queue state only tracks up to second
-        latest_timestamp = datetime.strptime(
-            datetime.strftime(latest_timestamp, dateformat), dateformat
-        ).replace(tzinfo=UTC)
+        latest_timestamp = datetime.strptime(datetime.strftime(latest_timestamp, dateformat), dateformat).replace(
+            tzinfo=UTC
+        )
 
         assert self.problem.get_recentmost_queuetime() == latest_timestamp
 
     def test_convert_files_to_filenames(self):
-        '''
+        """
         Test whether file objects are converted to filenames without altering other structures
-        '''
+        """
         problem_file = os.path.join(os.path.dirname(__file__), "test_files/filename_convert_test.txt")
         with open(problem_file) as fp:
-            answers_with_file = {'1_2_1': 'String-based answer',
-                                 '1_3_1': ['answer1', 'answer2', 'answer3'],
-                                 '1_4_1': [fp, fp]}
+            answers_with_file = {
+                "1_2_1": "String-based answer",
+                "1_3_1": ["answer1", "answer2", "answer3"],
+                "1_4_1": [fp, fp],
+            }
             answers_converted = convert_files_to_filenames(answers_with_file)
-            assert answers_converted['1_2_1'] == 'String-based answer'
-            assert answers_converted['1_3_1'] == ['answer1', 'answer2', 'answer3']
-            assert answers_converted['1_4_1'] == [fp.name, fp.name]
+            assert answers_converted["1_2_1"] == "String-based answer"
+            assert answers_converted["1_3_1"] == ["answer1", "answer2", "answer3"]
+            assert answers_converted["1_4_1"] == [fp.name, fp.name]
 
     def test_parse_score_msg_of_responder(self):
         """
         Test whether LoncapaProblem._parse_score_msg correcly parses valid HTML5 html.
         """
         valid_grader_msgs = [
-            '<span>MESSAGE</span>',  # Valid XML
-            textwrap.dedent("""
+            "<span>MESSAGE</span>",  # Valid XML
+            textwrap.dedent(
+                """
                 <div class='matlabResponse'><div id='mwAudioPlaceHolder'>
                 <audio controls autobuffer autoplay src='data:audio/wav;base64='>Audio is not supported on this browser.</audio>
                 <div>Right click <a href=https://endpoint.mss-mathworks.com/media/filename.wav>here</a> and click \"Save As\" to download the file</div></div>
                 <div style='white-space:pre' class='commandWindowOutput'></div><ul></ul></div>
-            """).replace('\n', ''),  # Valid HTML5 real case Matlab response, invalid XML
-            '<aaa></bbb>'  # Invalid XML, but will be parsed by html5lib to <aaa/>
+            """
+            ).replace(
+                "\n", ""
+            ),  # Valid HTML5 real case Matlab response, invalid XML
+            "<aaa></bbb>",  # Invalid XML, but will be parsed by html5lib to <aaa/>
         ]
 
         invalid_grader_msgs = [
-            '<audio',  # invalid XML and HTML5
-            '<p>\b</p>',  # invalid special character
+            "<audio",  # invalid XML and HTML5
+            "<p>\b</p>",  # invalid special character
         ]
 
         answer_ids = sorted(self.problem.get_question_answers())
@@ -1106,27 +1088,33 @@ def test_parse_score_msg_of_responder(self):
             old_cmap.update(CorrectMap(answer_id=answer_id, queuestate=queuestate))
 
         for grader_msg in valid_grader_msgs:
-            correct_score_msg = json.dumps({'correct': True, 'score': 1, 'msg': grader_msg})
-            incorrect_score_msg = json.dumps({'correct': False, 'score': 0, 'msg': grader_msg})
-            xserver_msgs = {'correct': correct_score_msg, 'incorrect': incorrect_score_msg, }
+            correct_score_msg = json.dumps({"correct": True, "score": 1, "msg": grader_msg})
+            incorrect_score_msg = json.dumps({"correct": False, "score": 0, "msg": grader_msg})
+            xserver_msgs = {
+                "correct": correct_score_msg,
+                "incorrect": incorrect_score_msg,
+            }
 
             for i, answer_id in enumerate(answer_ids):
                 self.problem.correct_map = CorrectMap()
                 self.problem.correct_map.update(old_cmap)
-                output = self.problem.update_score(xserver_msgs['correct'], queuekey=1000 + i)
-                assert output[answer_id]['msg'] == grader_msg
+                output = self.problem.update_score(xserver_msgs["correct"], queuekey=1000 + i)
+                assert output[answer_id]["msg"] == grader_msg
 
         for grader_msg in invalid_grader_msgs:
-            correct_score_msg = json.dumps({'correct': True, 'score': 1, 'msg': grader_msg})
-            incorrect_score_msg = json.dumps({'correct': False, 'score': 0, 'msg': grader_msg})
-            xserver_msgs = {'correct': correct_score_msg, 'incorrect': incorrect_score_msg, }
+            correct_score_msg = json.dumps({"correct": True, "score": 1, "msg": grader_msg})
+            incorrect_score_msg = json.dumps({"correct": False, "score": 0, "msg": grader_msg})
+            xserver_msgs = {
+                "correct": correct_score_msg,
+                "incorrect": incorrect_score_msg,
+            }
 
             for i, answer_id in enumerate(answer_ids):
                 self.problem.correct_map = CorrectMap()
                 self.problem.correct_map.update(old_cmap)
 
-                output = self.problem.update_score(xserver_msgs['correct'], queuekey=1000 + i)
-                assert output[answer_id]['msg'] == 'Invalid grader reply. Please contact the course staff.'
+                output = self.problem.update_score(xserver_msgs["correct"], queuekey=1000 + i)
+                assert output[answer_id]["msg"] == "Invalid grader reply. Please contact the course staff."
 
 
 @use_unsafe_codejail()
@@ -1134,151 +1122,122 @@ class ChoiceResponseTest(ResponseTest):  # pylint: disable=missing-class-docstri
     xml_factory_class = ChoiceResponseXMLFactory
 
     def test_radio_group_grade(self):
-        problem = self.build_problem(choice_type='radio',
-                                     choices=[False, True, False])
+        problem = self.build_problem(choice_type="radio", choices=[False, True, False])
 
         # Check that we get the expected results
-        self.assert_grade(problem, 'choice_0', 'incorrect')
-        self.assert_grade(problem, 'choice_1', 'correct')
-        self.assert_grade(problem, 'choice_2', 'incorrect')
+        self.assert_grade(problem, "choice_0", "incorrect")
+        self.assert_grade(problem, "choice_1", "correct")
+        self.assert_grade(problem, "choice_2", "incorrect")
 
         # No choice 3 exists --> mark incorrect
-        self.assert_grade(problem, 'choice_3', 'incorrect')
+        self.assert_grade(problem, "choice_3", "incorrect")
 
     def test_checkbox_group_grade(self):
-        problem = self.build_problem(choice_type='checkbox',
-                                     choices=[False, True, True])
+        problem = self.build_problem(choice_type="checkbox", choices=[False, True, True])
 
         # Check that we get the expected results
         # (correct if and only if BOTH correct choices chosen)
-        self.assert_grade(problem, ['choice_1', 'choice_2'], 'correct')
-        self.assert_grade(problem, 'choice_1', 'incorrect')
-        self.assert_grade(problem, 'choice_2', 'incorrect')
-        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
-        self.assert_grade(problem, ['choice_0', 'choice_2'], 'incorrect')
+        self.assert_grade(problem, ["choice_1", "choice_2"], "correct")
+        self.assert_grade(problem, "choice_1", "incorrect")
+        self.assert_grade(problem, "choice_2", "incorrect")
+        self.assert_grade(problem, ["choice_0", "choice_1"], "incorrect")
+        self.assert_grade(problem, ["choice_0", "choice_2"], "incorrect")
 
         # No choice 3 exists --> mark incorrect
-        self.assert_grade(problem, 'choice_3', 'incorrect')
+        self.assert_grade(problem, "choice_3", "incorrect")
 
     def test_checkbox_group_valid_grading_schemes(self):
         # Checkbox-type problems only allow one partial credit scheme.
         # Change this test if that changes.
         problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='edc,halves,bongo'
+            choice_type="checkbox", choices=[False, False, True, True], credit_type="edc,halves,bongo"
         )
         with pytest.raises(LoncapaProblemError):
-            input_dict = {'1_2_1': 'choice_1'}
+            input_dict = {"1_2_1": "choice_1"}
             problem.grade_answers(input_dict)
 
         # 'bongo' is not a valid grading scheme.
-        problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='bongo'
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, True, True], credit_type="bongo")
         with pytest.raises(LoncapaProblemError):
-            input_dict = {'1_2_1': 'choice_1'}
+            input_dict = {"1_2_1": "choice_1"}
             problem.grade_answers(input_dict)
 
     def test_checkbox_group_partial_credit_grade(self):
         # First: Every Decision Counts grading style
-        problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='edc'
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, True, True], credit_type="edc")
 
         # Check that we get the expected results
         # (correct if and only if BOTH correct choices chosen)
         # (partially correct if at least one choice is right)
         # (incorrect if totally wrong)
-        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
-        self.assert_grade(problem, ['choice_2', 'choice_3'], 'correct')
-        self.assert_grade(problem, 'choice_0', 'partially-correct')
-        self.assert_grade(problem, 'choice_2', 'partially-correct')
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2', 'choice_3'], 'partially-correct')
+        self.assert_grade(problem, ["choice_0", "choice_1"], "incorrect")
+        self.assert_grade(problem, ["choice_2", "choice_3"], "correct")
+        self.assert_grade(problem, "choice_0", "partially-correct")
+        self.assert_grade(problem, "choice_2", "partially-correct")
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_2", "choice_3"], "partially-correct")
 
         # Second: Halves grading style
-        problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='halves'
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, True, True], credit_type="halves")
 
         # Check that we get the expected results
         # (correct if and only if BOTH correct choices chosen)
         # (partially correct on one error)
         # (incorrect for more errors, at least with this # of choices.)
-        self.assert_grade(problem, ['choice_0', 'choice_1'], 'incorrect')
-        self.assert_grade(problem, ['choice_2', 'choice_3'], 'correct')
-        self.assert_grade(problem, 'choice_2', 'partially-correct')
-        self.assert_grade(problem, ['choice_1', 'choice_2', 'choice_3'], 'partially-correct')
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2', 'choice_3'], 'incorrect')
+        self.assert_grade(problem, ["choice_0", "choice_1"], "incorrect")
+        self.assert_grade(problem, ["choice_2", "choice_3"], "correct")
+        self.assert_grade(problem, "choice_2", "partially-correct")
+        self.assert_grade(problem, ["choice_1", "choice_2", "choice_3"], "partially-correct")
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_2", "choice_3"], "incorrect")
 
         # Third: Halves grading style with more options
         problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True, False],
-            credit_type='halves'
+            choice_type="checkbox", choices=[False, False, True, True, False], credit_type="halves"
         )
 
         # Check that we get the expected results
         # (2 errors allowed with 5+ choices)
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_4'], 'incorrect')
-        self.assert_grade(problem, ['choice_2', 'choice_3'], 'correct')
-        self.assert_grade(problem, 'choice_2', 'partially-correct')
-        self.assert_grade(problem, ['choice_1', 'choice_2', 'choice_3'], 'partially-correct')
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2', 'choice_3'], 'partially-correct')
-        self.assert_grade(problem, ['choice_0', 'choice_1', 'choice_2', 'choice_3', 'choice_4'], 'incorrect')
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_4"], "incorrect")
+        self.assert_grade(problem, ["choice_2", "choice_3"], "correct")
+        self.assert_grade(problem, "choice_2", "partially-correct")
+        self.assert_grade(problem, ["choice_1", "choice_2", "choice_3"], "partially-correct")
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_2", "choice_3"], "partially-correct")
+        self.assert_grade(problem, ["choice_0", "choice_1", "choice_2", "choice_3", "choice_4"], "incorrect")
 
     def test_checkbox_group_partial_points_grade(self):
         # Ensure that we get the expected number of points
         # Using assertAlmostEqual to avoid floating point issues
         # First: Every Decision Counts grading style
-        problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='edc'
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, True, True], credit_type="edc")
 
-        correct_map = problem.grade_answers({'1_2_1': 'choice_2'})
-        assert round(correct_map.get_npoints('1_2_1') - 0.75, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_2"})
+        assert round(correct_map.get_npoints("1_2_1") - 0.75, 7) >= 0
 
         # Second: Halves grading style
-        problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True],
-            credit_type='halves'
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, True, True], credit_type="halves")
 
-        correct_map = problem.grade_answers({'1_2_1': 'choice_2'})
-        assert round(correct_map.get_npoints('1_2_1') - 0.5, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_2"})
+        assert round(correct_map.get_npoints("1_2_1") - 0.5, 7) >= 0
 
         # Third: Halves grading style with more options
         problem = self.build_problem(
-            choice_type='checkbox',
-            choices=[False, False, True, True, False],
-            credit_type='halves'
+            choice_type="checkbox", choices=[False, False, True, True, False], credit_type="halves"
         )
 
-        correct_map = problem.grade_answers({'1_2_1': 'choice_2,choice4'})
-        assert round(correct_map.get_npoints('1_2_1') - 0.25, 7) >= 0
+        correct_map = problem.grade_answers({"1_2_1": "choice_2,choice4"})
+        assert round(correct_map.get_npoints("1_2_1") - 0.25, 7) >= 0
 
     def test_grade_with_no_checkbox_selected(self):
         """
         Test that answer marked as incorrect if no checkbox selected.
         """
-        problem = self.build_problem(
-            choice_type='checkbox', choices=[False, False, False]
-        )
+        problem = self.build_problem(choice_type="checkbox", choices=[False, False, False])
 
         correct_map = problem.grade_answers({})
-        assert correct_map.get_correctness('1_2_1') == 'incorrect'
+        assert correct_map.get_correctness("1_2_1") == "incorrect"
 
     def test_contextualized_choices(self):
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             a = 6
             b = 4
             c = a + b
@@ -1287,15 +1246,14 @@ def test_contextualized_choices(self):
             ok1 = c % 3 == 0 # check remainder modulo 3
             ok2 = c % 5 == 0 # check remainder modulo 5
             ok3 = not any((ok0, ok1, ok2))
-        """)
+        """
+        )
         choices = ["$ok0", "$ok1", "$ok2", "$ok3"]
-        problem = self.build_problem(script=script,
-                                     choice_type='checkbox',
-                                     choices=choices)
+        problem = self.build_problem(script=script, choice_type="checkbox", choices=choices)
 
         # Ensure the expected correctness
-        self.assert_grade(problem, ['choice_0', 'choice_2'], 'correct')
-        self.assert_grade(problem, ['choice_1', 'choice_3'], 'incorrect')
+        self.assert_grade(problem, ["choice_0", "choice_2"], "correct")
+        self.assert_grade(problem, ["choice_1", "choice_3"], "incorrect")
 
 
 @use_unsafe_codejail()
@@ -1308,10 +1266,10 @@ class NumericalResponseTest(ResponseTest):  # pylint: disable=missing-class-docs
     def test_grade_range_tolerance(self):
         problem_setup = [
             # [given_answer, [list of correct responses], [list of incorrect responses]]
-            ['[5, 7)', ['5', '6', '6.999'], ['4.999', '7']],
-            ['[1.6e-5, 1.9e24)', ['0.000016', '1.6*10^-5', '1.59e24'], ['1.59e-5', '1.9e24', '1.9*10^24']],
-            ['[0, 1.6e-5]', ['1.6*10^-5'], ["2"]],
-            ['(1.6e-5, 10]', ["2"], ['1.6*10^-5']],
+            ["[5, 7)", ["5", "6", "6.999"], ["4.999", "7"]],
+            ["[1.6e-5, 1.9e24)", ["0.000016", "1.6*10^-5", "1.59e24"], ["1.59e-5", "1.9e24", "1.9*10^24"]],
+            ["[0, 1.6e-5]", ["1.6*10^-5"], ["2"]],
+            ["(1.6e-5, 10]", ["2"], ["1.6*10^-5"]],
         ]
         for given_answer, correct_responses, incorrect_responses in problem_setup:
             problem = self.build_problem(answer=given_answer)
@@ -1321,49 +1279,47 @@ def test_additional_answer_grading(self):
         """
         Test additional answers are graded correct with their associated correcthint.
         """
-        primary_answer = '100'
-        primary_correcthint = 'primary feedback'
+        primary_answer = "100"
+        primary_correcthint = "primary feedback"
         additional_answers = {
-            '1': '1. additional feedback',
-            '2': '2. additional feedback',
-            '4': '4. additional feedback',
-            '5': ''
+            "1": "1. additional feedback",
+            "2": "2. additional feedback",
+            "4": "4. additional feedback",
+            "5": "",
         }
         problem = self.build_problem(
-            answer=primary_answer,
-            additional_answers=additional_answers,
-            correcthint=primary_correcthint
+            answer=primary_answer, additional_answers=additional_answers, correcthint=primary_correcthint
         )
 
         # Assert primary answer is graded correctly.
-        correct_map = problem.grade_answers({'1_2_1': primary_answer})
-        assert correct_map.get_correctness('1_2_1') == 'correct'
-        assert primary_correcthint in correct_map.get_msg('1_2_1')
+        correct_map = problem.grade_answers({"1_2_1": primary_answer})
+        assert correct_map.get_correctness("1_2_1") == "correct"
+        assert primary_correcthint in correct_map.get_msg("1_2_1")
 
         # Assert additional answers are graded correct
         for answer, correcthint in additional_answers.items():
-            correct_map = problem.grade_answers({'1_2_1': answer})
-            assert correct_map.get_correctness('1_2_1') == 'correct'
-            assert correcthint in correct_map.get_msg('1_2_1')
+            correct_map = problem.grade_answers({"1_2_1": answer})
+            assert correct_map.get_correctness("1_2_1") == "correct"
+            assert correcthint in correct_map.get_msg("1_2_1")
 
     def test_additional_answer_get_score(self):
         """
         Test `get_score` is working for additional answers.
         """
-        problem = self.build_problem(answer='100', additional_answers={'1': ''})
+        problem = self.build_problem(answer="100", additional_answers={"1": ""})
         responder = list(problem.responders.values())[0]
 
         # Check primary answer.
-        new_cmap = responder.get_score({'1_2_1': '100'})
-        assert new_cmap.get_correctness('1_2_1') == 'correct'
+        new_cmap = responder.get_score({"1_2_1": "100"})
+        assert new_cmap.get_correctness("1_2_1") == "correct"
 
         # Check additional answer.
-        new_cmap = responder.get_score({'1_2_1': '1'})
-        assert new_cmap.get_correctness('1_2_1') == 'correct'
+        new_cmap = responder.get_score({"1_2_1": "1"})
+        assert new_cmap.get_correctness("1_2_1") == "correct"
 
         # Check any wrong answer.
-        new_cmap = responder.get_score({'1_2_1': '2'})
-        assert new_cmap.get_correctness('1_2_1') == 'incorrect'
+        new_cmap = responder.get_score({"1_2_1": "2"})
+        assert new_cmap.get_correctness("1_2_1") == "incorrect"
 
     def test_grade_range_tolerance_partial_credit(self):
         problem_setup = [
@@ -1371,63 +1327,43 @@ def test_grade_range_tolerance_partial_credit(self):
             #   [list of correct responses],
             #   [list of incorrect responses],
             #   [list of partially correct responses]]
-            [
-                '[5, 7)',
-                ['5', '6', '6.999'],
-                ['0', '100'],
-                ['4', '8']
-            ],
-            [
-                '[1.6e-5, 1.9e24)',
-                ['0.000016', '1.6*10^-5', '1.59e24'],
-                ['-1e26', '1.9e26', '1.9*10^26'],
-                ['0', '2e24']
-            ],
-            [
-                '[0, 1.6e-5]',
-                ['1.6*10^-5'],
-                ['2'],
-                ['1.9e-5', '-1e-6']
-            ],
-            [
-                '(1.6e-5, 10]',
-                ['2'],
-                ['-20', '30'],
-                ['-1', '12']
-            ],
+            ["[5, 7)", ["5", "6", "6.999"], ["0", "100"], ["4", "8"]],
+            ["[1.6e-5, 1.9e24)", ["0.000016", "1.6*10^-5", "1.59e24"], ["-1e26", "1.9e26", "1.9*10^26"], ["0", "2e24"]],
+            ["[0, 1.6e-5]", ["1.6*10^-5"], ["2"], ["1.9e-5", "-1e-6"]],
+            ["(1.6e-5, 10]", ["2"], ["-20", "30"], ["-1", "12"]],
         ]
         for given_answer, correct_responses, incorrect_responses, partial_responses in problem_setup:
-            problem = self.build_problem(answer=given_answer, credit_type='close')
+            problem = self.build_problem(answer=given_answer, credit_type="close")
             self.assert_multiple_partial(problem, correct_responses, incorrect_responses, partial_responses)
 
     def test_grade_range_tolerance_exceptions(self):
         # no complex number in range tolerance staff answer
-        problem = self.build_problem(answer='[1j, 5]')
-        input_dict = {'1_2_1': '3'}
+        problem = self.build_problem(answer="[1j, 5]")
+        input_dict = {"1_2_1": "3"}
         with pytest.raises(StudentInputError):
             problem.grade_answers(input_dict)
 
         # no complex numbers in student ansers to range tolerance problems
-        problem = self.build_problem(answer='(1, 5)')
-        input_dict = {'1_2_1': '1*J'}
+        problem = self.build_problem(answer="(1, 5)")
+        input_dict = {"1_2_1": "1*J"}
         with pytest.raises(StudentInputError):
             problem.grade_answers(input_dict)
 
         # test isnan student input: no exception,
         # but problem should be graded as incorrect
-        problem = self.build_problem(answer='(1, 5)')
-        input_dict = {'1_2_1': ''}
+        problem = self.build_problem(answer="(1, 5)")
+        input_dict = {"1_2_1": ""}
         correct_map = problem.grade_answers(input_dict)
-        correctness = correct_map.get_correctness('1_2_1')
-        assert correctness == 'incorrect'
+        correctness = correct_map.get_correctness("1_2_1")
+        assert correctness == "incorrect"
 
         # test invalid range tolerance answer
         with pytest.raises(StudentInputError):
-            problem = self.build_problem(answer='(1 5)')
+            problem = self.build_problem(answer="(1 5)")
 
         # test empty boundaries
-        problem = self.build_problem(answer='(1, ]')
-        input_dict = {'1_2_1': '3'}
+        problem = self.build_problem(answer="(1, ]")
+        input_dict = {"1_2_1": "3"}
         with pytest.raises(StudentInputError):
             problem.grade_answers(input_dict)
 
@@ -1439,34 +1375,21 @@ def test_grade_exact(self):
 
     def test_grade_partial(self):
         # First: "list"-style grading scheme.
-        problem = self.build_problem(
-            answer=4,
-            credit_type='list',
-            partial_answers='2,8,-4'
-        )
+        problem = self.build_problem(answer=4, credit_type="list", partial_answers="2,8,-4")
         correct_responses = ["4", "4.0"]
         incorrect_responses = ["1", "3", "4.1", "0", "-2"]
         partial_responses = ["2", "2.0", "-4", "-4.0", "8", "8.0"]
         self.assert_multiple_partial(problem, correct_responses, incorrect_responses, partial_responses)
 
         # Second: "close"-style grading scheme. Default range is twice tolerance.
-        problem = self.build_problem(
-            answer=4,
-            tolerance=0.2,
-            credit_type='close'
-        )
+        problem = self.build_problem(answer=4, tolerance=0.2, credit_type="close")
         correct_responses = ["4", "4.1", "3.9"]
         incorrect_responses = ["1", "3", "4.5", "0", "-2"]
         partial_responses = ["4.3", "3.7"]
         self.assert_multiple_partial(problem, correct_responses, incorrect_responses, partial_responses)
 
         # Third: "close"-style grading scheme with partial_range set.
-        problem = self.build_problem(
-            answer=4,
-            tolerance=0.2,
-            partial_range=3,
-            credit_type='close'
-        )
+        problem = self.build_problem(answer=4, tolerance=0.2, partial_range=3, credit_type="close")
         correct_responses = ["4", "4.1"]
         incorrect_responses = ["1", "3", "0", "-2"]
         partial_responses = ["4.5", "3.5"]
@@ -1474,11 +1397,7 @@ def test_grade_partial(self):
 
         # Fourth: both "list"- and "close"-style grading schemes at once.
         problem = self.build_problem(
-            answer=4,
-            tolerance=0.2,
-            partial_range=3,
-            credit_type='close,list',
-            partial_answers='2,8,-4'
+            answer=4, tolerance=0.2, partial_range=3, credit_type="close,list", partial_answers="2,8,-4"
         )
         correct_responses = ["4", "4.0"]
         incorrect_responses = ["1", "3", "0", "-2"]
@@ -1487,8 +1406,8 @@ def test_grade_partial(self):
 
     def test_numerical_valid_grading_schemes(self):
         # 'bongo' is not a valid grading scheme.
-        problem = self.build_problem(answer=4, tolerance=0.1, credit_type='bongo')
-        input_dict = {'1_2_1': '4'}
+        problem = self.build_problem(answer=4, tolerance=0.1, credit_type="bongo")
+        input_dict = {"1_2_1": "4"}
         with pytest.raises(LoncapaProblemError):
             problem.grade_answers(input_dict)
 
@@ -1537,7 +1456,7 @@ def test_floats(self):
             [0.000016, ["1.6*10^-5"], ["0.000165"]],
             [1.9e24, ["1.9*10^24"], ["1.9001*10^24"]],
             [2e-15, ["2*10^-15"], [""]],
-            [3141592653589793238., ["3141592653589793115."], [""]],
+            [3141592653589793238.0, ["3141592653589793115."], [""]],
             [0.1234567, ["0.123456", "0.1234561"], ["0.123451"]],
             [1e-5, ["1e-5", "1.0e-5"], ["-1e-5", "2*1e-5"]],
         ]
@@ -1569,7 +1488,7 @@ def test_grade_with_script(self):
     def test_raises_zero_division_err(self):
         """See if division by zero is handled correctly."""
         problem = self.build_problem(answer="1")  # Answer doesn't matter
-        input_dict = {'1_2_1': '1/0'}
+        input_dict = {"1_2_1": "1/0"}
         with pytest.raises(StudentInputError):
             problem.grade_answers(input_dict)
 
@@ -1583,9 +1502,9 @@ def test_staff_inputs_expressions(self):
     def test_staff_inputs_expressions_legacy(self):
         """Test that staff may enter in a complex number as the answer."""
         problem = self.build_problem(answer="1+1j", tolerance=1e-3)
-        self.assert_grade(problem, '1+j', 'correct')
+        self.assert_grade(problem, "1+j", "correct")
 
-    @mock.patch('xmodule.capa.responsetypes.log')
+    @mock.patch("xmodule.capa.responsetypes.log")
     def test_staff_inputs_bad_syntax(self, mock_log):
         """Test that staff may enter in a complex number as the answer."""
         staff_ans = "clearly bad syntax )[+1e"
@@ -1593,13 +1512,11 @@ def test_staff_inputs_bad_syntax(self, mock_log):
 
         msg = "There was a problem with the staff answer to this problem"
         with self.assertRaisesRegex(StudentInputError, msg):
-            self.assert_grade(problem, '1+j', 'correct')
+            self.assert_grade(problem, "1+j", "correct")
 
-        mock_log.debug.assert_called_once_with(
-            "Content error--answer '%s' is not a valid number", staff_ans
-        )
+        mock_log.debug.assert_called_once_with("Content error--answer '%s' is not a valid number", staff_ans)
 
-    @mock.patch('xmodule.capa.responsetypes.log')
+    @mock.patch("xmodule.capa.responsetypes.log")
     def test_responsetype_i18n(self, mock_log):  # lint-amnesty, pylint: disable=unused-argument
         """Test that LoncapaSystem has an i18n that works."""
         staff_ans = "clearly bad syntax )[+1e"
@@ -1607,17 +1524,19 @@ def test_responsetype_i18n(self, mock_log):  # lint-amnesty, pylint: disable=unu
 
         class FakeTranslations(object):
             """A fake gettext.Translations object."""
+
             def ugettext(self, text):
                 """Return the 'translation' of `text`."""
                 if text == "There was a problem with the staff answer to this problem.":
                     text = "TRANSLATED!"
                 return text
+
             gettext = ugettext
 
         problem.capa_system.i18n = FakeTranslations()
 
         with self.assertRaisesRegex(StudentInputError, "TRANSLATED!"):
-            self.assert_grade(problem, '1+j', 'correct')
+            self.assert_grade(problem, "1+j", "correct")
 
     def test_grade_infinity(self):
         """
@@ -1627,23 +1546,23 @@ def test_grade_infinity(self):
         pass with any arbitrarily large student answer.
         """
         mapping = {
-            'some big input': float('inf'),
-            'some neg input': -float('inf'),
-            'weird NaN input': float('nan'),
-            '4': 4
+            "some big input": float("inf"),
+            "some neg input": -float("inf"),
+            "weird NaN input": float("nan"),
+            "4": 4,
         }
 
         def evaluator_side_effect(_, __, math_string):
             """Look up the given response for `math_string`."""
             return mapping[math_string]
 
-        problem = self.build_problem(answer=4, tolerance='10%')
+        problem = self.build_problem(answer=4, tolerance="10%")
 
-        with mock.patch('xmodule.capa.responsetypes.evaluator') as mock_eval:
+        with mock.patch("xmodule.capa.responsetypes.evaluator") as mock_eval:
             mock_eval.side_effect = evaluator_side_effect
-            self.assert_grade(problem, 'some big input', 'incorrect')
-            self.assert_grade(problem, 'some neg input', 'incorrect')
-            self.assert_grade(problem, 'weird NaN input', 'incorrect')
+            self.assert_grade(problem, "some big input", "incorrect")
+            self.assert_grade(problem, "some neg input", "incorrect")
+            self.assert_grade(problem, "weird NaN input", "incorrect")
 
     def test_err_handling(self):
         """
@@ -1652,39 +1571,42 @@ def test_err_handling(self):
         problem = self.build_problem(answer=4)
 
         errors = [  # (exception raised, message to student)
-            (calc.UndefinedVariable("Invalid Input: x not permitted in answer as a variable"),
-             r"Invalid Input: x not permitted in answer as a variable"),
+            (
+                calc.UndefinedVariable("Invalid Input: x not permitted in answer as a variable"),
+                r"Invalid Input: x not permitted in answer as a variable",
+            ),
             (ValueError("factorial() mess-up"), "Factorial function evaluated outside its domain"),
             (ValueError(), "Could not interpret '.*' as a number"),
             (pyparsing.ParseException("oopsie"), "Invalid math syntax"),
-            (ZeroDivisionError(), "Could not interpret '.*' as a number")
+            (ZeroDivisionError(), "Could not interpret '.*' as a number"),
         ]
 
-        with mock.patch('xmodule.capa.responsetypes.evaluator') as mock_eval:
+        with mock.patch("xmodule.capa.responsetypes.evaluator") as mock_eval:
             for err, msg_regex in errors:
 
                 def evaluator_side_effect(_, __, math_string):
                     """Raise an error only for the student input."""
-                    if math_string != '4':
+                    if math_string != "4":
                         raise err  # lint-amnesty, pylint: disable=cell-var-from-loop
+
                 mock_eval.side_effect = evaluator_side_effect
 
                 with self.assertRaisesRegex(StudentInputError, msg_regex):
-                    problem.grade_answers({'1_2_1': 'foobar'})
+                    problem.grade_answers({"1_2_1": "foobar"})
 
     def test_compare_answer(self):
         """Tests the answer compare function."""
         problem = self.build_problem(answer="42")
         responder = list(problem.responders.values())[0]
-        assert responder.compare_answer('48', '8*6')
-        assert not responder.compare_answer('48', '9*5')
+        assert responder.compare_answer("48", "8*6")
+        assert not responder.compare_answer("48", "9*5")
 
     def test_validate_answer(self):
         """Tests the answer validation function."""
         problem = self.build_problem(answer="42")
         responder = list(problem.responders.values())[0]
-        assert responder.validate_answer('23.5')
-        assert not responder.validate_answer('fish')
+        assert responder.validate_answer("23.5")
+        assert not responder.validate_answer("fish")
 
 
 @use_unsafe_codejail()
@@ -1700,40 +1622,42 @@ def test_inline_code(self):
         problem = self.build_problem(answer=inline_script, expect="42")
 
         # Check results
-        self.assert_grade(problem, '42', 'correct')
-        self.assert_grade(problem, '0', 'incorrect')
+        self.assert_grade(problem, "42", "correct")
+        self.assert_grade(problem, "0", "incorrect")
 
     def test_inline_message(self):
         # Inline code can update the global messages list
         # to pass messages to the CorrectMap for a particular input
         # The code can also set the global overall_message (str)
         # to pass a message that applies to the whole response
-        inline_script = textwrap.dedent("""
+        inline_script = textwrap.dedent(
+            """
             messages[0] = "Test Message"
             overall_message = "Overall message"
-            """)
+            """
+        )
         problem = self.build_problem(answer=inline_script)
 
-        input_dict = {'1_2_1': '0'}
+        input_dict = {"1_2_1": "0"}
         correctmap = problem.grade_answers(input_dict)
 
         # Check that the message for the particular input was received
-        input_msg = correctmap.get_msg('1_2_1')
-        assert input_msg == 'Test Message'
+        input_msg = correctmap.get_msg("1_2_1")
+        assert input_msg == "Test Message"
 
         # Check that the overall message (for the whole response) was received
         overall_msg = correctmap.get_overall_message()
-        assert overall_msg == 'Overall message'
+        assert overall_msg == "Overall message"
 
     def test_inline_randomization(self):
         # Make sure the seed from the problem gets fed into the script execution.
         inline_script = "messages[0] = {code}".format(code=self._get_random_number_code())
         problem = self.build_problem(answer=inline_script)
 
-        input_dict = {'1_2_1': '0'}
+        input_dict = {"1_2_1": "0"}
         correctmap = problem.grade_answers(input_dict)
 
-        input_msg = correctmap.get_msg('1_2_1')
+        input_msg = correctmap.get_msg("1_2_1")
         assert input_msg == self._get_random_number_result(problem.seed)
 
     def test_function_code_single_input(self):
@@ -1747,7 +1671,8 @@ def test_function_code_single_input(self):
         # The function should return a dict of the form
         # { 'ok': BOOL or STRING, 'msg': STRING } (no 'grade_decimal' key to test that it's optional)
         #
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 partial_credit = '21'
                 if answer_given == expect:
@@ -1757,44 +1682,45 @@ def check_func(expect, answer_given):
                 else:
                     retval = False
                 return {'ok': retval, 'msg': 'Message text'}
-        """)
+        """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func", expect="42")
 
         # Correct answer
-        input_dict = {'1_2_1': '42'}
+        input_dict = {"1_2_1": "42"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
-        npoints = correct_map.get_npoints('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
+        npoints = correct_map.get_npoints("1_2_1")
 
-        assert correctness == 'correct'
-        assert msg == 'Message text'
+        assert correctness == "correct"
+        assert msg == "Message text"
         assert npoints == 1
 
         # Partially Credit answer
-        input_dict = {'1_2_1': '21'}
+        input_dict = {"1_2_1": "21"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
-        npoints = correct_map.get_npoints('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
+        npoints = correct_map.get_npoints("1_2_1")
 
-        assert correctness == 'partially-correct'
-        assert msg == 'Message text'
+        assert correctness == "partially-correct"
+        assert msg == "Message text"
         assert 0 <= npoints <= 1
 
         # Incorrect answer
-        input_dict = {'1_2_1': '0'}
+        input_dict = {"1_2_1": "0"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
-        npoints = correct_map.get_npoints('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
+        npoints = correct_map.get_npoints("1_2_1")
 
-        assert correctness == 'incorrect'
-        assert msg == 'Message text'
+        assert correctness == "incorrect"
+        assert msg == "Message text"
         assert npoints == 0
 
     def test_function_code_single_input_decimal_score(self):
@@ -1808,7 +1734,8 @@ def test_function_code_single_input_decimal_score(self):
         # The function should return a dict of the form
         # { 'ok': BOOL or STRING, 'msg': STRING, 'grade_decimal': FLOAT }
         #
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 partial_credit = '21'
                 if answer_given == expect:
@@ -1825,54 +1752,57 @@ def check_func(expect, answer_given):
                     'msg': 'Message text',
                     'grade_decimal': score,
                 }
-        """)
+        """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func", expect="42")
 
         # Correct answer
-        input_dict = {'1_2_1': '42'}
+        input_dict = {"1_2_1": "42"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_npoints('1_2_1') == 0.9
-        assert correct_map.get_correctness('1_2_1') == 'correct'
+        assert correct_map.get_npoints("1_2_1") == 0.9
+        assert correct_map.get_correctness("1_2_1") == "correct"
 
         # Incorrect answer
-        input_dict = {'1_2_1': '43'}
+        input_dict = {"1_2_1": "43"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_npoints('1_2_1') == 0.1
-        assert correct_map.get_correctness('1_2_1') == 'incorrect'
+        assert correct_map.get_npoints("1_2_1") == 0.1
+        assert correct_map.get_correctness("1_2_1") == "incorrect"
 
         # Partially Correct answer
-        input_dict = {'1_2_1': '21'}
+        input_dict = {"1_2_1": "21"}
         correct_map = problem.grade_answers(input_dict)
-        assert correct_map.get_npoints('1_2_1') == 0.5
-        assert correct_map.get_correctness('1_2_1') == 'partially-correct'
+        assert correct_map.get_npoints("1_2_1") == 0.5
+        assert correct_map.get_correctness("1_2_1") == "partially-correct"
 
     def test_script_context(self):
         # Ensure that python script variables can be used in the "expect" and "answer" fields,
 
-        script = script = textwrap.dedent("""
+        script = script = textwrap.dedent(
+            """
             expected_ans = 42
 
             def check_func(expect, answer_given):
                 return answer_given == expect
-        """)
+        """
+        )
 
         problems = (
             self.build_problem(script=script, cfn="check_func", expect="$expected_ans"),
-            self.build_problem(script=script, cfn="check_func", answer_attr="$expected_ans")
+            self.build_problem(script=script, cfn="check_func", answer_attr="$expected_ans"),
         )
 
-        input_dict = {'1_2_1': '42'}
+        input_dict = {"1_2_1": "42"}
 
         for problem in problems:
             correctmap = problem.grade_answers(input_dict)
 
             # CustomResponse also adds 'expect' to the problem context; check that directly first:
-            assert problem.context['expect'] == '42'
+            assert problem.context["expect"] == "42"
 
             # Also make sure the problem was graded correctly:
-            correctness = correctmap.get_correctness('1_2_1')
-            assert correctness == 'correct'
+            correctness = correctmap.get_correctness("1_2_1")
+            assert correctness == "correct"
 
     def test_function_code_multiple_input_no_msg(self):
 
@@ -1881,7 +1811,8 @@ def test_function_code_multiple_input_no_msg(self):
         # If true, mark all the inputs correct
         # If one is true but not the other, mark all partially correct
         # If false, mark all the inputs incorrect
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 if answer_given[0] == expect and answer_given[1] == expect:
                     retval = True
@@ -1890,42 +1821,42 @@ def check_func(expect, answer_given):
                 else:
                     retval = False
                 return retval
-        """)
+        """
+        )
 
-        problem = self.build_problem(script=script, cfn="check_func",
-                                     expect="42", num_inputs=2)
+        problem = self.build_problem(script=script, cfn="check_func", expect="42", num_inputs=2)
 
         # Correct answer -- expect both inputs marked correct
-        input_dict = {'1_2_1': '42', '1_2_2': '42'}
+        input_dict = {"1_2_1": "42", "1_2_2": "42"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        assert correctness == 'correct'
+        correctness = correct_map.get_correctness("1_2_1")
+        assert correctness == "correct"
 
-        correctness = correct_map.get_correctness('1_2_2')
-        assert correctness == 'correct'
+        correctness = correct_map.get_correctness("1_2_2")
+        assert correctness == "correct"
 
         # One answer incorrect -- expect both inputs marked partially correct
-        input_dict = {'1_2_1': '0', '1_2_2': '42'}
+        input_dict = {"1_2_1": "0", "1_2_2": "42"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        assert correctness == 'partially-correct'
-        assert 0 <= correct_map.get_npoints('1_2_1') <= 1
+        correctness = correct_map.get_correctness("1_2_1")
+        assert correctness == "partially-correct"
+        assert 0 <= correct_map.get_npoints("1_2_1") <= 1
 
-        correctness = correct_map.get_correctness('1_2_2')
-        assert correctness == 'partially-correct'
-        assert 0 <= correct_map.get_npoints('1_2_2') <= 1
+        correctness = correct_map.get_correctness("1_2_2")
+        assert correctness == "partially-correct"
+        assert 0 <= correct_map.get_npoints("1_2_2") <= 1
 
         # Both answers incorrect -- expect both inputs marked incorrect
-        input_dict = {'1_2_1': '0', '1_2_2': '0'}
+        input_dict = {"1_2_1": "0", "1_2_2": "0"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        assert correctness == 'incorrect'
+        correctness = correct_map.get_correctness("1_2_1")
+        assert correctness == "incorrect"
 
-        correctness = correct_map.get_correctness('1_2_2')
-        assert correctness == 'incorrect'
+        correctness = correct_map.get_correctness("1_2_2")
+        assert correctness == "incorrect"
 
     def test_function_code_multiple_inputs(self):
 
@@ -1940,7 +1871,8 @@ def test_function_code_multiple_inputs(self):
         #
         # 'input_list' contains dictionaries representing the correctness
         #           and message for each input.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 check1 = (int(answer_given[0]) == 1)
                 check2 = (int(answer_given[1]) == 2)
@@ -1952,38 +1884,35 @@ def check_func(expect, answer_given):
                             {'ok': check2,  'msg': 'Feedback 2'},
                             {'ok': check3,  'msg': 'Feedback 3'},
                             {'ok': check4,  'msg': 'Feedback 4'} ] }
-            """)
-
-        problem = self.build_problem(
-            script=script,
-            cfn="check_func",
-            num_inputs=4
+            """
         )
 
+        problem = self.build_problem(script=script, cfn="check_func", num_inputs=4)
+
         # Grade the inputs (one input incorrect)
-        input_dict = {'1_2_1': '-999', '1_2_2': '2', '1_2_3': '3', '1_2_4': 'four'}
+        input_dict = {"1_2_1": "-999", "1_2_2": "2", "1_2_3": "3", "1_2_4": "four"}
         correct_map = problem.grade_answers(input_dict)
 
         # Expect that we receive the overall message (for the whole response)
-        assert correct_map.get_overall_message() == 'Overall message'
+        assert correct_map.get_overall_message() == "Overall message"
 
         # Expect that the inputs were graded individually
-        assert correct_map.get_correctness('1_2_1') == 'incorrect'
-        assert correct_map.get_correctness('1_2_2') == 'correct'
-        assert correct_map.get_correctness('1_2_3') == 'correct'
-        assert correct_map.get_correctness('1_2_4') == 'partially-correct'
+        assert correct_map.get_correctness("1_2_1") == "incorrect"
+        assert correct_map.get_correctness("1_2_2") == "correct"
+        assert correct_map.get_correctness("1_2_3") == "correct"
+        assert correct_map.get_correctness("1_2_4") == "partially-correct"
 
         # Expect that the inputs were given correct npoints
-        assert correct_map.get_npoints('1_2_1') == 0
-        assert correct_map.get_npoints('1_2_2') == 1
-        assert correct_map.get_npoints('1_2_3') == 1
-        assert 0 <= correct_map.get_npoints('1_2_4') <= 1
+        assert correct_map.get_npoints("1_2_1") == 0
+        assert correct_map.get_npoints("1_2_2") == 1
+        assert correct_map.get_npoints("1_2_3") == 1
+        assert 0 <= correct_map.get_npoints("1_2_4") <= 1
 
         # Expect that we received messages for each individual input
-        assert correct_map.get_msg('1_2_1') == 'Feedback 1'
-        assert correct_map.get_msg('1_2_2') == 'Feedback 2'
-        assert correct_map.get_msg('1_2_3') == 'Feedback 3'
-        assert correct_map.get_msg('1_2_4') == 'Feedback 4'
+        assert correct_map.get_msg("1_2_1") == "Feedback 1"
+        assert correct_map.get_msg("1_2_2") == "Feedback 2"
+        assert correct_map.get_msg("1_2_3") == "Feedback 3"
+        assert correct_map.get_msg("1_2_4") == "Feedback 4"
 
     def test_function_code_multiple_inputs_decimal_score(self):
 
@@ -1996,7 +1925,8 @@ def test_function_code_multiple_inputs_decimal_score(self):
         #        #
         # 'input_list' contains dictionaries representing the correctness
         #           and message for each input.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 check1 = (int(answer_given[0]) == 1)
                 check2 = (int(answer_given[1]) == 2)
@@ -2014,28 +1944,30 @@ def check_func(expect, answer_given):
                         {'ok': check4, 'grade_decimal': score4, 'msg': 'Feedback 4'},
                     ]
                 }
-            """)
+            """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func", num_inputs=4)
 
         # Grade the inputs (one input incorrect)
-        input_dict = {'1_2_1': '-999', '1_2_2': '2', '1_2_3': '3', '1_2_4': 'four'}
+        input_dict = {"1_2_1": "-999", "1_2_2": "2", "1_2_3": "3", "1_2_4": "four"}
         correct_map = problem.grade_answers(input_dict)
 
         # Expect that the inputs were graded individually
-        assert correct_map.get_correctness('1_2_1') == 'incorrect'
-        assert correct_map.get_correctness('1_2_2') == 'correct'
-        assert correct_map.get_correctness('1_2_3') == 'correct'
-        assert correct_map.get_correctness('1_2_4') == 'partially-correct'
+        assert correct_map.get_correctness("1_2_1") == "incorrect"
+        assert correct_map.get_correctness("1_2_2") == "correct"
+        assert correct_map.get_correctness("1_2_3") == "correct"
+        assert correct_map.get_correctness("1_2_4") == "partially-correct"
 
         # Expect that the inputs were given correct npoints
-        assert correct_map.get_npoints('1_2_1') == 0.1
-        assert correct_map.get_npoints('1_2_2') == 0.9
-        assert correct_map.get_npoints('1_2_3') == 0.9
-        assert correct_map.get_npoints('1_2_4') == 0.7
+        assert correct_map.get_npoints("1_2_1") == 0.1
+        assert correct_map.get_npoints("1_2_2") == 0.9
+        assert correct_map.get_npoints("1_2_3") == 0.9
+        assert correct_map.get_npoints("1_2_4") == 0.7
 
     def test_function_code_with_extra_args(self):
-        script = textwrap.dedent("""\
+        script = textwrap.dedent(
+            """\
                     def check_func(expect, answer_given, options, dynamath):
                         assert options == "xyzzy", "Options was %r" % options
                         partial_credit = '21'
@@ -2046,48 +1978,46 @@ def check_func(expect, answer_given, options, dynamath):
                         else:
                             retval = False
                         return {'ok': retval, 'msg': 'Message text'}
-                    """)
+                    """
+        )
 
         problem = self.build_problem(
-            script=script,
-            cfn="check_func",
-            expect="42",
-            options="xyzzy",
-            cfn_extra_args="options dynamath"
+            script=script, cfn="check_func", expect="42", options="xyzzy", cfn_extra_args="options dynamath"
         )
 
         # Correct answer
-        input_dict = {'1_2_1': '42'}
+        input_dict = {"1_2_1": "42"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
 
-        assert correctness == 'correct'
-        assert msg == 'Message text'
+        assert correctness == "correct"
+        assert msg == "Message text"
 
         # Partially Correct answer
-        input_dict = {'1_2_1': '21'}
+        input_dict = {"1_2_1": "21"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
 
-        assert correctness == 'partially-correct'
-        assert msg == 'Message text'
+        assert correctness == "partially-correct"
+        assert msg == "Message text"
 
         # Incorrect answer
-        input_dict = {'1_2_1': '0'}
+        input_dict = {"1_2_1": "0"}
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
 
-        assert correctness == 'incorrect'
-        assert msg == 'Message text'
+        assert correctness == "incorrect"
+        assert msg == "Message text"
 
     def test_function_code_with_attempt_number(self):
-        script = textwrap.dedent("""\
+        script = textwrap.dedent(
+            """\
                     def gradeit(expect, ans, **kwargs):
                         attempt = kwargs["attempt"]
                         message = "This is attempt number {}".format(str(attempt))
@@ -2096,35 +2026,31 @@ def gradeit(expect, ans, **kwargs):
                                 { 'ok': True, 'msg': message},
                             ]
                         }
-                    """)
-
-        problem = self.build_problem(
-            script=script,
-            cfn="gradeit",
-            expect="42",
-            cfn_extra_args="attempt"
+                    """
         )
 
+        problem = self.build_problem(script=script, cfn="gradeit", expect="42", cfn_extra_args="attempt")
+
         # first attempt
-        input_dict = {'1_2_1': '42'}
-        problem.context['attempt'] = 1
+        input_dict = {"1_2_1": "42"}
+        problem.context["attempt"] = 1
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
 
-        assert correctness == 'correct'
-        assert msg == 'This is attempt number 1'
+        assert correctness == "correct"
+        assert msg == "This is attempt number 1"
 
         # second attempt
-        problem.context['attempt'] = 2
+        problem.context["attempt"] = 2
         correct_map = problem.grade_answers(input_dict)
 
-        correctness = correct_map.get_correctness('1_2_1')
-        msg = correct_map.get_msg('1_2_1')
+        correctness = correct_map.get_correctness("1_2_1")
+        msg = correct_map.get_msg("1_2_1")
 
-        assert correctness == 'correct'
-        assert msg == 'This is attempt number 2'
+        assert correctness == "correct"
+        assert msg == "This is attempt number 2"
 
     def test_multiple_inputs_return_one_status(self):
         # When given multiple inputs, the 'answer_given' argument
@@ -2137,7 +2063,8 @@ def test_multiple_inputs_return_one_status(self):
         # Since we return a dict describing the status of one input,
         # we expect that the same 'ok' value is applied to each
         # of the inputs.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 check1 = (int(answer_given[0]) == 1)
                 check2 = (int(answer_given[1]) == 2)
@@ -2148,54 +2075,56 @@ def check_func(expect, answer_given):
                 else:
                     return {'ok': (check1 and check2 and check3),
                             'msg': 'Message text'}
-            """)
+            """
+        )
 
-        problem = self.build_problem(script=script,
-                                     cfn="check_func", num_inputs=3)
+        problem = self.build_problem(script=script, cfn="check_func", num_inputs=3)
 
         # Grade the inputs (one input incorrect)
-        input_dict = {'1_2_1': '-999', '1_2_2': '2', '1_2_3': '3'}
+        input_dict = {"1_2_1": "-999", "1_2_2": "2", "1_2_3": "3"}
         correct_map = problem.grade_answers(input_dict)
 
         # Everything marked incorrect
-        assert correct_map.get_correctness('1_2_1') == 'incorrect'
-        assert correct_map.get_correctness('1_2_2') == 'incorrect'
-        assert correct_map.get_correctness('1_2_3') == 'incorrect'
+        assert correct_map.get_correctness("1_2_1") == "incorrect"
+        assert correct_map.get_correctness("1_2_2") == "incorrect"
+        assert correct_map.get_correctness("1_2_3") == "incorrect"
 
         # Grade the inputs (one input partially correct)
-        input_dict = {'1_2_1': '-1', '1_2_2': '2', '1_2_3': '3'}
+        input_dict = {"1_2_1": "-1", "1_2_2": "2", "1_2_3": "3"}
         correct_map = problem.grade_answers(input_dict)
 
         # Everything marked partially correct
-        assert correct_map.get_correctness('1_2_1') == 'partially-correct'
-        assert correct_map.get_correctness('1_2_2') == 'partially-correct'
-        assert correct_map.get_correctness('1_2_3') == 'partially-correct'
+        assert correct_map.get_correctness("1_2_1") == "partially-correct"
+        assert correct_map.get_correctness("1_2_2") == "partially-correct"
+        assert correct_map.get_correctness("1_2_3") == "partially-correct"
 
         # Grade the inputs (everything correct)
-        input_dict = {'1_2_1': '1', '1_2_2': '2', '1_2_3': '3'}
+        input_dict = {"1_2_1": "1", "1_2_2": "2", "1_2_3": "3"}
         correct_map = problem.grade_answers(input_dict)
 
         # Everything marked incorrect
-        assert correct_map.get_correctness('1_2_1') == 'correct'
-        assert correct_map.get_correctness('1_2_2') == 'correct'
-        assert correct_map.get_correctness('1_2_3') == 'correct'
+        assert correct_map.get_correctness("1_2_1") == "correct"
+        assert correct_map.get_correctness("1_2_2") == "correct"
+        assert correct_map.get_correctness("1_2_3") == "correct"
 
         # Message is interpreted as an "overall message"
-        assert correct_map.get_overall_message() == 'Message text'
+        assert correct_map.get_overall_message() == "Message text"
 
     def test_script_exception_function(self):
 
         # Construct a script that will raise an exception
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 raise Exception("Test")
-            """)
+            """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func")
 
         # Expect that an exception gets raised when we check the answer
         with pytest.raises(ResponseError):
-            problem.grade_answers({'1_2_1': '42'})
+            problem.grade_answers({"1_2_1": "42"})
 
     def test_script_exception_inline(self):
 
@@ -2205,41 +2134,51 @@ def test_script_exception_inline(self):
 
         # Expect that an exception gets raised when we check the answer
         with pytest.raises(ResponseError):
-            problem.grade_answers({'1_2_1': '42'})
+            problem.grade_answers({"1_2_1": "42"})
 
     def test_invalid_dict_exception(self):
 
         # Construct a script that passes back an invalid dict format
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 return {'invalid': 'test'}
-            """)
+            """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func")
 
         # Expect that an exception gets raised when we check the answer
         with pytest.raises(ResponseError):
-            problem.grade_answers({'1_2_1': '42'})
+            problem.grade_answers({"1_2_1": "42"})
 
     def test_setup_randomization(self):
         # Ensure that the problem setup script gets the random seed from the problem.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             num = {code}
-            """.format(code=self._get_random_number_code()))
+            """.format(
+                code=self._get_random_number_code()
+            )
+        )
         problem = self.build_problem(script=script)
-        assert problem.context['num'] == self._get_random_number_result(problem.seed)
+        assert problem.context["num"] == self._get_random_number_result(problem.seed)
 
     def test_check_function_randomization(self):
         # The check function should get random-seeded from the problem.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 return {{'ok': True, 'msg': {code} }}
-        """.format(code=self._get_random_number_code()))
+        """.format(
+                code=self._get_random_number_code()
+            )
+        )
 
         problem = self.build_problem(script=script, cfn="check_func", expect="42")
-        input_dict = {'1_2_1': '42'}
+        input_dict = {"1_2_1": "42"}
         correct_map = problem.grade_answers(input_dict)
-        msg = correct_map.get_msg('1_2_1')
+        msg = correct_map.get_msg("1_2_1")
         assert msg == self._get_random_number_result(problem.seed)
 
     def test_random_isnt_none(self):
@@ -2253,29 +2192,43 @@ def test_random_isnt_none(self):
         r.seed(10)
         num = r.randint(0, 1e9)
 
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             random.seed(10)
             num = random.randint(0, 1e9)
-            """)
+            """
+        )
         problem = self.build_problem(script=script)
-        assert problem.context['num'] == num
+        assert problem.context["num"] == num
 
     def test_module_imports_inline(self):
-        '''
+        """
         Check that the correct modules are available to custom
         response scripts
-        '''
+        """
 
-        for module_name in ['random', 'numpy', 'math', 'scipy',
-                            'calc', 'eia', 'chemcalc', 'chemtools',
-                            'miller', 'draganddrop']:
+        for module_name in [
+            "random",
+            "numpy",
+            "math",
+            "scipy",
+            "calc",
+            "eia",
+            "chemcalc",
+            "chemtools",
+            "miller",
+            "draganddrop",
+        ]:
 
             # Create a script that checks that the name is defined
             # If the name is not defined, then the script
             # will raise an exception
-            script = textwrap.dedent('''
+            script = textwrap.dedent(
+                """
             correct[0] = 'correct'
-            assert('%s' in globals())''' % module_name)
+            assert('%s' in globals())"""
+                % module_name
+            )
 
             # Create the problem
             problem = self.build_problem(answer=script)
@@ -2283,28 +2236,40 @@ def test_module_imports_inline(self):
             # Expect that we can grade an answer without
             # getting an exception
             try:
-                problem.grade_answers({'1_2_1': '42'})
+                problem.grade_answers({"1_2_1": "42"})
 
             except ResponseError:
                 self.fail("Could not use name '{0}s' in custom response".format(module_name))
 
     def test_module_imports_function(self):
-        '''
+        """
         Check that the correct modules are available to custom
         response scripts
-        '''
+        """
 
-        for module_name in ['random', 'numpy', 'math', 'scipy',
-                            'calc', 'eia', 'chemcalc', 'chemtools',
-                            'miller', 'draganddrop']:
+        for module_name in [
+            "random",
+            "numpy",
+            "math",
+            "scipy",
+            "calc",
+            "eia",
+            "chemcalc",
+            "chemtools",
+            "miller",
+            "draganddrop",
+        ]:
 
             # Create a script that checks that the name is defined
             # If the name is not defined, then the script
             # will raise an exception
-            script = textwrap.dedent('''
+            script = textwrap.dedent(
+                """
             def check_func(expect, answer_given):
                 assert('%s' in globals())
-                return True''' % module_name)
+                return True"""
+                % module_name
+            )
 
             # Create the problem
             problem = self.build_problem(script=script, cfn="check_func")
@@ -2312,7 +2277,7 @@ def check_func(expect, answer_given):
             # Expect that we can grade an answer without
             # getting an exception
             try:
-                problem.grade_answers({'1_2_1': '42'})
+                problem.grade_answers({"1_2_1": "42"})
 
             except ResponseError:
                 self.fail("Could not use name '{0}s' in custom response".format(module_name))
@@ -2323,25 +2288,35 @@ def test_python_lib_zip_is_available(self):
         # Make a zipfile with one module in it with one function.
         zipstring = io.BytesIO()
         zipf = zipfile.ZipFile(zipstring, "w")  # lint-amnesty, pylint: disable=consider-using-with
-        zipf.writestr("my_helper.py", textwrap.dedent("""\
+        zipf.writestr(
+            "my_helper.py",
+            textwrap.dedent(
+                """\
             def seventeen():
                 return 17
-            """))
+            """
+            ),
+        )
         zipf.close()
 
         # Use that module in our Python script.
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             import my_helper
             num = my_helper.seventeen()
-            """)
+            """
+        )
         capa_system = mock_capa_system()
-        capa_system.get_python_lib_zip = lambda: zipstring.getvalue()  # lint-amnesty, pylint: disable=unnecessary-lambda
+        capa_system.get_python_lib_zip = (
+            lambda: zipstring.getvalue()  # lint-amnesty, pylint: disable=unnecessary-lambda
+        )
         problem = self.build_problem(script=script, capa_system=capa_system)
-        assert problem.context['num'] == 17
+        assert problem.context["num"] == 17
 
     def test_function_code_multiple_inputs_order(self):
         # Ensure that order must be correct according to sub-problem position
-        script = textwrap.dedent("""
+        script = textwrap.dedent(
+            """
             def check_func(expect, answer_given):
                 check1 = (int(answer_given[0]) == 1)
                 check2 = (int(answer_given[1]) == 2)
@@ -2368,27 +2343,38 @@ def check_func(expect, answer_given):
                                 { 'ok': check10, 'msg': '10'},
                                 { 'ok': check11, 'msg': '11'},
                 ]}
-            """)
+            """
+        )
 
         problem = self.build_problem(script=script, cfn="check_func", num_inputs=11)
 
         # Grade the inputs showing out of order
         input_dict = {
-            '1_2_1': '1',
-            '1_2_2': '2',
-            '1_2_3': '3',
-            '1_2_4': '4',
-            '1_2_5': '5',
-            '1_2_6': '6',
-            '1_2_10': '10',
-            '1_2_11': '16',
-            '1_2_7': '7',
-            '1_2_8': '8',
-            '1_2_9': '9'
+            "1_2_1": "1",
+            "1_2_2": "2",
+            "1_2_3": "3",
+            "1_2_4": "4",
+            "1_2_5": "5",
+            "1_2_6": "6",
+            "1_2_10": "10",
+            "1_2_11": "16",
+            "1_2_7": "7",
+            "1_2_8": "8",
+            "1_2_9": "9",
         }
 
         correct_order = [
-            '1_2_1', '1_2_2', '1_2_3', '1_2_4', '1_2_5', '1_2_6', '1_2_7', '1_2_8', '1_2_9', '1_2_10', '1_2_11'
+            "1_2_1",
+            "1_2_2",
+            "1_2_3",
+            "1_2_4",
+            "1_2_5",
+            "1_2_6",
+            "1_2_7",
+            "1_2_8",
+            "1_2_9",
+            "1_2_10",
+            "1_2_11",
         ]
 
         correct_map = problem.grade_answers(input_dict)
@@ -2396,15 +2382,15 @@ def check_func(expect, answer_given):
         assert list(problem.student_answers.keys()) != correct_order
 
         # euqal to correct order after sorting at get_score
-        self.assertListEqual(list(problem.responders.values())[0].context['idset'], correct_order)
+        self.assertListEqual(list(problem.responders.values())[0].context["idset"], correct_order)
 
-        assert correct_map.get_correctness('1_2_1') == 'correct'
-        assert correct_map.get_correctness('1_2_9') == 'correct'
-        assert correct_map.get_correctness('1_2_11') == 'incorrect'
+        assert correct_map.get_correctness("1_2_1") == "correct"
+        assert correct_map.get_correctness("1_2_9") == "correct"
+        assert correct_map.get_correctness("1_2_11") == "incorrect"
 
-        assert correct_map.get_msg('1_2_1') == '1'
-        assert correct_map.get_msg('1_2_9') == '9'
-        assert correct_map.get_msg('1_2_11') == '11'
+        assert correct_map.get_msg("1_2_1") == "1"
+        assert correct_map.get_msg("1_2_9") == "9"
+        assert correct_map.get_msg("1_2_11") == "11"
 
 
 @use_unsafe_codejail()
@@ -2412,6 +2398,7 @@ class SchematicResponseTest(ResponseTest):
     """
     Class containing setup and tests for Schematic responsetype.
     """
+
     xml_factory_class = SchematicResponseXMLFactory
 
     def test_grade(self):
@@ -2429,25 +2416,27 @@ def test_grade(self):
 
         # The actual dictionary would contain schematic information
         # sent from the JavaScript simulation
-        submission_dict = {'test': 'the_answer'}
-        input_dict = {'1_2_1': json.dumps(submission_dict)}
+        submission_dict = {"test": "the_answer"}
+        input_dict = {"1_2_1": json.dumps(submission_dict)}
         correct_map = problem.grade_answers(input_dict)
 
         # Expect that the problem is graded as true
         # (That is, our script verifies that the context
         # is what we expect)
-        assert correct_map.get_correctness('1_2_1') == 'correct'
+        assert correct_map.get_correctness("1_2_1") == "correct"
 
     def test_check_function_randomization(self):
         # The check function should get a random seed from the problem.
-        script = "correct = ['correct' if (submission[0]['num'] == {code}) else 'incorrect']".format(code=self._get_random_number_code())  # lint-amnesty, pylint: disable=line-too-long
+        script = "correct = ['correct' if (submission[0]['num'] == {code}) else 'incorrect']".format(
+            code=self._get_random_number_code()
+        )  # lint-amnesty, pylint: disable=line-too-long
         problem = self.build_problem(answer=script)
 
-        submission_dict = {'num': self._get_random_number_result(problem.seed)}
-        input_dict = {'1_2_1': json.dumps(submission_dict)}
+        submission_dict = {"num": self._get_random_number_result(problem.seed)}
+        input_dict = {"1_2_1": json.dumps(submission_dict)}
         correct_map = problem.grade_answers(input_dict)
 
-        assert correct_map.get_correctness('1_2_1') == 'correct'
+        assert correct_map.get_correctness("1_2_1") == "correct"
 
     def test_script_exception(self):
         # Construct a script that will raise an exception
@@ -2456,8 +2445,8 @@ def test_script_exception(self):
 
         # Expect that an exception gets raised when we check the answer
         with pytest.raises(ResponseError):
-            submission_dict = {'test': 'test'}
-            input_dict = {'1_2_1': json.dumps(submission_dict)}
+            submission_dict = {"test": "test"}
+            input_dict = {"1_2_1": json.dumps(submission_dict)}
             problem.grade_answers(input_dict)
 
 
@@ -2465,36 +2454,38 @@ class AnnotationResponseTest(ResponseTest):  # lint-amnesty, pylint: disable=mis
     xml_factory_class = AnnotationResponseXMLFactory
 
     def test_grade(self):
-        (correct, partially, incorrect) = ('correct', 'partially-correct', 'incorrect')
+        (correct, partially, incorrect) = ("correct", "partially-correct", "incorrect")
 
-        answer_id = '1_2_1'
-        options = (('x', correct), ('y', partially), ('z', incorrect))
-        make_answer = lambda option_ids: {answer_id: json.dumps({'options': option_ids})}
+        answer_id = "1_2_1"
+        options = (("x", correct), ("y", partially), ("z", incorrect))
+        make_answer = lambda option_ids: {answer_id: json.dumps({"options": option_ids})}
 
         tests = [
-            {'correctness': correct, 'points': 2, 'answers': make_answer([0])},
-            {'correctness': partially, 'points': 1, 'answers': make_answer([1])},
-            {'correctness': incorrect, 'points': 0, 'answers': make_answer([2])},
-            {'correctness': incorrect, 'points': 0, 'answers': make_answer([0, 1, 2])},
-            {'correctness': incorrect, 'points': 0, 'answers': make_answer([])},
-            {'correctness': incorrect, 'points': 0, 'answers': make_answer('')},
-            {'correctness': incorrect, 'points': 0, 'answers': make_answer(None)},
-            {'correctness': incorrect, 'points': 0, 'answers': {answer_id: 'null'}},
+            {"correctness": correct, "points": 2, "answers": make_answer([0])},
+            {"correctness": partially, "points": 1, "answers": make_answer([1])},
+            {"correctness": incorrect, "points": 0, "answers": make_answer([2])},
+            {"correctness": incorrect, "points": 0, "answers": make_answer([0, 1, 2])},
+            {"correctness": incorrect, "points": 0, "answers": make_answer([])},
+            {"correctness": incorrect, "points": 0, "answers": make_answer("")},
+            {"correctness": incorrect, "points": 0, "answers": make_answer(None)},
+            {"correctness": incorrect, "points": 0, "answers": {answer_id: "null"}},
         ]
 
         for test in tests:
-            expected_correctness = test['correctness']
-            expected_points = test['points']
-            answers = test['answers']
+            expected_correctness = test["correctness"]
+            expected_points = test["points"]
+            answers = test["answers"]
 
             problem = self.build_problem(options=options)
             correct_map = problem.grade_answers(answers)
             actual_correctness = correct_map.get_correctness(answer_id)
             actual_points = correct_map.get_npoints(answer_id)
 
-            assert expected_correctness == actual_correctness,\
-                ('%s should be marked %s' % (answer_id, expected_correctness))
-            assert expected_points == actual_points, ('%s should have %d points' % (answer_id, expected_points))
+            assert expected_correctness == actual_correctness, "%s should be marked %s" % (
+                answer_id,
+                expected_correctness,
+            )
+            assert expected_points == actual_points, "%s should have %d points" % (answer_id, expected_points)
 
 
 @use_unsafe_codejail()
@@ -2535,7 +2526,7 @@ class ChoiceTextResponseTest(ResponseTest):
         "2_choices_1_input_2_incorrect": [(False, []), (True, ["123"])],
         "2_choices_2_inputs_correct": [(True, ["123"]), (False, [])],
         "2_choices_2_inputs_wrong_choice": [(False, ["123"]), (True, [])],
-        "2_choices_2_inputs_wrong_input": [(True, ["321"]), (False, [])]
+        "2_choices_2_inputs_wrong_input": [(True, ["321"]), (False, [])],
     }
 
     # `TEST_SCENARIOS` is a dictionary of the form
@@ -2570,68 +2561,43 @@ class ChoiceTextResponseTest(ResponseTest):
         "2_choices_1_input_2_incorrect": ("2_choices_1_input_2", "incorrect"),
         "2_choices_2_inputs_correct": ("2_choices_2_inputs", "correct"),
         "2_choices_2_inputs_wrong_choice": ("2_choices_2_inputs", "incorrect"),
-        "2_choices_2_inputs_wrong_input": ("2_choices_2_inputs", "incorrect")
+        "2_choices_2_inputs_wrong_input": ("2_choices_2_inputs", "incorrect"),
     }
 
     # Dictionary that maps from problem_name to arguments for
     # _make_problem, that will create the problem.
     TEST_PROBLEM_ARGS = {
-        "1_choice_0_input": {"choices": ("true", {}), "script": ''},
-        "1_choice_1_input": {
-            "choices": ("true", {"answer": "123", "tolerance": "1"}),
-            "script": ''
-        },
-
+        "1_choice_0_input": {"choices": ("true", {}), "script": ""},
+        "1_choice_1_input": {"choices": ("true", {"answer": "123", "tolerance": "1"}), "script": ""},
         "1_input_script": {
             "choices": ("true", {"answer": "$computed_response", "tolerance": "1"}),
-            "script": "computed_response = math.sqrt(4)"
+            "script": "computed_response = math.sqrt(4)",
         },
-
         "1_choice_2_inputs": {
-            "choices": [
-                (
-                    "true", (
-                        {"answer": "123", "tolerance": "1"},
-                        {"answer": "456", "tolerance": "10"}
-                    )
-                )
-            ],
-            "script": ''
-        },
-        "2_choices_0_inputs": {
-            "choices": [("false", {}), ("true", {})],
-            "script": ''
-
+            "choices": [("true", ({"answer": "123", "tolerance": "1"}, {"answer": "456", "tolerance": "10"}))],
+            "script": "",
         },
+        "2_choices_0_inputs": {"choices": [("false", {}), ("true", {})], "script": ""},
         "2_choices_1_input_1": {
-            "choices": [
-                ("false", {}), ("true", {"answer": "123", "tolerance": "0"})
-            ],
-            "script": ''
+            "choices": [("false", {}), ("true", {"answer": "123", "tolerance": "0"})],
+            "script": "",
         },
         "2_choices_1_input_2": {
             "choices": [("true", {}), ("false", {"answer": "123", "tolerance": "0"})],
-            "script": ''
+            "script": "",
         },
         "2_choices_2_inputs": {
-            "choices": [
-                ("true", {"answer": "123", "tolerance": "0"}),
-                ("false", {"answer": "999", "tolerance": "0"})
-            ],
-            "script": ''
-        }
+            "choices": [("true", {"answer": "123", "tolerance": "0"}), ("false", {"answer": "999", "tolerance": "0"})],
+            "script": "",
+        },
     }
 
-    def _make_problem(self, choices, in_type='radiotextgroup', script=''):
+    def _make_problem(self, choices, in_type="radiotextgroup", script=""):
         """
         Convenience method to fill in default values for script and
         type if needed, then call self.build_problem
         """
-        return self.build_problem(
-            choices=choices,
-            type=in_type,
-            script=script
-        )
+        return self.build_problem(choices=choices, type=in_type, script=script)
 
     def _make_answer_dict(self, choice_list):
         """
@@ -2658,10 +2624,7 @@ def _make_answer_dict(self, choice_list):
                 # In `answer_id` `index` represents the ordinality of the
                 # choice and `ind` represents the ordinality of the
                 # numtolerance_input inside the parent choice.
-                answer_id = "1_2_1_choiceinput_{index}_numtolerance_input_{ind}".format(
-                    index=index,
-                    ind=ind
-                )
+                answer_id = "1_2_1_choiceinput_{index}_numtolerance_input_{ind}".format(index=index, ind=ind)
                 answer_dict[answer_id] = answer
 
         return answer_dict
@@ -2681,17 +2644,11 @@ def test_unchecked_input_not_validated(self):
         """
 
         two_choice_two_input = self._make_problem(
-            [
-                ("true", {"answer": "123", "tolerance": "1"}),
-                ("false", {})
-            ],
-            "checkboxtextgroup"
+            [("true", {"answer": "123", "tolerance": "1"}), ("false", {})], "checkboxtextgroup"
         )
 
         self.assert_grade(
-            two_choice_two_input,
-            self._make_answer_dict([(True, ["1"]), (False, ["Platypus"])]),
-            "incorrect"
+            two_choice_two_input, self._make_answer_dict([(True, ["1"]), (False, ["Platypus"])]), "incorrect"
         )
 
     def test_interpret_error(self):
@@ -2700,47 +2657,26 @@ def test_interpret_error(self):
         cause the response type to raise an error.
         """
         two_choice_two_input = self._make_problem(
-            [
-                ("true", {"answer": "123", "tolerance": "1"}),
-                ("false", {})
-            ],
-            "checkboxtextgroup"
+            [("true", {"answer": "123", "tolerance": "1"}), ("false", {})], "checkboxtextgroup"
         )
 
         with self.assertRaisesRegex(StudentInputError, "Could not interpret"):
             # Test that error is raised for input in selected correct choice.
-            self.assert_grade(
-                two_choice_two_input,
-                self._make_answer_dict([(True, ["Platypus"])]),
-                "correct"
-            )
+            self.assert_grade(two_choice_two_input, self._make_answer_dict([(True, ["Platypus"])]), "correct")
 
         with self.assertRaisesRegex(StudentInputError, "Could not interpret"):
             # Test that error is raised for input in selected incorrect choice.
             self.assert_grade(
-                two_choice_two_input,
-                self._make_answer_dict([(True, ["1"]), (True, ["Platypus"])]),
-                "correct"
+                two_choice_two_input, self._make_answer_dict([(True, ["1"]), (True, ["Platypus"])]), "correct"
             )
 
     def test_staff_answer_error(self):
         broken_problem = self._make_problem(
-            [("true", {"answer": "Platypus", "tolerance": "0"}),
-             ("true", {"answer": "edX", "tolerance": "0"})
-             ],
-            "checkboxtextgroup"
+            [("true", {"answer": "Platypus", "tolerance": "0"}), ("true", {"answer": "edX", "tolerance": "0"})],
+            "checkboxtextgroup",
         )
-        with self.assertRaisesRegex(
-            StudentInputError,
-            "The Staff answer could not be interpreted as a number."
-        ):
-            self.assert_grade(
-                broken_problem,
-                self._make_answer_dict(
-                    [(True, ["1"]), (True, ["1"])]
-                ),
-                "correct"
-            )
+        with self.assertRaisesRegex(StudentInputError, "The Staff answer could not be interpreted as a number."):
+            self.assert_grade(broken_problem, self._make_answer_dict([(True, ["1"]), (True, ["1"])]), "correct")
 
     def test_radio_grades(self):
         """
@@ -2759,17 +2695,9 @@ def test_radio_grades(self):
             test_choices = problem_args["choices"]
             test_script = problem_args["script"]
             # Build the actual problem for the test.
-            test_problem = self._make_problem(test_choices, 'radiotextgroup', test_script)
+            test_problem = self._make_problem(test_choices, "radiotextgroup", test_script)
             # Make sure the actual grade matches the expected grade.
-            self.assert_grade(
-                test_problem,
-                submission,
-                correctness,
-                msg="{0} should be {1}".format(
-                    name,
-                    correctness
-                )
-            )
+            self.assert_grade(test_problem, submission, correctness, msg="{0} should be {1}".format(name, correctness))
 
     def test_checkbox_grades(self):
         """
@@ -2781,51 +2709,31 @@ def test_checkbox_grades(self):
         scenarios = {
             "2_choices_correct": ("checkbox_two_choices", "correct"),
             "2_choices_incorrect": ("checkbox_two_choices", "incorrect"),
-
-            "2_choices_2_inputs_correct": (
-                "checkbox_2_choices_2_inputs",
-                "correct"
-            ),
-
-            "2_choices_2_inputs_missing_choice": (
-                "checkbox_2_choices_2_inputs",
-                "incorrect"
-            ),
-
-            "2_choices_2_inputs_wrong_input": (
-                "checkbox_2_choices_2_inputs",
-                "incorrect"
-            )
+            "2_choices_2_inputs_correct": ("checkbox_2_choices_2_inputs", "correct"),
+            "2_choices_2_inputs_missing_choice": ("checkbox_2_choices_2_inputs", "incorrect"),
+            "2_choices_2_inputs_wrong_input": ("checkbox_2_choices_2_inputs", "incorrect"),
         }
         # Dictionary scenario_name: test_inputs
         inputs = {
             "2_choices_correct": [(True, []), (True, [])],
             "2_choices_incorrect": [(True, []), (False, [])],
             "2_choices_2_inputs_correct": [(True, ["123"]), (True, ["456"])],
-            "2_choices_2_inputs_missing_choice": [
-                (True, ["123"]), (False, ["456"])
-            ],
-            "2_choices_2_inputs_wrong_input": [
-                (True, ["123"]), (True, ["654"])
-            ]
+            "2_choices_2_inputs_missing_choice": [(True, ["123"]), (False, ["456"])],
+            "2_choices_2_inputs_wrong_input": [(True, ["123"]), (True, ["654"])],
         }
 
         # Two choice zero input problem with both choices being correct.
-        checkbox_two_choices = self._make_problem(
-            [("true", {}), ("true", {})], "checkboxtextgroup"
-        )
+        checkbox_two_choices = self._make_problem([("true", {}), ("true", {})], "checkboxtextgroup")
         # Two choice two input problem with both choices correct.
         checkbox_two_choices_two_inputs = self._make_problem(
-            [("true", {"answer": "123", "tolerance": "0"}),
-             ("true", {"answer": "456", "tolerance": "0"})
-             ],
-            "checkboxtextgroup"
+            [("true", {"answer": "123", "tolerance": "0"}), ("true", {"answer": "456", "tolerance": "0"})],
+            "checkboxtextgroup",
         )
 
         # Dictionary problem_name: problem
         problems = {
             "checkbox_two_choices": checkbox_two_choices,
-            "checkbox_2_choices_2_inputs": checkbox_two_choices_two_inputs
+            "checkbox_2_choices_2_inputs": checkbox_two_choices_two_inputs,
         }
 
         for name, inputs in inputs.items():
@@ -2836,9 +2744,4 @@ def test_checkbox_grades(self):
             problem = problems[problem_name]
 
             # Make sure the actual grade matches the expected grade
-            self.assert_grade(
-                problem,
-                submission,
-                correctness,
-                msg="{0} should be {1}".format(name, correctness)
-            )
+            self.assert_grade(problem, submission, correctness, msg="{0} should be {1}".format(name, correctness))
diff --git a/xmodule/capa/tests/test_shuffle.py b/xmodule/capa/tests/test_shuffle.py
index d7ce39f00898..516cbddb0c63 100644
--- a/xmodule/capa/tests/test_shuffle.py
+++ b/xmodule/capa/tests/test_shuffle.py
@@ -1,11 +1,10 @@
 """Tests the capa shuffle and name-masking."""
 
-
 import textwrap
 import unittest
 
 from xmodule.capa.responsetypes import LoncapaProblemError
-from xmodule.capa.tests.helpers import new_loncapa_problem, mock_capa_system
+from xmodule.capa.tests.helpers import mock_capa_system, new_loncapa_problem
 
 
 class CapaShuffleTest(unittest.TestCase):
@@ -16,7 +15,8 @@ def setUp(self):
         self.system = mock_capa_system()
 
     def test_shuffle_4_choices(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -27,7 +27,8 @@ def test_shuffle_4_choices(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         # shuffling 4 things with seed of 0 yields: B A C D
         # Check that the choices are shuffled
@@ -36,11 +37,12 @@ def test_shuffle_4_choices(self):
         # Check that choice name masking is enabled and that unmasking works
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
-        assert response.unmask_order() == ['choice_1', 'choice_0', 'choice_2', 'choice_3']
-        assert the_html == problem.get_html(), 'should be able to call get_html() twice'
+        assert response.unmask_order() == ["choice_1", "choice_0", "choice_2", "choice_3"]
+        assert the_html == problem.get_html(), "should be able to call get_html() twice"
 
     def test_shuffle_custom_names(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -51,17 +53,19 @@ def test_shuffle_custom_names(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         # B A C D
         # Check that the custom name= names come through
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
         assert response.has_shuffle()
-        assert response.unmask_order() == ['choice_0', 'choice_aaa', 'choice_1', 'choice_ddd']
+        assert response.unmask_order() == ["choice_0", "choice_aaa", "choice_1", "choice_ddd"]
 
     def test_shuffle_different_seed(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -72,13 +76,15 @@ def test_shuffle_different_seed(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=341)  # yields D A B C
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'Donut'.*'Apple'.*'Banana'.*'Chocolate'.*\].*</div>")
 
     def test_shuffle_1_choice(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -86,17 +92,19 @@ def test_shuffle_1_choice(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'Apple'.*\].*</div>")
         response = list(problem.responders.values())[0]
         assert not response.has_mask()
         assert response.has_shuffle()
-        assert response.unmask_order() == ['choice_0']
+        assert response.unmask_order() == ["choice_0"]
 
     def test_shuffle_6_choices(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -109,14 +117,18 @@ def test_shuffle_6_choices(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)  # yields: C E A B D F
         # Donut -> Zonut to show that there is not some hidden alphabetic ordering going on
         the_html = problem.get_html()
-        self.assertRegex(the_html, r"<div>.*\[.*'Chocolate'.*'Eggplant'.*'Apple'.*'Banana'.*'Zonut'.*'Filet Mignon'.*\].*</div>")  # lint-amnesty, pylint: disable=line-too-long
+        self.assertRegex(
+            the_html, r"<div>.*\[.*'Chocolate'.*'Eggplant'.*'Apple'.*'Banana'.*'Zonut'.*'Filet Mignon'.*\].*</div>"
+        )  # lint-amnesty, pylint: disable=line-too-long
 
     def test_shuffle_false(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="false">
@@ -127,7 +139,8 @@ def test_shuffle_false(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str)
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'Apple'.*'Banana'.*'Chocolate'.*'Donut'.*\].*</div>")
@@ -136,7 +149,8 @@ def test_shuffle_false(self):
         assert not response.has_shuffle()
 
     def test_shuffle_fixed_head_end(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -149,14 +163,16 @@ def test_shuffle_fixed_head_end(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         # Alpha Beta held back from shuffle (head end)
         self.assertRegex(the_html, r"<div>.*\[.*'Alpha'.*'Beta'.*'B'.*'A'.*'C'.*'D'.*\].*</div>")
 
     def test_shuffle_fixed_tail_end(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -169,14 +185,16 @@ def test_shuffle_fixed_tail_end(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         # Alpha Beta held back from shuffle (tail end)
         self.assertRegex(the_html, r"<div>.*\[.*'B'.*'A'.*'C'.*'D'.*'Alpha'.*'Beta'.*\].*</div>")
 
     def test_shuffle_fixed_both_ends(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -192,16 +210,15 @@ def test_shuffle_fixed_both_ends(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
-        self.assertRegex(
-            the_html,
-            r"<div>.*\[.*'Alpha'.*'Beta'.*'B'.*'A'.*'C'.*'D'.*'Psi'.*'Omega'.*\].*</div>"
-        )
+        self.assertRegex(the_html, r"<div>.*\[.*'Alpha'.*'Beta'.*'B'.*'A'.*'C'.*'D'.*'Psi'.*'Omega'.*\].*</div>")
 
     def test_shuffle_fixed_both_ends_thin(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -211,13 +228,15 @@ def test_shuffle_fixed_both_ends_thin(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'Alpha'.*'A'.*'Omega'.*\].*</div>")
 
     def test_shuffle_fixed_all(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -227,14 +246,16 @@ def test_shuffle_fixed_all(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'A'.*'B'.*'C'.*\].*</div>")
 
     def test_shuffle_island(self):
         """A fixed 'island' choice not at the head or tail end gets lumped into the tail end."""
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -246,13 +267,15 @@ def test_shuffle_island(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<div>.*\[.*'A'.*'Mid'.*'Mid'.*'C'.*'D'.*\].*</div>")
 
     def test_multiple_shuffle_responses(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true">
@@ -272,25 +295,30 @@ def test_multiple_shuffle_responses(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         problem = new_loncapa_problem(xml_str, seed=0)
         orig_html = problem.get_html()
-        assert orig_html == problem.get_html(), 'should be able to call get_html() twice'
-        html = orig_html.replace('\n', ' ')  # avoid headaches with .* matching
+        assert orig_html == problem.get_html(), "should be able to call get_html() twice"
+        html = orig_html.replace("\n", " ")  # avoid headaches with .* matching
         print(html)
-        self.assertRegex(html, r"<div>.*\[.*'Banana'.*'Apple'.*'Chocolate'.*'Donut'.*\].*</div>.*" +
-                         r"<div>.*\[.*'C'.*'A'.*'D'.*'B'.*\].*</div>")
+        self.assertRegex(
+            html,
+            r"<div>.*\[.*'Banana'.*'Apple'.*'Chocolate'.*'Donut'.*\].*</div>.*"
+            + r"<div>.*\[.*'C'.*'A'.*'D'.*'B'.*\].*</div>",
+        )
         # Look at the responses in their authored order
-        responses = sorted(list(problem.responders.values()), key=lambda resp: int(resp.id[resp.id.rindex('_') + 1:]))
+        responses = sorted(list(problem.responders.values()), key=lambda resp: int(resp.id[resp.id.rindex("_") + 1 :]))
         assert not responses[0].has_mask()
         assert responses[0].has_shuffle()
         assert responses[1].has_shuffle()
-        assert responses[0].unmask_order() == ['choice_1', 'choice_0', 'choice_2', 'choice_3']
-        assert responses[1].unmask_order() == ['choice_2', 'choice_0', 'choice_3', 'choice_1']
+        assert responses[0].unmask_order() == ["choice_1", "choice_0", "choice_2", "choice_3"]
+        assert responses[1].unmask_order() == ["choice_2", "choice_0", "choice_3", "choice_1"]
 
     def test_shuffle_not_with_answerpool(self):
         """Raise error if shuffle and answer-pool are both used."""
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" shuffle="true" answer-pool="4">
@@ -302,7 +330,8 @@ def test_shuffle_not_with_answerpool(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
 
         with self.assertRaisesRegex(LoncapaProblemError, "shuffle and answer-pool"):
             new_loncapa_problem(xml_str)
diff --git a/xmodule/capa/tests/test_targeted_feedback.py b/xmodule/capa/tests/test_targeted_feedback.py
index 0ec13b4962a2..399164791bd6 100644
--- a/xmodule/capa/tests/test_targeted_feedback.py
+++ b/xmodule/capa/tests/test_targeted_feedback.py
@@ -3,23 +3,24 @@
 i.e. those with the <multiplechoiceresponse> element
 """
 
-
 import textwrap
 import unittest
-from xmodule.capa.tests.helpers import load_fixture, new_loncapa_problem, mock_capa_system
+
+from xmodule.capa.tests.helpers import load_fixture, mock_capa_system, new_loncapa_problem
 
 
 class CapaTargetedFeedbackTest(unittest.TestCase):
-    '''
+    """
     Testing class
-    '''
+    """
 
     def setUp(self):
         super(CapaTargetedFeedbackTest, self).setUp()  # lint-amnesty, pylint: disable=super-with-arguments
         self.system = mock_capa_system()
 
     def test_no_targeted_feedback(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse>
@@ -71,7 +72,8 @@ def test_no_targeted_feedback(self):
             </solution>
         </problem>
 
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
 
@@ -82,56 +84,65 @@ def test_no_targeted_feedback(self):
         self.assertRegex(without_new_lines, r"feedback1|feedback2|feedback3|feedbackC")
 
     def test_targeted_feedback_not_finished(self):
-        problem = new_loncapa_problem(load_fixture('targeted_feedback.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback.xml"))
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
 
         self.assertRegex(without_new_lines, r"<div>.*'wrong-1'.*'wrong-2'.*'correct-1'.*'wrong-3'.*</div>")
         self.assertNotRegex(without_new_lines, r"feedback1|feedback2|feedback3|feedbackC")
-        assert the_html == problem.get_html(), 'Should be able to call get_html() twice'
+        assert the_html == problem.get_html(), "Should be able to call get_html() twice"
 
     def test_targeted_feedback_student_answer1(self):
-        problem = new_loncapa_problem(load_fixture('targeted_feedback.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback.xml"))
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_3'}
+        problem.student_answers = {"1_2_1": "choice_3"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\\n", "").replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedback3\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Incorrect</span>.*3rd WRONG solution")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedback3\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Incorrect</span>.*3rd WRONG solution",
+        )
         self.assertNotRegex(without_new_lines, r"feedback1|feedback2|feedbackC")
         # Check that calling it multiple times yields the same thing
         the_html2 = problem.get_html()
         assert the_html == the_html2
 
     def test_targeted_feedback_student_answer2(self):
-        problem = new_loncapa_problem(load_fixture('targeted_feedback.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback.xml"))
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}
+        problem.student_answers = {"1_2_1": "choice_0"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\\n", "").replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Incorrect</span>.*1st WRONG solution")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Incorrect</span>.*1st WRONG solution",
+        )
         self.assertRegex(without_new_lines, r"<div>\{.*'1_solution_1'.*\}</div>")
         self.assertNotRegex(without_new_lines, r"feedback2|feedback3|feedbackC")
 
     def test_targeted_feedback_correct_answer(self):
-        """ Test the case of targeted feedback for a correct answer. """
-        problem = new_loncapa_problem(load_fixture('targeted_feedback.xml'))
+        """Test the case of targeted feedback for a correct answer."""
+        problem = new_loncapa_problem(load_fixture("targeted_feedback.xml"))
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_2'}
+        problem.student_answers = {"1_2_1": "choice_2"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\\n", "").replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines,
-                         r"<targetedfeedback explanation-id=\"feedbackC\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Correct</span>.*Feedback on your correct solution...")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedbackC\" role=\"group\" aria-describedby=\"1_2_1-legend\">\s*<span class=\"sr\">Correct</span>.*Feedback on your correct solution...",
+        )
         self.assertNotRegex(without_new_lines, r"feedback1|feedback2|feedback3")
 
     def test_targeted_feedback_id_typos(self):
         """Cases where the explanation-id's don't match anything."""
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="">
@@ -182,24 +193,26 @@ def test_targeted_feedback_id_typos(self):
             </div>
             </solution>
         </problem>
-        """)
+        """
+        )
 
         # explanation-id does not match anything: fall back to empty targetedfeedbackset
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}
+        problem.student_answers = {"1_2_1": "choice_0"}
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<targetedfeedbackset>\s*</targetedfeedbackset>")
 
         # New problem with same XML -- try the correct choice.
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_2'}  # correct
+        problem.student_answers = {"1_2_1": "choice_2"}  # correct
         the_html = problem.get_html()
         self.assertRegex(the_html, r"<targetedfeedbackset>\s*</targetedfeedbackset>")
 
     def test_targeted_feedback_no_solution_element(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="">
@@ -219,22 +232,21 @@ def test_targeted_feedback_no_solution_element(self):
                 </targetedfeedback>
             </targetedfeedbackset>
             </problem>
-        """)
+        """
+        )
 
         # Solution element not found
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_2'}
+        problem.student_answers = {"1_2_1": "choice_2"}
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # </div> right after </targetedfeedbackset>
-        self.assertRegex(
-            without_new_lines,
-            r"<div>.*<targetedfeedbackset>.*</targetedfeedbackset>\s*</div>"
-        )
+        self.assertRegex(without_new_lines, r"<div>.*<targetedfeedbackset>.*</targetedfeedbackset>\s*</div>")
 
     def test_targeted_feedback_show_solution_explanation(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="alwaysShowCorrectChoiceExplanation">
@@ -286,16 +298,20 @@ def test_targeted_feedback_show_solution_explanation(self):
             </solution>
         </problem>
 
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}
+        problem.student_answers = {"1_2_1": "choice_0"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution",
+        )
         self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedbackC\".*solution explanation")
         self.assertNotRegex(without_new_lines, r"<div>\{.*'1_solution_1'.*\}</div>")
         self.assertNotRegex(without_new_lines, r"feedback2|feedback3")
@@ -304,7 +320,8 @@ def test_targeted_feedback_show_solution_explanation(self):
         assert the_html == the_html2
 
     def test_targeted_feedback_no_show_solution_explanation(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="">
@@ -356,22 +373,27 @@ def test_targeted_feedback_no_show_solution_explanation(self):
             </solution>
         </problem>
 
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}
+        problem.student_answers = {"1_2_1": "choice_0"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution",
+        )
         self.assertNotRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedbackC\".*solution explanation")
         self.assertRegex(without_new_lines, r"<div>\{.*'1_solution_1'.*\}</div>")
         self.assertNotRegex(without_new_lines, r"feedback2|feedback3|feedbackC")
 
     def test_targeted_feedback_with_solutionset_explanation(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="alwaysShowCorrectChoiceExplanation">
@@ -433,22 +455,29 @@ def test_targeted_feedback_with_solutionset_explanation(self):
             </solutionset>
         </problem>
 
-        """)
+        """
+        )
 
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}
+        problem.student_answers = {"1_2_1": "choice_0"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # pylint: disable=line-too-long
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution")
-        self.assertRegex(without_new_lines, r"<targetedfeedback explanation-id=\"feedbackC2\".*other solution explanation")
+        self.assertRegex(
+            without_new_lines,
+            r"<targetedfeedback explanation-id=\"feedback1\" role=\"group\" aria-describedby=\"1_2_1-legend\">.*1st WRONG solution",
+        )
+        self.assertRegex(
+            without_new_lines, r"<targetedfeedback explanation-id=\"feedbackC2\".*other solution explanation"
+        )
         self.assertNotRegex(without_new_lines, r"<div>\{.*'1_solution_1'.*\}</div>")
         self.assertNotRegex(without_new_lines, r"feedback2|feedback3")
 
     def test_targeted_feedback_no_feedback_for_selected_choice1(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="alwaysShowCorrectChoiceExplanation">
@@ -495,13 +524,14 @@ def test_targeted_feedback_no_feedback_for_selected_choice1(self):
             </solutionset>
         </problem>
 
-        """)
+        """
+        )
 
         # The student choses one with no feedback, but alwaysShowCorrectChoiceExplanation
         # is in force, so we should see the correct solution feedback.
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_1'}
+        problem.student_answers = {"1_2_1": "choice_1"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
@@ -511,7 +541,8 @@ def test_targeted_feedback_no_feedback_for_selected_choice1(self):
         self.assertNotRegex(without_new_lines, r"feedback1|feedback3")
 
     def test_targeted_feedback_no_feedback_for_selected_choice2(self):
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
             <p>What is the correct answer?</p>
             <multiplechoiceresponse targeted-feedback="">
@@ -558,12 +589,13 @@ def test_targeted_feedback_no_feedback_for_selected_choice2(self):
             </solutionset>
         </problem>
 
-        """)
+        """
+        )
 
         # The student chooses one with no feedback set, so we check that there's no feedback.
         problem = new_loncapa_problem(xml_str)
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_1'}
+        problem.student_answers = {"1_2_1": "choice_1"}
 
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
@@ -574,37 +606,37 @@ def test_targeted_feedback_no_feedback_for_selected_choice2(self):
 
     def test_targeted_feedback_multiple_not_answered(self):
         # Not answered -> empty targeted feedback
-        problem = new_loncapa_problem(load_fixture('targeted_feedback_multiple.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback_multiple.xml"))
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # Q1 and Q2 have no feedback
         self.assertRegex(
             without_new_lines,
-            r'<targetedfeedbackset>\s*</targetedfeedbackset>.*<targetedfeedbackset>\s*</targetedfeedbackset>'
+            r"<targetedfeedbackset>\s*</targetedfeedbackset>.*<targetedfeedbackset>\s*</targetedfeedbackset>",
         )
 
     def test_targeted_feedback_multiple_answer_1(self):
-        problem = new_loncapa_problem(load_fixture('targeted_feedback_multiple.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback_multiple.xml"))
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0'}  # feedback1
+        problem.student_answers = {"1_2_1": "choice_0"}  # feedback1
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # Q1 has feedback1 and Q2 has nothing
         self.assertRegex(
             without_new_lines,
-            r'<targetedfeedbackset.*?>.*?explanation-id="feedback1".*?</targetedfeedbackset>.*' +
-            r'<targetedfeedbackset>\s*</targetedfeedbackset>'
+            r'<targetedfeedbackset.*?>.*?explanation-id="feedback1".*?</targetedfeedbackset>.*'
+            + r"<targetedfeedbackset>\s*</targetedfeedbackset>",
         )
 
     def test_targeted_feedback_multiple_answer_2(self):
-        problem = new_loncapa_problem(load_fixture('targeted_feedback_multiple.xml'))
+        problem = new_loncapa_problem(load_fixture("targeted_feedback_multiple.xml"))
         problem.done = True
-        problem.student_answers = {'1_2_1': 'choice_0', '1_3_1': 'choice_2'}  # Q1 wrong, Q2 correct
+        problem.student_answers = {"1_2_1": "choice_0", "1_3_1": "choice_2"}  # Q1 wrong, Q2 correct
         the_html = problem.get_html()
         without_new_lines = the_html.replace("\n", "")
         # Q1 has feedback1 and Q2 has feedbackC
         self.assertRegex(
             without_new_lines,
-            r'<targetedfeedbackset.*?>.*?explanation-id="feedback1".*?</targetedfeedbackset>.*' +
-            r'<targetedfeedbackset.*?>.*explanation-id="feedbackC".*?</targetedfeedbackset>'
+            r'<targetedfeedbackset.*?>.*?explanation-id="feedback1".*?</targetedfeedbackset>.*'
+            + r'<targetedfeedbackset.*?>.*explanation-id="feedbackC".*?</targetedfeedbackset>',
         )
diff --git a/xmodule/capa/tests/test_util.py b/xmodule/capa/tests/test_util.py
index 3176ff9b9a3d..da62d2d01d98 100644
--- a/xmodule/capa/tests/test_util.py
+++ b/xmodule/capa/tests/test_util.py
@@ -17,7 +17,7 @@
     contextualize_text,
     get_inner_html_from_xpath,
     remove_markup,
-    sanitize_html
+    sanitize_html,
 )
 
 
@@ -38,24 +38,24 @@ def test_compare_with_tolerance(self):  # lint-amnesty, pylint: disable=too-many
         result = compare_with_tolerance(101.0, 100.0)
         assert not result
         # Test absolute percentage tolerance
-        result = compare_with_tolerance(109.9, 100.0, '10%', False)
+        result = compare_with_tolerance(109.9, 100.0, "10%", False)
         assert result
-        result = compare_with_tolerance(110.1, 100.0, '10%', False)
+        result = compare_with_tolerance(110.1, 100.0, "10%", False)
         assert not result
         # Test relative percentage tolerance
-        result = compare_with_tolerance(111.0, 100.0, '10%', True)
+        result = compare_with_tolerance(111.0, 100.0, "10%", True)
         assert result
-        result = compare_with_tolerance(112.0, 100.0, '10%', True)
+        result = compare_with_tolerance(112.0, 100.0, "10%", True)
         assert not result
         # Test absolute tolerance (string)
-        result = compare_with_tolerance(109.9, 100.0, '10.0', False)
+        result = compare_with_tolerance(109.9, 100.0, "10.0", False)
         assert result
-        result = compare_with_tolerance(110.1, 100.0, '10.0', False)
+        result = compare_with_tolerance(110.1, 100.0, "10.0", False)
         assert not result
         # Test relative tolerance (string)
-        result = compare_with_tolerance(111.0, 100.0, '0.1', True)
+        result = compare_with_tolerance(111.0, 100.0, "0.1", True)
         assert result
-        result = compare_with_tolerance(112.0, 100.0, '0.1', True)
+        result = compare_with_tolerance(112.0, 100.0, "0.1", True)
         assert not result
         # Test absolute tolerance (float)
         result = compare_with_tolerance(109.9, 100.0, 10.0, False)
@@ -68,7 +68,7 @@ def test_compare_with_tolerance(self):  # lint-amnesty, pylint: disable=too-many
         result = compare_with_tolerance(112.0, 100.0, 0.1, True)
         assert not result
         ##### Infinite values #####
-        infinity = float('Inf')
+        infinity = float("Inf")
         # Test relative tolerance (float)
         result = compare_with_tolerance(infinity, 100.0, 1.0, True)
         assert not result
@@ -84,25 +84,25 @@ def test_compare_with_tolerance(self):  # lint-amnesty, pylint: disable=too-many
         result = compare_with_tolerance(infinity, infinity, 1.0, False)
         assert result
         # Test relative tolerance (string)
-        result = compare_with_tolerance(infinity, 100.0, '1.0', True)
+        result = compare_with_tolerance(infinity, 100.0, "1.0", True)
         assert not result
-        result = compare_with_tolerance(100.0, infinity, '1.0', True)
+        result = compare_with_tolerance(100.0, infinity, "1.0", True)
         assert not result
-        result = compare_with_tolerance(infinity, infinity, '1.0', True)
+        result = compare_with_tolerance(infinity, infinity, "1.0", True)
         assert result
         # Test absolute tolerance (string)
-        result = compare_with_tolerance(infinity, 100.0, '1.0', False)
+        result = compare_with_tolerance(infinity, 100.0, "1.0", False)
         assert not result
-        result = compare_with_tolerance(100.0, infinity, '1.0', False)
+        result = compare_with_tolerance(100.0, infinity, "1.0", False)
         assert not result
-        result = compare_with_tolerance(infinity, infinity, '1.0', False)
+        result = compare_with_tolerance(infinity, infinity, "1.0", False)
         assert result
         # Test absolute tolerance for smaller values
         result = compare_with_tolerance(100.01, 100.0, 0.01, False)
         assert result
         result = compare_with_tolerance(100.001, 100.0, 0.001, False)
         assert result
-        result = compare_with_tolerance(100.01, 100.0, '0.01%', False)
+        result = compare_with_tolerance(100.01, 100.0, "0.01%", False)
         assert result
         result = compare_with_tolerance(100.002, 100.0, 0.001, False)
         assert not result
@@ -116,21 +116,21 @@ def test_compare_with_tolerance(self):  # lint-amnesty, pylint: disable=too-many
         assert not result
         result = compare_with_tolerance(100.01, complex(100.0, 0), 0.010, False)
         assert result
-        result = compare_with_tolerance(110.1, complex(100.0, 0), '10.0', False)
+        result = compare_with_tolerance(110.1, complex(100.0, 0), "10.0", False)
         assert not result
-        result = compare_with_tolerance(111.0, complex(100.0, 0), '10%', True)
+        result = compare_with_tolerance(111.0, complex(100.0, 0), "10%", True)
         assert result
 
     def test_sanitize_html(self):
         """
         Test for html sanitization with nh3.
         """
-        allowed_tags = ['div', 'p', 'audio', 'pre', 'span']
+        allowed_tags = ["div", "p", "audio", "pre", "span"]
         for tag in allowed_tags:
             queue_msg = "<{0}>Test message</{0}>".format(tag)
             assert sanitize_html(queue_msg) == queue_msg
 
-        not_allowed_tag = 'script'
+        not_allowed_tag = "script"
         queue_msg = "<{0}>Test message</{0}>".format(not_allowed_tag)
         expected = ""
         assert sanitize_html(queue_msg) == expected
@@ -146,27 +146,26 @@ def test_remove_markup(self):
         """
         Test for markup removal with nh3.
         """
-        assert remove_markup('The <mark>Truth</mark> is <em>Out There</em> & you need to <strong>find</strong> it') ==\
-            'The Truth is Out There &amp; you need to find it'
+        assert (
+            remove_markup("The <mark>Truth</mark> is <em>Out There</em> & you need to <strong>find</strong> it")
+            == "The Truth is Out There &amp; you need to find it"
+        )
 
-    @ddt.data(
-        'When the root level failš the whole hierarchy won’t work anymore.',
-        'あなたあなたあなた'
-    )
+    @ddt.data("When the root level failš the whole hierarchy won’t work anymore.", "あなたあなたあなた")
     def test_contextualize_text(self, context_value):
         """Verify that variable substitution works as intended with non-ascii characters."""
-        key = 'answer0'
-        text = '$answer0'
+        key = "answer0"
+        text = "$answer0"
         context = {key: context_value}
         contextual_text = contextualize_text(text, context)
         assert context_value == contextual_text
 
     def test_contextualize_text_with_non_ascii_context(self):
         """Verify that variable substitution works as intended with non-ascii characters."""
-        key = 'あなた$a $b'
-        text = '$' + key
-        context = {'a': 'あなたあなたあなた', 'b': 'あなたhi'}
-        expected_text = '$あなたあなたあなたあなた あなたhi'
+        key = "あなた$a $b"
+        text = "$" + key
+        context = {"a": "あなたあなたあなた", "b": "あなたhi"}
+        expected_text = "$あなたあなたあなたあなた あなたhi"
         contextual_text = contextualize_text(text, context)
         assert expected_text == contextual_text
 
diff --git a/xmodule/capa/tests/test_xqueue_interface.py b/xmodule/capa/tests/test_xqueue_interface.py
index db06fbfcb367..91f7e838578e 100644
--- a/xmodule/capa/tests/test_xqueue_interface.py
+++ b/xmodule/capa/tests/test_xqueue_interface.py
@@ -1,14 +1,14 @@
 """Test the XQueue service and interface."""
 
+import json
 from unittest import TestCase
 from unittest.mock import Mock, patch
 
+import pytest
 from django.conf import settings
 from django.test.utils import override_settings
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
 from xblock.fields import ScopeIds
-import pytest
-import json
 
 from openedx.core.djangolib.testing.utils import skip_unless_lms
 from xmodule.capa.xqueue_interface import XQueueInterface, XQueueService
@@ -59,14 +59,14 @@ def test_construct_callback_with_flag_enabled(self, mock_flag):
     def test_construct_callback_with_flag_disabled(self, mock_flag):
         """Test construct_callback when the waffle flag is disabled."""
         usage_id = self.block.scope_ids.usage_id
-        callback_url = f'courses/{usage_id.context_key}/xqueue/user1/{usage_id}'
+        callback_url = f"courses/{usage_id.context_key}/xqueue/user1/{usage_id}"
 
-        assert self.service.construct_callback() == f'{settings.LMS_ROOT_URL}/{callback_url}/score_update'
-        assert self.service.construct_callback('alt_dispatch') == f'{settings.LMS_ROOT_URL}/{callback_url}/alt_dispatch'
+        assert self.service.construct_callback() == f"{settings.LMS_ROOT_URL}/{callback_url}/score_update"
+        assert self.service.construct_callback("alt_dispatch") == f"{settings.LMS_ROOT_URL}/{callback_url}/alt_dispatch"
 
-        custom_callback_url = 'http://alt.url'
-        with override_settings(XQUEUE_INTERFACE={**settings.XQUEUE_INTERFACE, 'callback_url': custom_callback_url}):
-            assert self.service.construct_callback() == f'{custom_callback_url}/{callback_url}/score_update'
+        custom_callback_url = "http://alt.url"
+        with override_settings(XQUEUE_INTERFACE={**settings.XQUEUE_INTERFACE, "callback_url": custom_callback_url}):
+            assert self.service.construct_callback() == f"{custom_callback_url}/{callback_url}/score_update"
 
     def test_default_queuename(self):
         """Check the format of the default queue name."""
@@ -90,16 +90,20 @@ def test_send_to_queue_with_flag_enabled(mock_send_to_submission, mock_flag):
     block = Mock()  # Mock block for the constructor
     xqueue_interface = XQueueInterface(url, django_auth, block=block)
 
-    header = json.dumps({
-        "lms_callback_url": (
-            "http://example.com/courses/course-v1:test_org+test_course+test_run/"
-            "xqueue/block@item_id/type@problem"
-        ),
-    })
-    body = json.dumps({
-        "student_info": json.dumps({"anonymous_student_id": "student_id"}),
-        "student_response": "student_answer",
-    })
+    header = json.dumps(
+        {
+            "lms_callback_url": (
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/"
+                "xqueue/block@item_id/type@problem"
+            ),
+        }
+    )
+    body = json.dumps(
+        {
+            "student_info": json.dumps({"anonymous_student_id": "student_id"}),
+            "student_response": "student_answer",
+        }
+    )
     files_to_upload = None
 
     mock_send_to_submission.return_value = {"submission": "mock_submission"}
@@ -118,16 +122,20 @@ def test_send_to_queue_with_flag_disabled(mock_http_post, mock_flag):
     block = Mock()  # Mock block for the constructor
     xqueue_interface = XQueueInterface(url, django_auth, block=block)
 
-    header = json.dumps({
-        "lms_callback_url": (
-            "http://example.com/courses/course-v1:test_org+test_course+test_run/"
-            "xqueue/block@item_id/type@problem"
-        ),
-    })
-    body = json.dumps({
-        "student_info": json.dumps({"anonymous_student_id": "student_id"}),
-        "student_response": "student_answer",
-    })
+    header = json.dumps(
+        {
+            "lms_callback_url": (
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/"
+                "xqueue/block@item_id/type@problem"
+            ),
+        }
+    )
+    body = json.dumps(
+        {
+            "student_info": json.dumps({"anonymous_student_id": "student_id"}),
+            "student_response": "student_answer",
+        }
+    )
     files_to_upload = None
 
     mock_http_post.return_value = (0, "Submission sent successfully")
diff --git a/xmodule/capa/tests/test_xqueue_submission.py b/xmodule/capa/tests/test_xqueue_submission.py
index 704c6249d447..806a103f6ac2 100644
--- a/xmodule/capa/tests/test_xqueue_submission.py
+++ b/xmodule/capa/tests/test_xqueue_submission.py
@@ -1,25 +1,24 @@
 """
 Unit tests for the XQueueInterfaceSubmission class.
 """
+
 import json
-import pytest
 from unittest.mock import Mock, patch
-from xmodule.capa.xqueue_submission import XQueueInterfaceSubmission
+
+import pytest
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
 from xblock.fields import ScopeIds
 
+from xmodule.capa.xqueue_submission import XQueueInterfaceSubmission
+
 
 @pytest.fixture
 def xqueue_service():
     """
     Fixture that returns an instance of XQueueInterfaceSubmission.
     """
-    location = BlockUsageLocator(
-        CourseLocator("test_org", "test_course", "test_run"),
-        "problem",
-        "ExampleProblem"
-    )
-    block = Mock(scope_ids=ScopeIds('user1', 'problem', location, location))
+    location = BlockUsageLocator(CourseLocator("test_org", "test_course", "test_run"), "problem", "ExampleProblem")
+    block = Mock(scope_ids=ScopeIds("user1", "problem", location, location))
     block.max_score = Mock(return_value=10)
     return XQueueInterfaceSubmission(block)
 
@@ -28,49 +27,52 @@ def test_get_submission_params(xqueue_service):
     """
     Test extracting item data from an xqueue submission.
     """
-    header = json.dumps({
-        'lms_callback_url': 'http://example.com/callback',
-        'queue_name': 'default'
-    })
-    payload = json.dumps({
-        'student_info': json.dumps({'anonymous_student_id': 'student_id'}),
-        'student_response': 'student_answer',
-        'grader_payload': json.dumps({'grader': 'test.py'})
-    })
-
-    student_item, student_answer, queue_name, grader_file_name, points_possible = (
-        xqueue_service.get_submission_params(header, payload)
+    header = json.dumps({"lms_callback_url": "http://example.com/callback", "queue_name": "default"})
+    payload = json.dumps(
+        {
+            "student_info": json.dumps({"anonymous_student_id": "student_id"}),
+            "student_response": "student_answer",
+            "grader_payload": json.dumps({"grader": "test.py"}),
+        }
+    )
+
+    student_item, student_answer, queue_name, grader_file_name, points_possible = xqueue_service.get_submission_params(
+        header, payload
     )
 
     assert student_item == {
-        'item_id': 'block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem',
-        'item_type': 'problem',
-        'course_id': 'course-v1:test_org+test_course+test_run',
-        'student_id': 'student_id'
+        "item_id": "block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem",
+        "item_type": "problem",
+        "course_id": "course-v1:test_org+test_course+test_run",
+        "student_id": "student_id",
     }
-    assert student_answer == 'student_answer'
-    assert queue_name == 'default'
-    assert grader_file_name == 'test.py'
+    assert student_answer == "student_answer"
+    assert queue_name == "default"
+    assert grader_file_name == "test.py"
     assert points_possible == 10
 
 
 @pytest.mark.django_db
-@patch('submissions.api.create_external_grader_detail')
+@patch("submissions.api.create_external_grader_detail")
 def test_send_to_submission(mock_create_external_grader_detail, xqueue_service):
     """
     Test sending a submission to the grading system.
     """
-    header = json.dumps({
-        'lms_callback_url': (
-            'http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/5/'
-            'block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem/'
-        ),
-    })
-    body = json.dumps({
-        'student_info': json.dumps({'anonymous_student_id': 'student_id'}),
-        'student_response': 'student_answer',
-        'grader_payload': json.dumps({'grader': 'test.py'})
-    })
+    header = json.dumps(
+        {
+            "lms_callback_url": (
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/5/"
+                "block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem/"
+            ),
+        }
+    )
+    body = json.dumps(
+        {
+            "student_info": json.dumps({"anonymous_student_id": "student_id"}),
+            "student_response": "student_answer",
+            "grader_payload": json.dumps({"grader": "test.py"}),
+        }
+    )
 
     mock_response = {"submission": "mock_submission"}
     mock_create_external_grader_detail.return_value = mock_response
@@ -80,35 +82,38 @@ def test_send_to_submission(mock_create_external_grader_detail, xqueue_service):
     assert result == mock_response
     mock_create_external_grader_detail.assert_called_once_with(
         {
-            'item_id': 'block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem',
-            'item_type': 'problem',
-            'course_id': 'course-v1:test_org+test_course+test_run',
-            'student_id': 'student_id'
+            "item_id": "block-v1:test_org+test_course+test_run+type@problem+block@ExampleProblem",
+            "item_type": "problem",
+            "course_id": "course-v1:test_org+test_course+test_run",
+            "student_id": "student_id",
         },
-        'student_answer',
-        queue_name='default',
-        grader_file_name='test.py',
+        "student_answer",
+        queue_name="default",
+        grader_file_name="test.py",
         points_possible=10,
-        files=None
+        files=None,
     )
 
 
 @pytest.mark.django_db
-@patch('submissions.api.create_external_grader_detail')
+@patch("submissions.api.create_external_grader_detail")
 def test_send_to_submission_with_missing_fields(mock_create_external_grader_detail, xqueue_service):
     """
     Test send_to_submission with missing required fields.
     """
-    header = json.dumps({
-        'lms_callback_url': (
-            'http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/5/'
-            'block@item_id/'
-        )
-    })
-    body = json.dumps({
-        'student_info': json.dumps({'anonymous_student_id': 'student_id'}),
-        'grader_payload': json.dumps({'grader': 'test.py'})
-    })
+    header = json.dumps(
+        {
+            "lms_callback_url": (
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/5/" "block@item_id/"
+            )
+        }
+    )
+    body = json.dumps(
+        {
+            "student_info": json.dumps({"anonymous_student_id": "student_id"}),
+            "grader_payload": json.dumps({"grader": "test.py"}),
+        }
+    )
 
     result = xqueue_service.send_to_submission(header, body)
 
diff --git a/xmodule/capa/util.py b/xmodule/capa/util.py
index ff8a22f07245..f33d2e5a6ddf 100644
--- a/xmodule/capa/util.py
+++ b/xmodule/capa/util.py
@@ -2,7 +2,6 @@
 Utility functions for capa.
 """
 
-
 import logging
 import re
 from cmath import isinf, isnan
@@ -14,10 +13,10 @@
 
 from openedx.core.djangolib.markup import HTML
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #
 # Utility functions used in CAPA responsetypes
-default_tolerance = '0.001%'
+default_tolerance = "0.001%"
 log = logging.getLogger(__name__)
 
 
@@ -59,7 +58,7 @@ def compare_with_tolerance(student_complex, instructor_complex, tolerance=defaul
     if isinstance(tolerance, str):
         if tolerance == default_tolerance:
             relative_tolerance = True
-        if tolerance.endswith('%'):
+        if tolerance.endswith("%"):
             tolerance = evaluator({}, {}, tolerance[:-1]) * 0.01
             if not relative_tolerance:
                 tolerance = tolerance * abs(instructor_complex)
@@ -102,12 +101,13 @@ def contextualize_text(text, context):  # private
     Takes a string with variables. E.g. $a+$b.
     Does a substitution of those variables from the context
     """
+
     def convert_to_str(value):
         """The method tries to convert unicode/non-ascii values into string"""
         try:
             return str(value)
         except UnicodeEncodeError:
-            return value.encode('utf8', errors='ignore')
+            return value.encode("utf8", errors="ignore")
 
     if not text:
         return text
@@ -118,8 +118,8 @@ def convert_to_str(value):
         # program, but also e.g. a reference to the numpy module.
         # Should be a separate dict of variables that should be
         # replaced.
-        context_key = '$' + key
-        if context_key in (text.decode('utf-8') if isinstance(text, bytes) else text):
+        context_key = "$" + key
+        if context_key in (text.decode("utf-8") if isinstance(text, bytes) else text):
             text = convert_to_str(text)
             context_value = convert_to_str(context[key])
             text = text.replace(context_key, context_value)
@@ -151,7 +151,7 @@ def is_file(file_to_test):
     """
     Duck typing to check if 'file_to_test' is a File object
     """
-    return all(hasattr(file_to_test, method) for method in ['read', 'name'])
+    return all(hasattr(file_to_test, method) for method in ["read", "name"])
 
 
 def find_with_default(node, path, default):
@@ -182,15 +182,15 @@ def sanitize_html(html_code):
     Used to sanitize XQueue responses from Matlab.
     """
     attributes = nh3.ALLOWED_ATTRIBUTES.copy()
-    attributes.update({
-        '*': {'class', 'style', 'id'},
-        'audio': {'controls', 'autobuffer', 'autoplay', 'src'},
-        'img': {'src', 'width', 'height', 'class'}
-    })
+    attributes.update(
+        {
+            "*": {"class", "style", "id"},
+            "audio": {"controls", "autobuffer", "autoplay", "src"},
+            "img": {"src", "width", "height", "class"},
+        }
+    )
     output = nh3.clean(
-        html_code,
-        tags=nh3.ALLOWED_TAGS | {'div', 'p', 'audio', 'pre', 'img', 'span'},
-        attributes=attributes
+        html_code, tags=nh3.ALLOWED_TAGS | {"div", "p", "audio", "pre", "img", "span"}, attributes=attributes
     )
     return output
 
@@ -201,10 +201,10 @@ def get_inner_html_from_xpath(xpath_node):
 
     """
     # returns string from xpath node
-    html = etree.tostring(xpath_node).strip().decode('utf-8')
+    html = etree.tostring(xpath_node).strip().decode("utf-8")
     # strips outer tag from html string
     # xss-lint: disable=python-interpolate-html
-    inner_html = re.sub('(?ms)<%s[^>]*>(.*)</%s>' % (xpath_node.tag, xpath_node.tag), '\\1', html)
+    inner_html = re.sub("(?ms)<%s[^>]*>(.*)</%s>" % (xpath_node.tag, xpath_node.tag), "\\1", html)
     return inner_html.strip()
 
 
diff --git a/xmodule/capa/xqueue_interface.py b/xmodule/capa/xqueue_interface.py
index 66b2dc738472..85d3b0e5dd8e 100644
--- a/xmodule/capa/xqueue_interface.py
+++ b/xmodule/capa/xqueue_interface.py
@@ -1,27 +1,28 @@
 """
 LMS Interface to external queueing system (xqueue)
 """
-from typing import Dict, Optional, TYPE_CHECKING
 
 import hashlib
 import json
 import logging
+from typing import TYPE_CHECKING, Dict, Optional
 
 import requests
 from django.conf import settings
 from django.urls import reverse
+from opaque_keys.edx.keys import CourseKey
 from requests.auth import HTTPBasicAuth
+
 from openedx.core.djangoapps.waffle_utils import CourseWaffleFlag
-from opaque_keys.edx.keys import CourseKey
 from xmodule.capa.xqueue_submission import XQueueInterfaceSubmission
 
 if TYPE_CHECKING:
     from xmodule.capa_block import ProblemBlock
 
 log = logging.getLogger(__name__)
-dateformat = '%Y%m%d%H%M%S'
+dateformat = "%Y%m%d%H%M%S"
 
-XQUEUE_METRIC_NAME = 'edxapp.xqueue'
+XQUEUE_METRIC_NAME = "edxapp.xqueue"
 
 # Wait time for response from Xqueue.
 XQUEUE_TIMEOUT = 35  # seconds
@@ -38,7 +39,7 @@
 # .. toggle_will_remain_in_codebase: True
 # .. toggle_tickets: none
 # .. toggle_status: supported
-SEND_TO_SUBMISSION_COURSE_FLAG = CourseWaffleFlag('send_to_submission_course.enable', __name__)
+SEND_TO_SUBMISSION_COURSE_FLAG = CourseWaffleFlag("send_to_submission_course.enable", __name__)
 
 
 def use_edx_submissions_for_xqueue(course_key: CourseKey | None = None) -> bool:
@@ -62,7 +63,7 @@ def make_hashkey(seed):
     Generate a string key by hashing
     """
     h = hashlib.md5()
-    h.update(str(seed).encode('latin-1'))
+    h.update(str(seed).encode("latin-1"))
     return h.hexdigest()
 
 
@@ -76,11 +77,7 @@ 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):
@@ -94,10 +91,10 @@ def parse_xreply(xreply):
         xreply = json.loads(xreply)
     except ValueError as err:
         log.error(err)
-        return (1, 'unexpected reply from server')
+        return (1, "unexpected reply from server")
 
-    return_code = xreply['return_code']
-    content = xreply['content']
+    return_code = xreply["return_code"]
+    content = xreply["content"]
 
     return (return_code, content)
 
@@ -105,9 +102,13 @@ def parse_xreply(xreply):
 class XQueueInterface:
     """Initializes the XQueue interface."""
 
-    def __init__(self, url: str, django_auth: Dict[str, str],
-                 requests_auth: Optional[HTTPBasicAuth] = None,
-                 block: 'ProblemBlock' = None):
+    def __init__(
+        self,
+        url: str,
+        django_auth: Dict[str, str],
+        requests_auth: Optional[HTTPBasicAuth] = None,
+        block: "ProblemBlock" = None,
+    ):
         """
         Initializes the XQueue interface.
 
@@ -142,13 +143,13 @@ def send_to_queue(self, header, body, files_to_upload=None):
 
         # log the send to xqueue
         header_info = json.loads(header)
-        queue_name = header_info.get('queue_name', '')  # lint-amnesty, pylint: disable=unused-variable
+        queue_name = header_info.get("queue_name", "")  # lint-amnesty, pylint: disable=unused-variable
 
         # Attempt to send to queue
         (error, msg) = self._send_to_queue(header, body, files_to_upload)
 
         # Log in, then try again
-        if error and (msg == 'login_required'):
+        if error and (msg == "login_required"):
             (error, content) = self._login()
             if error != 0:
                 # when the login fails
@@ -163,17 +164,11 @@ def send_to_queue(self, header, body, files_to_upload=None):
         return error, msg
 
     def _login(self):  # lint-amnesty, pylint: disable=missing-function-docstring
-        payload = {
-            'username': self.auth['username'],
-            'password': self.auth['password']
-        }
-        return self._http_post(self.url + '/xqueue/login/', payload)
+        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):  # lint-amnesty, pylint: disable=missing-function-docstring
-        payload = {
-            'xqueue_header': header,
-            'xqueue_body': body
-        }
+        payload = {"xqueue_header": header, "xqueue_body": body}
         files = {}
         if files_to_upload is not None:
             for f in files_to_upload:
@@ -185,31 +180,29 @@ def _send_to_queue(self, header, body, files_to_upload):  # lint-amnesty, pylint
                 "Unexpected None block: falling back to legacy xqueue submission. "
                 "This may indicate a problem with the xqueue transition."
             )
-            return self._http_post(self.url + '/xqueue/submit/', payload, files=files)
+            return self._http_post(self.url + "/xqueue/submit/", payload, files=files)
 
         course_key = self.block.scope_ids.usage_id.context_key
 
         if use_edx_submissions_for_xqueue(course_key):
             submission = self.submission.send_to_submission(header, body, files)
-            return None, ''
+            return None, ""
 
-        return self._http_post(self.url + '/xqueue/submit/', payload, files=files)
+        return self._http_post(self.url + "/xqueue/submit/", payload, files=files)
 
     def _http_post(self, url, data, files=None):  # lint-amnesty, pylint: disable=missing-function-docstring
         try:
-            response = self.session.post(
-                url, data=data, files=files, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT)
-            )
+            response = self.session.post(url, data=data, files=files, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT))
         except requests.exceptions.ConnectionError as err:
             log.error(err)
-            return 1, 'cannot connect to server'
+            return 1, "cannot connect to server"
 
         except requests.exceptions.ReadTimeout as err:
             log.error(err)
-            return 1, 'failed to read from the server'
+            return 1, "failed to read from the server"
 
         if response.status_code not in [200]:
-            return 1, 'unexpected HTTP status code [%d]' % response.status_code
+            return 1, "unexpected HTTP status code [%d]" % response.status_code
 
         return parse_xreply(response.text)
 
@@ -222,12 +215,11 @@ class XQueueService:
         block: The `ProblemBlock` instance.
     """
 
-    def __init__(self, block: 'ProblemBlock'):
-        basic_auth = settings.XQUEUE_INTERFACE.get('basic_auth')
+    def __init__(self, block: "ProblemBlock"):
+        basic_auth = settings.XQUEUE_INTERFACE.get("basic_auth")
         requests_auth = HTTPBasicAuth(*basic_auth) if basic_auth else None
         self._interface = XQueueInterface(
-            settings.XQUEUE_INTERFACE['url'], settings.XQUEUE_INTERFACE['django_auth'], requests_auth,
-            block=block
+            settings.XQUEUE_INTERFACE["url"], settings.XQUEUE_INTERFACE["django_auth"], requests_auth, block=block
         )
 
         self._block = block
@@ -268,7 +260,7 @@ def default_queuename(self) -> str:
         Returns the default queue name for the current course.
         """
         course_id = self._block.scope_ids.usage_id.context_key
-        return f'{course_id.org}-{course_id.course}'.replace(' ', '_')
+        return f"{course_id.org}-{course_id.course}".replace(" ", "_")
 
     @property
     def waittime(self) -> int:
diff --git a/xmodule/capa/xqueue_submission.py b/xmodule/capa/xqueue_submission.py
index 3d7f061ffc5d..b45e1b8ce87e 100644
--- a/xmodule/capa/xqueue_submission.py
+++ b/xmodule/capa/xqueue_submission.py
@@ -5,13 +5,14 @@
 
 import json
 import logging
+
 from xmodule.capa.errors import (
     GetSubmissionParamsError,
     JSONParsingError,
     MissingKeyError,
-    ValidationError,
+    RuntimeErrorSubmission,
     TypeErrorSubmission,
-    RuntimeErrorSubmission
+    ValidationError,
 )
 
 log = logging.getLogger(__name__)
@@ -49,7 +50,7 @@ def get_submission_params(self, header, payload):
         header = self._parse_json(header, "header")
         payload = self._parse_json(payload, "payload")
 
-        queue_name = header.get('queue_name', 'default')
+        queue_name = header.get("queue_name", "default")
 
         if not self.block:
             raise GetSubmissionParamsError()
@@ -62,7 +63,7 @@ def get_submission_params(self, header, payload):
 
         try:
             grader_payload = self._parse_json(payload["grader_payload"], "grader_payload")
-            grader_file_name = grader_payload.get("grader", '')
+            grader_file_name = grader_payload.get("grader", "")
         except KeyError as e:
             raise MissingKeyError("grader_payload") from e
 
@@ -76,12 +77,7 @@ def get_submission_params(self, header, payload):
         if student_answer is None:
             raise ValidationError("The field 'student_response' does not exist.")
 
-        student_dict = {
-            'item_id': item_id,
-            'item_type': item_type,
-            'course_id': course_id,
-            'student_id': student_id
-        }
+        student_dict = {"item_id": item_id, "item_type": item_type, "course_id": course_id, "student_id": student_id}
 
         return student_dict, student_answer, queue_name, grader_file_name, points_possible
 
@@ -91,8 +87,9 @@ def send_to_submission(self, header, body, files_to_upload=None):
         """
         try:
             from submissions.api import create_external_grader_detail
-            student_item, answer, queue_name, grader_file_name, points_possible = (
-                self.get_submission_params(header, body)
+
+            student_item, answer, queue_name, grader_file_name, points_possible = self.get_submission_params(
+                header, body
             )
             return create_external_grader_detail(
                 student_item,
@@ -100,7 +97,7 @@ def send_to_submission(self, header, body, files_to_upload=None):
                 queue_name=queue_name,
                 grader_file_name=grader_file_name,
                 points_possible=points_possible,
-                files=files_to_upload
+                files=files_to_upload,
             )
         except (JSONParsingError, MissingKeyError, ValidationError) as e:
             log.error("%s", e)
diff --git a/xmodule/capa_block.py b/xmodule/capa_block.py
index 1a096e76b22d..0ae400b434a7 100644
--- a/xmodule/capa_block.py
+++ b/xmodule/capa_block.py
@@ -1,6 +1,7 @@
 """
 Implements the Problem XBlock, which is built on top of the CAPA subsystem.
 """
+
 from __future__ import annotations
 
 import copy
@@ -23,14 +24,14 @@
 from pytz import utc
 from web_fragments.fragment import Fragment
 from xblock.core import XBlock
-from xblock.fields import Boolean, Dict, Float, Integer, Scope, String, XMLString, List
+from xblock.fields import Boolean, Dict, Float, Integer, List, Scope, String, XMLString
 from xblock.scorable import ScorableXBlockMixin, Score
 from xblocks_contrib.problem import ProblemBlock as _ExtractedProblemBlock
 
 from common.djangoapps.xblock_django.constants import (
     ATTR_KEY_DEPRECATED_ANONYMOUS_USER_ID,
-    ATTR_KEY_USER_IS_STAFF,
     ATTR_KEY_USER_ID,
+    ATTR_KEY_USER_IS_STAFF,
 )
 from openedx.core.djangolib.markup import HTML, Text
 from xmodule.capa import responsetypes
@@ -43,15 +44,11 @@
 from xmodule.exceptions import NotFoundError, ProcessingError
 from xmodule.graders import ShowCorrectness
 from xmodule.raw_block import RawMixin
-from xmodule.util.builtin_assets import add_webpack_js_to_fragment, add_css_to_fragment
+from xmodule.util.builtin_assets import add_css_to_fragment, add_webpack_js_to_fragment
 from xmodule.util.sandboxing import SandboxService
-from xmodule.x_module import (
-    ResourceTemplates,
-    XModuleMixin,
-    XModuleToXBlockMixin,
-    shim_xmodule_js
-)
+from xmodule.x_module import ResourceTemplates, XModuleMixin, XModuleToXBlockMixin, shim_xmodule_js
 from xmodule.xml_block import XmlMixin
+
 from .capa.xqueue_interface import XQueueService
 from .fields import Date, ListScoreField, ScoreField, Timedelta
 from .progress import Progress
@@ -69,7 +66,7 @@
 
 
 try:
-    FEATURES = getattr(settings, 'FEATURES', {})
+    FEATURES = getattr(settings, "FEATURES", {})
 except ImproperlyConfigured:
     FEATURES = {}
 
@@ -78,6 +75,7 @@ class SHOWANSWER:
     """
     Constants for when to show answer
     """
+
     ALWAYS = "always"
     ANSWERED = "answered"
     ATTEMPTED = "attempted"
@@ -96,6 +94,7 @@ class GRADING_METHOD:
     """
     Constants for grading method options.
     """
+
     LAST_SCORE = "last_score"
     FIRST_SCORE = "first_score"
     HIGHEST_SCORE = "highest_score"
@@ -106,6 +105,7 @@ class RANDOMIZATION:
     """
     Constants for problem randomization
     """
+
     ALWAYS = "always"
     ONRESET = "onreset"
     NEVER = "never"
@@ -116,6 +116,7 @@ class Randomization(String):
     """
     Define a field to store how to randomize a problem.
     """
+
     def from_json(self, value):
         if value in ("", "true"):
             return RANDOMIZATION.ALWAYS
@@ -126,13 +127,13 @@ def from_json(self, value):
     to_json = from_json
 
 
-@XBlock.needs('user')
-@XBlock.needs('i18n')
-@XBlock.needs('mako')
-@XBlock.needs('cache')
-@XBlock.needs('sandbox')
-@XBlock.needs('replace_urls')
-@XBlock.wants('call_to_action')
+@XBlock.needs("user")
+@XBlock.needs("i18n")
+@XBlock.needs("mako")
+@XBlock.needs("cache")
+@XBlock.needs("sandbox")
+@XBlock.needs("replace_urls")
+@XBlock.wants("call_to_action")
 class _BuiltInProblemBlock(
     ScorableXBlockMixin,
     RawMixin,
@@ -158,7 +159,8 @@ class _BuiltInProblemBlock(
     Online - Computer-Assisted Personalized Approach" LMS, from which this
     system is inspired.
     """
-    INDEX_CONTENT_TYPE = 'CAPA'
+
+    INDEX_CONTENT_TYPE = "CAPA"
 
     is_extracted = False
 
@@ -166,11 +168,11 @@ class _BuiltInProblemBlock(
 
     has_score = True
     show_in_read_only_mode = True
-    template_dir_name = 'problem'
+    template_dir_name = "problem"
     mako_template = "widgets/problem-edit.html"
     has_author_view = True
 
-    icon_class = 'problem'
+    icon_class = "problem"
 
     uses_xmodule_styles_setup = True
 
@@ -180,18 +182,19 @@ class _BuiltInProblemBlock(
         scope=Scope.settings,
         # it'd be nice to have a useful default but it screws up other things; so,
         # use display_name_with_default for those
-        default=_("Blank Problem")
+        default=_("Blank Problem"),
     )
     attempts = Integer(
-        help=_("Number of attempts taken by the student on this problem"),
-        default=0,
-        scope=Scope.user_state
+        help=_("Number of attempts taken by the student on this problem"), default=0, scope=Scope.user_state
     )
     max_attempts = Integer(
         display_name=_("Maximum Attempts"),
-        help=_("Defines the number of times a student can try to answer this problem. "
-               "If the value is not set, infinite attempts are allowed."),
-        values={"min": 0}, scope=Scope.settings
+        help=_(
+            "Defines the number of times a student can try to answer this problem. "
+            "If the value is not set, infinite attempts are allowed."
+        ),
+        values={"min": 0},
+        scope=Scope.settings,
     )
     grading_method = String(
         display_name=_("Grading Method"),
@@ -210,13 +213,14 @@ class _BuiltInProblemBlock(
     )
     due = Date(help=_("Date that this problem is due by"), scope=Scope.settings)
     graceperiod = Timedelta(
-        help=_("Amount of time after the due date that submissions will be accepted"),
-        scope=Scope.settings
+        help=_("Amount of time after the due date that submissions will be accepted"), scope=Scope.settings
     )
     show_correctness = String(
         display_name=_("Show Results"),
-        help=_("Defines when to show whether a learner's answer to the problem is correct. "
-               "Configured on the subsection."),
+        help=_(
+            "Defines when to show whether a learner's answer to the problem is correct. "
+            "Configured on the subsection."
+        ),
         scope=Scope.settings,
         default=ShowCorrectness.ALWAYS,
         values=[
@@ -227,8 +231,7 @@ class _BuiltInProblemBlock(
     )
     showanswer = String(
         display_name=_("Show Answer"),
-        help=_("Defines when to show the answer to the problem. "
-               "A default value can be set in Advanced Settings."),
+        help=_("Defines when to show the answer to the problem. A default value can be set in Advanced Settings."),
         scope=Scope.settings,
         default=SHOWANSWER.FINISHED,
         values=[
@@ -244,7 +247,7 @@ class _BuiltInProblemBlock(
             {"display_name": _("After All Attempts"), "value": SHOWANSWER.AFTER_ALL_ATTEMPTS},
             {"display_name": _("After All Attempts or Correct"), "value": SHOWANSWER.AFTER_ALL_ATTEMPTS_OR_CORRECT},
             {"display_name": _("Attempted"), "value": SHOWANSWER.ATTEMPTED_NO_PAST_DUE},
-        ]
+        ],
     )
     attempts_before_showanswer_button = Integer(
         display_name=_("Show Answer: Number of Attempts"),
@@ -256,22 +259,22 @@ class _BuiltInProblemBlock(
         scope=Scope.settings,
     )
     force_save_button = Boolean(
-        help=_("Whether to force the save button to appear on the page"),
-        scope=Scope.settings,
-        default=False
+        help=_("Whether to force the save button to appear on the page"), scope=Scope.settings, default=False
     )
     show_reset_button = Boolean(
         display_name=_("Show Reset Button"),
-        help=_("Determines whether a 'Reset' button is shown so the user may reset their answer. "
-               "A default value can be set in Advanced Settings."),
+        help=_(
+            "Determines whether a 'Reset' button is shown so the user may reset their answer. "
+            "A default value can be set in Advanced Settings."
+        ),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
     rerandomize = Randomization(
         display_name=_("Randomization"),
         help=_(
-            'Defines when to randomize the variables specified in the associated Python script. '
-            'For problems that do not randomize values, specify \"Never\". '
+            "Defines when to randomize the variables specified in the associated Python script. "
+            'For problems that do not randomize values, specify "Never". '
         ),
         default=RANDOMIZATION.NEVER,
         scope=Scope.settings,
@@ -279,20 +282,19 @@ class _BuiltInProblemBlock(
             {"display_name": _("Always"), "value": RANDOMIZATION.ALWAYS},
             {"display_name": _("On Reset"), "value": RANDOMIZATION.ONRESET},
             {"display_name": _("Never"), "value": RANDOMIZATION.NEVER},
-            {"display_name": _("Per Student"), "value": RANDOMIZATION.PER_STUDENT}
-        ]
+            {"display_name": _("Per Student"), "value": RANDOMIZATION.PER_STUDENT},
+        ],
     )
     data = XMLString(
         help=_("XML data for the problem"),
         scope=Scope.content,
-        enforce_type=FEATURES.get('ENABLE_XBLOCK_XML_VALIDATION', True),
-        default="<problem></problem>"
+        enforce_type=FEATURES.get("ENABLE_XBLOCK_XML_VALIDATION", True),
+        default="<problem></problem>",
     )
-    correct_map = Dict(help=_("Dictionary with the correctness of current student answers"),
-                       scope=Scope.user_state, default={})
-    correct_map_history = List(
-        help=_("List of correctness maps for each attempt"), scope=Scope.user_state, default=[]
+    correct_map = Dict(
+        help=_("Dictionary with the correctness of current student answers"), scope=Scope.user_state, default={}
     )
+    correct_map_history = List(help=_("List of correctness maps for each attempt"), scope=Scope.user_state, default=[])
     input_state = Dict(help=_("Dictionary for maintaining the state of inputtypes"), scope=Scope.user_state)
     student_answers = Dict(help=_("Dictionary with the current student responses"), scope=Scope.user_state)
     student_answers_history = List(
@@ -304,8 +306,9 @@ class _BuiltInProblemBlock(
     score_history = ListScoreField(
         help=_("List of scores for each attempt"), scope=Scope.user_state, default=[], enforce_type=False
     )
-    has_saved_answers = Boolean(help=_("Whether or not the answers have been saved since last submit"),
-                                scope=Scope.user_state, default=False)
+    has_saved_answers = Boolean(
+        help=_("Whether or not the answers have been saved since last submit"), scope=Scope.user_state, default=False
+    )
     done = Boolean(help=_("Whether the student has answered the problem"), scope=Scope.user_state, default=False)
     seed = Integer(help=_("Random seed for this student"), scope=Scope.user_state)
     last_submission_time = Date(help=_("Last submission time"), scope=Scope.user_state)
@@ -313,37 +316,37 @@ class _BuiltInProblemBlock(
         display_name=_("Timer Between Attempts"),
         help=_("Seconds a student must wait between submissions for a problem with multiple attempts."),
         scope=Scope.settings,
-        default=0)
+        default=0,
+    )
     weight = Float(
         display_name=_("Problem Weight"),
-        help=_("Defines the number of points each problem is worth. "
-               "If the value is not set, each response field in the problem is worth one point."),
-        values={"min": 0, "step": .1},
-        scope=Scope.settings
+        help=_(
+            "Defines the number of points each problem is worth. "
+            "If the value is not set, each response field in the problem is worth one point."
+        ),
+        values={"min": 0, "step": 0.1},
+        scope=Scope.settings,
     )
     markdown = String(help=_("Markdown source of this module"), default=None, scope=Scope.settings)
     source_code = String(
-        help=_("Source code for LaTeX and Word problems. This feature is not well-supported."),
-        scope=Scope.settings
-    )
-    use_latex_compiler = Boolean(
-        help=_("Enable LaTeX templates?"),
-        default=False,
-        scope=Scope.settings
+        help=_("Source code for LaTeX and Word problems. This feature is not well-supported."), scope=Scope.settings
     )
+    use_latex_compiler = Boolean(help=_("Enable LaTeX templates?"), default=False, scope=Scope.settings)
     matlab_api_key = String(
         display_name=_("Matlab API key"),
-        help=_("Enter the API key provided by MathWorks for accessing the MATLAB Hosted Service. "
-               "This key is granted for exclusive use by this course for the specified duration. "
-               "Please do not share the API key with other courses and notify MathWorks immediately "
-               "if you believe the key is exposed or compromised. To obtain a key for your course, "
-               "or to report an issue, please contact moocsupport@mathworks.com"),
-        scope=Scope.settings
+        help=_(
+            "Enter the API key provided by MathWorks for accessing the MATLAB Hosted Service. "
+            "This key is granted for exclusive use by this course for the specified duration. "
+            "Please do not share the API key with other courses and notify MathWorks immediately "
+            "if you believe the key is exposed or compromised. To obtain a key for your course, "
+            "or to report an issue, please contact moocsupport@mathworks.com"
+        ),
+        scope=Scope.settings,
     )
     markdown_edited = Boolean(
         help=_("Indicates if the problem was edited using the Markdown editor in the Authoring MFE."),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
 
     def bind_for_student(self, *args, **kwargs):  # lint-amnesty, pylint: disable=signature-differs
@@ -352,8 +355,8 @@ def bind_for_student(self, *args, **kwargs):  # lint-amnesty, pylint: disable=si
         # Capa was an XModule. When bind_for_student() was called on it with a new runtime, a new CapaModule object
         # was initialized when XModuleDescriptor._xmodule() was called next. self.lcp was constructed in CapaModule
         # init(). To keep the same behaviour, we delete self.lcp in bind_for_student().
-        if 'lcp' in self.__dict__:
-            del self.__dict__['lcp']
+        if "lcp" in self.__dict__:
+            del self.__dict__["lcp"]
 
     def student_view(self, _context, show_detailed_errors=False):
         """
@@ -368,8 +371,8 @@ def student_view(self, _context, show_detailed_errors=False):
             html = self.get_html()
         fragment = Fragment(html)
         add_css_to_fragment(fragment, "ProblemBlockDisplay.css")
-        add_webpack_js_to_fragment(fragment, 'ProblemBlockDisplay')
-        shim_xmodule_js(fragment, 'Problem')
+        add_webpack_js_to_fragment(fragment, "ProblemBlockDisplay")
+        shim_xmodule_js(fragment, "Problem")
         return fragment
 
     def public_view(self, context):
@@ -377,7 +380,7 @@ def public_view(self, context):
         Return the view seen by users who aren't logged in or who aren't
         enrolled in the course.
         """
-        if getattr(self.runtime, 'suppports_state_for_anonymous_users', False):
+        if getattr(self.runtime, "suppports_state_for_anonymous_users", False):
             # The new XBlock runtime can generally support capa problems for users who aren't logged in, so show the
             # normal student_view. To prevent anonymous users from viewing specific problems, adjust course policies
             # and/or content groups.
@@ -397,11 +400,11 @@ def studio_view(self, _context):
         Return the studio view.
         """
         fragment = Fragment(
-            self.runtime.service(self, 'mako').render_cms_template(self.mako_template, self.get_context())
+            self.runtime.service(self, "mako").render_cms_template(self.mako_template, self.get_context())
         )
-        add_css_to_fragment(fragment, 'ProblemBlockEditor.css')
-        add_webpack_js_to_fragment(fragment, 'ProblemBlockEditor')
-        shim_xmodule_js(fragment, 'MarkdownEditingDescriptor')
+        add_css_to_fragment(fragment, "ProblemBlockEditor.css")
+        add_webpack_js_to_fragment(fragment, "ProblemBlockEditor")
+        shim_xmodule_js(fragment, "MarkdownEditingDescriptor")
         return fragment
 
     def handle_ajax(self, dispatch, data):
@@ -418,15 +421,15 @@ def handle_ajax(self, dispatch, data):
         # self.score is initialized in self.lcp but in this method is accessed before self.lcp so just call it first.
         self.lcp  # lint-amnesty, pylint: disable=pointless-statement
         handlers = {
-            'hint_button': self.hint_button,
-            'problem_get': self.get_problem,
-            'problem_check': self.submit_problem,
-            'problem_reset': self.reset_problem,
-            'problem_save': self.save_problem,
-            'problem_show': self.get_answer,
-            'score_update': self.update_score,
-            'input_ajax': self.handle_input_ajax,
-            'ungraded_response': self.handle_ungraded_response
+            "hint_button": self.hint_button,
+            "problem_get": self.get_problem,
+            "problem_check": self.submit_problem,
+            "problem_reset": self.reset_problem,
+            "problem_save": self.save_problem,
+            "problem_show": self.get_answer,
+            "score_update": self.update_score,
+            "input_ajax": self.handle_input_ajax,
+            "ungraded_response": self.handle_ungraded_response,
         }
 
         _ = self.runtime.service(self, "i18n").gettext
@@ -437,12 +440,11 @@ def handle_ajax(self, dispatch, data):
         )
 
         not_found_error_message = _(
-            "The state of this problem has changed since you loaded this page. "
-            "Please refresh your page."
+            "The state of this problem has changed since you loaded this page. Please refresh your page."
         )
 
         if dispatch not in handlers:
-            return f'Error: {dispatch} is not a known capa action'
+            return f"Error: {dispatch} is not a known capa action"
 
         before = self.get_progress()
         before_attempts = self.attempts
@@ -455,7 +457,7 @@ def handle_ajax(self, dispatch, data):
                 "Unable to find data when dispatching %s to %s for user %s",
                 dispatch,
                 self.scope_ids.usage_id,
-                self.scope_ids.user_id
+                self.scope_ids.user_id,
             )
             _, _, traceback_obj = sys.exc_info()
             raise ProcessingError(not_found_error_message).with_traceback(traceback_obj) from ex
@@ -465,7 +467,7 @@ def handle_ajax(self, dispatch, data):
                 "Unknown error when dispatching %s to %s for user %s",
                 dispatch,
                 self.scope_ids.usage_id,
-                self.scope_ids.user_id
+                self.scope_ids.user_id,
             )
             _, _, traceback_obj = sys.exc_info()
             raise ProcessingError(generic_error_message).with_traceback(traceback_obj) from ex
@@ -475,12 +477,14 @@ def handle_ajax(self, dispatch, data):
         progress_changed = (after != before) or (after_attempts != before_attempts)
         curr_score, total_possible = self.get_display_progress()
 
-        result.update({
-            'progress_changed': progress_changed,
-            'current_score': curr_score,
-            'total_possible': total_possible,
-            'attempts_used': after_attempts,
-        })
+        result.update(
+            {
+                "progress_changed": progress_changed,
+                "current_score": curr_score,
+                "total_possible": total_possible,
+                "attempts_used": after_attempts,
+            }
+        )
 
         return json.dumps(result, cls=ComplexEncoder)
 
@@ -520,7 +524,7 @@ def is_grading_method_enabled(self) -> bool:
         feature is not enabled, the grading method field will not be shown in
         Studio settings and the default grading method will be used.
         """
-        return settings.FEATURES.get('ENABLE_GRADING_METHOD_IN_PROBLEMS', False)
+        return settings.FEATURES.get("ENABLE_GRADING_METHOD_IN_PROBLEMS", False)
 
     @property
     def debug(self):
@@ -529,7 +533,7 @@ def debug(self):
         the error in Studio. At the same time, in production, we don't want
         to show errors to students.
         """
-        return getattr(self.runtime, 'is_author_mode', False) or settings.DEBUG
+        return getattr(self.runtime, "is_author_mode", False) or settings.DEBUG
 
     @classmethod
     def filter_templates(cls, template, course):
@@ -539,15 +543,17 @@ def filter_templates(cls, template, course):
         Show them only if use_latex_compiler is set to True in
         course settings.
         """
-        return 'latex' not in template['template_id'] or course.use_latex_compiler
+        return "latex" not in template["template_id"] or course.use_latex_compiler
 
     def get_context(self):
         _context = EditingMixin.get_context(self)
-        _context.update({
-            'markdown': self.markdown,
-            'enable_markdown': self.markdown is not None,
-            'enable_latex_compiler': self.use_latex_compiler,
-        })
+        _context.update(
+            {
+                "markdown": self.markdown,
+                "enable_markdown": self.markdown is not None,
+                "enable_latex_compiler": self.use_latex_compiler,
+            }
+        )
         return _context
 
     # VS[compat]
@@ -556,37 +562,38 @@ def get_context(self):
     @classmethod
     def backcompat_paths(cls, path):
         return [
-            'problems/' + path[8:],
+            "problems/" + path[8:],
             path[8:],
         ]
 
     @property
     def non_editable_metadata_fields(self):
         non_editable_fields = super().non_editable_metadata_fields
-        non_editable_fields.extend([
-            ProblemBlock.due,
-            ProblemBlock.graceperiod,
-            ProblemBlock.force_save_button,
-            ProblemBlock.markdown,
-            ProblemBlock.use_latex_compiler,
-            ProblemBlock.show_correctness,
-
-            # Temporarily remove the ability to see MATLAB API key in Studio, as
-            # a pre-cursor to removing it altogether.
-            #   https://github.com/openedx/public-engineering/issues/192
-            ProblemBlock.matlab_api_key,
-        ])
+        non_editable_fields.extend(
+            [
+                ProblemBlock.due,
+                ProblemBlock.graceperiod,
+                ProblemBlock.force_save_button,
+                ProblemBlock.markdown,
+                ProblemBlock.use_latex_compiler,
+                ProblemBlock.show_correctness,
+                # Temporarily remove the ability to see MATLAB API key in Studio, as
+                # a pre-cursor to removing it altogether.
+                #   https://github.com/openedx/public-engineering/issues/192
+                ProblemBlock.matlab_api_key,
+            ]
+        )
         if not self.is_grading_method_enabled:
             non_editable_fields.append(ProblemBlock.grading_method)
         return non_editable_fields
 
     @property
     def problem_types(self):
-        """ Low-level problem type introspection for content libraries filtering by problem type """
+        """Low-level problem type introspection for content libraries filtering by problem type"""
         try:
             tree = etree.XML(self.data)
         except etree.XMLSyntaxError:
-            log.error(f'Error parsing problem types from xml for capa block {self.display_name}')
+            log.error(f"Error parsing problem types from xml for capa block {self.display_name}")
             return None  # short-term fix to prevent errors (TNL-5057). Will be more properly addressed in TNL-4525.
         registered_tags = responsetypes.registry.registered_tags()
         return {node.tag for node in tree.iter() if node.tag in registered_tags}
@@ -598,7 +605,7 @@ def index_dictionary(self):
         xblock_body = super().index_dictionary()
 
         # Make optioninput's options index friendly by replacing the actual tag with the values
-        capa_content = re.sub(r'<optioninput options="\(([^"]+)\)".*?>\s*|\S*<\/optioninput>', r'\1', self.data)
+        capa_content = re.sub(r'<optioninput options="\(([^"]+)\)".*?>\s*|\S*<\/optioninput>', r"\1", self.data)
 
         # Remove the following tags with content that can leak hints or solutions:
         # - `solution` (with optional attributes) and `solutionset`.
@@ -617,20 +624,16 @@ def index_dictionary(self):
                     <style.*?>.*?</style> |
                     <[a-z]*hint.*?>.*?</[a-z]*hint.*?>
                 """,
-                re.DOTALL |
-                re.VERBOSE),
+                re.DOTALL | re.VERBOSE,
+            ),
             "",
-            capa_content
+            capa_content,
         )
         # Strip out all other tags, leaving their content. But we want spaces between adjacent tags, so that
         # <choice correct="true"><div>Option A</div></choice><choice correct="false"><div>Option B</div></choice>
         # becomes "Option A Option B" not "Option AOption B" (these will appear in search results)
         capa_content = re.sub(r"</(\w+)><([^>]+)>", r"</\1> <\2>", capa_content)
-        capa_content = re.sub(
-            r"(\s|&nbsp;|//)+",
-            " ",
-            nh3.clean(capa_content, tags=set())
-        ).strip()
+        capa_content = re.sub(r"(\s|&nbsp;|//)+", " ", nh3.clean(capa_content, tags=set())).strip()
 
         capa_body = {
             "capa_content": capa_content,
@@ -653,8 +656,7 @@ def has_support(self, view, functionality):
         if functionality == "multi_device":
             types = self.problem_types  # Avoid calculating this property twice
             return types is not None and all(
-                responsetypes.registry.get_class_for_tag(tag).multi_device_support
-                for tag in types
+                responsetypes.registry.get_class_for_tag(tag).multi_device_support for tag in types
             )
         return False
 
@@ -712,7 +714,7 @@ def generate_report_data(self, user_state_iterator, limit_responses=None):
                            "Answer ID": "98e6a8e915904d5389821a94e48babcf_10_1"
             })
         """
-        if self.category != 'problem':
+        if self.category != "problem":
             raise NotImplementedError()
 
         if limit_responses == 0:
@@ -743,7 +745,7 @@ def generate_report_data(self, user_state_iterator, limit_responses=None):
         count = 0
         for user_state in user_state_iterator:
 
-            if 'student_answers' not in user_state.state:
+            if "student_answers" not in user_state.state:
                 continue
             try:
                 lcp = LoncapaProblem(
@@ -753,14 +755,14 @@ def generate_report_data(self, user_state_iterator, limit_responses=None):
                     # We choose to run without a fully initialized CapaModule
                     capa_block=None,
                     state={
-                        'done': user_state.state.get('done'),
-                        'correct_map': user_state.state.get('correct_map'),
-                        'student_answers': user_state.state.get('student_answers'),
-                        'has_saved_answers': user_state.state.get('has_saved_answers'),
-                        'input_state': user_state.state.get('input_state'),
-                        'seed': user_state.state.get('seed'),
+                        "done": user_state.state.get("done"),
+                        "correct_map": user_state.state.get("correct_map"),
+                        "student_answers": user_state.state.get("student_answers"),
+                        "has_saved_answers": user_state.state.get("has_saved_answers"),
+                        "input_state": user_state.state.get("input_state"),
+                        "seed": user_state.state.get("seed"),
                     },
-                    seed=user_state.state.get('seed'),
+                    seed=user_state.state.get("seed"),
                     # extract_tree=False allows us to work without a fully initialized CapaModule
                     # We'll still be able to find particular data in the XML when we need it
                     extract_tree=False,
@@ -770,7 +772,7 @@ def generate_report_data(self, user_state_iterator, limit_responses=None):
                     # Some types of problems have data in lcp.student_answers that isn't in lcp.problem_data.
                     # E.g. formulae do this to store the MathML version of the answer.
                     # We exclude these rows from the report because we only need the text-only answer.
-                    if answer_id.endswith('_dynamath'):
+                    if answer_id.endswith("_dynamath"):
                         continue
 
                     if limit_responses and count >= limit_responses:
@@ -794,8 +796,9 @@ def generate_report_data(self, user_state_iterator, limit_responses=None):
                 # Capture a backtrace for errors from failed loncapa problems
                 log.exception(
                     "An error occurred generating a problem report on course %s, problem %s, and student %s",
-                    self.course_id, self.scope_ids.usage_id,
-                    self.scope_ids.user_id
+                    self.course_id,
+                    self.scope_ids.usage_id,
+                    self.scope_ids.user_id,
                 )
                 # Also input error in report
                 report = {
@@ -812,8 +815,8 @@ def course_end_date(self):
         """
 
         try:
-            course_block_key = self.runtime.course_entry.structure['root']
-            return self.runtime.course_entry.structure['blocks'][course_block_key].fields['end']
+            course_block_key = self.runtime.course_entry.structure["root"]
+            return self.runtime.course_entry.structure["blocks"][course_block_key].fields["end"]
         except (AttributeError, KeyError):
             return None
 
@@ -843,8 +846,7 @@ def lcp(self):  # lint-amnesty, pylint: disable=method-hidden, missing-function-
         try:
             lcp = self.new_lcp(self.get_state_for_lcp())
         except Exception as err:  # pylint: disable=broad-except
-            msg = 'cannot create LoncapaProblem {loc}: {err}'.format(
-                loc=str(self.location), err=err)
+            msg = "cannot create LoncapaProblem {loc}: {err}".format(loc=str(self.location), err=err)
             raise LoncapaProblemError(msg).with_traceback(sys.exc_info()[2])
 
         if self.score is None:
@@ -860,11 +862,11 @@ def choose_new_seed(self):
         if self.rerandomize == RANDOMIZATION.NEVER:
             self.seed = 1
         elif self.rerandomize == RANDOMIZATION.PER_STUDENT:
-            user_id = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_ID) or 0
+            user_id = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_ID) or 0
             # see comment on randomization_bin
-            self.seed = randomization_bin(user_id, str(self.location).encode('utf-8'))
+            self.seed = randomization_bin(user_id, str(self.location).encode("utf-8"))
         else:
-            self.seed = struct.unpack('i', os.urandom(4))[0]
+            self.seed = struct.unpack("i", os.urandom(4))[0]
 
             # So that sandboxed code execution can be cached, but still have an interesting
             # number of possibilities, cap the number of different random seeds.
@@ -877,14 +879,14 @@ def new_lcp(self, state, text=None):
         if text is None:
             text = self.data
 
-        user_service = self.runtime.service(self, 'user')
+        user_service = self.runtime.service(self, "user")
         anonymous_student_id = user_service.get_current_user().opt_attrs.get(ATTR_KEY_DEPRECATED_ANONYMOUS_USER_ID)
         seed = user_service.get_current_user().opt_attrs.get(ATTR_KEY_USER_ID) or 0
 
-        sandbox_service = self.runtime.service(self, 'sandbox')
-        cache_service = self.runtime.service(self, 'cache')
+        sandbox_service = self.runtime.service(self, "sandbox")
+        cache_service = self.runtime.service(self, "cache")
 
-        is_studio = getattr(self.runtime, 'is_author_mode', False)
+        is_studio = getattr(self.runtime, "is_author_mode", False)
 
         capa_system = LoncapaSystem(
             ajax_url=self.ajax_url,
@@ -894,11 +896,11 @@ def new_lcp(self, state, text=None):
             get_python_lib_zip=sandbox_service.get_python_lib_zip,
             DEBUG=self.debug,
             i18n=self.runtime.service(self, "i18n"),
-            render_template=self.runtime.service(self, 'mako').render_template,
+            render_template=self.runtime.service(self, "mako").render_template,
             resources_fs=self.runtime.resources_fs,
             seed=seed,  # Why do we do this if we have self.seed?
             xqueue=None if is_studio else XQueueService(self),
-            matlab_api_key=self.matlab_api_key
+            matlab_api_key=self.matlab_api_key,
         )
 
         return LoncapaProblem(
@@ -915,13 +917,13 @@ def get_state_for_lcp(self):
         Give a dictionary holding the state of the module
         """
         return {
-            'done': self.done,
-            'correct_map': self.correct_map,
-            'correct_map_history': self.correct_map_history,
-            'student_answers': self.student_answers,
-            'has_saved_answers': self.has_saved_answers,
-            'input_state': self.input_state,
-            'seed': self.get_seed(),
+            "done": self.done,
+            "correct_map": self.correct_map,
+            "correct_map_history": self.correct_map_history,
+            "student_answers": self.student_answers,
+            "has_saved_answers": self.has_saved_answers,
+            "input_state": self.input_state,
+            "seed": self.get_seed(),
         }
 
     def set_state_from_lcp(self):
@@ -929,12 +931,12 @@ def set_state_from_lcp(self):
         Set the module's state from the settings in `self.lcp`
         """
         lcp_state = self.lcp.get_state()
-        self.done = lcp_state['done']
-        self.correct_map = lcp_state['correct_map']
-        self.correct_map_history = lcp_state['correct_map_history']
-        self.input_state = lcp_state['input_state']
-        self.student_answers = lcp_state['student_answers']
-        self.has_saved_answers = lcp_state['has_saved_answers']
+        self.done = lcp_state["done"]
+        self.correct_map = lcp_state["correct_map"]
+        self.correct_map_history = lcp_state["correct_map_history"]
+        self.input_state = lcp_state["input_state"]
+        self.student_answers = lcp_state["student_answers"]
+        self.has_saved_answers = lcp_state["has_saved_answers"]
 
     def set_last_submission_time(self):
         """
@@ -976,7 +978,7 @@ def get_display_progress(self):
         Return (score, total) to be displayed to the learner.
         """
         progress = self.get_progress()
-        score, total = (progress.frac() if progress else (0, 0))
+        score, total = progress.frac() if progress else (0, 0)
 
         # Withhold the score if hiding correctness
         if not self.correctness_available():
@@ -990,28 +992,30 @@ def get_html(self):
         """
         curr_score, total_possible = self.get_display_progress()
 
-        return self.runtime.service(self, 'mako').render_lms_template('problem_ajax.html', {
-            'element_id': self.location.html_id(),
-            'id': str(self.location),
-            'ajax_url': self.ajax_url,
-            'current_score': curr_score,
-            'total_possible': total_possible,
-            'attempts_used': self.attempts,
-            'content': self.get_problem_html(encapsulate=False),
-            'graded': self.graded,  # pylint: disable=no-member
-        })
+        return self.runtime.service(self, "mako").render_lms_template(
+            "problem_ajax.html",
+            {
+                "element_id": self.location.html_id(),
+                "id": str(self.location),
+                "ajax_url": self.ajax_url,
+                "current_score": curr_score,
+                "total_possible": total_possible,
+                "attempts_used": self.attempts,
+                "content": self.get_problem_html(encapsulate=False),
+                "graded": self.graded,  # pylint: disable=no-member
+            },
+        )
 
     def handle_fatal_lcp_error(self, error):  # lint-amnesty, pylint: disable=missing-function-docstring
         log.exception(f"LcpFatalError Encountered for {str(self.location)}")
         if error:
-            return(
-                HTML('<p>Error formatting HTML for problem:</p><p><pre style="color:red">{msg}</pre></p>').format(
-                    msg=str(error))
+            return HTML('<p>Error formatting HTML for problem:</p><p><pre style="color:red">{msg}</pre></p>').format(
+                msg=str(error)
             )
         else:
             return HTML(
-                '<p>Could not format HTML for problem. '
-                'Contact course staff in the discussion forum for assistance.</p>'
+                "<p>Could not format HTML for problem. "
+                "Contact course staff in the discussion forum for assistance.</p>"
             )
 
     def submit_button_name(self):
@@ -1021,7 +1025,7 @@ def submit_button_name(self):
         # The logic flow is a little odd so that _('xxx') strings can be found for
         # translation while also running _() just once for each string.
         _ = self.runtime.service(self, "i18n").gettext
-        submit = _('Submit')
+        submit = _("Submit")
 
         return submit
 
@@ -1034,13 +1038,13 @@ def submit_button_submitting_name(self):
         received by the server.
         """
         _ = self.runtime.service(self, "i18n").gettext
-        return _('Submitting')
+        return _("Submitting")
 
     def should_enable_submit_button(self):
         """
         Return True/False to indicate whether to enable the "Submit" button.
         """
-        submitted_without_reset = (self.is_submitted() and self.rerandomize == RANDOMIZATION.ALWAYS)
+        submitted_without_reset = self.is_submitted() and self.rerandomize == RANDOMIZATION.ALWAYS
 
         # If the problem is closed (past due / too many attempts)
         # then we disable the "submit" button
@@ -1055,7 +1059,7 @@ def should_show_reset_button(self):
         """
         Return True/False to indicate whether to show the "Reset" button.
         """
-        is_survey_question = (self.max_attempts == 0)
+        is_survey_question = self.max_attempts == 0
 
         # If the problem is closed (and not a survey question with max_attempts==0),
         # then do NOT show the reset button.
@@ -1083,7 +1087,7 @@ def should_show_save_button(self):
         if self.force_save_button:
             return not self.closed()
         else:
-            is_survey_question = (self.max_attempts == 0)
+            is_survey_question = self.max_attempts == 0
             needs_reset = self.is_submitted() and self.rerandomize == RANDOMIZATION.ALWAYS
 
             # If the student has unlimited attempts, and their answers
@@ -1121,22 +1125,14 @@ def handle_problem_html_error(self, err):
         """
         problem_display_name = self.display_name_with_default
         problem_location = str(self.location)
-        log.exception(
-            "ProblemGetHtmlError: %r, %r, %s",
-            problem_display_name,
-            problem_location,
-            str(err)
-        )
+        log.exception("ProblemGetHtmlError: %r, %r, %s", problem_display_name, problem_location, str(err))
 
         if self.debug:
-            msg = HTML(
-                '[courseware.capa.capa_block] '
-                'Failed to generate HTML for problem {url}'
-            ).format(
+            msg = HTML("[courseware.capa.capa_block] Failed to generate HTML for problem {url}").format(
                 url=str(self.location)
             )
-            msg += HTML('<p>Error:</p><p><pre>{msg}</pre></p>').format(msg=str(err))
-            msg += HTML('<p><pre>{tb}</pre></p>').format(tb=traceback.format_exc())
+            msg += HTML("<p>Error:</p><p><pre>{msg}</pre></p>").format(msg=str(err))
+            msg += HTML("<p><pre>{tb}</pre></p>").format(tb=traceback.format_exc())
             html = msg
 
         else:
@@ -1152,7 +1148,7 @@ def handle_problem_html_error(self, err):
             # Some inputtypes, such as dynamath, have additional "hidden" state that
             #   is not exposed to the student. Keep those hidden
             # TODO: Use regex, e.g. 'dynamath' is suffix at end of answer_id
-            hidden_state_keywords = ['dynamath']
+            hidden_state_keywords = ["dynamath"]
             for answer_id in answer_ids:
                 for hidden_state_keyword in hidden_state_keywords:
                     if answer_id.find(hidden_state_keyword) >= 0:
@@ -1169,14 +1165,14 @@ def handle_problem_html_error(self, err):
 
             # Translators: Following this message, there will be a bulleted list of items.
             warning_msg = _("The problem's state was corrupted by an invalid submission. The submission consisted of:")
-            warning += HTML('{}<ul>').format(warning_msg)
+            warning += HTML("{}<ul>").format(warning_msg)
 
             for student_answer in student_answers.values():
-                if student_answer != '':
-                    warning += HTML('<li>{}</li>').format(student_answer)
+                if student_answer != "":
+                    warning += HTML("<li>{}</li>").format(student_answer)
 
-            warning_msg = _('If this error persists, please contact the course staff.')
-            warning += HTML('</ul>{}</div>').format(warning_msg)
+            warning_msg = _("If this error persists, please contact the course staff.")
+            warning += HTML("</ul>{}</div>").format(warning_msg)
 
             html = warning
             try:
@@ -1187,7 +1183,7 @@ def handle_problem_html_error(self, err):
                     "ProblemGetHtmlError: Unable to generate html from LoncapaProblem: %r, %r, %s",
                     problem_display_name,
                     problem_location,
-                    str(error)
+                    str(error),
                 )
                 raise
 
@@ -1225,15 +1221,15 @@ def get_demand_hint(self, hint_index):
         _ = self.runtime.service(self, "i18n").gettext
 
         counter = 0
-        total_text = ''
+        total_text = ""
         while counter <= hint_index:
             # Translators: {previous_hints} is the HTML of hints that have already been generated, {hint_number_prefix}
             # is a header for this hint, and {hint_text} is the text of the hint itself.
             # This string is being passed to translation only for possible reordering of the placeholders.
-            total_text = HTML(_('{previous_hints}{list_start_tag}{strong_text}{hint_text}</li>')).format(
+            total_text = HTML(_("{previous_hints}{list_start_tag}{strong_text}{hint_text}</li>")).format(
                 previous_hints=HTML(total_text),
                 list_start_tag=HTML('<li class="hint-index-{counter}" tabindex="-1">').format(counter=counter),
-                strong_text=HTML('<strong>{hint_number_prefix}</strong>').format(
+                strong_text=HTML("<strong>{hint_number_prefix}</strong>").format(
                     # Translators: e.g. "Hint 1 of 3: " meaning we are showing the first of three hints.
                     # This text is shown in bold before the accompanying hint text.
                     hint_number_prefix=Text(_("Hint ({hint_num} of {hints_count}): ")).format(
@@ -1241,31 +1237,33 @@ def get_demand_hint(self, hint_index):
                     )
                 ),
                 # Course-authored HTML demand hints are supported.
-                hint_text=HTML(self.runtime.service(self, "replace_urls").replace_urls(
-                    get_inner_html_from_xpath(demand_hints[counter])
-                ))
+                hint_text=HTML(
+                    self.runtime.service(self, "replace_urls").replace_urls(
+                        get_inner_html_from_xpath(demand_hints[counter])
+                    )
+                ),
             )
             counter += 1
 
-        total_text = HTML('<ol>{hints}</ol>').format(hints=total_text)
+        total_text = HTML("<ol>{hints}</ol>").format(hints=total_text)
 
         # Log this demand-hint request. Note that this only logs the last hint requested (although now
         # all previously shown hints are still displayed).
         event_info = {}
-        event_info['module_id'] = str(self.location)
-        event_info['hint_index'] = hint_index
-        event_info['hint_len'] = len(demand_hints)
-        event_info['hint_text'] = get_inner_html_from_xpath(demand_hints[hint_index])
-        self.runtime.publish(self, 'edx.problem.hint.demandhint_displayed', event_info)
+        event_info["module_id"] = str(self.location)
+        event_info["hint_index"] = hint_index
+        event_info["hint_len"] = len(demand_hints)
+        event_info["hint_text"] = get_inner_html_from_xpath(demand_hints[hint_index])
+        self.runtime.publish(self, "edx.problem.hint.demandhint_displayed", event_info)
 
         _, should_enable_next_hint = self._should_enable_demand_hint(demand_hints=demand_hints, hint_index=hint_index)
 
         # We report the index of this hint, the client works out what index to use to get the next hint
         return {
-            'success': True,
-            'hint_index': hint_index,
-            'should_enable_next_hint': should_enable_next_hint,
-            'msg': total_text,
+            "success": True,
+            "hint_index": hint_index,
+            "should_enable_next_hint": should_enable_next_hint,
+            "msg": total_text,
         }
 
     def get_problem_html(self, encapsulate=True, submit_notification=False):
@@ -1297,12 +1295,12 @@ def get_problem_html(self, encapsulate=True, submit_notification=False):
         if not should_enable_submit_button:
             cta_service = self.runtime.service(self, "call_to_action")
             if cta_service:
-                submit_disabled_ctas = cta_service.get_ctas(self, 'capa_submit_disabled')
+                submit_disabled_ctas = cta_service.get_ctas(self, "capa_submit_disabled")
 
         content = {
-            'name': self.display_name_with_default,
-            'html': smart_str(html),
-            'weight': self.weight,
+            "name": self.display_name_with_default,
+            "html": smart_str(html),
+            "weight": self.weight,
         }
 
         # If demand hints are available, emit hint button and div.
@@ -1310,37 +1308,38 @@ def get_problem_html(self, encapsulate=True, submit_notification=False):
         demand_hint_possible, should_enable_next_hint = self._should_enable_demand_hint(demand_hints=demand_hints)
 
         answer_notification_type, answer_notification_message = self._get_answer_notification(
-            render_notifications=submit_notification)
+            render_notifications=submit_notification
+        )
 
         save_message = None
         if self.has_saved_answers:
-            save_message = _(
-                "Your answers were previously saved. Click '{button_name}' to grade them."
-            ).format(button_name=self.submit_button_name())
+            save_message = _("Your answers were previously saved. Click '{button_name}' to grade them.").format(
+                button_name=self.submit_button_name()
+            )
 
         context = {
-            'problem': content,
-            'id': str(self.location),
-            'short_id': self.location.html_id(),
-            'submit_button': submit_button,
-            'submit_button_submitting': submit_button_submitting,
-            'should_enable_submit_button': should_enable_submit_button,
-            'reset_button': self.should_show_reset_button(),
-            'save_button': self.should_show_save_button(),
-            'answer_available': self.answer_available(),
-            'grading_method': self.grading_method_display_name(),
-            'attempts_used': self.attempts,
-            'attempts_allowed': self.max_attempts,
-            'demand_hint_possible': demand_hint_possible,
-            'should_enable_next_hint': should_enable_next_hint,
-            'answer_notification_type': answer_notification_type,
-            'answer_notification_message': answer_notification_message,
-            'has_saved_answers': self.has_saved_answers,
-            'save_message': save_message,
-            'submit_disabled_cta': submit_disabled_ctas[0] if submit_disabled_ctas else None,
+            "problem": content,
+            "id": str(self.location),
+            "short_id": self.location.html_id(),
+            "submit_button": submit_button,
+            "submit_button_submitting": submit_button_submitting,
+            "should_enable_submit_button": should_enable_submit_button,
+            "reset_button": self.should_show_reset_button(),
+            "save_button": self.should_show_save_button(),
+            "answer_available": self.answer_available(),
+            "grading_method": self.grading_method_display_name(),
+            "attempts_used": self.attempts,
+            "attempts_allowed": self.max_attempts,
+            "demand_hint_possible": demand_hint_possible,
+            "should_enable_next_hint": should_enable_next_hint,
+            "answer_notification_type": answer_notification_type,
+            "answer_notification_message": answer_notification_message,
+            "has_saved_answers": self.has_saved_answers,
+            "save_message": save_message,
+            "submit_disabled_cta": submit_disabled_ctas[0] if submit_disabled_ctas else None,
         }
 
-        html = self.runtime.service(self, 'mako').render_lms_template('problem.html', context)
+        html = self.runtime.service(self, "mako").render_lms_template("problem.html", context)
 
         if encapsulate:
             html = HTML('<div id="problem_{id}" class="problem" data-url="{ajax_url}">{html}</div>').format(
@@ -1369,7 +1368,7 @@ def _get_answer_notification(self, render_notifications):
 
             # Show only a generic message if hiding correctness
             if not self.correctness_available():
-                answer_notification_type = 'submitted'
+                answer_notification_type = "submitted"
             elif len(id_list) == 1:
                 # Only one answer available
                 answer_notification_type = self.lcp.correct_map.get_correctness(id_list[0])
@@ -1381,40 +1380,36 @@ def _get_answer_notification(self, render_notifications):
                         # There is at least 1 of the following combinations of correctness states
                         # Correct and incorrect, Correct and partially correct, or Incorrect and partially correct
                         # which all should have a message type of Partially Correct
-                        answer_notification_type = 'partially-correct'
+                        answer_notification_type = "partially-correct"
                         break
 
             # Build the notification message based on the notification type and translate it.
             ngettext = self.runtime.service(self, "i18n").ngettext
             _ = self.runtime.service(self, "i18n").gettext
-            if answer_notification_type == 'incorrect':
+            if answer_notification_type == "incorrect":
                 if progress is not None:
                     answer_notification_message = ngettext(
-                        "Incorrect ({progress} point)",
-                        "Incorrect ({progress} points)",
-                        progress.frac()[1]
+                        "Incorrect ({progress} point)", "Incorrect ({progress} points)", progress.frac()[1]
                     ).format(progress=str(progress))
                 else:
-                    answer_notification_message = _('Incorrect')
-            elif answer_notification_type == 'correct':
+                    answer_notification_message = _("Incorrect")
+            elif answer_notification_type == "correct":
                 if progress is not None:
                     answer_notification_message = ngettext(
-                        "Correct ({progress} point)",
-                        "Correct ({progress} points)",
-                        progress.frac()[1]
+                        "Correct ({progress} point)", "Correct ({progress} points)", progress.frac()[1]
                     ).format(progress=str(progress))
                 else:
-                    answer_notification_message = _('Correct')
-            elif answer_notification_type == 'partially-correct':
+                    answer_notification_message = _("Correct")
+            elif answer_notification_type == "partially-correct":
                 if progress is not None:
                     answer_notification_message = ngettext(
                         "Partially correct ({progress} point)",
                         "Partially correct ({progress} points)",
-                        progress.frac()[1]
+                        progress.frac()[1],
                     ).format(progress=str(progress))
                 else:
-                    answer_notification_message = _('Partially Correct')
-            elif answer_notification_type == 'submitted':
+                    answer_notification_message = _("Partially Correct")
+            elif answer_notification_type == "submitted":
                 answer_notification_message = _("Answer submitted.")
 
         return answer_notification_type, answer_notification_message
@@ -1424,11 +1419,24 @@ def remove_tags_from_html(self, html):
         The capa xml includes many tags such as <additional_answer> or <demandhint> which are not
         meant to be part of the client html. We strip them all and return the resulting html.
         """
-        tags = ['demandhint', 'choicehint', 'optionhint', 'stringhint', 'numerichint', 'optionhint',
-                'correcthint', 'regexphint', 'additional_answer', 'stringequalhint', 'compoundhint',
-                'stringequalhint']
+        tags = [
+            "demandhint",
+            "choicehint",
+            "optionhint",
+            "stringhint",
+            "numerichint",
+            "optionhint",
+            "correcthint",
+            "regexphint",
+            "additional_answer",
+            "stringequalhint",
+            "compoundhint",
+            "stringequalhint",
+        ]
         for tag in tags:
-            html = re.sub(fr'<{tag}.*?>.*?</{tag}>', '', html, flags=re.DOTALL)  # xss-lint: disable=python-interpolate-html  # lint-amnesty, pylint: disable=line-too-long
+            html = re.sub(
+                rf"<{tag}.*?>.*?</{tag}>", "", html, flags=re.DOTALL
+            )  # xss-lint: disable=python-interpolate-html  # lint-amnesty, pylint: disable=line-too-long
             # Some of these tags span multiple lines
         # Note: could probably speed this up by calling sub() once with a big regex
         # vs. simply calling sub() many times as we have here.
@@ -1438,19 +1446,18 @@ def hint_button(self, data):
         """
         Hint button handler, returns new html using hint_index from the client.
         """
-        hint_index = int(data['hint_index'])
+        hint_index = int(data["hint_index"])
         return self.get_demand_hint(hint_index)
 
     def used_all_attempts(self):
-        """ All attempts have been used """
+        """All attempts have been used"""
         return self.max_attempts is not None and self.attempts >= self.max_attempts
 
     def is_past_due(self):
         """
         Is it now past this problem's due date, including grace period?
         """
-        return (self.close_date is not None and
-                datetime.datetime.now(utc) > self.close_date)
+        return self.close_date is not None and datetime.datetime.now(utc) > self.close_date
 
     def closed(self):
         """
@@ -1494,11 +1501,11 @@ def answer_available(self):
         """
         Is the user allowed to see an answer?
         """
-        user_is_staff = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
+        user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
         if not self.correctness_available():
             # If correctness is being withheld, then don't show answers either.
             return False
-        elif self.showanswer == '':
+        elif self.showanswer == "":
             return False
         elif self.showanswer == SHOWANSWER.NEVER:
             return False
@@ -1542,7 +1549,7 @@ def correctness_available(self):
 
         Limits access to the correct/incorrect flags, messages, and problem score.
         """
-        user_is_staff = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
+        user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
         return ShowCorrectness.correctness_available(
             show_correctness=self.show_correctness,
             due_date=self.close_date,
@@ -1559,8 +1566,8 @@ def update_score(self, data):
 
         No ajax return is needed. Return empty dict.
         """
-        queuekey = data['queuekey']
-        score_msg = data['xqueue_body']
+        queuekey = data["queuekey"]
+        score_msg = data["xqueue_body"]
         self.lcp.update_score(score_msg, queuekey)
         self.set_state_from_lcp()
         self.set_score(self.score_from_lcp(self.lcp))
@@ -1583,8 +1590,8 @@ def handle_ungraded_response(self, data):
 
         No ajax return is needed, so an empty dict is returned
         """
-        queuekey = data['queuekey']
-        score_msg = data['xqueue_body']
+        queuekey = data["queuekey"]
+        score_msg = data["xqueue_body"]
 
         # pass along the xqueue message to the problem
         self.lcp.ungraded_response(score_msg, queuekey)
@@ -1618,10 +1625,10 @@ def get_answer(self, _data):
             (and also screen reader text).
         """
         event_info = {}
-        event_info['problem_id'] = str(self.location)
-        self.publish_unmasked('showanswer', event_info)
+        event_info["problem_id"] = str(self.location)
+        self.publish_unmasked("showanswer", event_info)
         if not self.answer_available():  # lint-amnesty, pylint: disable=no-else-raise
-            raise NotFoundError('Answer is not available')
+            raise NotFoundError("Answer is not available")
         else:
             answers = self.lcp.get_question_answers()
             self.set_state_from_lcp()
@@ -1634,17 +1641,15 @@ def get_answer(self, _data):
                 answer_content = self.runtime.service(self, "replace_urls").replace_urls(answers[answer_id])
                 new_answer = {answer_id: answer_content}
             except TypeError:
-                log.debug('Unable to perform URL substitution on answers[%s]: %s',
-                          answer_id, answers[answer_id])
+                log.debug("Unable to perform URL substitution on answers[%s]: %s", answer_id, answers[answer_id])
                 new_answer = {answer_id: answers[answer_id]}
             new_answers.update(new_answer)
 
         return {
-            'answers': new_answers,
-            'correct_status_html': self.runtime.service(self, 'mako').render_lms_template(
-                'status_span.html',
-                {'status': Status('correct', self.runtime.service(self, "i18n").gettext)}
-            )
+            "answers": new_answers,
+            "correct_status_html": self.runtime.service(self, "mako").render_lms_template(
+                "status_span.html", {"status": Status("correct", self.runtime.service(self, "i18n").gettext)}
+            ),
         }
 
     # Figure out if we should move these to capa_problem?
@@ -1656,7 +1661,7 @@ def get_problem(self, _data):
         Used if we want to reconfirm we have the right thing e.g. after
         several AJAX calls.
         """
-        return {'html': self.get_problem_html(encapsulate=False, submit_notification=True)}
+        return {"html": self.get_problem_html(encapsulate=False, submit_notification=True)}
 
     @staticmethod
     def make_dict_of_responses(data):
@@ -1700,7 +1705,7 @@ def make_dict_of_responses(data):
         # We only want to consider each key a single time, so we use set(data.keys())
         for key in set(data.keys()):
             # e.g. input_resistor_1 ==> resistor_1
-            _, _, name = key.partition('_')
+            _, _, name = key.partition("_")
 
             # If key has no underscores, then partition
             # will return (key, '', '')
@@ -1715,8 +1720,8 @@ def make_dict_of_responses(data):
                 # answer will be an array.
                 # if the name ends with '{}' (Which looks like a dict),
                 # then the answer will be a dict
-                is_list_key = name.endswith('[]')
-                is_dict_key = name.endswith('{}')
+                is_list_key = name.endswith("[]")
+                is_dict_key = name.endswith("{}")
                 name = name[:-2] if is_list_key or is_dict_key else name
 
                 if is_list_key:
@@ -1725,7 +1730,7 @@ def make_dict_of_responses(data):
                     try:
                         val = json.loads(data[key])
                     # If the submission wasn't deserializable, raise an error.
-                    except(KeyError, ValueError):
+                    except (KeyError, ValueError):
                         raise ValueError(  # lint-amnesty, pylint: disable=raise-missing-from
                             f"Invalid submission: {data[key]} for {key}"
                         )
@@ -1748,16 +1753,16 @@ def publish_grade(self, score=None, only_if_higher=None, **kwargs):
         if not score:
             score = self.score
         event = {
-            'value': score.raw_earned,
-            'max_value': score.raw_possible,
-            'only_if_higher': only_if_higher,
+            "value": score.raw_earned,
+            "max_value": score.raw_possible,
+            "only_if_higher": only_if_higher,
         }
-        if kwargs.get('grader_response'):
-            event['grader_response'] = kwargs['grader_response']
+        if kwargs.get("grader_response"):
+            event["grader_response"] = kwargs["grader_response"]
 
-        self.runtime.publish(self, 'grade', event)
+        self.runtime.publish(self, "grade", event)
 
-        return {'grade': self.score.raw_earned, 'max_grade': self.score.raw_possible}
+        return {"grade": self.score.raw_earned, "max_grade": self.score.raw_possible}
 
     # pylint: disable=too-many-statements
     def submit_problem(self, data, override_time=False):
@@ -1769,16 +1774,16 @@ def submit_problem(self, data, override_time=False):
            'contents' : html}
         """
         event_info = {}
-        event_info['state'] = self.lcp.get_state()
-        event_info['problem_id'] = str(self.location)
+        event_info["state"] = self.lcp.get_state()
+        event_info["problem_id"] = str(self.location)
 
         self.lcp.has_saved_answers = False
         answers = self.make_dict_of_responses(data)
         answers_without_files = convert_files_to_filenames(answers)
         self.student_answers_history.append(answers_without_files)
-        event_info['answers'] = answers_without_files
+        event_info["answers"] = answers_without_files
 
-        metric_name = 'xmodule.capa.check_problem.{}'.format  # lint-amnesty, pylint: disable=unused-variable
+        metric_name = "xmodule.capa.check_problem.{}".format  # lint-amnesty, pylint: disable=unused-variable
         # Can override current time
         current_time = datetime.datetime.now(utc)
         if override_time is not False:
@@ -1789,7 +1794,7 @@ def submit_problem(self, data, override_time=False):
         # Too late. Cannot submit
         if self.closed():
             log.error(
-                'ProblemClosedError: Problem %s, close date: %s, due:%s, is_past_due: %s, attempts: %s/%s,',
+                "ProblemClosedError: Problem %s, close date: %s, due:%s, is_past_due: %s, attempts: %s/%s,",
                 str(self.location),
                 self.close_date,
                 self.due,
@@ -1797,14 +1802,14 @@ def submit_problem(self, data, override_time=False):
                 self.attempts,
                 self.max_attempts,
             )
-            event_info['failure'] = 'closed'
-            self.publish_unmasked('problem_check_fail', event_info)
+            event_info["failure"] = "closed"
+            self.publish_unmasked("problem_check_fail", event_info)
             raise NotFoundError(_("Problem is closed."))
 
         # Problem submitted. Student should reset before checking again
         if self.done and self.rerandomize == RANDOMIZATION.ALWAYS:
-            event_info['failure'] = 'unreset'
-            self.publish_unmasked('problem_check_fail', event_info)
+            event_info["failure"] = "unreset"
+            self.publish_unmasked("problem_check_fail", event_info)
             raise NotFoundError(_("Problem must be reset before it can be submitted again."))
 
         # Problem queued. Students must wait a specified waittime before they are allowed to submit
@@ -1816,26 +1821,25 @@ def submit_problem(self, data, override_time=False):
             waittime_between_requests = xqueue_service.waittime if xqueue_service else 0
             if (current_time - prev_submit_time).total_seconds() < waittime_between_requests:
                 msg = _("You must wait at least {wait} seconds between submissions.").format(
-                    wait=waittime_between_requests)
-                return {'success': msg, 'html': ''}
+                    wait=waittime_between_requests
+                )
+                return {"success": msg, "html": ""}
 
         # Wait time between resets: check if is too soon for submission.
         if self.last_submission_time is not None and self.submission_wait_seconds not in [0, None]:
             seconds_since_submission = (current_time - self.last_submission_time).total_seconds()
             if seconds_since_submission < self.submission_wait_seconds:
                 remaining_secs = int(self.submission_wait_seconds - seconds_since_submission)
-                msg = _('You must wait at least {wait_secs} between submissions. {remaining_secs} remaining.').format(
+                msg = _("You must wait at least {wait_secs} between submissions. {remaining_secs} remaining.").format(
                     wait_secs=self.pretty_print_seconds(self.submission_wait_seconds),
-                    remaining_secs=self.pretty_print_seconds(remaining_secs))
-                return {
-                    'success': msg,
-                    'html': ''
-                }
+                    remaining_secs=self.pretty_print_seconds(remaining_secs),
+                )
+                return {"success": msg, "html": ""}
 
         try:
             # expose the attempt number to a potential python custom grader
             # self.lcp.context['attempt'] refers to the attempt number (1-based)
-            self.lcp.context['attempt'] = self.attempts + 1
+            self.lcp.context["attempt"] = self.attempts + 1
             correct_map = self.lcp.grade_answers(answers)
             # self.attempts refers to the number of attempts that did not
             # raise an error (0-based)
@@ -1852,10 +1856,7 @@ def submit_problem(self, data, override_time=False):
 
         except (StudentInputError, ResponseError, LoncapaProblemError) as inst:
             if self.debug:
-                log.warning(
-                    "StudentInputError in capa_block:problem_check",
-                    exc_info=True
-                )
+                log.warning("StudentInputError in capa_block:problem_check", exc_info=True)
 
             # Save the user's state before failing
             self.set_state_from_lcp()
@@ -1864,7 +1865,7 @@ def submit_problem(self, data, override_time=False):
             # If the user is a staff member, include
             # the full exception, including traceback,
             # in the response
-            user_is_staff = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
+            user_is_staff = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
             if user_is_staff:
                 msg = f"Staff debug info: {traceback.format_exc()}"
 
@@ -1878,7 +1879,7 @@ def submit_problem(self, data, override_time=False):
                 except IndexError:
                     msg = full_error
 
-            return {'success': msg}
+            return {"success": msg}
 
         except Exception as err:
             # Save the user's state before failing
@@ -1887,38 +1888,36 @@ def submit_problem(self, data, override_time=False):
 
             if self.debug:
                 msg = f"Error checking problem: {str(err)}"
-                msg += f'\nTraceback:\n{traceback.format_exc()}'
-                return {'success': msg}
+                msg += f"\nTraceback:\n{traceback.format_exc()}"
+                return {"success": msg}
             raise
         published_grade = self.publish_grade()
 
         # success = correct if ALL questions in this problem are correct
-        success = 'correct'
+        success = "correct"
         for answer_id in correct_map:
             if not correct_map.is_correct(answer_id):
-                success = 'incorrect'
+                success = "incorrect"
 
         # NOTE: We are logging both full grading and queued-grading submissions. In the latter,
         #       'success' will always be incorrect
-        event_info['grade'] = published_grade['grade']
-        event_info['max_grade'] = published_grade['max_grade']
-        event_info['correct_map'] = correct_map.get_dict()
-        event_info['success'] = success
-        event_info['attempts'] = self.attempts
-        event_info['submission'] = self.get_submission_metadata_safe(answers_without_files, correct_map)
-        self.publish_unmasked('problem_check', event_info)
+        event_info["grade"] = published_grade["grade"]
+        event_info["max_grade"] = published_grade["max_grade"]
+        event_info["correct_map"] = correct_map.get_dict()
+        event_info["success"] = success
+        event_info["attempts"] = self.attempts
+        event_info["submission"] = self.get_submission_metadata_safe(answers_without_files, correct_map)
+        self.publish_unmasked("problem_check", event_info)
 
         # render problem into HTML
         html = self.get_problem_html(encapsulate=False, submit_notification=True)
 
         # Withhold success indicator if hiding correctness
         if not self.correctness_available():
-            success = 'submitted'
+            success = "submitted"
+
+        return {"success": success, "contents": html}
 
-        return {
-            'success': success,
-            'contents': html
-        }
     # pylint: enable=too-many-statements
 
     def get_score_with_grading_method(self, current_score: Score) -> Score:
@@ -1968,32 +1967,32 @@ def unmask_event(self, event_info):
                 # but check for the existence of the things we need to un-mask.
 
                 # Look for answers/id
-                answer = event_info.get('answers', {}).get(response.answer_id)
+                answer = event_info.get("answers", {}).get(response.answer_id)
                 if answer is not None:
-                    event_info['answers'][response.answer_id] = response.unmask_name(answer)
+                    event_info["answers"][response.answer_id] = response.unmask_name(answer)
 
                 # Look for state/student_answers/id
-                answer = event_info.get('state', {}).get('student_answers', {}).get(response.answer_id)
+                answer = event_info.get("state", {}).get("student_answers", {}).get(response.answer_id)
                 if answer is not None:
-                    event_info['state']['student_answers'][response.answer_id] = response.unmask_name(answer)
+                    event_info["state"]["student_answers"][response.answer_id] = response.unmask_name(answer)
 
                 # Look for old_state/student_answers/id  -- parallel to the above case, happens on reset
-                answer = event_info.get('old_state', {}).get('student_answers', {}).get(response.answer_id)
+                answer = event_info.get("old_state", {}).get("student_answers", {}).get(response.answer_id)
                 if answer is not None:
-                    event_info['old_state']['student_answers'][response.answer_id] = response.unmask_name(answer)
+                    event_info["old_state"]["student_answers"][response.answer_id] = response.unmask_name(answer)
 
             # Add 'permutation' to event_info for permuted responses.
             permutation_option = None
             if response.has_shuffle():
-                permutation_option = 'shuffle'
+                permutation_option = "shuffle"
             elif response.has_answerpool():
-                permutation_option = 'answerpool'
+                permutation_option = "answerpool"
 
             if permutation_option is not None:
                 # Add permutation record tuple: (one of:'shuffle'/'answerpool', [as-displayed list])
-                if 'permutation' not in event_info:
-                    event_info['permutation'] = {}
-                event_info['permutation'][response.answer_id] = (permutation_option, response.unmask_order())
+                if "permutation" not in event_info:
+                    event_info["permutation"] = {}
+                event_info["permutation"][response.answer_id] = (permutation_option, response.unmask_order())
 
     def pretty_print_seconds(self, num_seconds):
         """
@@ -2032,7 +2031,7 @@ def get_submission_metadata_safe(self, answers, correct_map):
             # NOTE: The above process requires deep inspection of capa structures that may break for some
             # uncommon problem types.  Ensure that it does not prevent answer submission in those
             # cases.  Any occurrences of errors in this block should be investigated and resolved.
-            log.exception('Unable to gather submission metadata, it will not be included in the event.')
+            log.exception("Unable to gather submission metadata, it will not be included in the event.")
 
         return {}
 
@@ -2065,7 +2064,7 @@ def get_submission_metadata(self, answers, correct_map):
             answer_input = self.lcp.inputs.get(input_id)
 
             if answer_input is None:
-                log.warning('Input id %s is not mapped to an input type.', input_id)
+                log.warning("Input id %s is not mapped to an input type.", input_id)
 
             answer_response = None
             for responder in self.lcp.responders.values():
@@ -2073,10 +2072,10 @@ def get_submission_metadata(self, answers, correct_map):
                     answer_response = responder
 
             if answer_response is None:
-                log.warning('Answer responder could not be found for input_id %s.', input_id)
+                log.warning("Answer responder could not be found for input_id %s.", input_id)
 
             user_visible_answer = internal_answer
-            if hasattr(answer_input, 'get_user_visible_answer'):
+            if hasattr(answer_input, "get_user_visible_answer"):
                 user_visible_answer = answer_input.get_user_visible_answer(internal_answer)
 
             # If this problem has rerandomize enabled, then it will generate N variants of the
@@ -2084,23 +2083,23 @@ def get_submission_metadata(self, answers, correct_map):
             # variant was selected.  Ideally it would be nice to have the exact question that
             # was presented to the user, with values interpolated etc, but that can be done
             # later if necessary.
-            variant = ''
+            variant = ""
             if self.rerandomize != RANDOMIZATION.NEVER:
                 variant = self.get_seed()
 
             is_correct = correct_map.is_correct(input_id)
             if is_correct is None:
-                is_correct = ''
+                is_correct = ""
 
-            response_data = getattr(answer_input, 'response_data', {})
+            response_data = getattr(answer_input, "response_data", {})
             input_metadata[input_id] = {
-                'question': response_data.get('label', ''),
-                'answer': user_visible_answer,
-                'response_type': getattr(getattr(answer_response, 'xml', None), 'tag', ''),
-                'input_type': getattr(answer_input, 'tag', ''),
-                'correct': is_correct,
-                'variant': variant,
-                'group_label': response_data.get('group_label', ''),
+                "question": response_data.get("label", ""),
+                "answer": user_visible_answer,
+                "response_type": getattr(getattr(answer_response, "xml", None), "tag", ""),
+                "input_type": getattr(answer_input, "tag", ""),
+                "correct": is_correct,
+                "variant": variant,
+                "group_label": response_data.get("group_label", ""),
             }
 
         return input_metadata
@@ -2112,34 +2111,31 @@ def save_problem(self, data):
         The message is informative on success, and an error message on failure.
         """
         event_info = {}
-        event_info['state'] = self.lcp.get_state()
-        event_info['problem_id'] = str(self.location)
+        event_info["state"] = self.lcp.get_state()
+        event_info["problem_id"] = str(self.location)
 
         answers = self.make_dict_of_responses(data)
-        event_info['answers'] = answers
+        event_info["answers"] = answers
         _ = self.runtime.service(self, "i18n").gettext
 
         # Too late. Cannot submit
         if self.closed() and not self.max_attempts == 0:
-            event_info['failure'] = 'closed'
-            self.publish_unmasked('save_problem_fail', event_info)
+            event_info["failure"] = "closed"
+            self.publish_unmasked("save_problem_fail", event_info)
             return {
-                'success': False,
+                "success": False,
                 # pylint: disable=line-too-long
                 # Translators: 'closed' means the problem's due date has passed. You may no longer attempt to solve the problem.
-                'msg': _("Problem is closed."),
+                "msg": _("Problem is closed."),
                 # pylint: enable=line-too-long
             }
 
         # Problem submitted. Student should reset before saving
         # again.
         if self.done and self.rerandomize == RANDOMIZATION.ALWAYS:
-            event_info['failure'] = 'done'
-            self.publish_unmasked('save_problem_fail', event_info)
-            return {
-                'success': False,
-                'msg': _("Problem needs to be reset prior to save.")
-            }
+            event_info["failure"] = "done"
+            self.publish_unmasked("save_problem_fail", event_info)
+            return {"success": False, "msg": _("Problem needs to be reset prior to save.")}
 
         self.lcp.student_answers = answers
         self.lcp.has_saved_answers = True
@@ -2147,17 +2143,13 @@ def save_problem(self, data):
         self.set_state_from_lcp()
         self.set_score(self.score_from_lcp(self.lcp))
 
-        self.publish_unmasked('save_problem_success', event_info)
+        self.publish_unmasked("save_problem_success", event_info)
         msg = _("Your answers have been saved.")
         if not self.max_attempts == 0:
-            msg = _(
-                "Your answers have been saved but not graded. Click '{button_name}' to grade them."
-            ).format(button_name=self.submit_button_name())
-        return {
-            'success': True,
-            'msg': msg,
-            'html': self.get_problem_html(encapsulate=False)
-        }
+            msg = _("Your answers have been saved but not graded. Click '{button_name}' to grade them.").format(
+                button_name=self.submit_button_name()
+            )
+        return {"success": True, "msg": msg, "html": self.get_problem_html(encapsulate=False)}
 
     def reset_problem(self, _data):
         """
@@ -2172,27 +2164,27 @@ def reset_problem(self, _data):
         `error` key containing an error message.
         """
         event_info = {}
-        event_info['old_state'] = self.lcp.get_state()
-        event_info['problem_id'] = str(self.location)
+        event_info["old_state"] = self.lcp.get_state()
+        event_info["problem_id"] = str(self.location)
         _ = self.runtime.service(self, "i18n").gettext
 
         if self.closed():
-            event_info['failure'] = 'closed'
-            self.publish_unmasked('reset_problem_fail', event_info)
+            event_info["failure"] = "closed"
+            self.publish_unmasked("reset_problem_fail", event_info)
             return {
-                'success': False,
+                "success": False,
                 # pylint: disable=line-too-long
                 # Translators: 'closed' means the problem's due date has passed. You may no longer attempt to solve the problem.
-                'msg': _("You cannot select Reset for a problem that is closed."),
+                "msg": _("You cannot select Reset for a problem that is closed."),
                 # pylint: enable=line-too-long
             }
 
         if not self.is_submitted():
-            event_info['failure'] = 'not_done'
-            self.publish_unmasked('reset_problem_fail', event_info)
+            event_info["failure"] = "not_done"
+            self.publish_unmasked("reset_problem_fail", event_info)
             return {
-                'success': False,
-                'msg': _("You must submit an answer before you can select Reset."),
+                "success": False,
+                "msg": _("You must submit an answer before you can select Reset."),
             }
 
         if self.is_submitted() and self.rerandomize in [RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET]:
@@ -2209,12 +2201,12 @@ def reset_problem(self, _data):
         # Grade may have changed, so publish new value
         self.publish_grade()
 
-        event_info['new_state'] = self.lcp.get_state()
-        self.publish_unmasked('reset_problem', event_info)
+        event_info["new_state"] = self.lcp.get_state()
+        self.publish_unmasked("reset_problem", event_info)
 
         return {
-            'success': True,
-            'html': self.get_problem_html(encapsulate=False),
+            "success": True,
+            "html": self.get_problem_html(encapsulate=False),
         }
 
     # ScorableXBlockMixin methods
@@ -2238,38 +2230,42 @@ def rescore(self, only_if_higher=False):
         Returns the error messages for exceptions occurring while performing
         the rescoring, rather than throwing them.
         """
-        event_info = {'state': self.lcp.get_state(), 'problem_id': str(self.location)}
+        event_info = {"state": self.lcp.get_state(), "problem_id": str(self.location)}
 
         _ = self.runtime.service(self, "i18n").gettext
 
         if not self.lcp.supports_rescoring():
-            event_info['failure'] = 'unsupported'
-            self.publish_unmasked('problem_rescore_fail', event_info)
+            event_info["failure"] = "unsupported"
+            self.publish_unmasked("problem_rescore_fail", event_info)
             # pylint: disable=line-too-long
             # Translators: 'rescoring' refers to the act of re-submitting a student's solution so it can get a new score.
             raise NotImplementedError(_("Problem's definition does not support rescoring."))
             # pylint: enable=line-too-long
 
         if not self.done:
-            event_info['failure'] = 'unanswered'
-            self.publish_unmasked('problem_rescore_fail', event_info)
+            event_info["failure"] = "unanswered"
+            self.publish_unmasked("problem_rescore_fail", event_info)
             raise NotFoundError(_("Problem must be answered before it can be graded again."))
 
         # get old score, for comparison:
         orig_score = self.get_score()
-        event_info['orig_score'] = orig_score.raw_earned
-        event_info['orig_total'] = orig_score.raw_possible
+        event_info["orig_score"] = orig_score.raw_earned
+        event_info["orig_total"] = orig_score.raw_possible
         try:
             calculated_score = self.calculate_score()
-        except (StudentInputError, ResponseError, LoncapaProblemError) as inst:  # lint-amnesty, pylint: disable=unused-variable
+        except (
+            StudentInputError,
+            ResponseError,
+            LoncapaProblemError,
+        ) as inst:  # lint-amnesty, pylint: disable=unused-variable
             log.warning("Input error in capa_block:problem_rescore", exc_info=True)
-            event_info['failure'] = 'input_error'
-            self.publish_unmasked('problem_rescore_fail', event_info)
+            event_info["failure"] = "input_error"
+            self.publish_unmasked("problem_rescore_fail", event_info)
             raise
 
         except Exception:
-            event_info['failure'] = 'unexpected'
-            self.publish_unmasked('problem_rescore_fail', event_info)
+            event_info["failure"] = "unexpected"
+            self.publish_unmasked("problem_rescore_fail", event_info)
             raise
 
         # rescoring should have no effect on attempts, so don't
@@ -2277,21 +2273,21 @@ def rescore(self, only_if_higher=False):
         self.set_state_from_lcp()
         self.publish_grade(score=calculated_score, only_if_higher=only_if_higher)
 
-        event_info['new_score'] = calculated_score.raw_earned
-        event_info['new_total'] = calculated_score.raw_possible
+        event_info["new_score"] = calculated_score.raw_earned
+        event_info["new_total"] = calculated_score.raw_possible
 
         # success = correct if ALL questions in this problem are correct
-        success = 'correct'
+        success = "correct"
         for answer_id in self.lcp.correct_map:
             if not self.lcp.correct_map.is_correct(answer_id):
-                success = 'incorrect'
+                success = "incorrect"
 
         # NOTE: We are logging both full grading and queued-grading submissions. In the latter,
         #       'success' will always be incorrect
-        event_info['correct_map'] = self.lcp.correct_map.get_dict()
-        event_info['success'] = success
-        event_info['attempts'] = self.attempts
-        self.publish_unmasked('problem_rescore', event_info)
+        event_info["correct_map"] = self.lcp.correct_map.get_dict()
+        event_info["success"] = success
+        event_info["attempts"] = self.attempts
+        self.publish_unmasked("problem_rescore", event_info)
 
     def get_rescore_with_grading_method(self) -> Score:
         """
@@ -2339,7 +2335,7 @@ def update_correctness(self):
         """
         # Make sure that the attempt number is always at least 1 for grading purposes,
         # even if the number of attempts have been reset and this problem is regraded.
-        self.lcp.context['attempt'] = max(self.attempts, 1)
+        self.lcp.context["attempt"] = max(self.attempts, 1)
         new_correct_map = self.lcp.get_grade_from_current_answers(None)
         self.lcp.correct_map.update(new_correct_map)
 
@@ -2352,7 +2348,7 @@ def update_correctness_list(self):
         """
         # Make sure that the attempt number is always at least 1 for grading purposes,
         # even if the number of attempts have been reset and this problem is regraded.
-        self.lcp.context['attempt'] = max(self.attempts, 1)
+        self.lcp.context["attempt"] = max(self.attempts, 1)
         new_correct_map_list = []
         for student_answers, correct_map in zip(self.student_answers_history, self.correct_map_history):
             new_correct_map = self.lcp.get_grade_from_current_answers(student_answers, correct_map)
@@ -2371,7 +2367,7 @@ def calculate_score(self):
             return self.get_rescore_with_grading_method()
         self.update_correctness()
         new_score = self.lcp.calculate_score()
-        return Score(raw_earned=new_score['score'], raw_possible=new_score['total'])
+        return Score(raw_earned=new_score["score"], raw_possible=new_score["total"])
 
     def calculate_score_list(self):
         """
@@ -2381,7 +2377,7 @@ def calculate_score_list(self):
 
         for correct_map in self.lcp.correct_map_history:
             new_score = self.lcp.calculate_score(correct_map)
-            new_score_list.append(Score(raw_earned=new_score['score'], raw_possible=new_score['total']))
+            new_score_list.append(Score(raw_earned=new_score["score"], raw_possible=new_score["total"]))
         return new_score_list
 
     def score_from_lcp(self, lcp):
@@ -2390,7 +2386,7 @@ def score_from_lcp(self, lcp):
         currently stored by the LCP.
         """
         lcp_score = lcp.calculate_score()
-        return Score(raw_earned=lcp_score['score'], raw_possible=lcp_score['total'])
+        return Score(raw_earned=lcp_score["score"], raw_possible=lcp_score["total"])
 
 
 class GradingMethodHandler:
@@ -2493,6 +2489,7 @@ class ComplexEncoder(json.JSONEncoder):
     """
     Extend the JSON encoder to correctly handle complex numbers
     """
+
     def default(self, obj):  # lint-amnesty, pylint: disable=arguments-differ, method-hidden
         """
         Print a nicely formatted complex number, or default to the JSON encoder
@@ -2510,15 +2507,12 @@ def randomization_bin(seed, problem_id):
     interesting.  To avoid having sets of students that always get the same problems,
     we'll combine the system's per-student seed with the problem id in picking the bin.
     """
-    r_hash = hashlib.sha1()
+    r_hash = hashlib.sha256()
     r_hash.update(str(seed).encode())
     r_hash.update(str(problem_id).encode())
     # get the first few digits of the hash, convert to an int, then mod.
     return int(r_hash.hexdigest()[:7], 16) % NUM_RANDOMIZATION_BINS
 
 
-ProblemBlock = (
-    _ExtractedProblemBlock if settings.USE_EXTRACTED_PROBLEM_BLOCK
-    else _BuiltInProblemBlock
-)
+ProblemBlock = _ExtractedProblemBlock if settings.USE_EXTRACTED_PROBLEM_BLOCK else _BuiltInProblemBlock
 ProblemBlock.__name__ = "ProblemBlock"
diff --git a/xmodule/contentstore/django.py b/xmodule/contentstore/django.py
index 2d375c70dd75..545794cc472e 100644
--- a/xmodule/contentstore/django.py
+++ b/xmodule/contentstore/django.py
@@ -14,18 +14,18 @@ def load_function(path):
     path is a string of the form "path.to.module.function"
     returns the imported python object `function` from `path.to.module`
     """
-    module_path, _, name = path.rpartition('.')
+    module_path, _, name = path.rpartition(".")
     return getattr(import_module(module_path), name)
 
 
-def contentstore(name='default'):  # lint-amnesty, pylint: disable=missing-function-docstring
+def contentstore(name="default"):  # lint-amnesty, pylint: disable=missing-function-docstring
     if name not in _CONTENTSTORE:
-        class_ = load_function(settings.CONTENTSTORE['ENGINE'])
+        class_ = load_function(settings.CONTENTSTORE["ENGINE"])
         options = {}
-        options.update(settings.CONTENTSTORE['DOC_STORE_CONFIG'])
-        if 'ADDITIONAL_OPTIONS' in settings.CONTENTSTORE:
-            if name in settings.CONTENTSTORE['ADDITIONAL_OPTIONS']:
-                options.update(settings.CONTENTSTORE['ADDITIONAL_OPTIONS'][name])
+        options.update(settings.CONTENTSTORE["DOC_STORE_CONFIG"])
+        if "ADDITIONAL_OPTIONS" in settings.CONTENTSTORE:
+            if name in settings.CONTENTSTORE["ADDITIONAL_OPTIONS"]:
+                options.update(settings.CONTENTSTORE["ADDITIONAL_OPTIONS"][name])
         _CONTENTSTORE[name] = class_(**options)
 
     return _CONTENTSTORE[name]
diff --git a/xmodule/fields.py b/xmodule/fields.py
index 2e65304d4422..b5f997f035f4 100644
--- a/xmodule/fields.py
+++ b/xmodule/fields.py
@@ -14,9 +14,10 @@
 
 
 class Date(JSONField):
-    '''
+    """
     Date fields know how to parse and produce json (iso) compatible formats. Converts to tz aware datetimes.
-    '''
+    """
+
     # See note below about not defaulting these
     CURRENT_YEAR = datetime.datetime.now(UTC).year
     PREVENT_DEFAULT_DAY_MON_SEED1 = datetime.datetime(CURRENT_YEAR, 1, 1, tzinfo=UTC)
@@ -53,15 +54,16 @@ def from_json(self, field):  # lint-amnesty, pylint: disable=arguments-differ
             return None
         elif isinstance(field, str):
             return self._parse_date_wo_default_month_day(field)
-        elif isinstance(field, int) or isinstance(field, float):  # lint-amnesty, pylint: disable=consider-merging-isinstance
+        elif isinstance(field, int) or isinstance(  # lint-amnesty, pylint: disable=consider-merging-isinstance
+            field, float
+        ):
             return datetime.datetime.fromtimestamp(field / 1000, UTC)
         elif isinstance(field, time.struct_time):
             return datetime.datetime.fromtimestamp(time.mktime(field), UTC)
         elif isinstance(field, datetime.datetime):
             return field
         else:
-            msg = "Field {} has bad value '{}'".format(
-                self.name, field)
+            msg = "Field {} has bad value '{}'".format(self.name, field)
             raise TypeError(msg)
 
     def to_json(self, value):
@@ -72,7 +74,7 @@ def to_json(self, value):
             return None
         if isinstance(value, time.struct_time):
             # struct_times are always utc
-            return time.strftime('%Y-%m-%dT%H:%M:%SZ', value)
+            return time.strftime("%Y-%m-%dT%H:%M:%SZ", value)
         elif isinstance(value, datetime.datetime):
             if value.tzinfo is None or value.utcoffset().total_seconds() == 0:
                 if value.year < 1900:
@@ -80,7 +82,7 @@ def to_json(self, value):
                     # isoformat instead
                     return value.isoformat()
                 # isoformat adds +00:00 rather than Z
-                return value.strftime('%Y-%m-%dT%H:%M:%SZ')
+                return value.strftime("%Y-%m-%dT%H:%M:%SZ")
             else:
                 return value.isoformat()
         else:
@@ -88,7 +90,10 @@ def to_json(self, value):
 
     enforce_type = from_json
 
-TIMEDELTA_REGEX = re.compile(r'^((?P<days>\d+?) day(?:s?))?(\s)?((?P<hours>\d+?) hour(?:s?))?(\s)?((?P<minutes>\d+?) minute(?:s)?)?(\s)?((?P<seconds>\d+?) second(?:s)?)?$')  # lint-amnesty, pylint: disable=line-too-long
+
+TIMEDELTA_REGEX = re.compile(
+    r"^((?P<days>\d+?) day(?:s?))?(\s)?((?P<hours>\d+?) hour(?:s?))?(\s)?((?P<minutes>\d+?) minute(?:s)?)?(\s)?((?P<seconds>\d+?) second(?:s)?)?$"  # lint-amnesty, pylint: disable=line-too-long
+)
 
 
 class Timedelta(JSONField):  # lint-amnesty, pylint: disable=missing-class-docstring
@@ -116,7 +121,7 @@ def from_json(self, time_str):  # lint-amnesty, pylint: disable=arguments-differ
             return
         parts = parts.groupdict()
         time_params = {}
-        for (name, param) in parts.items():
+        for name, param in parts.items():
             if param:
                 time_params[name] = int(param)
         return datetime.timedelta(**time_params)
@@ -126,11 +131,11 @@ def to_json(self, value):
             return None
 
         values = []
-        for attr in ('days', 'hours', 'minutes', 'seconds'):
+        for attr in ("days", "hours", "minutes", "seconds"):
             cur_value = getattr(value, attr, 0)
             if cur_value > 0:
                 values.append("%d %s" % (cur_value, attr))
-        return ' '.join(values)
+        return " ".join(values)
 
     def enforce_type(self, value):
         """
@@ -161,6 +166,7 @@ class RelativeTime(JSONField):
     Python object of RelativeTime is datetime.timedelta.
     JSONed representation of RelativeTime is "HH:MM:SS"
     """
+
     # Timedeltas are immutable, see http://docs.python.org/2/library/datetime.html#available-types
     MUTABLE = False
 
@@ -173,17 +179,13 @@ def isotime_to_timedelta(cls, value):
          that max value that can be used by user is "23:59:59".
         """
         try:
-            obj_time = time.strptime(value, '%H:%M:%S')
+            obj_time = time.strptime(value, "%H:%M:%S")
         except ValueError as e:
             raise ValueError(  # lint-amnesty, pylint: disable=raise-missing-from
                 "Incorrect RelativeTime value {!r} was set in XML or serialized. "
                 "Original parse message is {}".format(value, str(e))
             )
-        return datetime.timedelta(
-            hours=obj_time.tm_hour,
-            minutes=obj_time.tm_min,
-            seconds=obj_time.tm_sec
-        )
+        return datetime.timedelta(hours=obj_time.tm_hour, minutes=obj_time.tm_min, seconds=obj_time.tm_sec)
 
     def from_json(self, value):
         """
@@ -241,10 +243,10 @@ def timedelta_to_string(self, value):
 
          str(timedelta) has [H]H:MM:SS format, which is not suitable
          for front-end (and ISO time standard), so we force HH:MM:SS format.
-         """
+        """
         stringified = str(value)
         if len(stringified) == 7:
-            stringified = '0' + stringified
+            stringified = "0" + stringified
         return stringified
 
     def enforce_type(self, value):
@@ -264,6 +266,7 @@ class ScoreField(JSONField):
     from their problem state, specifically for use in staff override
     of problem scores.
     """
+
     MUTABLE = False
 
     def from_json(self, value):
@@ -272,17 +275,15 @@ def from_json(self, value):
         if isinstance(value, Score):
             return value
 
-        if set(value) != {'raw_earned', 'raw_possible'}:
-            raise TypeError('Scores must contain only a raw earned and raw possible value. Got {}'.format(
-                set(value)
-            ))
+        if set(value) != {"raw_earned", "raw_possible"}:
+            raise TypeError("Scores must contain only a raw earned and raw possible value. Got {}".format(set(value)))
 
-        raw_earned = value['raw_earned']
-        raw_possible = value['raw_possible']
+        raw_earned = value["raw_earned"]
+        raw_possible = value["raw_possible"]
 
         if raw_possible < 0:
             raise ValueError(
-                'Error deserializing field of type {}: Expected a positive number for raw_possible, got {}.'.format(
+                "Error deserializing field of type {}: Expected a positive number for raw_possible, got {}.".format(
                     self.display_name,
                     raw_possible,
                 )
@@ -290,10 +291,8 @@ def from_json(self, value):
 
         if not (0 <= raw_earned <= raw_possible):  # lint-amnesty, pylint: disable=superfluous-parens
             raise ValueError(
-                'Error deserializing field of type {}: Expected raw_earned between 0 and {}, got {}.'.format(
-                    self.display_name,
-                    raw_possible,
-                    raw_earned
+                "Error deserializing field of type {}: Expected raw_earned between 0 and {}, got {}.".format(
+                    self.display_name, raw_possible, raw_earned
                 )
             )
 
diff --git a/xmodule/progress.py b/xmodule/progress.py
index dda88ad53eca..379dbf12a61d 100644
--- a/xmodule/progress.py
+++ b/xmodule/progress.py
@@ -1,16 +1,15 @@
-'''
+"""
 Progress class for blocks.  Represents where a student is in a block.
 
 For most subclassing needs, you should only need to reimplement
 frac() and __str__().
-'''
-
+"""
 
 import numbers
 
 
 class Progress:
-    '''Represents a progress of a/b (a out of b done)
+    """Represents a progress of a/b (a out of b done)
 
     a and b must be numeric, but not necessarily integer, with
     0 <= a <= b and b > 0.
@@ -19,17 +18,16 @@ class Progress:
     blocks (e.g. html) should return None from get_progress().
 
     TODO: add tag for module type?  Would allow for smarter merging.
-    '''
+    """
 
     def __init__(self, a, b):
-        '''Construct a Progress object.  a and b must be numbers, and must have
-              0 <= a <= b and b > 0
-        '''
+        """Construct a Progress object.  a and b must be numbers, and must have
+        0 <= a <= b and b > 0
+        """
 
         # Want to do all checking at construction time, so explicitly check types
-        if not (isinstance(a, numbers.Number) and
-                isinstance(b, numbers.Number)):
-            raise TypeError(f'a and b must be numbers.  Passed {a}/{b}')
+        if not (isinstance(a, numbers.Number) and isinstance(b, numbers.Number)):
+            raise TypeError(f"a and b must be numbers.  Passed {a}/{b}")
 
         if a > b:  # lint-amnesty, pylint: disable=consider-using-min-builtin
             a = b
@@ -38,56 +36,56 @@ def __init__(self, a, b):
             a = 0
 
         if b <= 0:
-            raise ValueError(f'fraction a/b = {a}/{b} must have b > 0')
+            raise ValueError(f"fraction a/b = {a}/{b} must have b > 0")
 
         self._a = a
         self._b = b
 
     def frac(self):
-        ''' Return tuple (a,b) representing progress of a/b'''
+        """Return tuple (a,b) representing progress of a/b"""
         return (self._a, self._b)
 
     def percent(self):
-        ''' Returns a percentage progress as a float between 0 and 100.
+        """Returns a percentage progress as a float between 0 and 100.
 
         subclassing note: implemented in terms of frac(), assumes sanity
         checking is done at construction time.
-        '''
+        """
         (a, b) = self.frac()
         return 100.0 * a / b
 
     def started(self):
-        ''' Returns True if fractional progress is greater than 0.
+        """Returns True if fractional progress is greater than 0.
 
         subclassing note: implemented in terms of frac(), assumes sanity
         checking is done at construction time.
-        '''
+        """
         return self.frac()[0] > 0
 
     def inprogress(self):
-        ''' Returns True if fractional progress is strictly between 0 and 1.
+        """Returns True if fractional progress is strictly between 0 and 1.
 
         subclassing note: implemented in terms of frac(), assumes sanity
         checking is done at construction time.
-        '''
+        """
         (a, b) = self.frac()
         return a > 0 and a < b  # lint-amnesty, pylint: disable=chained-comparison
 
     def done(self):
-        ''' Return True if this represents done.
+        """Return True if this represents done.
 
         subclassing note: implemented in terms of frac(), assumes sanity
         checking is done at construction time.
-        '''
+        """
         (a, b) = self.frac()
         return a == b
 
     def ternary_str(self):
-        ''' Return a string version of this progress: either
+        """Return a string version of this progress: either
            "none", "in_progress", or "done".
 
         subclassing note: implemented in terms of frac()
-        '''
+        """
         (a, b) = self.frac()
         if a == 0:
             return "none"
@@ -96,8 +94,8 @@ def ternary_str(self):
         return "done"
 
     def __eq__(self, other):
-        ''' Two Progress objects are equal if they have identical values.
-        Implemented in terms of frac()'''
+        """Two Progress objects are equal if they have identical values.
+        Implemented in terms of frac()"""
         if not isinstance(other, Progress):
             return False
         (a, b) = self.frac()
@@ -105,26 +103,26 @@ def __eq__(self, other):
         return a == a2 and b == b2
 
     def __ne__(self, other):
-        ''' The opposite of equal'''
+        """The opposite of equal"""
         return not self.__eq__(other)
 
     def __str__(self):
-        '''Return a string representation of this string. Rounds results to
+        """Return a string representation of this string. Rounds results to
         two decimal places, stripping out any trailing zeroes.
 
         subclassing note: implemented in terms of frac().
 
-        '''
+        """
         (a, b) = self.frac()
-        display = lambda n: f'{n:.2f}'.rstrip('0').rstrip('.')
+        display = lambda n: f"{n:.2f}".rstrip("0").rstrip(".")
         return f"{display(a)}/{display(b)}"
 
     @staticmethod
     def add_counts(a, b):
-        '''Add two progress indicators, assuming that each represents items done:
+        """Add two progress indicators, assuming that each represents items done:
         (a / b) + (c / d) = (a + c) / (b + d).
         If either is None, returns the other.
-        '''
+        """
         if a is None:
             return b
         if b is None:
diff --git a/xmodule/raw_block.py b/xmodule/raw_block.py
index f24dd7712d85..703d84176092 100644
--- a/xmodule/raw_block.py
+++ b/xmodule/raw_block.py
@@ -9,20 +9,23 @@
 
 log = logging.getLogger(__name__)
 
-PRE_TAG_REGEX = re.compile(r'<pre\b[^>]*>(?:(?=([^<]+))\1|<(?!pre\b[^>]*>))*?</pre>')
+PRE_TAG_REGEX = re.compile(r"<pre\b[^>]*>(?:(?=([^<]+))\1|<(?!pre\b[^>]*>))*?</pre>")
 
 
 class RawMixin:
     """
     Common code between RawDescriptor and XBlocks converted from XModules.
     """
+
     resources_dir = None
 
     data = String(help="XML data for the block", default="", scope=Scope.content)
 
     @classmethod
-    def definition_from_xml(cls, xml_object, system):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
-        return {'data': etree.tostring(xml_object, pretty_print=True, encoding='unicode')}, []
+    def definition_from_xml(
+        cls, xml_object, system
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
+        return {"data": etree.tostring(xml_object, pretty_print=True, encoding="unicode")}, []
 
     def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=unused-argument
         """
@@ -49,13 +52,10 @@ def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=unuse
         except etree.XMLSyntaxError as err:
             # Can't recover here, so just add some info and
             # re-raise
-            lines = self.data.split('\n')
+            lines = self.data.split("\n")
             line, offset = err.position
-            msg = (
-                "Unable to create xml for block {loc}. "
-                "Context: '{context}'"
-            ).format(
-                context=lines[line - 1][offset - 40:offset + 40],
+            msg = ("Unable to create xml for block {loc}. " "Context: '{context}'").format(
+                context=lines[line - 1][offset - 40 : offset + 40],
                 loc=self.location,
             )
             raise SerializationError(self.location, msg)  # lint-amnesty, pylint: disable=raise-missing-from
@@ -87,15 +87,16 @@ class EmptyDataRawMixin:
     """
     Common code between EmptyDataRawDescriptor and XBlocks converted from XModules.
     """
+
     resources_dir = None
 
-    data = String(default='', scope=Scope.content)
+    data = String(default="", scope=Scope.content)
 
     @classmethod
     def definition_from_xml(cls, xml_object, system):  # lint-amnesty, pylint: disable=unused-argument
         if len(xml_object) == 0 and len(list(xml_object.items())) == 0:
-            return {'data': ''}, []
-        return {'data': etree.tostring(xml_object, pretty_print=True, encoding='unicode')}, []
+            return {"data": ""}, []
+        return {"data": etree.tostring(xml_object, pretty_print=True, encoding="unicode")}, []
 
     def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=unused-argument
         if self.data:
diff --git a/xmodule/stringify.py b/xmodule/stringify.py
index c97af7232338..8bc0e8da3b75 100644
--- a/xmodule/stringify.py
+++ b/xmodule/stringify.py
@@ -4,7 +4,7 @@
 
 
 def stringify_children(node):
-    '''
+    """
     Return all contents of an xml tree, without the outside tags.
     e.g. if node is parse of
         "<html a="b" foo="bar">Hi <div>there <span>Bruce</span><b>!</b></div><html>"
@@ -13,7 +13,7 @@ def stringify_children(node):
 
     fixed from
     http://stackoverflow.com/questions/4624062/get-all-text-inside-a-tag-in-lxml
-    '''
+    """
     # Useful things to know:
 
     # node.tostring() -- generates xml for the node, including start
@@ -24,7 +24,7 @@ def stringify_children(node):
     #                 next element.
     parts = [node.text]
     for c in node.getchildren():
-        parts.append(etree.tostring(c, with_tail=True, encoding='unicode'))
+        parts.append(etree.tostring(c, with_tail=True, encoding="unicode"))
 
     # filter removes possible Nones in texts and tails
-    return ''.join([part for part in parts if part])
+    return "".join([part for part in parts if part])
diff --git a/xmodule/tests/test_capa_block.py b/xmodule/tests/test_capa_block.py
index 21582e55eac3..036f05349c10 100644
--- a/xmodule/tests/test_capa_block.py
+++ b/xmodule/tests/test_capa_block.py
@@ -1,6 +1,7 @@
 """
 Tests of the Capa XModule
 """
+
 # pylint: disable=invalid-name
 
 
@@ -12,15 +13,14 @@
 import unittest
 from unittest.mock import DEFAULT, Mock, PropertyMock, patch
 
-import pytest
 import ddt
+import pytest
 import requests
 import webob
 from codejail.safe_exec import SafeExecException
 from django.conf import settings
 from django.test import override_settings
 from django.utils.encoding import smart_str
-from lms.djangoapps.courseware.user_state_client import XBlockUserState
 from lxml import etree
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
 from pytz import UTC
@@ -30,21 +30,21 @@
 from xblock.scorable import Score
 
 import xmodule
+from lms.djangoapps.courseware.user_state_client import XBlockUserState
 from openedx.core.djangolib.testing.utils import skip_unless_lms
 from xmodule.capa import responsetypes
 from xmodule.capa.correctmap import CorrectMap
 from xmodule.capa.responsetypes import LoncapaProblemError, ResponseError, StudentInputError
+from xmodule.capa.tests.test_util import use_unsafe_codejail
 from xmodule.capa.xqueue_interface import XQueueInterface
 from xmodule.capa_block import ComplexEncoder, ProblemBlock
 from xmodule.tests import DATA_DIR
-from xmodule.capa.tests.test_util import use_unsafe_codejail
 
 from ..capa_block import RANDOMIZATION, SHOWANSWER
 from . import get_test_system
 
-
 FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS = settings.FEATURES.copy()
-FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS['ENABLE_GRADING_METHOD_IN_PROBLEMS'] = True
+FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS["ENABLE_GRADING_METHOD_IN_PROBLEMS"] = True
 
 
 class CapaFactory:
@@ -52,7 +52,8 @@ class CapaFactory:
     A helper class to create problem blocks with various parameters for testing.
     """
 
-    sample_problem_xml = textwrap.dedent("""\
+    sample_problem_xml = textwrap.dedent(
+        """\
         <?xml version="1.0"?>
         <problem>
             <text>
@@ -62,7 +63,8 @@ class CapaFactory:
         <textline math="1" size="30"/>
         </numericalresponse>
         </problem>
-    """)
+    """
+    )
 
     num = 0
 
@@ -83,12 +85,23 @@ def answer_key(cls, response_num=2, input_num=1):
         """
         Return the key stored in the capa problem answer dict
         """
-        return ("%s_%d_%d" % ("-".join(['i4x', 'edX', 'capa_test', 'problem', 'SampleProblem%d' % cls.num]),
-                              response_num, input_num))
+        return "%s_%d_%d" % (
+            "-".join(["i4x", "edX", "capa_test", "problem", "SampleProblem%d" % cls.num]),
+            response_num,
+            input_num,
+        )
 
     @classmethod
-    def create(cls, attempts=None, problem_state=None, correct=False, xml=None, override_get_score=True,
-               render_template=None, **kwargs):
+    def create(
+        cls,
+        attempts=None,
+        problem_state=None,
+        correct=False,
+        xml=None,
+        override_get_score=True,
+        render_template=None,
+        **kwargs,
+    ):
         """
         All parameters are optional, and are added to the created problem if specified.
 
@@ -114,24 +127,24 @@ def create(cls, attempts=None, problem_state=None, correct=False, xml=None, over
         )
         if xml is None:
             xml = cls.sample_problem_xml
-        field_data = {'data': xml}
+        field_data = {"data": xml}
         field_data.update(kwargs)
         if problem_state is not None:
             field_data.update(problem_state)
         if attempts is not None:
             # converting to int here because I keep putting "0" and "1" in the tests
             # since everything else is a string.
-            field_data['attempts'] = int(attempts)
+            field_data["attempts"] = int(attempts)
 
         system = get_test_system(
             course_id=location.course_key,
-            user_is_staff=kwargs.get('user_is_staff', False),
+            user_is_staff=kwargs.get("user_is_staff", False),
             render_template=render_template or Mock(return_value="<div>Test Template HTML</div>"),
         )
         block = ProblemBlock(
             system,
             DictFieldData(field_data),
-            ScopeIds(None, 'problem', location, location),
+            ScopeIds(None, "problem", location, location),
         )
         assert block.lcp
 
@@ -142,7 +155,7 @@ def create(cls, attempts=None, problem_state=None, correct=False, xml=None, over
             else:
                 block.score = Score(raw_earned=0, raw_possible=1)
 
-        block.graded = 'False'
+        block.graded = "False"
         block.weight = 1
         return block
 
@@ -151,7 +164,9 @@ class CapaFactoryWithFiles(CapaFactory):
     """
     A factory for creating a Capa problem with files attached.
     """
-    sample_problem_xml = textwrap.dedent("""\
+
+    sample_problem_xml = textwrap.dedent(
+        """\
         <problem>
             <coderesponse queuename="BerkeleyX-cs188x">
                 <!-- actual filenames here don't matter for server-side tests,
@@ -185,7 +200,8 @@ class CapaFactoryWithFiles(CapaFactory):
                 </answer>
             </customresponse>
         </problem>
-    """)
+    """
+    )
 
 
 @ddt.ddt
@@ -210,7 +226,7 @@ def test_import(self):
 
         other_block = CapaFactory.create()
         assert block.get_score().raw_earned == 0
-        assert block.url_name != other_block.url_name, 'Factory should be creating unique names for each problem'
+        assert block.url_name != other_block.url_name, "Factory should be creating unique names for each problem"
 
     def test_correct(self):
         """
@@ -228,8 +244,8 @@ def test_get_score(self):
         Capa blocks store their score independently of the LCP internals, so it must
         be explicitly updated.
         """
-        student_answers = {'1_2_1': 'abcd'}
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=0.9)
+        student_answers = {"1_2_1": "abcd"}
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=0.9)
         block = CapaFactory.create(correct=True, override_get_score=False)
         block.lcp.correct_map = correct_map
         block.lcp.student_answers = student_answers
@@ -237,7 +253,7 @@ def test_get_score(self):
         block.set_score(block.score_from_lcp(block.lcp))
         assert block.get_score().raw_earned == 0.9
 
-        other_correct_map = CorrectMap(answer_id='1_2_1', correctness="incorrect", npoints=0.1)
+        other_correct_map = CorrectMap(answer_id="1_2_1", correctness="incorrect", npoints=0.1)
         other_block = CapaFactory.create(correct=False, override_get_score=False)
         other_block.lcp.correct_map = other_correct_map
         other_block.lcp.student_answers = student_answers
@@ -255,8 +271,8 @@ def test_showanswer_default(self):
         assert not problem.answer_available()
 
     @ddt.data(
-        (requests.exceptions.ReadTimeout, (1, 'failed to read from the server')),
-        (requests.exceptions.ConnectionError, (1, 'cannot connect to server')),
+        (requests.exceptions.ReadTimeout, (1, "failed to read from the server")),
+        (requests.exceptions.ConnectionError, (1, "cannot connect to server")),
     )
     @ddt.unpack
     def test_xqueue_request_exception(self, exception, result):
@@ -265,36 +281,70 @@ def test_xqueue_request_exception(self, exception, result):
         connect/read timeout(s) to request to xqueue
         """
         xqueue_interface = XQueueInterface("http://example.com/xqueue", Mock())
-        with patch.object(xqueue_interface.session, 'post', side_effect=exception):
+        with patch.object(xqueue_interface.session, "post", side_effect=exception):
             # pylint: disable = protected-access
-            response = xqueue_interface._http_post('http://some/fake/url', {})
+            response = xqueue_interface._http_post("http://some/fake/url", {})
             assert response == result
 
     def test_showanswer_attempted(self):
-        problem = CapaFactory.create(showanswer='attempted')
+        problem = CapaFactory.create(showanswer="attempted")
         assert not problem.answer_available()
         problem.attempts = 1
         assert problem.answer_available()
 
     @ddt.data(
         # If show_correctness=always, Answer is visible after attempted
-        ({'showanswer': 'attempted', 'max_attempts': '1', 'show_correctness': 'always', }, False, True),
+        (
+            {
+                "showanswer": "attempted",
+                "max_attempts": "1",
+                "show_correctness": "always",
+            },
+            False,
+            True,
+        ),
         # If show_correctness=never, Answer is never visible
-        ({'showanswer': 'attempted', 'max_attempts': '1', 'show_correctness': 'never', }, False, False),
+        (
+            {
+                "showanswer": "attempted",
+                "max_attempts": "1",
+                "show_correctness": "never",
+            },
+            False,
+            False,
+        ),
         # If show_correctness=past_due, answer is not visible before due date
-        ({'showanswer': 'attempted', 'show_correctness': 'past_due', 'max_attempts': '1', 'due': 'tomorrow_str', },
-         False, False),
+        (
+            {
+                "showanswer": "attempted",
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "due": "tomorrow_str",
+            },
+            False,
+            False,
+        ),
         # If show_correctness=past_due, answer is visible after due date
-        ({'showanswer': 'attempted', 'show_correctness': 'past_due', 'max_attempts': '1', 'due': 'yesterday_str', },
-         True, True))
+        (
+            {
+                "showanswer": "attempted",
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "due": "yesterday_str",
+            },
+            True,
+            True,
+        ),
+    )
     @ddt.unpack
-    def test_showanswer_hide_correctness(self, problem_data, answer_available_no_attempt,
-                                         answer_available_after_attempt):
+    def test_showanswer_hide_correctness(
+        self, problem_data, answer_available_no_attempt, answer_available_after_attempt
+    ):
         """
         Ensure that the answer will not be shown when correctness is being hidden.
         """
-        if 'due' in problem_data:
-            problem_data['due'] = getattr(self, problem_data['due'])
+        if "due" in problem_data:
+            problem_data["due"] = getattr(self, problem_data["due"])
         problem = CapaFactory.create(**problem_data)
         assert problem.answer_available() == answer_available_no_attempt
         problem.attempts = 1
@@ -303,33 +353,30 @@ def test_showanswer_hide_correctness(self, problem_data, answer_available_no_att
     def test_showanswer_closed(self):
 
         # can see after attempts used up, even with due date in the future
-        used_all_attempts = CapaFactory.create(showanswer='closed',
-                                               max_attempts="1",
-                                               attempts="1",
-                                               due=self.tomorrow_str)
+        used_all_attempts = CapaFactory.create(
+            showanswer="closed", max_attempts="1", attempts="1", due=self.tomorrow_str
+        )
         assert used_all_attempts.answer_available()
 
         # can see after due date
-        after_due_date = CapaFactory.create(showanswer='closed',
-                                            max_attempts="1",
-                                            attempts="0",
-                                            due=self.yesterday_str)
+        after_due_date = CapaFactory.create(showanswer="closed", max_attempts="1", attempts="0", due=self.yesterday_str)
 
         assert after_due_date.answer_available()
 
         # can't see because attempts left
-        attempts_left_open = CapaFactory.create(showanswer='closed',
-                                                max_attempts="1",
-                                                attempts="0",
-                                                due=self.tomorrow_str)
+        attempts_left_open = CapaFactory.create(
+            showanswer="closed", max_attempts="1", attempts="0", due=self.tomorrow_str
+        )
         assert not attempts_left_open.answer_available()
 
         # Can't see because grace period hasn't expired
-        still_in_grace = CapaFactory.create(showanswer='closed',
-                                            max_attempts="1",
-                                            attempts="0",
-                                            due=self.yesterday_str,
-                                            graceperiod=self.two_day_delta_str)
+        still_in_grace = CapaFactory.create(
+            showanswer="closed",
+            max_attempts="1",
+            attempts="0",
+            due=self.yesterday_str,
+            graceperiod=self.two_day_delta_str,
+        )
         assert not still_in_grace.answer_available()
 
     def test_showanswer_correct_or_past_due(self):
@@ -339,34 +386,31 @@ def test_showanswer_correct_or_past_due(self):
         """
 
         # can see because answer is correct, even with due date in the future
-        answer_correct = CapaFactory.create(showanswer='correct_or_past_due',
-                                            max_attempts="1",
-                                            attempts="0",
-                                            due=self.tomorrow_str,
-                                            correct=True)
+        answer_correct = CapaFactory.create(
+            showanswer="correct_or_past_due", max_attempts="1", attempts="0", due=self.tomorrow_str, correct=True
+        )
         assert answer_correct.answer_available()
 
         # can see after due date, even when answer isn't correct
-        past_due_date = CapaFactory.create(showanswer='correct_or_past_due',
-                                           max_attempts="1",
-                                           attempts="0",
-                                           due=self.yesterday_str)
+        past_due_date = CapaFactory.create(
+            showanswer="correct_or_past_due", max_attempts="1", attempts="0", due=self.yesterday_str
+        )
         assert past_due_date.answer_available()
 
         # can also see after due date when answer _is_ correct
-        past_due_date_correct = CapaFactory.create(showanswer='correct_or_past_due',
-                                                   max_attempts="1",
-                                                   attempts="0",
-                                                   due=self.yesterday_str,
-                                                   correct=True)
+        past_due_date_correct = CapaFactory.create(
+            showanswer="correct_or_past_due", max_attempts="1", attempts="0", due=self.yesterday_str, correct=True
+        )
         assert past_due_date_correct.answer_available()
 
         # Can't see because grace period hasn't expired and answer isn't correct
-        still_in_grace = CapaFactory.create(showanswer='correct_or_past_due',
-                                            max_attempts="1",
-                                            attempts="1",
-                                            due=self.yesterday_str,
-                                            graceperiod=self.two_day_delta_str)
+        still_in_grace = CapaFactory.create(
+            showanswer="correct_or_past_due",
+            max_attempts="1",
+            attempts="1",
+            due=self.yesterday_str,
+            graceperiod=self.two_day_delta_str,
+        )
         assert not still_in_grace.answer_available()
 
     def test_showanswer_past_due(self):
@@ -376,33 +420,32 @@ def test_showanswer_past_due(self):
         """
 
         # can't see after attempts used up, even with due date in the future
-        used_all_attempts = CapaFactory.create(showanswer='past_due',
-                                               max_attempts="1",
-                                               attempts="1",
-                                               due=self.tomorrow_str)
+        used_all_attempts = CapaFactory.create(
+            showanswer="past_due", max_attempts="1", attempts="1", due=self.tomorrow_str
+        )
         assert not used_all_attempts.answer_available()
 
         # can see after due date
-        past_due_date = CapaFactory.create(showanswer='past_due',
-                                           max_attempts="1",
-                                           attempts="0",
-                                           due=self.yesterday_str)
+        past_due_date = CapaFactory.create(
+            showanswer="past_due", max_attempts="1", attempts="0", due=self.yesterday_str
+        )
         assert past_due_date.answer_available()
 
         # can't see because attempts left
-        attempts_left_open = CapaFactory.create(showanswer='past_due',
-                                                max_attempts="1",
-                                                attempts="0",
-                                                due=self.tomorrow_str)
+        attempts_left_open = CapaFactory.create(
+            showanswer="past_due", max_attempts="1", attempts="0", due=self.tomorrow_str
+        )
         assert not attempts_left_open.answer_available()
 
         # Can't see because grace period hasn't expired, even though have no more
         # attempts.
-        still_in_grace = CapaFactory.create(showanswer='past_due',
-                                            max_attempts="1",
-                                            attempts="1",
-                                            due=self.yesterday_str,
-                                            graceperiod=self.two_day_delta_str)
+        still_in_grace = CapaFactory.create(
+            showanswer="past_due",
+            max_attempts="1",
+            attempts="1",
+            due=self.yesterday_str,
+            graceperiod=self.two_day_delta_str,
+        )
         assert not still_in_grace.answer_available()
 
     def test_showanswer_after_attempts_with_max(self):
@@ -414,10 +457,10 @@ def test_showanswer_after_attempts_with_max(self):
         the requisite number of times, i.e `attempts_before_showanswer_button`
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts='2',
-            attempts_before_showanswer_button='3',
-            max_attempts='5',
+            showanswer="after_attempts",
+            attempts="2",
+            attempts_before_showanswer_button="3",
+            max_attempts="5",
         )
         assert not problem.answer_available()
 
@@ -430,9 +473,9 @@ def test_showanswer_after_attempts_no_max(self):
         problem at least `attempts_before_showanswer_button` times
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts='2',
-            attempts_before_showanswer_button='3',
+            showanswer="after_attempts",
+            attempts="2",
+            attempts_before_showanswer_button="3",
         )
         assert not problem.answer_available()
 
@@ -445,10 +488,10 @@ def test_showanswer_after_attempts_used_all_attempts(self):
         visible even after they have exhausted their attempts.
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts_before_showanswer_button='2',
-            max_attempts='3',
-            attempts='3',
+            showanswer="after_attempts",
+            attempts_before_showanswer_button="2",
+            max_attempts="3",
+            attempts="3",
             due=self.tomorrow_str,
         )
         assert problem.answer_available()
@@ -461,9 +504,9 @@ def test_showanswer_after_attempts_past_due_date(self):
         number of times, the answer should be available past the due date.
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts_before_showanswer_button='2',
-            attempts='2',
+            showanswer="after_attempts",
+            attempts_before_showanswer_button="2",
+            attempts="2",
             due=self.yesterday_str,
         )
         assert problem.answer_available()
@@ -476,9 +519,9 @@ def test_showanswer_after_attempts_still_in_grace(self):
         the show answer button is visible throughout the grace period.
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            after_attempts='3',
-            attempts='4',
+            showanswer="after_attempts",
+            after_attempts="3",
+            attempts="4",
             due=self.yesterday_str,
             graceperiod=self.two_day_delta_str,
         )
@@ -493,10 +536,10 @@ def test_showanswer_after_attempts_large(self):
         i.e after_attempts falls back to max_attempts
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts_before_showanswer_button='5',
-            max_attempts='3',
-            attempts='3',
+            showanswer="after_attempts",
+            attempts_before_showanswer_button="5",
+            max_attempts="3",
+            attempts="3",
         )
         assert problem.answer_available()
 
@@ -508,9 +551,9 @@ def test_showanswer_after_attempts_zero(self):
         button should be visible at all times.
         """
         problem = CapaFactory.create(
-            showanswer='after_attempts',
-            attempts_before_showanswer_button='0',
-            attempts='0',
+            showanswer="after_attempts",
+            attempts_before_showanswer_button="0",
+            attempts="0",
         )
         assert problem.answer_available()
 
@@ -521,41 +564,38 @@ def test_showanswer_finished(self):
         """
 
         # can see after attempts used up, even with due date in the future
-        used_all_attempts = CapaFactory.create(showanswer='finished',
-                                               max_attempts="1",
-                                               attempts="1",
-                                               due=self.tomorrow_str)
+        used_all_attempts = CapaFactory.create(
+            showanswer="finished", max_attempts="1", attempts="1", due=self.tomorrow_str
+        )
         assert used_all_attempts.answer_available()
 
         # can see after due date
-        past_due_date = CapaFactory.create(showanswer='finished',
-                                           max_attempts="1",
-                                           attempts="0",
-                                           due=self.yesterday_str)
+        past_due_date = CapaFactory.create(
+            showanswer="finished", max_attempts="1", attempts="0", due=self.yesterday_str
+        )
         assert past_due_date.answer_available()
 
         # can't see because attempts left and wrong
-        attempts_left_open = CapaFactory.create(showanswer='finished',
-                                                max_attempts="1",
-                                                attempts="0",
-                                                due=self.tomorrow_str)
+        attempts_left_open = CapaFactory.create(
+            showanswer="finished", max_attempts="1", attempts="0", due=self.tomorrow_str
+        )
         assert not attempts_left_open.answer_available()
 
         # _can_ see because attempts left and right
-        correct_ans = CapaFactory.create(showanswer='finished',
-                                         max_attempts="1",
-                                         attempts="0",
-                                         due=self.tomorrow_str,
-                                         correct=True)
+        correct_ans = CapaFactory.create(
+            showanswer="finished", max_attempts="1", attempts="0", due=self.tomorrow_str, correct=True
+        )
         assert correct_ans.answer_available()
 
         # Can see even though grace period hasn't expired, because have no more
         # attempts.
-        still_in_grace = CapaFactory.create(showanswer='finished',
-                                            max_attempts="1",
-                                            attempts="1",
-                                            due=self.yesterday_str,
-                                            graceperiod=self.two_day_delta_str)
+        still_in_grace = CapaFactory.create(
+            showanswer="finished",
+            max_attempts="1",
+            attempts="1",
+            due=self.yesterday_str,
+            graceperiod=self.two_day_delta_str,
+        )
         assert still_in_grace.answer_available()
 
     def test_showanswer_answered(self):
@@ -565,25 +605,17 @@ def test_showanswer_answered(self):
         """
         # Can not see "Show Answer" when student answer is wrong
         answer_wrong = CapaFactory.create(
-            showanswer=SHOWANSWER.ANSWERED,
-            max_attempts="1",
-            attempts="0",
-            due=self.tomorrow_str,
-            correct=False
+            showanswer=SHOWANSWER.ANSWERED, max_attempts="1", attempts="0", due=self.tomorrow_str, correct=False
         )
         assert not answer_wrong.answer_available()
 
         # Expect to see "Show Answer" when answer is correct
         answer_correct = CapaFactory.create(
-            showanswer=SHOWANSWER.ANSWERED,
-            max_attempts="1",
-            attempts="0",
-            due=self.tomorrow_str,
-            correct=True
+            showanswer=SHOWANSWER.ANSWERED, max_attempts="1", attempts="0", due=self.tomorrow_str, correct=True
         )
         assert answer_correct.answer_available()
 
-    @ddt.data('', 'other-value')
+    @ddt.data("", "other-value")
     def test_show_correctness_other(self, show_correctness):
         """
         Test that correctness is visible if show_correctness is not set to one of the values
@@ -603,29 +635,62 @@ def test_show_correctness_never(self):
         """
         Test that correctness is hidden when show_correctness turned off.
         """
-        problem = CapaFactory.create(show_correctness='never')
+        problem = CapaFactory.create(show_correctness="never")
         assert not problem.correctness_available()
 
     @ddt.data(
         # Correctness not visible if due date in the future, even after using up all attempts
-        ({'show_correctness': 'past_due', 'max_attempts': '1', 'attempts': '1', 'due': 'tomorrow_str', }, False),
+        (
+            {
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "attempts": "1",
+                "due": "tomorrow_str",
+            },
+            False,
+        ),
         # Correctness visible if due date in the past
-        ({'show_correctness': 'past_due', 'max_attempts': '1', 'attempts': '0', 'due': 'yesterday_str', }, True),
+        (
+            {
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "attempts": "0",
+                "due": "yesterday_str",
+            },
+            True,
+        ),
         # Correctness not visible if due date in the future
-        ({'show_correctness': 'past_due', 'max_attempts': '1', 'attempts': '0', 'due': 'tomorrow_str', }, False),
+        (
+            {
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "attempts": "0",
+                "due": "tomorrow_str",
+            },
+            False,
+        ),
         # Correctness not visible because grace period hasn't expired,
         # even after using up all attempts
-        ({'show_correctness': 'past_due', 'max_attempts': '1', 'attempts': '1', 'due': 'yesterday_str',
-          'graceperiod': 'two_day_delta_str', }, False))
+        (
+            {
+                "show_correctness": "past_due",
+                "max_attempts": "1",
+                "attempts": "1",
+                "due": "yesterday_str",
+                "graceperiod": "two_day_delta_str",
+            },
+            False,
+        ),
+    )
     @ddt.unpack
     def test_show_correctness_past_due(self, problem_data, expected_result):
         """
         Test that with show_correctness="past_due", correctness will only be visible
         after the problem is closed for everyone--e.g. after due date + grace period.
         """
-        problem_data['due'] = getattr(self, problem_data['due'])
-        if 'graceperiod' in problem_data:
-            problem_data['graceperiod'] = getattr(self, problem_data['graceperiod'])
+        problem_data["due"] = getattr(self, problem_data["due"])
+        if "graceperiod" in problem_data:
+            problem_data["graceperiod"] = getattr(self, problem_data["graceperiod"])
         problem = CapaFactory.create(**problem_data)
         assert problem.correctness_available() == expected_result
 
@@ -652,20 +717,19 @@ def test_closed(self):
         assert block.closed()
 
         # Past due --> closed
-        block = CapaFactory.create(max_attempts="1", attempts="0",
-                                   due=self.yesterday_str)
+        block = CapaFactory.create(max_attempts="1", attempts="0", due=self.yesterday_str)
         assert block.closed()
 
-    @patch.object(ProblemBlock, 'course_end_date', new_callable=PropertyMock)
+    @patch.object(ProblemBlock, "course_end_date", new_callable=PropertyMock)
     def test_closed_for_archive(self, mock_course_end_date):
 
         # Utility to create a datetime object in the past
         def past_datetime(days):
-            return (datetime.datetime.now(UTC) - datetime.timedelta(days=days))
+            return datetime.datetime.now(UTC) - datetime.timedelta(days=days)
 
         # Utility to create a datetime object in the future
         def future_datetime(days):
-            return (datetime.datetime.now(UTC) + datetime.timedelta(days=days))
+            return datetime.datetime.now(UTC) + datetime.timedelta(days=days)
 
         block = CapaFactory.create(max_attempts="1", attempts="0")
 
@@ -691,14 +755,16 @@ def test_parse_get_params(self):
 
         # Valid GET param dict
         # 'input_5' intentionally left unset,
-        valid_get_dict = MultiDict({
-            'input_1': 'test',
-            'input_1_2': 'test',
-            'input_1_2_3': 'test',
-            'input_[]_3': 'test',
-            'input_4': None,
-            'input_6': 5
-        })
+        valid_get_dict = MultiDict(
+            {
+                "input_1": "test",
+                "input_1_2": "test",
+                "input_1_2_3": "test",
+                "input_[]_3": "test",
+                "input_4": None,
+                "input_6": 5,
+            }
+        )
 
         result = ProblemBlock.make_dict_of_responses(valid_get_dict)
 
@@ -706,32 +772,31 @@ def test_parse_get_params(self):
         # and that we get the same values back
         for key in result.keys():  # lint-amnesty, pylint: disable=consider-iterating-dictionary
             original_key = "input_" + key
-            assert original_key in valid_get_dict, ('Output dict should have key %s' % original_key)
+            assert original_key in valid_get_dict, "Output dict should have key %s" % original_key
             assert valid_get_dict[original_key] == result[key]
 
         # Valid GET param dict with list keys
         # Each tuple represents a single parameter in the query string
-        valid_get_dict = MultiDict((('input_2[]', 'test1'), ('input_2[]', 'test2')))
+        valid_get_dict = MultiDict((("input_2[]", "test1"), ("input_2[]", "test2")))
         result = ProblemBlock.make_dict_of_responses(valid_get_dict)
-        assert '2' in result
-        assert ['test1', 'test2'] == result['2']
+        assert "2" in result
+        assert ["test1", "test2"] == result["2"]
 
         # If we use [] at the end of a key name, we should always
         # get a list, even if there's just one value
-        valid_get_dict = MultiDict({'input_1[]': 'test'})
+        valid_get_dict = MultiDict({"input_1[]": "test"})
         result = ProblemBlock.make_dict_of_responses(valid_get_dict)
-        assert result['1'] == ['test']
+        assert result["1"] == ["test"]
 
         # If we have no underscores in the name, then the key is invalid
-        invalid_get_dict = MultiDict({'input': 'test'})
+        invalid_get_dict = MultiDict({"input": "test"})
         with pytest.raises(ValueError):
             result = ProblemBlock.make_dict_of_responses(invalid_get_dict)
 
         # Two equivalent names (one list, one non-list)
         # One of the values would overwrite the other, so detect this
         # and raise an exception
-        invalid_get_dict = MultiDict({'input_1[]': 'test 1',
-                                      'input_1': 'test 2'})
+        invalid_get_dict = MultiDict({"input_1[]": "test 1", "input_1": "test 2"})
         with pytest.raises(ValueError):
             result = ProblemBlock.make_dict_of_responses(invalid_get_dict)
 
@@ -742,29 +807,29 @@ def test_submit_problem_correct(self):
         # Simulate that all answers are marked correct, no matter
         # what the input is, by patching CorrectMap.is_correct()
         # Also simulate rendering the HTML
-        with patch('xmodule.capa.correctmap.CorrectMap.is_correct') as mock_is_correct:
-            with patch('xmodule.capa_block.ProblemBlock.get_problem_html') as mock_html:
+        with patch("xmodule.capa.correctmap.CorrectMap.is_correct") as mock_is_correct:
+            with patch("xmodule.capa_block.ProblemBlock.get_problem_html") as mock_html:
                 mock_is_correct.return_value = True
                 mock_html.return_value = "Test HTML"
 
                 # Check the problem
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 result = block.submit_problem(get_request_dict)
 
         # Expect that the problem is marked correct
-        assert result['success'] == 'correct'
+        assert result["success"] == "correct"
 
         # Expect that we get the (mocked) HTML
-        assert result['contents'] == 'Test HTML'
+        assert result["contents"] == "Test HTML"
 
         # Expect that the number of attempts is incremented by 1
         assert block.attempts == 2
         # and that this was considered attempt number 2 for grading purposes
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
 
-    @patch('xmodule.capa_block.ProblemBlock.get_score_with_grading_method')
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
+    @patch("xmodule.capa_block.ProblemBlock.get_score_with_grading_method")
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
     def test_submit_problem_with_grading_method_disable(
         self, mock_html: Mock, mock_is_correct: Mock, mock_get_score: Mock
     ):
@@ -778,43 +843,41 @@ def test_submit_problem_with_grading_method_disable(
 
         # First Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         assert block.score == Score(raw_earned=1, raw_possible=1)
         mock_get_score.assert_not_called()
 
         # Second Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '3.50'}
+        get_request_dict = {CapaFactory.input_key(): "3.50"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 2
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
         assert block.score == Score(raw_earned=0, raw_possible=1)
         mock_get_score.assert_not_called()
 
         # Third Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 3
-        assert block.lcp.context['attempt'] == 3
+        assert block.lcp.context["attempt"] == 3
         assert block.score == Score(raw_earned=1, raw_possible=1)
         mock_get_score.assert_not_called()
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
-    def test_submit_problem_with_grading_method_enable(
-        self, mock_html: Mock, mock_is_correct: Mock
-    ):
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
+    def test_submit_problem_with_grading_method_enable(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test that the grading method is enabled when submit a problem.
         Then, the `get_score_with_grading_method` method should be called.
@@ -824,21 +887,19 @@ def test_submit_problem_with_grading_method_enable(
         mock_is_correct.return_value = True
 
         with patch.object(
-            ProblemBlock, 'get_score_with_grading_method', wraps=block.get_score_with_grading_method
+            ProblemBlock, "get_score_with_grading_method", wraps=block.get_score_with_grading_method
         ) as mock_get_score:
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 1
-            assert block.lcp.context['attempt'] == 1
+            assert block.lcp.context["attempt"] == 1
             assert block.score == Score(raw_earned=1, raw_possible=1)
             mock_get_score.assert_called()
 
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
-    def test_submit_problem_grading_method_disable_to_enable(
-        self, mock_html: Mock, mock_is_correct: Mock
-    ):
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
+    def test_submit_problem_grading_method_disable_to_enable(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test when the grading method is disabled and then enabled.
 
@@ -850,126 +911,116 @@ def test_submit_problem_grading_method_disable_to_enable(
 
         # Disabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=False
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=False
         ):
             # First Attempt
             mock_is_correct.return_value = True
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 1
-            assert block.lcp.context['attempt'] == 1
+            assert block.lcp.context["attempt"] == 1
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
             # Second Attempt
             mock_is_correct.return_value = False
-            get_request_dict = {CapaFactory.input_key(): '3.50'}
+            get_request_dict = {CapaFactory.input_key(): "3.50"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 2
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
             assert block.score == Score(raw_earned=0, raw_possible=1)
 
         # Enabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=True
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=True
         ):
             # Third Attempt
             mock_is_correct.return_value = False
-            get_request_dict = {CapaFactory.input_key(): '3.96'}
+            get_request_dict = {CapaFactory.input_key(): "3.96"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 3
-            assert block.lcp.context['attempt'] == 3
+            assert block.lcp.context["attempt"] == 3
             assert block.score == Score(raw_earned=0, raw_possible=1)
 
             # Fourth Attempt
-            block.grading_method = 'highest_score'
+            block.grading_method = "highest_score"
             mock_is_correct.return_value = False
-            get_request_dict = {CapaFactory.input_key(): '3.99'}
+            get_request_dict = {CapaFactory.input_key(): "3.99"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 4
-            assert block.lcp.context['attempt'] == 4
+            assert block.lcp.context["attempt"] == 4
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
-    def test_submit_problem_grading_method_enable_to_disable(
-        self, mock_html: Mock, mock_is_correct: Mock
-    ):
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
+    def test_submit_problem_grading_method_enable_to_disable(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test when the grading method is enabled and then disabled.
 
         When the grading method is enabled, the final score is calculated according to the grading method.
         When the grading method is disabled, the final score is always the last attempt.
         """
-        block = CapaFactory.create(attempts=0, max_attempts=4, grading_method='highest_score')
+        block = CapaFactory.create(attempts=0, max_attempts=4, grading_method="highest_score")
         mock_html.return_value = "Test HTML"
 
         # Enabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=True
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=True
         ):
             # First Attempt
             mock_is_correct.return_value = True
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 1
-            assert block.lcp.context['attempt'] == 1
+            assert block.lcp.context["attempt"] == 1
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
             # Second Attempt
             mock_is_correct.return_value = False
-            get_request_dict = {CapaFactory.input_key(): '3.50'}
+            get_request_dict = {CapaFactory.input_key(): "3.50"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 2
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
         # Disabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=False
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=False
         ):
             # Third Attempt
             mock_is_correct.return_value = False
-            get_request_dict = {CapaFactory.input_key(): '3.96'}
+            get_request_dict = {CapaFactory.input_key(): "3.96"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 3
-            assert block.lcp.context['attempt'] == 3
+            assert block.lcp.context["attempt"] == 3
             assert block.score == Score(raw_earned=0, raw_possible=1)
 
             # Fourth Attempt
             mock_is_correct.return_value = True
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
 
             block.submit_problem(get_request_dict)
 
             assert block.attempts == 4
-            assert block.lcp.context['attempt'] == 4
+            assert block.lcp.context["attempt"] == 4
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
     def test_submit_problem_correct_last_score(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test the `last_score` grading method.
@@ -983,27 +1034,27 @@ def test_submit_problem_correct_last_score(self, mock_html: Mock, mock_is_correc
 
         # First Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         assert block.score == Score(raw_earned=1, raw_possible=1)
 
         # Second Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '3.54'}
+        get_request_dict = {CapaFactory.input_key(): "3.54"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 2
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
         assert block.score == Score(raw_earned=0, raw_possible=1)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
     def test_submit_problem_correct_highest_score(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test the `highest_score` grading method.
@@ -1011,32 +1062,32 @@ def test_submit_problem_correct_highest_score(self, mock_html: Mock, mock_is_cor
         When the grading method is `highest_score`,
         the final score is the highest score among all attempts.
         """
-        block = CapaFactory.create(attempts=0, max_attempts=2, grading_method='highest_score')
+        block = CapaFactory.create(attempts=0, max_attempts=2, grading_method="highest_score")
         mock_html.return_value = "Test HTML"
 
         # First Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         assert block.score == Score(raw_earned=1, raw_possible=1)
 
         # Second Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '3.54'}
+        get_request_dict = {CapaFactory.input_key(): "3.54"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 2
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
         assert block.score == Score(raw_earned=1, raw_possible=1)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
     def test_submit_problem_correct_first_score(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test the `first_score` grading method.
@@ -1044,32 +1095,32 @@ def test_submit_problem_correct_first_score(self, mock_html: Mock, mock_is_corre
         When the grading method is `first_score`,
         the final score is the first score among all attempts.
         """
-        block = CapaFactory.create(attempts=0, max_attempts=2, grading_method='first_score')
+        block = CapaFactory.create(attempts=0, max_attempts=2, grading_method="first_score")
         mock_html.return_value = "Test HTML"
 
         # First Attempt
         mock_is_correct.return_value = False
 
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         assert block.score == Score(raw_earned=0, raw_possible=1)
 
         # Second Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.54'}
+        get_request_dict = {CapaFactory.input_key(): "3.54"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 2
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
         assert block.score == Score(raw_earned=0, raw_possible=1)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa.correctmap.CorrectMap.is_correct')
-    @patch('xmodule.capa_block.ProblemBlock.get_problem_html')
+    @patch("xmodule.capa.correctmap.CorrectMap.is_correct")
+    @patch("xmodule.capa_block.ProblemBlock.get_problem_html")
     def test_submit_problem_correct_average_score(self, mock_html: Mock, mock_is_correct: Mock):
         """
         Test the `average_score` grading method.
@@ -1077,47 +1128,47 @@ def test_submit_problem_correct_average_score(self, mock_html: Mock, mock_is_cor
         When the grading method is `average_score`,
         the final score is the average score among all attempts.
         """
-        block = CapaFactory.create(attempts=0, max_attempts=4, grading_method='average_score')
+        block = CapaFactory.create(attempts=0, max_attempts=4, grading_method="average_score")
         mock_html.return_value = "Test HTML"
 
         # First Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         assert block.score == Score(raw_earned=0, raw_possible=1)
 
         # Second Attempt
         mock_is_correct.return_value = True
-        get_request_dict = {CapaFactory.input_key(): '3.54'}
+        get_request_dict = {CapaFactory.input_key(): "3.54"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 2
-        assert block.lcp.context['attempt'] == 2
+        assert block.lcp.context["attempt"] == 2
         assert block.score == Score(raw_earned=0.5, raw_possible=1)
 
         # Third Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '3.45'}
+        get_request_dict = {CapaFactory.input_key(): "3.45"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 3
-        assert block.lcp.context['attempt'] == 3
+        assert block.lcp.context["attempt"] == 3
         assert block.score == Score(raw_earned=0.33, raw_possible=1)
 
         # Fourth Attempt
         mock_is_correct.return_value = False
-        get_request_dict = {CapaFactory.input_key(): '41.3'}
+        get_request_dict = {CapaFactory.input_key(): "41.3"}
 
         block.submit_problem(get_request_dict)
 
         assert block.attempts == 4
-        assert block.lcp.context['attempt'] == 4
+        assert block.lcp.context["attempt"] == 4
         assert block.score == Score(raw_earned=0.25, raw_possible=1)
 
     def test_submit_problem_incorrect(self):
@@ -1125,39 +1176,36 @@ def test_submit_problem_incorrect(self):
         block = CapaFactory.create(attempts=0)
 
         # Simulate marking the input incorrect
-        with patch('xmodule.capa.correctmap.CorrectMap.is_correct') as mock_is_correct:
+        with patch("xmodule.capa.correctmap.CorrectMap.is_correct") as mock_is_correct:
             mock_is_correct.return_value = False
 
             # Check the problem
-            get_request_dict = {CapaFactory.input_key(): '0'}
+            get_request_dict = {CapaFactory.input_key(): "0"}
             result = block.submit_problem(get_request_dict)
 
         # Expect that the problem is marked correct
-        assert result['success'] == 'incorrect'
+        assert result["success"] == "incorrect"
 
         # Expect that the number of attempts is incremented by 1
         assert block.attempts == 1
         # and that this is considered the first attempt
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_submit_problem_closed(self):
         block = CapaFactory.create(attempts=3)
 
         # Problem closed -- cannot submit
         # Simulate that ProblemBlock.closed() always returns True
-        with patch('xmodule.capa_block.ProblemBlock.closed') as mock_closed:
+        with patch("xmodule.capa_block.ProblemBlock.closed") as mock_closed:
             mock_closed.return_value = True
             with pytest.raises(xmodule.exceptions.NotFoundError):
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 block.submit_problem(get_request_dict)
 
         # Expect that number of attempts NOT incremented
         assert block.attempts == 3
 
-    @ddt.data(
-        RANDOMIZATION.ALWAYS,
-        'true'
-    )
+    @ddt.data(RANDOMIZATION.ALWAYS, "true")
     def test_submit_problem_resubmitted_with_randomize(self, rerandomize):
         # Randomize turned on
         block = CapaFactory.create(rerandomize=rerandomize, attempts=0)
@@ -1167,55 +1215,49 @@ def test_submit_problem_resubmitted_with_randomize(self, rerandomize):
 
         # Expect that we cannot submit
         with pytest.raises(xmodule.exceptions.NotFoundError):
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
             block.submit_problem(get_request_dict)
 
         # Expect that number of attempts NOT incremented
         assert block.attempts == 0
 
-    @ddt.data(
-        RANDOMIZATION.NEVER,
-        'false',
-        RANDOMIZATION.PER_STUDENT
-    )
+    @ddt.data(RANDOMIZATION.NEVER, "false", RANDOMIZATION.PER_STUDENT)
     def test_submit_problem_resubmitted_no_randomize(self, rerandomize):
         # Randomize turned off
         block = CapaFactory.create(rerandomize=rerandomize, attempts=0, done=True)
 
         # Expect that we can submit successfully
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         result = block.submit_problem(get_request_dict)
 
-        assert result['success'] == 'correct'
+        assert result["success"] == "correct"
 
         # Expect that number of attempts IS incremented, still same attempt
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_submit_problem_queued(self):
         block = CapaFactory.create(attempts=1)
 
         # Simulate that the problem is queued
         multipatch = patch.multiple(
-            'xmodule.capa.capa_problem.LoncapaProblem',
-            is_queued=DEFAULT,
-            get_recentmost_queuetime=DEFAULT
+            "xmodule.capa.capa_problem.LoncapaProblem", is_queued=DEFAULT, get_recentmost_queuetime=DEFAULT
         )
         with multipatch as values:
-            values['is_queued'].return_value = True
-            values['get_recentmost_queuetime'].return_value = datetime.datetime.now(UTC)
+            values["is_queued"].return_value = True
+            values["get_recentmost_queuetime"].return_value = datetime.datetime.now(UTC)
 
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
             result = block.submit_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
-            assert 'You must wait' in result['success']
+            assert "You must wait" in result["success"]
 
         # Expect that the number of attempts is NOT incremented
         assert block.attempts == 1
 
     @pytest.mark.django_db
-    @patch.object(XQueueInterface, '_http_post')
+    @patch.object(XQueueInterface, "_http_post")
     def test_submit_problem_with_files(self, mock_xqueue_post):
         # Check a problem with uploaded files, using the submit_problem API.
         # pylint: disable=protected-access
@@ -1235,7 +1277,7 @@ def test_submit_problem_with_files(self, mock_xqueue_post):
         # Create a request dictionary for submit_problem.
         get_request_dict = {
             CapaFactoryWithFiles.input_key(response_num=2): fileobjs,
-            CapaFactoryWithFiles.input_key(response_num=3): 'None',
+            CapaFactoryWithFiles.input_key(response_num=3): "None",
         }
 
         block.submit_problem(get_request_dict)
@@ -1261,12 +1303,12 @@ def test_submit_problem_with_files(self, mock_xqueue_post):
 
         assert mock_xqueue_post.call_count == 1
         _, kwargs = mock_xqueue_post.call_args
-        self.assertCountEqual(fpaths, list(kwargs['files'].keys()))
-        for fpath, fileobj in kwargs['files'].items():
+        self.assertCountEqual(fpaths, list(kwargs["files"].keys()))
+        for fpath, fileobj in kwargs["files"].items():
             assert fpath == fileobj.name
 
     @pytest.mark.django_db
-    @patch.object(XQueueInterface, '_http_post')
+    @patch.object(XQueueInterface, "_http_post")
     def test_submit_problem_with_files_as_xblock(self, mock_xqueue_post):
         # Check a problem with uploaded files, using the XBlock API.
         # pylint: disable=protected-access
@@ -1287,78 +1329,75 @@ def test_submit_problem_with_files_as_xblock(self, mock_xqueue_post):
         post_data = []
         for fname, fileobj in zip(fnames, fileobjs):
             post_data.append((CapaFactoryWithFiles.input_key(response_num=2), (fname, fileobj)))
-        post_data.append((CapaFactoryWithFiles.input_key(response_num=3), 'None'))
-        request = webob.Request.blank("/some/fake/url", POST=post_data, content_type='multipart/form-data')
+        post_data.append((CapaFactoryWithFiles.input_key(response_num=3), "None"))
+        request = webob.Request.blank("/some/fake/url", POST=post_data, content_type="multipart/form-data")
 
-        block.handle('xmodule_handler', request, 'problem_check')
+        block.handle("xmodule_handler", request, "problem_check")
 
         assert mock_xqueue_post.call_count == 1
         _, kwargs = mock_xqueue_post.call_args
-        self.assertCountEqual(fnames, list(kwargs['files'].keys()))
-        for fpath, fileobj in kwargs['files'].items():
+        self.assertCountEqual(fnames, list(kwargs["files"].keys()))
+        for fpath, fileobj in kwargs["files"].items():
             assert fpath == fileobj.name
 
     def test_submit_problem_error(self):
 
         # Try each exception that capa_block should handle
-        exception_classes = [StudentInputError,
-                             LoncapaProblemError,
-                             ResponseError]
+        exception_classes = [StudentInputError, LoncapaProblemError, ResponseError]
         for exception_class in exception_classes:
             # Create the block
             block = CapaFactory.create(attempts=1, user_is_staff=False)
 
             # Simulate answering a problem that raises the exception
-            with patch('xmodule.capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
-                mock_grade.side_effect = exception_class('test error')
+            with patch("xmodule.capa.capa_problem.LoncapaProblem.grade_answers") as mock_grade:
+                mock_grade.side_effect = exception_class("test error")
 
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 result = block.submit_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
-            expected_msg = 'test error'
+            expected_msg = "test error"
 
-            assert expected_msg == result['success']
+            assert expected_msg == result["success"]
 
             # Expect that the number of attempts is NOT incremented
             assert block.attempts == 1
             # but that this was considered attempt number 2 for grading purposes
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
 
     def test_submit_problem_error_with_codejail_exception(self):
 
         # Try each exception that capa_block should handle
-        exception_classes = [StudentInputError,
-                             LoncapaProblemError,
-                             ResponseError]
+        exception_classes = [StudentInputError, LoncapaProblemError, ResponseError]
         for exception_class in exception_classes:
 
             # Create the block
             block = CapaFactory.create(attempts=1, user_is_staff=False)
 
             # Simulate a codejail exception "Exception: Couldn't execute jailed code"
-            with patch('xmodule.capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
+            with patch("xmodule.capa.capa_problem.LoncapaProblem.grade_answers") as mock_grade:
                 try:
                     raise ResponseError(
-                        'Couldn\'t execute jailed code: stdout: \'\', '
-                        'stderr: \'Traceback (most recent call last):\\n'
+                        "Couldn't execute jailed code: stdout: '', "
+                        "stderr: 'Traceback (most recent call last):\\n"
                         '  File "jailed_code", line 15, in <module>\\n'
                         '    exec code in g_dict\\n  File "<string>", line 67, in <module>\\n'
                         '  File "<string>", line 65, in check_func\\n'
-                        'Exception: Couldn\'t execute jailed code\\n\' with status code: 1', )
+                        "Exception: Couldn't execute jailed code\\n' with status code: 1",
+                    )
                 except ResponseError as err:
                     mock_grade.side_effect = exception_class(str(err))
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 result = block.submit_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success' without the text of the stack trace
-            expected_msg = 'Couldn\'t execute jailed code'
-            assert expected_msg == result['success']
+            expected_msg = "Couldn't execute jailed code"
+            assert expected_msg == result["success"]
 
             # Expect that the number of attempts is NOT incremented
             assert block.attempts == 1
             # but that this was considered the second attempt for grading purposes
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
 
     @override_settings(DEBUG=True)
     def test_submit_problem_other_errors(self):
@@ -1371,15 +1410,15 @@ def test_submit_problem_other_errors(self):
         block = CapaFactory.create(attempts=1, user_is_staff=False)
 
         # Simulate answering a problem that raises the exception
-        with patch('xmodule.capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
+        with patch("xmodule.capa.capa_problem.LoncapaProblem.grade_answers") as mock_grade:
             error_msg = "Superterrible error happened: ☠"
             mock_grade.side_effect = Exception(error_msg)
 
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
             result = block.submit_problem(get_request_dict)
 
         # Expect an AJAX alert message in 'success'
-        assert error_msg in result['success']
+        assert error_msg in result["success"]
 
     def test_submit_problem_zero_max_grade(self):
         """
@@ -1389,96 +1428,90 @@ def test_submit_problem_zero_max_grade(self):
         block = CapaFactory.create(attempts=1)
 
         # Override the problem score to have a total of zero.
-        block.lcp.get_score = lambda: {'score': 0, 'total': 0}
+        block.lcp.get_score = lambda: {"score": 0, "total": 0}
 
         # Check the problem
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
     def test_submit_problem_error_nonascii(self):
 
         # Try each exception that capa_block should handle
-        exception_classes = [StudentInputError,
-                             LoncapaProblemError,
-                             ResponseError]
+        exception_classes = [StudentInputError, LoncapaProblemError, ResponseError]
         for exception_class in exception_classes:
             # Create the block
             block = CapaFactory.create(attempts=1, user_is_staff=False)
 
             # Simulate answering a problem that raises the exception
-            with patch('xmodule.capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
+            with patch("xmodule.capa.capa_problem.LoncapaProblem.grade_answers") as mock_grade:
                 mock_grade.side_effect = exception_class("ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ")
 
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 result = block.submit_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
-            expected_msg = 'ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ'
+            expected_msg = "ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ"
 
-            assert expected_msg == result['success']
+            assert expected_msg == result["success"]
 
             # Expect that the number of attempts is NOT incremented
             assert block.attempts == 1
             # but that this was considered the second attempt for grading purposes
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
 
     def test_submit_problem_error_with_staff_user(self):
 
         # Try each exception that capa block should handle
-        for exception_class in [StudentInputError,
-                                LoncapaProblemError,
-                                ResponseError]:
+        for exception_class in [StudentInputError, LoncapaProblemError, ResponseError]:
             # Create the block
             block = CapaFactory.create(attempts=1, user_is_staff=True)
 
             # Simulate answering a problem that raises an exception
-            with patch('xmodule.capa.capa_problem.LoncapaProblem.grade_answers') as mock_grade:
-                mock_grade.side_effect = exception_class('test error')
+            with patch("xmodule.capa.capa_problem.LoncapaProblem.grade_answers") as mock_grade:
+                mock_grade.side_effect = exception_class("test error")
 
-                get_request_dict = {CapaFactory.input_key(): '3.14'}
+                get_request_dict = {CapaFactory.input_key(): "3.14"}
                 result = block.submit_problem(get_request_dict)
 
             # Expect an AJAX alert message in 'success'
-            assert 'test error' in result['success']
+            assert "test error" in result["success"]
 
             # We DO include traceback information for staff users
-            assert 'Traceback' in result['success']
+            assert "Traceback" in result["success"]
 
             # Expect that the number of attempts is NOT incremented
             assert block.attempts == 1
             # but that it was considered the second attempt for grading purposes
-            assert block.lcp.context['attempt'] == 2
+            assert block.lcp.context["attempt"] == 2
 
     @ddt.data(
-        ("never", True, None, 'submitted'),
-        ("never", False, None, 'submitted'),
-        ("past_due", True, None, 'submitted'),
-        ("past_due", False, None, 'submitted'),
-        ("always", True, 1, 'correct'),
-        ("always", False, 0, 'incorrect'),
+        ("never", True, None, "submitted"),
+        ("never", False, None, "submitted"),
+        ("past_due", True, None, "submitted"),
+        ("past_due", False, None, "submitted"),
+        ("always", True, 1, "correct"),
+        ("always", False, 0, "incorrect"),
     )
     @ddt.unpack
     def test_handle_ajax_show_correctness(self, show_correctness, is_correct, expected_score, expected_success):
-        block = CapaFactory.create(show_correctness=show_correctness,
-                                   due=self.tomorrow_str,
-                                   correct=is_correct)
+        block = CapaFactory.create(show_correctness=show_correctness, due=self.tomorrow_str, correct=is_correct)
 
         # Simulate marking the input correct/incorrect
-        with patch('xmodule.capa.correctmap.CorrectMap.is_correct') as mock_is_correct:
+        with patch("xmodule.capa.correctmap.CorrectMap.is_correct") as mock_is_correct:
             mock_is_correct.return_value = is_correct
 
             # Check the problem
-            get_request_dict = {CapaFactory.input_key(): '0'}
-            json_result = block.handle_ajax('problem_check', get_request_dict)
+            get_request_dict = {CapaFactory.input_key(): "0"}
+            json_result = block.handle_ajax("problem_check", get_request_dict)
             result = json.loads(json_result)
 
         # Expect that the AJAX result withholds correctness and score
-        assert result['current_score'] == expected_score
-        assert result['success'] == expected_success
+        assert result["current_score"] == expected_score
+        assert result["success"] == expected_success
 
         # Expect that the number of attempts is incremented by 1
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_reset_problem(self):
         block = CapaFactory.create(done=True)
@@ -1486,7 +1519,7 @@ def test_reset_problem(self):
         block.choose_new_seed = Mock(wraps=block.choose_new_seed)
 
         # Stub out HTML rendering
-        with patch('xmodule.capa_block.ProblemBlock.get_problem_html') as mock_html:
+        with patch("xmodule.capa_block.ProblemBlock.get_problem_html") as mock_html:
             mock_html.return_value = "<div>Test HTML</div>"
 
             # Reset the problem
@@ -1494,11 +1527,11 @@ def test_reset_problem(self):
             result = block.reset_problem(get_request_dict)
 
         # Expect that the request was successful
-        assert (('success' in result) and result['success'])
+        assert ("success" in result) and result["success"]
 
         # Expect that the problem HTML is retrieved
-        assert 'html' in result
-        assert result['html'] == '<div>Test HTML</div>'
+        assert "html" in result
+        assert result["html"] == "<div>Test HTML</div>"
 
         # Expect that the problem was reset
         block.new_lcp.assert_called_once_with(None)
@@ -1508,7 +1541,7 @@ def test_reset_problem_closed(self):
         block = CapaFactory.create(rerandomize=RANDOMIZATION.ALWAYS)
 
         # Simulate that the problem is closed
-        with patch('xmodule.capa_block.ProblemBlock.closed') as mock_closed:
+        with patch("xmodule.capa_block.ProblemBlock.closed") as mock_closed:
             mock_closed.return_value = True
 
             # Try to reset the problem
@@ -1516,7 +1549,7 @@ def test_reset_problem_closed(self):
             result = block.reset_problem(get_request_dict)
 
         # Expect that the problem was NOT reset
-        assert (('success' in result) and (not result['success']))
+        assert ("success" in result) and (not result["success"])
 
     def test_reset_problem_not_done(self):
         # Simulate that the problem is NOT done
@@ -1527,7 +1560,7 @@ def test_reset_problem_not_done(self):
         result = block.reset_problem(get_request_dict)
 
         # Expect that the problem was NOT reset
-        assert (('success' in result) and (not result['success']))
+        assert ("success" in result) and (not result["success"])
 
     def test_rescore_problem_correct(self):
 
@@ -1535,17 +1568,17 @@ def test_rescore_problem_correct(self):
 
         # Simulate that all answers are marked correct, no matter
         # what the input is, by patching LoncapaResponse.evaluate_answers()
-        with patch('xmodule.capa.responsetypes.LoncapaResponse.evaluate_answers') as mock_evaluate_answers:
+        with patch("xmodule.capa.responsetypes.LoncapaResponse.evaluate_answers") as mock_evaluate_answers:
             mock_evaluate_answers.return_value = CorrectMap(
                 answer_id=CapaFactory.answer_key(),
-                correctness='correct',
+                correctness="correct",
                 npoints=1,
             )
-            with patch('xmodule.capa.correctmap.CorrectMap.is_correct') as mock_is_correct:
+            with patch("xmodule.capa.correctmap.CorrectMap.is_correct") as mock_is_correct:
                 mock_is_correct.return_value = True
 
                 # Check the problem
-                get_request_dict = {CapaFactory.input_key(): '1'}
+                get_request_dict = {CapaFactory.input_key(): "1"}
                 block.submit_problem(get_request_dict)
             block.rescore(only_if_higher=False)
 
@@ -1555,7 +1588,7 @@ def test_rescore_problem_correct(self):
         # Expect that the number of attempts is not incremented
         assert block.attempts == 1
         # and that this was considered attempt number 1 for grading purposes
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_rescore_problem_additional_correct(self):
         # make sure it also works when new correct answer has been added
@@ -1563,17 +1596,17 @@ def test_rescore_problem_additional_correct(self):
         answer_id = CapaFactory.answer_key()
 
         # Check the problem
-        get_request_dict = {CapaFactory.input_key(): '1'}
+        get_request_dict = {CapaFactory.input_key(): "1"}
         result = block.submit_problem(get_request_dict)
 
         # Expect that the problem is marked incorrect and user didn't earn score
-        assert result['success'] == 'incorrect'
+        assert result["success"] == "incorrect"
         assert block.get_score() == (0, 1)
-        assert block.correct_map[answer_id]['correctness'] == 'incorrect'
+        assert block.correct_map[answer_id]["correctness"] == "incorrect"
 
         # Expect that the number of attempts has incremented to 1
         assert block.attempts == 1
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
         # Simulate that after making an incorrect answer to the correct answer
         # the new calculated score is (1,1)
@@ -1581,20 +1614,20 @@ def test_rescore_problem_additional_correct(self):
         # In case of rescore with only_if_higher=True it should update score of block
         # if previous score was lower
 
-        with patch('xmodule.capa.correctmap.CorrectMap.is_correct') as mock_is_correct:
+        with patch("xmodule.capa.correctmap.CorrectMap.is_correct") as mock_is_correct:
             mock_is_correct.return_value = True
             block.set_score(block.score_from_lcp(block.lcp))
-            with patch('xmodule.capa.responsetypes.NumericalResponse.get_staff_ans') as get_staff_ans:
+            with patch("xmodule.capa.responsetypes.NumericalResponse.get_staff_ans") as get_staff_ans:
                 get_staff_ans.return_value = 1 + 0j
                 block.rescore(only_if_higher=True)
 
         # Expect that the problem is marked correct and user earned the score
         assert block.get_score() == (1, 1)
-        assert block.correct_map[answer_id]['correctness'] == 'correct'
+        assert block.correct_map[answer_id]["correctness"] == "correct"
         # Expect that the number of attempts is not incremented
         assert block.attempts == 1
         # and hence that this was still considered the first attempt for grading purposes
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_rescore_problem_incorrect(self):
         # make sure it also works when attempts have been reset,
@@ -1603,8 +1636,8 @@ def test_rescore_problem_incorrect(self):
 
         # Simulate that all answers are marked incorrect, no matter
         # what the input is, by patching LoncapaResponse.evaluate_answers()
-        with patch('xmodule.capa.responsetypes.LoncapaResponse.evaluate_answers') as mock_evaluate_answers:
-            mock_evaluate_answers.return_value = CorrectMap(CapaFactory.answer_key(), 'incorrect')
+        with patch("xmodule.capa.responsetypes.LoncapaResponse.evaluate_answers") as mock_evaluate_answers:
+            mock_evaluate_answers.return_value = CorrectMap(CapaFactory.answer_key(), "incorrect")
             block.rescore(only_if_higher=False)
 
         # Expect that the problem is marked incorrect
@@ -1613,9 +1646,9 @@ def test_rescore_problem_incorrect(self):
         # Expect that the number of attempts is not incremented
         assert block.attempts == 0
         # and that this is treated as the first attempt for grading purposes
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
-    @patch('xmodule.capa_block.ProblemBlock.get_rescore_with_grading_method')
+    @patch("xmodule.capa_block.ProblemBlock.get_rescore_with_grading_method")
     def test_rescore_problem_with_grading_method_disable(self, mock_get_rescore: Mock):
         """
         Test the rescore method with grading method disabled.
@@ -1626,7 +1659,7 @@ def test_rescore_problem_with_grading_method_disable(self, mock_get_rescore: Moc
         block.rescore(only_if_higher=False)
 
         assert block.attempts == 0
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
         mock_get_rescore.assert_not_called()
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
@@ -1638,16 +1671,16 @@ def test_rescore_problem_with_grading_method_enable(self):
         block = CapaFactory.create(attempts=0, done=True)
 
         with patch.object(
-            ProblemBlock, 'get_rescore_with_grading_method', wraps=block.get_rescore_with_grading_method
+            ProblemBlock, "get_rescore_with_grading_method", wraps=block.get_rescore_with_grading_method
         ) as mock_get_rescore:
 
             block.rescore(only_if_higher=False)
 
             assert block.attempts == 0
-            assert block.lcp.context['attempt'] == 1
+            assert block.lcp.context["attempt"] == 1
             mock_get_rescore.assert_called()
 
-    @patch('xmodule.capa_block.ProblemBlock.publish_grade')
+    @patch("xmodule.capa_block.ProblemBlock.publish_grade")
     def test_rescore_problem_grading_method_disable_to_enable(self, mock_publish_grade: Mock):
         """
         Test the rescore method the grading method is disabled and then enabled.
@@ -1657,20 +1690,18 @@ def test_rescore_problem_grading_method_disable_to_enable(self, mock_publish_gra
         """
         block = CapaFactory.create(attempts=0, max_attempts=3)
 
-        get_request_dict = {CapaFactory.input_key(): '3.21'}
+        get_request_dict = {CapaFactory.input_key(): "3.21"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.45'}
+        get_request_dict = {CapaFactory.input_key(): "3.45"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         # Disabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=False
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=False
         ):
             # Score is the last score
             assert block.score == Score(raw_earned=1, raw_possible=1)
@@ -1678,46 +1709,38 @@ def test_rescore_problem_grading_method_disable_to_enable(self, mock_publish_gra
             block.rescore(only_if_higher=False)
 
             # Still Score is the last score
-            mock_publish_grade.assert_called_with(
-                score=Score(raw_earned=1, raw_possible=1), only_if_higher=False
-            )
+            mock_publish_grade.assert_called_with(score=Score(raw_earned=1, raw_possible=1), only_if_higher=False)
 
         # Enabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=True
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=True
         ):
             with patch(
-                'xmodule.capa.capa_problem.LoncapaProblem.is_grading_method_enabled',
+                "xmodule.capa.capa_problem.LoncapaProblem.is_grading_method_enabled",
                 new_callable=PropertyMock,
-                return_value=True
+                return_value=True,
             ):
                 # Change grading method to 'first_score'
-                block.grading_method = 'first_score'
+                block.grading_method = "first_score"
                 block.rescore(only_if_higher=False)
 
-                mock_publish_grade.assert_called_with(
-                    score=Score(raw_earned=0, raw_possible=1), only_if_higher=False
-                )
+                mock_publish_grade.assert_called_with(score=Score(raw_earned=0, raw_possible=1), only_if_higher=False)
 
                 # Change grading method to 'highest_score'
-                block.grading_method = 'highest_score'
+                block.grading_method = "highest_score"
                 block.rescore(only_if_higher=False)
 
-                mock_publish_grade.assert_called_with(
-                    score=Score(raw_earned=1, raw_possible=1), only_if_higher=False
-                )
+                mock_publish_grade.assert_called_with(score=Score(raw_earned=1, raw_possible=1), only_if_higher=False)
 
                 # Change grading method to 'average_score'
-                block.grading_method = 'average_score'
+                block.grading_method = "average_score"
                 block.rescore(only_if_higher=False)
 
                 mock_publish_grade.assert_called_with(
                     score=Score(raw_earned=0.33, raw_possible=1), only_if_higher=False
                 )
 
-    @patch('xmodule.capa_block.ProblemBlock.publish_grade')
+    @patch("xmodule.capa_block.ProblemBlock.publish_grade")
     def test_rescore_problem_grading_method_enable_to_disable(self, mock_publish_grade: Mock):
         """
         Test the rescore method the grading method is enabled and then disabled.
@@ -1727,48 +1750,42 @@ def test_rescore_problem_grading_method_enable_to_disable(self, mock_publish_gra
         """
         block = CapaFactory.create(attempts=0, max_attempts=3)
 
-        get_request_dict = {CapaFactory.input_key(): '3.21'}
+        get_request_dict = {CapaFactory.input_key(): "3.21"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.45'}
+        get_request_dict = {CapaFactory.input_key(): "3.45"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         # Enabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=True
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=True
         ):
             with patch(
-                'xmodule.capa.capa_problem.LoncapaProblem.is_grading_method_enabled',
+                "xmodule.capa.capa_problem.LoncapaProblem.is_grading_method_enabled",
                 new_callable=PropertyMock,
-                return_value=True
+                return_value=True,
             ):
                 # Grading method is 'last_score'
-                assert block.grading_method == 'last_score'
+                assert block.grading_method == "last_score"
                 assert block.score == Score(raw_earned=1, raw_possible=1)
 
                 # Change grading method to 'first_score'
-                block.grading_method = 'first_score'
+                block.grading_method = "first_score"
                 block.rescore(only_if_higher=False)
 
-                mock_publish_grade.assert_called_with(
-                    score=Score(raw_earned=0, raw_possible=1), only_if_higher=False
-                )
+                mock_publish_grade.assert_called_with(score=Score(raw_earned=0, raw_possible=1), only_if_higher=False)
 
                 # Change grading method to 'highest_score'
-                block.grading_method = 'highest_score'
+                block.grading_method = "highest_score"
                 block.rescore(only_if_higher=False)
 
-                mock_publish_grade.assert_called_with(
-                    score=Score(raw_earned=1, raw_possible=1), only_if_higher=False
-                )
+                mock_publish_grade.assert_called_with(score=Score(raw_earned=1, raw_possible=1), only_if_higher=False)
 
                 # Change grading method to 'average_score'
-                block.grading_method = 'average_score'
+                block.grading_method = "average_score"
                 block.rescore(only_if_higher=False)
 
                 mock_publish_grade.assert_called_with(
@@ -1777,16 +1794,14 @@ def test_rescore_problem_grading_method_enable_to_disable(self, mock_publish_gra
 
         # Disabled grading method
         with patch(
-            'xmodule.capa_block.ProblemBlock.is_grading_method_enabled',
-            new_callable=PropertyMock,
-            return_value=False
+            "xmodule.capa_block.ProblemBlock.is_grading_method_enabled", new_callable=PropertyMock, return_value=False
         ):
             block.rescore(only_if_higher=False)
             # The score is the last score
             assert block.score == Score(raw_earned=1, raw_possible=1)
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
-    @patch('xmodule.capa_block.ProblemBlock.publish_grade')
+    @patch("xmodule.capa_block.ProblemBlock.publish_grade")
     def test_rescore_problem_update_grading_method(self, mock_publish_grade: Mock):
         """
         Test the rescore method when the grading method is updated.
@@ -1796,42 +1811,36 @@ def test_rescore_problem_update_grading_method(self, mock_publish_grade: Mock):
         """
         block = CapaFactory.create(attempts=0, max_attempts=3)
 
-        get_request_dict = {CapaFactory.input_key(): '3.21'}
+        get_request_dict = {CapaFactory.input_key(): "3.21"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.45'}
+        get_request_dict = {CapaFactory.input_key(): "3.45"}
         block.submit_problem(get_request_dict)
 
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         # Grading method is 'last_score'
-        assert block.grading_method == 'last_score'
+        assert block.grading_method == "last_score"
         assert block.score == Score(raw_earned=1, raw_possible=1)
 
         # Change grading method to 'first_score'
-        block.grading_method = 'first_score'
+        block.grading_method = "first_score"
         block.rescore(only_if_higher=False)
 
-        mock_publish_grade.assert_called_with(
-            score=Score(raw_earned=0, raw_possible=1), only_if_higher=False
-        )
+        mock_publish_grade.assert_called_with(score=Score(raw_earned=0, raw_possible=1), only_if_higher=False)
 
         # Change grading method to 'highest_score'
-        block.grading_method = 'highest_score'
+        block.grading_method = "highest_score"
         block.rescore(only_if_higher=False)
 
-        mock_publish_grade.assert_called_with(
-            score=Score(raw_earned=1, raw_possible=1), only_if_higher=False
-        )
+        mock_publish_grade.assert_called_with(score=Score(raw_earned=1, raw_possible=1), only_if_higher=False)
 
         # Change grading method to 'average_score'
-        block.grading_method = 'average_score'
+        block.grading_method = "average_score"
         block.rescore(only_if_higher=False)
 
-        mock_publish_grade.assert_called_with(
-            score=Score(raw_earned=0.33, raw_possible=1), only_if_higher=False
-        )
+        mock_publish_grade.assert_called_with(score=Score(raw_earned=0.33, raw_possible=1), only_if_higher=False)
 
     def test_rescore_problem_not_done(self):
         # Simulate that the problem is NOT done
@@ -1845,7 +1854,7 @@ def test_rescore_problem_not_supported(self):
         block = CapaFactory.create(done=True)
 
         # Try to rescore the problem, and get exception
-        with patch('xmodule.capa.capa_problem.LoncapaProblem.supports_rescoring') as mock_supports_rescoring:
+        with patch("xmodule.capa.capa_problem.LoncapaProblem.supports_rescoring") as mock_supports_rescoring:
             mock_supports_rescoring.return_value = False
             with pytest.raises(NotImplementedError):
                 block.rescore(only_if_higher=False)
@@ -1855,10 +1864,10 @@ def test_calculate_score_list(self):
         Test that the `calculate_score_list` method returns the correct list of scores.
         """
         block = CapaFactory.create(correct=True)
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=1)
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=1)
         block.lcp.correct_map_history = [correct_map, correct_map]
 
-        with patch.object(block.lcp, 'calculate_score', return_value={'score': 1, 'total': 2}):
+        with patch.object(block.lcp, "calculate_score", return_value={"score": 1, "total": 2}):
             result = block.calculate_score_list()
             expected_result = [Score(raw_earned=1, raw_possible=2), Score(raw_earned=1, raw_possible=2)]
             self.assertEqual(result, expected_result)
@@ -1873,7 +1882,7 @@ def test_calculate_score_list_empty(self):
         block = CapaFactory.create(correct=True)
         block.lcp.correct_map_history = []
 
-        with patch.object(block.lcp, 'calculate_score', return_value=Mock()):
+        with patch.object(block.lcp, "calculate_score", return_value=Mock()):
             result = block.calculate_score_list()
             self.assertEqual(result, [])
             block.lcp.calculate_score.assert_not_called()
@@ -1886,21 +1895,21 @@ def test_update_correctness_list_updates_attempt(self):
 
         block.update_correctness_list()
 
-        self.assertEqual(block.lcp.context['attempt'], 1)
+        self.assertEqual(block.lcp.context["attempt"], 1)
 
     def test_update_correctness_list_with_history(self):
         """
         Test that the `update_correctness_list` method updates the correct map history.
         """
         block = CapaFactory.create(correct=True, attempts=2)
-        correct_map = CorrectMap(answer_id='1_2_1', correctness="correct", npoints=1)
-        student_answers = {'1_2_1': 'abcd'}
+        correct_map = CorrectMap(answer_id="1_2_1", correctness="correct", npoints=1)
+        student_answers = {"1_2_1": "abcd"}
         block.correct_map_history = [correct_map]
         block.student_answers_history = [student_answers]
 
-        with patch.object(block.lcp, 'get_grade_from_current_answers', return_value=correct_map):
+        with patch.object(block.lcp, "get_grade_from_current_answers", return_value=correct_map):
             block.update_correctness_list()
-            self.assertEqual(block.lcp.context['attempt'], 2)
+            self.assertEqual(block.lcp.context["attempt"], 2)
             block.lcp.get_grade_from_current_answers.assert_called_once_with(student_answers, correct_map)
             self.assertEqual(block.lcp.correct_map_history, [correct_map])
             self.assertEqual(block.lcp.correct_map.get_dict(), correct_map.get_dict())
@@ -1916,9 +1925,9 @@ def test_update_correctness_list_without_history(self):
         block.correct_map_history = []
         block.student_answers_history = []
 
-        with patch.object(block.lcp, 'get_grade_from_current_answers', return_value=Mock()):
+        with patch.object(block.lcp, "get_grade_from_current_answers", return_value=Mock()):
             block.update_correctness_list()
-            self.assertEqual(block.lcp.context['attempt'], 1)
+            self.assertEqual(block.lcp.context["attempt"], 1)
             block.lcp.get_grade_from_current_answers.assert_not_called()
 
     @override_settings(FEATURES=FEATURES_WITH_GRADING_METHOD_IN_PROBLEMS)
@@ -1927,9 +1936,9 @@ def test_get_rescore_with_grading_method(self):
         Test that the `get_rescore_with_grading_method` method returns the correct score.
         """
         block = CapaFactory.create(done=True, attempts=0, max_attempts=2)
-        get_request_dict = {CapaFactory.input_key(): '3.21'}
+        get_request_dict = {CapaFactory.input_key(): "3.21"}
         block.submit_problem(get_request_dict)
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         result = block.get_rescore_with_grading_method()
@@ -1942,9 +1951,9 @@ def test_get_score_with_grading_method(self):
         returns the correct score based on the grading method.
         """
         block = CapaFactory.create(done=True, attempts=0, max_attempts=2)
-        get_request_dict = {CapaFactory.input_key(): '3.21'}
+        get_request_dict = {CapaFactory.input_key(): "3.21"}
         block.submit_problem(get_request_dict)
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
         expected_score = Score(raw_earned=1, raw_possible=1)
 
@@ -1953,7 +1962,7 @@ def test_get_score_with_grading_method(self):
         self.assertEqual(score, expected_score)
         self.assertEqual(block.score, expected_score)
 
-    @patch('xmodule.capa_block.ProblemBlock.score_from_lcp')
+    @patch("xmodule.capa_block.ProblemBlock.score_from_lcp")
     def test_get_score_with_grading_method_updates_score(self, mock_score_from_lcp: Mock):
         """
         Test that the `get_score_with_grading_method` method returns the correct score.
@@ -1978,7 +1987,7 @@ def test_get_score_with_grading_method_calls_grading_method_handler(self):
         block = CapaFactory.create(attempts=1)
         current_score = Score(raw_earned=0, raw_possible=1)
 
-        with patch('xmodule.capa_block.GradingMethodHandler') as mock_handler:
+        with patch("xmodule.capa_block.GradingMethodHandler") as mock_handler:
             mock_handler.return_value.get_score.return_value = current_score
             block.get_score_with_grading_method(current_score)
             mock_handler.assert_called_once_with(
@@ -1993,6 +2002,7 @@ class CustomCapaFactory(CapaFactory):
             """
             A factory for creating a Capa problem with arbitrary xml.
             """
+
             sample_problem_xml = textwrap.dedent(xml)
 
         return CustomCapaFactory
@@ -2000,16 +2010,18 @@ class CustomCapaFactory(CapaFactory):
     def test_codejail_error_upon_problem_creation(self):
         # Simulate a codejail safe_exec failure upon problem creation.
         # Create a problem with some script attached.
-        xml_str = textwrap.dedent("""
+        xml_str = textwrap.dedent(
+            """
             <problem>
                 <script>test=True</script>
             </problem>
-        """)
+        """
+        )
         factory = self.capa_factory_for_problem_xml(xml_str)
 
         # When codejail safe_exec fails upon problem creation, a LoncapaProblemError should be raised.
         with pytest.raises(LoncapaProblemError):
-            with patch('xmodule.capa.capa_problem.safe_exec') as mock_safe_exec:
+            with patch("xmodule.capa.capa_problem.safe_exec") as mock_safe_exec:
                 mock_safe_exec.side_effect = SafeExecException()
                 factory.create()
 
@@ -2020,19 +2032,19 @@ def _rescore_problem_error_helper(self, exception_class):
         CapaFactory.answer_key()
 
         # Check the problem
-        get_request_dict = {CapaFactory.input_key(): '1'}
+        get_request_dict = {CapaFactory.input_key(): "1"}
         block.submit_problem(get_request_dict)
 
         # Simulate answering a problem that raises the exception
-        with patch('xmodule.capa.capa_problem.LoncapaProblem.get_grade_from_current_answers') as mock_rescore:
-            mock_rescore.side_effect = exception_class('test error \u03a9')
+        with patch("xmodule.capa.capa_problem.LoncapaProblem.get_grade_from_current_answers") as mock_rescore:
+            mock_rescore.side_effect = exception_class("test error \u03a9")
             with pytest.raises(exception_class):
                 block.rescore(only_if_higher=False)
 
         # Expect that the number of attempts is NOT incremented
         assert block.attempts == 1
         # and that this was considered the first attempt for grading purposes
-        assert block.lcp.context['attempt'] == 1
+        assert block.lcp.context["attempt"] == 1
 
     def test_rescore_problem_student_input_error(self):
         self._rescore_problem_error_helper(StudentInputError)
@@ -2047,68 +2059,61 @@ def test_save_problem(self):
         block = CapaFactory.create(done=False)
 
         # Save the problem
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         result = block.save_problem(get_request_dict)
 
         # Expect that answers are saved to the problem
-        expected_answers = {CapaFactory.answer_key(): '3.14'}
+        expected_answers = {CapaFactory.answer_key(): "3.14"}
         assert block.lcp.student_answers == expected_answers
 
         # Expect that the result is success
-        assert (('success' in result) and result['success'])
+        assert ("success" in result) and result["success"]
 
     def test_save_problem_closed(self):
         block = CapaFactory.create(done=False)
 
         # Simulate that the problem is closed
-        with patch('xmodule.capa_block.ProblemBlock.closed') as mock_closed:
+        with patch("xmodule.capa_block.ProblemBlock.closed") as mock_closed:
             mock_closed.return_value = True
 
             # Try to save the problem
-            get_request_dict = {CapaFactory.input_key(): '3.14'}
+            get_request_dict = {CapaFactory.input_key(): "3.14"}
             result = block.save_problem(get_request_dict)
 
         # Expect that the result is failure
-        assert (('success' in result) and (not result['success']))
+        assert ("success" in result) and (not result["success"])
 
-    @ddt.data(
-        RANDOMIZATION.ALWAYS,
-        'true'
-    )
+    @ddt.data(RANDOMIZATION.ALWAYS, "true")
     def test_save_problem_submitted_with_randomize(self, rerandomize):
         # Capa XModule treats 'always' and 'true' equivalently
         block = CapaFactory.create(rerandomize=rerandomize, done=True)
 
         # Try to save
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         result = block.save_problem(get_request_dict)
 
         # Expect that we cannot save
-        assert (('success' in result) and (not result['success']))
+        assert ("success" in result) and (not result["success"])
 
-    @ddt.data(
-        RANDOMIZATION.NEVER,
-        'false',
-        RANDOMIZATION.PER_STUDENT
-    )
+    @ddt.data(RANDOMIZATION.NEVER, "false", RANDOMIZATION.PER_STUDENT)
     def test_save_problem_submitted_no_randomize(self, rerandomize):
         # Capa XBlock treats 'false' and 'per_student' equivalently
         block = CapaFactory.create(rerandomize=rerandomize, done=True)
 
         # Try to save
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         result = block.save_problem(get_request_dict)
 
         # Expect that we succeed
-        assert (('success' in result) and result['success'])
+        assert ("success" in result) and result["success"]
 
     def test_submit_button_name(self):
         block = CapaFactory.create(attempts=0)
-        assert block.submit_button_name() == 'Submit'
+        assert block.submit_button_name() == "Submit"
 
     def test_submit_button_submitting_name(self):
         block = CapaFactory.create(attempts=1, max_attempts=10)
-        assert block.submit_button_submitting_name() == 'Submitting'
+        assert block.submit_button_submitting_name() == "Submitting"
 
     def test_should_enable_submit_button(self):
 
@@ -2249,34 +2254,25 @@ def test_should_show_save_button(self):
     def test_should_show_save_button_force_save_button(self):
         # If we're after the deadline, do NOT show the save button
         # even though we're forcing a save
-        block = CapaFactory.create(due=self.yesterday_str,
-                                   force_save_button="true",
-                                   done=True)
+        block = CapaFactory.create(due=self.yesterday_str, force_save_button="true", done=True)
         assert not block.should_show_save_button()
 
         # If the user is out of attempts, do NOT show the save button
         attempts = random.randint(1, 10)
-        block = CapaFactory.create(attempts=attempts,
-                                   max_attempts=attempts,
-                                   force_save_button="true",
-                                   done=True)
+        block = CapaFactory.create(attempts=attempts, max_attempts=attempts, force_save_button="true", done=True)
         assert not block.should_show_save_button()
 
         # Otherwise, if we force the save button,
         # then show it even if we would ordinarily
         # require a reset first
-        block = CapaFactory.create(force_save_button="true",
-                                   rerandomize=RANDOMIZATION.ALWAYS,
-                                   done=True)
+        block = CapaFactory.create(force_save_button="true", rerandomize=RANDOMIZATION.ALWAYS, done=True)
         assert block.should_show_save_button()
 
-        block = CapaFactory.create(force_save_button="true",
-                                   rerandomize="true",
-                                   done=True)
+        block = CapaFactory.create(force_save_button="true", rerandomize="true", done=True)
         assert block.should_show_save_button()
 
     def test_no_max_attempts(self):
-        block = CapaFactory.create(max_attempts='')
+        block = CapaFactory.create(max_attempts="")
         html = block.get_problem_html()
         assert html is not None
         # assert that we got here without exploding
@@ -2296,7 +2292,7 @@ def test_get_problem_html(self):
         block.should_show_save_button = Mock(return_value=show_save_button)
 
         # Patch the capa problem's HTML rendering
-        with patch('xmodule.capa.capa_problem.LoncapaProblem.get_html') as mock_html:
+        with patch("xmodule.capa.capa_problem.LoncapaProblem.get_html") as mock_html:
             mock_html.return_value = "<div>Test Problem HTML</div>"
 
             # Render the problem HTML
@@ -2306,21 +2302,21 @@ def test_get_problem_html(self):
             html_encapsulated = block.get_problem_html(encapsulate=True)
 
         # Expect that we get the rendered template back
-        assert html == '<div>Test Template HTML</div>'
+        assert html == "<div>Test Template HTML</div>"
 
         # Check the rendering context
         render_args, _ = render_template.call_args
         assert len(render_args) == 2
 
         template_name = render_args[0]
-        assert template_name == 'problem.html'
+        assert template_name == "problem.html"
 
         context = render_args[1]
-        assert context['problem']['html'] == '<div>Test Problem HTML</div>'
-        assert bool(context['should_enable_submit_button']) == enable_submit_button
-        assert bool(context['reset_button']) == show_reset_button
-        assert bool(context['save_button']) == show_save_button
-        assert not context['demand_hint_possible']
+        assert context["problem"]["html"] == "<div>Test Problem HTML</div>"
+        assert bool(context["should_enable_submit_button"]) == enable_submit_button
+        assert bool(context["reset_button"]) == show_reset_button
+        assert bool(context["save_button"]) == show_save_button
+        assert not context["demand_hint_possible"]
 
         # Assert that the encapsulated html contains the original html
         assert html in html_encapsulated
@@ -2348,21 +2344,21 @@ def test_demand_hint(self):
         block = CapaFactory.create(xml=self.demand_xml, render_template=render_template)
         block.get_problem_html()  # ignoring html result
         context = render_template.call_args[0][1]
-        assert context['demand_hint_possible']
-        assert context['should_enable_next_hint']
+        assert context["demand_hint_possible"]
+        assert context["should_enable_next_hint"]
 
         # Check the AJAX call that gets the hint by index
         result = block.get_demand_hint(0)
-        assert result['hint_index'] == 0
-        assert result['should_enable_next_hint']
+        assert result["hint_index"] == 0
+        assert result["should_enable_next_hint"]
 
         result = block.get_demand_hint(1)
-        assert result['hint_index'] == 1
-        assert not result['should_enable_next_hint']
+        assert result["hint_index"] == 1
+        assert not result["should_enable_next_hint"]
 
         result = block.get_demand_hint(2)  # here the server wraps around to index 0
-        assert result['hint_index'] == 0
-        assert result['should_enable_next_hint']
+        assert result["hint_index"] == 0
+        assert result["should_enable_next_hint"]
 
     def test_single_demand_hint(self):
         """
@@ -2386,13 +2382,13 @@ def test_single_demand_hint(self):
         block = CapaFactory.create(xml=test_xml, render_template=render_template)
         block.get_problem_html()  # ignoring html result
         context = render_template.call_args[0][1]
-        assert context['demand_hint_possible']
-        assert context['should_enable_next_hint']
+        assert context["demand_hint_possible"]
+        assert context["should_enable_next_hint"]
 
         # Check the AJAX call that gets the hint by index
         result = block.get_demand_hint(0)
-        assert result['hint_index'] == 0
-        assert not result['should_enable_next_hint']
+        assert result["hint_index"] == 0
+        assert not result["should_enable_next_hint"]
 
     def test_image_hint(self):
         """
@@ -2418,26 +2414,26 @@ def test_image_hint(self):
         block = CapaFactory.create(xml=test_xml, render_template=render_template)
         block.get_problem_html()  # ignoring html result
         context = render_template.call_args[0][1]
-        assert context['demand_hint_possible']
-        assert context['should_enable_next_hint']
+        assert context["demand_hint_possible"]
+        assert context["should_enable_next_hint"]
 
         # Check the AJAX call that gets the hint by index
         result = block.get_demand_hint(0)
-        assert result['hint_index'] == 0
-        assert not result['should_enable_next_hint']
+        assert result["hint_index"] == 0
+        assert not result["should_enable_next_hint"]
 
     def test_demand_hint_logging(self):
         """
         Test calling get_demand_hunt() results in an event being published.
         """
         block = CapaFactory.create(xml=self.demand_xml)
-        with patch.object(block.runtime, 'publish') as mock_publish:
+        with patch.object(block.runtime, "publish") as mock_publish:
             block.get_problem_html()
             block.get_demand_hint(0)
             mock_publish.assert_called_with(
-                block, 'edx.problem.hint.demandhint_displayed',
-                {'hint_index': 0, 'module_id': str(block.location),
-                 'hint_text': 'Demand 1', 'hint_len': 2}
+                block,
+                "edx.problem.hint.demandhint_displayed",
+                {"hint_index": 0, "module_id": str(block.location), "hint_text": "Demand 1", "hint_len": 2},
             )
 
     def test_input_state_consistency(self):
@@ -2477,7 +2473,7 @@ def test_get_problem_html_error(self):
         # Check the rendering context
         render_args, _ = render_template.call_args
         context = render_args[1]
-        assert 'error' in context['problem']['html']
+        assert "error" in context["problem"]["html"]
 
         # Expect that the block has created a new dummy problem with the error
         assert original_problem != block.lcp
@@ -2504,7 +2500,7 @@ def test_get_problem_html_error_preview(self):
         # Check the rendering context
         render_args, _ = render_template.call_args
         context = render_args[1]
-        assert error_msg in context['problem']['html']
+        assert error_msg in context["problem"]["html"]
 
     @override_settings(DEBUG=True)
     def test_get_problem_html_error_w_debug(self):
@@ -2527,15 +2523,10 @@ def test_get_problem_html_error_w_debug(self):
         # Check the rendering context
         render_args, _ = render_template.call_args
         context = render_args[1]
-        assert error_msg in context['problem']['html']
+        assert error_msg in context["problem"]["html"]
 
     @ddt.data(
-        'false',
-        'true',
-        RANDOMIZATION.NEVER,
-        RANDOMIZATION.PER_STUDENT,
-        RANDOMIZATION.ALWAYS,
-        RANDOMIZATION.ONRESET
+        "false", "true", RANDOMIZATION.NEVER, RANDOMIZATION.PER_STUDENT, RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET
     )
     def test_random_seed_no_change(self, rerandomize):
 
@@ -2554,7 +2545,7 @@ def test_random_seed_no_change(self, rerandomize):
             assert seed == 1, "Seed should always be 1 when rerandomize='%s'" % rerandomize
 
         # Check the problem
-        get_request_dict = {CapaFactory.input_key(): '3.14'}
+        get_request_dict = {CapaFactory.input_key(): "3.14"}
         block.submit_problem(get_request_dict)
 
         # Expect that the seed is the same
@@ -2567,12 +2558,7 @@ def test_random_seed_no_change(self, rerandomize):
         assert seed == block.seed
 
     @ddt.data(
-        'false',
-        'true',
-        RANDOMIZATION.NEVER,
-        RANDOMIZATION.PER_STUDENT,
-        RANDOMIZATION.ALWAYS,
-        RANDOMIZATION.ONRESET
+        "false", "true", RANDOMIZATION.NEVER, RANDOMIZATION.PER_STUDENT, RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET
     )
     def test_random_seed_with_reset(self, rerandomize):
         """
@@ -2597,13 +2583,13 @@ def _reset_and_get_seed(block):
             return block.seed
 
         def _retry_and_check(num_tries, test_func):
-            '''
+            """
             Returns True if *test_func* was successful
             (returned True) within *num_tries* attempts
 
             *test_func* must be a function
             of the form test_func() -> bool
-            '''
+            """
             success = False
             for __ in range(num_tries):
                 if test_func() is True:
@@ -2622,9 +2608,7 @@ def _retry_and_check(num_tries, test_func):
         # is set to 'never' -- it should still be 1
         # The seed also stays the same if we're randomizing
         # 'per_student': the same student should see the same problem
-        if rerandomize in [RANDOMIZATION.NEVER,
-                           'false',
-                           RANDOMIZATION.PER_STUDENT]:
+        if rerandomize in [RANDOMIZATION.NEVER, "false", RANDOMIZATION.PER_STUDENT]:
             assert seed == _reset_and_get_seed(block)
 
         # Otherwise, we expect the seed to change
@@ -2637,16 +2621,11 @@ def _retry_and_check(num_tries, test_func):
             success = _retry_and_check(60, lambda: _reset_and_get_seed(block) != seed)
 
             assert block.seed is not None
-            msg = 'Could not get a new seed from reset after 60 tries'
+            msg = "Could not get a new seed from reset after 60 tries"
             assert success, msg
 
     @ddt.data(
-        'false',
-        'true',
-        RANDOMIZATION.NEVER,
-        RANDOMIZATION.PER_STUDENT,
-        RANDOMIZATION.ALWAYS,
-        RANDOMIZATION.ONRESET
+        "false", "true", RANDOMIZATION.NEVER, RANDOMIZATION.PER_STUDENT, RANDOMIZATION.ALWAYS, RANDOMIZATION.ONRESET
     )
     def test_random_seed_with_reset_question_unsubmitted(self, rerandomize):
         """
@@ -2675,12 +2654,7 @@ def _reset_and_get_seed(block):
         # the seed should never change because the student hasn't finished the problem
         assert seed == _reset_and_get_seed(block)
 
-    @ddt.data(
-        RANDOMIZATION.ALWAYS,
-        RANDOMIZATION.PER_STUDENT,
-        'true',
-        RANDOMIZATION.ONRESET
-    )
+    @ddt.data(RANDOMIZATION.ALWAYS, RANDOMIZATION.PER_STUDENT, "true", RANDOMIZATION.ONRESET)
     def test_random_seed_bins(self, rerandomize):
         # Assert that we are limiting the number of possible seeds.
         # Get a bunch of seeds, they should all be in 0-999.
@@ -2690,8 +2664,8 @@ def test_random_seed_bins(self, rerandomize):
             assert 0 <= block.seed < 1000
             i -= 1
 
-    @patch('xmodule.capa_block.log')
-    @patch('xmodule.capa_block.Progress')
+    @patch("xmodule.capa_block.log")
+    @patch("xmodule.capa_block.Progress")
     def test_get_progress_error(self, mock_progress, mock_log):
         """
         Check that an exception given in `Progress` produces a `log.exception` call.
@@ -2701,10 +2675,10 @@ def test_get_progress_error(self, mock_progress, mock_log):
             mock_progress.side_effect = error_type
             block = CapaFactory.create()
             assert block.get_progress() is None
-            mock_log.exception.assert_called_once_with('Got bad progress')
+            mock_log.exception.assert_called_once_with("Got bad progress")
             mock_log.reset_mock()
 
-    @patch('xmodule.capa_block.Progress')
+    @patch("xmodule.capa_block.Progress")
     def test_get_progress_no_error_if_weight_zero(self, mock_progress):
         """
         Check that if the weight is 0 get_progress does not try to create a Progress object.
@@ -2716,7 +2690,7 @@ def test_get_progress_no_error_if_weight_zero(self, mock_progress):
         assert progress is None
         assert not mock_progress.called
 
-    @patch('xmodule.capa_block.Progress')
+    @patch("xmodule.capa_block.Progress")
     def test_get_progress_calculate_progress_fraction(self, mock_progress):
         """
         Check that score and total are calculated correctly for the progress fraction.
@@ -2744,9 +2718,7 @@ def test_get_display_progress_show_correctness(self, show_correctness, is_correc
         """
         Check that score and total are calculated correctly for the progress fraction.
         """
-        block = CapaFactory.create(correct=is_correct,
-                                   show_correctness=show_correctness,
-                                   due=self.tomorrow_str)
+        block = CapaFactory.create(correct=is_correct, show_correctness=show_correctness, due=self.tomorrow_str)
         block.weight = 1
         score, total = block.get_display_progress()
         assert score == expected_score
@@ -2766,10 +2738,11 @@ def test_get_problem(self):
         Check that get_problem() returns the expected dictionary.
         """
         block = CapaFactory.create()
-        assert block.get_problem('data') == {'html': block.get_problem_html(encapsulate=False)}
+        assert block.get_problem("data") == {"html": block.get_problem_html(encapsulate=False)}
 
     # Standard question with shuffle="true" used by a few tests
-    common_shuffle_xml = textwrap.dedent("""
+    common_shuffle_xml = textwrap.dedent(
+        """
         <problem>
         <multiplechoiceresponse>
           <choicegroup type="MultipleChoice" shuffle="true">
@@ -2780,7 +2753,8 @@ def test_get_problem(self):
           </choicegroup>
         </multiplechoiceresponse>
         </problem>
-    """)
+    """
+    )
 
     def test_check_unmask(self):
         """
@@ -2788,20 +2762,23 @@ def test_check_unmask(self):
         unmasked names should appear in the publish event_info.
         """
         block = CapaFactory.create(xml=self.common_shuffle_xml)
-        with patch.object(block.runtime, 'publish') as mock_publish:
-            get_request_dict = {CapaFactory.input_key(): 'choice_3'}  # the correct choice
+        with patch.object(block.runtime, "publish") as mock_publish:
+            get_request_dict = {CapaFactory.input_key(): "choice_3"}  # the correct choice
             block.submit_problem(get_request_dict)
             mock_call = mock_publish.mock_calls[1]
             event_info = mock_call[1][2]
-            assert event_info['answers'][CapaFactory.answer_key()] == 'choice_3'
+            assert event_info["answers"][CapaFactory.answer_key()] == "choice_3"
             # 'permutation' key added to record how problem was shown
-            assert event_info['permutation'][CapaFactory.answer_key()] ==\
-                   ('shuffle', ['choice_3', 'choice_1', 'choice_2', 'choice_0'])
-            assert event_info['success'] == 'correct'
+            assert event_info["permutation"][CapaFactory.answer_key()] == (
+                "shuffle",
+                ["choice_3", "choice_1", "choice_2", "choice_0"],
+            )
+            assert event_info["success"] == "correct"
 
     def test_check_unmask_answerpool(self):
         """Check answer-pool question publish uses unmasked names"""
-        xml = textwrap.dedent("""
+        xml = textwrap.dedent(
+            """
             <problem>
             <multiplechoiceresponse>
               <choicegroup type="MultipleChoice" answer-pool="4">
@@ -2812,25 +2789,28 @@ def test_check_unmask_answerpool(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         block = CapaFactory.create(xml=xml)
-        with patch.object(block.runtime, 'publish') as mock_publish:
-            get_request_dict = {CapaFactory.input_key(): 'choice_2'}  # mask_X form when masking enabled
+        with patch.object(block.runtime, "publish") as mock_publish:
+            get_request_dict = {CapaFactory.input_key(): "choice_2"}  # mask_X form when masking enabled
             block.submit_problem(get_request_dict)
             mock_call = mock_publish.mock_calls[1]
             event_info = mock_call[1][2]
-            assert event_info['answers'][CapaFactory.answer_key()] == 'choice_2'
+            assert event_info["answers"][CapaFactory.answer_key()] == "choice_2"
             # 'permutation' key added to record how problem was shown
-            assert event_info['permutation'][CapaFactory.answer_key()] ==\
-                   ('answerpool', ['choice_1', 'choice_3', 'choice_2', 'choice_0'])
-            assert event_info['success'] == 'incorrect'
+            assert event_info["permutation"][CapaFactory.answer_key()] == (
+                "answerpool",
+                ["choice_1", "choice_3", "choice_2", "choice_0"],
+            )
+            assert event_info["success"] == "incorrect"
 
     @ddt.unpack
     @ddt.data(
-        {'display_name': None, 'expected_display_name': 'problem'},
-        {'display_name': '', 'expected_display_name': 'problem'},
-        {'display_name': ' ', 'expected_display_name': 'problem'},
-        {'display_name': 'CAPA 101', 'expected_display_name': 'CAPA 101'}
+        {"display_name": None, "expected_display_name": "problem"},
+        {"display_name": "", "expected_display_name": "problem"},
+        {"display_name": " ", "expected_display_name": "problem"},
+        {"display_name": "CAPA 101", "expected_display_name": "CAPA 101"},
     )
     def test_problem_display_name_with_default(self, display_name, expected_display_name):
         """
@@ -2840,8 +2820,8 @@ def test_problem_display_name_with_default(self, display_name, expected_display_
         assert block.display_name_with_default == expected_display_name
 
     @ddt.data(
-        '',
-        '   ',
+        "",
+        "   ",
     )
     def test_problem_no_display_name(self, display_name):
         """
@@ -2852,12 +2832,13 @@ def test_problem_no_display_name(self, display_name):
         block.get_problem_html()
         render_args, _ = render_template.call_args
         context = render_args[1]
-        assert context['problem']['name'] == block.location.block_type
+        assert context["problem"]["name"] == block.location.block_type
 
 
 @ddt.ddt
 class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
-    sample_checkbox_problem_xml = textwrap.dedent("""
+    sample_checkbox_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>Title</p>
 
@@ -2888,9 +2869,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
             </solution>
 
         </problem>
-    """)
+    """
+    )
 
-    sample_dropdown_problem_xml = textwrap.dedent("""
+    sample_dropdown_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>Dropdown problems allow learners to select only one option from a list of options.</p>
 
@@ -2915,9 +2898,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
             </solution>
 
         </problem>
-    """)
+    """
+    )
 
-    sample_multichoice_problem_xml = textwrap.dedent("""
+    sample_multichoice_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>Multiple choice problems allow learners to select only one option.</p>
 
@@ -2951,9 +2936,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
             </solution>
 
         </problem>
-    """)
+    """
+    )
 
-    sample_numerical_input_problem_xml = textwrap.dedent("""
+    sample_numerical_input_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>In a numerical input problem, learners enter numbers or a specific and relatively simple mathematical
             expression. Learners enter the response in plain text, and the system then converts the text to a symbolic
@@ -2991,9 +2978,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
             </solution>
 
         </problem>
-    """)
+    """
+    )
 
-    sample_text_input_problem_xml = textwrap.dedent("""
+    sample_text_input_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>In text input problems, also known as "fill-in-the-blank" problems, learners enter text into a response
             field. The text can include letters and characters such as punctuation marks. The text that the learner
@@ -3023,9 +3012,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
             </solution>
 
         </problem>
-    """)
+    """
+    )
 
-    sample_checkboxes_with_hints_and_feedback_problem_xml = textwrap.dedent("""
+    sample_checkboxes_with_hints_and_feedback_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>You can provide feedback for each option in a checkbox problem, with distinct feedback depending on
             whether or not the learner selects that option.</p>
@@ -3076,9 +3067,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
               <hint>A fruit contains seeds of the plant.</hint>
             </demandhint>
         </problem>
-    """)
+    """
+    )
 
-    sample_dropdown_with_hints_and_feedback_problem_xml = textwrap.dedent("""
+    sample_dropdown_with_hints_and_feedback_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>You can provide feedback for each available option in a dropdown problem.</p>
 
@@ -3108,9 +3101,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
               <hint>A fruit contains seeds of the plant.</hint>
             </demandhint>
         </problem>
-    """)
+    """
+    )
 
-    sample_multichoice_with_hints_and_feedback_problem_xml = textwrap.dedent("""
+    sample_multichoice_with_hints_and_feedback_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>You can provide feedback for each option in a multiple choice problem.</p>
 
@@ -3141,9 +3136,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
               <hint>A fruit contains seeds of the plant.</hint>
             </demandhint>
         </problem>
-    """)
+    """
+    )
 
-    sample_numerical_input_with_hints_and_feedback_problem_xml = textwrap.dedent("""
+    sample_numerical_input_with_hints_and_feedback_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>You can provide feedback for correct answers in numerical input problems. You cannot provide feedback
             for incorrect answers.</p>
@@ -3177,9 +3174,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
               <hint>n is the count of items in the set.</hint>
             </demandhint>
         </problem>
-    """)
+    """
+    )
 
-    sample_text_input_with_hints_and_feedback_problem_xml = textwrap.dedent("""
+    sample_text_input_with_hints_and_feedback_problem_xml = textwrap.dedent(
+        """
         <problem>
             <p>You can provide feedback for the correct answer in text input problems, as well as for specific
             incorrect answers.</p>
@@ -3208,10 +3207,11 @@ class ProblemBlockXMLTest(unittest.TestCase):  # lint-amnesty, pylint: disable=m
               <hint>Consider all 50 states, not just the continental United States.</hint>
             </demandhint>
         </problem>
-    """)
+    """
+    )
 
     def _create_block(self, xml, name=None):
-        """ Creates a ProblemBlock to run test against """
+        """Creates a ProblemBlock to run test against"""
         block = CapaFactory.create()
         block.data = xml
         if name:
@@ -3220,18 +3220,20 @@ def _create_block(self, xml, name=None):
 
     @ddt.data(*sorted(responsetypes.registry.registered_tags()))
     def test_all_response_types(self, response_tag):
-        """ Tests that every registered response tag is correctly returned """
+        """Tests that every registered response tag is correctly returned"""
         xml = "<problem><{response_tag}></{response_tag}></problem>".format(response_tag=response_tag)
         name = "Some Capa Problem"
         block = self._create_block(xml, name=name)
         assert block.problem_types == {response_tag}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': [response_tag],
-                'content': {'display_name': name, 'capa_content': ''}}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": [response_tag],
+            "content": {"display_name": name, "capa_content": ""},
+        }
 
     def test_response_types_ignores_non_response_tags(self):
-        xml = textwrap.dedent("""
+        xml = textwrap.dedent(
+            """
             <problem>
             <p>Label</p>
             <div>Some comment</div>
@@ -3244,17 +3246,20 @@ def test_response_types_ignores_non_response_tags(self):
               </choicegroup>
             </multiplechoiceresponse>
             </problem>
-        """)
+        """
+        )
         name = "Test Capa Problem"
         block = self._create_block(xml, name=name)
-        assert block.problem_types == {'multiplechoiceresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['multiplechoiceresponse'],
-                'content': {'display_name': name, 'capa_content': 'Label Some comment Apple Banana Chocolate Donut'}}
+        assert block.problem_types == {"multiplechoiceresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["multiplechoiceresponse"],
+            "content": {"display_name": name, "capa_content": "Label Some comment Apple Banana Chocolate Donut"},
+        }
 
     def test_response_types_multiple_tags(self):
-        xml = textwrap.dedent("""
+        xml = textwrap.dedent(
+            """
             <problem>
                 <p>Label</p>
                 <div>Some comment</div>
@@ -3272,30 +3277,30 @@ def test_response_types_multiple_tags(self):
                     <optioninput options="('1','2')" correct="2"></optioninput>
                 </optionresponse>
             </problem>
-        """)
+        """
+        )
         name = "Other Test Capa Problem"
         block = self._create_block(xml, name=name)
-        assert block.problem_types == {'multiplechoiceresponse', 'optionresponse'}
+        assert block.problem_types == {"multiplechoiceresponse", "optionresponse"}
 
         # We are converting problem_types to a set to compare it later without taking into account the order
         # the reasoning behind is that the problem_types (property) is represented by dict and when it is converted
         # to list its ordering is different everytime.
 
         indexing_result = block.index_dictionary()
-        indexing_result['problem_types'] = set(indexing_result['problem_types'])
+        indexing_result["problem_types"] = set(indexing_result["problem_types"])
         self.assertDictEqual(
-            indexing_result, {
-                'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': {"optionresponse", "multiplechoiceresponse"},
-                'content': {
-                    'display_name': name,
-                    'capa_content': "Label Some comment Donut Buggy '1','2'"
-                },
-            }
+            indexing_result,
+            {
+                "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+                "problem_types": {"optionresponse", "multiplechoiceresponse"},
+                "content": {"display_name": name, "capa_content": "Label Some comment Donut Buggy '1','2'"},
+            },
         )
 
     def test_solutions_not_indexed(self):
-        xml = textwrap.dedent("""
+        xml = textwrap.dedent(
+            """
             <problem>
                 <solution>Test solution.</solution>
                 <solution explanation-id="solution0">Test solution with attribute.</solution>
@@ -3324,18 +3329,21 @@ def test_solutions_not_indexed(self):
                 <hint>Test hint.</hint>
                 <hintpart>Test hintpart.</hintpart>
             </problem>
-        """)
+        """
+        )
         name = "Blank Common Capa Problem"
         block = self._create_block(xml, name=name)
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': [],
-                'content': {'display_name': name, 'capa_content': ''}}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": [],
+            "content": {"display_name": name, "capa_content": ""},
+        }
 
     def test_indexing_checkboxes(self):
         name = "Checkboxes"
         block = self._create_block(self.sample_checkbox_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             Title
             Description
             Example
@@ -3346,32 +3354,38 @@ def test_indexing_checkboxes(self):
             French
             Hungarian
             Note: Make sure you select all of the correct options—there may be more than one!
-        """)
-        assert block.problem_types == {'choiceresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['choiceresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"choiceresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["choiceresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_dropdown(self):
         name = "Dropdown"
         block = self._create_block(self.sample_dropdown_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             Dropdown problems allow learners to select only one option from a list of options.
             Description
             You can use the following example problem as a model.
             Which of the following countries celebrates its independence on August 15? 'India','Spain','China','Bermuda'
-        """)
-        assert block.problem_types == {'optionresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['optionresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"optionresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["optionresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_multiple_choice(self):
         name = "Multiple Choice"
         block = self._create_block(self.sample_multichoice_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             Multiple choice problems allow learners to select only one option.
             When you add the problem, be sure to select Settings to specify a Display Name and other values.
             You can use the following example problem as a model.
@@ -3380,17 +3394,20 @@ def test_indexing_multiple_choice(self):
             Germany
             Indonesia
             Russia
-        """)
-        assert block.problem_types == {'multiplechoiceresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['multiplechoiceresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"multiplechoiceresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["multiplechoiceresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_numerical_input(self):
         name = "Numerical Input"
         block = self._create_block(self.sample_numerical_input_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             In a numerical input problem, learners enter numbers or a specific and relatively simple mathematical
             expression. Learners enter the response in plain text, and the system then converts the text to a symbolic
             expression that learners can see below the response field.
@@ -3402,17 +3419,20 @@ def test_indexing_numerical_input(self):
             You can use the following example problems as models.
             How many miles away from Earth is the sun? Use scientific notation to answer.
             The square of what number is -100?
-        """)
-        assert block.problem_types == {'numericalresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['numericalresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"numericalresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["numericalresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_text_input(self):
         name = "Text Input"
         block = self._create_block(self.sample_text_input_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             In text input problems, also known as "fill-in-the-blank" problems, learners enter text into a response
             field. The text can include letters and characters such as punctuation marks. The text that the learner
             enters must match your specified answer text exactly. You can specify more than one correct answer.
@@ -3421,31 +3441,36 @@ def test_indexing_text_input(self):
             apply.
             You can use the following example problem as a model.
             What was the first post-secondary school in China to allow both male and female students?
-        """)
-        assert block.problem_types == {'stringresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['stringresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"stringresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["stringresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_non_latin_problem(self):
-        sample_text_input_problem_xml = textwrap.dedent("""
+        sample_text_input_problem_xml = textwrap.dedent(
+            """
             <problem>
                 <script type="text/python">FX1_VAL='Καλημέρα'</script>
                 <p>Δοκιμή με μεταβλητές με Ελληνικούς χαρακτήρες μέσα σε python: $FX1_VAL</p>
             </problem>
-        """)
+        """
+        )
         name = "Non latin Input"
         block = self._create_block(sample_text_input_problem_xml, name=name)
         capa_content = "Δοκιμή με μεταβλητές με Ελληνικούς χαρακτήρες μέσα σε python: $FX1_VAL"
 
         block_dict = block.index_dictionary()
-        assert block_dict['content']['capa_content'] == smart_str(capa_content)
+        assert block_dict["content"]["capa_content"] == smart_str(capa_content)
 
     def test_indexing_checkboxes_with_hints_and_feedback(self):
         name = "Checkboxes with Hints and Feedback"
         block = self._create_block(self.sample_checkboxes_with_hints_and_feedback_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             You can provide feedback for each option in a checkbox problem, with distinct feedback depending on
             whether or not the learner selects that option.
             You can also provide compound feedback for a specific combination of answers. For example, if you have
@@ -3459,17 +3484,20 @@ def test_indexing_checkboxes_with_hints_and_feedback(self):
             pumpkin
             potato
             tomato
-        """)
-        assert block.problem_types == {'choiceresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['choiceresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"choiceresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["choiceresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_dropdown_with_hints_and_feedback(self):
         name = "Dropdown with Hints and Feedback"
         block = self._create_block(self.sample_dropdown_with_hints_and_feedback_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             You can provide feedback for each available option in a dropdown problem.
             You can also add hints for learners.
             Be sure to select Settings to specify a Display Name and other values that apply.
@@ -3479,17 +3507,20 @@ def test_indexing_dropdown_with_hints_and_feedback(self):
             pumpkin
             potato
             tomato
-        """)
-        assert block.problem_types == {'optionresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['optionresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"optionresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["optionresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_multiple_choice_with_hints_and_feedback(self):
         name = "Multiple Choice with Hints and Feedback"
         block = self._create_block(self.sample_multichoice_with_hints_and_feedback_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             You can provide feedback for each option in a multiple choice problem.
             You can also add hints for learners.
             Be sure to select Settings to specify a Display Name and other values that apply.
@@ -3499,17 +3530,20 @@ def test_indexing_multiple_choice_with_hints_and_feedback(self):
             pumpkin
             potato
             tomato
-        """)
-        assert block.problem_types == {'multiplechoiceresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['multiplechoiceresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"multiplechoiceresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["multiplechoiceresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_numerical_input_with_hints_and_feedback(self):
         name = "Numerical Input with Hints and Feedback"
         block = self._create_block(self.sample_numerical_input_with_hints_and_feedback_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             You can provide feedback for correct answers in numerical input problems. You cannot provide feedback
             for incorrect answers.
             Use feedback for the correct answer to reinforce the process for arriving at the numerical value.
@@ -3517,17 +3551,20 @@ def test_indexing_numerical_input_with_hints_and_feedback(self):
             Be sure to select Settings to specify a Display Name and other values that apply.
             Use the following example problem as a model.
             What is the arithmetic mean for the following set of numbers? (1, 5, 6, 3, 5)
-        """)
-        assert block.problem_types == {'numericalresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['numericalresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"numericalresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["numericalresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_text_input_with_hints_and_feedback(self):
         name = "Text Input with Hints and Feedback"
         block = self._create_block(self.sample_text_input_with_hints_and_feedback_problem_xml, name=name)
-        capa_content = textwrap.dedent("""
+        capa_content = textwrap.dedent(
+            """
             You can provide feedback for the correct answer in text input problems, as well as for specific
             incorrect answers.
             Use feedback on expected incorrect answers to address common misconceptions and to provide guidance on
@@ -3535,15 +3572,18 @@ def test_indexing_text_input_with_hints_and_feedback(self):
             Be sure to select Settings to specify a Display Name and other values that apply.
             Use the following example problem as a model.
             Which U.S. state has the largest land area?
-        """)
-        assert block.problem_types == {'stringresponse'}
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': ['stringresponse'],
-                'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ').strip()}}
+        """
+        )
+        assert block.problem_types == {"stringresponse"}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["stringresponse"],
+            "content": {"display_name": name, "capa_content": capa_content.replace("\n", " ").strip()},
+        }
 
     def test_indexing_problem_with_html_tags(self):
-        sample_problem_xml = textwrap.dedent("""
+        sample_problem_xml = textwrap.dedent(
+            """
             <problem>
                 <style>p {left: 10px;}</style>
                 <!-- Beginning of the html -->
@@ -3556,14 +3596,16 @@ def test_indexing_problem_with_html_tags(self):
                     var alive;
                 </script>
             </problem>
-        """)
+        """
+        )
         name = "Mixed business"
         block = self._create_block(sample_problem_xml, name=name)
         capa_content = "This has HTML comment in it. HTML end."
-        assert block.index_dictionary() ==\
-               {'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-                'problem_types': [],
-                'content': {'display_name': name, 'capa_content': capa_content}}
+        assert block.index_dictionary() == {
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": [],
+            "content": {"display_name": name, "capa_content": capa_content},
+        }
 
     def test_indexing_problem_with_no_whitespace_between_tags(self):
         """
@@ -3571,10 +3613,10 @@ def test_indexing_problem_with_no_whitespace_between_tags(self):
         We want to make sure the index description is still readable and has whitespace.
         """
         sample_problem_xml = (
-            "<problem display_name=\"No spaces\">"
+            '<problem display_name="No spaces">'
             "<choiceresponse><div>Question text here.</div><checkboxgroup>"
-            "<choice correct=\"true\"><div>Option A</div></choice>"
-            "<choice correct=\"false\"><div>Option B</div></choice>"
+            '<choice correct="true"><div>Option A</div></choice>'
+            '<choice correct="false"><div>Option B</div></choice>'
             "</checkboxgroup></choiceresponse>"
             "</problem>"
         )
@@ -3582,9 +3624,9 @@ def test_indexing_problem_with_no_whitespace_between_tags(self):
         block = self._create_block(sample_problem_xml, name=name)
         capa_content = "Question text here. Option A Option B"
         assert block.index_dictionary() == {
-            'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
-            'problem_types': ['choiceresponse'],
-            'content': {'display_name': name, 'capa_content': capa_content},
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": ["choiceresponse"],
+            "content": {"display_name": name, "capa_content": capa_content},
         }
 
     def test_invalid_xml_handling(self):
@@ -3592,10 +3634,12 @@ def test_invalid_xml_handling(self):
         Tests to confirm that invalid XML throws errors during xblock creation,
         so as not to allow bad data into modulestore.
         """
-        sample_invalid_xml = textwrap.dedent("""
+        sample_invalid_xml = textwrap.dedent(
+            """
             <problem>
             </proble-oh no my finger broke and I can't close the problem tag properly...
-        """)
+        """
+        )
         with pytest.raises(etree.XMLSyntaxError):
             self._create_block(sample_invalid_xml, name="Invalid XML")
 
@@ -3603,7 +3647,8 @@ def test_invalid_dropdown_xml(self):
         """
         Verify the capa problem cannot be created from dropdown xml with multiple correct answers.
         """
-        problem_xml = textwrap.dedent("""
+        problem_xml = textwrap.dedent(
+            """
         <problem>
             <optionresponse>
               <p>You can use this template as a guide to the simple editor markdown and OLX markup to use for dropdown
@@ -3617,7 +3662,8 @@ def test_invalid_dropdown_xml(self):
               </optioninput>
             </optionresponse>
         </problem>
-        """)
+        """
+        )
         with pytest.raises(Exception):
             CapaFactory.create(xml=problem_xml)
 
@@ -3629,9 +3675,9 @@ def test_default(self):
         Check that complex numbers can be encoded into JSON.
         """
         complex_num = 1 - 1j
-        expected_str = '1-1*j'
+        expected_str = "1-1*j"
         json_str = json.dumps(complex_num, cls=ComplexEncoder)
-        assert expected_str == json_str[1:(- 1)]
+        assert expected_str == json_str[1:(-1)]
         # ignore quotes
 
 
@@ -3677,50 +3723,61 @@ def test_choice_answer_text(self):
             """
 
         # Whitespace screws up comparisons
-        xml = ''.join(line.strip() for line in xml.split('\n'))
+        xml = "".join(line.strip() for line in xml.split("\n"))
         factory = self.capa_factory_for_problem_xml(xml)
         block = factory.create()
 
         answer_input_dict = {
-            factory.input_key(2): 'blue',
-            factory.input_key(3): 'choice_0',
-            factory.input_key(4): ['choice_0', 'choice_1'],
+            factory.input_key(2): "blue",
+            factory.input_key(3): "choice_0",
+            factory.input_key(4): ["choice_0", "choice_1"],
         }
         event = self.get_event_for_answers(block, answer_input_dict)
 
-        assert event['submission'] ==\
-               {factory.answer_key(2): {'question': 'What color is the open ocean on a sunny day?',
-                                        'answer': 'blue', 'response_type': 'optionresponse',
-                                        'input_type': 'optioninput',
-                                        'correct': True,
-                                        'group_label': '',
-                                        'variant': ''},
-                factory.answer_key(3): {'question': 'Which piece of furniture is built for sitting?',
-                                        'answer': '<text>a table</text>',
-                                        'response_type': 'multiplechoiceresponse',
-                                        'input_type': 'choicegroup',
-                                        'correct': False,
-                                        'group_label': '',
-                                        'variant': ''},
-                factory.answer_key(4): {'question': 'Which of the following are musical instruments?',
-                                        'answer': ['a piano', 'a tree'],
-                                        'response_type': 'choiceresponse',
-                                        'input_type': 'checkboxgroup',
-                                        'correct': False,
-                                        'group_label': '',
-                                        'variant': ''}}
+        assert event["submission"] == {
+            factory.answer_key(2): {
+                "question": "What color is the open ocean on a sunny day?",
+                "answer": "blue",
+                "response_type": "optionresponse",
+                "input_type": "optioninput",
+                "correct": True,
+                "group_label": "",
+                "variant": "",
+            },
+            factory.answer_key(3): {
+                "question": "Which piece of furniture is built for sitting?",
+                "answer": "<text>a table</text>",
+                "response_type": "multiplechoiceresponse",
+                "input_type": "choicegroup",
+                "correct": False,
+                "group_label": "",
+                "variant": "",
+            },
+            factory.answer_key(4): {
+                "question": "Which of the following are musical instruments?",
+                "answer": ["a piano", "a tree"],
+                "response_type": "choiceresponse",
+                "input_type": "checkboxgroup",
+                "correct": False,
+                "group_label": "",
+                "variant": "",
+            },
+        }
 
     def capa_factory_for_problem_xml(self, xml):  # lint-amnesty, pylint: disable=missing-function-docstring
         class CustomCapaFactory(CapaFactory):
             """
             A factory for creating a Capa problem with arbitrary xml.
             """
+
             sample_problem_xml = textwrap.dedent(xml)
 
         return CustomCapaFactory
 
-    def get_event_for_answers(self, block, answer_input_dict):  # lint-amnesty, pylint: disable=missing-function-docstring
-        with patch.object(block.runtime, 'publish') as mock_publish:
+    def get_event_for_answers(
+        self, block, answer_input_dict
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring
+        with patch.object(block.runtime, "publish") as mock_publish:
             block.submit_problem(answer_input_dict)
 
             assert len(mock_publish.mock_calls) >= 2
@@ -3734,24 +3791,27 @@ def test_numerical_textline(self):
         factory = CapaFactory
         block = factory.create()
 
-        answer_input_dict = {
-            factory.input_key(2): '3.14'
-        }
+        answer_input_dict = {factory.input_key(2): "3.14"}
 
         event = self.get_event_for_answers(block, answer_input_dict)
-        assert event['submission'] ==\
-               {factory.answer_key(2): {'question': '', 'answer': '3.14',
-                                        'response_type': 'numericalresponse',
-                                        'input_type': 'textline',
-                                        'correct': True,
-                                        'group_label': '',
-                                        'variant': ''}}
+        assert event["submission"] == {
+            factory.answer_key(2): {
+                "question": "",
+                "answer": "3.14",
+                "response_type": "numericalresponse",
+                "input_type": "textline",
+                "correct": True,
+                "group_label": "",
+                "variant": "",
+            }
+        }
 
     def test_multiple_inputs(self):
-        group_label = 'Choose the correct color'
-        input1_label = 'What color is the sky?'
-        input2_label = 'What color are pine needles?'
-        factory = self.capa_factory_for_problem_xml("""\
+        group_label = "Choose the correct color"
+        input1_label = "What color is the sky?"
+        input2_label = "What color are pine needles?"
+        factory = self.capa_factory_for_problem_xml(
+            """\
             <problem display_name="Multiple Inputs">
               <optionresponse>
                 <label>{}</label>
@@ -3759,34 +3819,45 @@ def test_multiple_inputs(self):
                 <optioninput options="('yellow','blue','green')" correct="green" label="{}"/>
               </optionresponse>
             </problem>
-            """.format(group_label, input1_label, input2_label))
+            """.format(
+                group_label, input1_label, input2_label
+            )
+        )
         block = factory.create()
         answer_input_dict = {
-            factory.input_key(2, 1): 'blue',
-            factory.input_key(2, 2): 'yellow',
+            factory.input_key(2, 1): "blue",
+            factory.input_key(2, 2): "yellow",
         }
 
         event = self.get_event_for_answers(block, answer_input_dict)
-        assert event['submission'] ==\
-               {factory.answer_key(2, 1): {'group_label': group_label,
-                                           'question': input1_label,
-                                           'answer': 'blue',
-                                           'response_type': 'optionresponse',
-                                           'input_type': 'optioninput',
-                                           'correct': True, 'variant': ''},
-                factory.answer_key(2, 2): {'group_label': group_label,
-                                           'question': input2_label,
-                                           'answer': 'yellow',
-                                           'response_type': 'optionresponse',
-                                           'input_type': 'optioninput',
-                                           'correct': False, 'variant': ''}}
+        assert event["submission"] == {
+            factory.answer_key(2, 1): {
+                "group_label": group_label,
+                "question": input1_label,
+                "answer": "blue",
+                "response_type": "optionresponse",
+                "input_type": "optioninput",
+                "correct": True,
+                "variant": "",
+            },
+            factory.answer_key(2, 2): {
+                "group_label": group_label,
+                "question": input2_label,
+                "answer": "yellow",
+                "response_type": "optionresponse",
+                "input_type": "optioninput",
+                "correct": False,
+                "variant": "",
+            },
+        }
 
     def test_optioninput_extended_xml(self):
         """Test the new XML form of writing with <option> tag instead of options= attribute."""
-        group_label = 'Are you the Gatekeeper?'
-        input1_label = 'input 1 label'
-        input2_label = 'input 2 label'
-        factory = self.capa_factory_for_problem_xml("""\
+        group_label = "Are you the Gatekeeper?"
+        input1_label = "input 1 label"
+        input2_label = "input 2 label"
+        factory = self.capa_factory_for_problem_xml(
+            """\
             <problem display_name="Woo Hoo">
                 <optionresponse>
                    <label>{}</label>
@@ -3821,49 +3892,60 @@ def test_optioninput_extended_xml(self):
                    </optioninput>
                  </optionresponse>
             </problem>
-            """.format(group_label, input1_label, input2_label))
+            """.format(
+                group_label, input1_label, input2_label
+            )
+        )
         block = factory.create()
 
         answer_input_dict = {
-            factory.input_key(2, 1): 'apple',
-            factory.input_key(2, 2): 'cucumber',
+            factory.input_key(2, 1): "apple",
+            factory.input_key(2, 2): "cucumber",
         }
 
         event = self.get_event_for_answers(block, answer_input_dict)
-        assert event['submission'] ==\
-               {factory.answer_key(2, 1): {'group_label': group_label,
-                                           'question': input1_label,
-                                           'answer': 'apple',
-                                           'response_type': 'optionresponse',
-                                           'input_type': 'optioninput',
-                                           'correct': True, 'variant': ''},
-                factory.answer_key(2, 2): {'group_label': group_label,
-                                           'question': input2_label,
-                                           'answer': 'cucumber',
-                                           'response_type': 'optionresponse',
-                                           'input_type': 'optioninput',
-                                           'correct': False, 'variant': ''}}
+        assert event["submission"] == {
+            factory.answer_key(2, 1): {
+                "group_label": group_label,
+                "question": input1_label,
+                "answer": "apple",
+                "response_type": "optionresponse",
+                "input_type": "optioninput",
+                "correct": True,
+                "variant": "",
+            },
+            factory.answer_key(2, 2): {
+                "group_label": group_label,
+                "question": input2_label,
+                "answer": "cucumber",
+                "response_type": "optionresponse",
+                "input_type": "optioninput",
+                "correct": False,
+                "variant": "",
+            },
+        }
 
     def test_rerandomized_inputs(self):
         factory = CapaFactory
         block = factory.create(rerandomize=RANDOMIZATION.ALWAYS)
 
-        answer_input_dict = {
-            factory.input_key(2): '3.14'
-        }
+        answer_input_dict = {factory.input_key(2): "3.14"}
 
         event = self.get_event_for_answers(block, answer_input_dict)
-        assert event['submission'] ==\
-               {factory.answer_key(2): {'question': '',
-                                        'answer': '3.14',
-                                        'response_type': 'numericalresponse',
-                                        'input_type': 'textline',
-                                        'correct': True,
-                                        'group_label': '',
-                                        'variant': block.seed}}
+        assert event["submission"] == {
+            factory.answer_key(2): {
+                "question": "",
+                "answer": "3.14",
+                "response_type": "numericalresponse",
+                "input_type": "textline",
+                "correct": True,
+                "group_label": "",
+                "variant": block.seed,
+            }
+        }
 
     @pytest.mark.django_db
-    @patch.object(XQueueInterface, '_http_post')
+    @patch.object(XQueueInterface, "_http_post")
     def test_file_inputs(self, mock_xqueue_post):
         fnames = ["prog1.py", "prog2.py", "prog3.py"]
         fpaths = [os.path.join(DATA_DIR, "capa", fname) for fname in fnames]
@@ -3879,31 +3961,37 @@ def test_file_inputs(self, mock_xqueue_post):
 
         answer_input_dict = {
             CapaFactoryWithFiles.input_key(response_num=2): fileobjs,
-            CapaFactoryWithFiles.input_key(response_num=3): 'None',
+            CapaFactoryWithFiles.input_key(response_num=3): "None",
         }
 
         event = self.get_event_for_answers(block, answer_input_dict)
-        assert event['submission'] ==\
-               {factory.answer_key(2): {'question': '',
-                                        'answer': fpaths,
-                                        'response_type': 'coderesponse',
-                                        'input_type': 'filesubmission',
-                                        'correct': False,
-                                        'group_label': '',
-                                        'variant': ''},
-                factory.answer_key(3): {'answer': 'None',
-                                        'correct': True,
-                                        'group_label': '',
-                                        'question': '',
-                                        'response_type': 'customresponse',
-                                        'input_type': 'textline',
-                                        'variant': ''}}
+        assert event["submission"] == {
+            factory.answer_key(2): {
+                "question": "",
+                "answer": fpaths,
+                "response_type": "coderesponse",
+                "input_type": "filesubmission",
+                "correct": False,
+                "group_label": "",
+                "variant": "",
+            },
+            factory.answer_key(3): {
+                "answer": "None",
+                "correct": True,
+                "group_label": "",
+                "question": "",
+                "response_type": "customresponse",
+                "input_type": "textline",
+                "variant": "",
+            },
+        }
 
     def test_get_answer_with_jump_to_id_urls(self):
         """
         Make sure replace_jump_to_id_urls() is called in get_answer.
         """
-        problem_xml = textwrap.dedent("""
+        problem_xml = textwrap.dedent(
+            """
         <problem>
             <p>What is 1+4?</p>
                 <numericalresponse answer="5">
@@ -3917,14 +4005,15 @@ def test_get_answer_with_jump_to_id_urls(self):
                 </div>
                 </solution>
         </problem>
-        """)
+        """
+        )
 
         data = {}
-        problem = CapaFactory.create(showanswer='always', xml=problem_xml)
-        problem.runtime.service(problem, 'replace_urls').replace_urls = Mock()
+        problem = CapaFactory.create(showanswer="always", xml=problem_xml)
+        problem.runtime.service(problem, "replace_urls").replace_urls = Mock()
 
         problem.get_answer(data)
-        assert problem.runtime.service(problem, 'replace_urls').replace_urls.called
+        assert problem.runtime.service(problem, "replace_urls").replace_urls.called
 
 
 class ProblemBlockReportGenerationTest(unittest.TestCase):
@@ -3934,12 +4023,11 @@ class ProblemBlockReportGenerationTest(unittest.TestCase):
 
     def setUp(self):  # lint-amnesty, pylint: disable=super-method-not-called
         self.find_question_label_patcher = patch(
-            'xmodule.capa.capa_problem.LoncapaProblem.find_question_label',
-            lambda self, answer_id: answer_id
+            "xmodule.capa.capa_problem.LoncapaProblem.find_question_label", lambda self, answer_id: answer_id
         )
         self.find_answer_text_patcher = patch(
-            'xmodule.capa.capa_problem.LoncapaProblem.find_answer_text',
-            lambda self, answer_id, current_answer: current_answer
+            "xmodule.capa.capa_problem.LoncapaProblem.find_answer_text",
+            lambda self, answer_id, current_answer: current_answer,
         )
         self.find_question_label_patcher.start()
         self.find_answer_text_patcher.start()
@@ -3948,18 +4036,17 @@ def setUp(self):  # lint-amnesty, pylint: disable=super-method-not-called
 
     def _mock_user_state_generator(self, user_count=1, response_count=10):
         for uid in range(user_count):
-            yield self._user_state(username=f'user{uid}', response_count=response_count)
+            yield self._user_state(username=f"user{uid}", response_count=response_count)
 
-    def _user_state(self, username='testuser', response_count=10, suffix=''):
+    def _user_state(self, username="testuser", response_count=10, suffix=""):
         return XBlockUserState(
             username=username,
             state={
-                'student_answers': {
-                    f'{username}_answerid_{aid}{suffix}': f'{username}_answer_{aid}'
-                    for aid in range(response_count)
+                "student_answers": {
+                    f"{username}_answerid_{aid}{suffix}": f"{username}_answer_{aid}" for aid in range(response_count)
                 },
-                'seed': 1,
-                'correct_map': {},
+                "seed": 1,
+                "correct_map": {},
             },
             block_key=None,
             updated=None,
@@ -3967,14 +4054,14 @@ def _user_state(self, username='testuser', response_count=10, suffix=''):
         )
 
     def _get_block(self):  # lint-amnesty, pylint: disable=missing-function-docstring
-        scope_ids = Mock(block_type='problem')
+        scope_ids = Mock(block_type="problem")
         block = ProblemBlock(get_test_system(), scope_ids=scope_ids)
         block.runtime = Mock()
-        block.data = '<problem/>'
+        block.data = "<problem/>"
         return block
 
     def test_generate_report_data_not_implemented(self):
-        scope_ids = Mock(block_type='noproblem')
+        scope_ids = Mock(block_type="noproblem")
         block = ProblemBlock(get_test_system(), scope_ids=scope_ids)
         with pytest.raises(NotImplementedError):
             next(block.generate_report_data(iter([])))
@@ -3988,29 +4075,33 @@ def test_generate_report_data_dont_limit_responses(self):
         block = self._get_block()
         user_count = 5
         response_count = 10
-        report_data = list(block.generate_report_data(
-            self._mock_user_state_generator(
-                user_count=user_count,
-                response_count=response_count,
+        report_data = list(
+            block.generate_report_data(
+                self._mock_user_state_generator(
+                    user_count=user_count,
+                    response_count=response_count,
+                )
             )
-        ))
+        )
         assert (user_count * response_count) == len(report_data)
 
     def test_generate_report_data_skip_dynamath(self):
         block = self._get_block()
-        iterator = iter([self._user_state(suffix='_dynamath')])
+        iterator = iter([self._user_state(suffix="_dynamath")])
         report_data = list(block.generate_report_data(iterator))
         assert 0 == len(report_data)
 
     def test_generate_report_data_report_loncapa_error(self):
-        #Test to make sure reports continue despite loncappa errors, and write them into the report.
+        # Test to make sure reports continue despite loncappa errors, and write them into the report.
         block = self._get_block()
-        with patch('xmodule.capa_block.LoncapaProblem') as mock_LoncapaProblem:
+        with patch("xmodule.capa_block.LoncapaProblem") as mock_LoncapaProblem:
             mock_LoncapaProblem.side_effect = LoncapaProblemError
-            report_data = list(block.generate_report_data(
-                self._mock_user_state_generator(
-                    user_count=1,
-                    response_count=5,
+            report_data = list(
+                block.generate_report_data(
+                    self._mock_user_state_generator(
+                        user_count=1,
+                        response_count=5,
+                    )
                 )
-            ))
-            assert 'Python Error: No Answer Retrieved' in list(report_data[0][1].values())
+            )
+            assert "Python Error: No Answer Retrieved" in list(report_data[0][1].values())
diff --git a/xmodule/tests/test_fields.py b/xmodule/tests/test_fields.py
index 1e928fb1b3d8..95b329bdb00d 100644
--- a/xmodule/tests/test_fields.py
+++ b/xmodule/tests/test_fields.py
@@ -1,8 +1,8 @@
 """Tests for classes defined in fields.py."""
 
-
 import datetime
 import unittest
+
 import pytest
 from pytz import UTC
 
@@ -13,63 +13,63 @@ class DateTest(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-clas
     date = Date()
 
     def compare_dates(self, dt1, dt2, expected_delta):
-        assert (dt1 - dt2) == expected_delta, ((((str(dt1) + '-') + str(dt2)) + '!=') + str(expected_delta))
+        assert (dt1 - dt2) == expected_delta, (((str(dt1) + "-") + str(dt2)) + "!=") + str(expected_delta)
 
     def test_from_json(self):
         """Test conversion from iso compatible date strings to struct_time"""
         self.compare_dates(
-            DateTest.date.from_json("2013-01-01"),
-            DateTest.date.from_json("2012-12-31"),
-            datetime.timedelta(days=1)
+            DateTest.date.from_json("2013-01-01"), DateTest.date.from_json("2012-12-31"), datetime.timedelta(days=1)
         )
         self.compare_dates(
             DateTest.date.from_json("2013-01-01T00"),
             DateTest.date.from_json("2012-12-31T23"),
-            datetime.timedelta(hours=1)
+            datetime.timedelta(hours=1),
         )
         self.compare_dates(
             DateTest.date.from_json("2013-01-01T00:00"),
             DateTest.date.from_json("2012-12-31T23:59"),
-            datetime.timedelta(minutes=1)
+            datetime.timedelta(minutes=1),
         )
         self.compare_dates(
             DateTest.date.from_json("2013-01-01T00:00:00"),
             DateTest.date.from_json("2012-12-31T23:59:59"),
-            datetime.timedelta(seconds=1)
+            datetime.timedelta(seconds=1),
         )
         self.compare_dates(
             DateTest.date.from_json("2013-01-01T00:00:00Z"),
             DateTest.date.from_json("2012-12-31T23:59:59Z"),
-            datetime.timedelta(seconds=1)
+            datetime.timedelta(seconds=1),
         )
         self.compare_dates(
             DateTest.date.from_json("2012-12-31T23:00:01-01:00"),
             DateTest.date.from_json("2013-01-01T00:00:00+01:00"),
-            datetime.timedelta(hours=1, seconds=1)
+            datetime.timedelta(hours=1, seconds=1),
         )
 
     def test_enforce_type(self):
         assert DateTest.date.enforce_type(None) is None
-        assert DateTest.date.enforce_type('') is None
-        assert DateTest.date.enforce_type('2012-12-31T23:00:01') ==\
-               datetime.datetime(2012, 12, 31, 23, 0, 1, tzinfo=UTC)
+        assert DateTest.date.enforce_type("") is None
+        assert DateTest.date.enforce_type("2012-12-31T23:00:01") == datetime.datetime(
+            2012, 12, 31, 23, 0, 1, tzinfo=UTC
+        )
         assert DateTest.date.enforce_type(1234567890000) == datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=UTC)
-        assert DateTest.date.enforce_type(datetime.datetime(2014, 5, 9, 21, 1, 27, tzinfo=UTC)) ==\
-               datetime.datetime(2014, 5, 9, 21, 1, 27, tzinfo=UTC)
+        assert DateTest.date.enforce_type(datetime.datetime(2014, 5, 9, 21, 1, 27, tzinfo=UTC)) == datetime.datetime(
+            2014, 5, 9, 21, 1, 27, tzinfo=UTC
+        )
         with pytest.raises(TypeError):
             DateTest.date.enforce_type([1])
 
     def test_return_None(self):
-        assert DateTest.date.from_json('') is None
+        assert DateTest.date.from_json("") is None
         assert DateTest.date.from_json(None) is None
         with pytest.raises(TypeError):
-            DateTest.date.from_json(['unknown value'])
+            DateTest.date.from_json(["unknown value"])
 
     def test_old_due_date_format(self):
         current = datetime.datetime.today()
-        assert datetime.datetime(current.year, 3, 12, 12, tzinfo=UTC) == DateTest.date.from_json('March 12 12:00')
-        assert datetime.datetime(current.year, 12, 4, 16, 30, tzinfo=UTC) == DateTest.date.from_json('December 4 16:30')
-        assert DateTest.date.from_json('12 12:00') is None
+        assert datetime.datetime(current.year, 3, 12, 12, tzinfo=UTC) == DateTest.date.from_json("March 12 12:00")
+        assert datetime.datetime(current.year, 12, 4, 16, 30, tzinfo=UTC) == DateTest.date.from_json("December 4 16:30")
+        assert DateTest.date.from_json("12 12:00") is None
 
     def test_non_std_from_json(self):
         """
@@ -85,35 +85,41 @@ def test_to_json(self):
         """
         Test converting time reprs to iso dates
         """
-        assert DateTest.date.to_json(datetime.datetime.strptime('2012-12-31T23:59:59Z', '%Y-%m-%dT%H:%M:%SZ')) ==\
-               '2012-12-31T23:59:59Z'
-        assert DateTest.date.to_json(DateTest.date.from_json('2012-12-31T23:59:59Z')) == '2012-12-31T23:59:59Z'
-        assert DateTest.date.to_json(DateTest.date.from_json('2012-12-31T23:00:01-01:00')) ==\
-               '2012-12-31T23:00:01-01:00'
+        assert (
+            DateTest.date.to_json(datetime.datetime.strptime("2012-12-31T23:59:59Z", "%Y-%m-%dT%H:%M:%SZ"))
+            == "2012-12-31T23:59:59Z"
+        )
+        assert DateTest.date.to_json(DateTest.date.from_json("2012-12-31T23:59:59Z")) == "2012-12-31T23:59:59Z"
+        assert (
+            DateTest.date.to_json(DateTest.date.from_json("2012-12-31T23:00:01-01:00")) == "2012-12-31T23:00:01-01:00"
+        )
         with pytest.raises(TypeError):
-            DateTest.date.to_json('2012-12-31T23:00:01-01:00')
+            DateTest.date.to_json("2012-12-31T23:00:01-01:00")
 
 
 class TimedeltaTest(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
     delta = Timedelta()
 
     def test_from_json(self):
-        assert TimedeltaTest.delta.from_json('1 day 12 hours 59 minutes 59 seconds') ==\
-               datetime.timedelta(days=1, hours=12, minutes=59, seconds=59)
+        assert TimedeltaTest.delta.from_json("1 day 12 hours 59 minutes 59 seconds") == datetime.timedelta(
+            days=1, hours=12, minutes=59, seconds=59
+        )
 
-        assert TimedeltaTest.delta.from_json('1 day 46799 seconds') == datetime.timedelta(days=1, seconds=46799)
+        assert TimedeltaTest.delta.from_json("1 day 46799 seconds") == datetime.timedelta(days=1, seconds=46799)
 
     def test_enforce_type(self):
         assert TimedeltaTest.delta.enforce_type(None) is None
-        assert TimedeltaTest.delta.enforce_type(datetime.timedelta(days=1, seconds=46799)) ==\
-               datetime.timedelta(days=1, seconds=46799)
-        assert TimedeltaTest.delta.enforce_type('1 day 46799 seconds') == datetime.timedelta(days=1, seconds=46799)
+        assert TimedeltaTest.delta.enforce_type(datetime.timedelta(days=1, seconds=46799)) == datetime.timedelta(
+            days=1, seconds=46799
+        )
+        assert TimedeltaTest.delta.enforce_type("1 day 46799 seconds") == datetime.timedelta(days=1, seconds=46799)
         with pytest.raises(TypeError):
             TimedeltaTest.delta.enforce_type([1])
 
     def test_to_json(self):
-        assert '1 days 46799 seconds' ==\
-               TimedeltaTest.delta.to_json(datetime.timedelta(days=1, hours=12, minutes=59, seconds=59))
+        assert "1 days 46799 seconds" == TimedeltaTest.delta.to_json(
+            datetime.timedelta(days=1, hours=12, minutes=59, seconds=59)
+        )
 
 
 class RelativeTimeTest(unittest.TestCase):  # lint-amnesty, pylint: disable=missing-class-docstring
@@ -121,7 +127,7 @@ class RelativeTimeTest(unittest.TestCase):  # lint-amnesty, pylint: disable=miss
     delta = RelativeTime()
 
     def test_from_json(self):
-        assert RelativeTimeTest.delta.from_json('0:05:07') == datetime.timedelta(seconds=307)
+        assert RelativeTimeTest.delta.from_json("0:05:07") == datetime.timedelta(seconds=307)
 
         assert RelativeTimeTest.delta.from_json(100.0) == datetime.timedelta(seconds=100)
         assert RelativeTimeTest.delta.from_json(None) == datetime.timedelta(seconds=0)
@@ -134,16 +140,17 @@ def test_from_json(self):
 
     def test_enforce_type(self):
         assert RelativeTimeTest.delta.enforce_type(None) is None
-        assert RelativeTimeTest.delta.enforce_type(datetime.timedelta(days=1, seconds=46799)) ==\
-               datetime.timedelta(days=1, seconds=46799)
-        assert RelativeTimeTest.delta.enforce_type('0:05:07') == datetime.timedelta(seconds=307)
+        assert RelativeTimeTest.delta.enforce_type(datetime.timedelta(days=1, seconds=46799)) == datetime.timedelta(
+            days=1, seconds=46799
+        )
+        assert RelativeTimeTest.delta.enforce_type("0:05:07") == datetime.timedelta(seconds=307)
         with pytest.raises(TypeError):
             RelativeTimeTest.delta.enforce_type([1])
 
     def test_to_json(self):
-        assert '01:02:03' == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=3723))
-        assert '00:00:00' == RelativeTimeTest.delta.to_json(None)
-        assert '00:01:40' == RelativeTimeTest.delta.to_json(100.0)
+        assert "01:02:03" == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=3723))
+        assert "00:00:00" == RelativeTimeTest.delta.to_json(None)
+        assert "00:01:40" == RelativeTimeTest.delta.to_json(100.0)
 
         error_msg = "RelativeTime max value is 23:59:59=86400.0 seconds, but 90000.0 seconds is passed"
         with self.assertRaisesRegex(ValueError, error_msg):
@@ -153,5 +160,5 @@ def test_to_json(self):
             RelativeTimeTest.delta.to_json("123")
 
     def test_str(self):
-        assert '01:02:03' == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=3723))
-        assert '11:02:03' == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=39723))
+        assert "01:02:03" == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=3723))
+        assert "11:02:03" == RelativeTimeTest.delta.to_json(datetime.timedelta(seconds=39723))
diff --git a/xmodule/tests/test_progress.py b/xmodule/tests/test_progress.py
index 17cdc2b19a60..c2ae97ced753 100644
--- a/xmodule/tests/test_progress.py
+++ b/xmodule/tests/test_progress.py
@@ -1,15 +1,15 @@
 """Module progress tests"""
 
-
 import unittest
 
 from xmodule.progress import Progress
 
 
 class ProgressTest(unittest.TestCase):
-    ''' Test that basic Progress objects work.  A Progress represents a
+    """Test that basic Progress objects work.  A Progress represents a
     fraction between 0 and 1.
-    '''
+    """
+
     not_started = Progress(0, 17)
     part_done = Progress(2, 6)
     half_done = Progress(3, 6)
@@ -36,7 +36,7 @@ def test_create_object(self):
 
     def test_clamp(self):
         assert (2, 2) == Progress(3, 2).frac()
-        assert (0, 2) == Progress((- 2), 2).frac()
+        assert (0, 2) == Progress((-2), 2).frac()
 
     def test_frac(self):
         prg = Progress(1, 2)
@@ -73,15 +73,15 @@ def test_done(self):
         assert not self.not_started.done()
 
     def test_str(self):
-        assert str(self.not_started) == '0/17'
-        assert str(self.part_done) == '2/6'
-        assert str(self.done) == '7/7'
-        assert str(Progress(2.1234, 7)) == '2.12/7'
-        assert str(Progress(2.0034, 7)) == '2/7'
-        assert str(Progress(0.999, 7)) == '1/7'
+        assert str(self.not_started) == "0/17"
+        assert str(self.part_done) == "2/6"
+        assert str(self.done) == "7/7"
+        assert str(Progress(2.1234, 7)) == "2.12/7"
+        assert str(Progress(2.0034, 7)) == "2/7"
+        assert str(Progress(0.999, 7)) == "1/7"
 
     def test_add(self):
-        '''Test the Progress.add_counts() method'''
+        """Test the Progress.add_counts() method"""
         prg1 = Progress(0, 2)
         prg2 = Progress(1, 3)
         prg3 = Progress(2, 5)
@@ -96,8 +96,8 @@ def test_add(self):
         assert add(prg_none, prg2) == prg2.frac()
 
     def test_equality(self):
-        '''Test that comparing Progress objects for equality
-        works correctly.'''
+        """Test that comparing Progress objects for equality
+        works correctly."""
         prg1 = Progress(1, 2)
         prg2 = Progress(2, 4)
         prg3 = Progress(1, 2)
diff --git a/xmodule/tests/test_stringify.py b/xmodule/tests/test_stringify.py
index a70453ce2b01..d7568f7b16d2 100644
--- a/xmodule/tests/test_stringify.py
+++ b/xmodule/tests/test_stringify.py
@@ -2,7 +2,6 @@
 Tests stringify functions used in xmodule html
 """
 
-
 from lxml import etree
 
 from xmodule.stringify import stringify_children
@@ -10,7 +9,7 @@
 
 def test_stringify():
     text = 'Hi <div x="foo">there <span>Bruce</span><b>!</b></div>'
-    html = f'''<html a="b" foo="bar">{text}</html>'''
+    html = f"""<html a="b" foo="bar">{text}</html>"""
     xml = etree.fromstring(html)
     out = stringify_children(xml)
     assert out == text
diff --git a/xmodule/tests/test_xml_block.py b/xmodule/tests/test_xml_block.py
index 7f33aad0f998..3c25cebee58f 100644
--- a/xmodule/tests/test_xml_block.py
+++ b/xmodule/tests/test_xml_block.py
@@ -4,8 +4,8 @@
 
 import unittest
 from unittest.mock import Mock
-import dateutil.parser
 
+import dateutil.parser
 from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
 from xblock.field_data import DictFieldData
 from xblock.fields import Any, Boolean, Dict, Float, Integer, List, Scope, String
@@ -30,30 +30,26 @@ def to_json(self, value):
 
 class TestFields:
     # Will be returned by editable_metadata_fields.
-    max_attempts = Integer(scope=Scope.settings, default=1000, values={'min': 1, 'max': 10})
+    max_attempts = Integer(scope=Scope.settings, default=1000, values={"min": 1, "max": 10})
     # Will not be returned by editable_metadata_fields because filtered out by non_editable_metadata_fields.
     due = Date(scope=Scope.settings)
     # Will not be returned by editable_metadata_fields because is not Scope.settings.
     student_answers = Dict(scope=Scope.user_state)
     # Will be returned, and can override the inherited value from XModule.
     display_name = String(
-        scope=Scope.settings,
-        default='local default',
-        display_name='Local Display Name',
-        help='local help'
+        scope=Scope.settings, default="local default", display_name="Local Display Name", help="local help"
     )
     # Used for testing select type, effect of to_json method
     string_select = CrazyJsonString(
         scope=Scope.settings,
-        default='default value',
-        values=[{'display_name': 'first', 'value': 'value a'},
-                {'display_name': 'second', 'value': 'value b'}]
+        default="default value",
+        values=[{"display_name": "first", "value": "value a"}, {"display_name": "second", "value": "value b"}],
     )
     showanswer = InheritanceMixin.showanswer
     # Used for testing select type
-    float_select = Float(scope=Scope.settings, default=.999, values=[1.23, 0.98])
+    float_select = Float(scope=Scope.settings, default=0.999, values=[1.23, 0.98])
     # Used for testing float type
-    float_non_select = Float(scope=Scope.settings, default=.999, values={'min': 0, 'step': .3})
+    float_non_select = Float(scope=Scope.settings, default=0.999, values={"min": 0, "step": 0.3})
     # Used for testing that Booleans get mapped to select type
     boolean_select = Boolean(scope=Scope.settings)
     # Used for testing Lists
@@ -69,17 +65,18 @@ class TestableInheritingXBlock(XmlMixin):  # lint-amnesty, pylint: disable=abstr
         """
         An XBlock we can use in these tests.
         """
+
         inherited = String(scope=Scope.settings, default="the default")
         not_inherited = String(scope=Scope.settings, default="nothing")
 
     def setUp(self):
         super().setUp()
-        self.dummy_course_key = CourseLocator('test_org', 'test_123', 'test_run')
+        self.dummy_course_key = CourseLocator("test_org", "test_123", "test_run")
         self.system = get_test_descriptor_system()
         self.all_blocks = {}
         self.system.get_block = self.all_blocks.get
         self.field_data = InheritingFieldData(
-            inheritable_names=['inherited'],
+            inheritable_names=["inherited"],
             kvs=DictKeyValueStore({}),
         )
 
@@ -87,19 +84,12 @@ def get_block_using_split_kvs(self, block_type, block_id, fields, defaults):
         """
         Construct an Xblock with split mongo kvs.
         """
-        kvs = SplitMongoKVS(
-            definition=Mock(),
-            initial_values=fields,
-            default_values=defaults,
-            parent=None
-        )
+        kvs = SplitMongoKVS(definition=Mock(), initial_values=fields, default_values=defaults, parent=None)
         self.field_data = InheritingFieldData(
-            inheritable_names=['inherited'],
+            inheritable_names=["inherited"],
             kvs=kvs,
         )
-        block = self.get_a_block(
-            usage_id=self.get_usage_id(block_type, block_id)
-        )
+        block = self.get_a_block(usage_id=self.get_usage_id(block_type, block_id))
 
         return block
 
@@ -131,8 +121,8 @@ def test_default_value(self):
         Test that the Blocks with nothing set with return the fields' defaults.
         """
         block = self.get_a_block()
-        assert block.inherited == 'the default'
-        assert block.not_inherited == 'nothing'
+        assert block.inherited == "the default"
+        assert block.not_inherited == "nothing"
 
     def test_set_value(self):
         """
@@ -141,8 +131,8 @@ def test_set_value(self):
         block = self.get_a_block()
         block.inherited = "Changed!"
         block.not_inherited = "New Value!"
-        assert block.inherited == 'Changed!'
-        assert block.not_inherited == 'New Value!'
+        assert block.inherited == "Changed!"
+        assert block.not_inherited == "New Value!"
 
     def test_inherited(self):
         """
@@ -150,11 +140,11 @@ def test_inherited(self):
         """
         parent_block = self.get_a_block(usage_id=self.get_usage_id("course", "parent"))
         parent_block.inherited = "Changed!"
-        assert parent_block.inherited == 'Changed!'
+        assert parent_block.inherited == "Changed!"
 
         child = self.get_a_block(usage_id=self.get_usage_id("vertical", "child"))
         child.parent = parent_block.location
-        assert child.inherited == 'Changed!'
+        assert child.inherited == "Changed!"
 
     def test_inherited_across_generations(self):
         """
@@ -162,12 +152,12 @@ def test_inherited_across_generations(self):
         """
         parent = self.get_a_block(usage_id=self.get_usage_id("course", "parent"))
         parent.inherited = "Changed!"
-        assert parent.inherited == 'Changed!'
+        assert parent.inherited == "Changed!"
         for child_num in range(10):
             usage_id = self.get_usage_id("vertical", f"child_{child_num}")
             child = self.get_a_block(usage_id=usage_id)
             child.parent = parent.location
-            assert child.inherited == 'Changed!'
+            assert child.inherited == "Changed!"
 
     def test_not_inherited(self):
         """
@@ -175,11 +165,11 @@ def test_not_inherited(self):
         """
         parent = self.get_a_block(usage_id=self.get_usage_id("course", "parent"))
         parent.not_inherited = "Changed!"
-        assert parent.not_inherited == 'Changed!'
+        assert parent.not_inherited == "Changed!"
 
         child = self.get_a_block(usage_id=self.get_usage_id("vertical", "child"))
         child.parent = parent.location
-        assert child.not_inherited == 'nothing'
+        assert child.not_inherited == "nothing"
 
     def test_non_defaults_inherited_across_lib(self):
         """
@@ -192,7 +182,7 @@ def test_non_defaults_inherited_across_lib(self):
             fields=dict(inherited="changed!"),
             defaults=dict(inherited="parent's default"),
         )
-        assert parent_block.inherited == 'changed!'
+        assert parent_block.inherited == "changed!"
 
         child = self.get_block_using_split_kvs(
             block_type="problem",
@@ -201,7 +191,7 @@ def test_non_defaults_inherited_across_lib(self):
             defaults={},
         )
         child.parent = parent_block.location
-        assert child.inherited == 'changed!'
+        assert child.inherited == "changed!"
 
     def test_defaults_not_inherited_across_lib(self):
         """
@@ -214,7 +204,7 @@ def test_defaults_not_inherited_across_lib(self):
             fields=dict(inherited="changed!"),
             defaults=dict(inherited="parent's default"),
         )
-        assert parent_block.inherited == 'changed!'
+        assert parent_block.inherited == "changed!"
 
         child = self.get_block_using_split_kvs(
             block_type="library_content",
@@ -238,60 +228,89 @@ def test_display_name_field(self):
         # Also tests that xml_attributes is filtered out of XmlMixin.
         assert 1 == len(editable_fields), editable_fields
         self.assert_field_values(
-            editable_fields, 'display_name', XModuleMixin.display_name,
-            explicitly_set=False, value=None, default_value=None
+            editable_fields,
+            "display_name",
+            XModuleMixin.display_name,
+            explicitly_set=False,
+            value=None,
+            default_value=None,
         )
 
     def test_override_default(self):
         # Tests that explicitly_set is correct when a value overrides the default (not inheritable).
-        editable_fields = self.get_xml_editable_fields(DictFieldData({'display_name': 'foo'}))
+        editable_fields = self.get_xml_editable_fields(DictFieldData({"display_name": "foo"}))
         self.assert_field_values(
-            editable_fields, 'display_name', XModuleMixin.display_name,
-            explicitly_set=True, value='foo', default_value=None
+            editable_fields,
+            "display_name",
+            XModuleMixin.display_name,
+            explicitly_set=True,
+            value="foo",
+            default_value=None,
         )
 
     def test_integer_field(self):
-        block = self.get_block(DictFieldData({'max_attempts': '7'}))
+        block = self.get_block(DictFieldData({"max_attempts": "7"}))
         editable_fields = block.editable_metadata_fields
         assert 8 == len(editable_fields)
         self.assert_field_values(
-            editable_fields, 'max_attempts', TestFields.max_attempts,
-            explicitly_set=True, value=7, default_value=1000, type='Integer',
-            options=TestFields.max_attempts.values
+            editable_fields,
+            "max_attempts",
+            TestFields.max_attempts,
+            explicitly_set=True,
+            value=7,
+            default_value=1000,
+            type="Integer",
+            options=TestFields.max_attempts.values,
         )
         self.assert_field_values(
-            editable_fields, 'display_name', TestFields.display_name,
-            explicitly_set=False, value='local default', default_value='local default'
+            editable_fields,
+            "display_name",
+            TestFields.display_name,
+            explicitly_set=False,
+            value="local default",
+            default_value="local default",
         )
 
         editable_fields = self.get_block(DictFieldData({})).editable_metadata_fields
         self.assert_field_values(
-            editable_fields, 'max_attempts', TestFields.max_attempts,
-            explicitly_set=False, value=1000, default_value=1000, type='Integer',
-            options=TestFields.max_attempts.values
+            editable_fields,
+            "max_attempts",
+            TestFields.max_attempts,
+            explicitly_set=False,
+            value=1000,
+            default_value=1000,
+            type="Integer",
+            options=TestFields.max_attempts.values,
         )
 
     def test_inherited_field(self):
-        kvs = InheritanceKeyValueStore(initial_values={}, inherited_settings={'showanswer': 'inherited'})
+        kvs = InheritanceKeyValueStore(initial_values={}, inherited_settings={"showanswer": "inherited"})
         model_data = KvsFieldData(kvs)
         block = self.get_block(model_data)
         editable_fields = block.editable_metadata_fields
         self.assert_field_values(
-            editable_fields, 'showanswer', InheritanceMixin.showanswer,
-            explicitly_set=False, value='inherited', default_value='inherited'
+            editable_fields,
+            "showanswer",
+            InheritanceMixin.showanswer,
+            explicitly_set=False,
+            value="inherited",
+            default_value="inherited",
         )
 
         # Mimic the case where display_name WOULD have been inherited, except we explicitly set it.
         kvs = InheritanceKeyValueStore(
-            initial_values={'showanswer': 'explicit'},
-            inherited_settings={'showanswer': 'inheritable value'}
+            initial_values={"showanswer": "explicit"}, inherited_settings={"showanswer": "inheritable value"}
         )
         model_data = KvsFieldData(kvs)
         block = self.get_block(model_data)
         editable_fields = block.editable_metadata_fields
         self.assert_field_values(
-            editable_fields, 'showanswer', InheritanceMixin.showanswer,
-            explicitly_set=True, value='explicit', default_value='inheritable value'
+            editable_fields,
+            "showanswer",
+            InheritanceMixin.showanswer,
+            explicitly_set=True,
+            value="explicit",
+            default_value="inheritable value",
         )
 
     def test_type_and_options(self):
@@ -303,35 +322,61 @@ def test_type_and_options(self):
 
         # Tests for select
         self.assert_field_values(
-            editable_fields, 'string_select', TestFields.string_select,
-            explicitly_set=False, value='default value', default_value='default value',
-            type='Select', options=[{'display_name': 'first', 'value': 'value a JSON'},
-                                    {'display_name': 'second', 'value': 'value b JSON'}]
+            editable_fields,
+            "string_select",
+            TestFields.string_select,
+            explicitly_set=False,
+            value="default value",
+            default_value="default value",
+            type="Select",
+            options=[
+                {"display_name": "first", "value": "value a JSON"},
+                {"display_name": "second", "value": "value b JSON"},
+            ],
         )
 
         self.assert_field_values(
-            editable_fields, 'float_select', TestFields.float_select,
-            explicitly_set=False, value=.999, default_value=.999,
-            type='Select', options=[1.23, 0.98]
+            editable_fields,
+            "float_select",
+            TestFields.float_select,
+            explicitly_set=False,
+            value=0.999,
+            default_value=0.999,
+            type="Select",
+            options=[1.23, 0.98],
         )
 
         self.assert_field_values(
-            editable_fields, 'boolean_select', TestFields.boolean_select,
-            explicitly_set=False, value=None, default_value=None,
-            type='Select', options=[{'display_name': "True", "value": True}, {'display_name': "False", "value": False}]
+            editable_fields,
+            "boolean_select",
+            TestFields.boolean_select,
+            explicitly_set=False,
+            value=None,
+            default_value=None,
+            type="Select",
+            options=[{"display_name": "True", "value": True}, {"display_name": "False", "value": False}],
         )
 
         # Test for float
         self.assert_field_values(
-            editable_fields, 'float_non_select', TestFields.float_non_select,
-            explicitly_set=False, value=.999, default_value=.999,
-            type='Float', options={'min': 0, 'step': .3}
+            editable_fields,
+            "float_non_select",
+            TestFields.float_non_select,
+            explicitly_set=False,
+            value=0.999,
+            default_value=0.999,
+            type="Float",
+            options={"min": 0, "step": 0.3},
         )
 
         self.assert_field_values(
-            editable_fields, 'list_field', TestFields.list_field,
-            explicitly_set=False, value=[], default_value=[],
-            type='List'
+            editable_fields,
+            "list_field",
+            TestFields.list_field,
+            explicitly_set=False,
+            value=[],
+            default_value=[],
+            type="List",
         )
 
     # Start of helper methods
@@ -354,43 +399,56 @@ def non_editable_metadata_fields(self):
         system = get_test_descriptor_system(render_template=Mock())
         return system.construct_xblock_from_class(TestModuleBlock, field_data=field_data, scope_ids=Mock())
 
-    def assert_field_values(self, editable_fields, name, field, explicitly_set, value, default_value,  # lint-amnesty, pylint: disable=dangerous-default-value
-                            type='Generic', options=[]):  # lint-amnesty, pylint: disable=redefined-builtin
+    def assert_field_values(  # lint-amnesty, pylint: disable=dangerous-default-value
+        self,
+        editable_fields,
+        name,
+        field,
+        explicitly_set,
+        value,
+        default_value,
+        type="Generic",
+        options=[],
+    ):  # lint-amnesty, pylint: disable=redefined-builtin
         test_field = editable_fields[name]
 
-        assert field.name == test_field['field_name']
-        assert field.display_name == test_field['display_name']
-        assert field.help == test_field['help']
+        assert field.name == test_field["field_name"]
+        assert field.display_name == test_field["display_name"]
+        assert field.help == test_field["help"]
 
-        assert field.to_json(value) == test_field['value']
-        assert field.to_json(default_value) == test_field['default_value']
+        assert field.to_json(value) == test_field["value"]
+        assert field.to_json(default_value) == test_field["default_value"]
 
-        assert options == test_field['options']
-        assert type == test_field['type']
+        assert options == test_field["options"]
+        assert type == test_field["type"]
 
-        assert explicitly_set == test_field['explicitly_set']
+        assert explicitly_set == test_field["explicitly_set"]
 
 
 class TestSerialize(unittest.TestCase):
-    """ Tests the serialize, method, which is not dependent on type. """
+    """Tests the serialize, method, which is not dependent on type."""
 
     def test_serialize(self):
-        assert serialize_field(None) == 'null'
-        assert serialize_field(-2) == '-2'
-        assert serialize_field('2') == '2'
-        assert serialize_field(-3.41) == '-3.41'
-        assert serialize_field('2.589') == '2.589'
-        assert serialize_field(False) == 'false'
-        assert serialize_field('false') == 'false'
-        assert serialize_field('fAlse') == 'fAlse'
-        assert serialize_field('hat box') == 'hat box'
-        serialized_dict = serialize_field({'bar': 'hat', 'frog': 'green'})
-        assert serialized_dict == '{"bar": "hat", "frog": "green"}' or serialized_dict == '{"frog": "green", "bar": "hat"}'  # lint-amnesty, pylint: disable=consider-using-in, line-too-long
-        assert serialize_field([3.5, 5.6]) == '[3.5, 5.6]'
-        assert serialize_field(['foo', 'bar']) == '["foo", "bar"]'
-        assert serialize_field("2012-12-31T23:59:59Z") == '2012-12-31T23:59:59Z'
-        assert serialize_field("1 day 12 hours 59 minutes 59 seconds") == '1 day 12 hours 59 minutes 59 seconds'
-        assert serialize_field(dateutil.parser.parse('2012-12-31T23:59:59Z')) == '2012-12-31T23:59:59+00:00'
+        assert serialize_field(None) == "null"
+        assert serialize_field(-2) == "-2"
+        assert serialize_field("2") == "2"
+        assert serialize_field(-3.41) == "-3.41"
+        assert serialize_field("2.589") == "2.589"
+        assert serialize_field(False) == "false"
+        assert serialize_field("false") == "false"
+        assert serialize_field("fAlse") == "fAlse"
+        assert serialize_field("hat box") == "hat box"
+        serialized_dict = serialize_field({"bar": "hat", "frog": "green"})
+        assert (
+            serialized_dict  # lint-amnesty, pylint: disable=consider-using-in, line-too-long
+            == '{"bar": "hat", "frog": "green"}'
+            or serialized_dict == '{"frog": "green", "bar": "hat"}'
+        )
+        assert serialize_field([3.5, 5.6]) == "[3.5, 5.6]"
+        assert serialize_field(["foo", "bar"]) == '["foo", "bar"]'
+        assert serialize_field("2012-12-31T23:59:59Z") == "2012-12-31T23:59:59Z"
+        assert serialize_field("1 day 12 hours 59 minutes 59 seconds") == "1 day 12 hours 59 minutes 59 seconds"
+        assert serialize_field(dateutil.parser.parse("2012-12-31T23:59:59Z")) == "2012-12-31T23:59:59+00:00"
 
 
 class TestDeserialize(unittest.TestCase):
@@ -412,27 +470,27 @@ def assertDeserializeNonString(self):
         self.assertDeserializeEqual([10], [10])
         self.assertDeserializeEqual({}, {})
         self.assertDeserializeEqual([], [])
-        self.assertDeserializeEqual(None, 'null')
+        self.assertDeserializeEqual(None, "null")
 
 
 class TestDeserializeInteger(TestDeserialize):
-    """ Tests deserialize as related to Integer type. """
+    """Tests deserialize as related to Integer type."""
 
     field_type = Integer
 
     def test_deserialize(self):
-        self.assertDeserializeEqual(-2, '-2')
+        self.assertDeserializeEqual(-2, "-2")
         self.assertDeserializeEqual("450", '"450"')
 
         # False can be parsed as a int (converts to 0)
-        self.assertDeserializeEqual(False, 'false')
+        self.assertDeserializeEqual(False, "false")
         # True can be parsed as a int (converts to 1)
-        self.assertDeserializeEqual(True, 'true')
+        self.assertDeserializeEqual(True, "true")
         # 2.78 can be converted to int, so the string will be deserialized
-        self.assertDeserializeEqual(-2.78, '-2.78')
+        self.assertDeserializeEqual(-2.78, "-2.78")
 
     def test_deserialize_unsupported_types(self):
-        self.assertDeserializeEqual('[3]', '[3]')
+        self.assertDeserializeEqual("[3]", "[3]")
         # '2.78' cannot be converted to int, so input value is returned
         self.assertDeserializeEqual('"-2.78"', '"-2.78"')
         # 'false' cannot be converted to int, so input value is returned
@@ -441,134 +499,128 @@ def test_deserialize_unsupported_types(self):
 
 
 class TestDeserializeFloat(TestDeserialize):
-    """ Tests deserialize as related to Float type. """
+    """Tests deserialize as related to Float type."""
 
     field_type = Float
 
     def test_deserialize(self):
-        self.assertDeserializeEqual(-2, '-2')
+        self.assertDeserializeEqual(-2, "-2")
         self.assertDeserializeEqual("450", '"450"')
-        self.assertDeserializeEqual(-2.78, '-2.78')
+        self.assertDeserializeEqual(-2.78, "-2.78")
         self.assertDeserializeEqual("0.45", '"0.45"')
 
         # False can be parsed as a float (converts to 0)
-        self.assertDeserializeEqual(False, 'false')
+        self.assertDeserializeEqual(False, "false")
         # True can be parsed as a float (converts to 1)
-        self.assertDeserializeEqual(True, 'true')
+        self.assertDeserializeEqual(True, "true")
 
     def test_deserialize_unsupported_types(self):
-        self.assertDeserializeEqual('[3]', '[3]')
+        self.assertDeserializeEqual("[3]", "[3]")
         # 'false' cannot be converted to float, so input value is returned
         self.assertDeserializeEqual('"false"', '"false"')
         self.assertDeserializeNonString()
 
 
 class TestDeserializeBoolean(TestDeserialize):
-    """ Tests deserialize as related to Boolean type. """
+    """Tests deserialize as related to Boolean type."""
 
     field_type = Boolean
 
     def test_deserialize(self):
         # json.loads converts the value to Python bool
-        self.assertDeserializeEqual(False, 'false')
-        self.assertDeserializeEqual(True, 'true')
+        self.assertDeserializeEqual(False, "false")
+        self.assertDeserializeEqual(True, "true")
 
         # json.loads fails, string value is returned.
-        self.assertDeserializeEqual('False', 'False')
-        self.assertDeserializeEqual('True', 'True')
+        self.assertDeserializeEqual("False", "False")
+        self.assertDeserializeEqual("True", "True")
 
         # json.loads deserializes as a string
-        self.assertDeserializeEqual('false', '"false"')
-        self.assertDeserializeEqual('fAlse', '"fAlse"')
+        self.assertDeserializeEqual("false", '"false"')
+        self.assertDeserializeEqual("fAlse", '"fAlse"')
         self.assertDeserializeEqual("TruE", '"TruE"')
 
         # 2.78 can be converted to a bool, so the string will be deserialized
-        self.assertDeserializeEqual(-2.78, '-2.78')
+        self.assertDeserializeEqual(-2.78, "-2.78")
 
         self.assertDeserializeNonString()
 
 
 class TestDeserializeString(TestDeserialize):
-    """ Tests deserialize as related to String type. """
+    """Tests deserialize as related to String type."""
 
     field_type = String
 
     def test_deserialize(self):
-        self.assertDeserializeEqual('hAlf', '"hAlf"')
-        self.assertDeserializeEqual('false', '"false"')
-        self.assertDeserializeEqual('single quote', 'single quote')
+        self.assertDeserializeEqual("hAlf", '"hAlf"')
+        self.assertDeserializeEqual("false", '"false"')
+        self.assertDeserializeEqual("single quote", "single quote")
 
     def test_deserialize_unsupported_types(self):
-        self.assertDeserializeEqual('3.4', '3.4')
-        self.assertDeserializeEqual('false', 'false')
-        self.assertDeserializeEqual('2', '2')
-        self.assertDeserializeEqual('[3]', '[3]')
+        self.assertDeserializeEqual("3.4", "3.4")
+        self.assertDeserializeEqual("false", "false")
+        self.assertDeserializeEqual("2", "2")
+        self.assertDeserializeEqual("[3]", "[3]")
         self.assertDeserializeNonString()
 
 
 class TestDeserializeAny(TestDeserialize):
-    """ Tests deserialize as related to Any type. """
+    """Tests deserialize as related to Any type."""
 
     field_type = Any
 
     def test_deserialize(self):
-        self.assertDeserializeEqual('hAlf', '"hAlf"')
-        self.assertDeserializeEqual('false', '"false"')
-        self.assertDeserializeEqual({'bar': 'hat', 'frog': 'green'}, '{"bar": "hat", "frog": "green"}')
-        self.assertDeserializeEqual([3.5, 5.6], '[3.5, 5.6]')
-        self.assertDeserializeEqual('[', '[')
-        self.assertDeserializeEqual(False, 'false')
-        self.assertDeserializeEqual(3.4, '3.4')
+        self.assertDeserializeEqual("hAlf", '"hAlf"')
+        self.assertDeserializeEqual("false", '"false"')
+        self.assertDeserializeEqual({"bar": "hat", "frog": "green"}, '{"bar": "hat", "frog": "green"}')
+        self.assertDeserializeEqual([3.5, 5.6], "[3.5, 5.6]")
+        self.assertDeserializeEqual("[", "[")
+        self.assertDeserializeEqual(False, "false")
+        self.assertDeserializeEqual(3.4, "3.4")
         self.assertDeserializeNonString()
 
 
 class TestDeserializeList(TestDeserialize):
-    """ Tests deserialize as related to List type. """
+    """Tests deserialize as related to List type."""
 
     field_type = List
 
     def test_deserialize(self):
-        self.assertDeserializeEqual(['foo', 'bar'], '["foo", "bar"]')
-        self.assertDeserializeEqual([3.5, 5.6], '[3.5, 5.6]')
-        self.assertDeserializeEqual([], '[]')
+        self.assertDeserializeEqual(["foo", "bar"], '["foo", "bar"]')
+        self.assertDeserializeEqual([3.5, 5.6], "[3.5, 5.6]")
+        self.assertDeserializeEqual([], "[]")
 
     def test_deserialize_unsupported_types(self):
-        self.assertDeserializeEqual('3.4', '3.4')
-        self.assertDeserializeEqual('false', 'false')
-        self.assertDeserializeEqual('2', '2')
+        self.assertDeserializeEqual("3.4", "3.4")
+        self.assertDeserializeEqual("false", "false")
+        self.assertDeserializeEqual("2", "2")
         self.assertDeserializeNonString()
 
 
 class TestDeserializeDate(TestDeserialize):
-    """ Tests deserialize as related to Date type. """
+    """Tests deserialize as related to Date type."""
 
     field_type = Date
 
     def test_deserialize(self):
-        self.assertDeserializeEqual('2012-12-31T23:59:59Z', "2012-12-31T23:59:59Z")
-        self.assertDeserializeEqual('2012-12-31T23:59:59Z', '"2012-12-31T23:59:59Z"')
+        self.assertDeserializeEqual("2012-12-31T23:59:59Z", "2012-12-31T23:59:59Z")
+        self.assertDeserializeEqual("2012-12-31T23:59:59Z", '"2012-12-31T23:59:59Z"')
         self.assertDeserializeNonString()
 
 
 class TestDeserializeTimedelta(TestDeserialize):
-    """ Tests deserialize as related to Timedelta type. """
+    """Tests deserialize as related to Timedelta type."""
 
     field_type = Timedelta
 
     def test_deserialize(self):
-        self.assertDeserializeEqual(
-            '1 day 12 hours 59 minutes 59 seconds',
-            '1 day 12 hours 59 minutes 59 seconds'
-        )
-        self.assertDeserializeEqual(
-            '1 day 12 hours 59 minutes 59 seconds',
-            '"1 day 12 hours 59 minutes 59 seconds"'
-        )
+        self.assertDeserializeEqual("1 day 12 hours 59 minutes 59 seconds", "1 day 12 hours 59 minutes 59 seconds")
+        self.assertDeserializeEqual("1 day 12 hours 59 minutes 59 seconds", '"1 day 12 hours 59 minutes 59 seconds"')
         self.assertDeserializeNonString()
 
 
 class TestDeserializeRelativeTime(TestDeserialize):
-    """ Tests deserialize as related to Timedelta type. """
+    """Tests deserialize as related to Timedelta type."""
 
     field_type = RelativeTime
 
@@ -586,56 +638,56 @@ def test_deserialize(self):
         """
 
         # test that from_json produces no exceptions
-        self.assertDeserializeEqual('10:20:30', '"10:20:30"')
+        self.assertDeserializeEqual("10:20:30", '"10:20:30"')
 
 
 class TestXmlAttributes(XModuleXmlImportTest):
 
     def test_unknown_attribute(self):
-        assert not hasattr(CourseBlock, 'unknown_attr')
-        course = self.process_xml(CourseFactory.build(unknown_attr='value'))
-        assert not hasattr(course, 'unknown_attr')
-        assert course.xml_attributes['unknown_attr'] == 'value'
+        assert not hasattr(CourseBlock, "unknown_attr")
+        course = self.process_xml(CourseFactory.build(unknown_attr="value"))
+        assert not hasattr(course, "unknown_attr")
+        assert course.xml_attributes["unknown_attr"] == "value"
 
     def test_known_attribute(self):
-        assert hasattr(CourseBlock, 'show_calculator')
-        course = self.process_xml(CourseFactory.build(show_calculator='true'))
+        assert hasattr(CourseBlock, "show_calculator")
+        course = self.process_xml(CourseFactory.build(show_calculator="true"))
         assert course.show_calculator
-        assert 'show_calculator' not in course.xml_attributes
+        assert "show_calculator" not in course.xml_attributes
 
     def test_rerandomize_in_policy(self):
         # Rerandomize isn't a basic attribute of Sequence
-        assert not hasattr(SequenceBlock, 'rerandomize')
+        assert not hasattr(SequenceBlock, "rerandomize")
 
-        root = SequenceFactory.build(policy={'rerandomize': 'never'})
+        root = SequenceFactory.build(policy={"rerandomize": "never"})
         ProblemFactory.build(parent=root)
 
         seq = self.process_xml(root)
 
         # Rerandomize is added to the constructed sequence via the InheritanceMixin
-        assert seq.rerandomize == 'never'
+        assert seq.rerandomize == "never"
 
         # Rerandomize is a known value coming from policy, and shouldn't appear
         # in xml_attributes
-        assert 'rerandomize' not in seq.xml_attributes
+        assert "rerandomize" not in seq.xml_attributes
 
     def test_attempts_in_policy(self):
         # attempts isn't a basic attribute of Sequence
-        assert not hasattr(SequenceBlock, 'attempts')
+        assert not hasattr(SequenceBlock, "attempts")
 
-        root = SequenceFactory.build(policy={'attempts': '1'})
+        root = SequenceFactory.build(policy={"attempts": "1"})
         ProblemFactory.build(parent=root)
 
         seq = self.process_xml(root)
 
         # attempts isn't added to the constructed sequence, because
         # it's not in the InheritanceMixin
-        assert not hasattr(seq, 'attempts')
+        assert not hasattr(seq, "attempts")
 
         # attempts is an unknown attribute, so we should include it
         # in xml_attributes so that it gets written out (despite the misleading
         # name)
-        assert 'attempts' in seq.xml_attributes
+        assert "attempts" in seq.xml_attributes
 
     def check_inheritable_attribute(self, attribute, value):
         # `attribute` isn't a basic attribute of Sequence
@@ -664,6 +716,6 @@ def check_inheritable_attribute(self, attribute, value):
         assert attribute not in seq.xml_attributes
 
     def test_inheritable_attributes(self):
-        self.check_inheritable_attribute('days_early_for_beta', 2)
-        self.check_inheritable_attribute('max_attempts', 5)
-        self.check_inheritable_attribute('visible_to_staff_only', True)
+        self.check_inheritable_attribute("days_early_for_beta", 2)
+        self.check_inheritable_attribute("max_attempts", 5)
+        self.check_inheritable_attribute("visible_to_staff_only", True)
diff --git a/xmodule/util/sandboxing.py b/xmodule/util/sandboxing.py
index 01e897adeca2..f8f952623ecc 100644
--- a/xmodule/util/sandboxing.py
+++ b/xmodule/util/sandboxing.py
@@ -5,14 +5,14 @@
 from django.conf import settings
 from opaque_keys.edx.keys import CourseKey, LearningContextKey
 
-DEFAULT_PYTHON_LIB_FILENAME = 'python_lib.zip'
+DEFAULT_PYTHON_LIB_FILENAME = "python_lib.zip"
 
 
 def course_code_library_asset_name():
     """
     Return the asset name to use for course code libraries, defaulting to python_lib.zip.
     """
-    return getattr(settings, 'PYTHON_LIB_FILENAME', DEFAULT_PYTHON_LIB_FILENAME)
+    return getattr(settings, "PYTHON_LIB_FILENAME", DEFAULT_PYTHON_LIB_FILENAME)
 
 
 def can_execute_unsafe_code(course_id):
@@ -34,7 +34,7 @@ def can_execute_unsafe_code(course_id):
     # in a settings file
     # To others using this: the code as-is is brittle and likely to be changed in the future,
     # as per the TODO, so please consider carefully before adding more values to COURSES_WITH_UNSAFE_CODE
-    for regex in getattr(settings, 'COURSES_WITH_UNSAFE_CODE', []):
+    for regex in getattr(settings, "COURSES_WITH_UNSAFE_CODE", []):
         if re.match(regex, str(course_id)):
             return True
     return False
@@ -63,6 +63,7 @@ class SandboxService:
         contentstore(function): function which creates an instance of xmodule.content.ContentStore
         course_id(string or CourseLocator): identifier for the course
     """
+
     def __init__(self, contentstore, course_id, **kwargs):
         super().__init__(**kwargs)
         self.contentstore = contentstore
diff --git a/xmodule/x_module.py b/xmodule/x_module.py
index 741481268f8d..4ed1a03b619d 100644
--- a/xmodule/x_module.py
+++ b/xmodule/x_module.py
@@ -9,7 +9,6 @@
 from functools import partial
 
 import yaml
-
 from django.conf import settings
 from lxml import etree
 from opaque_keys.edx.asides import AsideDefinitionKeyV2, AsideUsageKeyV2
@@ -18,23 +17,9 @@
 from webob import Response
 from webob.multidict import MultiDict
 from xblock.core import XBlock
-from xblock.fields import (
-    Dict,
-    Float,
-    Integer,
-    List,
-    Scope,
-    String,
-    UserScope
-)
+from xblock.fields import Dict, Float, Integer, List, Scope, String, UserScope
 from xblock.runtime import IdGenerator, IdReader, Runtime
 
-from xmodule import block_metadata_utils
-from xmodule.fields import RelativeTime
-from xmodule.modulestore.exceptions import ItemNotFoundError
-from xmodule.util.builtin_assets import add_webpack_js_to_fragment
-from openedx.core.djangolib.markup import HTML
-
 from common.djangoapps.xblock_django.constants import (
     ATTR_KEY_ANONYMOUS_USER_ID,
     ATTR_KEY_REQUEST_COUNTRY_CODE,
@@ -44,12 +29,16 @@
     ATTR_KEY_USER_IS_STAFF,
     ATTR_KEY_USER_ROLE,
 )
-
+from openedx.core.djangolib.markup import HTML
+from xmodule import block_metadata_utils
+from xmodule.fields import RelativeTime
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.util.builtin_assets import add_webpack_js_to_fragment
 
 log = logging.getLogger(__name__)
 
-XMODULE_METRIC_NAME = 'edxapp.xmodule'
-XMODULE_DURATION_METRIC_NAME = XMODULE_METRIC_NAME + '.duration'
+XMODULE_METRIC_NAME = "edxapp.xmodule"
+XMODULE_DURATION_METRIC_NAME = XMODULE_METRIC_NAME + ".duration"
 XMODULE_METRIC_SAMPLE_RATE = 0.1
 
 # xblock view names
@@ -57,27 +46,27 @@
 # This is the view that will be rendered to display the XBlock in the LMS.
 # It will also be used to render the block in "preview" mode in Studio, unless
 # the XBlock also implements author_view.
-STUDENT_VIEW = 'student_view'
+STUDENT_VIEW = "student_view"
 
 # This is the view that will be rendered to display the XBlock in the LMS for unenrolled learners.
 # Implementations of this view should assume that a user and user data are not available.
-PUBLIC_VIEW = 'public_view'
+PUBLIC_VIEW = "public_view"
 
 # An optional view of the XBlock similar to student_view, but with possible inline
 # editing capabilities. This view differs from studio_view in that it should be as similar to student_view
 # as possible. When previewing XBlocks within Studio, Studio will prefer author_view to student_view.
-AUTHOR_VIEW = 'author_view'
+AUTHOR_VIEW = "author_view"
 
 # The view used to render an editor in Studio. The editor rendering can be completely different
 # from the LMS student_view, and it is only shown when the author selects "Edit".
-STUDIO_VIEW = 'studio_view'
+STUDIO_VIEW = "studio_view"
 
 # Views that present a "preview" view of an xblock (as opposed to an editing view).
 PREVIEW_VIEWS = [STUDENT_VIEW, PUBLIC_VIEW, AUTHOR_VIEW]
 
 DEFAULT_PUBLIC_VIEW_MESSAGE = (
-    'This content is only accessible to enrolled learners. '
-    'Sign in or register, and enroll in this course to view it.'
+    "This content is only accessible to enrolled learners. "
+    "Sign in or register, and enroll in this course to view it."
 )
 
 
@@ -91,6 +80,7 @@ class OpaqueKeyReader(IdReader):
     """
     IdReader for :class:`DefinitionKey` and :class:`UsageKey`s.
     """
+
     def get_definition_id(self, usage_id):
         """Retrieve the definition that a usage is derived from.
 
@@ -168,6 +158,7 @@ class AsideKeyGenerator(IdGenerator):
     """
     An :class:`.IdGenerator` that only provides facilities for constructing new XBlockAsides.
     """
+
     def create_aside(self, definition_id, usage_id, aside_type):
         """
         Make a new aside definition and usage ids, indicating an :class:`.XBlockAside` of type `aside_type`
@@ -208,23 +199,24 @@ def shim_xmodule_js(fragment, js_module_name):
     import webpack_loader.utils  # lint-amnesty, pylint: disable=unused-import
 
     if not fragment.js_init_fn:
-        fragment.initialize_js('XBlockToXModuleShim')
-        fragment.json_init_args = {'xmodule-type': js_module_name}
+        fragment.initialize_js("XBlockToXModuleShim")
+        fragment.json_init_args = {"xmodule-type": js_module_name}
 
-        add_webpack_js_to_fragment(fragment, 'XModuleShim')
+        add_webpack_js_to_fragment(fragment, "XModuleShim")
 
 
 class XModuleFields:
     """
     Common fields for XModules.
     """
+
     display_name = String(
         display_name=_("Display Name"),
         help=_("The display name for this component."),
         scope=Scope.settings,
         # it'd be nice to have a useful default but it screws up other things; so,
         # use display_name_with_default for those
-        default=None
+        default=None,
     )
 
 
@@ -235,6 +227,7 @@ class XModuleMixin(XModuleFields, XBlock):
 
     Adding this Mixin to an :class:`XBlock` allows it to cooperate with old-style :class:`XModules`
     """
+
     # Attributes for inspection of the block
 
     # This indicates whether the xmodule is a problem-type.
@@ -259,7 +252,7 @@ class XModuleMixin(XModuleFields, XBlock):
     # This attribute can be overridden by subclasses, and
     # the function can also be overridden if the icon class depends on the data
     # in the module
-    icon_class = 'other'
+    icon_class = "other"
 
     def __init__(self, *args, **kwargs):
         self._asides = []
@@ -269,7 +262,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def get_cds_init_args(self):
-        """ Get initialization data used by SplitModuleStoreRuntime to defer FieldData initialization """
+        """Get initialization data used by SplitModuleStoreRuntime to defer FieldData initialization"""
         if self._cds_init_args is None:
             raise KeyError("cds_init_args was not provided for this XBlock")
         if self._cds_init_args is False:
@@ -295,8 +288,9 @@ def xmodule_runtime(self):
         Deprecated in favor of the runtime property.
         """
         warnings.warn(
-            'xmodule_runtime property is deprecated. Please use the runtime property instead.',
-            DeprecationWarning, stacklevel=3,
+            "xmodule_runtime property is deprecated. Please use the runtime property instead.",
+            DeprecationWarning,
+            stacklevel=3,
         )
         return self.runtime
 
@@ -308,8 +302,9 @@ def system(self):
         Deprecated in favor of the runtime property.
         """
         warnings.warn(
-            'system property is deprecated. Please use the runtime property instead.',
-            DeprecationWarning, stacklevel=3,
+            "system property is deprecated. Please use the runtime property instead.",
+            DeprecationWarning,
+            stacklevel=3,
         )
         return self.runtime
 
@@ -403,9 +398,7 @@ def get_explicitly_set_fields_by_scope(self, scope=Scope.content):
                     result[field.name] = field.read_json(self)
                 except TypeError as exception:
                     exception_message = "{message}, Block-location:{location}, Field-name:{field_name}".format(
-                        message=str(exception),
-                        location=str(self.location),
-                        field_name=field.name
+                        message=str(exception), location=str(self.location), field_name=field.name
                     )
                     raise TypeError(exception_message)  # lint-amnesty, pylint: disable=raise-missing-from
         return result
@@ -467,12 +460,7 @@ def get_children(self, usage_id_filter=None, usage_key_filter=None):  # pylint:
         if usage_id_filter is None and usage_key_filter is not None:
             usage_id_filter = usage_key_filter
 
-        return [
-            child
-            for child
-            in super().get_children(usage_id_filter)
-            if child is not None
-        ]
+        return [child for child in super().get_children(usage_id_filter) if child is not None]
 
     def get_child(self, usage_id):
         """
@@ -482,7 +470,7 @@ def get_child(self, usage_id):
         try:
             child = super().get_child(usage_id)
         except ItemNotFoundError:
-            log.warning('Unable to load item %s, skipping', usage_id)
+            log.warning("Unable to load item %s, skipping", usage_id)
             return None
 
         if child is None:
@@ -544,19 +532,19 @@ def get_score(self):
         return None
 
     def max_score(self):
-        """ Maximum score. Two notes:
+        """Maximum score. Two notes:
 
-            * This is generic; in abstract, a problem could be 3/5 points on one
-              randomization, and 5/7 on another
+        * This is generic; in abstract, a problem could be 3/5 points on one
+          randomization, and 5/7 on another
 
-            * In practice, this is a Very Bad Idea, and (a) will break some code
-              in place (although that code should get fixed), and (b) break some
-              analytics we plan to put in place.
+        * In practice, this is a Very Bad Idea, and (a) will break some code
+          in place (although that code should get fixed), and (b) break some
+          analytics we plan to put in place.
         """
         return None
 
     def get_progress(self):
-        """ Return a progress.Progress object that represents how far the
+        """Return a progress.Progress object that represents how far the
         student has gone in this module.  Must be implemented to get correct
         progress tracking behavior in nesting modules like sequence and
         vertical.
@@ -579,8 +567,8 @@ def bind_for_student(self, user_id, wrappers=None):
 
         # Skip rebinding if we're already bound a user, and it's this user.
         if self.scope_ids.user_id is not None and user_id == self.scope_ids.user_id:
-            if getattr(self.runtime, 'position', None):
-                self.position = self.runtime.position   # update the position of the tab
+            if getattr(self.runtime, "position", None):
+                self.position = self.runtime.position  # update the position of the tab
             return
 
         # If we are switching users mid-request, save the data from the old user.
@@ -608,7 +596,7 @@ def bind_for_student(self, user_id, wrappers=None):
         if wrappers:
             # Put user-specific wrappers around the field-data service for this block.
             # Note that these are different from modulestore.xblock_field_data_wrappers, which are not user-specific.
-            wrapped_field_data = self.runtime.service(self, 'field-data-unbound')
+            wrapped_field_data = self.runtime.service(self, "field-data-unbound")
             for wrapper in wrappers:
                 wrapped_field_data = wrapper(wrapped_field_data)
             self._bound_field_data = wrapped_field_data
@@ -637,7 +625,7 @@ def editable_metadata_fields(self):
         metadata_fields = {}
 
         # Only use the fields from this class, not mixins
-        fields = getattr(self, 'unmixed_class', self.__class__).fields
+        fields = getattr(self, "unmixed_class", self.__class__).fields
 
         for field in fields.values():
             if field in self.non_editable_metadata_fields:
@@ -653,16 +641,17 @@ def _create_metadata_editor_info(self, field):
         """
         Creates the information needed by the metadata editor for a specific field.
         """
+
         def jsonify_value(field, json_choice):
             """
             Convert field value to JSON, if needed.
             """
             if isinstance(json_choice, dict):
                 new_json_choice = dict(json_choice)  # make a copy so below doesn't change the original
-                if 'display_name' in json_choice:
-                    new_json_choice['display_name'] = get_text(json_choice['display_name'])
-                if 'value' in json_choice:
-                    new_json_choice['value'] = field.to_json(json_choice['value'])
+                if "display_name" in json_choice:
+                    new_json_choice["display_name"] = get_text(json_choice["display_name"])
+                if "value" in json_choice:
+                    new_json_choice["value"] = field.to_json(json_choice["value"])
             else:
                 new_json_choice = field.to_json(json_choice)
             return new_json_choice
@@ -676,10 +665,10 @@ def get_text(value):
 
         # gets the 'default_value' and 'explicitly_set' attrs
         metadata_field_editor_info = self.runtime.get_field_provenance(self, field)
-        metadata_field_editor_info['field_name'] = field.name
-        metadata_field_editor_info['display_name'] = get_text(field.display_name)
-        metadata_field_editor_info['help'] = get_text(field.help)
-        metadata_field_editor_info['value'] = field.read_json(self)
+        metadata_field_editor_info["field_name"] = field.name
+        metadata_field_editor_info["display_name"] = get_text(field.display_name)
+        metadata_field_editor_info["help"] = get_text(field.help)
+        metadata_field_editor_info["value"] = field.read_json(self)
 
         # We support the following editors:
         # 1. A select editor for fields with a list of possible values (includes Booleans).
@@ -688,7 +677,7 @@ def get_text(value):
         editor_type = "Generic"
         values = field.values
         if "values_provider" in field.runtime_options:
-            values = field.runtime_options['values_provider'](self)
+            values = field.runtime_options["values_provider"](self)
         if isinstance(values, (tuple, list)) and len(values) > 0:
             editor_type = "Select"
             values = [jsonify_value(field, json_choice) for json_choice in values]
@@ -704,8 +693,8 @@ def get_text(value):
             editor_type = "RelativeTime"
         elif isinstance(field, String) and field.name == "license":
             editor_type = "License"
-        metadata_field_editor_info['type'] = editor_type
-        metadata_field_editor_info['options'] = [] if values is None else values
+        metadata_field_editor_info["type"] = editor_type
+        metadata_field_editor_info["options"] = [] if values is None else values
 
         return metadata_field_editor_info
 
@@ -721,11 +710,9 @@ def public_view(self, _context):
 
         if self.display_name:
             display_text = _(
-                '{display_name} is only accessible to enrolled learners. '
-                'Sign in or register, and enroll in this course to view it.'
-            ).format(
-                display_name=self.display_name
-            )
+                "{display_name} is only accessible to enrolled learners. "
+                "Sign in or register, and enroll in this course to view it."
+            ).format(display_name=self.display_name)
         else:
             display_text = _(DEFAULT_PUBLIC_VIEW_MESSAGE)  # lint-amnesty, pylint: disable=translation-of-non-string
 
@@ -736,18 +723,20 @@ class XModuleToXBlockMixin:
     """
     Common code needed by XModule and XBlocks converted from XModules.
     """
+
     @property
     def ajax_url(self):
         """
         Returns the URL for the ajax handler.
         """
-        return self.runtime.handler_url(self, 'xmodule_handler', '', '').rstrip('/?')
+        return self.runtime.handler_url(self, "xmodule_handler", "", "").rstrip("/?")
 
     @XBlock.handler
     def xmodule_handler(self, request, suffix=None):
         """
         XBlock handler that wraps `handle_ajax`
         """
+
         class FileObjForWebobFiles:
             """
             Turn Webob cgi.FieldStorage uploaded files into pure file objects.
@@ -758,6 +747,7 @@ class FileObjForWebobFiles:
             name, so we carry the FieldStorage .filename attribute as the .name.
 
             """
+
             def __init__(self, webob_file):
                 self.file = webob_file.file
                 self.name = webob_file.filename
@@ -773,7 +763,7 @@ def __getattr__(self, name):
                 request_post[key] = list(map(FileObjForWebobFiles, request.POST.getall(key)))
 
         response_data = self.handle_ajax(suffix, request_post)
-        return Response(response_data, content_type='application/json', charset='UTF-8')
+        return Response(response_data, content_type="application/json", charset="UTF-8")
 
 
 def policy_key(location):
@@ -781,7 +771,7 @@ def policy_key(location):
     Get the key for a location in a policy file.  (Since the policy file is
     specific to a course, it doesn't need the full location url).
     """
-    return f'{location.block_type}/{location.block_id}'
+    return f"{location.block_type}/{location.block_id}"
 
 
 Template = namedtuple("Template", "metadata data children")
@@ -800,6 +790,7 @@ class ResourceTemplates:
     Note that a template must end with ".yaml" extension otherwise it will not be
     loaded.
     """
+
     template_packages = [__name__]
 
     @classmethod
@@ -813,7 +804,7 @@ def _load_template(cls, template_path, template_id):
 
         with open(template_path) as file_object:
             template = yaml.safe_load(file_object)
-            template['template_id'] = template_id
+            template["template_id"] = template_id
             return template
 
     @classmethod
@@ -823,7 +814,7 @@ def _load_templates_in_dir(cls, dirpath):
         """
         templates = []
         for template_file in os.listdir(dirpath):
-            if not template_file.endswith('.yaml'):
+            if not template_file.endswith(".yaml"):
                 log.warning("Skipping unknown template file %s", template_file)
                 continue
 
@@ -844,21 +835,23 @@ def templates(cls):
 
         for dirpath in cls.get_template_dirpaths():
             for template in cls._load_templates_in_dir(dirpath):
-                templates[template['template_id']] = template
+                templates[template["template_id"]] = template
 
         return list(templates.values())
 
     @classmethod
     def get_template_dir(cls):  # lint-amnesty, pylint: disable=missing-function-docstring
-        if getattr(cls, 'template_dir_name', None):
-            dirname = os.path.join('templates', cls.template_dir_name)  # lint-amnesty, pylint: disable=no-member
-            template_path = resources.files(__name__.rsplit('.', 1)[0]) / dirname
+        if getattr(cls, "template_dir_name", None):
+            dirname = os.path.join("templates", cls.template_dir_name)  # lint-amnesty, pylint: disable=no-member
+            template_path = resources.files(__name__.rsplit(".", 1)[0]) / dirname
 
             if not template_path.is_dir():
-                log.warning("No resource directory {dir} found when loading {cls_name} templates".format(
-                    dir=dirname,
-                    cls_name=cls.__name__,
-                ))
+                log.warning(
+                    "No resource directory {dir} found when loading {cls_name} templates".format(
+                        dir=dirname,
+                        cls_name=cls.__name__,
+                    )
+                )
                 return
             return dirname
         return
@@ -871,7 +864,7 @@ def get_template_dirpaths(cls):
         template_dirpaths = []
         template_dirname = cls.get_template_dir()
         if template_dirname:
-            template_path = resources.files(__name__.rsplit('.', 1)[0]) / template_dirname
+            template_path = resources.files(__name__.rsplit(".", 1)[0]) / template_dirname
             if template_path.is_dir():
                 with resources.as_file(template_path) as template_real_path:
                     template_dirpaths.append(str(template_real_path))
@@ -887,7 +880,7 @@ def get_custom_template_dir(cls):
         If settings.CUSTOM_RESOURCE_TEMPLATES_DIRECTORY is defined, check if it has a
         subdirectory named as the class's template_dir_name and return the full path.
         """
-        template_dir_name = getattr(cls, 'template_dir_name', None)
+        template_dir_name = getattr(cls, "template_dir_name", None)
 
         if template_dir_name is None:
             return
@@ -919,6 +912,7 @@ class _ConfigurableFragmentWrapper:
     """
     Runtime mixin that allows for composition of many `wrap_xblock` wrappers
     """
+
     def __init__(self, wrappers=None, wrappers_asides=None, **kwargs):
         """
         :param wrappers: A list of wrappers, where each wrapper is:
@@ -946,7 +940,7 @@ def wrap_xblock(self, block, view, frag, context):
 
         return frag
 
-    def wrap_aside(self, block, aside, view, frag, context):    # pylint: disable=unused-argument
+    def wrap_aside(self, block, aside, view, frag, context):  # pylint: disable=unused-argument
         """
         See :func:`Runtime.wrap_child`
         """
@@ -962,7 +956,7 @@ def wrap_aside(self, block, aside, view, frag, context):    # pylint: disable=un
 # Runtime.handler_url interface.
 #
 # The monkey-patching happens in cms/djangoapps/xblock_config/apps.py and lms/djangoapps/lms_xblock/apps.py
-def block_global_handler_url(block, handler_name, suffix='', query='', thirdparty=False):
+def block_global_handler_url(block, handler_name, suffix="", query="", thirdparty=False):
     """
     See :meth:`xblock.runtime.Runtime.handler_url`.
     """
@@ -978,7 +972,9 @@ def block_global_local_resource_url(block, uri):
     """
     See :meth:`xblock.runtime.Runtime.local_resource_url`.
     """
-    raise NotImplementedError("Applications must monkey-patch this function before using local_resource_url for studio_view")  # lint-amnesty, pylint: disable=line-too-long
+    raise NotImplementedError(
+        "Applications must monkey-patch this function before using local_resource_url for studio_view"
+    )  # lint-amnesty, pylint: disable=line-too-long
 
 
 class _MetricsMixin:
@@ -999,10 +995,12 @@ def render(self, block, view_name, context=None):  # lint-amnesty, pylint: disab
                 duration,
                 block.__class__.__name__,
                 view_name,
-                getattr(block, 'location', ''),
+                getattr(block, "location", ""),
             )
 
-    def handle(self, block, handler_name, request, suffix=''):  # lint-amnesty, pylint: disable=missing-function-docstring
+    def handle(
+        self, block, handler_name, request, suffix=""
+    ):  # lint-amnesty, pylint: disable=missing-function-docstring
         start_time = time.time()
         try:
             return super().handle(block, handler_name, request, suffix=suffix)
@@ -1014,7 +1012,7 @@ def handle(self, block, handler_name, request, suffix=''):  # lint-amnesty, pyli
                 duration,
                 block.__class__.__name__,
                 handler_name,
-                getattr(block, 'location', ''),
+                getattr(block, "location", ""),
             )
 
 
@@ -1036,10 +1034,11 @@ def anonymous_student_id(self):
               use `ATTR_KEY_DEPRECATED_ANONYMOUS_USER_ID` from the user service.
         """
         warnings.warn(
-            'runtime.anonymous_student_id is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=3,
+            "runtime.anonymous_student_id is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=3,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_ANONYMOUS_USER_ID)
         return None
@@ -1053,8 +1052,9 @@ def seed(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.seed is deprecated. Please use the user service `user_id` instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.seed is deprecated. Please use the user service `user_id` instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
         return self.user_id or 0
 
@@ -1066,10 +1066,11 @@ def user_id(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.user_id is deprecated. Use block.scope_ids.user_id or the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.user_id is deprecated. Use block.scope_ids.user_id or the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_USER_ID)
         return None
@@ -1082,10 +1083,11 @@ def user_is_staff(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.user_is_staff is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.user_is_staff is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_STAFF)
         return None
@@ -1098,10 +1100,11 @@ def user_location(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.user_location is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.user_location is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_REQUEST_COUNTRY_CODE)
         return None
@@ -1118,10 +1121,11 @@ def get_real_user(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.get_real_user is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.get_real_user is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_user_by_anonymous_id
         return None
@@ -1136,10 +1140,11 @@ def get_user_role(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.get_user_role is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.get_user_role is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return partial(user_service.get_current_user().opt_attrs.get, ATTR_KEY_USER_ROLE)
 
@@ -1151,10 +1156,11 @@ def user_is_beta_tester(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.user_is_beta_tester is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.user_is_beta_tester is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_BETA_TESTER)
 
@@ -1166,10 +1172,11 @@ def user_is_admin(self):
         Deprecated in favor of the user service.
         """
         warnings.warn(
-            'runtime.user_is_admin is deprecated. Please use the user service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.user_is_admin is deprecated. Please use the user service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        user_service = self._services.get('user')
+        user_service = self._services.get("user")
         if user_service:
             return user_service.get_current_user().opt_attrs.get(ATTR_KEY_USER_IS_GLOBAL_STAFF)
 
@@ -1181,13 +1188,14 @@ def render_template(self):
         Deprecated in favor of the mako service.
         """
         warnings.warn(
-            'Use of runtime.render_template is deprecated. '
-            'Use MakoService.render_template or a JavaScript-based template instead.',
-            DeprecationWarning, stacklevel=2,
+            "Use of runtime.render_template is deprecated. "
+            "Use MakoService.render_template or a JavaScript-based template instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        if hasattr(self, '_deprecated_render_template'):
+        if hasattr(self, "_deprecated_render_template"):
             return self._deprecated_render_template
-        render_service = self._services.get('mako')
+        render_service = self._services.get("mako")
         if render_service:
             return render_service.render_template
         return None
@@ -1210,10 +1218,11 @@ def can_execute_unsafe_code(self):
         Deprecated in favor of the sandbox service.
         """
         warnings.warn(
-            'runtime.can_execute_unsafe_code is deprecated. Please use the sandbox service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.can_execute_unsafe_code is deprecated. Please use the sandbox service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        sandbox_service = self._services.get('sandbox')
+        sandbox_service = self._services.get("sandbox")
         if sandbox_service:
             return sandbox_service.can_execute_unsafe_code
         # Default to saying "no unsafe code".
@@ -1230,10 +1239,11 @@ def get_python_lib_zip(self):
         Deprecated in favor of the sandbox service.
         """
         warnings.warn(
-            'runtime.get_python_lib_zip is deprecated. Please use the sandbox service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.get_python_lib_zip is deprecated. Please use the sandbox service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        sandbox_service = self._services.get('sandbox')
+        sandbox_service = self._services.get("sandbox")
         if sandbox_service:
             return sandbox_service.get_python_lib_zip
         # Default to saying "no lib data"
@@ -1249,10 +1259,11 @@ def cache(self):
         Deprecated in favor of the cache service.
         """
         warnings.warn(
-            'runtime.cache is deprecated. Please use the cache service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.cache is deprecated. Please use the cache service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
-        return self._services.get('cache') or DoNothingCache()
+        return self._services.get("cache") or DoNothingCache()
 
     @property
     def filestore(self):
@@ -1262,8 +1273,9 @@ def filestore(self):
         Deprecated in favor of runtime.resources_fs property.
         """
         warnings.warn(
-            'runtime.filestore is deprecated. Please use the runtime.resources_fs service instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.filestore is deprecated. Please use the runtime.resources_fs service instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
         return self.resources_fs
 
@@ -1275,8 +1287,9 @@ def node_path(self):
         Deprecated.
         """
         warnings.warn(
-            'node_path is deprecated. Please use other methods of finding the node_modules location.',
-            DeprecationWarning, stacklevel=2,
+            "node_path is deprecated. Please use other methods of finding the node_modules location.",
+            DeprecationWarning,
+            stacklevel=2,
         )
 
     @property
@@ -1286,8 +1299,9 @@ def hostname(self):
         Deprecated in favour of direct import of `django.conf.settings`
         """
         warnings.warn(
-            'runtime.hostname is deprecated. Please use `LMS_BASE` from `django.conf.settings`.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.hostname is deprecated. Please use `LMS_BASE` from `django.conf.settings`.",
+            DeprecationWarning,
+            stacklevel=2,
         )
         return settings.LMS_BASE
 
@@ -1301,9 +1315,10 @@ def rebind_noauth_module_to_user(self):
         """
         warnings.warn(
             "rebind_noauth_module_to_user is deprecated. Please use the 'rebind_user' service instead.",
-            DeprecationWarning, stacklevel=2,
+            DeprecationWarning,
+            stacklevel=2,
         )
-        rebind_user_service = self._services.get('rebind_user')
+        rebind_user_service = self._services.get("rebind_user")
         if rebind_user_service:
             return partial(rebind_user_service.rebind_noauth_module_to_user)
 
@@ -1315,8 +1330,9 @@ def STATIC_URL(self):  # pylint: disable=invalid-name
         Deprecated in favor of the settings.STATIC_URL configuration.
         """
         warnings.warn(
-            'runtime.STATIC_URL is deprecated. Please use settings.STATIC_URL instead.',
-            DeprecationWarning, stacklevel=2,
+            "runtime.STATIC_URL is deprecated. Please use settings.STATIC_URL instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
         return settings.STATIC_URL
 
@@ -1329,9 +1345,10 @@ def course_id(self):
         """
         warnings.warn(
             "`runtime.course_id` is deprecated. Use `context_key` instead: `block.scope_ids.usage_id.context_key`.",
-            DeprecationWarning, stacklevel=2,
+            DeprecationWarning,
+            stacklevel=2,
         )
-        if hasattr(self, '_deprecated_course_id'):
+        if hasattr(self, "_deprecated_course_id"):
             return self._deprecated_course_id.for_branch(None)
 
     @course_id.setter
@@ -1346,6 +1363,7 @@ class ModuleStoreRuntime(_MetricsMixin, _ConfigurableFragmentWrapper, _ModuleSys
     """
     Base class for :class:`Runtime`s to be used with :class:`XBlock`s loaded from ModuleStore.
     """
+
     def __init__(
         self,
         load_item,
@@ -1354,7 +1372,7 @@ def __init__(
         get_policy=None,
         render_template=None,
         disabled_xblock_types=lambda: [],
-        **kwargs
+        **kwargs,
     ):
         """
         load_item: Takes a Location and returns an XModuleDescriptor
@@ -1374,8 +1392,8 @@ def __init__(
         local_resource_url: an implementation of :meth:`xblock.runtime.Runtime.local_resource_url`
 
         """
-        kwargs.setdefault('id_reader', OpaqueKeyReader())
-        kwargs.setdefault('id_generator', AsideKeyGenerator())
+        kwargs.setdefault("id_reader", OpaqueKeyReader())
+        kwargs.setdefault("id_generator", AsideKeyGenerator())
         super().__init__(**kwargs)
 
         # This is used by XModules to write out separate files during xml export
@@ -1398,14 +1416,15 @@ def __init__(
             # a few cases where the MakoService is not added to the XBlock's runtime. Specifically: * in the Instructor
             # Dashboard bulk emails tab, when rendering the HtmlBlock for its WYSIWYG editor. * during testing, when
             # fetching factory-created blocks.
-            if 'mako' not in self._services:
+            if "mako" not in self._services:
                 from common.djangoapps.edxmako.services import MakoService
-                self._services['mako'] = MakoService()
+
+                self._services["mako"] = MakoService()
 
         self.disabled_xblock_types = disabled_xblock_types
 
     def get(self, attr):
-        """	provide uniform access to attributes (like etree)."""
+        """provide uniform access to attributes (like etree)."""
         return self.__dict__.get(attr)
 
     def set(self, attr, val):
@@ -1418,7 +1437,7 @@ def get_block(self, usage_id, for_parent=None):
         # get_block_for_descriptor property is used to bind additional data such as user data
         # to the XBlock and to check if the user has access to the block as may be required for
         # the LMS or Preview.
-        if getattr(self, 'get_block_for_descriptor', None):
+        if getattr(self, "get_block_for_descriptor", None):
             return self.get_block_for_descriptor(block)
         return block
 
@@ -1447,18 +1466,18 @@ def get_field_provenance(self, xblock, field):
         # about the kvs, dbmodel, etc.
 
         result = {}
-        result['explicitly_set'] = xblock._field_data.has(xblock, field.name)
+        result["explicitly_set"] = xblock._field_data.has(xblock, field.name)
         try:
-            result['default_value'] = xblock._field_data.default(xblock, field.name)
+            result["default_value"] = xblock._field_data.default(xblock, field.name)
         except KeyError:
-            result['default_value'] = field.to_json(field.default)
+            result["default_value"] = field.to_json(field.default)
         return result
 
-    def handler_url(self, block, handler_name, suffix='', query='', thirdparty=False):
+    def handler_url(self, block, handler_name, suffix="", query="", thirdparty=False):
         # When the Modulestore instantiates ModuleStoreRuntime, we will reference a
         # global function that the application can override, unless a specific function is
         # defined for LMS/CMS through the handler_url_override property.
-        if getattr(self, 'handler_url_override', None):
+        if getattr(self, "handler_url_override", None):
             return self.handler_url_override(block, handler_name, suffix, query, thirdparty)
         return block_global_handler_url(block, handler_name, suffix, query, thirdparty)
 
@@ -1478,7 +1497,7 @@ def applicable_aside_types(self, block):
         """
         # applicable_aside_types_override property can be used by LMS/CMS to define specific filters
         # and conditions as may be applicable.
-        if getattr(self, 'applicable_aside_types_override', None):
+        if getattr(self, "applicable_aside_types_override", None):
             return self.applicable_aside_types_override(block, applicable_aside_types=super().applicable_aside_types)
 
         potential_set = set(super().applicable_aside_types(block))
@@ -1492,7 +1511,7 @@ def resource_url(self, resource):
 
     def add_block_as_child_node(self, block, node):
         child = etree.SubElement(node, block.category)
-        child.set('url_name', block.url_name)
+        child.set("url_name", block.url_name)
         block.add_xml_to_node(child)
 
     def publish(self, block, event_type, event):  # lint-amnesty, pylint: disable=arguments-differ
@@ -1500,7 +1519,7 @@ def publish(self, block, event_type, event):  # lint-amnesty, pylint: disable=ar
         Publish events through the `EventPublishingService`.
         This ensures that the correct track method is used for Instructor tasks.
         """
-        if publish_service := self._services.get('publish'):
+        if publish_service := self._services.get("publish"):
             publish_service.publish(block, event_type, event)
 
     def service(self, block, service_name):
@@ -1527,19 +1546,20 @@ def service(self, block, service_name):
 
     def wrap_aside(self, block, aside, view, frag, context):
         # LMS/CMS can define custom wrap aside using wrap_asides_override as required.
-        if getattr(self, 'wrap_asides_override', None):
+        if getattr(self, "wrap_asides_override", None):
             return self.wrap_asides_override(block, aside, view, frag, context, request_token=self.request_token)
         return super().wrap_aside(block, aside, view, frag, context)
 
     def layout_asides(self, block, context, frag, view_name, aside_frag_fns):
         # LMS/CMS can define custom layout aside using layout_asides_override as required.
-        if getattr(self, 'layout_asides_override', None):
+        if getattr(self, "layout_asides_override", None):
             return self.layout_asides_override(block, context, frag, view_name, aside_frag_fns)
         return super().layout_asides(block, context, frag, view_name, aside_frag_fns)
 
 
 class DoNothingCache:
     """A duck-compatible object to use in ModuleSystemShim when there's no cache."""
+
     def get(self, _key):
         return None
 
diff --git a/xmodule/xml_block.py b/xmodule/xml_block.py
index 752fe5a8a912..a589b53d2ae3 100644
--- a/xmodule/xml_block.py
+++ b/xmodule/xml_block.py
@@ -10,13 +10,14 @@
 from xblock.core import XML_NAMESPACES
 from xblock.fields import Dict, Scope, ScopeIds
 from xblock.runtime import KvsFieldData
+
 from xmodule.modulestore import EdxJSONEncoder
 from xmodule.modulestore.inheritance import InheritanceKeyValueStore, own_metadata
 
 log = logging.getLogger(__name__)
 
 # assume all XML files are persisted as utf-8.
-EDX_XML_PARSER = XMLParser(dtd_validation=False, load_dtd=False, remove_blank_text=True, encoding='utf-8')
+EDX_XML_PARSER = XMLParser(dtd_validation=False, load_dtd=False, remove_blank_text=True, encoding="utf-8")
 
 
 def name_to_pathname(name):
@@ -24,7 +25,7 @@ def name_to_pathname(name):
     Convert a location name for use in a path: replace ':' with '/'.
     This allows users of the xml format to organize content into directories
     """
-    return name.replace(':', '/')
+    return name.replace(":", "/")
 
 
 def is_pointer_tag(xml_obj):
@@ -40,9 +41,9 @@ def is_pointer_tag(xml_obj):
     Returns a bool.
     """
     if xml_obj.tag != "course":
-        expected_attr = {'url_name'}
+        expected_attr = {"url_name"}
     else:
-        expected_attr = {'url_name', 'course', 'org'}
+        expected_attr = {"url_name", "course", "org"}
 
     actual_attr = set(xml_obj.attrib.keys())
 
@@ -62,7 +63,7 @@ def serialize_field(value):
         return value
     elif isinstance(value, datetime.datetime):
         if value.tzinfo is not None and value.utcoffset() is None:
-            return value.isoformat() + 'Z'
+            return value.isoformat() + "Z"
         return value.isoformat()
 
     return json.dumps(value, cls=EdxJSONEncoder)
@@ -104,49 +105,58 @@ class XmlMixin:
     """
     Class containing XML parsing functionality shared between XBlock and XModuleDescriptor.
     """
+
     resources_dir = None
 
     # Extension to append to filename paths
-    filename_extension = 'xml'
-
-    xml_attributes = Dict(help="Map of unhandled xml attributes, used only for storage between import and export",
-                          default={}, scope=Scope.settings)
-
-    metadata_to_strip = ('data_dir',
-                         'tabs', 'grading_policy',
-                         'discussion_blackouts',
-                         # VS[compat]
-                         # These attributes should have been removed from here once all 2012-fall courses imported into
-                         # the CMS and "inline" OLX format deprecated. But, it never got deprecated. Moreover, it's
-                         # widely used to this date. So, we still have to strip them. Also, removing of "filename"
-                         # changes OLX returned by `/api/olx-export/v1/xblock/{block_id}/`, which indicates that some
-                         # places in the platform rely on it.
-                         'course', 'org', 'url_name', 'filename',
-                         # Used for storing xml attributes between import and export, for roundtrips
-                         'xml_attributes',
-                         # Used by _import_xml_node_to_parent in cms/djangoapps/contentstore/helpers.py to prevent
-                         # XmlMixin from treating some XML nodes as "pointer nodes".
-                         "x-is-pointer-node",
-                         )
+    filename_extension = "xml"
+
+    xml_attributes = Dict(
+        help="Map of unhandled xml attributes, used only for storage between import and export",
+        default={},
+        scope=Scope.settings,
+    )
+
+    metadata_to_strip = (
+        "data_dir",
+        "tabs",
+        "grading_policy",
+        "discussion_blackouts",
+        # VS[compat]
+        # These attributes should have been removed from here once all 2012-fall courses imported into
+        # the CMS and "inline" OLX format deprecated. But, it never got deprecated. Moreover, it's
+        # widely used to this date. So, we still have to strip them. Also, removing of "filename"
+        # changes OLX returned by `/api/olx-export/v1/xblock/{block_id}/`, which indicates that some
+        # places in the platform rely on it.
+        "course",
+        "org",
+        "url_name",
+        "filename",
+        # Used for storing xml attributes between import and export, for roundtrips
+        "xml_attributes",
+        # Used by _import_xml_node_to_parent in cms/djangoapps/contentstore/helpers.py to prevent
+        # XmlMixin from treating some XML nodes as "pointer nodes".
+        "x-is-pointer-node",
+    )
 
     # This is a categories to fields map that contains the block category specific fields which should not be
     # cleaned and/or override while adding xml to node.
     metadata_to_not_to_clean = {
         # A category `video` having `sub` and `transcripts` fields
         # which should not be cleaned/override in an xml object.
-        'video': ('sub', 'transcripts')
+        "video": ("sub", "transcripts")
     }
 
-    metadata_to_export_to_policy = ('discussion_topics',)
+    metadata_to_export_to_policy = ("discussion_topics",)
 
     @staticmethod
     def _get_metadata_from_xml(xml_object, remove=True):
         """
         Extract the metadata from the XML.
         """
-        meta = xml_object.find('meta')
+        meta = xml_object.find("meta")
         if meta is None:
-            return ''
+            return ""
         dmdata = meta.text
         if remove:
             xml_object.remove(meta)
@@ -169,9 +179,11 @@ def clean_metadata_from_xml(cls, xml_object, excluded_fields=()):
         xml_object
         """
         for field_name, field in cls.fields.items():
-            if (field.scope == Scope.settings
-                    and field_name not in excluded_fields
-                    and xml_object.get(field_name) is not None):
+            if (
+                field.scope == Scope.settings
+                and field_name not in excluded_fields
+                and xml_object.get(field_name) is not None
+            ):
                 del xml_object.attrib[field_name]
 
     @classmethod
@@ -197,7 +209,7 @@ def load_file(cls, filepath, fs, def_id):  # pylint: disable=invalid-name
                 return cls.file_to_xml(xml_file)
         except Exception as err:  # lint-amnesty, pylint: disable=broad-except
             # Add info about where we are, but keep the traceback
-            raise Exception(f'Unable to load file contents at path {filepath} for item {def_id}: {err}') from err
+            raise Exception(f"Unable to load file contents at path {filepath} for item {def_id}: {err}") from err
 
     @classmethod
     def load_definition(cls, xml_object, system, def_id, id_generator):
@@ -216,10 +228,10 @@ def load_definition(cls, xml_object, system, def_id, id_generator):
         # VS[compat]
         # The filename attr should have been removed once all 2012-fall courses imported into the CMS and "inline" OLX
         # format deprecated. This never happened, and `filename` is still used, so we have too keep both formats.
-        filename = xml_object.get('filename')
+        filename = xml_object.get("filename")
         if filename is None:
             definition_xml = copy.deepcopy(xml_object)
-            filepath = ''
+            filepath = ""
             aside_children = []
         else:
             filepath = cls._format_filepath(xml_object.tag, filename)
@@ -228,7 +240,7 @@ def load_definition(cls, xml_object, system, def_id, id_generator):
             # If the file doesn't exist at the right path, give the class a chance to fix it up. The file will be
             # written out again in the correct format. This should have gone away once the CMS became online and had
             # imported all 2012-fall courses from XML.
-            if not system.resources_fs.exists(filepath) and hasattr(cls, 'backcompat_paths'):
+            if not system.resources_fs.exists(filepath) and hasattr(cls, "backcompat_paths"):
                 candidates = cls.backcompat_paths(filepath)
                 for candidate in candidates:
                     if system.resources_fs.exists(candidate):
@@ -246,11 +258,11 @@ def load_definition(cls, xml_object, system, def_id, id_generator):
         cls.clean_metadata_from_xml(definition_xml)
         definition, children = cls.definition_from_xml(definition_xml, system)
         if definition_metadata:
-            definition['definition_metadata'] = definition_metadata
-        definition['filename'] = [filepath, filename]
+            definition["definition_metadata"] = definition_metadata
+        definition["filename"] = [filepath, filename]
 
         if aside_children:
-            definition['aside_children'] = aside_children
+            definition["aside_children"] = aside_children
 
         return definition, children
 
@@ -261,7 +273,7 @@ def load_metadata(cls, xml_object):
 
         Returns a dictionary {key: value}.
         """
-        metadata = {'xml_attributes': {}}
+        metadata = {"xml_attributes": {}}
         for attr, val in xml_object.attrib.items():
 
             if attr in cls.metadata_to_strip:
@@ -269,7 +281,7 @@ def load_metadata(cls, xml_object):
                 continue
 
             if attr not in cls.fields:
-                metadata['xml_attributes'][attr] = val
+                metadata["xml_attributes"][attr] = val
             else:
                 metadata[attr] = deserialize_field(cls.fields[attr], val)
         return metadata
@@ -284,7 +296,7 @@ def apply_policy(cls, metadata, policy):
             if attr not in cls.fields:
                 # Store unknown attributes coming from policy.json
                 # in such a way that they will export to xml unchanged
-                metadata['xml_attributes'][attr] = value
+                metadata["xml_attributes"][attr] = value
             else:
                 metadata[attr] = value
 
@@ -308,7 +320,7 @@ def parse_xml(cls, node, runtime, keys):  # pylint: disable=too-many-statements
 
         if keys is None:
             # Passing keys=None is against the XBlock API but some platform tests do it.
-            def_id = runtime.id_generator.create_definition(node.tag, node.get('url_name'))
+            def_id = runtime.id_generator.create_definition(node.tag, node.get("url_name"))
             keys = ScopeIds(None, node.tag, def_id, runtime.id_generator.create_usage(def_id))
         aside_children = []
 
@@ -335,21 +347,21 @@ def parse_xml(cls, node, runtime, keys):  # pylint: disable=too-many-statements
         # Make Ike's github preview links work in both old and new file layouts.
         if is_pointer_tag(node):
             # new style -- contents actually at filepath
-            definition['filename'] = [filepath, filepath]
+            definition["filename"] = [filepath, filepath]
 
         metadata = cls.load_metadata(definition_xml)
 
         # move definition metadata into dict
-        dmdata = definition.get('definition_metadata', '')
+        dmdata = definition.get("definition_metadata", "")
         if dmdata:
-            metadata['definition_metadata_raw'] = dmdata
+            metadata["definition_metadata_raw"] = dmdata
             try:
                 metadata.update(json.loads(dmdata))
             except Exception as err:  # lint-amnesty, pylint: disable=broad-except
-                log.debug('Error in loading metadata %r', dmdata, exc_info=True)
-                metadata['definition_metadata_err'] = str(err)
+                log.debug("Error in loading metadata %r", dmdata, exc_info=True)
+                metadata["definition_metadata_err"] = str(err)
 
-        definition_aside_children = definition.pop('aside_children', None)
+        definition_aside_children = definition.pop("aside_children", None)
         if definition_aside_children:
             aside_children.extend(definition_aside_children)
 
@@ -357,7 +369,7 @@ def parse_xml(cls, node, runtime, keys):  # pylint: disable=too-many-statements
         cls.apply_policy(metadata, runtime.get_policy(keys.usage_id))
 
         field_data = {**metadata, **definition, "children": children}
-        field_data['xml_attributes']['filename'] = definition.get('filename', ['', None])  # for git link
+        field_data["xml_attributes"]["filename"] = definition.get("filename", ["", None])  # for git link
         if "filename" in field_data:
             del field_data["filename"]  # filename should only be in xml_attributes.
 
@@ -371,14 +383,16 @@ def parse_xml(cls, node, runtime, keys):  # pylint: disable=too-many-statements
         else:
             # The "normal" / new way to set field data:
             xblock = runtime.construct_xblock_from_class(cls, keys)
-            for (key, value_jsonish) in field_data.items():
+            for key, value_jsonish in field_data.items():
                 if key in cls.fields:
                     setattr(xblock, key, cls.fields[key].from_json(value_jsonish))
-                elif key == 'children':
+                elif key == "children":
                     xblock.children = value_jsonish
                 else:
                     log.warning(
-                        "Imported %s XBlock does not have field %s found in XML.", xblock.scope_ids.block_type, key,
+                        "Imported %s XBlock does not have field %s found in XML.",
+                        xblock.scope_ids.block_type,
+                        key,
                     )
 
         if aside_children:
@@ -413,14 +427,14 @@ def load_definition_xml(cls, node, runtime, def_id):
         """
         Loads definition_xml stored in a dedicated file
         """
-        url_name = node.get('url_name')
+        url_name = node.get("url_name")
         filepath = cls._format_filepath(node.tag, name_to_pathname(url_name))
         definition_xml = cls.load_file(filepath, runtime.resources_fs, def_id)
         return definition_xml, filepath
 
     @classmethod
     def _format_filepath(cls, category, name):
-        return f'{category}/{name}.{cls.filename_extension}'
+        return f"{category}/{name}.{cls.filename_extension}"
 
     def export_to_file(self):
         """If this returns True, write the definition of this block to a separate
@@ -459,16 +473,20 @@ def add_xml_to_node(self, node):
         # Add the non-inherited metadata
         for attr in sorted(own_metadata(self)):
             # don't want e.g. data_dir
-            if (attr not in self.metadata_to_strip
-                    and attr not in self.metadata_to_export_to_policy
-                    and attr not in not_to_clean_fields):
+            if (
+                attr not in self.metadata_to_strip
+                and attr not in self.metadata_to_export_to_policy
+                and attr not in not_to_clean_fields
+            ):
                 val = serialize_field(self.fields[attr].to_json(getattr(self, attr)))
                 try:
                     xml_object.set(attr, val)
                 except Exception:  # lint-amnesty, pylint: disable=broad-except
                     logging.exception(
-                        'Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!',  # lint-amnesty, pylint: disable=line-too-long
-                        attr, val, self.url_name
+                        "Failed to serialize metadata attribute %s with value %s in module %s. This could mean data loss!!!",  # lint-amnesty, pylint: disable=line-too-long
+                        attr,
+                        val,
+                        self.url_name,
                     )
 
         for key, value in self.xml_attributes.items():
@@ -481,11 +499,11 @@ def add_xml_to_node(self, node):
             # if folder is course then create file with name {course_run}.xml
             filepath = self._format_filepath(
                 self.category,
-                self.location.run if self.category == 'course' else url_path,
+                self.location.run if self.category == "course" else url_path,
             )
             self.runtime.export_fs.makedirs(os.path.dirname(filepath), recreate=True)
-            with self.runtime.export_fs.open(filepath, 'wb') as fileobj:
-                ElementTree(xml_object).write(fileobj, pretty_print=True, encoding='utf-8')
+            with self.runtime.export_fs.open(filepath, "wb") as fileobj:
+                ElementTree(xml_object).write(fileobj, pretty_print=True, encoding="utf-8")
         else:
             # Write all attributes from xml_object onto node
             node.clear()
@@ -496,21 +514,20 @@ def add_xml_to_node(self, node):
             node.extend(xml_object)
 
         # Do not override an existing value for the course.
-        if not node.get('url_name'):
-            node.set('url_name', self.url_name)
+        if not node.get("url_name"):
+            node.set("url_name", self.url_name)
 
         # Special case for course pointers:
-        if self.category == 'course':
+        if self.category == "course":
             # add org and course attributes on the pointer tag
-            node.set('org', self.location.org)
-            node.set('course', self.location.course)
+            node.set("org", self.location.org)
+            node.set("course", self.location.course)
 
     def definition_to_xml(self, resource_fs):
         """
         Return a new etree Element object created from this modules definition.
         """
-        raise NotImplementedError(
-            "%s does not implement definition_to_xml" % self.__class__.__name__)
+        raise NotImplementedError("%s does not implement definition_to_xml" % self.__class__.__name__)
 
     @property
     def non_editable_metadata_fields(self):