From efdfef3c25e88f61a0955dbf4f8c59f72c94ba06 Mon Sep 17 00:00:00 2001
From: salmannawaz <salman.nawaz@arbisoft.com>
Date: Wed, 24 Jun 2026 01:43:05 +0500
Subject: [PATCH] chore: fix ruff lint and formatting issues

- Fix F401 re-exports in __init__.py files using explicit `X as X` syntax
- Fix F841 unused variables by removing assignments or using _ prefix
- Remove unused imports auto-fixed by ruff
- Auto-format 48 files with ruff format
- Fix 3 E501 long lines in lti.py
- Update docs/changelog.rst to point to GitHub Releases (CHANGELOG.rst removed)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 docs/changelog.rst                            |   5 +-
 docs/conf.py                                  |   1 +
 xblock_pdf/__init__.py                        |   2 +-
 xblock_pdf/pdf.py                             |  75 +-
 xblock_pdf/tests/test_pdf.py                  |  56 +-
 xblock_pdf/utils.py                           |   4 +-
 xblocks_contrib/__init__.py                   |  16 +-
 xblocks_contrib/annotatable/__init__.py       |   2 +-
 xblocks_contrib/annotatable/annotatable.py    |  14 +-
 xblocks_contrib/discussion/__init__.py        |   2 +-
 xblocks_contrib/discussion/discussion.py      |  97 +-
 .../discussion/tests/test_discussion.py       |  47 +-
 xblocks_contrib/html/__init__.py              |   3 +-
 xblocks_contrib/html/html.py                  |   1 -
 xblocks_contrib/html/tests/test_html.py       |   1 -
 xblocks_contrib/legacy_utils/xml_utils.py     | 147 ++--
 xblocks_contrib/lti/__init__.py               |   2 +-
 xblocks_contrib/lti/lti.py                    | 337 +++----
 xblocks_contrib/lti/lti_2_util.py             |  65 +-
 xblocks_contrib/lti/tests/helpers.py          |  70 +-
 xblocks_contrib/lti/tests/test_lti20_unit.py  | 153 ++--
 xblocks_contrib/lti/tests/test_lti_unit.py    |  72 +-
 xblocks_contrib/poll/__init__.py              |   2 +-
 xblocks_contrib/poll/tests/test_poll.py       |   3 -
 xblocks_contrib/problem/__init__.py           |   2 +-
 xblocks_contrib/problem/capa/capa_problem.py  |   3 +-
 xblocks_contrib/problem/capa/customrender.py  |   2 +-
 xblocks_contrib/problem/capa/inputtypes.py    |   1 -
 xblocks_contrib/problem/capa/responsetypes.py |  18 +-
 .../problem/capa/safe_exec/__init__.py        |   3 +-
 .../problem/capa/safe_exec/lazymod.py         |   2 +-
 .../problem/capa/safe_exec/safe_exec.py       |   1 -
 .../capa/safe_exec/tests/test_safe_exec.py    |   2 -
 .../capa/tests/response_xml_factory.py        |   1 -
 .../problem/capa/tests/test_inputtypes.py     |   2 +-
 .../problem/capa/tests/test_responsetypes.py  |   2 -
 .../problem/capa/tests/test_shuffle.py        |   2 +-
 .../capa/tests/test_xqueue_interface.py       |   6 +-
 .../capa/tests/test_xqueue_submission.py      |   6 +-
 .../problem/capa/xqueue_interface.py          |   6 +-
 xblocks_contrib/problem/capa_block.py         |   9 +-
 .../problem/tests/test_capa_block.py          |   9 +-
 xblocks_contrib/video/__init__.py             |   2 +-
 xblocks_contrib/video/ajax_handler_mixin.py   |  10 +-
 xblocks_contrib/video/bumper_utils.py         |  97 +-
 xblocks_contrib/video/cache_utils.py          |   6 +-
 xblocks_contrib/video/constants.py            |   8 +-
 xblocks_contrib/video/mixin.py                |   7 +-
 .../video/studio_metadata_mixin.py            |  41 +-
 .../video/tests/test_studio_metadata_mixin.py | 108 +--
 xblocks_contrib/video/tests/test_utils.py     |  26 +-
 xblocks_contrib/video/tests/test_video.py     | 829 +++++++++---------
 xblocks_contrib/video/validation.py           |   1 +
 xblocks_contrib/video/video.py                | 483 +++++-----
 xblocks_contrib/video/video_handlers.py       | 244 +++---
 .../video/video_static_content_utils.py       |  12 +-
 .../video/video_transcripts_utils.py          |  49 +-
 xblocks_contrib/video/video_utils.py          |  59 +-
 xblocks_contrib/video/video_xfields.py        | 127 +--
 xblocks_contrib/word_cloud/__init__.py        |   5 +-
 .../word_cloud/tests/test_word_cloud.py       |   6 +-
 xblocks_contrib/word_cloud/word_cloud.py      | 129 ++-
 62 files changed, 1718 insertions(+), 1785 deletions(-)

diff --git a/docs/changelog.rst b/docs/changelog.rst
index 565b0521..62e14340 100644
--- a/docs/changelog.rst
+++ b/docs/changelog.rst
@@ -1 +1,4 @@
-.. include:: ../CHANGELOG.rst
+Changelog
+=========
+
+Changes are tracked via `GitHub Releases <https://github.com/openedx/xblocks-contrib/releases>`_.
diff --git a/docs/conf.py b/docs/conf.py
index 1e75f0ea..c14b2abd 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -11,6 +11,7 @@
 All configuration values have a default; values that are commented out
 serve to show the default.
 """
+
 import os
 import re
 import sys
diff --git a/xblock_pdf/__init__.py b/xblock_pdf/__init__.py
index ae2b9e92..f41b34bc 100644
--- a/xblock_pdf/__init__.py
+++ b/xblock_pdf/__init__.py
@@ -1,3 +1,3 @@
 """Init for PDFBlock."""
 
-from .pdf import PDFBlock
+from .pdf import PDFBlock as PDFBlock
diff --git a/xblock_pdf/pdf.py b/xblock_pdf/pdf.py
index 91a27c25..7266b25f 100644
--- a/xblock_pdf/pdf.py
+++ b/xblock_pdf/pdf.py
@@ -1,4 +1,5 @@
 """pdfXBlock main Python class."""
+
 import json
 
 from django.utils.translation import gettext_noop as _
@@ -13,7 +14,7 @@
 resource_loader = ResourceLoader(__name__)
 
 
-@XBlock.needs('i18n')
+@XBlock.needs("i18n")
 class PDFBlock(XBlock):
     """PDF XBlock. Allows authors to embed PDFs in their courses."""
 
@@ -23,21 +24,21 @@ class PDFBlock(XBlock):
         display_name=_("Display Name"),
         default=_("PDF"),
         scope=Scope.settings,
-        help=_("This name appears in the horizontal navigation at the top of the page.")
+        help=_("This name appears in the horizontal navigation at the top of the page."),
     )
 
     url = String(
         display_name=_("PDF URL"),
         default=_("https://tutorial.math.lamar.edu/pdf/Trig_Cheat_Sheet.pdf"),
         scope=Scope.content,
-        help=_("The URL for your PDF.")
+        help=_("The URL for your PDF."),
     )
 
     allow_download = Boolean(
         display_name=_("PDF Download Allowed"),
         default=True,
         scope=Scope.content,
-        help=_("Display a download button for this PDF.")
+        help=_("Display a download button for this PDF."),
     )
 
     source_text = String(
@@ -47,7 +48,7 @@ class PDFBlock(XBlock):
         help=_(
             "Add a download link for the source file of your PDF. "
             "Use it for example to provide the PowerPoint file used to create this PDF."
-        )
+        ),
     )
 
     source_url = String(
@@ -57,38 +58,38 @@ class PDFBlock(XBlock):
         help=_(
             "Add a download link for the source file of your PDF. "
             "Use it for example to provide the PowerPoint file used to create this PDF."
-        )
+        ),
     )
 
     @property
     def raw_settings(self):
         """Get the raw settings of the XBlock as a dictionary."""
         return {
-            'display_name': self.display_name,
-            'url': self.url,
-            'allow_download': self.allow_download,
-            'disable_all_download': is_all_download_disabled(),
-            'source_text': self.source_text,
-            'source_url': self.source_url,
+            "display_name": self.display_name,
+            "url": self.url,
+            "allow_download": self.allow_download,
+            "disable_all_download": is_all_download_disabled(),
+            "source_text": self.source_text,
+            "source_url": self.source_url,
         }
 
     def student_view(self, context=None):  # pylint: disable=unused-argument
         """Primary view of the XBlock, shown to students when viewing courses."""
         html = resource_loader.render_django_template(
-            'templates/html/pdf_view.html',
+            "templates/html/pdf_view.html",
             context=self.raw_settings,
             i18n_service=self.runtime.service(self, "i18n"),
         )
 
-        event_type = 'edx.pdf.loaded'
+        event_type = "edx.pdf.loaded"
         event_data = {
-            'url': self.url,
-            'source_url': self.source_url,
+            "url": self.url,
+            "source_url": self.source_url,
         }
         self.runtime.publish(self, event_type, event_data)
         frag = Fragment(html)
         frag.add_javascript(resource_loader.load_unicode("static/js/pdf_view.js"))
-        frag.initialize_js('pdfXBlockInitView')
+        frag.initialize_js("pdfXBlockInitView")
         return frag
 
     def studio_view(self, context=None):
@@ -98,49 +99,49 @@ def studio_view(self, context=None):
         Shown to teachers when editing the XBlock.
         """
         context = {
-            'display_name': self.display_name,
-            'url': self.url,
-            'allow_download': self.allow_download,
-            'disable_all_download': is_all_download_disabled(),
-            'source_text': self.source_text,
-            'source_url': self.source_url
+            "display_name": self.display_name,
+            "url": self.url,
+            "allow_download": self.allow_download,
+            "disable_all_download": is_all_download_disabled(),
+            "source_text": self.source_text,
+            "source_url": self.source_url,
         }
         html = resource_loader.render_django_template(
-            'templates/html/pdf_edit.html',
+            "templates/html/pdf_edit.html",
             context=context,
             i18n_service=self.runtime.service(self, "i18n"),
         )
         frag = Fragment(html)
         frag.add_javascript(resource_loader.load_unicode("static/js/pdf_edit.js"))
-        frag.initialize_js('pdfXBlockInitEdit')
+        frag.initialize_js("pdfXBlockInitEdit")
         return frag
 
     @XBlock.json_handler
-    def on_download(self, data, suffix=''):  # pylint: disable=unused-argument
+    def on_download(self, data, suffix=""):  # pylint: disable=unused-argument
         """Download file event handler."""
-        event_type = 'edx.pdf.downloaded'
+        event_type = "edx.pdf.downloaded"
         event_data = {
-            'url': self.url,
-            'source_url': self.source_url,
+            "url": self.url,
+            "source_url": self.source_url,
         }
         self.runtime.publish(self, event_type, event_data)
 
     @XBlock.handler
     def load_pdf(self, *_args, **_kwargs):
         """Get the PDF block's settings in JSON format."""
-        return Response(json.dumps(self.raw_settings), content_type='application/json', charset='utf8')
+        return Response(json.dumps(self.raw_settings), content_type="application/json", charset="utf8")
 
     @XBlock.json_handler
-    def save_pdf(self, data, suffix=''):  # pylint: disable=unused-argument
+    def save_pdf(self, data, suffix=""):  # pylint: disable=unused-argument
         """Save handler."""
-        self.display_name = data['display_name']
-        self.url = data['url']
+        self.display_name = data["display_name"]
+        self.url = data["url"]
 
         if not is_all_download_disabled():
-            self.allow_download = bool_from_str(data['allow_download'])
-            self.source_text = data['source_text']
-            self.source_url = data['source_url']
+            self.allow_download = bool_from_str(data["allow_download"])
+            self.source_text = data["source_text"]
+            self.source_url = data["source_url"]
 
         return {
-            'result': 'success',
+            "result": "success",
         }
diff --git a/xblock_pdf/tests/test_pdf.py b/xblock_pdf/tests/test_pdf.py
index f02ddd47..87fdb57c 100644
--- a/xblock_pdf/tests/test_pdf.py
+++ b/xblock_pdf/tests/test_pdf.py
@@ -1,9 +1,10 @@
 """Tests for the PDF Block"""
+
 import json
 from typing import Any, Optional
 from unittest.mock import MagicMock, patch
 
-from django.test import TestCase, override_settings
+from django.test import override_settings
 from xblock.field_data import DictFieldData
 from xblock.fields import ScopeIds
 from xblock.test.toy_runtime import ToyRuntime
@@ -41,7 +42,6 @@ def mock_handle_request(data: Optional[dict[str, Any]] = None, method: str = "PO
 
 def test_defaults_render():
     """Test the basic view loads."""
-    scope_ids = ScopeIds("1", "2", "3", "4")
     block = make_block()
     content = get_student_content(block)
     assert '<iframe src="https://tutorial.math.lamar.edu/pdf/Trig_Cheat_Sheet.pdf"' in content
@@ -52,10 +52,10 @@ def test_download_button():
     block = make_block(allow_download=True)
     get_student_content(block)
     content = get_student_content(block)
-    assert 'Download the PDF' in content
+    assert "Download the PDF" in content
     block.allow_download = False
     content = get_student_content(block)
-    assert 'Download the PDF' not in content
+    assert "Download the PDF" not in content
 
 
 def test_source_url():
@@ -80,13 +80,15 @@ def test_studio_view_renders():
 def test_saves_settings():
     """Test that PDF settings are saved."""
     block = make_block()
-    request = mock_handle_request({
-        "display_name": "Novel application of theory",
-        "url": "https://example.com/nature_article.pdf",
-        "allow_download": "false",
-        "source_text": "Get educated",
-        "source_url": "https://example.com/nature_article.tex",
-    })
+    request = mock_handle_request(
+        {
+            "display_name": "Novel application of theory",
+            "url": "https://example.com/nature_article.pdf",
+            "allow_download": "false",
+            "source_text": "Get educated",
+            "source_url": "https://example.com/nature_article.tex",
+        }
+    )
     block.save_pdf(request)
     assert block.display_name == "Novel application of theory"
     assert block.url == "https://example.com/nature_article.pdf"
@@ -102,20 +104,22 @@ def test_saves_settings_omits_on_download_disabled_flag():
     downloads disabled flag is set.
     """
     block = make_block()
-    request = mock_handle_request({
-        "display_name": "Novel application of theory",
-        "url": "https://example.com/nature_article.pdf",
-        # These fields shouldn't be visible on the front end,
-        # but should be dropped if they somehow are.
-        #
-        # Potential future improvement would be saving these
-        # but ignoring them when rendering. This is not currently
-        # the case since the fields are entirely absent from the studio
-        # render, and so would send blank data which would error out.
-        "allow_download": "false",
-        "source_text": "Get educated",
-        "source_url": "https://example.com/nature_article.tex",
-    })
+    request = mock_handle_request(
+        {
+            "display_name": "Novel application of theory",
+            "url": "https://example.com/nature_article.pdf",
+            # These fields shouldn't be visible on the front end,
+            # but should be dropped if they somehow are.
+            #
+            # Potential future improvement would be saving these
+            # but ignoring them when rendering. This is not currently
+            # the case since the fields are entirely absent from the studio
+            # render, and so would send blank data which would error out.
+            "allow_download": "false",
+            "source_text": "Get educated",
+            "source_url": "https://example.com/nature_article.tex",
+        }
+    )
     block.save_pdf(request)
     assert block.display_name == "Novel application of theory"
     assert block.url == "https://example.com/nature_article.pdf"
@@ -138,7 +142,7 @@ def test_download_event_fires(mock_publish):
         {
             "url": "https://tutorial.math.lamar.edu/pdf/Trig_Cheat_Sheet.pdf",
             "source_url": "",
-        }
+        },
     )
 
 
diff --git a/xblock_pdf/utils.py b/xblock_pdf/utils.py
index f32b68c7..079c58b0 100644
--- a/xblock_pdf/utils.py
+++ b/xblock_pdf/utils.py
@@ -5,9 +5,9 @@
 
 def bool_from_str(str_value):
     """Convert string from submitted form to boolean."""
-    return str_value.strip().lower() == 'true'
+    return str_value.strip().lower() == "true"
 
 
 def is_all_download_disabled():
     """Check if all downloads are disabled or not."""
-    return getattr(settings, 'PDFXBLOCK_DISABLE_ALL_DOWNLOAD', False)
+    return getattr(settings, "PDFXBLOCK_DISABLE_ALL_DOWNLOAD", False)
diff --git a/xblocks_contrib/__init__.py b/xblocks_contrib/__init__.py
index e7be4706..a594ded4 100644
--- a/xblocks_contrib/__init__.py
+++ b/xblocks_contrib/__init__.py
@@ -1,12 +1,12 @@
 """Init for the xblocks_contrib package."""
 
-from .annotatable import AnnotatableBlock
-from .discussion import DiscussionXBlock
-from .html import HtmlBlock
-from .lti import LTIBlock
-from .poll import PollBlock
-from .problem import ProblemBlock
-from .video import VideoBlock
-from .word_cloud import WordCloudBlock
+from .annotatable import AnnotatableBlock as AnnotatableBlock
+from .discussion import DiscussionXBlock as DiscussionXBlock
+from .html import HtmlBlock as HtmlBlock
+from .lti import LTIBlock as LTIBlock
+from .poll import PollBlock as PollBlock
+from .problem import ProblemBlock as ProblemBlock
+from .video import VideoBlock as VideoBlock
+from .word_cloud import WordCloudBlock as WordCloudBlock
 
 __version__ = "0.17.0"
diff --git a/xblocks_contrib/annotatable/__init__.py b/xblocks_contrib/annotatable/__init__.py
index 19cb87a1..55a846a1 100644
--- a/xblocks_contrib/annotatable/__init__.py
+++ b/xblocks_contrib/annotatable/__init__.py
@@ -2,4 +2,4 @@
 Init for the AnnotatableBlock.
 """
 
-from .annotatable import AnnotatableBlock
+from .annotatable import AnnotatableBlock as AnnotatableBlock
diff --git a/xblocks_contrib/annotatable/annotatable.py b/xblocks_contrib/annotatable/annotatable.py
index 3e698d1a..58cee59f 100644
--- a/xblocks_contrib/annotatable/annotatable.py
+++ b/xblocks_contrib/annotatable/annotatable.py
@@ -28,6 +28,7 @@ class SerializationError(Exception):
     """
     Thrown when a module cannot be exported to XML
     """
+
     def __init__(self, location, msg):
         super().__init__(msg)
         self.location = location
@@ -249,8 +250,8 @@ def workbench_scenarios():
     @classmethod
     def definition_from_xml(cls, xml_object, system):
         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):
         """
@@ -277,13 +278,10 @@ def definition_to_xml(self, resource_fs):
         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  # lint-amnesty, pylint: disable=unpacking-non-sequence
-            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.usage_key,
             )
             raise SerializationError(self.usage_key, msg) from err
diff --git a/xblocks_contrib/discussion/__init__.py b/xblocks_contrib/discussion/__init__.py
index 223f080f..4e6609a8 100644
--- a/xblocks_contrib/discussion/__init__.py
+++ b/xblocks_contrib/discussion/__init__.py
@@ -2,4 +2,4 @@
 Init for the DiscussionXBlock.
 """
 
-from .discussion import DiscussionXBlock
+from .discussion import DiscussionXBlock as DiscussionXBlock
diff --git a/xblocks_contrib/discussion/discussion.py b/xblocks_contrib/discussion/discussion.py
index 5b7d5212..b2021c34 100644
--- a/xblocks_contrib/discussion/discussion.py
+++ b/xblocks_contrib/discussion/discussion.py
@@ -21,7 +21,7 @@
 
 log = logging.getLogger(__name__)
 loader = ResourceLoader(__name__)
-Text = markupsafe.escape                        # pylint: disable=invalid-name
+Text = markupsafe.escape  # pylint: disable=invalid-name
 
 
 def _(text):
@@ -31,7 +31,7 @@ def _(text):
     return text
 
 
-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.
 
@@ -56,12 +56,13 @@ def HTML(html):                                 # pylint: disable=invalid-name
 
 @XBlock.needs("i18n")
 @XBlock.needs("user")
-@XBlock.wants('discussion_config_service')
+@XBlock.wants("discussion_config_service")
 # pylint: disable=abstract-method
 class DiscussionXBlock(XBlock, StudioEditableXBlockMixin, LegacyXmlMixin):
     """
     Provides a discussion forum that is inline with other content in the courseware.
     """
+
     is_extracted = True
     completion_mode = XBlockCompletionMode.EXCLUDED
 
@@ -70,7 +71,7 @@ class DiscussionXBlock(XBlock, StudioEditableXBlockMixin, LegacyXmlMixin):
         display_name=_("Display Name"),
         help=_("The display name for this component."),
         default="Discussion",
-        scope=Scope.settings
+        scope=Scope.settings,
     )
     discussion_category = String(
         display_name=_("Category"),
@@ -79,7 +80,7 @@ class DiscussionXBlock(XBlock, StudioEditableXBlockMixin, LegacyXmlMixin):
             "A category name for the discussion. "
             "This name appears in the left pane of the discussion forum for the course."
         ),
-        scope=Scope.settings
+        scope=Scope.settings,
     )
     discussion_target = String(
         display_name=_("Subcategory"),
@@ -88,7 +89,7 @@ class DiscussionXBlock(XBlock, StudioEditableXBlockMixin, LegacyXmlMixin):
             "A subcategory name for the discussion. "
             "This name appears in the left pane of the discussion forum for the course."
         ),
-        scope=Scope.settings
+        scope=Scope.settings,
     )
     sort_key = String(scope=Scope.settings)
 
@@ -101,7 +102,7 @@ def discussion_config(self):
         """
         Returns discussion service.
         """
-        return self.runtime.service(self, 'discussion_config_service')
+        return self.runtime.service(self, "discussion_config_service")
 
     @property
     def is_visible(self):
@@ -116,7 +117,7 @@ def django_user(self):
         Returns django user associated with user currently interacting
         with the XBlock.
         """
-        user_service = self.runtime.service(self, 'user')
+        user_service = self.runtime.service(self, "user")
         if not user_service:
             return None
         return user_service._django_user  # pylint: disable=protected-access
@@ -126,11 +127,7 @@ def add_resource_urls(self, fragment):
         Adds URLs for JS and CSS resources that this XBlock depends on to `fragment`.
         """
 
-        css_file_path = (
-            '/css/inline-discussion-rtl.css'
-            if get_language_bidi()
-            else '/css/inline-discussion.css'
-        )
+        css_file_path = "/css/inline-discussion-rtl.css" if get_language_bidi() else "/css/inline-discussion.css"
 
         # Determine how static assets should be served based on Django settings.
         # Open edX requires different asset paths for production vs. local development.
@@ -171,46 +168,50 @@ def student_view(self, context=None):
             return fragment
 
         self.add_resource_urls(fragment)
-        login_msg = ''
+        login_msg = ""
 
         if not self.django_user.is_authenticated:
-            qs = urllib.parse.urlencode({
-                'course_id': self.context_key,
-                'enrollment_action': 'enroll',
-                'email_opt_in': False,
-            })
-            login_msg = Text(_("You are not signed in. To view the discussion content, {sign_in_link} or "
-                               "{register_link}, and enroll in this course.")).format(
+            qs = urllib.parse.urlencode(
+                {
+                    "course_id": self.context_key,
+                    "enrollment_action": "enroll",
+                    "email_opt_in": False,
+                }
+            )
+            login_msg = Text(
+                _(
+                    "You are not signed in. To view the discussion content, {sign_in_link} or "
+                    "{register_link}, and enroll in this course."
+                )
+            ).format(
                 sign_in_link=HTML('<a href="{url}">{sign_in_label}</a>').format(
-                    sign_in_label=_('sign in'),
-                    url='{}?{}'.format(reverse('signin_user'), qs),
+                    sign_in_label=_("sign in"),
+                    url="{}?{}".format(reverse("signin_user"), qs),
                 ),
                 register_link=HTML('<a href="/{url}">{register_label}</a>').format(
-                    register_label=_('register'),
-                    url='{}?{}'.format(reverse('register_user'), qs),
+                    register_label=_("register"),
+                    url="{}?{}".format(reverse("register_user"), qs),
                 ),
             )
 
         if self.discussion_config.is_discussion_enabled:
             context = {
-                'discussion_id': self.discussion_id,
-                'display_name': self.display_name if self.display_name else _("Discussion"),
-                'user': self.django_user,
-                'course_id': self.context_key,
-                'discussion_category': self.discussion_category,
-                'discussion_target': self.discussion_target,
-                'can_create_thread': self.has_permission("create_thread"),
-                'can_create_comment': self.has_permission("create_comment"),
-                'can_create_subcomment': self.has_permission("create_sub_comment"),
-                'login_msg': login_msg,
-                'PLATFORM_NAME': settings.PLATFORM_NAME,
-                'enable_discussion_home_panel': settings.FEATURES.get("ENABLE_DISCUSSION_HOME_PANEL", False),
+                "discussion_id": self.discussion_id,
+                "display_name": self.display_name if self.display_name else _("Discussion"),
+                "user": self.django_user,
+                "course_id": self.context_key,
+                "discussion_category": self.discussion_category,
+                "discussion_target": self.discussion_target,
+                "can_create_thread": self.has_permission("create_thread"),
+                "can_create_comment": self.has_permission("create_comment"),
+                "can_create_subcomment": self.has_permission("create_sub_comment"),
+                "login_msg": login_msg,
+                "PLATFORM_NAME": settings.PLATFORM_NAME,
+                "enable_discussion_home_panel": settings.FEATURES.get("ENABLE_DISCUSSION_HOME_PANEL", False),
             }
-            fragment.add_content(
-                render_to_string('discussion_templates/_discussion_inline.html', context)
-            )
+            fragment.add_content(render_to_string("discussion_templates/_discussion_inline.html", context))
 
-        fragment.initialize_js('DiscussionInlineBlock')
+        fragment.initialize_js("DiscussionInlineBlock")
 
         return fragment
 
@@ -220,19 +221,17 @@ def author_view(self, context=None):
         """
         fragment = Fragment()
         context = {
-            'discussion_id': self.discussion_id,
-            'is_visible': self.is_visible,
+            "discussion_id": self.discussion_id,
+            "is_visible": self.is_visible,
         }
-        fragment.add_content(
-            loader.render_django_template('templates/_discussion_inline_studio.html', context)
-        )
+        fragment.add_content(loader.render_django_template("templates/_discussion_inline_studio.html", context))
         return fragment
 
     def student_view_data(self):
         """
         Returns a JSON representation of the student_view of this XBlock.
         """
-        return {'topic_id': self.discussion_id}
+        return {"topic_id": self.discussion_id}
 
     @classmethod
     def parse_xml(cls, node, runtime, keys):
@@ -259,7 +258,7 @@ def _apply_metadata_and_policy(cls, block, node, runtime):
         """
         Attempt to load definition XML from "discussion" folder in OLX, than parse it and update block fields
         """
-        if node.get('url_name') is None:
+        if node.get("url_name") is None:
             return  # Newer/XBlock XML format - no need to load an additional file.
         try:
             definition_xml, _ = cls.load_definition_xml(node, runtime, block.scope_ids.def_id)
@@ -267,7 +266,7 @@ def _apply_metadata_and_policy(cls, block, node, runtime):
             log.info(
                 "Exception %s when trying to load definition xml for block %s - assuming XBlock export format",
                 err,
-                block
+                block,
             )
             return
 
diff --git a/xblocks_contrib/discussion/tests/test_discussion.py b/xblocks_contrib/discussion/tests/test_discussion.py
index 67073684..e71e556a 100644
--- a/xblocks_contrib/discussion/tests/test_discussion.py
+++ b/xblocks_contrib/discussion/tests/test_discussion.py
@@ -1,5 +1,4 @@
-""" Tests for DiscussionXBLock"""
-
+"""Tests for DiscussionXBLock"""
 
 import itertools
 import random
@@ -21,7 +20,7 @@ def attribute_pair_repr(self):
     Custom string representation for the AttributePair namedtuple which is
     consistent between test runs.
     """
-    return f'<AttributePair name={self.name}>'
+    return f"<AttributePair name={self.name}>"
 
 
 AttributePair = namedtuple("AttributePair", ["name", "value"])
@@ -37,7 +36,12 @@ def _random_string():
     """
     Generates random string
     """
-    return ''.join(random.choice(string.ascii_lowercase, ) for _ in range(12))
+    return "".join(
+        random.choice(
+            string.ascii_lowercase,
+        )
+        for _ in range(12)
+    )
 
 
 def _make_attribute_test_cases():
@@ -49,7 +53,7 @@ def _make_attribute_test_cases():
         yield (
             AttributePair(id_attr, _random_string()),
             AttributePair(category_attr, _random_string()),
-            AttributePair(target_attr, _random_string())
+            AttributePair(target_attr, _random_string()),
         )
 
 
@@ -58,6 +62,7 @@ class DiscussionXBlockImportExportTests(TestCase):
     """
     Import and export tests
     """
+
     DISCUSSION_XBLOCK_LOCATION = "xblocks_contrib.discussion.DiscussionXBlock"
 
     def setUp(self):
@@ -93,9 +98,12 @@ def test_xblock_export_format(self, id_pair, category_pair, target_pair, patched
             {target_attr}="{target_value}"
         />
         """.format(
-            id_attr=id_pair.name, id_value=id_pair.value,
-            category_attr=category_pair.name, category_value=category_pair.value,
-            target_attr=target_pair.name, target_value=target_pair.value,
+            id_attr=id_pair.name,
+            id_value=id_pair.value,
+            category_attr=category_pair.name,
+            category_value=category_pair.value,
+            target_attr=target_pair.name,
+            target_value=target_pair.value,
         )
         node = etree.fromstring(xblock_xml)
 
@@ -124,9 +132,12 @@ def test_legacy_export_format(self, id_pair, category_pair, target_pair, patched
             {category_attr}="{category_value}"
             {target_attr}="{target_value}"
         />""".format(
-            id_attr=id_pair.name, id_value=id_pair.value,
-            category_attr=category_pair.name, category_value=category_pair.value,
-            target_attr=target_pair.name, target_value=target_pair.value,
+            id_attr=id_pair.name,
+            id_value=id_pair.value,
+            category_attr=category_pair.name,
+            category_value=category_pair.value,
+            target_attr=target_pair.name,
+            target_value=target_pair.value,
         )
         node = etree.fromstring(xblock_xml)
         definition_node = etree.fromstring(xblock_definition_xml)
@@ -154,25 +165,25 @@ def test_export_default_discussion_id(self):
         export,  in a course with a course ID different from the one from which the export was created - because the
         discussion ID would be different.
         """
-        target_node = etree.Element('dummy')
+        target_node = etree.Element("dummy")
 
         block = DiscussionXBlock(self.runtime_mock, scope_ids=self.keys, field_data=DictFieldData({}))
-        discussion_id_field = block.fields['discussion_id']  # pylint: disable=unsubscriptable-object
+        discussion_id_field = block.fields["discussion_id"]  # pylint: disable=unsubscriptable-object
 
         # precondition checks - discussion_id does not have a value and uses UNIQUE_ID
         assert discussion_id_field._get_cached_value(block) == NO_CACHE_VALUE  # pylint: disable=W0212
         assert discussion_id_field.default == UNIQUE_ID
 
         block.add_xml_to_node(target_node)
-        assert target_node.tag == 'discussion'  # pylint: disable=W0212
-        assert 'discussion_id' not in target_node.attrib
+        assert target_node.tag == "discussion"  # pylint: disable=W0212
+        assert "discussion_id" not in target_node.attrib
 
     @ddt.data("jediwannabe", "iddqd", "itisagooddaytodie")
     def test_export_custom_discussion_id(self, discussion_id):
         """
         Test that custom discussion_id values are exported
         """
-        target_node = etree.Element('dummy')
+        target_node = etree.Element("dummy")
 
         block = DiscussionXBlock(self.runtime_mock, scope_ids=self.keys, field_data=DictFieldData({}))
         block.discussion_id = discussion_id
@@ -181,5 +192,5 @@ def test_export_custom_discussion_id(self, discussion_id):
         assert block.discussion_id == discussion_id
 
         block.add_xml_to_node(target_node)
-        assert target_node.tag == 'discussion'
-        assert target_node.attrib['discussion_id'], discussion_id
+        assert target_node.tag == "discussion"
+        assert target_node.attrib["discussion_id"], discussion_id
diff --git a/xblocks_contrib/html/__init__.py b/xblocks_contrib/html/__init__.py
index 0fe36653..474a2bf6 100644
--- a/xblocks_contrib/html/__init__.py
+++ b/xblocks_contrib/html/__init__.py
@@ -2,4 +2,5 @@
 Init for the HtmlBlock.
 """
 
-from .html import HtmlBlock, HtmlBlockMixin
+from .html import HtmlBlock as HtmlBlock
+from .html import HtmlBlockMixin as HtmlBlockMixin
diff --git a/xblocks_contrib/html/html.py b/xblocks_contrib/html/html.py
index 2d3b85a0..3713bb51 100644
--- a/xblocks_contrib/html/html.py
+++ b/xblocks_contrib/html/html.py
@@ -409,7 +409,6 @@ def load_definition(cls, xml_object, system, def_id, id_generator):
             # again in the correct format.  This should go away once the CMS is
             # online and has imported all current (fall 2012) courses from xml
             if not system.resources_fs.exists(filepath):
-
                 candidates = cls.backcompat_paths(filepath)
                 # log.debug("candidates = {0}".format(candidates))
                 for candidate in candidates:
diff --git a/xblocks_contrib/html/tests/test_html.py b/xblocks_contrib/html/tests/test_html.py
index 67ffd259..92e33122 100644
--- a/xblocks_contrib/html/tests/test_html.py
+++ b/xblocks_contrib/html/tests/test_html.py
@@ -157,7 +157,6 @@ def test_student_preview_view(self, view):
 
 
 class HtmlBlockSubstitutionTestCase(unittest.TestCase):
-
     def test_substitution_user_id(self):
         sample_xml = """%%USER_ID%%"""
         field_data = DictFieldData({"data": sample_xml})
diff --git a/xblocks_contrib/legacy_utils/xml_utils.py b/xblocks_contrib/legacy_utils/xml_utils.py
index 500d9265..c010532f 100644
--- a/xblocks_contrib/legacy_utils/xml_utils.py
+++ b/xblocks_contrib/legacy_utils/xml_utils.py
@@ -37,7 +37,7 @@
 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")
 
 
 class EdxJSONEncoder(DjangoJSONEncoder):
@@ -66,7 +66,7 @@ def name_to_pathname(name: str) -> str:
     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: _Element) -> bool:
@@ -82,9 +82,9 @@ def is_pointer_tag(xml_obj: _Element) -> bool:
     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())
 
@@ -104,7 +104,7 @@ def serialize_field(value: Any) -> str:
         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)
@@ -154,9 +154,7 @@ def own_metadata(block: XBlock) -> dict[str, Any]:
                 result[field.name] = field.read_json(block)
             except TypeError as exception:
                 exception_message = "{message}, Block-location:{location}, Field-name:{field_name}".format(
-                    message=str(exception),
-                    location=str(block.usage_key),
-                    field_name=field.name
+                    message=str(exception), location=str(block.usage_key), field_name=field.name
                 )
                 raise TypeError(exception_message)  # lint-amnesty, pylint: disable=raise-missing-from
     return result
@@ -168,47 +166,56 @@ class LegacyXmlMixin:
     NOTE: This is a temporary solution, we don't want new XBlocks to use this mixin.
     It will be removed in the future improvements.
     """
+
     # 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)
@@ -231,9 +238,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
@@ -259,7 +268,7 @@ def load_file(cls, filepath, fs, def_id):  # pylint: disable=invalid-name
                 return cls.file_to_xml(xml_file)
         except Exception as err:
             # 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):
@@ -278,10 +287,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)
@@ -290,7 +299,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):
@@ -308,11 +317,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
 
@@ -323,15 +332,14 @@ 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:
                 # don't load these
                 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
@@ -346,7 +354,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
 
@@ -368,7 +376,7 @@ def parse_xml(cls, node, runtime, keys):
         """
         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 = []
 
@@ -398,21 +406,21 @@ def parse_xml(cls, node, runtime, keys):
         # 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)
 
@@ -467,14 +475,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
@@ -512,17 +520,21 @@ 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!!!',
-                        attr, val, self.usage_key.block_id
+                        "Failed to serialize metadata attribute %s with value %s in module %s. "
+                        "This could mean data loss!!!",
+                        attr,
+                        val,
+                        self.usage_key.block_id,
                     )
 
         for key, value in self.xml_attributes.items():
@@ -534,8 +546,8 @@ def add_xml_to_node(self, node):
             url_path = name_to_pathname(self.usage_key.block_id)
             filepath = self._format_filepath(self.usage_key.block_type, 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()
@@ -546,8 +558,8 @@ 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.usage_key.block_id)
+        if not node.get("url_name"):
+            node.set("url_name", self.usage_key.block_id)
 
         # We do not need to cater the `course` category here in xblocks_contrib,
         # because course export is handled in the edx-platform code.
@@ -562,8 +574,7 @@ 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):
diff --git a/xblocks_contrib/lti/__init__.py b/xblocks_contrib/lti/__init__.py
index 23a58683..cc65289f 100644
--- a/xblocks_contrib/lti/__init__.py
+++ b/xblocks_contrib/lti/__init__.py
@@ -4,4 +4,4 @@
 Learning Tools Interoperability (LTI) module.
 """
 
-from .lti import LTIBlock
+from .lti import LTIBlock as LTIBlock
diff --git a/xblocks_contrib/lti/lti.py b/xblocks_contrib/lti/lti.py
index 90f1a746..f0d68738 100644
--- a/xblocks_contrib/lti/lti.py
+++ b/xblocks_contrib/lti/lti.py
@@ -84,9 +84,9 @@
 from .lti_2_util import LTI20BlockMixin, LTIError
 
 # The anonymous user ID for the user in the course.
-ATTR_KEY_ANONYMOUS_USER_ID = 'edx-platform.anonymous_user_id'
+ATTR_KEY_ANONYMOUS_USER_ID = "edx-platform.anonymous_user_id"
 # The user's role in the course ('staff', 'instructor', or 'student').
-ATTR_KEY_USER_ROLE = 'edx-platform.user_role'
+ATTR_KEY_USER_ROLE = "edx-platform.user_role"
 
 resource_loader = ResourceLoader(__name__)
 
@@ -96,7 +96,7 @@
     "<a rel='noopener' target='_blank' "
     "href='https://edx.readthedocs.io/projects/edx-partner-course-staff/en/latest/exercises_tools/lti_component.html'>"
 )
-BREAK_TAG = '<br />'
+BREAK_TAG = "<br />"
 
 
 class LTIFields:
@@ -119,7 +119,8 @@ class LTIFields:
 
         https://github.com/idan/oauthlib/blob/master/oauthlib/oauth1/rfc5849/signature.py#L136
     """
-    data = String(default='', scope=Scope.content)
+
+    data = String(default="", scope=Scope.content)
 
     display_name = String(
         display_name=_("Display Name"),
@@ -133,47 +134,56 @@ class LTIFields:
 
     lti_id = String(
         display_name=_("LTI ID"),
-        help=markupsafe.escape(_(
-            "Enter the LTI ID for the external LTI provider.  "
-            "This value must be the same LTI ID that you entered in the "
-            "LTI Passports setting on the Advanced Settings page."
-            "{break_tag}See {docs_anchor_open}the edX LTI documentation{anchor_close} for more details on this setting."
-        )).format(
+        help=markupsafe.escape(
+            _(
+                "Enter the LTI ID for the external LTI provider.  "
+                "This value must be the same LTI ID that you entered in the "
+                "LTI Passports setting on the Advanced Settings page."
+                "{break_tag}See {docs_anchor_open}the edX LTI documentation"
+                "{anchor_close} for more details on this setting."
+            )
+        ).format(
             break_tag=markupsafe.Markup(BREAK_TAG),
             docs_anchor_open=markupsafe.Markup(DOCS_ANCHOR_TAG_OPEN),
-            anchor_close=markupsafe.Markup("</a>")
+            anchor_close=markupsafe.Markup("</a>"),
         ),
-        default='',
-        scope=Scope.settings
+        default="",
+        scope=Scope.settings,
     )
 
     launch_url = String(
         display_name=_("LTI URL"),
-        help=markupsafe.escape(_(
-            "Enter the URL of the external tool that this component launches. "
-            "This setting is only used when Hide External Tool is set to False."
-            "{break_tag}See {docs_anchor_open}the edX LTI documentation{anchor_close} for more details on this setting."
-        )).format(
+        help=markupsafe.escape(
+            _(
+                "Enter the URL of the external tool that this component launches. "
+                "This setting is only used when Hide External Tool is set to False."
+                "{break_tag}See {docs_anchor_open}the edX LTI documentation"
+                "{anchor_close} for more details on this setting."
+            )
+        ).format(
             break_tag=markupsafe.Markup(BREAK_TAG),
             docs_anchor_open=markupsafe.Markup(DOCS_ANCHOR_TAG_OPEN),
-            anchor_close=markupsafe.Markup("</a>")
+            anchor_close=markupsafe.Markup("</a>"),
         ),
-        default='http://www.example.com',
-        scope=Scope.settings
+        default="http://www.example.com",
+        scope=Scope.settings,
     )
 
     custom_parameters = List(
         display_name=_("Custom Parameters"),
-        help=markupsafe.escape(_(
-            "Add the key/value pair for any custom parameters, such as the page your e-book should open to or "
-            "the background color for this component."
-            "{break_tag}See {docs_anchor_open}the edX LTI documentation{anchor_close} for more details on this setting."
-        )).format(
+        help=markupsafe.escape(
+            _(
+                "Add the key/value pair for any custom parameters, such as the page your e-book should open to or "
+                "the background color for this component."
+                "{break_tag}See {docs_anchor_open}the edX LTI documentation"
+                "{anchor_close} for more details on this setting."
+            )
+        ).format(
             break_tag=markupsafe.Markup(BREAK_TAG),
             docs_anchor_open=markupsafe.Markup(DOCS_ANCHOR_TAG_OPEN),
-            anchor_close=markupsafe.Markup("</a>")
+            anchor_close=markupsafe.Markup("</a>"),
         ),
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     open_in_a_new_page = Boolean(
@@ -184,16 +194,14 @@ class LTIFields:
             "This setting is only used when Hide External Tool is set to False.  "
         ),
         default=True,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     has_score = Boolean(
         display_name=_("Scored"),
-        help=_(
-            "Select True if this component will receive a numerical score from the external LTI system."
-        ),
+        help=_("Select True if this component will receive a numerical score from the external LTI system."),
         default=False,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     weight = Float(
@@ -211,14 +219,10 @@ class LTIFields:
     module_score = Float(
         help=_("The score kept in the xblock KVS -- duplicate of the published score in django DB"),
         default=None,
-        scope=Scope.user_state
+        scope=Scope.user_state,
     )
 
-    score_comment = String(
-        help=_("Comment as returned from grader, LTI2.0 spec"),
-        default="",
-        scope=Scope.user_state
-    )
+    score_comment = String(help=_("Comment as returned from grader, LTI2.0 spec"), default="", scope=Scope.user_state)
 
     hide_launch = Boolean(
         display_name=_("Hide External Tool"),
@@ -228,7 +232,7 @@ class LTIFields:
             "This setting hides the Launch button and any IFrames for this component."
         ),
         default=False,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     # Users will be presented with a message indicating that their e-mail/username would be sent to a third
@@ -239,7 +243,7 @@ class LTIFields:
         # Translators: This is used to request the user's username for a third party service.
         help=_("Select True to request the user's username."),
         default=False,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     ask_to_send_email = Boolean(
@@ -247,7 +251,7 @@ class LTIFields:
         # Translators: This is used to request the user's email for a third party service.
         help=_("Select True to request the user's email address."),
         default=False,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     description = String(
@@ -257,29 +261,37 @@ class LTIFields:
             " box to inform users why their username and/or email will be forwarded to a third party application."
         ),
         default="",
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     button_text = String(
         display_name=_("Button Text"),
-        help=_(
-            "Enter the text on the button used to launch the third party application."
-        ),
+        help=_("Enter the text on the button used to launch the third party application."),
         default="",
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     accept_grades_past_due = Boolean(
         display_name=_("Accept grades past deadline"),
         help=_("Select True to allow third party systems to post grades past the deadline."),
         default=True,
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     editable_fields = (
-        "accept_grades_past_due", "ask_to_send_email", "ask_to_send_username", "button_text",
-        "custom_parameters", "description", "display_name", "has_score", "hide_launch",
-        "launch_url", "lti_id", "open_in_a_new_page", "weight",
+        "accept_grades_past_due",
+        "ask_to_send_email",
+        "ask_to_send_username",
+        "button_text",
+        "custom_parameters",
+        "description",
+        "display_name",
+        "has_score",
+        "hide_launch",
+        "launch_url",
+        "lti_id",
+        "open_in_a_new_page",
+        "weight",
     )
 
 
@@ -425,7 +437,7 @@ def get_input_fields(self):  # lint-amnesty, pylint: disable=missing-function-do
 
         for custom_parameter in self.custom_parameters:
             try:
-                param_name, param_value = [p.strip() for p in custom_parameter.split('=', 1)]
+                param_name, param_value = [p.strip() for p in custom_parameter.split("=", 1)]
             except ValueError:
                 _ = self.runtime.service(self, "i18n").ugettext
                 msg = _('Could not parse custom parameter: {custom_parameter}. Should be "x=y" string.').format(
@@ -435,7 +447,7 @@ def get_input_fields(self):  # lint-amnesty, pylint: disable=missing-function-do
 
             # LTI specs: 'custom_' should be prepended before each custom parameter, as pointed in link above.
             if param_name not in PARAMETERS:
-                param_name = 'custom_' + param_name
+                param_name = "custom_" + param_name
 
             custom_parameters[str(param_name)] = str(param_value)
 
@@ -488,25 +500,24 @@ def get_context(self):
         sanitized_comment = nh3.clean(self.score_comment)
 
         return {
-            'input_fields': self.get_input_fields(),
-
+            "input_fields": self.get_input_fields(),
             # These parameters do not participate in OAuth signing.
-            'launch_url': self.launch_url.strip(),
-            'element_id': self.usage_key.html_id(),
-            'element_class': self.scope_ids.block_type,
-            'open_in_a_new_page': self.open_in_a_new_page,
-            'display_name': self.display_name,
-            'form_url': self.runtime.handler_url(self, 'preview_handler').rstrip('/?'),
-            'hide_launch': self.hide_launch,
-            'has_score': self.has_score,
-            'weight': self.weight,
-            'module_score': self.module_score,
-            'comment': sanitized_comment,
-            'description': self.description,
-            'ask_to_send_username': self.ask_to_send_username,
-            'ask_to_send_email': self.ask_to_send_email,
-            'button_text': self.button_text,
-            'accept_grades_past_due': self.accept_grades_past_due,
+            "launch_url": self.launch_url.strip(),
+            "element_id": self.usage_key.html_id(),
+            "element_class": self.scope_ids.block_type,
+            "open_in_a_new_page": self.open_in_a_new_page,
+            "display_name": self.display_name,
+            "form_url": self.runtime.handler_url(self, "preview_handler").rstrip("/?"),
+            "hide_launch": self.hide_launch,
+            "has_score": self.has_score,
+            "weight": self.weight,
+            "module_score": self.module_score,
+            "comment": sanitized_comment,
+            "description": self.description,
+            "ask_to_send_username": self.ask_to_send_username,
+            "ask_to_send_email": self.ask_to_send_email,
+            "button_text": self.button_text,
+            "accept_grades_past_due": self.accept_grades_past_due,
         }
 
     def student_view(self, _context=None):
@@ -516,8 +527,7 @@ def student_view(self, _context=None):
         frag = Fragment()
         frag.add_content(
             resource_loader.render_django_template(
-                "templates/lti.html", self.get_context(),
-                i18n_service=self.runtime.service(self, 'i18n')
+                "templates/lti.html", self.get_context(), i18n_service=self.runtime.service(self, "i18n")
             )
         )
 
@@ -532,7 +542,7 @@ def preview_handler(self, _, __):
         This is called to get context with new oauth params to iframe.
         """
         template = resource_loader.render_django_template("templates/lti_form.html", self.get_context())
-        return Response(template, content_type='text/html')
+        return Response(template, content_type="text/html")
 
     @XBlock.handler
     def grade_handler(self, request, suffix):  # lint-amnesty, pylint: disable=unused-argument
@@ -593,10 +603,10 @@ def grade_handler(self, request, suffix):  # lint-amnesty, pylint: disable=unuse
         # Supported actions:
         #   - replaceResultRequest.
         unsupported_values = {
-            'imsx_codeMajor': 'unsupported',
-            'imsx_description': 'Target does not support the requested operation.',
-            'imsx_messageIdentifier': 'unknown',
-            'response': ''
+            "imsx_codeMajor": "unsupported",
+            "imsx_description": "Target does not support the requested operation.",
+            "imsx_messageIdentifier": "unknown",
+            "response": "",
         }
         # Returns if:
         #   - past due grades are not accepted and grade is past due
@@ -604,14 +614,14 @@ def grade_handler(self, request, suffix):  # lint-amnesty, pylint: disable=unuse
         #   - can't parse response from TP;
         #   - can't verify OAuth signing or OAuth signing is incorrect.
         failure_values = {
-            'imsx_codeMajor': 'failure',
-            'imsx_description': 'The request has failed.',
-            'imsx_messageIdentifier': 'unknown',
-            'response': ''
+            "imsx_codeMajor": "failure",
+            "imsx_description": "The request has failed.",
+            "imsx_messageIdentifier": "unknown",
+            "response": "",
         }
 
         if not self.accept_grades_past_due and self.is_past_due():
-            failure_values['imsx_description'] = "Grade is past due"
+            failure_values["imsx_description"] = "Grade is past due"
             return Response(response_xml_template.format(**failure_values), content_type="application/xml")
 
         try:
@@ -619,40 +629,40 @@ def grade_handler(self, request, suffix):  # lint-amnesty, pylint: disable=unuse
         except Exception as e:  # lint-amnesty, pylint: disable=broad-except
             error_message = "Request body XML parsing error: " + escape(str(e))
             log.debug("[LTI]: " + error_message)  # lint-amnesty, pylint: disable=logging-not-lazy
-            failure_values['imsx_description'] = error_message
+            failure_values["imsx_description"] = error_message
             return Response(response_xml_template.format(**failure_values), content_type="application/xml")
 
         # Verify OAuth signing.
         try:
             self.verify_oauth_body_sign(request)
         except (ValueError, LTIError) as e:
-            failure_values['imsx_messageIdentifier'] = escape(imsx_messageIdentifier)
+            failure_values["imsx_messageIdentifier"] = escape(imsx_messageIdentifier)
             error_message = "OAuth verification error: " + escape(str(e))
-            failure_values['imsx_description'] = error_message
+            failure_values["imsx_description"] = error_message
             log.debug("[LTI]: " + error_message)  # lint-amnesty, pylint: disable=logging-not-lazy
             return Response(response_xml_template.format(**failure_values), content_type="application/xml")
 
-        real_user = self.runtime.service(self, 'user').get_user_by_anonymous_id(parse.unquote(sourcedId.split(':')[-1]))
+        real_user = self.runtime.service(self, "user").get_user_by_anonymous_id(parse.unquote(sourcedId.split(":")[-1]))
         if not real_user:  # that means we can't save to database, as we do not have real user id.
-            failure_values['imsx_messageIdentifier'] = escape(imsx_messageIdentifier)
-            failure_values['imsx_description'] = "User not found."
+            failure_values["imsx_messageIdentifier"] = escape(imsx_messageIdentifier)
+            failure_values["imsx_description"] = "User not found."
             return Response(response_xml_template.format(**failure_values), content_type="application/xml")
 
-        if action == 'replaceResultRequest':
+        if action == "replaceResultRequest":
             self.set_user_module_score(real_user, score, self.max_score())
 
             values = {
-                'imsx_codeMajor': 'success',
-                'imsx_description': f'Score for {sourcedId} is now {score}',
-                'imsx_messageIdentifier': escape(imsx_messageIdentifier),
-                'response': '<replaceResultResponse/>'
+                "imsx_codeMajor": "success",
+                "imsx_description": f"Score for {sourcedId} is now {score}",
+                "imsx_messageIdentifier": escape(imsx_messageIdentifier),
+                "response": "<replaceResultResponse/>",
             }
             log.debug("[LTI]: Grade is saved.")
             return Response(response_xml_template.format(**values), content_type="application/xml")
 
-        unsupported_values['imsx_messageIdentifier'] = escape(imsx_messageIdentifier)
+        unsupported_values["imsx_messageIdentifier"] = escape(imsx_messageIdentifier)
         log.debug("[LTI]: Incorrect action.")
-        return Response(response_xml_template.format(**unsupported_values), content_type='application/xml')
+        return Response(response_xml_template.format(**unsupported_values), content_type="application/xml")
 
     @staticmethod
     def workbench_scenarios():
@@ -678,7 +688,7 @@ def get_user_id(self):
         """
         Returns the current user ID, URL-escaped so it is safe to use as a URL component.
         """
-        user_id = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_ANONYMOUS_USER_ID)
+        user_id = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_ANONYMOUS_USER_ID)
         assert user_id is not None
         return str(parse.quote(user_id))
 
@@ -693,7 +703,7 @@ def get_outcome_service_url(self, service_name="grade_handler"):
 
         The scheme logic is handled in lms/lib/xblock/runtime.py
         """
-        return self.runtime.handler_url(self, service_name, thirdparty=True).rstrip('/?')
+        return self.runtime.handler_url(self, service_name, thirdparty=True).rstrip("/?")
 
     def get_resource_link_id(self):
         """
@@ -738,9 +748,7 @@ def get_lis_result_sourcedid(self):
         This field is generally optional, but is required for grading.
         """
         return "{context}:{resource_link}:{user_id}".format(
-            context=parse.quote(self.context_id),
-            resource_link=self.get_resource_link_id(),
-            user_id=self.get_user_id()
+            context=parse.quote(self.context_id), resource_link=self.get_resource_link_id(), user_id=self.get_user_id()
         )
 
     def get_course(self):
@@ -772,18 +780,18 @@ def role(self):
         Get system user role and convert it to LTI role.
         """
         roles = {
-            'student': 'Student',
-            'staff': 'Administrator',
-            'instructor': 'Instructor',
+            "student": "Student",
+            "staff": "Administrator",
+            "instructor": "Instructor",
         }
-        user_role = self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_ROLE)
-        return roles.get(user_role, 'Student')
+        user_role = self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_ROLE)
+        return roles.get(user_role, "Student")
 
     def get_icon_class(self):
-        """ Returns the icon class """
+        """Returns the icon class"""
         if self.graded and self.has_score:  # pylint: disable=no-member
-            return 'problem'
-        return 'other'
+            return "problem"
+        return "other"
 
     def oauth_params(self, custom_parameters, client_key, client_secret):
         """
@@ -795,31 +803,24 @@ def oauth_params(self, custom_parameters, client_key, client_secret):
         Also *anonymous student id* is passed to template and therefore to LTI provider.
         """
 
-        client = oauthlib.oauth1.Client(
-            client_key=str(client_key),
-            client_secret=str(client_secret)
-        )
+        client = oauthlib.oauth1.Client(client_key=str(client_key), client_secret=str(client_secret))
 
         # Must have parameters for correct signing from LTI:
         body = {
-            'user_id': self.get_user_id(),
-            'oauth_callback': 'about:blank',
-            'launch_presentation_return_url': '',
-            'lti_message_type': 'basic-lti-launch-request',
-            'lti_version': 'LTI-1p0',
-            'roles': self.role,
-
+            "user_id": self.get_user_id(),
+            "oauth_callback": "about:blank",
+            "launch_presentation_return_url": "",
+            "lti_message_type": "basic-lti-launch-request",
+            "lti_version": "LTI-1p0",
+            "roles": self.role,
             # Parameters required for grading:
-            'resource_link_id': self.get_resource_link_id(),
-            'lis_result_sourcedid': self.get_lis_result_sourcedid(),
-
-            'context_id': self.context_id,
+            "resource_link_id": self.get_resource_link_id(),
+            "lis_result_sourcedid": self.get_lis_result_sourcedid(),
+            "context_id": self.context_id,
         }
 
         if self.has_score:
-            body.update({
-                'lis_outcome_service_url': self.get_outcome_service_url()
-            })
+            body.update({"lis_outcome_service_url": self.get_outcome_service_url()})
 
         self.user_email = ""  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         self.user_username = ""  # lint-amnesty, pylint: disable=attribute-defined-outside-init
@@ -827,7 +828,7 @@ def oauth_params(self, custom_parameters, client_key, client_secret):
         # Username and email can't be sent in studio mode, because the user object is not defined.
         # To test functionality test in LMS
 
-        real_user_object = self.runtime.service(self, 'user').get_user_by_anonymous_id()
+        real_user_object = self.runtime.service(self, "user").get_user_by_anonymous_id()
         try:
             self.user_email = real_user_object.email  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         except AttributeError:
@@ -847,15 +848,11 @@ def oauth_params(self, custom_parameters, client_key, client_secret):
 
         headers = {
             # This is needed for body encoding:
-            'Content-Type': 'application/x-www-form-urlencoded',
+            "Content-Type": "application/x-www-form-urlencoded",
         }
 
         try:
-            __, headers, __ = client.sign(
-                str(self.launch_url.strip()),
-                http_method='POST',
-                body=body,
-                headers=headers)
+            __, headers, __ = client.sign(str(self.launch_url.strip()), http_method="POST", body=body, headers=headers)
         except ValueError:  # Scheme not in url.
             # https://github.com/idan/oauthlib/blob/master/oauthlib/oauth1/rfc5849/signature.py#L136
             # Stubbing headers for now:
@@ -865,24 +862,25 @@ def oauth_params(self, custom_parameters, client_key, client_secret):
                 self.context_key,
             )
             headers = {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Authorization': 'OAuth oauth_nonce="80966668944732164491378916897", \
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Authorization": 'OAuth oauth_nonce="80966668944732164491378916897", \
 oauth_timestamp="1378916897", oauth_version="1.0", oauth_signature_method="HMAC-SHA1", \
-oauth_consumer_key="", oauth_signature="frVp4JuvT1mVXlxktiAUjQ7%2F1cw%3D"'}
+oauth_consumer_key="", oauth_signature="frVp4JuvT1mVXlxktiAUjQ7%2F1cw%3D"',
+            }
 
-        params = headers['Authorization']
+        params = headers["Authorization"]
         # Parse headers to pass to template as part of context:
-        params = dict([param.strip().replace('"', '').split('=') for param in params.split(',')])
+        params = dict([param.strip().replace('"', "").split("=") for param in params.split(",")])
 
-        params['oauth_nonce'] = params['OAuth oauth_nonce']
-        del params['OAuth oauth_nonce']
+        params["oauth_nonce"] = params["OAuth oauth_nonce"]
+        del params["OAuth oauth_nonce"]
 
         # oauthlib encodes signature with
         # 'Content-Type': 'application/x-www-form-urlencoded'
         # so '='' becomes '%3D'.
         # We send form via browser, so browser will encode it again,
         # So we need to decode signature back:
-        params['oauth_signature'] = parse.unquote(params['oauth_signature']).encode('utf-8').decode('utf8')
+        params["oauth_signature"] = parse.unquote(params["oauth_signature"]).encode("utf-8").decode("utf8")
 
         # Add LTI parameters to OAuth parameters for sending in form.
         params.update(body)
@@ -900,26 +898,28 @@ def parse_grade_xml_body(cls, body):
         Raises Exception if can't parse.
         """
         lti_spec_namespace = "http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0"
-        namespaces = {'def': lti_spec_namespace}
+        namespaces = {"def": lti_spec_namespace}
 
         data = body.strip()
-        parser = etree.XMLParser(ns_clean=True, recover=True, encoding='utf-8')
+        parser = etree.XMLParser(ns_clean=True, recover=True, encoding="utf-8")
         root = etree.fromstring(data, parser=parser)
 
-        imsx_messageIdentifier = root.xpath("//def:imsx_messageIdentifier", namespaces=namespaces)[0].text or ''
+        imsx_messageIdentifier = root.xpath("//def:imsx_messageIdentifier", namespaces=namespaces)[0].text or ""
         sourcedId = root.xpath("//def:sourcedId", namespaces=namespaces)[0].text
         score = root.xpath("//def:textString", namespaces=namespaces)[0].text
-        action = root.xpath(
-            "//def:imsx_POXBody", namespaces=namespaces
-        )[0].getchildren()[0].tag.replace('{' + lti_spec_namespace + '}', '')
+        action = (
+            root.xpath("//def:imsx_POXBody", namespaces=namespaces)[0]
+            .getchildren()[0]
+            .tag.replace("{" + lti_spec_namespace + "}", "")
+        )
         # Raise exception if score is not float or not in range 0.0-1.0 regarding spec.
         score = float(score)
         if not 0 <= score <= 1:
-            raise LTIError('score value outside the permitted range of 0-1.')
+            raise LTIError("score value outside the permitted range of 0-1.")
 
         return imsx_messageIdentifier, sourcedId, score, action
 
-    def verify_oauth_body_sign(self, request, content_type='application/x-www-form-urlencoded'):
+    def verify_oauth_body_sign(self, request, content_type="application/x-www-form-urlencoded"):
         """
         Verify grade request from LTI provider using OAuth body signing.
 
@@ -937,43 +937,46 @@ def verify_oauth_body_sign(self, request, content_type='application/x-www-form-u
 
         client_key, client_secret = self.get_client_key_secret()  # lint-amnesty, pylint: disable=unused-variable
         headers = {
-            'Authorization': str(request.headers.get('Authorization')),
-            'Content-Type': content_type,
+            "Authorization": str(request.headers.get("Authorization")),
+            "Content-Type": content_type,
         }
 
         sha1 = hashlib.sha1()
         sha1.update(request.body)
-        oauth_body_hash = base64.b64encode(sha1.digest()).decode('utf-8')
+        oauth_body_hash = base64.b64encode(sha1.digest()).decode("utf-8")
         oauth_params = signature.collect_parameters(headers=headers, exclude_oauth_signature=False)
         oauth_headers = dict(oauth_params)
-        oauth_signature = oauth_headers.pop('oauth_signature')
+        oauth_signature = oauth_headers.pop("oauth_signature")
         mock_request_lti_1 = mock.Mock(
             uri=str(parse.unquote(self.get_outcome_service_url())),
             http_method=str(request.method),
             params=list(oauth_headers.items()),
-            signature=oauth_signature
+            signature=oauth_signature,
         )
         mock_request_lti_2 = mock.Mock(
             uri=str(parse.unquote(request.url)),
             http_method=str(request.method),
             params=list(oauth_headers.items()),
-            signature=oauth_signature
+            signature=oauth_signature,
         )
-        if oauth_body_hash != oauth_headers.get('oauth_body_hash'):
+        if oauth_body_hash != oauth_headers.get("oauth_body_hash"):
             log.error(
                 "OAuth body hash verification failed, provided: %s, calculated: %s, for url: %s, body is: %s",
-                oauth_headers.get('oauth_body_hash'),
+                oauth_headers.get("oauth_body_hash"),
                 oauth_body_hash,
                 self.get_outcome_service_url(),
-                request.body
+                request.body,
             )
             raise LTIError("OAuth body hash verification is failed.")
 
-        if (not signature.verify_hmac_sha1(mock_request_lti_1, client_secret) and not
-                signature.verify_hmac_sha1(mock_request_lti_2, client_secret)):
+        if not signature.verify_hmac_sha1(mock_request_lti_1, client_secret) and not signature.verify_hmac_sha1(
+            mock_request_lti_2, client_secret
+        ):
             log.error(
                 "OAuth signature verification failed, for headers: %s url: %s method: %s",
-                oauth_headers, self.get_outcome_service_url(), str(request.method)
+                oauth_headers,
+                self.get_outcome_service_url(),
+                str(request.method),
             )
             raise LTIError("OAuth signature verification has failed.")
 
@@ -984,17 +987,17 @@ def get_client_key_secret(self):
         course = self.get_course()
         for lti_passport in course.lti_passports if course else []:
             try:
-                lti_id, key, secret = [i.strip() for i in lti_passport.split(':')]
+                lti_id, key, secret = [i.strip() for i in lti_passport.split(":")]
             except ValueError:
                 _ = self.runtime.service(self, "i18n").ugettext
                 msg = _('Could not parse LTI passport: {lti_passport}. Should be "id:key:secret" string.').format(
-                    lti_passport=f'{lti_passport!r}'
+                    lti_passport=f"{lti_passport!r}"
                 )
                 raise LTIError(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
             if lti_id == self.lti_id.strip():
                 return key, secret
-        return '', ''
+        return "", ""
 
     def is_past_due(self):
         """
@@ -1010,8 +1013,8 @@ def is_past_due(self):
     @classmethod
     def definition_from_xml(cls, xml_object, system):
         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):
         if self.data:
diff --git a/xblocks_contrib/lti/lti_2_util.py b/xblocks_contrib/lti/lti_2_util.py
index ee6d0c41..b1688f02 100644
--- a/xblocks_contrib/lti/lti_2_util.py
+++ b/xblocks_contrib/lti/lti_2_util.py
@@ -3,7 +3,6 @@
 keep the LTIBlock class from getting too big
 """
 
-
 import base64
 import hashlib
 import json
@@ -21,7 +20,7 @@
 log = logging.getLogger(__name__)
 
 LTI_2_0_REST_SUFFIX_PARSER = re.compile(r"^user/(?P<anon_id>\w+)", re.UNICODE)
-LTI_2_0_JSON_CONTENT_TYPE = 'application/vnd.ims.lis.v2.result+json'
+LTI_2_0_JSON_CONTENT_TYPE = "application/vnd.ims.lis.v2.result+json"
 
 
 class LTIError(Exception):
@@ -80,7 +79,7 @@ def lti_2_0_result_rest_handler(self, request, suffix):
         except LTIError:
             return Response(status=401)  # Unauthorized in this case.  401 is right
 
-        real_user = self.runtime.service(self, 'user').get_user_by_anonymous_id(anon_id)
+        real_user = self.runtime.service(self, "user").get_user_by_anonymous_id(anon_id)
         if not real_user:  # that means we can't save to database, as we do not have real user id.
             msg = f"[LTI]: Real user not found against anon_id: {anon_id}"
             log.info(msg)
@@ -122,14 +121,14 @@ def _log_correct_authorization_header(self, request):
         )
         params = client.get_oauth_params(mock_request)
         mock_request.oauth_params = params
-        mock_request.oauth_params.append(('oauth_body_hash', oauth_body_hash))
+        mock_request.oauth_params.append(("oauth_body_hash", oauth_body_hash))
         sig = client.get_oauth_signature(mock_request)
-        mock_request.oauth_params.append(('oauth_signature', sig))
+        mock_request.oauth_params.append(("oauth_signature", sig))
 
         _, headers, _ = client._render(mock_request)  # pylint: disable=protected-access
         log.debug(
             "\n\n#### COPY AND PASTE AUTHORIZATION HEADER ####\n%s\n####################################\n\n",
-            headers['Authorization']
+            headers["Authorization"],
         )
 
     def parse_lti_2_0_handler_suffix(self, suffix):
@@ -151,7 +150,7 @@ def parse_lti_2_0_handler_suffix(self, suffix):
         if suffix:
             match_obj = LTI_2_0_REST_SUFFIX_PARSER.match(suffix)
             if match_obj:
-                return match_obj.group('anon_id')
+                return match_obj.group("anon_id")
         # fall-through handles all error cases
         msg = "No valid user id found in endpoint URL"
         log.info(f"[LTI]: {msg}")
@@ -170,7 +169,7 @@ def _round_away_from_zero(self, number, digits=0):
         We want to continue to round away from zero so that student grades remain
         consistent and don't suddenly change.
         """
-        p = 10.0 ** digits
+        p = 10.0**digits
 
         if number >= 0:
             return float(math.floor((number * p) + 0.5)) / p
@@ -190,18 +189,15 @@ def _lti_2_0_result_get_handler(self, _request, real_user):
         Returns:
             webob.response:  response to this request, in JSON format with status 200 if success
         """
-        base_json_obj = {
-            "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
-            "@type": "Result"
-        }
-        self.runtime.service(self, 'rebind_user').rebind_noauth_module_to_user(self, real_user)
+        base_json_obj = {"@context": "http://purl.imsglobal.org/ctx/lis/v2/Result", "@type": "Result"}
+        self.runtime.service(self, "rebind_user").rebind_noauth_module_to_user(self, real_user)
         if self.module_score is None:  # In this case, no score has been ever set
-            return Response(json.dumps(base_json_obj).encode('utf-8'), content_type=LTI_2_0_JSON_CONTENT_TYPE)
+            return Response(json.dumps(base_json_obj).encode("utf-8"), content_type=LTI_2_0_JSON_CONTENT_TYPE)
 
         # Fall through to returning grade and comment
-        base_json_obj['resultScore'] = self._round_away_from_zero(self.module_score, 2)
-        base_json_obj['comment'] = self.score_comment
-        return Response(json.dumps(base_json_obj).encode('utf-8'), content_type=LTI_2_0_JSON_CONTENT_TYPE)
+        base_json_obj["resultScore"] = self._round_away_from_zero(self.module_score, 2)
+        base_json_obj["comment"] = self.score_comment
+        return Response(json.dumps(base_json_obj).encode("utf-8"), content_type=LTI_2_0_JSON_CONTENT_TYPE)
 
     def _lti_2_0_result_del_handler(self, _request, real_user):
         """
@@ -233,7 +229,7 @@ def _lti_2_0_result_put_handler(self, request, real_user):
             webob.response:  response to this request.  status 200 if success.  404 if body of PUT request is malformed
         """
         try:
-            (score, comment) = self.parse_lti_2_0_result_json(request.body.decode('utf-8'))
+            (score, comment) = self.parse_lti_2_0_result_json(request.body.decode("utf-8"))
         except LTIError:
             return Response(status=404)  # have to do 404 due to spec, but 400 is better, with error msg in body
 
@@ -277,17 +273,17 @@ def set_user_module_score(self, user, score, max_score, *, comment="", score_del
         else:
             scaled_score = None
 
-        self.runtime.service(self, 'rebind_user').rebind_noauth_module_to_user(self, user)
+        self.runtime.service(self, "rebind_user").rebind_noauth_module_to_user(self, user)
 
         # have to publish for the progress page...
         self.runtime.publish(
             self,
-            'grade',
+            "grade",
             {
-                'value': scaled_score,
-                'max_value': max_score,
-                'user_id': user.id,
-                'score_deleted': score_deleted,
+                "value": scaled_score,
+                "max_value": max_score,
+                "user_id": user.id,
+                "score_deleted": score_deleted,
             },
         )
         self.module_score = scaled_score
@@ -307,12 +303,14 @@ def verify_lti_2_0_result_rest_headers(self, request, verify_content_type=True):
         Raises:
             LTIError if verification fails
         """
-        content_type = request.headers.get('Content-Type')
+        content_type = request.headers.get("Content-Type")
         if verify_content_type and content_type != LTI_2_0_JSON_CONTENT_TYPE:
             log.info(f"[LTI]: v2.0 result service -- bad Content-Type: {content_type}")
             raise LTIError(
-                "For LTI 2.0 result service, Content-Type must be {}.  Got {}".format(LTI_2_0_JSON_CONTENT_TYPE,
-                                                                                      content_type))
+                "For LTI 2.0 result service, Content-Type must be {}.  Got {}".format(
+                    LTI_2_0_JSON_CONTENT_TYPE, content_type
+                )
+            )
         try:
             self.verify_oauth_body_sign(request, content_type=LTI_2_0_JSON_CONTENT_TYPE)
         except (ValueError, LTIError) as err:
@@ -352,8 +350,9 @@ def parse_lti_2_0_result_json(self, json_str):
             if isinstance(json_obj, list) and len(json_obj) >= 1 and isinstance(json_obj[0], dict):
                 json_obj = json_obj[0]
             else:
-                msg = ("Supplied JSON string is a list that does not contain an object as the first element. {}"
-                       .format(json_str))
+                msg = "Supplied JSON string is a list that does not contain an object as the first element. {}".format(
+                    json_str
+                )
                 log.info(f"[LTI] {msg}")
                 raise LTIError(msg)
 
@@ -376,13 +375,13 @@ def parse_lti_2_0_result_json(self, json_str):
         # to the LTI spec.  We will indicate this by returning None as score, "" as comment.
         # The actual delete will be handled by the caller
         if "resultScore" not in json_obj:
-            return None, json_obj.get('comment', "")
+            return None, json_obj.get("comment", "")
 
         # if present, 'resultScore' must be a number between 0 and 1 inclusive
         try:
-            score = float(json_obj.get('resultScore', "unconvertable"))  # Check if float is present and the right type
+            score = float(json_obj.get("resultScore", "unconvertable"))  # Check if float is present and the right type
             if not 0 <= score <= 1:
-                msg = 'score value outside the permitted range of 0-1.'
+                msg = "score value outside the permitted range of 0-1."
                 log.info(f"[LTI] {msg}")
                 raise LTIError(msg)
         except (TypeError, ValueError) as err:
@@ -390,4 +389,4 @@ def parse_lti_2_0_result_json(self, json_str):
             log.info(f"[LTI] {msg}")
             raise LTIError(msg)  # lint-amnesty, pylint: disable=raise-missing-from
 
-        return score, json_obj.get('comment', "")
+        return score, json_obj.get("comment", "")
diff --git a/xblocks_contrib/lti/tests/helpers.py b/xblocks_contrib/lti/tests/helpers.py
index 23c71618..43608296 100644
--- a/xblocks_contrib/lti/tests/helpers.py
+++ b/xblocks_contrib/lti/tests/helpers.py
@@ -11,12 +11,12 @@
 from xblock.runtime import Runtime
 
 TIMEDELTA_REGEX = re.compile(
-    r'^'
-    r'((?P<days>\d+?) day(?:s?))?(\s)?'
-    r'((?P<hours>\d+?) hour(?:s?))?(\s)?'
-    r'((?P<minutes>\d+?) minute(?:s)?)?(\s)?'
-    r'((?P<seconds>\d+?) second(?:s)?)?'
-    r'$'
+    r"^"
+    r"((?P<days>\d+?) day(?:s?))?(\s)?"
+    r"((?P<hours>\d+?) hour(?:s?))?(\s)?"
+    r"((?P<minutes>\d+?) minute(?:s)?)?(\s)?"
+    r"((?P<seconds>\d+?) second(?:s)?)?"
+    r"$"
 )
 
 
@@ -45,7 +45,7 @@ def from_json(self, time_str):  # lint-amnesty, pylint: disable=arguments-rename
             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)
@@ -55,11 +55,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):
         """
@@ -76,14 +76,16 @@ class StubUserService(UserService):
     Stub UserService for testing the sequence block.
     """
 
-    def __init__(self,  # pylint: disable=too-many-positional-arguments
-                 user=None,
-                 user_is_staff=False,
-                 user_role=None,
-                 anonymous_user_id=None,
-                 deprecated_anonymous_user_id=None,
-                 request_country_code=None,
-                 **kwargs):
+    def __init__(
+        self,  # pylint: disable=too-many-positional-arguments
+        user=None,
+        user_is_staff=False,
+        user_role=None,
+        anonymous_user_id=None,
+        deprecated_anonymous_user_id=None,
+        request_country_code=None,
+        **kwargs,
+    ):
         self.user = user
         self.user_is_staff = user_is_staff
         self.user_role = user_role
@@ -99,17 +101,17 @@ def get_current_user(self):
         """
         user = XBlockUser()
         if self.user and self.user.is_authenticated:
-            user.opt_attrs['edx-platform.anonymous_user_id'] = self.anonymous_user_id
-            user.opt_attrs['edx-platform.deprecated_anonymous_user_id'] = self.deprecated_anonymous_user_id
-            user.opt_attrs['edx-platform.request_country_code'] = self.request_country_code
-            user.opt_attrs['edx-platform.user_is_staff'] = self.user_is_staff
-            user.opt_attrs['edx-platform.user_id'] = self.user.id
-            user.opt_attrs['edx-platform.user_role'] = self.user_role
-            user.opt_attrs['edx-platform.username'] = self.user.username
+            user.opt_attrs["edx-platform.anonymous_user_id"] = self.anonymous_user_id
+            user.opt_attrs["edx-platform.deprecated_anonymous_user_id"] = self.deprecated_anonymous_user_id
+            user.opt_attrs["edx-platform.request_country_code"] = self.request_country_code
+            user.opt_attrs["edx-platform.user_is_staff"] = self.user_is_staff
+            user.opt_attrs["edx-platform.user_id"] = self.user.id
+            user.opt_attrs["edx-platform.user_role"] = self.user_role
+            user.opt_attrs["edx-platform.username"] = self.user.username
         else:
-            user.opt_attrs['edx-platform.username'] = 'anonymous'
-            user.opt_attrs['edx-platform.request_country_code'] = self.request_country_code
-            user.opt_attrs['edx-platform.is_authenticated'] = False
+            user.opt_attrs["edx-platform.username"] = "anonymous"
+            user.opt_attrs["edx-platform.request_country_code"] = self.request_country_code
+            user.opt_attrs["edx-platform.is_authenticated"] = False
         return user
 
     def get_user_by_anonymous_id(self, uid=None):  # pylint: disable=unused-argument
@@ -127,9 +129,7 @@ def __init__(self, anonymous_student_id, services=None):
         super().__init__(id_reader=lambda: None, id_generator=lambda: None, services=services)
         self.anonymous_student_id = anonymous_student_id
 
-    def handler_url(
-        self, block, handler_name, suffix="", query="", thirdparty=False
-    ):  # pylint: disable=too-many-positional-arguments
+    def handler_url(self, block, handler_name, suffix="", query="", thirdparty=False):  # pylint: disable=too-many-positional-arguments
         return f"/mock_url/{handler_name}"
 
     def local_resource_url(self, block, resource):  # pylint: disable=arguments-renamed
@@ -149,19 +149,19 @@ def get_test_system(
     """Construct a minimal test system for the LTIBlockTest."""
 
     if not user:
-        user = Mock(name='get_test_system.user', is_staff=False)
+        user = Mock(name="get_test_system.user", is_staff=False)
     user_service = StubUserService(
         user=user,
-        anonymous_user_id='student',
-        deprecated_anonymous_user_id='student',
+        anonymous_user_id="student",
+        deprecated_anonymous_user_id="student",
         user_is_staff=user_is_staff,
-        user_role='student',
+        user_role="student",
     )
     runtime = MockRuntime(
         anonymous_student_id="student",
         services={
             "user": user_service,
-        }
+        },
     )
 
     return runtime
diff --git a/xblocks_contrib/lti/tests/test_lti20_unit.py b/xblocks_contrib/lti/tests/test_lti20_unit.py
index efad5cc9..56303c2a 100644
--- a/xblocks_contrib/lti/tests/test_lti20_unit.py
+++ b/xblocks_contrib/lti/tests/test_lti20_unit.py
@@ -32,9 +32,7 @@ def setUp(self):
         self.xblock = LTIBlock(self.runtime, DictFieldData({}), Mock())
         self.lti_id = self.xblock.lti_id
 
-        self.unquoted_resource_link_id = (
-            "{}-i4x-2-3-lti-31de800015cf4afb973356dbe81496df".format(settings.LMS_BASE)
-        )
+        self.unquoted_resource_link_id = "{}-i4x-2-3-lti-31de800015cf4afb973356dbe81496df".format(settings.LMS_BASE)
 
         self.xblock.due = None
         self.xblock.graceperiod = None
@@ -42,9 +40,7 @@ def setUp(self):
     def test_sanitize_get_context(self):
         """Tests that the get_context function does basic sanitization"""
         # get_context, unfortunately, requires a lot of mocking machinery
-        mocked_course = Mock(
-            name="mocked_course", lti_passports=["lti_id:test_client:test_secret"]
-        )
+        mocked_course = Mock(name="mocked_course", lti_passports=["lti_id:test_client:test_secret"])
         modulestore = Mock(name="modulestore")
         modulestore.get_course.return_value = mocked_course
         self.xblock.runtime.modulestore = modulestore
@@ -74,9 +70,7 @@ def test_lti20_rest_failed_oauth_body_verify(self):
         err_msg = "OAuth body verification failed"
         self.xblock.verify_oauth_body_sign = Mock(side_effect=LTIError(err_msg))
         with self.assertRaisesRegex(LTIError, err_msg):
-            request = Mock(
-                headers={"Content-Type": "application/vnd.ims.lis.v2.result+json"}
-            )
+            request = Mock(headers={"Content-Type": "application/vnd.ims.lis.v2.result+json"})
             self.xblock.verify_lti_2_0_result_rest_headers(request)
 
     def test_lti20_rest_good_headers(self):
@@ -85,9 +79,7 @@ def test_lti20_rest_good_headers(self):
         """
         self.xblock.verify_oauth_body_sign = Mock(return_value=True)
 
-        request = Mock(
-            headers={"Content-Type": "application/vnd.ims.lis.v2.result+json"}
-        )
+        request = Mock(headers={"Content-Type": "application/vnd.ims.lis.v2.result+json"})
         self.xblock.verify_lti_2_0_result_rest_headers(request)
         #  We just want the above call to complete without exceptions, and to have called verify_oauth_body_sign
         assert self.xblock.verify_oauth_body_sign.called
@@ -95,13 +87,7 @@ def test_lti20_rest_good_headers(self):
     BAD_DISPATCH_INPUTS = [
         None,
         "",
-        "abcd"
-        "notuser/abcd"
-        "user/"
-        "user//"
-        "user/gbere/"
-        "user/gbere/xsdf"
-        "user/ಠ益ಠ",  # not alphanumeric
+        "abcdnotuser/abcduser/user//user/gbere/user/gbere/xsdfuser/ಠ益ಠ",  # not alphanumeric
     ]
 
     def test_lti20_rest_bad_dispatch(self):
@@ -128,41 +114,59 @@ def test_lti20_rest_good_dispatch(self):
 
     BAD_JSON_INPUTS = [
         # (bad inputs, error message expected)
-        ([
-            "kk",   # ValueError
-            "{{}",  # ValueError
-            "{}}",  # ValueError
-            3,       # TypeError
-            {},      # TypeError
-        ], "Supplied JSON string in request body could not be decoded"),
-        ([
-            "3",        # valid json, not array or object
-            "[]",       # valid json, array too small
-            "[3, {}]",  # valid json, 1st element not an object
-        ], "Supplied JSON string is a list that does not contain an object as the first element"),
-        ([
-            '{"@type": "NOTResult"}',  # @type key must have value 'Result'
-        ], "JSON object does not contain correct @type attribute"),
-        ([
-            # @context missing
-            '{"@type": "Result", "resultScore": 0.1}',
-        ], "JSON object does not contain required key"),
-        ([
-            '''
+        (
+            [
+                "kk",  # ValueError
+                "{{}",  # ValueError
+                "{}}",  # ValueError
+                3,  # TypeError
+                {},  # TypeError
+            ],
+            "Supplied JSON string in request body could not be decoded",
+        ),
+        (
+            [
+                "3",  # valid json, not array or object
+                "[]",  # valid json, array too small
+                "[3, {}]",  # valid json, 1st element not an object
+            ],
+            "Supplied JSON string is a list that does not contain an object as the first element",
+        ),
+        (
+            [
+                '{"@type": "NOTResult"}',  # @type key must have value 'Result'
+            ],
+            "JSON object does not contain correct @type attribute",
+        ),
+        (
+            [
+                # @context missing
+                '{"@type": "Result", "resultScore": 0.1}',
+            ],
+            "JSON object does not contain required key",
+        ),
+        (
+            [
+                """
             {"@type": "Result",
              "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
-             "resultScore": 100}'''  # score out of range
-        ], "score value outside the permitted range of 0-1."),
-        ([
-            '''
+             "resultScore": 100}"""  # score out of range
+            ],
+            "score value outside the permitted range of 0-1.",
+        ),
+        (
+            [
+                """
             {"@type": "Result",
              "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
-             "resultScore": "1b"}''',   # score ValueError
-            '''
+             "resultScore": "1b"}""",  # score ValueError
+                """
             {"@type": "Result",
              "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
-             "resultScore": {}}''',   # score TypeError
-        ], "Could not convert resultScore to float"),
+             "resultScore": {}}""",  # score TypeError
+            ],
+            "Could not convert resultScore to float",
+        ),
     ]
 
     def test_lti20_bad_json(self):
@@ -175,20 +179,29 @@ def test_lti20_bad_json(self):
                     self.xblock.parse_lti_2_0_result_json(einput)
 
     GOOD_JSON_INPUTS = [
-        ('''
+        (
+            """
         {"@type": "Result",
          "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
-         "resultScore": 0.1}''', ""),  # no comment means we expect ""
-        ('''
+         "resultScore": 0.1}""",
+            "",
+        ),  # no comment means we expect ""
+        (
+            """
         [{"@type": "Result",
          "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
          "@id": "anon_id:abcdef0123456789",
-         "resultScore": 0.1}]''', ""),  # OK to have array of objects -- just take the first.  @id is okay too
-        ('''
+         "resultScore": 0.1}]""",
+            "",
+        ),  # OK to have array of objects -- just take the first.  @id is okay too
+        (
+            """
         {"@type": "Result",
          "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
          "resultScore": 0.1,
-         "comment": "ಠ益ಠ"}''', "ಠ益ಠ"),  # unicode comment
+         "comment": "ಠ益ಠ"}""",
+            "ಠ益ಠ",
+        ),  # unicode comment
     ]
 
     def test_lti20_good_json(self):
@@ -206,14 +219,14 @@ def test_lti20_good_json(self):
          "@id": "anon_id:abcdef0123456789",
          "resultScore": 0.1,
          "comment": "ಠ益ಠ"}
-    """).encode('utf-8')
+    """).encode("utf-8")
 
     GOOD_JSON_PUT_LIKE_DELETE = textwrap.dedent("""
         {"@type": "Result",
          "@context": "http://purl.imsglobal.org/ctx/lis/v2/Result",
          "@id": "anon_id:abcdef0123456789",
          "comment": "ಠ益ಠ"}
-    """).encode('utf-8')
+    """).encode("utf-8")
 
     def get_signed_lti20_mock_request(self, body, method="PUT"):
         """
@@ -221,8 +234,8 @@ def get_signed_lti20_mock_request(self, body, method="PUT"):
         """
         mock_request = Mock()
         mock_request.headers = {
-            'Content-Type': 'application/vnd.ims.lis.v2.result+json',
-            'Authorization': (
+            "Content-Type": "application/vnd.ims.lis.v2.result+json",
+            "Authorization": (
                 'OAuth oauth_nonce="135685044251684026041377608307", '
                 'oauth_timestamp="1234567890", oauth_version="1.0", '
                 'oauth_signature_method="HMAC-SHA1", '
@@ -242,9 +255,7 @@ def setup_system_xblock_mocks_for_lti20_request_test(self):
         Helper fn to set up mocking for lti 2.0 request test
         """
         self.xblock.max_score = Mock(return_value=1.0)
-        self.xblock.get_client_key_secret = Mock(
-            return_value=("test_client_key", "test_client_secret")
-        )
+        self.xblock.get_client_key_secret = Mock(return_value=("test_client_key", "test_client_secret"))
         self.xblock.verify_oauth_body_sign = Mock()
 
     def test_lti20_put_like_delete_success(self):
@@ -256,18 +267,14 @@ def test_lti20_put_like_delete_success(self):
         COMMENT = "ಠ益ಠ"  # pylint: disable=invalid-name
         self.xblock.module_score = SCORE
         self.xblock.score_comment = COMMENT
-        mock_request = self.get_signed_lti20_mock_request(
-            self.GOOD_JSON_PUT_LIKE_DELETE
-        )
+        mock_request = self.get_signed_lti20_mock_request(self.GOOD_JSON_PUT_LIKE_DELETE)
         # Now call the handler
         response = self.xblock.lti_2_0_result_rest_handler(mock_request, "user/abcd")
         # Now assert there's no score
         assert response.status_code == 200
         assert self.xblock.module_score is None
         assert self.xblock.score_comment == ""
-        (_, evt_type, called_grade_obj), _ = (
-            self.runtime.publish.call_args
-        )
+        (_, evt_type, called_grade_obj), _ = self.runtime.publish.call_args
         assert called_grade_obj == {
             "user_id": self.USER_STANDIN.id,
             "value": None,
@@ -292,9 +299,7 @@ def test_lti20_delete_success(self):
         assert response.status_code == 200
         assert self.xblock.module_score is None
         assert self.xblock.score_comment == ""
-        (_, evt_type, called_grade_obj), _ = (
-            self.runtime.publish.call_args
-        )
+        (_, evt_type, called_grade_obj), _ = self.runtime.publish.call_args
         assert called_grade_obj == {
             "user_id": self.USER_STANDIN.id,
             "value": None,
@@ -315,9 +320,7 @@ def test_lti20_put_set_score_success(self):
         assert response.status_code == 200
         assert self.xblock.module_score == 0.1
         assert self.xblock.score_comment == "ಠ益ಠ"
-        (_, evt_type, called_grade_obj), _ = (
-            self.runtime.publish.call_args
-        )
+        (_, evt_type, called_grade_obj), _ = self.runtime.publish.call_args
         assert evt_type == "grade"
         assert called_grade_obj == {
             "user_id": self.USER_STANDIN.id,
@@ -372,9 +375,7 @@ def test_lti20_unsupported_method_error(self):
         mock_request = self.get_signed_lti20_mock_request(self.GOOD_JSON_PUT)
         for bad_method in self.UNSUPPORTED_HTTP_METHODS:
             mock_request.method = bad_method
-            response = self.xblock.lti_2_0_result_rest_handler(
-                mock_request, "user/abcd"
-            )
+            response = self.xblock.lti_2_0_result_rest_handler(mock_request, "user/abcd")
             assert response.status_code == 404
 
     def test_lti20_request_handler_bad_headers(self):
diff --git a/xblocks_contrib/lti/tests/test_lti_unit.py b/xblocks_contrib/lti/tests/test_lti_unit.py
index 5bf59db5..d786c4f2 100644
--- a/xblocks_contrib/lti/tests/test_lti_unit.py
+++ b/xblocks_contrib/lti/tests/test_lti_unit.py
@@ -58,31 +58,25 @@ def setUp(self):
                     </{action}>
                   </imsx_POXBody>
                 </imsx_POXEnvelopeRequest>
-            """)
-        self.context_key = CourseKey.from_string('org/course/run')
+            """
+        )
+        self.context_key = CourseKey.from_string("org/course/run")
         self.runtime = get_test_system()
         self.runtime.publish = Mock()
-        self.runtime._services['rebind_user'] = Mock()  # pylint: disable=protected-access
+        self.runtime._services["rebind_user"] = Mock()  # pylint: disable=protected-access
 
         self.xblock = LTIBlock(
             self.runtime,
             DictFieldData({}),
-            ScopeIds(
-                None, None, None, BlockUsageLocator(self.context_key, "lti", "name")
-            ),
+            ScopeIds(None, None, None, BlockUsageLocator(self.context_key, "lti", "name")),
         )
         current_user = self.runtime.service(self.xblock, "user").get_current_user()
         self.user_id = current_user.opt_attrs.get(ATTR_KEY_ANONYMOUS_USER_ID)
         self.lti_id = self.xblock.lti_id
 
-        self.unquoted_resource_link_id = (
-            "{}-i4x-2-3-lti-31de800015cf4afb973356dbe81496df".format(settings.LMS_BASE)
-        )
+        self.unquoted_resource_link_id = "{}-i4x-2-3-lti-31de800015cf4afb973356dbe81496df".format(settings.LMS_BASE)
 
-        sourced_id = ":".join(
-            parse.quote(i)
-            for i in (self.lti_id, self.unquoted_resource_link_id, self.user_id)
-        )
+        sourced_id = ":".join(parse.quote(i) for i in (self.lti_id, self.unquoted_resource_link_id, self.user_id))
 
         self.defaults = {
             "namespace": "http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0",
@@ -112,18 +106,12 @@ def get_response_values(self, response):
         namespaces = {"def": lti_spec_namespace}
 
         code_major = root.xpath("//def:imsx_codeMajor", namespaces=namespaces)[0].text
-        description = root.xpath("//def:imsx_description", namespaces=namespaces)[
-            0
-        ].text
-        message_identifier = root.xpath(
-            "//def:imsx_messageIdentifier", namespaces=namespaces
-        )[0].text
+        description = root.xpath("//def:imsx_description", namespaces=namespaces)[0].text
+        message_identifier = root.xpath("//def:imsx_messageIdentifier", namespaces=namespaces)[0].text
         imsx_pox_body = root.xpath("//def:imsx_POXBody", namespaces=namespaces)[0]
 
         try:
-            action = imsx_pox_body.getchildren()[0].tag.replace(
-                "{" + lti_spec_namespace + "}", ""
-            )
+            action = imsx_pox_body.getchildren()[0].tag.replace("{" + lti_spec_namespace + "}", "")
         except Exception:  # pylint: disable=broad-except
             action = None
 
@@ -312,25 +300,17 @@ def test_outcome_service_url(self):
         mock_url_prefix = "https://hostname/"
         test_service_name = "test_service"
 
-        def mock_handler_url(
-            block, handler_name, **kwargs
-        ):  # pylint: disable=unused-argument
+        def mock_handler_url(block, handler_name, **kwargs):  # pylint: disable=unused-argument
             """Mock function for returning fully-qualified handler urls"""
             return mock_url_prefix + handler_name
 
         self.xblock.runtime.handler_url = Mock(side_effect=mock_handler_url)
-        real_outcome_service_url = self.xblock.get_outcome_service_url(
-            service_name=test_service_name
-        )
+        real_outcome_service_url = self.xblock.get_outcome_service_url(service_name=test_service_name)
         assert real_outcome_service_url == (mock_url_prefix + test_service_name)
 
     def test_resource_link_id(self):
-        with patch(
-            "xblocks_contrib.lti.lti.LTIBlock.usage_key", new_callable=PropertyMock
-        ):
-            self.xblock.usage_key.html_id = (
-                lambda: "i4x-2-3-lti-31de800015cf4afb973356dbe81496df"
-            )
+        with patch("xblocks_contrib.lti.lti.LTIBlock.usage_key", new_callable=PropertyMock):
+            self.xblock.usage_key.html_id = lambda: "i4x-2-3-lti-31de800015cf4afb973356dbe81496df"
             expected_resource_link_id = str(parse.quote(self.unquoted_resource_link_id))
             real_resource_link_id = self.xblock.get_resource_link_id()
             assert real_resource_link_id == expected_resource_link_id
@@ -397,9 +377,7 @@ def test_bad_client_key_secret(self):
         with pytest.raises(LTIError):
             self.xblock.get_client_key_secret()
 
-    @patch(
-        "xblocks_contrib.lti.lti.signature.verify_hmac_sha1", Mock(return_value=True)
-    )
+    @patch("xblocks_contrib.lti.lti.signature.verify_hmac_sha1", Mock(return_value=True))
     @patch(
         "xblocks_contrib.lti.lti.LTIBlock.get_client_key_secret",
         Mock(return_value=("test_client_key", "test_client_secret")),
@@ -470,9 +448,7 @@ def test_wrong_xml_namespace(self):
         Tests that tool provider returned grade back with wrong XML Namespace.
         """
         with pytest.raises(IndexError):
-            mocked_request = self.get_signed_grade_mock_request(
-                namespace_lti_v1p1=False
-            )
+            mocked_request = self.get_signed_grade_mock_request(namespace_lti_v1p1=False)
             self.xblock.parse_grade_xml_body(mocked_request.body)
 
     def test_parse_grade_xml_body(self):
@@ -482,17 +458,13 @@ def test_parse_grade_xml_body(self):
         Tests that xml body was parsed successfully.
         """
         mocked_request = self.get_signed_grade_mock_request()
-        message_identifier, sourced_id, grade, action = (
-            self.xblock.parse_grade_xml_body(mocked_request.body)
-        )
+        message_identifier, sourced_id, grade, action = self.xblock.parse_grade_xml_body(mocked_request.body)
         assert self.defaults["messageIdentifier"] == message_identifier
         assert self.defaults["sourcedId"] == sourced_id
         assert self.defaults["grade"] == grade
         assert self.defaults["action"] == action
 
-    @patch(
-        "xblocks_contrib.lti.lti.signature.verify_hmac_sha1", Mock(return_value=False)
-    )
+    @patch("xblocks_contrib.lti.lti.signature.verify_hmac_sha1", Mock(return_value=False))
     @patch(
         "xblocks_contrib.lti.lti.LTIBlock.get_client_key_secret",
         Mock(return_value=("test_client_key", "test_client_secret")),
@@ -538,9 +510,7 @@ def test_good_custom_params(self):
         Custom parameters are presented in right format.
         """
         self.xblock.custom_parameters = ["test_custom_params=test_custom_param_value"]
-        self.xblock.get_client_key_secret = Mock(
-            return_value=("test_client_key", "test_client_secret")
-        )
+        self.xblock.get_client_key_secret = Mock(return_value=("test_client_key", "test_client_secret"))
         self.xblock.oauth_params = Mock()
         self.xblock.get_input_fields()
         self.xblock.oauth_params.assert_called_with(
@@ -555,9 +525,7 @@ def test_bad_custom_params(self):
         """
         bad_custom_params = ["test_custom_params: test_custom_param_value"]
         self.xblock.custom_parameters = bad_custom_params
-        self.xblock.get_client_key_secret = Mock(
-            return_value=("test_client_key", "test_client_secret")
-        )
+        self.xblock.get_client_key_secret = Mock(return_value=("test_client_key", "test_client_secret"))
         self.xblock.oauth_params = Mock()
         with pytest.raises(LTIError):
             self.xblock.get_input_fields()
diff --git a/xblocks_contrib/poll/__init__.py b/xblocks_contrib/poll/__init__.py
index 6eddb6a0..db5a1e2a 100644
--- a/xblocks_contrib/poll/__init__.py
+++ b/xblocks_contrib/poll/__init__.py
@@ -2,4 +2,4 @@
 Init for the PollBlock.
 """
 
-from .poll import PollBlock
+from .poll import PollBlock as PollBlock
diff --git a/xblocks_contrib/poll/tests/test_poll.py b/xblocks_contrib/poll/tests/test_poll.py
index 1ee0ed13..bc0fad3e 100644
--- a/xblocks_contrib/poll/tests/test_poll.py
+++ b/xblocks_contrib/poll/tests/test_poll.py
@@ -2,10 +2,7 @@
 Tests for PollBlock
 """
 
-import json
-
 from django.test import TestCase
-from lxml import etree
 from opaque_keys.edx.keys import CourseKey
 from xblock.field_data import DictFieldData
 from xblock.fields import ScopeIds
diff --git a/xblocks_contrib/problem/__init__.py b/xblocks_contrib/problem/__init__.py
index 95757cba..c7738676 100644
--- a/xblocks_contrib/problem/__init__.py
+++ b/xblocks_contrib/problem/__init__.py
@@ -2,4 +2,4 @@
 Init for the ProblemBlock.
 """
 
-from .capa_block import ProblemBlock
+from .capa_block import ProblemBlock as ProblemBlock
diff --git a/xblocks_contrib/problem/capa/capa_problem.py b/xblocks_contrib/problem/capa/capa_problem.py
index 1329a747..c38fee8a 100644
--- a/xblocks_contrib/problem/capa/capa_problem.py
+++ b/xblocks_contrib/problem/capa/capa_problem.py
@@ -239,7 +239,7 @@ def __init__(  # pylint: disable=too-many-positional-arguments,too-many-argument
             # 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"):
                     response.late_transforms(self)
@@ -925,7 +925,6 @@ def _extract_context(self, tree):
         python_path = []
 
         for script in tree.findall(".//script"):
-
             stype = script.get("type")
             if stype:
                 if "javascript" in stype:
diff --git a/xblocks_contrib/problem/capa/customrender.py b/xblocks_contrib/problem/capa/customrender.py
index 731fd50f..4eb6121e 100644
--- a/xblocks_contrib/problem/capa/customrender.py
+++ b/xblocks_contrib/problem/capa/customrender.py
@@ -132,7 +132,7 @@ def get_html(self):
         # xss-lint: disable=python-wrap-html
         html_str = (
             f'<section class="targeted-feedback-span">'
-            f'<span>{etree.tostring(self.xml, encoding="unicode")}</span>'
+            f"<span>{etree.tostring(self.xml, encoding='unicode')}</span>"
             f"</section>"
         )
         try:
diff --git a/xblocks_contrib/problem/capa/inputtypes.py b/xblocks_contrib/problem/capa/inputtypes.py
index bc8b146c..c87017d0 100644
--- a/xblocks_contrib/problem/capa/inputtypes.py
+++ b/xblocks_contrib/problem/capa/inputtypes.py
@@ -39,7 +39,6 @@
 # makes sense, but a bunch of problems have markup that assumes block.  Bigger TODO: figure out a
 # general css and layout strategy for capa, document it, then implement it.
 
-
 import json
 import logging
 import re
diff --git a/xblocks_contrib/problem/capa/responsetypes.py b/xblocks_contrib/problem/capa/responsetypes.py
index feacffa5..3d66495c 100644
--- a/xblocks_contrib/problem/capa/responsetypes.py
+++ b/xblocks_contrib/problem/capa/responsetypes.py
@@ -28,6 +28,7 @@
 import random2 as random
 import requests
 import six
+
 # specific library imports
 from calc import UndefinedVariable, UnmatchedParenthesis, evaluator
 from django.utils import html
@@ -475,7 +476,12 @@ def get_hints(self, student_answers, new_cmap, old_cmap):  # pylint: disable=too
                 # We need the CorrectMap code for hint functions. No, this is not great.
                 CORRECTMAP_PY = inspect.getsource(correctmap)
 
-            code = CORRECTMAP_PY + "\n" + self.context["script_code"] + "\n" + textwrap.dedent("""
+            code = (
+                CORRECTMAP_PY
+                + "\n"
+                + self.context["script_code"]
+                + "\n"
+                + textwrap.dedent("""
                     new_cmap = CorrectMap()
                     new_cmap.set_dict(new_cmap_dict)
                     old_cmap = CorrectMap()
@@ -484,6 +490,7 @@ def get_hints(self, student_answers, new_cmap, old_cmap):  # pylint: disable=too
                     new_cmap_dict.update(new_cmap.get_dict())
                     old_cmap_dict.update(old_cmap.get_dict())
                     """).format(hintfn=hintfn)
+            )
             globals_dict = {
                 "answer_ids": self.answer_ids,
                 "student_answers": student_answers,
@@ -535,7 +542,6 @@ def get_hints(self, student_answers, new_cmap, old_cmap):  # pylint: disable=too
             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(  # pylint: disable=assignment-from-no-return
                 rephints, student_answers
@@ -688,7 +694,6 @@ def setup_response(self):
         self.correct_choices = set()
         self.incorrect_choices = set()
         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()
@@ -2283,9 +2288,7 @@ def get_score(self, student_answers):  # pylint: disable=too-many-locals
             correct_map.set(idset[k], correct[k], msg=messages[k], npoints=npoints)
         return correct_map
 
-    def execute_check_function(
-        self, idset, submission
-    ):  # pylint: disable=too-many-statements,too-many-locals,too-many-branches
+    def execute_check_function(self, idset, submission):  # pylint: disable=too-many-statements,too-many-locals,too-many-branches
         """Execute the custom check function for a submission, updating correctness,
         messages, and grades in the context."""
 
@@ -2328,7 +2331,6 @@ def execute_check_function(
                 # If there are multiple inputs, they all get marked
                 # to the same correct/incorrect value
                 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
@@ -2435,7 +2437,6 @@ def execute_check_function(
                     raise ResponseError(_("CustomResponse: check function returned an invalid dictionary!"))
 
             else:
-
                 # 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
@@ -2461,7 +2462,6 @@ def clean_message_html(self, msg):
         # will return "</html>".  To avoid this, we first check
         # that *msg* is a non-empty string.
         if msg:
-
             # 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))
diff --git a/xblocks_contrib/problem/capa/safe_exec/__init__.py b/xblocks_contrib/problem/capa/safe_exec/__init__.py
index ffbe8f23..14b74d70 100644
--- a/xblocks_contrib/problem/capa/safe_exec/__init__.py
+++ b/xblocks_contrib/problem/capa/safe_exec/__init__.py
@@ -1,3 +1,4 @@
 """Capa's specialized use of codejail.safe_exec."""
 
-from .safe_exec import safe_exec, update_hash
+from .safe_exec import safe_exec as safe_exec
+from .safe_exec import update_hash as update_hash
diff --git a/xblocks_contrib/problem/capa/safe_exec/lazymod.py b/xblocks_contrib/problem/capa/safe_exec/lazymod.py
index a956e8c5..49e7a7b2 100644
--- a/xblocks_contrib/problem/capa/safe_exec/lazymod.py
+++ b/xblocks_contrib/problem/capa/safe_exec/lazymod.py
@@ -36,7 +36,7 @@ def __getattr__(self, name):
         try:
             subname = f"{self.__name__}.{name}"
             __import__(subname)
-            submod = getattr(mod, name)  # pylint: disable=unused-variable
+            _submod = getattr(mod, name)
         except ImportError as exc:
             raise AttributeError(f"'module' object has no attribute {name!r}") from exc
         self.__dict__[name] = LazyModule(subname)
diff --git a/xblocks_contrib/problem/capa/safe_exec/safe_exec.py b/xblocks_contrib/problem/capa/safe_exec/safe_exec.py
index a6f67b0c..ca5ef304 100644
--- a/xblocks_contrib/problem/capa/safe_exec/safe_exec.py
+++ b/xblocks_contrib/problem/capa/safe_exec/safe_exec.py
@@ -187,7 +187,6 @@ def safe_exec(
             emsg, exception = get_remote_exec(data)
 
     else:
-
         # Create a copy so the originals are not modified as part of this call.
         # This has to happen before local exec is run, since globals are modified
         # as a side effect.
diff --git a/xblocks_contrib/problem/capa/safe_exec/tests/test_safe_exec.py b/xblocks_contrib/problem/capa/safe_exec/tests/test_safe_exec.py
index 560c6abc..e890a1e5 100644
--- a/xblocks_contrib/problem/capa/safe_exec/tests/test_safe_exec.py
+++ b/xblocks_contrib/problem/capa/safe_exec/tests/test_safe_exec.py
@@ -116,10 +116,8 @@ def test_cant_do_something_forbidden(self):
         """
         # If in-platform codejail isn't configured...
         if not jail_code.is_configured("python"):
-
             # ...AND if remote codejail isn't configured...
             if not is_codejail_rest_service_enabled():
-
                 # ...then skip this test.
                 pytest.skip(reason="Local or remote codejail has to be configured and enabled to run this test.")
 
diff --git a/xblocks_contrib/problem/capa/tests/response_xml_factory.py b/xblocks_contrib/problem/capa/tests/response_xml_factory.py
index fbba69ac..c0f4b923 100644
--- a/xblocks_contrib/problem/capa/tests/response_xml_factory.py
+++ b/xblocks_contrib/problem/capa/tests/response_xml_factory.py
@@ -507,7 +507,6 @@ def create_response_element(self, **kwargs):  # pylint: disable=too-many-locals
             hintgroup_element = etree.SubElement(response_element, "hintgroup")
 
             for hint_prompt, hint_name, hint_text in hint_list:
-
                 # For each hint, create a <formulahint> element
                 formulahint_element = etree.SubElement(hintgroup_element, "formulahint")
 
diff --git a/xblocks_contrib/problem/capa/tests/test_inputtypes.py b/xblocks_contrib/problem/capa/tests/test_inputtypes.py
index 6306e382..272aa33c 100644
--- a/xblocks_contrib/problem/capa/tests/test_inputtypes.py
+++ b/xblocks_contrib/problem/capa/tests/test_inputtypes.py
@@ -739,7 +739,7 @@ def test_matlab_api_key(self):
         the_input = lookup_tag("matlabinput")(system, elt, {})
 
         data = {"submission": "x = 1234;"}
-        response = the_input.handle_ajax("plot", data)  # pylint: disable=unused-variable
+        the_input.handle_ajax("plot", data)
 
         body = system.xqueue.interface.send_to_queue.call_args[1]["body"]
         payload = json.loads(body)
diff --git a/xblocks_contrib/problem/capa/tests/test_responsetypes.py b/xblocks_contrib/problem/capa/tests/test_responsetypes.py
index e93d4340..814d19aa 100644
--- a/xblocks_contrib/problem/capa/tests/test_responsetypes.py
+++ b/xblocks_contrib/problem/capa/tests/test_responsetypes.py
@@ -2267,7 +2267,6 @@ def test_module_imports_inline(self):
             "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
@@ -2304,7 +2303,6 @@ def test_module_imports_function(self):
             "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
diff --git a/xblocks_contrib/problem/capa/tests/test_shuffle.py b/xblocks_contrib/problem/capa/tests/test_shuffle.py
index d7682318..3b52f057 100644
--- a/xblocks_contrib/problem/capa/tests/test_shuffle.py
+++ b/xblocks_contrib/problem/capa/tests/test_shuffle.py
@@ -293,7 +293,7 @@ def test_multiple_shuffle_responses(self):
             + 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()
diff --git a/xblocks_contrib/problem/capa/tests/test_xqueue_interface.py b/xblocks_contrib/problem/capa/tests/test_xqueue_interface.py
index 5efa81ac..d627a2a3 100644
--- a/xblocks_contrib/problem/capa/tests/test_xqueue_interface.py
+++ b/xblocks_contrib/problem/capa/tests/test_xqueue_interface.py
@@ -20,8 +20,7 @@ def test_send_to_queue_with_flag_enabled(mock_send_to_submission):
     header = json.dumps(
         {
             "lms_callback_url": (
-                "http://example.com/courses/course-v1:test_org+test_course+test_run/"
-                "xqueue/block@item_id/type@problem"
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/block@item_id/type@problem"
             ),
             "lms_key": "default",
         }
@@ -52,8 +51,7 @@ def test_send_to_queue_with_flag_disabled(mock_http_post):
     header = json.dumps(
         {
             "lms_callback_url": (
-                "http://example.com/courses/course-v1:test_org+test_course+test_run/"
-                "xqueue/block@item_id/type@problem"
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/block@item_id/type@problem"
             ),
             "lms_key": "default",
         }
diff --git a/xblocks_contrib/problem/capa/tests/test_xqueue_submission.py b/xblocks_contrib/problem/capa/tests/test_xqueue_submission.py
index e021b745..60cf8821 100644
--- a/xblocks_contrib/problem/capa/tests/test_xqueue_submission.py
+++ b/xblocks_contrib/problem/capa/tests/test_xqueue_submission.py
@@ -100,16 +100,14 @@ def test_send_to_submission(mock_create_external_grader_detail, xqueue_service):
 
 @pytest.mark.django_db
 @patch("submissions.api.create_external_grader_detail")
-def test_send_to_submission_with_missing_fields(
-    mock_create_external_grader_detail, xqueue_service
-):  # pylint: disable=redefined-outer-name
+def test_send_to_submission_with_missing_fields(mock_create_external_grader_detail, xqueue_service):  # pylint: disable=redefined-outer-name
     """
     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/"
+                "http://example.com/courses/course-v1:test_org+test_course+test_run/xqueue/5/block@item_id/"
             )
         }
     )
diff --git a/xblocks_contrib/problem/capa/xqueue_interface.py b/xblocks_contrib/problem/capa/xqueue_interface.py
index 11dcd0dc..acd2bda8 100644
--- a/xblocks_contrib/problem/capa/xqueue_interface.py
+++ b/xblocks_contrib/problem/capa/xqueue_interface.py
@@ -116,7 +116,7 @@ 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", "")  # pylint: disable=unused-variable
+        _queue_name = header_info.get("queue_name", "")
 
         # Attempt to send to queue
         error, msg = self._send_to_queue(header, body, files_to_upload)
@@ -161,9 +161,7 @@ def _send_to_queue(self, header, body, files_to_upload):
         queue_key = header_info["lms_key"]
 
         if self.use_submission_service:
-            submission = self.submission.send_to_submission(  # pylint: disable=unused-variable
-                header, body, queue_key, files
-            )
+            self.submission.send_to_submission(header, body, queue_key, files)
             return None, ""
 
         return self._http_post(self.url + "/xqueue/submit/", payload, files=files)
diff --git a/xblocks_contrib/problem/capa_block.py b/xblocks_contrib/problem/capa_block.py
index 8186da02..c2831c9a 100644
--- a/xblocks_contrib/problem/capa_block.py
+++ b/xblocks_contrib/problem/capa_block.py
@@ -77,8 +77,7 @@ def _(text):
 MAX_RANDOMIZATION_BINS = 1000
 
 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."
 )
 
 
@@ -275,8 +274,7 @@ class ProblemBlock(ScorableXBlockMixin, LegacyXmlMixin, XBlock):
     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."
+            "Defines when to show whether a learner's answer to the problem is correct. Configured on the subsection."
         ),
         scope=Scope.settings,
         default=ShowCorrectness.ALWAYS,
@@ -783,7 +781,6 @@ 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:
                 continue
             try:
@@ -2448,7 +2445,7 @@ def definition_to_xml(self, resource_fs):
             line, offset = err.position  # pylint: disable=unpacking-non-sequence
             msg = (
                 f"Unable to create xml for block {self.usage_key}. "
-                f"Context: '{lines[line - 1][offset - 40: offset + 40]}'"
+                f"Context: '{lines[line - 1][offset - 40 : offset + 40]}'"
             )
             raise SerializationError(self.usage_key, msg) from err
 
diff --git a/xblocks_contrib/problem/tests/test_capa_block.py b/xblocks_contrib/problem/tests/test_capa_block.py
index da9a30c2..f6226654 100644
--- a/xblocks_contrib/problem/tests/test_capa_block.py
+++ b/xblocks_contrib/problem/tests/test_capa_block.py
@@ -250,9 +250,9 @@ def test_import(self):
 
         other_block = CapaFactory.create()
         assert block.get_score().raw_earned == 0
-        assert (
-            block.usage_key.block_id != other_block.usage_key.block_id
-        ), "Factory should be creating unique names for each problem"
+        assert block.usage_key.block_id != other_block.usage_key.block_id, (
+            "Factory should be creating unique names for each problem"
+        )
 
     def test_correct(self):
         """
@@ -1402,7 +1402,6 @@ def test_submit_problem_error_with_codejail_exception(self):
         # Try each exception that capa_block should handle
         exception_classes = [StudentInputError, LoncapaProblemError, ResponseError]
         for exception_class in exception_classes:
-
             # Create the block
             block = CapaFactory.create(attempts=1, user_is_staff=False)
 
@@ -1715,7 +1714,6 @@ def test_rescore_problem_with_grading_method_enable(self):
         with patch.object(
             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
@@ -2653,7 +2651,6 @@ def _retry_and_check(num_tries, test_func):
         # Otherwise, we expect the seed to change
         # to another valid seed
         else:
-
             # Since there's a small chance (expected) we might get the
             # same seed again, give it 60 chances
             # to generate a different seed
diff --git a/xblocks_contrib/video/__init__.py b/xblocks_contrib/video/__init__.py
index 680674b2..472e0903 100644
--- a/xblocks_contrib/video/__init__.py
+++ b/xblocks_contrib/video/__init__.py
@@ -2,4 +2,4 @@
 Init for the VideoBlock.
 """
 
-from .video import VideoBlock
+from .video import VideoBlock as VideoBlock
diff --git a/xblocks_contrib/video/ajax_handler_mixin.py b/xblocks_contrib/video/ajax_handler_mixin.py
index 11dfd053..b4eaa565 100644
--- a/xblocks_contrib/video/ajax_handler_mixin.py
+++ b/xblocks_contrib/video/ajax_handler_mixin.py
@@ -1,4 +1,5 @@
-""" Mixin that provides AJAX handling for Video XBlock """
+"""Mixin that provides AJAX handling for Video XBlock"""
+
 from webob import Response
 from webob.multidict import MultiDict
 from xblock.core import XBlock
@@ -8,18 +9,20 @@ class AjaxHandlerMixin:
     """
     Mixin that provides AJAX handling for Video XBlock
     """
+
     @property
     def ajax_url(self):
         """
         Returns the URL for the ajax handler.
         """
-        return self.runtime.handler_url(self, 'ajax_handler', '', '').rstrip('/?')
+        return self.runtime.handler_url(self, "ajax_handler", "", "").rstrip("/?")
 
     @XBlock.handler
     def ajax_handler(self, request, suffix=None):
         """
         XBlock handler that wraps `ajax_handler`
         """
+
         class FileObjForWebobFiles:
             """
             Turn Webob cgi.FieldStorage uploaded files into pure file objects.
@@ -30,6 +33,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
@@ -45,4 +49,4 @@ 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")
diff --git a/xblocks_contrib/video/bumper_utils.py b/xblocks_contrib/video/bumper_utils.py
index 4d1f75be..1570e597 100644
--- a/xblocks_contrib/video/bumper_utils.py
+++ b/xblocks_contrib/video/bumper_utils.py
@@ -2,7 +2,6 @@
 Utils for video bumper
 """
 
-
 import copy
 import json
 import logging
@@ -21,11 +20,11 @@ def get_bumper_settings(video):
     """
     Get bumper settings from video instance.
     """
-    bumper_settings = copy.deepcopy(getattr(video, 'video_bumper', {}))
+    bumper_settings = copy.deepcopy(getattr(video, "video_bumper", {}))
 
     # clean up /static/ prefix from bumper transcripts
-    for lang, transcript_url in bumper_settings.get('transcripts', {}).items():
-        bumper_settings['transcripts'][lang] = transcript_url.replace("/static/", "")
+    for lang, transcript_url in bumper_settings.get("transcripts", {}).items():
+        bumper_settings["transcripts"][lang] = transcript_url.replace("/static/", "")
 
     return bumper_settings
 
@@ -42,21 +41,23 @@ def is_bumper_enabled(video):
     Returns:
          bool.
     """
-    bumper_last_view_date = getattr(video, 'bumper_last_view_date', None)
+    bumper_last_view_date = getattr(video, "bumper_last_view_date", None)
     utc_now = datetime.now(ZoneInfo("UTC"))
-    periodicity = settings.FEATURES.get('SHOW_BUMPER_PERIODICITY', 0)
-    has_viewed = any([
-        video.bumper_do_not_show_again,
-        (bumper_last_view_date and bumper_last_view_date + timedelta(seconds=periodicity) > utc_now)
-    ])
+    periodicity = settings.FEATURES.get("SHOW_BUMPER_PERIODICITY", 0)
+    has_viewed = any(
+        [
+            video.bumper_do_not_show_again,
+            (bumper_last_view_date and bumper_last_view_date + timedelta(seconds=periodicity) > utc_now),
+        ]
+    )
     is_studio = getattr(video.runtime, "is_author_mode", False)
     edxval_api = get_edxval_api()
     return bool(
-        not is_studio and
-        settings.FEATURES.get('ENABLE_VIDEO_BUMPER') and
-        get_bumper_settings(video) and
-        edxval_api and
-        not has_viewed
+        not is_studio
+        and settings.FEATURES.get("ENABLE_VIDEO_BUMPER")
+        and get_bumper_settings(video)
+        and edxval_api
+        and not has_viewed
     )
 
 
@@ -65,10 +66,10 @@ def bumperize(video):
     Populate video with bumper settings, if they are presented.
     """
     video.bumper = {
-        'enabled': False,
-        'edx_video_id': "",
-        'transcripts': {},
-        'metadata': None,
+        "enabled": False,
+        "edx_video_id": "",
+        "transcripts": {},
+        "metadata": None,
     }
 
     if not is_bumper_enabled(video):
@@ -77,22 +78,22 @@ def bumperize(video):
     bumper_settings = get_bumper_settings(video)
 
     try:
-        video.bumper['edx_video_id'] = bumper_settings['video_id']
-        video.bumper['transcripts'] = bumper_settings['transcripts']
+        video.bumper["edx_video_id"] = bumper_settings["video_id"]
+        video.bumper["transcripts"] = bumper_settings["transcripts"]
     except (TypeError, KeyError):
-        log.warning(
-            "Could not retrieve video bumper information from course settings"
-        )
+        log.warning("Could not retrieve video bumper information from course settings")
         return
 
     sources = get_bumper_sources(video)
     if not sources:
         return
 
-    video.bumper.update({
-        'metadata': bumper_metadata(video, sources),
-        'enabled': True,  # Video poster needs this.
-    })
+    video.bumper.update(
+        {
+            "metadata": bumper_metadata(video, sources),
+            "enabled": True,  # Video poster needs this.
+        }
+    )
 
 
 def get_bumper_sources(video):
@@ -104,12 +105,12 @@ def get_bumper_sources(video):
     edxval_api = get_edxval_api()
     try:
         val_profiles = ["desktop_webm", "desktop_mp4"]
-        val_video_urls = edxval_api.get_urls_for_profiles(video.bumper['edx_video_id'], val_profiles)
+        val_video_urls = edxval_api.get_urls_for_profiles(video.bumper["edx_video_id"], val_profiles)
         bumper_sources = [url for url in [val_video_urls[p] for p in val_profiles] if url]
     except edxval_api.ValInternalError:
         # if no bumper sources, nothing will be showed
         log.warning(
-            "Could not retrieve information from VAL for Bumper edx Video ID: %s.", video.bumper['edx_video_id']
+            "Could not retrieve information from VAL for Bumper edx Video ID: %s.", video.bumper["edx_video_id"]
         )
         return []
 
@@ -123,22 +124,24 @@ def bumper_metadata(video, sources):
     transcripts = video.get_transcripts_info(is_bumper=True)
     unused_track_url, bumper_transcript_language, bumper_languages = video.get_transcripts_for_student(transcripts)
 
-    metadata = OrderedDict({
-        'saveStateUrl': video.ajax_url + '/save_user_state',
-        'showCaptions': json.dumps(video.show_captions),
-        'sources': sources,
-        'streams': '',
-        'transcriptLanguage': bumper_transcript_language,
-        'transcriptLanguages': bumper_languages,
-        'transcriptTranslationUrl': set_query_parameter(
-            video.runtime.handler_url(video, 'transcript', 'translation/__lang__').rstrip('/?'), 'is_bumper', 1
-        ),
-        'transcriptAvailableTranslationsUrl': set_query_parameter(
-            video.runtime.handler_url(video, 'transcript', 'available_translations').rstrip('/?'), 'is_bumper', 1
-        ),
-        'publishCompletionUrl': set_query_parameter(
-            video.runtime.handler_url(video, 'publish_completion', '').rstrip('?'), 'is_bumper', 1
-        ),
-    })
+    metadata = OrderedDict(
+        {
+            "saveStateUrl": video.ajax_url + "/save_user_state",
+            "showCaptions": json.dumps(video.show_captions),
+            "sources": sources,
+            "streams": "",
+            "transcriptLanguage": bumper_transcript_language,
+            "transcriptLanguages": bumper_languages,
+            "transcriptTranslationUrl": set_query_parameter(
+                video.runtime.handler_url(video, "transcript", "translation/__lang__").rstrip("/?"), "is_bumper", 1
+            ),
+            "transcriptAvailableTranslationsUrl": set_query_parameter(
+                video.runtime.handler_url(video, "transcript", "available_translations").rstrip("/?"), "is_bumper", 1
+            ),
+            "publishCompletionUrl": set_query_parameter(
+                video.runtime.handler_url(video, "publish_completion", "").rstrip("?"), "is_bumper", 1
+            ),
+        }
+    )
 
     return metadata
diff --git a/xblocks_contrib/video/cache_utils.py b/xblocks_contrib/video/cache_utils.py
index 77a97c74..4a9a7f96 100644
--- a/xblocks_contrib/video/cache_utils.py
+++ b/xblocks_contrib/video/cache_utils.py
@@ -1,4 +1,5 @@
-""" Cache Utils for Video Block """
+"""Cache Utils for Video Block"""
+
 import itertools
 
 import wrapt
@@ -42,6 +43,7 @@ def request_cached(namespace=None, arg_map_function=None, request_cache_getter=N
               cache the value it returns, and return that cached value for subsequent calls with the
               same args/kwargs within a single request.
     """
+
     @wrapt.decorator
     def decorator(wrapped, instance, args, kwargs):
         """
@@ -83,7 +85,7 @@ def _func_call_cache_key(func, arg_map_function, *args, **kwargs):
     converted_kwargs = list(map(arg_map_function, _sorted_kwargs_list(kwargs)))
 
     cache_keys = [func.__module__, func.__name__] + converted_args + converted_kwargs
-    return '.'.join(cache_keys)
+    return ".".join(cache_keys)
 
 
 def _sorted_kwargs_list(kwargs):
diff --git a/xblocks_contrib/video/constants.py b/xblocks_contrib/video/constants.py
index 17bf5750..403261b5 100644
--- a/xblocks_contrib/video/constants.py
+++ b/xblocks_contrib/video/constants.py
@@ -5,13 +5,13 @@
 # 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"
 
 # The personally identifiable user ID.
-ATTR_KEY_USER_ID = 'edx-platform.user_id'
+ATTR_KEY_USER_ID = "edx-platform.user_id"
 # The country code determined from the user's request IP address.
-ATTR_KEY_REQUEST_COUNTRY_CODE = 'edx-platform.request_country_code'
+ATTR_KEY_REQUEST_COUNTRY_CODE = "edx-platform.request_country_code"
diff --git a/xblocks_contrib/video/mixin.py b/xblocks_contrib/video/mixin.py
index db4bc789..e8957d00 100644
--- a/xblocks_contrib/video/mixin.py
+++ b/xblocks_contrib/video/mixin.py
@@ -24,6 +24,7 @@ class LicenseMixin(XBlockMixin):
     is exclusively owned by the creator of the content by default. Other
     countries may have similar laws.
     """
+
     license = String(
         display_name=_("License"),
         help=_("A license defines how the contents of this block can be shared and reused."),
@@ -40,9 +41,9 @@ def parse_license_from_xml(cls, definition, node):
         to this method, rather than reimplementing it in their XML import
         functions.
         """
-        license = node.get('license', default=None)  # pylint: disable=redefined-builtin
+        license = node.get("license", default=None)  # pylint: disable=redefined-builtin
         if license:
-            definition['license'] = license
+            definition["license"] = license
         return definition
 
     def add_license_to_xml(self, node, default=None):
@@ -54,4 +55,4 @@ def add_license_to_xml(self, node, default=None):
         functions.
         """
         if getattr(self, "license", default):
-            node.set('license', self.license)
+            node.set("license", self.license)
diff --git a/xblocks_contrib/video/studio_metadata_mixin.py b/xblocks_contrib/video/studio_metadata_mixin.py
index 38fd9345..1975d89f 100644
--- a/xblocks_contrib/video/studio_metadata_mixin.py
+++ b/xblocks_contrib/video/studio_metadata_mixin.py
@@ -1,4 +1,5 @@
-""" Studio Metadata Mixin"""
+"""Studio Metadata Mixin"""
+
 from django.conf import settings
 from xblock.core import XBlock
 from xblock.fields import Dict, Float, Integer, List, Scope, String
@@ -112,7 +113,7 @@ def editable_metadata_fields(self):
         """
         editable_fields = self._get_editable_metadata_fields()
 
-        settings_service = self.runtime.service(self, 'settings')
+        settings_service = self.runtime.service(self, "settings")
         if settings_service:
             xb_settings = settings_service.get_settings_bucket(self)
             if not xb_settings.get("licensing_enabled", False) and "license" in editable_fields:
@@ -120,48 +121,46 @@ def editable_metadata_fields(self):
 
         # Default Timed Transcript a.k.a `sub` has been deprecated and end users shall
         # not be able to modify it.
-        editable_fields.pop('sub')
+        editable_fields.pop("sub")
 
-        languages = [{'label': label, 'code': lang} for lang, label in settings.ALL_LANGUAGES]
-        languages.sort(key=lambda lang_item: lang_item['label'])
-        editable_fields['transcripts']['custom'] = True
-        editable_fields['transcripts']['languages'] = languages
-        editable_fields['transcripts']['type'] = 'VideoTranslations'
+        languages = [{"label": label, "code": lang} for lang, label in settings.ALL_LANGUAGES]
+        languages.sort(key=lambda lang_item: lang_item["label"])
+        editable_fields["transcripts"]["custom"] = True
+        editable_fields["transcripts"]["languages"] = languages
+        editable_fields["transcripts"]["type"] = "VideoTranslations"
 
         # We need to send ajax requests to show transcript status
         # whenever edx_video_id changes on frontend. Thats why we
         # are changing type to `VideoID` so that a specific
         # Backbonjs view can handle it.
-        editable_fields['edx_video_id']['type'] = 'VideoID'
+        editable_fields["edx_video_id"]["type"] = "VideoID"
 
         # `public_access` is a boolean field and by default backbonejs code render it as a dropdown with 2 options
         # but in our case we also need to show an input field with dropdown, the input field will show the url to
         # be shared with leaners. This is not possible with default rendering logic in backbonjs code, that is why
         # we are setting a new type and then do a custom rendering in backbonejs code to render the desired UI.
-        editable_fields['public_access']['type'] = 'PublicAccess'
-        editable_fields['public_access']['url'] = self.get_public_video_url()
+        editable_fields["public_access"]["type"] = "PublicAccess"
+        editable_fields["public_access"]["url"] = self.get_public_video_url()
 
         # construct transcripts info and also find if `en` subs exist
         transcripts_info = self.get_transcripts_info()
         possible_sub_ids = [self.sub, self.youtube_id_1_0] + get_html5_ids(self.html5_sources)
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if video_config_service:
             for sub_id in possible_sub_ids:
                 try:
                     _, sub_id, _ = video_config_service.get_transcript(
-                        self, lang='en', output_format=TranscriptExtensions.TXT
+                        self, lang="en", output_format=TranscriptExtensions.TXT
                     )
-                    transcripts_info['transcripts'] = dict(transcripts_info['transcripts'], en=sub_id)
+                    transcripts_info["transcripts"] = dict(transcripts_info["transcripts"], en=sub_id)
                     break
                 except TranscriptNotFoundError:
                     continue
 
-        editable_fields['transcripts']['value'] = transcripts_info['transcripts']
-        editable_fields['transcripts']['urlRoot'] = self.runtime.handler_url(
-            self,
-            'studio_transcript',
-            'translation'
-        ).rstrip('/?')
-        editable_fields['handout']['type'] = 'FileUploader'
+        editable_fields["transcripts"]["value"] = transcripts_info["transcripts"]
+        editable_fields["transcripts"]["urlRoot"] = self.runtime.handler_url(
+            self, "studio_transcript", "translation"
+        ).rstrip("/?")
+        editable_fields["handout"]["type"] = "FileUploader"
 
         return editable_fields
diff --git a/xblocks_contrib/video/tests/test_studio_metadata_mixin.py b/xblocks_contrib/video/tests/test_studio_metadata_mixin.py
index b1c9036b..d8d65aaf 100644
--- a/xblocks_contrib/video/tests/test_studio_metadata_mixin.py
+++ b/xblocks_contrib/video/tests/test_studio_metadata_mixin.py
@@ -1,4 +1,5 @@
 """Tests for StudioMetadataMixin.editable_metadata_fields (VideoBlock)."""
+
 from unittest.mock import Mock, patch
 
 from django.test import SimpleTestCase
@@ -32,8 +33,8 @@ class TestEditableMetadataFieldsProperty(SimpleTestCase):
     def _instantiate_block(**field_data):
         """Instantiate a VideoBlock with a DummyRuntime."""
         system = DummyRuntime()
-        course_key = CourseLocator('org', 'course', 'run')
-        usage_key = course_key.make_usage_key('video', 'SampleProblem')
+        course_key = CourseLocator("org", "course", "run")
+        usage_key = course_key.make_usage_key("video", "SampleProblem")
         return system.construct_xblock_from_class(
             VideoBlock,
             scope_ids=ScopeIds(None, None, usage_key, usage_key),
@@ -47,14 +48,14 @@ def setUp(self):
     def _base_fields(self, include_license=True):
         """Return a minimal editable-fields dict that satisfies the property's expectations."""
         fields = {
-            'sub': {'type': 'Generic', 'value': ''},
-            'transcripts': {'type': 'Dict', 'value': {}},
-            'edx_video_id': {'type': 'Generic', 'value': ''},
-            'public_access': {'type': 'Select', 'value': False},
-            'handout': {'type': 'Generic', 'value': ''},
+            "sub": {"type": "Generic", "value": ""},
+            "transcripts": {"type": "Dict", "value": {}},
+            "edx_video_id": {"type": "Generic", "value": ""},
+            "public_access": {"type": "Select", "value": False},
+            "handout": {"type": "Generic", "value": ""},
         }
         if include_license:
-            fields['license'] = {'type': 'License', 'value': ''}
+            fields["license"] = {"type": "License", "value": ""}
         return fields
 
     @staticmethod
@@ -70,14 +71,16 @@ def _get_fields(self, include_license=False, public_url=None, transcripts=None,
         licensing or video_config tests); omit it to have all service calls
         return None (skipping license and English-transcript logic).
         """
-        service_kwargs = {'side_effect': service} if service else {'return_value': None}
+        service_kwargs = {"side_effect": service} if service else {"return_value": None}
         with (
-            patch.object(self.block, '_get_editable_metadata_fields',
-                         return_value=self._base_fields(include_license)),
-            patch.object(self.block, 'get_transcripts_info',
-                         return_value={'sub': self.block.sub, 'transcripts': transcripts or {}}),
-            patch.object(self.block, 'get_public_video_url', return_value=public_url),
-            patch.object(self.block.runtime, 'service', **service_kwargs),
+            patch.object(self.block, "_get_editable_metadata_fields", return_value=self._base_fields(include_license)),
+            patch.object(
+                self.block,
+                "get_transcripts_info",
+                return_value={"sub": self.block.sub, "transcripts": transcripts or {}},
+            ),
+            patch.object(self.block, "get_public_video_url", return_value=public_url),
+            patch.object(self.block.runtime, "service", **service_kwargs),
         ):
             return self.block.editable_metadata_fields
 
@@ -88,32 +91,35 @@ def _get_fields(self, include_license=False, public_url=None, transcripts=None,
     def test_default_field_modifications(self):
         """Verify all field-level changes made by editable_metadata_fields with default args."""
         fields = self._get_fields()
-        self.assertNotIn('sub', fields)
-        self.assertTrue(fields['transcripts']['custom'])
-        self.assertEqual(fields['transcripts']['type'], 'VideoTranslations')
-        self.assertEqual(fields['transcripts']['languages'], [
-            {'label': 'English', 'code': 'en'},
-            {'label': 'Esperanto', 'code': 'eo'},
-            {'label': 'Urdu', 'code': 'ur'},
-        ])
+        self.assertNotIn("sub", fields)
+        self.assertTrue(fields["transcripts"]["custom"])
+        self.assertEqual(fields["transcripts"]["type"], "VideoTranslations")
+        self.assertEqual(
+            fields["transcripts"]["languages"],
+            [
+                {"label": "English", "code": "en"},
+                {"label": "Esperanto", "code": "eo"},
+                {"label": "Urdu", "code": "ur"},
+            ],
+        )
         # DummyRuntime.handler_url returns a fixed path used by the transcript upload widget
-        self.assertEqual(fields['transcripts']['urlRoot'], '/handler/block/handler')
-        self.assertEqual(fields['edx_video_id']['type'], 'VideoID')
-        self.assertEqual(fields['handout']['type'], 'FileUploader')
+        self.assertEqual(fields["transcripts"]["urlRoot"], "/handler/block/handler")
+        self.assertEqual(fields["edx_video_id"]["type"], "VideoID")
+        self.assertEqual(fields["handout"]["type"], "FileUploader")
         # public_access type is always set; url is None when no public video URL is available
-        self.assertEqual(fields['public_access']['type'], 'PublicAccess')
-        self.assertIsNone(fields['public_access']['url'])
+        self.assertEqual(fields["public_access"]["type"], "PublicAccess")
+        self.assertIsNone(fields["public_access"]["url"])
 
     def test_transcripts_value_passthrough(self):
         """Verify transcripts.value is passed through from get_transcripts_info."""
-        fields = self._get_fields(transcripts={'fr': 'french.srt'})
-        self.assertEqual(fields['transcripts']['value'], {'fr': 'french.srt'})
+        fields = self._get_fields(transcripts={"fr": "french.srt"})
+        self.assertEqual(fields["transcripts"]["value"], {"fr": "french.srt"})
 
     def test_public_access_enriched_when_url_present(self):
         """Verify public_access url is populated when a public video URL is available."""
-        fields = self._get_fields(public_url='https://example.com/video')
-        self.assertEqual(fields['public_access']['type'], 'PublicAccess')
-        self.assertEqual(fields['public_access']['url'], 'https://example.com/video')
+        fields = self._get_fields(public_url="https://example.com/video")
+        self.assertEqual(fields["public_access"]["type"], "PublicAccess")
+        self.assertEqual(fields["public_access"]["url"], "https://example.com/video")
 
     # ------------------------------------------------------------------
     # License field handling
@@ -122,27 +128,27 @@ def test_public_access_enriched_when_url_present(self):
     def test_license_removed_when_licensing_disabled(self):
         """'license' is removed when the settings service reports licensing_enabled=False."""
         settings_service = Mock()
-        settings_service.get_settings_bucket.return_value = {'licensing_enabled': False}
+        settings_service.get_settings_bucket.return_value = {"licensing_enabled": False}
         fields = self._get_fields(
             include_license=True,
-            service=self._service_stub('settings', settings_service),
+            service=self._service_stub("settings", settings_service),
         )
-        self.assertNotIn('license', fields)
+        self.assertNotIn("license", fields)
 
     def test_license_kept_when_licensing_enabled(self):
         """'license' is kept when the settings service reports licensing_enabled=True."""
         settings_service = Mock()
-        settings_service.get_settings_bucket.return_value = {'licensing_enabled': True}
+        settings_service.get_settings_bucket.return_value = {"licensing_enabled": True}
         fields = self._get_fields(
             include_license=True,
-            service=self._service_stub('settings', settings_service),
+            service=self._service_stub("settings", settings_service),
         )
-        self.assertIn('license', fields)
+        self.assertIn("license", fields)
 
     def test_license_retained_when_no_settings_service(self):
         """'license' is retained when no settings service is available (service returns None)."""
         fields = self._get_fields(include_license=True)
-        self.assertIn('license', fields)
+        self.assertIn("license", fields)
 
     # ------------------------------------------------------------------
     # English transcript lookup via video_config service
@@ -151,30 +157,30 @@ def test_license_retained_when_no_settings_service(self):
     def test_english_transcript_found_added_to_value(self):
         """When video_config returns an English transcript, it is added to transcripts.value."""
         video_config = Mock()
-        video_config.get_transcript.return_value = ('content', 'en_subs_id', 'txt')
+        video_config.get_transcript.return_value = ("content", "en_subs_id", "txt")
         fields = self._get_fields(
             transcripts={},
-            service=self._service_stub('video_config', video_config),
+            service=self._service_stub("video_config", video_config),
         )
-        self.assertEqual(fields['transcripts']['value'], {'en': 'en_subs_id'})
+        self.assertEqual(fields["transcripts"]["value"], {"en": "en_subs_id"})
 
     def test_english_transcript_merged_with_existing_transcripts(self):
         """English transcript from video_config is merged with, not replacing, existing transcripts."""
         video_config = Mock()
-        video_config.get_transcript.return_value = ('content', 'en_subs_id', 'txt')
+        video_config.get_transcript.return_value = ("content", "en_subs_id", "txt")
         fields = self._get_fields(
-            transcripts={'fr': 'french.srt'},
-            service=self._service_stub('video_config', video_config),
+            transcripts={"fr": "french.srt"},
+            service=self._service_stub("video_config", video_config),
         )
-        self.assertEqual(fields['transcripts']['value'], {'fr': 'french.srt', 'en': 'en_subs_id'})
+        self.assertEqual(fields["transcripts"]["value"], {"fr": "french.srt", "en": "en_subs_id"})
 
     def test_transcript_not_found_leaves_value_unchanged(self):
         """When video_config raises TranscriptNotFoundError, transcripts.value is not modified."""
         video_config = Mock()
         video_config.get_transcript.side_effect = TranscriptNotFoundError
         fields = self._get_fields(
-            transcripts={'fr': 'french.srt'},
-            service=self._service_stub('video_config', video_config),
+            transcripts={"fr": "french.srt"},
+            service=self._service_stub("video_config", video_config),
         )
-        self.assertNotIn('en', fields['transcripts']['value'])
-        self.assertEqual(fields['transcripts']['value'], {'fr': 'french.srt'})
+        self.assertNotIn("en", fields["transcripts"]["value"])
+        self.assertEqual(fields["transcripts"]["value"], {"fr": "french.srt"})
diff --git a/xblocks_contrib/video/tests/test_utils.py b/xblocks_contrib/video/tests/test_utils.py
index 308984c4..f8feb1d3 100644
--- a/xblocks_contrib/video/tests/test_utils.py
+++ b/xblocks_contrib/video/tests/test_utils.py
@@ -1,4 +1,5 @@
 """Test utilities for the video XBlock: DummyRuntime, AsideTestType, and constants."""
+
 from unittest.mock import Mock
 
 from web_fragments.fragment import Fragment
@@ -7,7 +8,7 @@
 from xblock.runtime import DictKeyValueStore, KvsFieldData, Runtime
 from xblock.test.tools import TestRuntime
 
-EXPORT_IMPORT_STATIC_DIR = 'static'
+EXPORT_IMPORT_STATIC_DIR = "static"
 VALIDATION_MESSAGE_WARNING = "warning"
 
 
@@ -17,25 +18,25 @@ class DummyRuntime(TestRuntime, Runtime):
     """
 
     def __init__(self, _render_template=None, **kwargs):
-        services = kwargs.setdefault('services', {})
-        services['field-data'] = KvsFieldData(DictKeyValueStore())
-        video_config_mock = Mock(name='video_config')
+        services = kwargs.setdefault("services", {})
+        services["field-data"] = KvsFieldData(DictKeyValueStore())
+        video_config_mock = Mock(name="video_config")
         video_config_mock.available_translations = lambda block, transcripts_info, verify_assets=True: []
-        services['video_config'] = video_config_mock
+        services["video_config"] = video_config_mock
 
         # Ignore load_error_blocks as it's not supported by modern TestRuntime
-        kwargs.pop('load_error_blocks', None)
+        kwargs.pop("load_error_blocks", None)
 
         super().__init__(**kwargs)
-        self._resources_fs = Mock(name='DummyRuntime.resources_fs', root_path='.')
+        self._resources_fs = Mock(name="DummyRuntime.resources_fs", root_path=".")
 
     def handler_url(self, *args, **kwargs):
         """Return a test handler URL."""
-        return '/handler/block/handler'
+        return "/handler/block/handler"
 
     def local_resource_url(self, *args, **kwargs):
         """Return a test local resource URL."""
-        return '/resource/'
+        return "/resource/"
 
     def publish(self, *args, **kwargs):
         """No-op for tests."""
@@ -47,14 +48,14 @@ def query(self, block):
 
     def resource_url(self, *args, **kwargs):
         """Return a test resource URL."""
-        return '/static/'
+        return "/static/"
 
     def parse_asides(self, node, def_id, usage_id, _id_generator):
         """pull the asides out of the xml payload and instantiate them"""
         aside_children = []
         for child in node.iterchildren():
             # get xblock-family from node
-            xblock_family = child.attrib.pop('xblock-family', None)
+            xblock_family = child.attrib.pop("xblock-family", None)
             if xblock_family:
                 xblock_family = self._family_id_to_superclass(xblock_family)
                 if issubclass(xblock_family, XBlockAside):
@@ -74,12 +75,13 @@ class AsideTestType(XBlockAside):
     """
     Test Aside type
     """
+
     FRAG_CONTENT = "<p>Aside rendered</p>"
 
     content = String(default="default_content", scope=Scope.content)
     data_field = String(default="default_data", scope=Scope.settings)
 
-    @XBlockAside.aside_for('student_view')
+    @XBlockAside.aside_for("student_view")
     def student_view_aside(self, block, context):  # pylint: disable=unused-argument
         """Add to the student view"""
         return Fragment(self.FRAG_CONTENT)
diff --git a/xblocks_contrib/video/tests/test_video.py b/xblocks_contrib/video/tests/test_video.py
index aec9f0e9..118fbbbb 100644
--- a/xblocks_contrib/video/tests/test_video.py
+++ b/xblocks_contrib/video/tests/test_video.py
@@ -12,7 +12,6 @@
 the course, section, subsection, unit, etc.
 """
 
-
 import datetime
 import shutil
 import unittest
@@ -36,7 +35,7 @@
 from xblocks_contrib.video.tests.test_utils import VALIDATION_MESSAGE_WARNING, AsideTestType, DummyRuntime
 from xblocks_contrib.video.video import EXPORT_IMPORT_STATIC_DIR, VideoBlock, create_youtube_string
 
-SRT_FILEDATA = '''
+SRT_FILEDATA = """
 0
 00:00:00,270 --> 00:00:02,720
 sprechen sie deutsch?
@@ -44,9 +43,9 @@
 1
 00:00:02,720 --> 00:00:05,430
 Ja, ich spreche Deutsch
-'''
+"""
 
-CRO_SRT_FILEDATA = '''
+CRO_SRT_FILEDATA = """
 0
 00:00:00,270 --> 00:00:02,720
 Dobar dan!
@@ -54,38 +53,30 @@
 1
 00:00:02,720 --> 00:00:05,430
 Kako ste danas?
-'''
+"""
 
-YOUTUBE_SUBTITLES = (
-    "Sample trascript line 1. "
-    "Sample trascript line 2. "
-    "Sample trascript line 3."
-)
+YOUTUBE_SUBTITLES = "Sample trascript line 1. Sample trascript line 2. Sample trascript line 3."
 
-MOCKED_YOUTUBE_TRANSCRIPT_API_RESPONSE = '''
+MOCKED_YOUTUBE_TRANSCRIPT_API_RESPONSE = """
     <transcript>
         <text start="27.88" dur="3.68">Sample trascript line 1.</text>
         <text start="31.76" dur="9.54">Sample trascript line 2.</text>
         <text start="44.04" dur="3.1">Sample trascript line 3.</text>
     </transcript>
-'''
+"""
 
-ALL_LANGUAGES = (
-    ["en", "English"],
-    ["eo", "Esperanto"],
-    ["ur", "Urdu"]
-)
+ALL_LANGUAGES = (["en", "English"], ["eo", "Esperanto"], ["ur", "Urdu"])
 
 
 def instantiate_block(**field_data):
     """
     Instantiate block with most properties.
     """
-    if field_data.get('data', None):
-        field_data = VideoBlock.parse_video_xml(field_data['data'])
+    if field_data.get("data", None):
+        field_data = VideoBlock.parse_video_xml(field_data["data"])
     system = DummyRuntime()
-    course_key = CourseLocator('org', 'course', 'run')
-    usage_key = course_key.make_usage_key('video', 'SampleProblem')
+    course_key = CourseLocator("org", "course", "run")
+    usage_key = course_key.make_usage_key("video", "SampleProblem")
     return system.construct_xblock_from_class(
         VideoBlock,
         scope_ids=ScopeIds(None, None, usage_key, usage_key),
@@ -96,60 +87,61 @@ def instantiate_block(**field_data):
 # Because of the way xblocks_contrib.video.video imports edxval.api, we
 # must mock the entire module, which requires making mock exception classes.
 
+
 class _MockValVideoNotFoundError(Exception):
     """Mock ValVideoNotFoundError exception"""
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
 
 class _MockValCannotCreateError(Exception):
     """Mock ValCannotCreateError exception"""
+
     pass  # lint-amnesty, pylint: disable=unnecessary-pass
 
 
 class VideoBlockTest(unittest.TestCase):
     """Logic tests for Video XBlock."""
 
-    raw_field_data = {
-        'data': '<video />'
-    }
+    raw_field_data = {"data": "<video />"}
 
     def test_parse_youtube(self):
         """Test parsing old-style Youtube ID strings into a dict."""
-        youtube_str = '0.75:jNCf2gIqpeE,1.00:ZwkTiUPN0mg,1.25:rsq9auxASqI,1.50:kMyNdzVHHgg'
+        youtube_str = "0.75:jNCf2gIqpeE,1.00:ZwkTiUPN0mg,1.25:rsq9auxASqI,1.50:kMyNdzVHHgg"
         output = VideoBlock._parse_youtube(youtube_str)
-        assert output == {'0.75': 'jNCf2gIqpeE', '1.00': 'ZwkTiUPN0mg', '1.25': 'rsq9auxASqI', '1.50': 'kMyNdzVHHgg'}
+        assert output == {"0.75": "jNCf2gIqpeE", "1.00": "ZwkTiUPN0mg", "1.25": "rsq9auxASqI", "1.50": "kMyNdzVHHgg"}
 
     def test_parse_youtube_one_video(self):
         """
         Ensure that all keys are present and missing speeds map to the
         empty string.
         """
-        youtube_str = '0.75:jNCf2gIqpeE'
+        youtube_str = "0.75:jNCf2gIqpeE"
         output = VideoBlock._parse_youtube(youtube_str)
-        assert output == {'0.75': 'jNCf2gIqpeE', '1.00': '', '1.25': '', '1.50': ''}
+        assert output == {"0.75": "jNCf2gIqpeE", "1.00": "", "1.25": "", "1.50": ""}
 
     def test_parse_youtube_invalid(self):
         """Ensure that ids that are invalid return an empty dict"""
         # invalid id
-        youtube_str = 'thisisaninvalidid'
+        youtube_str = "thisisaninvalidid"
         output = VideoBlock._parse_youtube(youtube_str)
-        assert output == {'0.75': '', '1.00': '', '1.25': '', '1.50': ''}
+        assert output == {"0.75": "", "1.00": "", "1.25": "", "1.50": ""}
         # another invalid id
-        youtube_str = ',::,:,,'
+        youtube_str = ",::,:,,"
         output = VideoBlock._parse_youtube(youtube_str)
-        assert output == {'0.75': '', '1.00': '', '1.25': '', '1.50': ''}
+        assert output == {"0.75": "", "1.00": "", "1.25": "", "1.50": ""}
 
         # and another one, partially invalid
-        youtube_str = '0.75_BAD!!!,1.0:AXdE34_U,1.25:KLHF9K_Y,1.5:VO3SxfeD,'
+        youtube_str = "0.75_BAD!!!,1.0:AXdE34_U,1.25:KLHF9K_Y,1.5:VO3SxfeD,"
         output = VideoBlock._parse_youtube(youtube_str)
-        assert output == {'0.75': '', '1.00': 'AXdE34_U', '1.25': 'KLHF9K_Y', '1.50': 'VO3SxfeD'}
+        assert output == {"0.75": "", "1.00": "AXdE34_U", "1.25": "KLHF9K_Y", "1.50": "VO3SxfeD"}
 
     def test_parse_youtube_key_format(self):
         """
         Make sure that inconsistent speed keys are parsed correctly.
         """
-        youtube_str = '1.00:p2Q6BrNhdh8'
-        youtube_str_hack = '1.0:p2Q6BrNhdh8'
+        youtube_str = "1.00:p2Q6BrNhdh8"
+        youtube_str_hack = "1.0:p2Q6BrNhdh8"
         assert VideoBlock._parse_youtube(youtube_str) == VideoBlock._parse_youtube(youtube_str_hack)
 
     def test_parse_youtube_empty(self):
@@ -157,7 +149,7 @@ def test_parse_youtube_empty(self):
         Some courses have empty youtube attributes, so we should handle
         that well.
         """
-        assert VideoBlock._parse_youtube('') == {'0.75': '', '1.00': '', '1.25': '', '1.50': ''}
+        assert VideoBlock._parse_youtube("") == {"0.75": "", "1.00": "", "1.25": "", "1.50": ""}
 
 
 class VideoBlockTestBase(unittest.TestCase):
@@ -174,11 +166,12 @@ def assertXmlEqual(self, expected, xml):
         Assert that the given XML fragments have the same attributes, text, and
         (recursively) children
         """
+
         def get_child_tags(elem):
             """Extract the list of tag names for children of elem"""
             return [child.tag for child in elem]
 
-        for attr in ['tag', 'attrib', 'text', 'tail']:
+        for attr in ["tag", "attrib", "text", "tail"]:
             expected_attr = getattr(expected, attr)
             actual_attr = getattr(xml, attr)
             assert expected_attr == actual_attr
@@ -197,10 +190,10 @@ def test_create_youtube_string(self):
         """
         Test that Youtube ID strings are correctly created when writing back out to XML.
         """
-        self.block.youtube_id_0_75 = 'izygArpw-Qo'
-        self.block.youtube_id_1_0 = 'p2Q6BrNhdh8'
-        self.block.youtube_id_1_25 = '1EeWXzPdhSA'
-        self.block.youtube_id_1_5 = 'rABDYkeK0x8'
+        self.block.youtube_id_0_75 = "izygArpw-Qo"
+        self.block.youtube_id_1_0 = "p2Q6BrNhdh8"
+        self.block.youtube_id_1_25 = "1EeWXzPdhSA"
+        self.block.youtube_id_1_5 = "rABDYkeK0x8"
         expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA,1.50:rABDYkeK0x8"
         assert create_youtube_string(self.block) == expected
 
@@ -208,9 +201,9 @@ def test_create_youtube_string_missing(self):
         """
         Test that Youtube IDs which aren't explicitly set aren't included in the output string.
         """
-        self.block.youtube_id_0_75 = 'izygArpw-Qo'
-        self.block.youtube_id_1_0 = 'p2Q6BrNhdh8'
-        self.block.youtube_id_1_25 = '1EeWXzPdhSA'
+        self.block.youtube_id_0_75 = "izygArpw-Qo"
+        self.block.youtube_id_1_0 = "p2Q6BrNhdh8"
+        self.block.youtube_id_1_25 = "1EeWXzPdhSA"
         expected = "0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
         assert create_youtube_string(self.block) == expected
 
@@ -242,7 +235,7 @@ def assert_attributes_equal(self, video, attrs):
             assert getattr(video, key) == value
 
     def test_constructor(self):
-        sample_xml = '''
+        sample_xml = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -257,28 +250,31 @@ def test_constructor(self):
               <transcript language="ua" src="ukrainian_translation.srt" />
               <transcript language="ge" src="german_translation.srt" />
             </video>
-        '''
+        """
         block = instantiate_block(data=sample_xml)
-        self.assert_attributes_equal(block, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'download_video': True,
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            'handout': 'http://www.example.com/handout',
-            'download_track': True,
-            'html5_sources': ['http://www.example.com/source.mp4', 'http://www.example.com/source.ogg'],
-            'data': '',
-            'transcripts': {'ua': 'ukrainian_translation.srt', 'ge': 'german_translation.srt'}
-        })
+        self.assert_attributes_equal(
+            block,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "download_video": True,
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                "handout": "http://www.example.com/handout",
+                "download_track": True,
+                "html5_sources": ["http://www.example.com/source.mp4", "http://www.example.com/source.ogg"],
+                "data": "",
+                "transcripts": {"ua": "ukrainian_translation.srt", "ge": "german_translation.srt"},
+            },
+        )
 
     def test_parse_xml(self):
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -292,44 +288,47 @@ def test_parse_xml(self):
               <transcript language="uk" src="ukrainian_translation.srt" />
               <transcript language="de" src="german_translation.srt" />
             </video>
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            'handout': 'http://www.example.com/handout',
-            'download_track': False,
-            'download_video': False,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': '',
-            'transcripts': {'uk': 'ukrainian_translation.srt', 'de': 'german_translation.srt'},
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                "handout": "http://www.example.com/handout",
+                "download_track": False,
+                "download_video": False,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+                "transcripts": {"uk": "ukrainian_translation.srt", "de": "german_translation.srt"},
+            },
+        )
 
     @XBlockAside.register_temp_plugin(AsideTestType, "test_aside")
-    @patch('xblocks_contrib.video.video.VideoBlock.load_file')
-    @patch('xblocks_contrib.video.video.is_pointer_tag')
+    @patch("xblocks_contrib.video.video.VideoBlock.load_file")
+    @patch("xblocks_contrib.video.video.is_pointer_tag")
     @ddt.data(True, False)
     def test_parse_xml_with_asides(self, video_xml_has_aside, mock_is_pointer_tag, mock_load_file):
         """Test that `parse_xml` parses asides from the video xml"""
         runtime = DummyRuntime(load_error_blocks=True)
         if video_xml_has_aside:
-            xml_data = '''
+            xml_data = """
                 <video url_name="a16643fa63234fef8f6ebbc1902e2253">
                 <test_aside xblock-family="xblock_asides.v1" data_field="aside parsed"/>
                 </video>
-            '''
+            """
         else:
-            xml_data = '''
+            xml_data = """
                 <video url_name="a16643fa63234fef8f6ebbc1902e2253">
                 </video>
-            '''
+            """
         mock_is_pointer_tag.return_value = True
         xml_object = etree.fromstring(xml_data)
         mock_load_file.return_value = xml_object
@@ -343,9 +342,11 @@ def test_parse_xml_with_asides(self, video_xml_has_aside, mock_is_pointer_tag, m
             assert aside.data_field == "default_data"
 
     @ddt.data(
-        ('course-v1:test_org+test_course+test_run',
-         '/asset-v1:test_org+test_course+test_run+type@asset+block@test.png'),
-        ('test_org/test_course/test_run', '/c4x/test_org/test_course/asset/test.png')
+        (
+            "course-v1:test_org+test_course+test_run",
+            "/asset-v1:test_org+test_course+test_run+type@asset+block@test.png",
+        ),
+        ("test_org/test_course/test_run", "/c4x/test_org/test_course/asset/test.png"),
     )
     @ddt.unpack
     def test_parse_xml_when_handout_is_course_asset(self, course_id_string, expected_handout_link):
@@ -354,7 +355,7 @@ def test_parse_xml_when_handout_is_course_asset(self, course_id_string, expected
         """
         module_system = DummyRuntime(load_error_blocks=True)
         course_id = CourseKey.from_string(course_id_string)
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -368,27 +369,30 @@ def test_parse_xml_when_handout_is_course_asset(self, course_id_string, expected
               <transcript language="uk" src="ukrainian_translation.srt" />
               <transcript language="de" src="german_translation.srt" />
             </video>
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         module_system.id_generator.target_course_id = course_id
 
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            'handout': expected_handout_link,
-            'download_track': False,
-            'download_video': False,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': '',
-            'transcripts': {'uk': 'ukrainian_translation.srt', 'de': 'german_translation.srt'},
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                "handout": expected_handout_link,
+                "download_track": False,
+                "download_video": False,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+                "transcripts": {"uk": "ukrainian_translation.srt", "de": "german_translation.srt"},
+            },
+        )
 
     def test_parse_xml_missing_attributes(self):
         """
@@ -396,30 +400,33 @@ def test_parse_xml_missing_attributes(self):
         explicitly set in XML.
         """
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
                    show_captions="true">
               <source src="http://www.example.com/source.mp4"/>
             </video>
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': '',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': '',
-            'show_captions': True,
-            'start_time': datetime.timedelta(seconds=0.0),
-            'end_time': datetime.timedelta(seconds=0.0),
-            'track': '',
-            'handout': None,
-            'download_track': False,
-            'download_video': False,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': ''
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "",
+                "show_captions": True,
+                "start_time": datetime.timedelta(seconds=0.0),
+                "end_time": datetime.timedelta(seconds=0.0),
+                "track": "",
+                "handout": None,
+                "download_track": False,
+                "download_video": False,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+            },
+        )
 
     def test_parse_xml_missing_download_track(self):
         """
@@ -427,56 +434,62 @@ def test_parse_xml_missing_download_track(self):
         explicitly set in XML.
         """
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,1.25:1EeWXzPdhSA"
                    show_captions="true">
               <source src="http://www.example.com/source.mp4"/>
               <track src="http://www.example.com/track"/>
             </video>
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': '',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': '',
-            'show_captions': True,
-            'start_time': datetime.timedelta(seconds=0.0),
-            'end_time': datetime.timedelta(seconds=0.0),
-            'track': 'http://www.example.com/track',
-            'download_track': True,
-            'download_video': False,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': '',
-            'transcripts': {},
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "",
+                "show_captions": True,
+                "start_time": datetime.timedelta(seconds=0.0),
+                "end_time": datetime.timedelta(seconds=0.0),
+                "track": "http://www.example.com/track",
+                "download_track": True,
+                "download_video": False,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+                "transcripts": {},
+            },
+        )
 
     def test_parse_xml_no_attributes(self):
         """
         Make sure settings are correct if none are explicitly set in XML.
         """
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '<video></video>'
+        xml_data = "<video></video>"
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': '',
-            'youtube_id_1_0': '3_yD_cEKoCk',
-            'youtube_id_1_25': '',
-            'youtube_id_1_5': '',
-            'show_captions': True,
-            'start_time': datetime.timedelta(seconds=0.0),
-            'end_time': datetime.timedelta(seconds=0.0),
-            'track': '',
-            'handout': None,
-            'download_track': False,
-            'download_video': False,
-            'html5_sources': [],
-            'data': '',
-            'transcripts': {},
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "",
+                "youtube_id_1_0": "3_yD_cEKoCk",
+                "youtube_id_1_25": "",
+                "youtube_id_1_5": "",
+                "show_captions": True,
+                "start_time": datetime.timedelta(seconds=0.0),
+                "end_time": datetime.timedelta(seconds=0.0),
+                "track": "",
+                "handout": None,
+                "download_track": False,
+                "download_video": False,
+                "html5_sources": [],
+                "data": "",
+                "transcripts": {},
+            },
+        )
 
     def test_parse_xml_double_quotes(self):
         """
@@ -484,7 +497,7 @@ def test_parse_xml_double_quotes(self):
         a few weeks).
         """
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '''
+        xml_data = """
             <video display_name="&quot;display_name&quot;"
                 html5_sources="[&quot;source_1&quot;, &quot;source_2&quot;]"
                 show_captions="false"
@@ -498,49 +511,55 @@ def test_parse_xml_double_quotes(self):
                 youtube_id_1_5="&quot;OEoXaMPEzf15&quot;"
                 youtube_id_1_0="&quot;OEoXaMPEzf10&quot;"
                 />
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': 'OEoXaMPEzf65',
-            'youtube_id_1_0': 'OEoXaMPEzf10',
-            'youtube_id_1_25': 'OEoXaMPEzf125',
-            'youtube_id_1_5': 'OEoXaMPEzf15',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=0.0),
-            'end_time': datetime.timedelta(seconds=0.0),
-            'track': 'http://www.example.com/track',
-            'handout': 'http://www.example.com/handout',
-            'download_track': True,
-            'download_video': True,
-            'html5_sources': ["source_1", "source_2"],
-            'data': ''
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "OEoXaMPEzf65",
+                "youtube_id_1_0": "OEoXaMPEzf10",
+                "youtube_id_1_25": "OEoXaMPEzf125",
+                "youtube_id_1_5": "OEoXaMPEzf15",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=0.0),
+                "end_time": datetime.timedelta(seconds=0.0),
+                "track": "http://www.example.com/track",
+                "handout": "http://www.example.com/handout",
+                "download_track": True,
+                "download_video": True,
+                "html5_sources": ["source_1", "source_2"],
+                "data": "",
+            },
+        )
 
     def test_parse_xml_double_quote_concatenated_youtube(self):
         module_system = DummyRuntime(load_error_blocks=True)
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:&quot;p2Q6BrNhdh8&quot;,1.25:&quot;1EeWXzPdhSA&quot;">
             </video>
-        '''
+        """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': '',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': '',
-            'show_captions': True,
-            'start_time': datetime.timedelta(seconds=0.0),
-            'end_time': datetime.timedelta(seconds=0.0),
-            'track': '',
-            'handout': None,
-            'download_track': False,
-            'download_video': False,
-            'html5_sources': [],
-            'data': ''
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "",
+                "show_captions": True,
+                "start_time": datetime.timedelta(seconds=0.0),
+                "end_time": datetime.timedelta(seconds=0.0),
+                "track": "",
+                "handout": None,
+                "download_track": False,
+                "download_video": False,
+                "html5_sources": [],
+                "data": "",
+            },
+        )
 
     def test_old_video_format(self):
         """
@@ -560,19 +579,22 @@ def test_old_video_format(self):
         """
         xml_object = etree.fromstring(xml_data)
         output = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(output, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            # 'download_track': True,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': '',
-        })
+        self.assert_attributes_equal(
+            output,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                # 'download_track': True,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+            },
+        )
 
     def test_old_video_data(self):
         """
@@ -591,19 +613,22 @@ def test_old_video_data(self):
         """
         xml_object = etree.fromstring(xml_data)
         video = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(video, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            # 'download_track': True,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': ''
-        })
+        self.assert_attributes_equal(
+            video,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                # 'download_track': True,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+            },
+        )
 
     def test_import_with_float_times(self):
         """
@@ -622,21 +647,24 @@ def test_import_with_float_times(self):
         """
         xml_object = etree.fromstring(xml_data)
         video = VideoBlock.parse_xml(xml_object, module_system, None)
-        self.assert_attributes_equal(video, {
-            'youtube_id_0_75': 'izygArpw-Qo',
-            'youtube_id_1_0': 'p2Q6BrNhdh8',
-            'youtube_id_1_25': '1EeWXzPdhSA',
-            'youtube_id_1_5': 'rABDYkeK0x8',
-            'show_captions': False,
-            'start_time': datetime.timedelta(seconds=1),
-            'end_time': datetime.timedelta(seconds=60),
-            'track': 'http://www.example.com/track',
-            # 'download_track': True,
-            'html5_sources': ['http://www.example.com/source.mp4'],
-            'data': ''
-        })
-
-    @patch('xblocks_contrib.video.video.get_edxval_api')
+        self.assert_attributes_equal(
+            video,
+            {
+                "youtube_id_0_75": "izygArpw-Qo",
+                "youtube_id_1_0": "p2Q6BrNhdh8",
+                "youtube_id_1_25": "1EeWXzPdhSA",
+                "youtube_id_1_5": "rABDYkeK0x8",
+                "show_captions": False,
+                "start_time": datetime.timedelta(seconds=1),
+                "end_time": datetime.timedelta(seconds=60),
+                "track": "http://www.example.com/track",
+                # 'download_track': True,
+                "html5_sources": ["http://www.example.com/source.mp4"],
+                "data": "",
+            },
+        )
+
+    @patch("xblocks_contrib.video.video.get_edxval_api")
     def test_import_val_data(self, mock_get_edxval_api):
         """
         Test that `parse_xml` works method works as expected.
@@ -645,16 +673,16 @@ def test_import_val_data(self, mock_get_edxval_api):
 
         def mock_val_import(xml, edx_video_id, resource_fs, static_dir, external_transcripts, *, course_id=None):
             """Mock edxval.api.import_parse_xml"""
-            assert xml.tag == 'video_asset'
-            assert dict(list(xml.items())) == {'mock_attr': ''}
-            assert edx_video_id == 'test_edx_video_id'
+            assert xml.tag == "video_asset"
+            assert dict(list(xml.items())) == {"mock_attr": ""}
+            assert edx_video_id == "test_edx_video_id"
             assert static_dir == EXPORT_IMPORT_STATIC_DIR
             assert resource_fs is not None
-            assert external_transcripts == {'en': ['subs_3_yD_cEKoCk.srt.sjson']}
-            assert course_id == 'test_course_id'
+            assert external_transcripts == {"en": ["subs_3_yD_cEKoCk.srt.sjson"]}
+            assert course_id == "test_course_id"
             return edx_video_id
 
-        edx_video_id = 'test_edx_video_id'
+        edx_video_id = "test_edx_video_id"
         mock_val_api.import_from_xml = Mock(wraps=mock_val_import)
         module_system = DummyRuntime(load_error_blocks=True)
 
@@ -666,24 +694,22 @@ def mock_val_import(xml, edx_video_id, resource_fs, static_dir, external_transcr
             <video edx_video_id="{edx_video_id}">
                 <video_asset mock_attr=""/>
             </video>
-        """.format(
-            edx_video_id=edx_video_id
-        )
+        """.format(edx_video_id=edx_video_id)
         xml_object = etree.fromstring(xml_data)
-        module_system.id_generator.target_course_id = 'test_course_id'
+        module_system.id_generator.target_course_id = "test_course_id"
         video = VideoBlock.parse_xml(xml_object, module_system, None)
 
-        self.assert_attributes_equal(video, {'edx_video_id': edx_video_id})
+        self.assert_attributes_equal(video, {"edx_video_id": edx_video_id})
         mock_val_api.import_from_xml.assert_called_once_with(
             ANY,
             edx_video_id,
             module_system.resources_fs,
             EXPORT_IMPORT_STATIC_DIR,
-            {'en': ['subs_3_yD_cEKoCk.srt.sjson']},
-            course_id='test_course_id'
+            {"en": ["subs_3_yD_cEKoCk.srt.sjson"]},
+            course_id="test_course_id",
         )
 
-    @patch('xblocks_contrib.video.video.get_edxval_api')
+    @patch("xblocks_contrib.video.video.get_edxval_api")
     def test_import_val_data_invalid(self, mock_get_edxval_api):
         mock_val_api = mock_get_edxval_api.return_value
         mock_val_api.ValCannotCreateError = _MockValCannotCreateError
@@ -712,34 +738,32 @@ def setUp(self):
         self.file_system = OSFS(self.temp_dir)
         self.addCleanup(shutil.rmtree, self.temp_dir)
 
-    @patch('xblocks_contrib.video.video.get_edxval_api')
+    @patch("xblocks_contrib.video.video.get_edxval_api")
     def test_export_to_xml(self, mock_get_edxval_api):
         """
         Test that we write the correct XML on export.
         """
         mock_val_api = mock_get_edxval_api.return_value
-        edx_video_id = 'test_edx_video_id'
-        mock_val_api.export_to_xml = Mock(
-            return_value={"xml": etree.Element('video_asset'), "transcripts": {}}
-        )
-        self.block.youtube_id_0_75 = 'izygArpw-Qo'
-        self.block.youtube_id_1_0 = 'p2Q6BrNhdh8'
-        self.block.youtube_id_1_25 = '1EeWXzPdhSA'
-        self.block.youtube_id_1_5 = 'rABDYkeK0x8'
+        edx_video_id = "test_edx_video_id"
+        mock_val_api.export_to_xml = Mock(return_value={"xml": etree.Element("video_asset"), "transcripts": {}})
+        self.block.youtube_id_0_75 = "izygArpw-Qo"
+        self.block.youtube_id_1_0 = "p2Q6BrNhdh8"
+        self.block.youtube_id_1_25 = "1EeWXzPdhSA"
+        self.block.youtube_id_1_5 = "rABDYkeK0x8"
         self.block.show_captions = False
         self.block.start_time = datetime.timedelta(seconds=1.0)
         self.block.end_time = datetime.timedelta(seconds=60)
-        self.block.track = 'http://www.example.com/track'
-        self.block.handout = 'http://www.example.com/handout'
+        self.block.track = "http://www.example.com/track"
+        self.block.handout = "http://www.example.com/handout"
         self.block.download_track = True
-        self.block.html5_sources = ['http://www.example.com/source.mp4', 'http://www.example.com/source1.ogg']
+        self.block.html5_sources = ["http://www.example.com/source.mp4", "http://www.example.com/source1.ogg"]
         self.block.download_video = True
-        self.block.transcripts = {'ua': 'ukrainian_translation.srt', 'ge': 'german_translation.srt'}
+        self.block.transcripts = {"ua": "ukrainian_translation.srt", "ge": "german_translation.srt"}
         self.block.edx_video_id = edx_video_id
 
         xml = self.block.definition_to_xml(self.file_system)
         parser = etree.XMLParser(remove_blank_text=True)
-        xml_string = '''\
+        xml_string = """\
          <video
             url_name="SampleProblem"
             start_time="0:00:01"
@@ -758,7 +782,7 @@ def test_export_to_xml(self, mock_get_edxval_api):
            <transcript language="ge" src="german_translation.srt" />
            <transcript language="ua" src="ukrainian_translation.srt" />
          </video>
-        '''
+        """
         expected = etree.XML(xml_string, parser=parser)
         self.assertXmlEqual(expected, xml)
         mock_val_api.export_to_xml.assert_called_once_with(
@@ -772,23 +796,23 @@ def test_export_to_xml_without_video_id(self):
         """
         Test that we write the correct XML on export of a video without edx_video_id.
         """
-        self.block.youtube_id_0_75 = 'izygArpw-Qo'
-        self.block.youtube_id_1_0 = 'p2Q6BrNhdh8'
-        self.block.youtube_id_1_25 = '1EeWXzPdhSA'
-        self.block.youtube_id_1_5 = 'rABDYkeK0x8'
+        self.block.youtube_id_0_75 = "izygArpw-Qo"
+        self.block.youtube_id_1_0 = "p2Q6BrNhdh8"
+        self.block.youtube_id_1_25 = "1EeWXzPdhSA"
+        self.block.youtube_id_1_5 = "rABDYkeK0x8"
         self.block.show_captions = False
         self.block.start_time = datetime.timedelta(seconds=1.0)
         self.block.end_time = datetime.timedelta(seconds=60)
-        self.block.track = 'http://www.example.com/track'
-        self.block.handout = 'http://www.example.com/handout'
+        self.block.track = "http://www.example.com/track"
+        self.block.handout = "http://www.example.com/handout"
         self.block.download_track = True
-        self.block.html5_sources = ['http://www.example.com/source.mp4', 'http://www.example.com/source1.ogg']
+        self.block.html5_sources = ["http://www.example.com/source.mp4", "http://www.example.com/source1.ogg"]
         self.block.download_video = True
-        self.block.transcripts = {'ua': 'ukrainian_translation.srt', 'ge': 'german_translation.srt'}
+        self.block.transcripts = {"ua": "ukrainian_translation.srt", "ge": "german_translation.srt"}
 
         xml = self.block.definition_to_xml(self.file_system)
         parser = etree.XMLParser(remove_blank_text=True)
-        xml_string = '''\
+        xml_string = """\
          <video
             url_name="SampleProblem"
             start_time="0:00:01"
@@ -806,17 +830,17 @@ def test_export_to_xml_without_video_id(self):
            <transcript language="ge" src="german_translation.srt" />
            <transcript language="ua" src="ukrainian_translation.srt" />
          </video>
-        '''
+        """
         expected = etree.XML(xml_string, parser=parser)
         self.assertXmlEqual(expected, xml)
 
-    @patch('xblocks_contrib.video.video.get_edxval_api')
+    @patch("xblocks_contrib.video.video.get_edxval_api")
     def test_export_to_xml_val_error(self, mock_get_edxval_api):
         mock_val_api = mock_get_edxval_api.return_value
         # Export should succeed without VAL data if video does not exist
         mock_val_api.ValVideoNotFoundError = _MockValVideoNotFoundError
         mock_val_api.export_to_xml = Mock(side_effect=mock_val_api.ValVideoNotFoundError)
-        self.block.edx_video_id = 'test_edx_video_id'
+        self.block.edx_video_id = "test_edx_video_id"
 
         xml = self.block.definition_to_xml(self.file_system)
         parser = etree.XMLParser(remove_blank_text=True)
@@ -824,26 +848,26 @@ def test_export_to_xml_val_error(self, mock_get_edxval_api):
         expected = etree.XML(xml_string, parser=parser)
         self.assertXmlEqual(expected, xml)
 
-    @patch('xblocks_contrib.video.video.get_edxval_api', return_value=None)
+    @patch("xblocks_contrib.video.video.get_edxval_api", return_value=None)
     def test_export_to_xml_empty_end_time(self, _mock_get_edxval_api):
         """
         Test that we write the correct XML on export.
         """
-        self.block.youtube_id_0_75 = 'izygArpw-Qo'
-        self.block.youtube_id_1_0 = 'p2Q6BrNhdh8'
-        self.block.youtube_id_1_25 = '1EeWXzPdhSA'
-        self.block.youtube_id_1_5 = 'rABDYkeK0x8'
+        self.block.youtube_id_0_75 = "izygArpw-Qo"
+        self.block.youtube_id_1_0 = "p2Q6BrNhdh8"
+        self.block.youtube_id_1_25 = "1EeWXzPdhSA"
+        self.block.youtube_id_1_5 = "rABDYkeK0x8"
         self.block.show_captions = False
         self.block.start_time = datetime.timedelta(seconds=5.0)
         self.block.end_time = datetime.timedelta(seconds=0.0)
-        self.block.track = 'http://www.example.com/track'
+        self.block.track = "http://www.example.com/track"
         self.block.download_track = True
-        self.block.html5_sources = ['http://www.example.com/source.mp4', 'http://www.example.com/source.ogg']
+        self.block.html5_sources = ["http://www.example.com/source.mp4", "http://www.example.com/source.ogg"]
         self.block.download_video = True
 
         xml = self.block.definition_to_xml(self.file_system)
         parser = etree.XMLParser(remove_blank_text=True)
-        xml_string = '''\
+        xml_string = """\
          <video url_name="SampleProblem" start_time="0:00:05"
                 youtube="0.75:izygArpw-Qo,1.00:p2Q6BrNhdh8,1.25:1EeWXzPdhSA,1.50:rABDYkeK0x8"
                 show_captions="false" download_video="true" download_track="true">
@@ -851,11 +875,11 @@ def test_export_to_xml_empty_end_time(self, _mock_get_edxval_api):
            <source src="http://www.example.com/source.ogg"/>
            <track src="http://www.example.com/track"/>
          </video>
-        '''
+        """
         expected = etree.XML(xml_string, parser=parser)
         self.assertXmlEqual(expected, xml)
 
-    @patch('xblocks_contrib.video.video.get_edxval_api', return_value=None)
+    @patch("xblocks_contrib.video.video.get_edxval_api", return_value=None)
     def test_export_to_xml_empty_parameters(self, _mock_get_edxval_api):
         """
         Test XML export with defaults.
@@ -863,9 +887,9 @@ def test_export_to_xml_empty_parameters(self, _mock_get_edxval_api):
         xml = self.block.definition_to_xml(self.file_system)
         # Check that download_video field is also set to default (False) in xml for backward compatibility
         expected = '<video youtube="1.00:3_yD_cEKoCk" url_name="SampleProblem"/>\n'
-        assert expected == etree.tostring(xml, pretty_print=True).decode('utf-8')
+        assert expected == etree.tostring(xml, pretty_print=True).decode("utf-8")
 
-    @patch('xblocks_contrib.video.video.get_edxval_api', return_value=None)
+    @patch("xblocks_contrib.video.video.get_edxval_api", return_value=None)
     def test_export_to_xml_with_transcripts_as_none(self, _mock_get_edxval_api):
         """
         Test XML export with transcripts being overridden to None.
@@ -875,61 +899,66 @@ def test_export_to_xml_with_transcripts_as_none(self, _mock_get_edxval_api):
         expected = b'<video youtube="1.00:3_yD_cEKoCk" url_name="SampleProblem"/>\n'
         assert expected == etree.tostring(xml, pretty_print=True)
 
-    @patch('xblocks_contrib.video.video.get_edxval_api', return_value=None)
+    @patch("xblocks_contrib.video.video.get_edxval_api", return_value=None)
     def test_export_to_xml_invalid_characters_in_attributes(self, _mock_get_edxval_api):
         """
         Test XML export will *not* raise TypeError by lxml library if contains illegal characters.
         The illegal characters in a String field are removed from the string instead.
         """
-        self.block.display_name = 'Display\x1eName'
+        self.block.display_name = "Display\x1eName"
         xml = self.block.definition_to_xml(self.file_system)
-        assert xml.get('display_name') == 'DisplayName'
+        assert xml.get("display_name") == "DisplayName"
 
-    @patch('xblocks_contrib.video.video.get_edxval_api', return_value=None)
+    @patch("xblocks_contrib.video.video.get_edxval_api", return_value=None)
     def test_export_to_xml_unicode_characters(self, _mock_get_edxval_api):
         """
         Test XML export handles the unicode characters.
         """
-        self.block.display_name = '这是文'
+        self.block.display_name = "这是文"
         xml = self.block.definition_to_xml(self.file_system)
-        assert xml.get('display_name') == '这是文'
+        assert xml.get("display_name") == "这是文"
 
 
 @ddt.ddt
-@patch.object(settings, 'FEATURES', create=True, new={
-    'FALLBACK_TO_ENGLISH_TRANSCRIPTS': False,
-})
+@patch.object(
+    settings,
+    "FEATURES",
+    create=True,
+    new={
+        "FALLBACK_TO_ENGLISH_TRANSCRIPTS": False,
+    },
+)
 class VideoBlockStudentViewDataTestCase(unittest.TestCase):
     """
     Make sure that VideoBlock returns the expected student_view_data.
     """
 
-    VIDEO_URL_1 = 'http://www.example.com/source_low.mp4'
-    VIDEO_URL_2 = 'http://www.example.com/source_med.mp4'
-    VIDEO_URL_3 = 'http://www.example.com/source_high.mp4'
+    VIDEO_URL_1 = "http://www.example.com/source_low.mp4"
+    VIDEO_URL_2 = "http://www.example.com/source_med.mp4"
+    VIDEO_URL_3 = "http://www.example.com/source_high.mp4"
 
     @ddt.data(
         # Ensure no extra data is returned if video block configured only for web display.
         (
-            {'only_on_web': True},
-            {'only_on_web': True},
+            {"only_on_web": True},
+            {"only_on_web": True},
         ),
         # Ensure that YouTube URLs are included in `encoded_videos`, but not `all_sources`.
         (
             {
-                'only_on_web': False,
-                'youtube_id_1_0': 'abc',
-                'html5_sources': [VIDEO_URL_2, VIDEO_URL_3],
+                "only_on_web": False,
+                "youtube_id_1_0": "abc",
+                "html5_sources": [VIDEO_URL_2, VIDEO_URL_3],
             },
             {
-                'only_on_web': False,
-                'duration': None,
-                'transcripts': {},
-                'encoded_videos': {
-                    'fallback': {'url': VIDEO_URL_2, 'file_size': 0},
-                    'youtube': {'url': 'https://www.youtube.com/watch?v=abc', 'file_size': 0},
+                "only_on_web": False,
+                "duration": None,
+                "transcripts": {},
+                "encoded_videos": {
+                    "fallback": {"url": VIDEO_URL_2, "file_size": 0},
+                    "youtube": {"url": "https://www.youtube.com/watch?v=abc", "file_size": 0},
                 },
-                'all_sources': [VIDEO_URL_2, VIDEO_URL_3],
+                "all_sources": [VIDEO_URL_2, VIDEO_URL_3],
             },
         ),
     )
@@ -942,80 +971,79 @@ def test_student_view_data(self, field_data, expected_student_view_data):
         student_view_data = block.student_view_data()
         assert student_view_data == expected_student_view_data
 
+    @patch("xblocks_contrib.video.video.VideoBlock.is_hls_playback_enabled", Mock(return_value=True))
     @patch(
-        'xblocks_contrib.video.video.VideoBlock.is_hls_playback_enabled',
-        Mock(return_value=True)
+        "xblocks_contrib.video.video_transcripts_utils.get_available_transcript_languages", Mock(return_value=["es"])
     )
-    @patch(
-        'xblocks_contrib.video.video_transcripts_utils.get_available_transcript_languages',
-        Mock(return_value=['es'])
-    )
-    @patch('edxval.api.get_video_info_for_course_and_profiles', Mock(return_value={}))
-    @patch('edxval.api.get_video_info')
+    @patch("edxval.api.get_video_info_for_course_and_profiles", Mock(return_value={}))
+    @patch("edxval.api.get_video_info")
     def test_student_view_data_with_hls_flag(self, mock_get_video_info):
         mock_get_video_info.return_value = {
-            'url': '/edxval/video/example',
-            'edx_video_id': 'example_id',
-            'duration': 111.0,
-            'client_video_id': 'The example video',
-            'encoded_videos': [
-                {
-                    'url': 'http://www.meowmix.com',
-                    'file_size': 25556,
-                    'bitrate': 9600,
-                    'profile': 'hls'
-                }
-            ]
+            "url": "/edxval/video/example",
+            "edx_video_id": "example_id",
+            "duration": 111.0,
+            "client_video_id": "The example video",
+            "encoded_videos": [
+                {"url": "http://www.meowmix.com", "file_size": 25556, "bitrate": 9600, "profile": "hls"}
+            ],
         }
 
-        block = instantiate_block(edx_video_id='example_id', only_on_web=False)
+        block = instantiate_block(edx_video_id="example_id", only_on_web=False)
         block.runtime.handler_url = MagicMock()
         student_view_data = block.student_view_data()
-        expected_video_data = {'hls': {'url': 'http://www.meowmix.com', 'file_size': 25556}}
-        self.assertDictEqual(student_view_data.get('encoded_videos'), expected_video_data)
+        expected_video_data = {"hls": {"url": "http://www.meowmix.com", "file_size": 25556}}
+        self.assertDictEqual(student_view_data.get("encoded_videos"), expected_video_data)
 
 
 @ddt.ddt
-@patch.object(settings, 'YOUTUBE', create=True, new={
-    # YouTube JavaScript API
-    'API': 'www.youtube.com/iframe_api',
-
-    # URL to get YouTube metadata
-    'METADATA_URL': 'www.googleapis.com/youtube/v3/videos/',
-
-    # Current youtube api for requesting transcripts.
-    # For example: http://video.google.com/timedtext?lang=en&v=j_jEn79vS3g.
-    'TEXT_API': {
-        'url': 'video.google.com/timedtext',
-        'params': {
-            'lang': 'en',
-            'v': 'set_youtube_id_of_11_symbols_here',
+@patch.object(
+    settings,
+    "YOUTUBE",
+    create=True,
+    new={
+        # YouTube JavaScript API
+        "API": "www.youtube.com/iframe_api",
+        # URL to get YouTube metadata
+        "METADATA_URL": "www.googleapis.com/youtube/v3/videos/",
+        # Current youtube api for requesting transcripts.
+        # For example: http://video.google.com/timedtext?lang=en&v=j_jEn79vS3g.
+        "TEXT_API": {
+            "url": "video.google.com/timedtext",
+            "params": {
+                "lang": "en",
+                "v": "set_youtube_id_of_11_symbols_here",
+            },
+        },
+        # Current web page mechanism for scraping transcript information from youtube video pages
+        "TRANSCRIPTS": {
+            "CAPTION_TRACKS_REGEX": r"captionTracks\"\:\[(?P<caption_tracks>[^\]]+)",
+            "YOUTUBE_URL_BASE": "https://www.youtube.com/watch?v=",
         },
     },
-
-    # Current web page mechanism for scraping transcript information from youtube video pages
-    'TRANSCRIPTS': {
-        'CAPTION_TRACKS_REGEX': r"captionTracks\"\:\[(?P<caption_tracks>[^\]]+)",
-        'YOUTUBE_URL_BASE': 'https://www.youtube.com/watch?v=',
-    }
-})
-@patch.object(settings, 'CONTENTSTORE', create=True, new={
-    'ENGINE': 'xmodule.contentstore.mongo.MongoContentStore',
-    'DOC_STORE_CONFIG': {
-        'host': 'localhost',
-        'db': 'test_xcontent_%s' % uuid4().hex,
+)
+@patch.object(
+    settings,
+    "CONTENTSTORE",
+    create=True,
+    new={
+        "ENGINE": "xmodule.contentstore.mongo.MongoContentStore",
+        "DOC_STORE_CONFIG": {
+            "host": "localhost",
+            "db": "test_xcontent_%s" % uuid4().hex,
+        },
+        # allow for additional options that can be keyed on a name, e.g. 'trashcan'
+        "ADDITIONAL_OPTIONS": {"trashcan": {"bucket": "trash_fs"}},
     },
-    # allow for additional options that can be keyed on a name, e.g. 'trashcan'
-    'ADDITIONAL_OPTIONS': {
-        'trashcan': {
-            'bucket': 'trash_fs'
-        }
-    }
-})
-@patch.object(settings, 'FEATURES', create=True, new={
-    # The default value in {lms,cms}/envs/common.py and xmodule/tests/test_video.py should be consistent.
-    'FALLBACK_TO_ENGLISH_TRANSCRIPTS': True,
-})
+)
+@patch.object(
+    settings,
+    "FEATURES",
+    create=True,
+    new={
+        # The default value in {lms,cms}/envs/common.py and xmodule/tests/test_video.py should be consistent.
+        "FALLBACK_TO_ENGLISH_TRANSCRIPTS": True,
+    },
+)
 class VideoBlockIndexingTestCase(unittest.TestCase):
     """
     Make sure that VideoBlock can format data for indexing as expected.
@@ -1025,7 +1053,7 @@ def test_video_with_no_subs_index_dictionary(self):
         """
         Test index dictionary of a video block without subtitles.
         """
-        xml_data = '''
+        xml_data = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -1037,16 +1065,16 @@ def test_video_with_no_subs_index_dictionary(self):
               <track src="http://www.example.com/track"/>
               <handout src="http://www.example.com/handout"/>
             </video>
-        '''
+        """
         block = instantiate_block(data=xml_data)
-        assert block.index_dictionary() == {'content': {'display_name': 'Test Video'}, 'content_type': 'Video'}
+        assert block.index_dictionary() == {"content": {"display_name": "Test Video"}, "content_type": "Video"}
 
     def test_video_with_multiple_transcripts_index_dictionary(self):
         """
         Test index dictionary of a video block with
         two transcripts uploaded by a user.
         """
-        xml_data_transcripts = '''
+        xml_data_transcripts = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -1060,26 +1088,24 @@ def test_video_with_multiple_transcripts_index_dictionary(self):
               <transcript language="ge" src="subs_grmtran1.srt" />
               <transcript language="hr" src="subs_croatian1.srt" />
             </video>
-        '''
+        """
         _TRANSCRIPT_TEXT_BY_LANG = {
-            'ge': 'sprechen sie deutsch? Ja, ich spreche Deutsch',
-            'hr': 'Dobar dan! Kako ste danas?',
+            "ge": "sprechen sie deutsch? Ja, ich spreche Deutsch",
+            "hr": "Dobar dan! Kako ste danas?",
         }
         block = instantiate_block(data=xml_data_transcripts)
-        video_config_service = block.runtime.service(block, 'video_config')
+        video_config_service = block.runtime.service(block, "video_config")
         # Mock get_transcript to return transcript text for the given language.
-        video_config_service.get_transcript = (
-            lambda block, lang=None, output_format=None: (
-                _TRANSCRIPT_TEXT_BY_LANG.get(lang, ''),
-            )
+        video_config_service.get_transcript = lambda block, lang=None, output_format=None: (
+            _TRANSCRIPT_TEXT_BY_LANG.get(lang, ""),
         )
         expected = {
-            'content': {
-                'display_name': 'Test Video',
-                'transcript_ge': 'sprechen sie deutsch? Ja, ich spreche Deutsch',
-                'transcript_hr': 'Dobar dan! Kako ste danas?',
+            "content": {
+                "display_name": "Test Video",
+                "transcript_ge": "sprechen sie deutsch? Ja, ich spreche Deutsch",
+                "transcript_hr": "Dobar dan! Kako ste danas?",
             },
-            'content_type': 'Video',
+            "content_type": "Video",
         }
         assert block.index_dictionary() == expected
 
@@ -1089,7 +1115,7 @@ def test_video_with_language_do_not_have_transcripts_translation(self):
         Test translation retrieval of a video block with
         a language having no transcripts uploaded by a user.
         """
-        xml_data_transcripts = '''
+        xml_data_transcripts = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -1102,15 +1128,13 @@ def test_video_with_language_do_not_have_transcripts_translation(self):
               <handout src="http://www.example.com/handout"/>
               <transcript language="ur" src="" />
             </video>
-        '''
+        """
         block = instantiate_block(data=xml_data_transcripts)
-        video_config_service = block.runtime.service(block, 'video_config')
+        video_config_service = block.runtime.service(block, "video_config")
         translations = video_config_service.available_translations(
-            block,
-            block.get_transcripts_info(),
-            verify_assets=False
+            block, block.get_transcripts_info(), verify_assets=False
         )
-        assert translations != ['ur']
+        assert translations != ["ur"]
 
     def assert_validation_message(self, validation, expected_msg):
         """
@@ -1124,16 +1148,13 @@ def assert_validation_message(self, validation, expected_msg):
         # Validation contains some warning/message
         assert validation.summary
         assert VALIDATION_MESSAGE_WARNING == validation.summary.type
-        assert expected_msg in validation.summary.text.replace('Urdu, Esperanto', 'Esperanto, Urdu')
+        assert expected_msg in validation.summary.text.replace("Urdu, Esperanto", "Esperanto, Urdu")
 
     @ddt.data(
-        (
-            '<transcript language="ur" src="" />',
-            'There is no transcript file associated with the Urdu language.'
-        ),
+        ('<transcript language="ur" src="" />', "There is no transcript file associated with the Urdu language."),
         (
             '<transcript language="eo" src="" /><transcript language="ur" src="" />',
-            'There are no transcript files associated with the Esperanto, Urdu languages.'
+            "There are no transcript files associated with the Esperanto, Urdu languages.",
         ),
     )
     @ddt.unpack
@@ -1142,7 +1163,7 @@ def test_no_transcript_validation_message(self, xml_transcripts, expected_valida
         """
         Test the validation message when no associated transcript file uploaded.
         """
-        xml_data_transcripts = '''
+        xml_data_transcripts = """
             <video display_name="Test Video"
                    youtube="1.0:p2Q6BrNhdh8,0.75:izygArpw-Qo,1.25:1EeWXzPdhSA,1.5:rABDYkeK0x8"
                    show_captions="false"
@@ -1155,7 +1176,7 @@ def test_no_transcript_validation_message(self, xml_transcripts, expected_valida
               <handout src="http://www.example.com/handout"/>
               {xml_transcripts}
             </video>
-        '''.format(xml_transcripts=xml_transcripts)
+        """.format(xml_transcripts=xml_transcripts)
         block = instantiate_block(data=xml_data_transcripts)
         validation = block.validate()
         self.assert_validation_message(validation, expected_validation_msg)
@@ -1167,5 +1188,5 @@ def test_video_transcript_none(self):
         block = instantiate_block(data=None)
         block.transcripts = None
         response = block.get_transcripts_info()
-        expected = {'transcripts': {}, 'sub': ''}
+        expected = {"transcripts": {}, "sub": ""}
         assert expected == response
diff --git a/xblocks_contrib/video/validation.py b/xblocks_contrib/video/validation.py
index 45388ace..11379164 100644
--- a/xblocks_contrib/video/validation.py
+++ b/xblocks_contrib/video/validation.py
@@ -1,6 +1,7 @@
 """
 Extension of XBlock Validation class to include information for presentation in Studio.
 """
+
 from xblock.validation import Validation, ValidationMessage
 
 
diff --git a/xblocks_contrib/video/video.py b/xblocks_contrib/video/video.py
index a228179c..fab3ff15 100644
--- a/xblocks_contrib/video/video.py
+++ b/xblocks_contrib/video/video.py
@@ -102,17 +102,23 @@
 log = logging.getLogger(__name__)
 loader = ResourceLoader(__name__)
 
-EXPORT_IMPORT_COURSE_DIR = 'course'
-EXPORT_IMPORT_STATIC_DIR = 'static'
+EXPORT_IMPORT_COURSE_DIR = "course"
+EXPORT_IMPORT_STATIC_DIR = "static"
 
 
-@XBlock.wants('settings', 'completion', 'request_cache', 'video_config')
-@XBlock.needs('i18n', 'user')
+@XBlock.wants("settings", "completion", "request_cache", "video_config")
+@XBlock.needs("i18n", "user")
 class VideoBlock(
-        VideoFields, VideoTranscriptsMixin, VideoStudioViewHandlers, VideoStudentViewHandlers,
-        LegacyXmlMixin, XBlock,
-        AjaxHandlerMixin, StudioMetadataMixin,
-        LicenseMixin):
+    VideoFields,
+    VideoTranscriptsMixin,
+    VideoStudioViewHandlers,
+    VideoStudentViewHandlers,
+    LegacyXmlMixin,
+    XBlock,
+    AjaxHandlerMixin,
+    StudioMetadataMixin,
+    LicenseMixin,
+):
     """
     XML source example::
 
@@ -125,25 +131,19 @@ class VideoBlock(
             <source src=".../mit-3091x/M-3091X-FA12-L21-3_100.ogv"/>
         </video>
     """
+
     is_extracted = True
     has_custom_completion = True
     completion_mode = XBlockCompletionMode.COMPLETABLE
 
     video_time = 0
-    icon_class = 'video'
+    icon_class = "video"
 
     show_in_read_only_mode = True
 
     tabs = [
-        {
-            'name': _("Basic"),
-            'template': "video/transcripts.html",
-            'current': True
-        },
-        {
-            'name': _("Advanced"),
-            'template': "tabs/metadata-edit-tab.html"
-        }
+        {"name": _("Basic"), "template": "video/transcripts.html", "current": True},
+        {"name": _("Advanced"), "template": "tabs/metadata-edit-tab.html"},
     ]
 
     js_module_name = "TabsEditingDescriptor"
@@ -169,7 +169,7 @@ def get_transcripts_for_student(self, transcripts, dest_lang=None):
             if self.track:
                 track_url = self.track
             elif sub or other_lang:
-                track_url = self.runtime.handler_url(self, 'transcript', 'download').rstrip('/?')
+                track_url = self.runtime.handler_url(self, "transcript", "download").rstrip("/?")
 
         transcript_language = self.get_default_transcript_language(transcripts, dest_lang)
         languages = {}
@@ -181,7 +181,7 @@ def get_transcripts_for_student(self, transcripts, dest_lang=None):
                 continue
 
         if not other_lang or (other_lang and sub):
-            languages['en'] = 'English'
+            languages["en"] = "English"
 
         # OrderedDict for easy testing of rendered context in tests
         sorted_languages = sorted(list(languages.items()), key=itemgetter(1))
@@ -193,7 +193,7 @@ def is_hls_playback_enabled(self, course_id: CourseKey) -> bool:
         """
         Check if HLS playback is enabled for the course.
         """
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         return video_config_service.is_hls_playback_enabled(course_id) if video_config_service else False
 
     @property
@@ -201,7 +201,7 @@ def youtube_deprecated(self):
         """
         Return True if youtube is deprecated and hls as primary playback is enabled else False
         """
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         # Return False if `hls` playback feature is disabled.
         if not self.is_hls_playback_enabled(self.context_key):
             return False
@@ -213,14 +213,15 @@ def youtube_deprecated(self):
     def youtube_disabled_for_course(self):  # lint-amnesty, pylint: disable=missing-function-docstring
         if not self.context_key.is_course:
             return False  # Only courses have this flag
-        request_cache = RequestCache('youtube_disabled_for_course')
+        request_cache = RequestCache("youtube_disabled_for_course")
         cache_response = request_cache.get_cached_response(self.context_key)
         if cache_response.is_found:
             return cache_response.value
 
-        video_config_service = self.runtime.service(self, 'video_config')
-        youtube_is_disabled = video_config_service.is_youtube_blocked_for_course(
-            self.context_key) if video_config_service else False
+        video_config_service = self.runtime.service(self, "video_config")
+        youtube_is_disabled = (
+            video_config_service.is_youtube_blocked_for_course(self.context_key) if video_config_service else False
+        )
         request_cache.set(self.context_key, youtube_is_disabled)
         return youtube_is_disabled
 
@@ -277,7 +278,7 @@ def public_view(self, context):
         """
         is_embed = context.get("public_video_embed")
 
-        if not is_embed and getattr(self.runtime, 'suppports_state_for_anonymous_users', False):
+        if not is_embed and getattr(self.runtime, "suppports_state_for_anonymous_users", False):
             # The new runtime can support anonymous users as fully as regular users:
             return self.student_view(context)
 
@@ -292,7 +293,7 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         Return html for a given view of this block.
         """
         context = context or {}
-        track_status = (self.download_track and self.track)
+        track_status = self.download_track and self.track
         transcript_download_format = self.transcript_download_format if not track_status else None
         sources = [source for source in self.html5_sources if source]
 
@@ -304,9 +305,9 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         # Determine if there is an alternative source for this video
         # based on user locale.  This exists to support cases where
         # we leverage a geography specific CDN, like China.
-        default_cdn_url = getattr(settings, 'VIDEO_CDN_URL', {}).get('default')
-        user_location = self.runtime.service(self, 'user').get_current_user().opt_attrs[ATTR_KEY_REQUEST_COUNTRY_CODE]
-        cdn_url = getattr(settings, 'VIDEO_CDN_URL', {}).get(user_location, default_cdn_url)
+        default_cdn_url = getattr(settings, "VIDEO_CDN_URL", {}).get("default")
+        user_location = self.runtime.service(self, "user").get_current_user().opt_attrs[ATTR_KEY_REQUEST_COUNTRY_CODE]
+        cdn_url = getattr(settings, "VIDEO_CDN_URL", {}).get(user_location, default_cdn_url)
 
         # If we have an edx_video_id, we prefer its values over what we store
         # internally for download links (source, html5_sources) and the youtube
@@ -317,7 +318,7 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
                 val_profiles = ["youtube", "desktop_webm", "desktop_mp4"]
 
                 if self.is_hls_playback_enabled(self.context_key):
-                    val_profiles.append('hls')
+                    val_profiles.append("hls")
 
                 # strip edx_video_id to prevent ValVideoNotFoundError error if unwanted spaces are there. TNL-5769
                 val_video_urls = edxval_api.get_urls_for_profiles(self.edx_video_id.strip(), val_profiles)
@@ -333,7 +334,7 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
                         if url not in sources:
                             sources.append(url)
                         # don't include hls urls for download
-                        if self.download_video and not url.endswith('.m3u8'):
+                        if self.download_video and not url.endswith(".m3u8"):
                             # function returns None when the url cannot be re-written
                             rewritten_link = rewrite_video_url(cdn_url, url)
                             if rewritten_link:
@@ -347,8 +348,8 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
 
                 # get video duration
                 video_data = edxval_api.get_video_info(self.edx_video_id.strip())
-                video_duration = video_data.get('duration')
-                video_status = video_data.get('status')
+                video_duration = video_data.get("duration")
+                video_status = video_data.get("status")
 
             except (edxval_api.ValInternalError, edxval_api.ValVideoNotFoundError):
                 # VAL raises this exception if it can't find data for the edx video ID. This can happen if the
@@ -360,9 +361,8 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         # 'CN' is China ISO 3166-1 country code.
         # Video caching is disabled for Studio. User_location is always None in Studio.
         # CountryMiddleware disabled for Studio.
-        if getattr(self, 'video_speed_optimizations', True) and cdn_url:
-
-            if self.edx_video_id and edxval_api and video_status != 'external':
+        if getattr(self, "video_speed_optimizations", True) and cdn_url:
+            if self.edx_video_id and edxval_api and video_status != "external":
                 for index, source_url in enumerate(sources):
                     new_url = rewrite_video_url(cdn_url, source_url)
                     if new_url:
@@ -373,26 +373,25 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         if not download_video_link and self.download_video:
             if self.html5_sources:
                 # If there are multiple html5 sources, we use the first non HLS video urls
-                download_video_link = next((url for url in self.html5_sources if not url.endswith('.m3u8')), None)
+                download_video_link = next((url for url in self.html5_sources if not url.endswith(".m3u8")), None)
 
         transcripts = self.get_transcripts_info()
         track_url, transcript_language, sorted_languages = self.get_transcripts_for_student(
-            transcripts=transcripts,
-            dest_lang=context.get("dest_lang")
+            transcripts=transcripts, dest_lang=context.get("dest_lang")
         )
 
         cdn_eval = False
         cdn_exp_group = None
 
         if self.youtube_disabled_for_course():
-            self.youtube_streams = ''  # lint-amnesty, pylint: disable=attribute-defined-outside-init
+            self.youtube_streams = ""  # lint-amnesty, pylint: disable=attribute-defined-outside-init
         else:
             self.youtube_streams = youtube_streams or create_youtube_string(self)  # pylint: disable=W0201
 
-        settings_service = self.runtime.service(self, 'settings')  # lint-amnesty, pylint: disable=unused-variable
+        _settings_service = self.runtime.service(self, "settings")
 
         poster = self._poster()
-        completion_service = self.runtime.service(self, 'completion')
+        completion_service = self.runtime.service(self, "completion")
         if completion_service:
             completion_enabled = completion_service.completion_tracking_enabled()
         else:
@@ -402,18 +401,19 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         # video will autoadvance or not.
         # For autoadvance controls to be shown, both the feature flag and the course setting must be true.
         # This allows to enable the feature for certain courses only.
-        autoadvance_enabled = settings.FEATURES.get('ENABLE_AUTOADVANCE_VIDEOS', False) and \
-            getattr(self, 'video_auto_advance', False)
+        autoadvance_enabled = settings.FEATURES.get("ENABLE_AUTOADVANCE_VIDEOS", False) and getattr(
+            self, "video_auto_advance", False
+        )
 
         # This is the current status of auto-advance (not the control visibility).
         # But when controls aren't visible we force it to off. The student might have once set the preference to
         # true, but now staff or admin have hidden the autoadvance button and the student won't be able to disable
         # it anymore; therefore we force-disable it in this case (when controls aren't visible).
         autoadvance_this_video = self.auto_advance and autoadvance_enabled
-        is_embed = context.get('public_video_embed', False)
+        is_embed = context.get("public_video_embed", False)
         is_public_view = view == PUBLIC_VIEW
         metadata = {
-            'autoAdvance': autoadvance_this_video,
+            "autoAdvance": autoadvance_this_video,
             # For now, the option "data-autohide-html5" is hard coded. This option
             # either enables or disables autohiding of controls and captions on mouse
             # inactivity. If set to true, controls and captions will autohide for
@@ -425,52 +425,53 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
             # There is no option in the "Advanced Editor" to set this option. However,
             # this option will have an effect if changed to "True". The code on
             # front-end exists.
-            'autohideHtml5': False,
-            'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', False),
+            "autohideHtml5": False,
+            "autoplay": settings.FEATURES.get("AUTOPLAY_VIDEOS", False),
             # This won't work when we move to data that
             # isn't on the filesystem
-            'captionDataDir': getattr(self, 'data_dir', None),
-            'completionEnabled': completion_enabled,
-            'completionPercentage': settings.COMPLETION_VIDEO_COMPLETE_PERCENTAGE,
-            'duration': video_duration,
-            'end': self.end_time.total_seconds(),
-            'generalSpeed': self.global_speed,
-            'lmsRootURL': settings.LMS_ROOT_URL,
-            'poster': poster,
-            'prioritizeHls': self.prioritize_hls(self.youtube_streams, sources),
-            'publishCompletionUrl': self.runtime.handler_url(self, 'publish_completion', '').rstrip('?'),
+            "captionDataDir": getattr(self, "data_dir", None),
+            "completionEnabled": completion_enabled,
+            "completionPercentage": settings.COMPLETION_VIDEO_COMPLETE_PERCENTAGE,
+            "duration": video_duration,
+            "end": self.end_time.total_seconds(),
+            "generalSpeed": self.global_speed,
+            "lmsRootURL": settings.LMS_ROOT_URL,
+            "poster": poster,
+            "prioritizeHls": self.prioritize_hls(self.youtube_streams, sources),
+            "publishCompletionUrl": self.runtime.handler_url(self, "publish_completion", "").rstrip("?"),
             # This is the server's guess at whether youtube is available for
             # this user, based on what was recorded the last time we saw the
             # user, and defaulting to True.
-            'recordedYoutubeIsAvailable': self.youtube_is_available,
-            'savedVideoPosition': self.saved_video_position.total_seconds(),
-            'saveStateEnabled': not is_public_view,
-            'saveStateUrl': self.ajax_url + '/save_user_state',
+            "recordedYoutubeIsAvailable": self.youtube_is_available,
+            "savedVideoPosition": self.saved_video_position.total_seconds(),
+            "saveStateEnabled": not is_public_view,
+            "saveStateUrl": self.ajax_url + "/save_user_state",
             # Despite the setting on the block, don't show transcript by default
             # if the video is embedded in social media
-            'showCaptions': json.dumps(self.show_captions and not is_embed),
-            'sources': sources,
-            'speed': self.speed,
-            'start': self.start_time.total_seconds(),
-            'streams': self.youtube_streams,
-            'transcriptAvailableTranslationsUrl': self.runtime.handler_url(
-                self, 'transcript', 'available_translations'
-            ).rstrip('/?'),
-            'aiTranslationsUrl': settings.AI_TRANSLATIONS_API_URL,
-            'transcriptLanguage': transcript_language,
-            'transcriptLanguages': sorted_languages,
-            'transcriptTranslationUrl': self.runtime.handler_url(
-                self, 'transcript', 'translation/__lang__'
-            ).rstrip('/?'),
-            'ytApiUrl': settings.YOUTUBE['API'],
-            'ytMetadataEndpoint': (
+            "showCaptions": json.dumps(self.show_captions and not is_embed),
+            "sources": sources,
+            "speed": self.speed,
+            "start": self.start_time.total_seconds(),
+            "streams": self.youtube_streams,
+            "transcriptAvailableTranslationsUrl": self.runtime.handler_url(
+                self, "transcript", "available_translations"
+            ).rstrip("/?"),
+            "aiTranslationsUrl": settings.AI_TRANSLATIONS_API_URL,
+            "transcriptLanguage": transcript_language,
+            "transcriptLanguages": sorted_languages,
+            "transcriptTranslationUrl": self.runtime.handler_url(self, "transcript", "translation/__lang__").rstrip(
+                "/?"
+            ),
+            "ytApiUrl": settings.YOUTUBE["API"],
+            "ytMetadataEndpoint": (
                 # In the new runtime, get YouTube metadata via a handler. The handler supports anonymous users and
                 # can work in sandboxed iframes. In the old runtime, the JS will call the LMS's yt_video_metadata
                 # API endpoint directly (not an XBlock handler).
-                self.runtime.handler_url(self, 'yt_video_metadata')
-                if getattr(self.runtime, 'suppports_state_for_anonymous_users', False) else ''
+                self.runtime.handler_url(self, "yt_video_metadata")
+                if getattr(self.runtime, "suppports_state_for_anonymous_users", False)
+                else ""
             ),
-            'ytTestTimeout': settings.YOUTUBE['TEST_TIMEOUT'],
+            "ytTestTimeout": settings.YOUTUBE["TEST_TIMEOUT"],
         }
 
         bumperize(self)
@@ -478,31 +479,31 @@ def get_html(self, view=STUDENT_VIEW, context=None):  # pylint: disable=too-many
         is_video_from_same_origin = bool(download_video_link and cdn_url and download_video_link.startswith(cdn_url))
 
         template_context = {
-            'autoadvance_enabled': autoadvance_enabled,
-            'bumper_metadata': json.dumps(self.bumper['metadata']),  # pylint: disable=E1101
-            'cdn_eval': cdn_eval,
-            'cdn_exp_group': cdn_exp_group,
-            'display_name': self.display_name_with_default,
-            'download_video_link': download_video_link,
-            'is_video_from_same_origin': is_video_from_same_origin,
-            'handout': self.handout,
-            'hide_downloads': is_public_view or is_embed,
-            'id': self.usage_key.html_id(),
-            'block_id': str(self.usage_key),
-            'course_id': str(self.context_key),
-            'video_id': str(self.edx_video_id),
-            'user_id': self.get_user_id(),
-            'is_embed': is_embed,
-            'license': getattr(self, "license", None),
-            'metadata': json.dumps(OrderedDict(metadata)),
-            'poster': json.dumps(get_poster(self)),
-            'track': track_url,
-            'transcript_download_format': transcript_download_format,
+            "autoadvance_enabled": autoadvance_enabled,
+            "bumper_metadata": json.dumps(self.bumper["metadata"]),  # pylint: disable=E1101
+            "cdn_eval": cdn_eval,
+            "cdn_exp_group": cdn_exp_group,
+            "display_name": self.display_name_with_default,
+            "download_video_link": download_video_link,
+            "is_video_from_same_origin": is_video_from_same_origin,
+            "handout": self.handout,
+            "hide_downloads": is_public_view or is_embed,
+            "id": self.usage_key.html_id(),
+            "block_id": str(self.usage_key),
+            "course_id": str(self.context_key),
+            "video_id": str(self.edx_video_id),
+            "user_id": self.get_user_id(),
+            "is_embed": is_embed,
+            "license": getattr(self, "license", None),
+            "metadata": json.dumps(OrderedDict(metadata)),
+            "poster": json.dumps(get_poster(self)),
+            "track": track_url,
+            "transcript_download_format": transcript_download_format,
             # pylint: disable=unsubscriptable-object
-            'transcript_download_formats_list': self.fields['transcript_download_format'].values,
-            'transcript_feedback_enabled': self.is_transcript_feedback_enabled(),
+            "transcript_download_formats_list": self.fields["transcript_download_format"].values,
+            "transcript_feedback_enabled": self.is_transcript_feedback_enabled(),
         }
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if video_config_service:
             template_context.update(video_config_service.get_public_sharing_context(self, self.context_key))
 
@@ -516,22 +517,23 @@ def is_transcript_feedback_enabled(self):
             return False  # Only courses support this feature at all (not libraries)
         try:
             # Video transcript feedback must be enabled in order to show the widget
-            video_config_service = self.runtime.service(self, 'video_config')
-            feature_enabled = video_config_service.is_transcript_feedback_enabled(
-                self.context_key) if video_config_service else False
+            video_config_service = self.runtime.service(self, "video_config")
+            feature_enabled = (
+                video_config_service.is_transcript_feedback_enabled(self.context_key) if video_config_service else False
+            )
         except Exception:  # pylint: disable=broad-except
             log.exception(f"Error retrieving course for course ID: {self.context_key}")
             return False
         return feature_enabled
 
     def get_user_id(self):
-        return self.runtime.service(self, 'user').get_current_user().opt_attrs.get(ATTR_KEY_USER_ID)
+        return self.runtime.service(self, "user").get_current_user().opt_attrs.get(ATTR_KEY_USER_ID)
 
     def get_public_video_url(self):
         """
         Returns the public video url
         """
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         return video_config_service.get_public_video_url(self) if video_config_service else None
 
     def validate(self):
@@ -555,10 +557,10 @@ def validate(self):
                 StudioValidationMessage(
                     StudioValidationMessage.WARNING,
                     ungettext(
-                        'There is no transcript file associated with the {lang} language.',
-                        'There are no transcript files associated with the {lang} languages.',
-                        len(no_transcript_lang)
-                    ).format(lang=', '.join(sorted(no_transcript_lang)))
+                        "There is no transcript file associated with the {lang} language.",
+                        "There are no transcript files associated with the {lang} languages.",
+                        len(no_transcript_lang),
+                    ).format(lang=", ".join(sorted(no_transcript_lang))),
                 )
             )
         return validation
@@ -580,7 +582,7 @@ def editor_saved(self, user, old_metadata, old_content):  # lint-amnesty, pylint
         That means that html5_sources are always in list of fields that were changed (`metadata` param in save_item).
         This should be fixed too.
         """
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if video_config_service:
             video_config_service.handle_editor_saved(self, user.id, old_metadata)
 
@@ -615,8 +617,8 @@ def parse_xml(cls, node, runtime, _keys):
 
         See XmlMixin.parse_xml for the detailed description.
         """
-        url_name = node.get('url_name')
-        block_type = 'video'
+        url_name = node.get("url_name")
+        block_type = "video"
         definition_id = runtime.id_generator.create_definition(block_type, url_name)
         usage_id = runtime.id_generator.create_usage(definition_id)
         aside_children = []
@@ -641,9 +643,7 @@ def parse_xml(cls, node, runtime, _keys):
 
         # Update VAL with info extracted from `node`
         video.edx_video_id = video.import_video_info_into_val(
-            node,
-            runtime.resources_fs,
-            getattr(runtime.id_generator, 'target_course_id', None)
+            node, runtime.resources_fs, getattr(runtime.id_generator, "target_course_id", None)
         )
 
         if aside_children:
@@ -655,19 +655,19 @@ def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=too-m
         """
         Returns an xml string representing this block.
         """
-        xml = etree.Element('video')
+        xml = etree.Element("video")
         youtube_string = create_youtube_string(self)
         if youtube_string:
-            xml.set('youtube', str(youtube_string))
-        xml.set('url_name', self.usage_key.block_id)
+            xml.set("youtube", str(youtube_string))
+        xml.set("url_name", self.usage_key.block_id)
         attrs = [
-            ('display_name', self.display_name),
-            ('show_captions', json.dumps(self.show_captions)),
-            ('start_time', self.start_time),
-            ('end_time', self.end_time),
-            ('sub', self.sub),
-            ('download_track', json.dumps(self.download_track)),
-            ('download_video', json.dumps(self.download_video))
+            ("display_name", self.display_name),
+            ("show_captions", json.dumps(self.show_captions)),
+            ("start_time", self.start_time),
+            ("end_time", self.end_time),
+            ("sub", self.sub),
+            ("download_track", json.dumps(self.download_track)),
+            ("download_video", json.dumps(self.download_video)),
         ]
         for key, value in attrs:
             # Mild workaround to ensure that tests pass -- if a field
@@ -682,25 +682,25 @@ def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=too-m
                         log.exception(exception_message)
                         # If exception is UnicodeDecodeError set value using unicode 'utf-8' scheme.
                         log.info("Setting xml value using 'utf-8' scheme.")
-                        xml.set(key, str(value, 'utf-8'))
+                        xml.set(key, str(value, "utf-8"))
                     except ValueError:
                         exception_message = format_xml_exception_message(self.usage_key, key, value)
                         log.exception(exception_message)
                         raise
 
         for source in self.html5_sources:
-            ele = etree.Element('source')
-            ele.set('src', source)
+            ele = etree.Element("source")
+            ele.set("src", source)
             xml.append(ele)
 
         if self.track:
-            ele = etree.Element('track')
-            ele.set('src', self.track)
+            ele = etree.Element("track")
+            ele.set("src", self.track)
             xml.append(ele)
 
         if self.handout:
-            ele = etree.Element('handout')
-            ele.set('src', self.handout)
+            ele = etree.Element("handout")
+            ele.set("src", self.handout)
             xml.append(ele)
 
         transcripts = {}
@@ -727,30 +727,30 @@ def definition_to_xml(self, resource_fs):  # lint-amnesty, pylint: disable=too-m
                     course_id=self.context_key.for_branch(None),
                 )
                 # Update xml with edxval metadata
-                xml.append(exported_metadata['xml'])
+                xml.append(exported_metadata["xml"])
 
                 # we don't need sub if english transcript
                 # is also in new transcripts.
-                new_transcripts = exported_metadata['transcripts']
+                new_transcripts = exported_metadata["transcripts"]
                 transcripts.update(new_transcripts)
-                if new_transcripts.get('en'):
-                    xml.set('sub', '')
+                if new_transcripts.get("en"):
+                    xml.set("sub", "")
 
             except edxval_api.ValVideoNotFoundError:
                 pass
         else:
-            if transcripts.get('en'):
-                xml.set('sub', '')
+            if transcripts.get("en"):
+                xml.set("sub", "")
 
         if transcripts:
             # Update `transcripts` attribute in the xml
-            xml.set('transcripts', json.dumps(transcripts, sort_keys=True))
+            xml.set("transcripts", json.dumps(transcripts, sort_keys=True))
 
             # Sorting transcripts for easy testing of resulting xml
             for transcript_language in sorted(transcripts.keys()):
-                ele = etree.Element('transcript')
-                ele.set('language', transcript_language)
-                ele.set('src', transcripts[transcript_language])
+                ele = etree.Element("transcript")
+                ele.set("language", transcript_language)
+                ele.set("src", transcripts[transcript_language])
                 xml.append(ele)
 
         # handle license specifically
@@ -768,30 +768,30 @@ def create_youtube_url(self, youtube_id):
             A full youtube url to the video whose ID is passed in
         """
         if youtube_id:
-            return f'https://www.youtube.com/watch?v={youtube_id}'
+            return f"https://www.youtube.com/watch?v={youtube_id}"
         else:
-            return ''
+            return ""
 
     def get_context(self):
         """
         Extend context by data for transcript basic tab.
         """
         edxval_api = get_edxval_api()
-        _context = {
-            'editable_metadata_fields': self.editable_metadata_fields
-        }
-        _context.update({
-            'tabs': self.tabs,
-            'html_id': self.usage_key.html_id(),  # element_id
-            'data': self.data,
-        })
+        _context = {"editable_metadata_fields": self.editable_metadata_fields}
+        _context.update(
+            {
+                "tabs": self.tabs,
+                "html_id": self.usage_key.html_id(),  # element_id
+                "data": self.data,
+            }
+        )
 
         metadata_fields = copy.deepcopy(self.editable_metadata_fields)
 
-        display_name = metadata_fields['display_name']
-        video_url = metadata_fields['html5_sources']
-        video_id = metadata_fields['edx_video_id']
-        youtube_id_1_0 = metadata_fields['youtube_id_1_0']
+        display_name = metadata_fields["display_name"]
+        video_url = metadata_fields["html5_sources"]
+        video_id = metadata_fields["edx_video_id"]
+        youtube_id_1_0 = metadata_fields["youtube_id_1_0"]
 
         def get_youtube_link(video_id):
             """
@@ -807,51 +807,50 @@ def get_youtube_link(video_id):
             return self.create_youtube_url(video_id)
 
         _ = self.runtime.service(self, "i18n").ugettext
-        video_url.update({
-            'help': _('The URL for your video. This can be a YouTube URL or a link to an .mp4, .ogg, or '
-                      '.webm video file hosted elsewhere on the Internet.'),
-            'display_name': _('Default Video URL'),
-            'field_name': 'video_url',
-            'type': 'VideoList',
-            'default_value': [get_youtube_link(youtube_id_1_0['default_value'])]
-        })
-
-        source_url = self.create_youtube_url(youtube_id_1_0['value'])
+        video_url.update(
+            {
+                "help": _(
+                    "The URL for your video. This can be a YouTube URL or a link to an .mp4, .ogg, or "
+                    ".webm video file hosted elsewhere on the Internet."
+                ),
+                "display_name": _("Default Video URL"),
+                "field_name": "video_url",
+                "type": "VideoList",
+                "default_value": [get_youtube_link(youtube_id_1_0["default_value"])],
+            }
+        )
+
+        source_url = self.create_youtube_url(youtube_id_1_0["value"])
         # First try a lookup in VAL. If any video encoding is found given the video id then
         # override the source_url with it.
         if self.edx_video_id and edxval_api:
-
-            val_profiles = ['youtube', 'desktop_webm', 'desktop_mp4']
+            val_profiles = ["youtube", "desktop_webm", "desktop_mp4"]
             if self.is_hls_playback_enabled(self.context_key.for_branch(None)):
-                val_profiles.append('hls')
+                val_profiles.append("hls")
 
             # Get video encodings for val profiles.
             val_video_encodings = edxval_api.get_urls_for_profiles(self.edx_video_id, val_profiles)
 
             # VAL's youtube source has greater priority over external youtube source.
-            if val_video_encodings.get('youtube'):
-                source_url = self.create_youtube_url(val_video_encodings['youtube'])
+            if val_video_encodings.get("youtube"):
+                source_url = self.create_youtube_url(val_video_encodings["youtube"])
 
             # If no youtube source is provided externally or in VAl, update source_url in order: hls > mp4 and webm
             if not source_url:
-                if val_video_encodings.get('hls'):
-                    source_url = val_video_encodings['hls']
-                elif val_video_encodings.get('desktop_mp4'):
-                    source_url = val_video_encodings['desktop_mp4']
-                elif val_video_encodings.get('desktop_webm'):
-                    source_url = val_video_encodings['desktop_webm']
+                if val_video_encodings.get("hls"):
+                    source_url = val_video_encodings["hls"]
+                elif val_video_encodings.get("desktop_mp4"):
+                    source_url = val_video_encodings["desktop_mp4"]
+                elif val_video_encodings.get("desktop_webm"):
+                    source_url = val_video_encodings["desktop_webm"]
 
         # Only add if html5 sources do not already contain source_url.
-        if source_url and source_url not in video_url['value']:
-            video_url['value'].insert(0, source_url)
+        if source_url and source_url not in video_url["value"]:
+            video_url["value"].insert(0, source_url)
 
-        metadata = {
-            'display_name': display_name,
-            'video_url': video_url,
-            'edx_video_id': video_id
-        }
+        metadata = {"display_name": display_name, "video_url": video_url, "edx_video_id": video_id}
 
-        _context.update({'transcripts_basic_tab_metadata': metadata})
+        _context.update({"transcripts_basic_tab_metadata": metadata})
         return _context
 
     @classmethod
@@ -861,13 +860,13 @@ def _parse_youtube(cls, data):
         into a dictionary. Necessary for backwards compatibility with
         XML-based courses.
         """
-        ret = {'0.75': '', '1.00': '', '1.25': '', '1.50': ''}
+        ret = {"0.75": "", "1.00": "", "1.25": "", "1.50": ""}
 
-        videos = data.split(',')
+        videos = data.split(",")
         for video in videos:
-            pieces = video.split(':')
+            pieces = video.split(":")
             try:
-                speed = '%.2f' % float(pieces[0])  # normalize speed
+                speed = "%.2f" % float(pieces[0])  # normalize speed
 
                 # Handle the fact that youtube IDs got double-quoted for a period of time.
                 # Note: we pass in "VideoFields.youtube_id_1_0" so we deserialize as a String--
@@ -875,7 +874,7 @@ def _parse_youtube(cls, data):
                 youtube_id = deserialize_field(cls.youtube_id_1_0, pieces[1])
                 ret[speed] = youtube_id
             except (ValueError, IndexError):
-                log.warning('Invalid YouTube ID: %s', video)
+                log.warning("Invalid YouTube ID: %s", video)
         return ret
 
     @classmethod
@@ -900,68 +899,65 @@ def parse_video_xml(cls, xml, id_generator=None):
 
         # Convert between key names for certain attributes --
         # necessary for backwards compatibility.
-        compat_keys = {
-            'from': 'start_time',
-            'to': 'end_time'
-        }
-        sources = xml.findall('source')
+        compat_keys = {"from": "start_time", "to": "end_time"}
+        sources = xml.findall("source")
         if sources:
-            field_data['html5_sources'] = [ele.get('src') for ele in sources]
+            field_data["html5_sources"] = [ele.get("src") for ele in sources]
 
-        track = xml.find('track')
+        track = xml.find("track")
         if track is not None:
-            field_data['track'] = track.get('src')
+            field_data["track"] = track.get("src")
 
-        handout = xml.find('handout')
+        handout = xml.find("handout")
         if handout is not None:
-            field_data['handout'] = handout.get('src')
+            field_data["handout"] = handout.get("src")
 
-        transcripts = xml.findall('transcript')
+        transcripts = xml.findall("transcript")
         if transcripts:
-            field_data['transcripts'] = {tr.get('language'): tr.get('src') for tr in transcripts}
+            field_data["transcripts"] = {tr.get("language"): tr.get("src") for tr in transcripts}
 
         for attr, value in xml.items():
             if attr in compat_keys:  # lint-amnesty, pylint: disable=consider-using-get
                 attr = compat_keys[attr]
-            if attr in cls.metadata_to_strip + ('url_name', 'name'):
+            if attr in cls.metadata_to_strip + ("url_name", "name"):
                 continue
-            if attr == 'youtube':
+            if attr == "youtube":
                 speeds = cls._parse_youtube(value)
                 for speed, youtube_id in speeds.items():
                     # should have made these youtube_id_1_00 for
                     # cleanliness, but hindsight doesn't need glasses
-                    normalized_speed = speed[:-1] if speed.endswith('0') else speed
+                    normalized_speed = speed[:-1] if speed.endswith("0") else speed
                     # If the user has specified html5 sources, make sure we don't use the default video
-                    if youtube_id != '' or 'html5_sources' in field_data:
-                        field_data['youtube_id_{}'.format(normalized_speed.replace('.', '_'))] = youtube_id
+                    if youtube_id != "" or "html5_sources" in field_data:
+                        field_data["youtube_id_{}".format(normalized_speed.replace(".", "_"))] = youtube_id
             elif attr in conversions:
                 field_data[attr] = conversions[attr](value)
             elif attr not in cls.fields:  # lint-amnesty, pylint: disable=unsupported-membership-test
-                field_data.setdefault('xml_attributes', {})[attr] = value
+                field_data.setdefault("xml_attributes", {})[attr] = value
             else:
                 # We export values with json.dumps (well, except for Strings, but
                 # for about a month we did it for Strings also).
                 # pylint: disable-next=unsubscriptable-object
                 field_data[attr] = deserialize_field(cls.fields[attr], value)
 
-        course_id = getattr(id_generator, 'target_course_id', None)
+        course_id = getattr(id_generator, "target_course_id", None)
         # Update the handout location with current course_id
-        if 'handout' in field_data and course_id:
-            handout_location = get_location_from_path(field_data['handout'])
+        if "handout" in field_data and course_id:
+            handout_location = get_location_from_path(field_data["handout"])
             if isinstance(handout_location, AssetLocator):
                 handout_new_location = compute_location(course_id, handout_location.path)
-                field_data['handout'] = serialize_asset_key_with_slash(handout_new_location)
+                field_data["handout"] = serialize_asset_key_with_slash(handout_new_location)
 
         # For backwards compatibility: Add `source` if XML doesn't have `download_video`
         # attribute.
-        if 'download_video' not in field_data and sources:
-            field_data['source'] = field_data['html5_sources'][0]
+        if "download_video" not in field_data and sources:
+            field_data["source"] = field_data["html5_sources"][0]
 
         # For backwards compatibility: if XML doesn't have `download_track` attribute,
         # it means that it is an old format. So, if `track` has some value,
         # `download_track` needs to have value `True`.
-        if 'download_track' not in field_data and track is not None:
-            field_data['download_track'] = True
+        if "download_track" not in field_data and track is not None:
+            field_data["download_track"] = True
 
         # load license if it exists
         field_data = LicenseMixin.parse_license_from_xml(field_data, xml)
@@ -980,9 +976,9 @@ def import_video_info_into_val(self, xml, resource_fs, course_id):
         edx_video_id = clean_video_id(self.edx_video_id)
 
         # Create video_asset is not already present.
-        video_asset_elem = xml.find('video_asset')
+        video_asset_elem = xml.find("video_asset")
         if video_asset_elem is None:
-            video_asset_elem = etree.Element('video_asset')
+            video_asset_elem = etree.Element("video_asset")
 
         # This will be a dict containing the list of names of the external transcripts.
         # Example:
@@ -993,9 +989,8 @@ def import_video_info_into_val(self, xml, resource_fs, course_id):
         external_transcripts = defaultdict(list)
 
         # Add trancript from self.sub and self.youtube_id_1_0 fields.
-        external_transcripts['en'] = [
-            subs_filename(transcript, 'en')
-            for transcript in [self.sub, self.youtube_id_1_0] if transcript
+        external_transcripts["en"] = [
+            subs_filename(transcript, "en") for transcript in [self.sub, self.youtube_id_1_0] if transcript
         ]
 
         for language_code, transcript in self.transcripts.items():
@@ -1009,7 +1004,7 @@ def import_video_info_into_val(self, xml, resource_fs, course_id):
                 resource_fs,
                 EXPORT_IMPORT_STATIC_DIR,
                 external_transcripts,
-                course_id=course_id
+                course_id=course_id,
             )
         return edx_video_id
 
@@ -1020,8 +1015,8 @@ def index_dictionary(self):
         }
 
         def _update_transcript_for_index(language=None):
-            """ Find video transcript - if not found, don't update index """
-            video_config_service = self.runtime.service(self, 'video_config')
+            """Find video transcript - if not found, don't update index"""
+            video_config_service = self.runtime.service(self, "video_config")
             if video_config_service:
                 try:
                     transcript = video_config_service.get_transcript(
@@ -1086,9 +1081,9 @@ def student_view_data(self, context=None):
 
         # Check in VAL data first if edx_video_id exists
         if self.edx_video_id:
-            video_profile_names = context.get("profiles", ["mobile_low", 'desktop_mp4', 'desktop_webm', 'mobile_high'])
-            if self.is_hls_playback_enabled(self.context_key) and 'hls' not in video_profile_names:
-                video_profile_names.append('hls')
+            video_profile_names = context.get("profiles", ["mobile_low", "desktop_mp4", "desktop_webm", "mobile_high"])
+            if self.is_hls_playback_enabled(self.context_key) and "hls" not in video_profile_names:
+                video_profile_names.append("hls")
 
             # get and cache bulk VAL data for course
             val_course_data = self.get_cached_val_data_for_course(
@@ -1100,7 +1095,7 @@ def student_view_data(self, context=None):
 
             # Get the encoded videos if data from VAL is found
             if val_video_data:
-                encoded_videos = val_video_data.get('profiles', {})
+                encoded_videos = val_video_data.get("profiles", {})
 
             # If information for this edx_video_id is not found in the bulk course data, make a
             # separate request for this individual edx_video_id, unless cache misses are disabled.
@@ -1112,9 +1107,9 @@ def student_view_data(self, context=None):
                 try:
                     val_video_data = edxval_api.get_video_info(self.edx_video_id)
                     # Unfortunately, the VAL API is inconsistent in how it returns the encodings, so remap here.
-                    for enc_vid in val_video_data.pop('encoded_videos'):
-                        if enc_vid['profile'] in video_profile_names:
-                            encoded_videos[enc_vid['profile']] = {key: enc_vid[key] for key in ["url", "file_size"]}
+                    for enc_vid in val_video_data.pop("encoded_videos"):
+                        if enc_vid["profile"] in video_profile_names:
+                            encoded_videos[enc_vid["profile"]] = {key: enc_vid[key] for key in ["url", "file_size"]}
                 except edxval_api.ValVideoNotFoundError:
                     pass
 
@@ -1134,22 +1129,19 @@ def student_view_data(self, context=None):
                     "file_size": 0,  # File size is not relevant for external link
                 }
 
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if video_config_service:
-            available_translations = video_config_service.available_translations(
-                self,
-                self.get_transcripts_info()
-            )
+            available_translations = video_config_service.available_translations(self, self.get_transcripts_info())
         else:
             available_translations = []
         transcripts = {
-            lang: self.runtime.handler_url(self, 'transcript', 'download', query="lang=" + lang, thirdparty=True)
+            lang: self.runtime.handler_url(self, "transcript", "download", query="lang=" + lang, thirdparty=True)
             for lang in available_translations
         }
 
         return {
             "only_on_web": self.only_on_web,
-            "duration": val_video_data.get('duration', None),
+            "duration": val_video_data.get("duration", None),
             "transcripts": transcripts,
             "encoded_videos": encoded_videos,
             "all_sources": all_sources,
@@ -1162,8 +1154,7 @@ def _poster(self):
         edxval_api = get_edxval_api()
         if edxval_api and self.edx_video_id:
             return edxval_api.get_course_video_image_url(
-                course_id=self.context_key.for_branch(None),
-                edx_video_id=self.edx_video_id.strip()
+                course_id=self.context_key.for_branch(None), edx_video_id=self.edx_video_id.strip()
             )
         return None
 
diff --git a/xblocks_contrib/video/video_handlers.py b/xblocks_contrib/video/video_handlers.py
index f54ee663..95105069 100644
--- a/xblocks_contrib/video/video_handlers.py
+++ b/xblocks_contrib/video/video_handlers.py
@@ -5,7 +5,6 @@
 StudioViewHandlers are handlers for video descriptor instance.
 """
 
-
 import json
 import logging
 import math
@@ -27,7 +26,7 @@
 def get_transcript(
     video_block,
     lang: str | None = None,
-    output_format: str = 'srt',
+    output_format: str = "srt",
     youtube_id: str | None = None,
     is_bumper: bool = False,
 ) -> tuple[bytes, str, str]:
@@ -40,7 +39,7 @@ def get_transcript(
     Raises:
         Exception: If the video config service is not available or the transcript cannot be retrieved.
     """
-    video_config_service = video_block.runtime.service(video_block, 'video_config')
+    video_config_service = video_block.runtime.service(video_block, "video_config")
     if not video_config_service:
         raise Exception("Video config service not found")
     return video_config_service.get_transcript(video_block, lang, output_format, youtube_id, is_bumper)
@@ -49,14 +48,15 @@ def get_transcript(
 # Disable no-member warning:
 # pylint: disable=no-member
 
+
 def to_boolean(value):
     """
     Convert a value from a GET or POST request parameter to a bool
     """
     if isinstance(value, bytes):
-        value = value.decode('ascii', errors='replace')
+        value = value.decode("ascii", errors="replace")
     if isinstance(value, str):
-        return value.lower() == 'true'
+        return value.lower() == "true"
     else:
         return bool(value)
 
@@ -65,6 +65,7 @@ class VideoStudentViewHandlers:
     """
     Handlers for video block instance.
     """
+
     global_speed = None
     transcript_language = None
 
@@ -73,21 +74,26 @@ def handle_ajax(self, dispatch, data):
         Update values of xfields, that were changed by student.
         """
         accepted_keys = [
-            'speed', 'auto_advance', 'saved_video_position', 'transcript_language',
-            'transcript_download_format', 'youtube_is_available',
-            'bumper_last_view_date', 'bumper_do_not_show_again'
+            "speed",
+            "auto_advance",
+            "saved_video_position",
+            "transcript_language",
+            "transcript_download_format",
+            "youtube_is_available",
+            "bumper_last_view_date",
+            "bumper_do_not_show_again",
         ]
 
         conversions = {
-            'speed': json.loads,
-            'auto_advance': json.loads,
-            'saved_video_position': RelativeTime.isotime_to_timedelta,
-            'youtube_is_available': json.loads,
-            'bumper_last_view_date': to_boolean,
-            'bumper_do_not_show_again': to_boolean,
+            "speed": json.loads,
+            "auto_advance": json.loads,
+            "saved_video_position": RelativeTime.isotime_to_timedelta,
+            "youtube_is_available": json.loads,
+            "bumper_last_view_date": to_boolean,
+            "bumper_do_not_show_again": to_boolean,
         }
 
-        if dispatch == 'save_user_state':
+        if dispatch == "save_user_state":
             for key in data:
                 if key in accepted_keys:
                     if key in conversions:
@@ -95,25 +101,25 @@ def handle_ajax(self, dispatch, data):
                     else:
                         value = data[key]
 
-                    if key == 'bumper_last_view_date':
+                    if key == "bumper_last_view_date":
                         value = now()
 
-                    if key == 'speed' and math.isnan(value):
+                    if key == "speed" and math.isnan(value):
                         message = f"Invalid speed value {value}, must be a float."
                         log.warning(message)
-                        return json.dumps({'success': False, 'error': message})
+                        return json.dumps({"success": False, "error": message})
 
                     setattr(self, key, value)
 
-                    if key == 'speed':
+                    if key == "speed":
                         self.global_speed = self.speed
 
-            return json.dumps({'success': True})
+            return json.dumps({"success": True})
 
         log.debug(f"GET {data}")
         log.debug(f"DISPATCH {dispatch}")
 
-        raise TranscriptNotFoundError('Unexpected dispatch type')
+        raise TranscriptNotFoundError("Unexpected dispatch type")
 
     def get_static_transcript(self, request, transcripts):
         """
@@ -128,14 +134,14 @@ def get_static_transcript(self, request, transcripts):
         """
         response = Response(status=404)
         # Only do redirect for English
-        if not self.transcript_language == 'en':
+        if not self.transcript_language == "en":
             return response
 
         # If this video lives in library, the code below is not relevant and will error.
         if not isinstance(self.context_key, CourseLocator):
             return response
 
-        video_id = request.GET.get('videoId', None)
+        video_id = request.GET.get("videoId", None)
         if video_id:
             transcript_name = video_id
         else:
@@ -149,15 +155,14 @@ def get_static_transcript(self, request, transcripts):
                 asset_path = course.static_asset_path
             else:
                 # It seems static_asset_path is not set in any XMLModuleStore courses.
-                asset_path = getattr(course, 'data_dir', '')
+                asset_path = getattr(course, "data_dir", "")
 
             if asset_path:
                 response = Response(
                     status=307,
-                    location='/static/{}/{}'.format(
-                        asset_path,
-                        subs_filename(transcript_name, self.transcript_language)
-                    )
+                    location="/static/{}/{}".format(
+                        asset_path, subs_filename(transcript_name, self.transcript_language)
+                    ),
                 )
         return response
 
@@ -174,17 +179,17 @@ def publish_completion(self, data, dispatch):  # pylint: disable=unused-argument
             dispatch: Ignored.
         Return value: JSON response (200 on success, 400 for malformed data)
         """
-        completion_service = self.runtime.service(self, 'completion')
+        completion_service = self.runtime.service(self, "completion")
         if completion_service is None:
             raise JsonHandlerError(500, "No completion service found")
         if not completion_service.completion_tracking_enabled():
             raise JsonHandlerError(404, "Completion tracking is not enabled and API calls are unexpected")
-        if not isinstance(data['completion'], (int, float)):
+        if not isinstance(data["completion"], (int, float)):
             message = "Invalid completion value {}. Must be a float in range [0.0, 1.0]"
-            raise JsonHandlerError(400, message.format(data['completion']))
-        if not 0.0 <= data['completion'] <= 1.0:
+            raise JsonHandlerError(400, message.format(data["completion"]))
+        if not 0.0 <= data["completion"] <= 1.0:
             message = "Invalid completion value {}. Must be in range [0.0, 1.0]"
-            raise JsonHandlerError(400, message.format(data['completion']))
+            raise JsonHandlerError(400, message.format(data["completion"]))
         self.runtime.publish(self, "completion", data)
         return {"result": "ok"}
 
@@ -201,22 +206,13 @@ def make_transcript_http_response(content, filename, language, content_type, add
             add_attachment_header (bool): whether to add attachment header or not
         """
         headerlist = [
-            ('Content-Language', language),
+            ("Content-Language", language),
         ]
 
         if add_attachment_header:
-            headerlist.append(
-                (
-                    'Content-Disposition',
-                    f'attachment; filename="{filename}"'
-                )
-            )
+            headerlist.append(("Content-Disposition", f'attachment; filename="{filename}"'))
 
-        response = Response(
-            content,
-            headerlist=headerlist,
-            charset='utf8'
-        )
+        response = Response(content, headerlist=headerlist, charset="utf8")
         response.content_type = content_type
 
         return response
@@ -247,11 +243,11 @@ def transcript(self, request, dispatch):
                     Returns list of languages, for which transcript files exist.
                     For 'en' check if SJSON exists. For non-'en' check if SRT file exists.
         """
-        is_bumper = request.GET.get('is_bumper', False)
+        is_bumper = request.GET.get("is_bumper", False)
         transcripts = self.get_transcripts_info(is_bumper)
 
-        if dispatch.startswith('translation'):
-            language = dispatch.replace('translation', '').strip('/')
+        if dispatch.startswith("translation"):
+            language = dispatch.replace("translation", "").strip("/")
 
             # Because scrapers hit video blocks, verify that a user exists.
             # use the _request attr to get the django request object.
@@ -263,7 +259,7 @@ def transcript(self, request, dispatch):
                 log.info("Invalid /translation request: no language.")
                 return Response(status=400)
 
-            if language not in ['en'] + list(transcripts["transcripts"].keys()):
+            if language not in ["en"] + list(transcripts["transcripts"].keys()):
                 log.info("Video: transcript facilities are not available for given language.")
                 return Response(status=404)
 
@@ -271,57 +267,45 @@ def transcript(self, request, dispatch):
                 self.transcript_language = language
 
             try:
-                youtube_id = None if is_bumper else request.GET.get('videoId')
+                youtube_id = None if is_bumper else request.GET.get("videoId")
                 content, filename, mimetype = get_transcript(
                     self,
                     lang=self.transcript_language,
                     output_format=TranscriptExtensions.SJSON,
                     youtube_id=youtube_id,
-                    is_bumper=is_bumper
+                    is_bumper=is_bumper,
                 )
                 response = self.make_transcript_http_response(
-                    content,
-                    filename,
-                    self.transcript_language,
-                    mimetype,
-                    add_attachment_header=False
+                    content, filename, self.transcript_language, mimetype, add_attachment_header=False
                 )
             except TranscriptNotFoundError as exc:
                 edx_video_id = clean_video_id(self.edx_video_id)
                 log.warning(
-                    '[Translation Dispatch] %s: %s',
+                    "[Translation Dispatch] %s: %s",
                     self.usage_key,
-                    exc if is_bumper else f'Transcript not found for {edx_video_id}, lang: {self.transcript_language}',
+                    exc if is_bumper else f"Transcript not found for {edx_video_id}, lang: {self.transcript_language}",
                 )
                 response = self.get_static_transcript(request, transcripts)
 
-        elif dispatch == 'download':
-            lang = request.GET.get('lang', None)
+        elif dispatch == "download":
+            lang = request.GET.get("lang", None)
 
             try:
                 content, filename, mimetype = get_transcript(self, lang, output_format=self.transcript_download_format)
             except TranscriptNotFoundError:
                 return Response(status=404)
 
-            response = self.make_transcript_http_response(
-                content,
-                filename,
-                self.transcript_language,
-                mimetype
-            )
-        elif dispatch.startswith('available_translations'):
-            video_config_service = self.runtime.service(self, 'video_config')
+            response = self.make_transcript_http_response(content, filename, self.transcript_language, mimetype)
+        elif dispatch.startswith("available_translations"):
+            video_config_service = self.runtime.service(self, "video_config")
             if not video_config_service:
                 return Response(status=404)
             available_translations = video_config_service.available_translations(
-                self,
-                transcripts,
-                verify_assets=True,
-                is_bumper=is_bumper
+                self, transcripts, verify_assets=True, is_bumper=is_bumper
             )
             if available_translations:
                 response = Response(json.dumps(available_translations))
-                response.content_type = 'application/json'
+                response.content_type = "application/json"
             else:
                 response = Response(status=404)
         else:  # unknown dispatch
@@ -331,25 +315,23 @@ def transcript(self, request, dispatch):
         return response
 
     @XBlock.handler
-    def student_view_user_state(self, request, suffix=''):  # lint-amnesty, pylint: disable=unused-argument
+    def student_view_user_state(self, request, suffix=""):  # lint-amnesty, pylint: disable=unused-argument
         """
         Endpoint to get user-specific state, like current position and playback speed,
         without rendering the full student_view HTML. This is similar to student_view_state,
         but that one cannot contain user-specific info.
         """
         view_state = self.student_view_data()
-        view_state.update({
-            "saved_video_position": self.saved_video_position.total_seconds(),
-            "speed": self.speed,
-        })
-        return Response(
-            json.dumps(view_state),
-            content_type='application/json',
-            charset='UTF-8'
+        view_state.update(
+            {
+                "saved_video_position": self.saved_video_position.total_seconds(),
+                "speed": self.speed,
+            }
         )
+        return Response(json.dumps(view_state), content_type="application/json", charset="UTF-8")
 
     @XBlock.handler
-    def yt_video_metadata(self, request, suffix=''):  # lint-amnesty, pylint: disable=unused-argument
+    def yt_video_metadata(self, request, suffix=""):  # lint-amnesty, pylint: disable=unused-argument
         """
         Endpoint to get YouTube metadata.
         This handler is only used in the openedx_content-based runtime. The old
@@ -357,11 +339,11 @@ def yt_video_metadata(self, request, suffix=''):  # lint-amnesty, pylint: disabl
         """
         if not self.youtube_id_1_0:
             # TODO: more informational response to explain that yt_video_metadata not supported for non-youtube videos.
-            return Response('{}', status=400)
+            return Response("{}", status=400)
 
         metadata, status_code = load_metadata_from_youtube(video_id=self.youtube_id_1_0, request=request)
         response = Response(json.dumps(metadata), status=status_code)
-        response.content_type = 'application/json'
+        response.content_type = "application/json"
         return response
 
 
@@ -369,6 +351,7 @@ class VideoStudioViewHandlers:
     """
     Handlers for Studio view.
     """
+
     def validate_transcript_upload_data(self, data):
         """
         Validates video transcript file.
@@ -381,30 +364,24 @@ def validate_transcript_upload_data(self, data):
         error = None
         _ = self.runtime.service(self, "i18n").ugettext
         # Validate the must have attributes - this error is unlikely to be faced by common users.
-        must_have_attrs = ['edx_video_id', 'language_code', 'new_language_code']
+        must_have_attrs = ["edx_video_id", "language_code", "new_language_code"]
         missing = [attr for attr in must_have_attrs if attr not in data]
 
         # Get available transcript languages.
         transcripts = self.get_transcripts_info()
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if not video_config_service:
             return error
-        available_translations = video_config_service.available_translations(
-            self,
-            transcripts,
-            verify_assets=True
-        )
+        available_translations = video_config_service.available_translations(self, transcripts, verify_assets=True)
 
         if missing:
-            error = _('The following parameters are required: {missing}.').format(missing=', '.join(missing))
-        elif (
-            data['language_code'] != data['new_language_code'] and data['new_language_code'] in available_translations
-        ):
+            error = _("The following parameters are required: {missing}.").format(missing=", ".join(missing))
+        elif data["language_code"] != data["new_language_code"] and data["new_language_code"] in available_translations:
             error = _('A transcript with the "{language_code}" language code already exists.').format(
-                language_code=data['new_language_code'],
+                language_code=data["new_language_code"],
             )
-        elif 'file' not in data:
-            error = _('A transcript file is required.')
+        elif "file" not in data:
+            error = _("A transcript file is required.")
 
         return error
 
@@ -438,13 +415,12 @@ def studio_transcript(self, request, dispatch):
                     no SRT extension or not parse-able by PySRT
                 UnicodeDecodeError: non-UTF8 uploaded file content encoding.
         """
-        if dispatch.startswith('translation'):
-
-            if request.method == 'POST':
+        if dispatch.startswith("translation"):
+            if request.method == "POST":
                 response = self._studio_transcript_upload(request)
-            elif request.method == 'DELETE':
+            elif request.method == "DELETE":
                 response = self._studio_transcript_delete(request)
-            elif request.method == 'GET':
+            elif request.method == "GET":
                 response = self._studio_transcript_get(request)
             else:
                 # Any other HTTP method is not allowed.
@@ -461,22 +437,22 @@ def _studio_transcript_upload(self, request):
         Upload transcript. Used in "POST" method in `studio_transcript`
         """
         _ = self.runtime.service(self, "i18n").ugettext
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if not video_config_service:
-            return Response(json={'error': _('Runtime does not support transcripts.')}, status=400)
+            return Response(json={"error": _("Runtime does not support transcripts.")}, status=400)
         error = self.validate_transcript_upload_data(data=request.POST)
         if error:
-            return Response(json={'error': error}, status=400)
-        edx_video_id = (request.POST['edx_video_id'] or "").strip()
-        language_code = request.POST['language_code']
-        new_language_code = request.POST['new_language_code']
+            return Response(json={"error": error}, status=400)
+        edx_video_id = (request.POST["edx_video_id"] or "").strip()
+        language_code = request.POST["language_code"]
+        new_language_code = request.POST["new_language_code"]
         try:
             video_config_service.upload_transcript(
                 video_block=self,  # NOTE: .edx_video_id and .transcripts may get mutated
                 edx_video_id=edx_video_id,
                 language_code=language_code,
                 new_language_code=new_language_code,
-                transcript_file=request.POST['file'].file,
+                transcript_file=request.POST["file"].file,
             )
             return Response(
                 json.dumps(
@@ -489,12 +465,8 @@ def _studio_transcript_upload(self, request):
             )
         except (TranscriptsGenerationException, UnicodeDecodeError):
             return Response(
-                json={
-                    'error': _(
-                        'There is a problem with this transcript file. Try to upload a different file.'
-                    )
-                },
-                status=400
+                json={"error": _("There is a problem with this transcript file. Try to upload a different file.")},
+                status=400,
             )
 
     def _studio_transcript_delete(self, request):
@@ -502,16 +474,16 @@ def _studio_transcript_delete(self, request):
         Delete transcript. Used in "DELETE" method in `studio_transcript`
         """
         _ = self.runtime.service(self, "i18n").ugettext
-        video_config_service = self.runtime.service(self, 'video_config')
+        video_config_service = self.runtime.service(self, "video_config")
         if not video_config_service:
-            return Response(json={'error': _('Runtime does not support transcripts.')}, status=400)
+            return Response(json={"error": _("Runtime does not support transcripts.")}, status=400)
         request_data = request.json
-        if 'lang' not in request_data or 'edx_video_id' not in request_data:
+        if "lang" not in request_data or "edx_video_id" not in request_data:
             return Response(status=400)
         video_config_service.delete_transcript(
             video_block=self,
-            edx_video_id=request_data['edx_video_id'],
-            language_code=request_data['lang'],
+            edx_video_id=request_data["edx_video_id"],
+            language_code=request_data["lang"],
         )
         return Response(status=200)
 
@@ -520,29 +492,25 @@ def _studio_transcript_get(self, request):
         Get transcript. Used in "GET" method in `studio_transcript`
         """
         _ = self.runtime.service(self, "i18n").ugettext
-        language = request.GET.get('language_code')
+        language = request.GET.get("language_code")
         if not language:
-            return Response(json={'error': _('Language is required.')}, status=400)
+            return Response(json={"error": _("Language is required.")}, status=400)
 
         try:
-            video_config_service = self.runtime.service(self, 'video_config')
+            video_config_service = self.runtime.service(self, "video_config")
             if not video_config_service:
                 return Response(status=404)
             transcript_content, transcript_name, mime_type = video_config_service.get_transcript(
                 self, lang=language, output_format=TranscriptExtensions.SRT
             )
-            response = Response(transcript_content, headerlist=[
-                (
-                    'Content-Disposition',
-                    f'attachment; filename="{transcript_name}"'
-                ),
-                ('Content-Language', language),
-                ('Content-Type', mime_type)
-            ])
-        except (
-            UnicodeDecodeError,
-            TranscriptsGenerationException,
-            TranscriptNotFoundError
-        ):
+            response = Response(
+                transcript_content,
+                headerlist=[
+                    ("Content-Disposition", f'attachment; filename="{transcript_name}"'),
+                    ("Content-Language", language),
+                    ("Content-Type", mime_type),
+                ],
+            )
+        except (UnicodeDecodeError, TranscriptsGenerationException, TranscriptNotFoundError):
             response = Response(status=404)
         return response
diff --git a/xblocks_contrib/video/video_static_content_utils.py b/xblocks_contrib/video/video_static_content_utils.py
index d69d9d9c..67d385d3 100644
--- a/xblocks_contrib/video/video_static_content_utils.py
+++ b/xblocks_contrib/video/video_static_content_utils.py
@@ -18,9 +18,9 @@ def compute_location(course_key, path, revision=None, is_thumbnail=False):  # py
     - revision: is the object's revision information
     - is_thumbnail: is whether or not we want the thumbnail version of this asset
     """
-    path = path.replace('/', '_')
+    path = path.replace("/", "_")
     return course_key.make_asset_key(
-        'asset' if not is_thumbnail else 'thumbnail',
+        "asset" if not is_thumbnail else "thumbnail",
         AssetLocator.clean_keeping_underscores(path),
     ).for_branch(None)
 
@@ -33,9 +33,9 @@ def get_location_from_path(path):
         return AssetKey.from_string(path)
     except InvalidKeyError:
         # TODO - re-address this once LMS-11198 is tackled.
-        if path.startswith('/') or path.endswith('/'):
+        if path.startswith("/") or path.endswith("/"):
             # try stripping off the leading/trailing slash and try again
-            return AssetKey.from_string(path.strip('/'))
+            return AssetKey.from_string(path.strip("/"))
         return None
 
 
@@ -44,6 +44,6 @@ def serialize_asset_key_with_slash(asset_key):
     Legacy code expects the serialized asset key to start with a slash.
     """
     url = str(asset_key)
-    if not url.startswith('/'):
-        url = '/' + url  # TODO - re-address this once LMS-11198 is tackled.
+    if not url.startswith("/"):
+        url = "/" + url  # TODO - re-address this once LMS-11198 is tackled.
     return url
diff --git a/xblocks_contrib/video/video_transcripts_utils.py b/xblocks_contrib/video/video_transcripts_utils.py
index 8fd58a94..aa71aca4 100644
--- a/xblocks_contrib/video/video_transcripts_utils.py
+++ b/xblocks_contrib/video/video_transcripts_utils.py
@@ -3,7 +3,6 @@
 ++++++++++++++++++++++++++++++++++++++++++++++
 """
 
-
 import copy
 import logging
 
@@ -16,20 +15,21 @@
 
 log = logging.getLogger(__name__)
 
-NON_EXISTENT_TRANSCRIPT = 'non_existent_dummy_file_name'
+NON_EXISTENT_TRANSCRIPT = "non_existent_dummy_file_name"
 
 
 class TranscriptExtensions:
     """
     Video block transcript extensions.
     """
-    SRT = 'srt'
-    TXT = 'txt'
-    SJSON = 'sjson'
+
+    SRT = "srt"
+    TXT = "txt"
+    SJSON = "sjson"
     mime_types = {
-        SRT: 'application/x-subrip; charset=utf-8',
-        TXT: 'text/plain; charset=utf-8',
-        SJSON: 'application/json',
+        SRT: "application/x-subrip; charset=utf-8",
+        TXT: "text/plain; charset=utf-8",
+        SJSON: "application/json",
     }
 
 
@@ -38,18 +38,18 @@ def get_html5_ids(html5_sources):
     Helper method to parse out an HTML5 source into the ideas
     NOTE: This assumes that '/' are not in the filename
     """
-    html5_ids = [x.split('/')[-1].rsplit('.', 1)[0] for x in html5_sources]
+    html5_ids = [x.split("/")[-1].rsplit(".", 1)[0] for x in html5_sources]
     return html5_ids
 
 
-def subs_filename(subs_id, lang='en'):
+def subs_filename(subs_id, lang="en"):
     """
     Generate proper filename for storage.
     """
-    if lang == 'en':
-        return f'subs_{subs_id}.srt.sjson'
+    if lang == "en":
+        return f"subs_{subs_id}.srt.sjson"
     else:
-        return f'{lang}_subs_{subs_id}.srt.sjson'
+        return f"{lang}_subs_{subs_id}.srt.sjson"
 
 
 def clean_video_id(edx_video_id):
@@ -102,19 +102,19 @@ def get_default_transcript_language(self, transcripts, dest_lang=None):
             if resolved_transcript_dest_lang:
                 return resolved_transcript_dest_lang
             # language in plugin selector is english and empty transcripts or transcripts and sub exists
-            if dest_lang == 'en' and (not other_lang or (other_lang and sub)):
-                return 'en'
+            if dest_lang == "en" and (not other_lang or (other_lang and sub)):
+                return "en"
 
         if self.transcript_language in other_lang:
             return self.transcript_language
 
         if sub:
-            return 'en'
+            return "en"
 
         if len(other_lang) > 0:
             return sorted(other_lang)[0]
 
-        return 'en'
+        return "en"
 
     def get_transcripts_info(self, is_bumper=False):
         """
@@ -129,7 +129,7 @@ def get_transcripts_info(self, is_bumper=False):
         #       https://github.com/openedx/edx-platform/issues/36282
 
         if is_bumper:
-            transcripts = copy.deepcopy(get_bumper_settings(self).get('transcripts', {}))
+            transcripts = copy.deepcopy(get_bumper_settings(self).get("transcripts", {}))
             sub = transcripts.pop("en", "")
         else:
             transcripts = self.transcripts if self.transcripts else {}
@@ -138,7 +138,8 @@ def get_transcripts_info(self, is_bumper=False):
         # Only attach transcripts that are not empty.
         transcripts = {
             language_code: transcript_file
-            for language_code, transcript_file in transcripts.items() if transcript_file != ''
+            for language_code, transcript_file in transcripts.items()
+            if transcript_file != ""
         }
 
         # bumper transcripts are stored in content store so we don't need to include val transcripts
@@ -148,7 +149,7 @@ def get_transcripts_info(self, is_bumper=False):
             # transcript module and contentstore will only function as fallback until all the
             # data is migrated to edx-val.
             for language_code in transcript_languages:
-                if language_code == 'en' and not sub:
+                if language_code == "en" and not sub:
                     sub = NON_EXISTENT_TRANSCRIPT
                 elif not transcripts.get(language_code):
                     transcripts[language_code] = NON_EXISTENT_TRANSCRIPT
@@ -163,7 +164,7 @@ def resolve_language_code_to_transcript_code(transcripts, dest_lang):
     """
     Attempts to match the requested dest lang with the existing transcript languages
     """
-    sub, other_lang = transcripts["sub"], transcripts["transcripts"]  # pylint: disable=unused-variable
+    _, other_lang = transcripts["sub"], transcripts["transcripts"]
     # lang code exists in list of other transcript languages as-is
     if dest_lang in other_lang:
         return dest_lang
@@ -171,7 +172,7 @@ def resolve_language_code_to_transcript_code(transcripts, dest_lang):
     # Language codes can be base languages, 2-3 characters, or they can include a
     # locale (`fr` for french, `fr-ca` for canadian french). Sometimes the part after the
     # dash is capitalized, sometimes it is not. Check both variants.
-    dash_index = dest_lang.find('-')
+    dash_index = dest_lang.find("-")
     if dash_index >= 0:
         lowercase_dest_lang = dest_lang.lower()
         if lowercase_dest_lang in other_lang:
@@ -209,14 +210,14 @@ def get_endonym_or_label(language_code):
     # LANGUAGE_DICT
     try:
         lang_info = get_language_info(language_code)
-        return lang_info['name_local']
+        return lang_info["name_local"]
     except KeyError:
         pass
 
     # Last place to look is in settings.ALL_LANGUAGES. Ideally we find the actual code,
     # but also, check the 'generic' language. If even the generic language isn't found,
     # something is wrong, so log an error and throw an exception.
-    first_dash_index = language_code.find('-')
+    first_dash_index = language_code.find("-")
     generic_code = None if first_dash_index == -1 else language_code[:first_dash_index]
     potential_generic_label = None
     for code, language_label in settings.ALL_LANGUAGES:
diff --git a/xblocks_contrib/video/video_utils.py b/xblocks_contrib/video/video_utils.py
index 148553c2..64fec65a 100644
--- a/xblocks_contrib/video/video_utils.py
+++ b/xblocks_contrib/video/video_utils.py
@@ -2,7 +2,6 @@
 Module contains utils specific for video_block but not for transcripts.
 """
 
-
 import logging
 from collections import OrderedDict
 from urllib.parse import parse_qs, urlencode, urlparse, urlsplit, urlunsplit
@@ -23,19 +22,9 @@ def create_youtube_string(block):
     block.  Necessary for backwards compatibility with XML-based
     courses.
     """
-    youtube_ids = [
-        block.youtube_id_0_75,
-        block.youtube_id_1_0,
-        block.youtube_id_1_25,
-        block.youtube_id_1_5
-    ]
-    youtube_speeds = ['0.75', '1.00', '1.25', '1.50']
-    return ','.join([
-        ':'.join(pair)
-        for pair
-        in zip(youtube_speeds, youtube_ids)
-        if pair[1]
-    ])
+    youtube_ids = [block.youtube_id_0_75, block.youtube_id_1_0, block.youtube_id_1_25, block.youtube_id_1_5]
+    youtube_speeds = ["0.75", "1.00", "1.25", "1.50"]
+    return ",".join([":".join(pair) for pair in zip(youtube_speeds, youtube_ids) if pair[1]])
 
 
 def rewrite_video_url(cdn_base_url, original_video_url):
@@ -89,8 +78,8 @@ def get_poster(video):
     poster = OrderedDict({"url": "", "type": ""})
 
     if video.youtube_streams:
-        youtube_id = video.youtube_streams.split('1.00:')[1].split(',')[0]
-        poster["url"] = settings.YOUTUBE['IMAGE_API'].format(youtube_id=youtube_id)
+        youtube_id = video.youtube_streams.split("1.00:")[1].split(",")[0]
+        poster["url"] = settings.YOUTUBE["IMAGE_API"].format(youtube_id=youtube_id)
         poster["type"] = "youtube"
     else:
         poster["url"] = "https://www.edx.org/sites/default/files/theme/edx-logo-header.png"
@@ -105,9 +94,7 @@ def format_xml_exception_message(location, key, value):
     when setting xml attributes.
     """
     exception_message = "Block-location:{location}, Key:{key}, Value:{value}".format(
-        location=str(location),
-        key=key,
-        value=value
+        location=str(location), key=key, value=value
     )
     return exception_message
 
@@ -134,10 +121,10 @@ def load_metadata_from_youtube(video_id, request):
     """
     metadata = {}
     status_code = 500
-    if video_id and settings.YOUTUBE_API_KEY and settings.YOUTUBE_API_KEY != 'PUT_YOUR_API_KEY_HERE':
+    if video_id and settings.YOUTUBE_API_KEY and settings.YOUTUBE_API_KEY != "PUT_YOUR_API_KEY_HERE":
         yt_api_key = settings.YOUTUBE_API_KEY
-        yt_metadata_url = settings.YOUTUBE['METADATA_URL']
-        yt_timeout = settings.YOUTUBE.get('TEST_TIMEOUT', 1500) / 1000  # converting milli seconds to seconds
+        yt_metadata_url = settings.YOUTUBE["METADATA_URL"]
+        yt_timeout = settings.YOUTUBE.get("TEST_TIMEOUT", 1500) / 1000  # converting milli seconds to seconds
 
         headers = {}
         http_referer = None
@@ -145,42 +132,37 @@ def load_metadata_from_youtube(video_id, request):
         try:
             # This raises an attribute error if called from the xblock yt_video_metadata handler, which passes
             # a webob request instead of a django request.
-            http_referer = request.META.get('HTTP_REFERER')
+            http_referer = request.META.get("HTTP_REFERER")
         except AttributeError:
             # So here, let's assume it's a webob request and access the referer the webob way.
             http_referer = request.referer
 
         if http_referer:
-            headers['Referer'] = http_referer
+            headers["Referer"] = http_referer
 
-        payload = {'id': video_id, 'part': 'contentDetails', 'key': yt_api_key}
+        payload = {"id": video_id, "part": "contentDetails", "key": yt_api_key}
         try:
             res = requests.get(yt_metadata_url, params=payload, timeout=yt_timeout, headers=headers)
             status_code = res.status_code
             if res.status_code == 200:
                 try:
                     res_json = res.json()
-                    if res_json.get('items', []):
+                    if res_json.get("items", []):
                         metadata = res_json
                     else:
                         logging.warning(
-                            'Unable to find the items in response. Following response was received: %s',
-                            res.text
+                            "Unable to find the items in response. Following response was received: %s", res.text
                         )
                 except ValueError:
-                    logging.warning(
-                        'Unable to decode response to json. Following response was received: %s',
-                        res.text
-                    )
+                    logging.warning("Unable to decode response to json. Following response was received: %s", res.text)
             else:
                 logging.warning(
-                    'YouTube API request failed with status code=%s - Error message is=%s',
-                    status_code, res.text
+                    "YouTube API request failed with status code=%s - Error message is=%s", status_code, res.text
                 )
         except (Timeout, ConnectionError):
-            logging.warning('YouTube API request failed because of connection time out or connection error')
+            logging.warning("YouTube API request failed because of connection time out or connection error")
     else:
-        logging.warning('YouTube API key or video id is None. Please make sure API key and video id is not None')
+        logging.warning("YouTube API key or video id is None. Please make sure API key and video id is not None")
 
     return metadata, status_code
 
@@ -206,8 +188,8 @@ def get_resource_url(xblock, path, package_scope=None):
     pipeline_path = dev_path = f"public/{path}"
     if package_scope:
         pipeline_path = f"{package_scope}/{pipeline_path}"
-    pipeline = getattr(settings, 'PIPELINE', {})
-    if pipeline.get('PIPELINE_ENABLED', True) or not getattr(settings, 'REQUIRE_DEBUG', False):
+    pipeline = getattr(settings, "PIPELINE", {})
+    if pipeline.get("PIPELINE_ENABLED", True) or not getattr(settings, "REQUIRE_DEBUG", False):
         resource_path = pipeline_path
     else:
         resource_path = dev_path
@@ -221,6 +203,7 @@ def get_edxval_api():
     """
     try:
         import edxval.api as edxval_api  # pylint: disable=import-outside-toplevel
+
         return edxval_api
     except ImportError:
         return None
diff --git a/xblocks_contrib/video/video_xfields.py b/xblocks_contrib/video/video_xfields.py
index c823efe8..79588a63 100644
--- a/xblocks_contrib/video/video_xfields.py
+++ b/xblocks_contrib/video/video_xfields.py
@@ -1,8 +1,7 @@
-"""  # lint-amnesty, pylint: disable=cyclic-import
+"""# lint-amnesty, pylint: disable=cyclic-import
 XFields for video block.
 """
 
-
 import datetime
 
 from xblock.fields import Boolean, DateTime, Dict, Float, List, RelativeTime, Scope, String
@@ -16,19 +15,18 @@ def _(text):
 
 class VideoFields:
     """Fields for `VideoBlock`."""
+
     data = String(default="", scope=Scope.content)
 
     display_name = String(
         help=_("The display name for this component."),
         display_name=_("Component Display Name"),
         default="Video",
-        scope=Scope.settings
+        scope=Scope.settings,
     )
 
     saved_video_position = RelativeTime(
-        help=_("Current position in the video."),
-        scope=Scope.user_state,
-        default=datetime.timedelta(seconds=0)
+        help=_("Current position in the video."), scope=Scope.user_state, default=datetime.timedelta(seconds=0)
     )
     # TODO: This should be moved to Scope.content, but this will
     # require data migration to support the old video block.
@@ -36,25 +34,25 @@ class VideoFields:
         help=_("Optional, for older browsers: the YouTube ID for the normal speed video."),
         display_name=_("YouTube ID"),
         scope=Scope.settings,
-        default="3_yD_cEKoCk"
+        default="3_yD_cEKoCk",
     )
     youtube_id_0_75 = String(
         help=_("Optional, for older browsers: the YouTube ID for the .75x speed video."),
         display_name=_("YouTube ID for .75x speed"),
         scope=Scope.settings,
-        default=""
+        default="",
     )
     youtube_id_1_25 = String(
         help=_("Optional, for older browsers: the YouTube ID for the 1.25x speed video."),
         display_name=_("YouTube ID for 1.25x speed"),
         scope=Scope.settings,
-        default=""
+        default="",
     )
     youtube_id_1_5 = String(
         help=_("Optional, for older browsers: the YouTube ID for the 1.5x speed video."),
         display_name=_("YouTube ID for 1.5x speed"),
         scope=Scope.settings,
-        default=""
+        default="",
     )
     start_time = RelativeTime(  # datetime.timedelta object
         help=_(
@@ -64,7 +62,7 @@ class VideoFields:
         ),
         display_name=_("Video Start Time"),
         scope=Scope.settings,
-        default=datetime.timedelta(seconds=0)
+        default=datetime.timedelta(seconds=0),
     )
     end_time = RelativeTime(  # datetime.timedelta object
         help=_(
@@ -74,73 +72,85 @@ class VideoFields:
         ),
         display_name=_("Video Stop Time"),
         scope=Scope.settings,
-        default=datetime.timedelta(seconds=0)
+        default=datetime.timedelta(seconds=0),
     )
     # front-end code of video player checks logical validity of (start_time, end_time) pair.
 
     download_video = Boolean(
-        help=_("Allow students to download versions of this video in different formats if they cannot use the edX video"
-               " player or do not have access to YouTube. You must add at least one non-YouTube URL "
-               "in the Video File URLs field."),
+        help=_(
+            "Allow students to download versions of this video in different formats if they cannot use the edX video"
+            " player or do not have access to YouTube. You must add at least one non-YouTube URL "
+            "in the Video File URLs field."
+        ),
         display_name=_("Video Download Allowed"),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
     html5_sources = List(
-        help=_("The URL or URLs where you've posted non-YouTube versions of the video. Each URL must end in .mpeg,"
-               " .mp4, .ogg, or .webm and cannot be a YouTube URL. (For browser compatibility, we strongly recommend"
-               " .mp4 and .webm format.) Students will be able to view the first listed video that's compatible with"
-               " the student's computer. To allow students to download these videos, "
-               "set Video Download Allowed to True."),
+        help=_(
+            "The URL or URLs where you've posted non-YouTube versions of the video. Each URL must end in .mpeg,"
+            " .mp4, .ogg, or .webm and cannot be a YouTube URL. (For browser compatibility, we strongly recommend"
+            " .mp4 and .webm format.) Students will be able to view the first listed video that's compatible with"
+            " the student's computer. To allow students to download these videos, "
+            "set Video Download Allowed to True."
+        ),
         display_name=_("Video File URLs"),
         scope=Scope.settings,
     )
     track = String(
-        help=_("By default, students can download an .srt or .txt transcript when you set Download Transcript "
-               "Allowed to True. If you want to provide a downloadable transcript in a different format, we recommend "
-               "that you upload a handout by using the Upload a Handout field. If this isn't possible, you can post a "
-               "transcript file on the Files & Uploads page or on the Internet, and then add the URL for the "
-               "transcript here. Students see a link to download that transcript below the video."),
+        help=_(
+            "By default, students can download an .srt or .txt transcript when you set Download Transcript "
+            "Allowed to True. If you want to provide a downloadable transcript in a different format, we recommend "
+            "that you upload a handout by using the Upload a Handout field. If this isn't possible, you can post a "
+            "transcript file on the Files & Uploads page or on the Internet, and then add the URL for the "
+            "transcript here. Students see a link to download that transcript below the video."
+        ),
         display_name=_("Downloadable Transcript URL"),
         scope=Scope.settings,
-        default=''
+        default="",
     )
     download_track = Boolean(
-        help=_("Allow students to download the timed transcript. A link to download the file appears below the video."
-               " By default, the transcript is an .srt or .txt file. If you want to provide the transcript for "
-               "download in a different format, upload a file by using the Upload Handout field."),
+        help=_(
+            "Allow students to download the timed transcript. A link to download the file appears below the video."
+            " By default, the transcript is an .srt or .txt file. If you want to provide the transcript for "
+            "download in a different format, upload a file by using the Upload Handout field."
+        ),
         display_name=_("Download Transcript Allowed"),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
     # `sub` is deprecated field and should not be used in future. Now, transcripts are primarily handled in VAL and
     # backward compatibility for the video blocks already using this field has been ensured.
     sub = String(
-        help=_("The default transcript for the video, from the Default Timed Transcript field on the Basic tab. "
-               "This transcript should be in English. You don't have to change this setting."),
+        help=_(
+            "The default transcript for the video, from the Default Timed Transcript field on the Basic tab. "
+            "This transcript should be in English. You don't have to change this setting."
+        ),
         display_name=_("Default Timed Transcript"),
         scope=Scope.settings,
-        default=""
+        default="",
     )
     show_captions = Boolean(
         help=_("Specify whether the transcripts appear with the video by default."),
         display_name=_("Show Transcript"),
         scope=Scope.settings,
-        default=True
+        default=True,
     )
     # Data format: {'de': 'german_translation', 'uk': 'ukrainian_translation'}
     transcripts = Dict(
-        help=_("Add transcripts in different languages."
-               " Click below to specify a language and upload an .srt transcript file for that language."),
+        help=_(
+            "Add transcripts in different languages."
+            " Click below to specify a language and upload an .srt transcript file for that language."
+        ),
         display_name=_("Transcript Languages"),
         scope=Scope.settings,
-        default={}
+        default={},
     )
     transcript_language = String(
         help=_("Preferred language for transcript."),
         display_name=_("Preferred language for transcript"),
         scope=Scope.preferences,
-        default="en"
+        default="en",
     )
     transcript_download_format = String(
         help=_("Transcript file format to download by user."),
@@ -148,19 +158,12 @@ class VideoFields:
         values=[
             # Translators: This is a type of file used for captioning in the video player.
             {"display_name": _("SubRip (.srt) file"), "value": "srt"},
-            {"display_name": _("Text (.txt) file"), "value": "txt"}
+            {"display_name": _("Text (.txt) file"), "value": "txt"},
         ],
-        default='srt',
-    )
-    speed = Float(
-        help=_("The last speed that the user specified for the video."),
-        scope=Scope.user_state
-    )
-    global_speed = Float(
-        help=_("The default speed for the video."),
-        scope=Scope.preferences,
-        default=1.0
+        default="srt",
     )
+    speed = Float(help=_("The last speed that the user specified for the video."), scope=Scope.user_state)
+    global_speed = Float(help=_("The default speed for the video."), scope=Scope.preferences, default=1.0)
     auto_advance = Boolean(
         help=_("Specify whether to advance automatically to the next unit when the video ends."),
         scope=Scope.preferences,
@@ -171,13 +174,13 @@ class VideoFields:
         default=True,
     )
     youtube_is_available = Boolean(
-        help=_("Specify whether YouTube is available for the user."),
-        scope=Scope.user_info,
-        default=True
+        help=_("Specify whether YouTube is available for the user."), scope=Scope.user_info, default=True
     )
     handout = String(
-        help=_("Upload a handout to accompany this video. Students can download the handout by "
-               "clicking Download Handout under the video."),
+        help=_(
+            "Upload a handout to accompany this video. Students can download the handout by "
+            "clicking Download Handout under the video."
+        ),
         display_name=_("Upload Handout"),
         scope=Scope.settings,
     )
@@ -188,13 +191,15 @@ class VideoFields:
         ),
         display_name=_("Video Available on Web Only"),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
     edx_video_id = String(
-        help=_("If you were assigned a Video ID by edX for the video to play in this component, enter the ID here."
-               " In this case, do not enter values in the Default Video URL, the Video File URLs, "
-               "and the YouTube ID fields. If you were not assigned a Video ID,"
-               " enter values in those other fields and ignore this field."),
+        help=_(
+            "If you were assigned a Video ID by edX for the video to play in this component, enter the ID here."
+            " In this case, do not enter values in the Default Video URL, the Video File URLs, "
+            "and the YouTube ID fields. If you were not assigned a Video ID,"
+            " enter values in those other fields and ignore this field."
+        ),
         display_name=_("Video ID"),
         scope=Scope.settings,
         default="",
@@ -212,7 +217,7 @@ class VideoFields:
         help=_("Specify whether the video can be accessed publicly by learners."),
         display_name=_("Public Access"),
         scope=Scope.settings,
-        default=False
+        default=False,
     )
     # thumbnail is need as a field for the new video editor. The field is hidden in
     # the legacy modal.
diff --git a/xblocks_contrib/word_cloud/__init__.py b/xblocks_contrib/word_cloud/__init__.py
index f4ed3cab..4ae1aa5f 100644
--- a/xblocks_contrib/word_cloud/__init__.py
+++ b/xblocks_contrib/word_cloud/__init__.py
@@ -1,4 +1,3 @@
-"""Word cloud is ungraded xblock used by students to generate and view word cloud.
-"""
+"""Word cloud is ungraded xblock used by students to generate and view word cloud."""
 
-from .word_cloud import WordCloudBlock
+from .word_cloud import WordCloudBlock as WordCloudBlock
diff --git a/xblocks_contrib/word_cloud/tests/test_word_cloud.py b/xblocks_contrib/word_cloud/tests/test_word_cloud.py
index acbd4cdb..0a92e64c 100644
--- a/xblocks_contrib/word_cloud/tests/test_word_cloud.py
+++ b/xblocks_contrib/word_cloud/tests/test_word_cloud.py
@@ -58,15 +58,15 @@ def test_get_state_submitted(self):
         self.assertTrue(state["submitted"])
         self.assertEqual(
             state["top_words"],
-            [{'text': 'Banana', 'size': 21, 'percent': 29}, {'text': 'Strawberry', 'size': 28, 'percent': 71}]
+            [{"text": "Banana", "size": 21, "percent": 29}, {"text": "Strawberry", "size": 28, "percent": 71}],
         )
-        self.assertEqual(state['total_count'], 73)
+        self.assertEqual(state["total_count"], 73)
 
     def test_submit_state_first_time(self):
         self.block.submitted = False
         data = {"student_words": ["hello", "world", "hello"]}
         response = self.block.submit_state(data)
-        self.assertEqual(response['status'], 'success')
+        self.assertEqual(response["status"], "success")
         self.assertTrue(self.block.submitted)
         self.assertEqual(self.block.student_words, ["hello", "world", "hello"])
         self.assertEqual(self.block.all_words["hello"], 2)
diff --git a/xblocks_contrib/word_cloud/word_cloud.py b/xblocks_contrib/word_cloud/word_cloud.py
index 1d28a96f..f2d86a91 100644
--- a/xblocks_contrib/word_cloud/word_cloud.py
+++ b/xblocks_contrib/word_cloud/word_cloud.py
@@ -5,6 +5,7 @@
 If student does not yet answered - `num_inputs` numbers of text inputs.
 If student have answered - words he entered and cloud.
 """
+
 import uuid
 
 from django.utils.translation import gettext_noop as _
@@ -40,7 +41,7 @@ class WordCloudBlock(StudioEditableXBlockMixin, LegacyXmlMixin, XBlock):
     is_extracted = True
     # "data" class attribute is added to make the following test case pass in edx-platform repo.
     # cms/djangoapps/contentstore/tests/test_contentstore.py::ImportRequiredTestCases::test_empty_data_roundtrip
-    data = String(default='', scope=Scope.content)
+    data = String(default="", scope=Scope.content)
 
     editable_fields = ["display_name", "num_inputs", "instructions", "num_top_words", "display_student_percents"]
 
@@ -48,13 +49,14 @@ class WordCloudBlock(StudioEditableXBlockMixin, LegacyXmlMixin, XBlock):
         display_name=_("Display Name"),
         help=_("The display name for this component."),
         scope=Scope.settings,
-        default="Word cloud"
+        default="Word cloud",
     )
     instructions = String(
         display_name=_("Instructions"),
         help=_(
             "Add instructions to help learners understand how to use the word cloud. Clear instructions are "
-            "important, especially for learners who have accessibility requirements."),
+            "important, especially for learners who have accessibility requirements."
+        ),
         scope=Scope.settings,
     )
     num_inputs = Integer(
@@ -62,41 +64,29 @@ class WordCloudBlock(StudioEditableXBlockMixin, LegacyXmlMixin, XBlock):
         help=_("The number of text boxes available for learners to add words and sentences."),
         scope=Scope.settings,
         default=5,
-        values={"min": 1}
+        values={"min": 1},
     )
     num_top_words = Integer(
         display_name=_("Maximum Words"),
         help=_("The maximum number of words displayed in the generated word cloud."),
         scope=Scope.settings,
         default=250,
-        values={"min": 1}
+        values={"min": 1},
     )
     display_student_percents = Boolean(
         display_name=_("Show Percents"),
         help=_("Statistics are shown for entered words near that word."),
         scope=Scope.settings,
-        default=True
+        default=True,
     )
 
     # Fields for descriptor.
     submitted = Boolean(
-        help=_("Whether this learner has posted words to the cloud."),
-        scope=Scope.user_state,
-        default=False
-    )
-    student_words = List(
-        help=_("Student answer."),
-        scope=Scope.user_state,
-        default=[]
-    )
-    all_words = Dict(
-        help=_("All possible words from all learners."),
-        scope=Scope.user_state_summary
-    )
-    top_words = Dict(
-        help=_("Top num_top_words words for word cloud."),
-        scope=Scope.user_state_summary
+        help=_("Whether this learner has posted words to the cloud."), scope=Scope.user_state, default=False
     )
+    student_words = List(help=_("Student answer."), scope=Scope.user_state, default=[])
+    all_words = Dict(help=_("All possible words from all learners."), scope=Scope.user_state_summary)
+    top_words = Dict(help=_("Top num_top_words words for word cloud."), scope=Scope.user_state_summary)
 
     @staticmethod
     def workbench_scenarios():
@@ -123,24 +113,27 @@ def student_view(self, context=None):  # pylint: disable=W0613
         Create primary view of the WordCloudXBlock, shown to students when viewing courses.
         """
         frag = Fragment()
-        frag.add_content(resource_loader.render_django_template(
-            "templates/word_cloud.html", {
-                'display_name': self.display_name,
-                'instructions': self.instructions,
-                'element_class': self.scope_ids.block_type,
-                'element_id': uuid.uuid1(0),
-                'num_inputs': self.num_inputs,
-                'range_num_inputs': range(self.num_inputs),
-                'submitted': self.submitted,
-            },
-            i18n_service=self.runtime.service(self, 'i18n')
-        ))
+        frag.add_content(
+            resource_loader.render_django_template(
+                "templates/word_cloud.html",
+                {
+                    "display_name": self.display_name,
+                    "instructions": self.instructions,
+                    "element_class": self.scope_ids.block_type,
+                    "element_id": uuid.uuid1(0),
+                    "num_inputs": self.num_inputs,
+                    "range_num_inputs": range(self.num_inputs),
+                    "submitted": self.submitted,
+                },
+                i18n_service=self.runtime.service(self, "i18n"),
+            )
+        )
         frag.add_css(resource_loader.load_unicode("static/css/word_cloud.css"))
         frag.add_javascript(resource_loader.load_unicode("static/js/src/word_cloud.js"))
         frag.add_javascript(resource_loader.load_unicode("static/js/src/d3.min.js"))
         frag.add_javascript(resource_loader.load_unicode("static/js/src/d3.layout.cloud.js"))
         frag.add_javascript(resource_loader.load_unicode("static/js/src/html_utils.js"))
-        frag.initialize_js('WordCloudBlock')
+        frag.initialize_js("WordCloudBlock")
         return frag
 
     def good_word(self, word):
@@ -157,42 +150,32 @@ def top_dict(self, dict_obj, amount):
         :type amount: int
         :rtype: dict
         """
-        return dict(
-            sorted(
-                list(dict_obj.items()),
-                key=lambda x: x[1],
-                reverse=True
-            )[:amount]
-        )
+        return dict(sorted(list(dict_obj.items()), key=lambda x: x[1], reverse=True)[:amount])
 
     def get_state(self):
         """Return success json answer for client."""
         if self.submitted:
             total_count = sum(self.all_words.values())
             return {
-                'status': 'success',
-                'submitted': True,
-                'display_student_percents': pretty_bool(
-                    self.display_student_percents
-                ),
-                'student_words': {
-                    word: self.all_words[word] for word in self.student_words
-                },
-                'total_count': total_count,
-                'top_words': self.prepare_words(self.top_words, total_count),
+                "status": "success",
+                "submitted": True,
+                "display_student_percents": pretty_bool(self.display_student_percents),
+                "student_words": {word: self.all_words[word] for word in self.student_words},
+                "total_count": total_count,
+                "top_words": self.prepare_words(self.top_words, total_count),
             }
         else:
             return {
-                'status': 'success',
-                'submitted': False,
-                'display_student_percents': False,
-                'student_words': {},
-                'total_count': 0,
-                'top_words': {}
+                "status": "success",
+                "submitted": False,
+                "display_student_percents": False,
+                "student_words": {},
+                "total_count": 0,
+                "top_words": {},
             }
 
     @XBlock.json_handler
-    def handle_get_state(self, data, suffix=''):  # pylint: disable=unused-argument
+    def handle_get_state(self, data, suffix=""):  # pylint: disable=unused-argument
         """
         AJAX handler to get the current state of the XBlock
 
@@ -205,10 +188,10 @@ def handle_get_state(self, data, suffix=''):  # pylint: disable=unused-argument
         return self.get_state()
 
     @XBlock.json_handler
-    def handle_submit_state(self, data, suffix=''):  # pylint: disable=unused-argument
+    def handle_submit_state(self, data, suffix=""):  # pylint: disable=unused-argument
         return self.submit_state(data)
 
-    def submit_state(self, data, suffix=''):  # pylint: disable=unused-argument
+    def submit_state(self, data, suffix=""):  # pylint: disable=unused-argument
         """
         AJAX handler to submit the current state of the XBlock
 
@@ -220,14 +203,11 @@ def submit_state(self, data, suffix=''):  # pylint: disable=unused-argument
         """
 
         if self.submitted:
-            return {
-                'status': 'fail',
-                'error': 'You have already posted your data.'
-            }
+            return {"status": "fail", "error": "You have already posted your data."}
 
         # Student words from client.
         # FIXME: we must use raw JSON, not a post data (multipart/form-data)
-        raw_student_words = data.get('student_words')
+        raw_student_words = data.get("student_words")
         student_words = [word for word in map(self.good_word, raw_student_words) if word]
 
         self.student_words = student_words
@@ -244,10 +224,7 @@ def submit_state(self, data, suffix=''):  # pylint: disable=unused-argument
             temp_all_words[word] = temp_all_words.get(word, 0) + 1
 
         # Update top_words.
-        self.top_words = self.top_dict(
-            temp_all_words,
-            self.num_top_words
-        )
+        self.top_words = self.top_dict(temp_all_words, self.num_top_words)
 
         # Save all_words in database.
         self.all_words = temp_all_words
@@ -279,13 +256,7 @@ def prepare_words(self, top_words, total_count):
             else:
                 percent = round((100.0 * word_tuple[1]) / total_count)
                 percents += percent
-            list_to_return.append(
-                {
-                    'text': word_tuple[0],
-                    'size': word_tuple[1],
-                    'percent': percent
-                }
-            )
+            list_to_return.append({"text": word_tuple[0], "size": word_tuple[1], "percent": percent})
         return list_to_return
 
     def index_dictionary(self):
@@ -315,8 +286,8 @@ def index_dictionary(self):
     @classmethod
     def definition_from_xml(cls, xml_object, system):
         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):
         if self.data: