diff --git a/_ui_tests/conftest.py b/_ui_tests/conftest.py
index 51d1b2a32..47a418bc8 100644
--- a/_ui_tests/conftest.py
+++ b/_ui_tests/conftest.py
@@ -27,6 +27,5 @@ def pytest_runtest_makereport(item, call):
     fails, ie whenever the method throws an exception
     """
     if call.excinfo is not None:
-        if driver_register.get_driver() is not None and hasattr(item, 'obj'):
-            driver_register.get_driver().get_screenshot_as_file(
-                str(item.obj).split(" ")[2] + '.png')
+        if driver_register.get_driver() is not None and hasattr(item, "obj"):
+            driver_register.get_driver().get_screenshot_as_file(str(item.obj).split(" ")[2] + ".png")
diff --git a/_ui_tests/test_subitems.py b/_ui_tests/test_subitems.py
index 7d1569215..fca728b32 100644
--- a/_ui_tests/test_subitems.py
+++ b/_ui_tests/test_subitems.py
@@ -24,10 +24,8 @@ def create_wiki_item(self, item_name):
         driver.get(self.base_url + "/" + item_name)
         driver.find_element_by_link_text("Default").click()
         driver.find_element_by_link_text("Wiki (MoinMoin)").click()
-        driver.find_element_by_link_text(
-            "create the item from scratch").click()
-        driver.find_element_by_id("f_content_form_data_text").send_keys(
-            "This is a test item\n")
+        driver.find_element_by_link_text("create the item from scratch").click()
+        driver.find_element_by_id("f_content_form_data_text").send_keys("This is a test item\n")
         driver.find_element_by_id("f_submit").click()
 
     def test_createsubitem(self):
@@ -38,26 +36,23 @@ def test_createsubitem(self):
 
         driver.get(self.base_url + "/" + self.base_item_name)
         driver.find_element_by_link_text("Modify").click()
-        driver.find_element_by_id("f_content_form_data_text").send_keys(
-            "\n[[/" + self.subitem_name + "]]\n")
+        driver.find_element_by_id("f_content_form_data_text").send_keys("\n[[/" + self.subitem_name + "]]\n")
         driver.find_element_by_id("f_submit").click()
         driver.find_element_by_link_text("/" + self.subitem_name).click()
         driver.find_element_by_link_text("Default").click()
         driver.find_element_by_link_text("Wiki (MoinMoin)").click()
         driver.find_element_by_link_text("create the item from scratch").click()
-        driver.find_element_by_id("f_content_form_data_text").send_keys(
-            "This is a test subitem")
+        driver.find_element_by_id("f_content_form_data_text").send_keys("This is a test subitem")
         driver.find_element_by_id("f_submit").click()
-        assert "This is a test subitem" in driver.find_element_by_id(
-            "moin-content-data").text
-        assert driver.title.split(" - ")[0] == self.base_item_name + \
-            "/" + self.subitem_name
+        assert "This is a test subitem" in driver.find_element_by_id("moin-content-data").text
+        assert driver.title.split(" - ")[0] == self.base_item_name + "/" + self.subitem_name
 
     def teardown_class(self):
         """shuts down browser"""
         self.driver.quit()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     # This lets us run the test directly, without using pytest
     # This is useful for example for being able to call help, eg
     # 'help(driver)', or 'help(driver.find_element_by_id("f_submit"))'
diff --git a/_ui_tests/utils.py b/_ui_tests/utils.py
index 5684723a8..00b6be3bc 100644
--- a/_ui_tests/utils.py
+++ b/_ui_tests/utils.py
@@ -9,7 +9,7 @@
 
 import pytest
 
-pytest.importorskip('selenium')
+pytest.importorskip("selenium")
 webdriver = selenium.webdriver  # noqa
 
 import config
@@ -17,7 +17,7 @@
 try:
     f = urllib.request.urlopen(config.BASE_URL)
 except OSError:
-    pytestmark = pytest.mark.skip('The UI tests need a wiki server running on %s' % config.BASE_URL)
+    pytestmark = pytest.mark.skip("The UI tests need a wiki server running on %s" % config.BASE_URL)
 
 import driver_register
 
@@ -41,7 +41,7 @@ def generate_random_word(length):
     """
     generates a random string containing numbers, of length 'length'
     """
-    word = str(random.randint(10 ** (length - 1), 10 ** length))
+    word = str(random.randint(10 ** (length - 1), 10**length))
     return word
 
 
diff --git a/contrib/loadtesting/locust/locustfile.py b/contrib/loadtesting/locust/locustfile.py
index ab77386d6..ffb61dec9 100644
--- a/contrib/loadtesting/locust/locustfile.py
+++ b/contrib/loadtesting/locust/locustfile.py
@@ -75,6 +75,7 @@
 # sleep time between GET, POST requests in seconds
 sleep_time = 0
 
+
 class LoadTest(HttpUser):
     """
     First, create a Home page in the default and user namespaces.
@@ -98,37 +99,45 @@ def on_test_start(environment, **kwargs):
                 host = host[:-1]
 
             print("==== creating Home and users/Home ====")
-            url = host + "/+modify/users/Home?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-            data = urllib.parse.urlencode({"content_form_data_text": "= users/Home =\n * created by Locust",
-                                           "comment": "",
-                                           "submit": "OK",
-                                           "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                                           "meta_form_itemtype": "default",
-                                           "meta_form_acl": "None",
-                                           "meta_form_tags": "None",
-                                           "meta_form_name": "Home",
-                                           "extra_meta_text": '{"namespace": "users","rev_number": 1}',
-                                           })
+            url = (
+                host + "/+modify/users/Home?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+            )
+            data = urllib.parse.urlencode(
+                {
+                    "content_form_data_text": "= users/Home =\n * created by Locust",
+                    "comment": "",
+                    "submit": "OK",
+                    "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                    "meta_form_itemtype": "default",
+                    "meta_form_acl": "None",
+                    "meta_form_tags": "None",
+                    "meta_form_name": "Home",
+                    "extra_meta_text": '{"namespace": "users","rev_number": 1}',
+                }
+            )
             data = data.encode("utf-8")
             content = urllib.request.urlopen(url=url, data=data).read()
 
             url = host + "/+modify/Home?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-            data = urllib.parse.urlencode({"content_form_data_text": "= Home =\n * created by Locust",
-                                           "comment": "",
-                                           "submit": "OK",
-                                           "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                                           "meta_form_itemtype": "default",
-                                           "meta_form_acl": "None",
-                                           "meta_form_tags": "None",
-                                           "meta_form_name": "Home",
-                                           "extra_meta_text": '{"namespace": "","rev_number": 1}',
-                                           })
+            data = urllib.parse.urlencode(
+                {
+                    "content_form_data_text": "= Home =\n * created by Locust",
+                    "comment": "",
+                    "submit": "OK",
+                    "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                    "meta_form_itemtype": "default",
+                    "meta_form_acl": "None",
+                    "meta_form_tags": "None",
+                    "meta_form_name": "Home",
+                    "extra_meta_text": '{"namespace": "","rev_number": 1}',
+                }
+            )
             data = data.encode("utf-8")
             content = urllib.request.urlopen(url=url, data=data).read()
 
     @task(1)
     def user_workflow(self):
-        """Define workflow for each locust """
+        """Define workflow for each locust"""
         self.get_home()
         self.click_login()
         self.click_post_register()
@@ -165,12 +174,16 @@ def click_register(self):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
     def click_post_register(self):
-        with self.client.post("/+register",
-                              {"register_username": self.user_name,
-                               "register_password1": "locust123",
-                               "register_password2": "locust123",
-                               "register_email": self.user_email,
-                              }, catch_response=True) as response:
+        with self.client.post(
+            "/+register",
+            {
+                "register_username": self.user_name,
+                "register_password1": "locust123",
+                "register_password2": "locust123",
+                "register_email": self.user_email,
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -180,12 +193,16 @@ def click_login_again(self):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
     def click_post_login(self):
-        with self.client.post("/+login",
-                              {"login_username": self.user_name,
-                               "login_password": "locust123",
-                               "login_submit": "1",
-                               "login_nexturl": "/Home",
-                              }, catch_response=True) as response:
+        with self.client.post(
+            "/+login",
+            {
+                "login_username": self.user_name,
+                "login_password": "locust123",
+                "login_submit": "1",
+                "login_nexturl": "/Home",
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -195,26 +212,39 @@ def create_home_page(self):
             if response.status_code == 404:
                 response.success()
             else:
-                print("%s: Starting wiki not empty, user's home page already exists: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
+                print(
+                    "%s: Starting wiki not empty, user's home page already exists: response.status_code = %s"
+                    % (sys._getframe().f_lineno, response.status_code)
+                )
         # click MoinMoin markup link
-        home_page_get = "/+modify/users/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default"
+        home_page_get = (
+            "/+modify/users/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default"
+        )
         with self.client.get(home_page_get, catch_response=True) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
         # complete form and post
         new_content = "= %s =\n\nMy Home Page created by Locust" % self.user_name
-        home_page_post = "/+modify/users/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-        with self.client.post(home_page_post,
-                              {"content_form_data_text": new_content,
-                               "comment": "my comment",
-                               "submit": "OK",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "apple, pear",
-                               "meta_form_name": self.user_name,
-                               "extra_meta_text": '{"namespace": "users","rev_number": 1}',
-                              }, catch_response=True) as response:
+        home_page_post = (
+            "/+modify/users/"
+            + self.user_name
+            + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        )
+        with self.client.post(
+            home_page_post,
+            {
+                "content_form_data_text": new_content,
+                "comment": "my comment",
+                "submit": "OK",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "apple, pear",
+                "meta_form_name": self.user_name,
+                "extra_meta_text": '{"namespace": "users","rev_number": 1}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -224,22 +254,30 @@ def modify_home_page(self, idx):
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
         # click modify link
-        home_page = "/+modify" + self.user_home_page + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        home_page = (
+            "/+modify"
+            + self.user_home_page
+            + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        )
         with self.client.get(home_page, catch_response=True) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
         # update the page
-        with self.client.post(home_page,
-                              {"content_form_data_text": test_content % (self.user_name, self.get_time() + " idx=%s" % idx),
-                               "comment": "my homepage comment",
-                               "submit": "OK",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "apple, pear",
-                               "meta_form_name": self.user_name,
-                               "extra_meta_text": '{"namespace": "users","rev_number":1}',
-                              }, catch_response=True) as response:
+        with self.client.post(
+            home_page,
+            {
+                "content_form_data_text": test_content % (self.user_name, self.get_time() + " idx=%s" % idx),
+                "comment": "my homepage comment",
+                "submit": "OK",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "apple, pear",
+                "meta_form_name": self.user_name,
+                "extra_meta_text": '{"namespace": "users","rev_number":1}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -250,7 +288,10 @@ def create_new_page(self):
             if response.status_code == 404:
                 response.success()
             else:
-                print("%s: Item already exists, starting wiki not empty: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
+                print(
+                    "%s: Item already exists, starting wiki not empty: response.status_code = %s"
+                    % (sys._getframe().f_lineno, response.status_code)
+                )
         # click MoinMoin markup link
         page_get = "/+modify/" + new_item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default"
         with self.client.get(page_get, catch_response=True) as response:
@@ -258,18 +299,24 @@ def create_new_page(self):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
         # complete form and post
         new_content = "= %s =\n\nNew Item created by Locust" % new_item_name
-        new_page_post = "/+modify/" + new_item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-        with self.client.post(new_page_post,
-                              {"content_form_data_text": new_content,
-                               "comment": "yes",
-                               "submit": "OK",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "lime, orange",
-                               "meta_form_name": new_item_name,
-                               "extra_meta_text": '{"namespace": "","rev_number": 1}',
-                              }, catch_response=True) as response:
+        new_page_post = (
+            "/+modify/" + new_item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        )
+        with self.client.post(
+            new_page_post,
+            {
+                "content_form_data_text": new_content,
+                "comment": "yes",
+                "submit": "OK",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "lime, orange",
+                "meta_form_name": new_item_name,
+                "extra_meta_text": '{"namespace": "","rev_number": 1}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -286,18 +333,24 @@ def modify_new_page(self, idx):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
         # complete form and post
         new_content = "= %s =\n\nNew Item created by Locust" % new_item_name
-        new_page_post = "/+modify/" + new_item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-        with self.client.post(new_page_post,
-                              {"content_form_data_text": test_content % (self.user_name, self.get_time() + " idx=%s" % idx),
-                               "comment": "yes",
-                               "submit": "OK",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "lime, orange",
-                               "meta_form_name": new_item_name,
-                               "extra_meta_text": '{"namespace": "","rev_number": 1}',
-                              }, catch_response=True) as response:
+        new_page_post = (
+            "/+modify/" + new_item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        )
+        with self.client.post(
+            new_page_post,
+            {
+                "content_form_data_text": test_content % (self.user_name, self.get_time() + " idx=%s" % idx),
+                "comment": "yes",
+                "submit": "OK",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "lime, orange",
+                "meta_form_name": new_item_name,
+                "extra_meta_text": '{"namespace": "","rev_number": 1}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
diff --git a/contrib/loadtesting/locust/locustfile2.py b/contrib/loadtesting/locust/locustfile2.py
index b5e5f7852..d2c4d6dc8 100644
--- a/contrib/loadtesting/locust/locustfile2.py
+++ b/contrib/loadtesting/locust/locustfile2.py
@@ -44,7 +44,6 @@
     * refresh browser window
 """
 
-
 import sys
 import argparse
 import urllib.request, urllib.parse, urllib.error
@@ -61,6 +60,7 @@
 # sleep time between GET, POST requests in seconds
 sleep_time = 0
 
+
 def get_textarea(html):
     """Return contents of textarea where html is html output from +modify"""
     try:
@@ -71,6 +71,7 @@ def get_textarea(html):
         html_ = "Error: malformed html = " + html
     return html_
 
+
 def format_date_time(dt=None):
     """Return current or passed (dt) time in a human readable format."""
     if dt is None:
@@ -97,16 +98,19 @@ def on_test_start(environment, **kwargs):
                 host = host[:-1]
             print("==== creating Home item ====")
             url = host + "/+modify/Home?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-            data = urllib.parse.urlencode({"content_form_data_text": "= Home =\n * created by Locust",
-                                          "comment": "",
-                                          "submit": "OK",
-                                          "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                                          "meta_form_itemtype": "default",
-                                          "meta_form_acl": "None",
-                                          "meta_form_tags": "None",
-                                          "meta_form_name": "Home",
-                                          "extra_meta_text": '{"namespace": "","rev_number": 1}',
-                                          })
+            data = urllib.parse.urlencode(
+                {
+                    "content_form_data_text": "= Home =\n * created by Locust",
+                    "comment": "",
+                    "submit": "OK",
+                    "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                    "meta_form_itemtype": "default",
+                    "meta_form_acl": "None",
+                    "meta_form_tags": "None",
+                    "meta_form_name": "Home",
+                    "extra_meta_text": '{"namespace": "","rev_number": 1}',
+                }
+            )
             data = data.encode("utf-8")
             content = urllib.request.urlopen(url=url, data=data).read()
 
@@ -157,12 +161,16 @@ def click_register(self):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
     def click_post_register(self):
-        with self.client.post("/+register",
-                              {"register_username": self.user_name,
-                               "register_password1": "locust123",
-                               "register_password2": "locust123",
-                               "register_email": self.user_email,
-                              }, catch_response=True) as response:
+        with self.client.post(
+            "/+register",
+            {
+                "register_username": self.user_name,
+                "register_password1": "locust123",
+                "register_password2": "locust123",
+                "register_email": self.user_email,
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -172,12 +180,16 @@ def click_login_again(self):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
     def click_post_login(self):
-        with self.client.post("/+login",
-                              {"login_username": self.user_name,
-                               "login_password": "locust123",
-                               "login_submit": "1",
-                               "login_nexturl": "/Home",
-                              }, catch_response=True) as response:
+        with self.client.post(
+            "/+login",
+            {
+                "login_username": self.user_name,
+                "login_password": "locust123",
+                "login_submit": "1",
+                "login_nexturl": "/Home",
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -201,7 +213,12 @@ def update_home_page(self, idx):
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
             if b"is locked by" in response.content:
                 # someone else has item locked for editing
-                self.message += "\n\n%s Item %s is locked, Locust user %s cannot do change number %s" % (dt, item_name, self.user_name, self.count)
+                self.message += "\n\n%s Item %s is locked, Locust user %s cannot do change number %s" % (
+                    dt,
+                    item_name,
+                    self.user_name,
+                    self.count,
+                )
                 return
         time.sleep(sleep_time)
         content = response.content.decode("utf-8")
@@ -209,38 +226,57 @@ def update_home_page(self, idx):
         textarea_data = get_textarea(content) + self.message
         self.message = ""
         # complete form and post
-        new_content = "%s\n\n%s Item %s updated by Locust user %s change number = %s" % (textarea_data, dt, item_name, self.user_name, self.count)
-        new_page_post = "/+modify/" + item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        new_content = "%s\n\n%s Item %s updated by Locust user %s change number = %s" % (
+            textarea_data,
+            dt,
+            item_name,
+            self.user_name,
+            self.count,
+        )
+        new_page_post = (
+            "/+modify/" + item_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+        )
 
         # do preview
-        with self.client.post(new_page_post,
-                              {"content_form_data_text": new_content,
-                               "comment": "my comment",
-                               "preview": "Preview",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "lime, orange",
-                               "meta_form_name": item_name,
-                               "extra_meta_text": '{"namespace": ""}',
-                              }, catch_response=True) as response:
+        with self.client.post(
+            new_page_post,
+            {
+                "content_form_data_text": new_content,
+                "comment": "my comment",
+                "preview": "Preview",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "lime, orange",
+                "meta_form_name": item_name,
+                "extra_meta_text": '{"namespace": ""}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
             if b"Deletions are marked like this." not in response.content:
-                print("%s: response.status_code = %s --- Missing Deletions are marked like this." % (sys._getframe().f_lineno, response.status_code))
+                print(
+                    "%s: response.status_code = %s --- Missing Deletions are marked like this."
+                    % (sys._getframe().f_lineno, response.status_code)
+                )
         time.sleep(sleep_time)
         # do save
-        with self.client.post(new_page_post,
-                              {"content_form_data_text": new_content,
-                               "comment": "my comment",
-                               "submit": "OK",
-                               "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                               "meta_form_itemtype": "default",
-                               "meta_form_acl": "None",
-                               "meta_form_tags": "lime, orange",
-                               "meta_form_name": item_name,
-                               "extra_meta_text": '{"namespace": ""}',
-                              }, catch_response=True) as response:
+        with self.client.post(
+            new_page_post,
+            {
+                "content_form_data_text": new_content,
+                "comment": "my comment",
+                "submit": "OK",
+                "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                "meta_form_itemtype": "default",
+                "meta_form_acl": "None",
+                "meta_form_tags": "lime, orange",
+                "meta_form_name": item_name,
+                "extra_meta_text": '{"namespace": ""}',
+            },
+            catch_response=True,
+        ) as response:
             if response.status_code != 200:
                 print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
@@ -250,23 +286,34 @@ def save_messages(self):
         Create an item with this users name and add the remaining messages.
         """
         if self.message:
-            with self.client.get("/+modify/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default", catch_response=True) as response:
+            with self.client.get(
+                "/+modify/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default",
+                catch_response=True,
+            ) as response:
                 if response.status_code != 200:
                     print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
             # complete form and post
             new_content = "= %s =\n\n== Unsaved locked out messages ==%s" % (self.user_name, self.message)
-            home_page_post = "/+modify/" + self.user_name + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
-            with self.client.post(home_page_post,
-                                  {"content_form_data_text": new_content,
-                                   "comment": "my comment",
-                                   "submit": "OK",
-                                   "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
-                                   "meta_form_itemtype": "default",
-                                   "meta_form_acl": "None",
-                                   "meta_form_tags": "",
-                                   "meta_form_name": self.user_name,
-                                   "extra_meta_text": '{"namespace": "","rev_number": 1}',
-                                  }, catch_response=True) as response:
+            home_page_post = (
+                "/+modify/"
+                + self.user_name
+                + "?contenttype=text%2Fx.moin.wiki%3Bcharset%3Dutf-8&itemtype=default&template="
+            )
+            with self.client.post(
+                home_page_post,
+                {
+                    "content_form_data_text": new_content,
+                    "comment": "my comment",
+                    "submit": "OK",
+                    "meta_form_contenttype": "text/x.moin.wiki;charset=utf-8",
+                    "meta_form_itemtype": "default",
+                    "meta_form_acl": "None",
+                    "meta_form_tags": "",
+                    "meta_form_name": self.user_name,
+                    "extra_meta_text": '{"namespace": "","rev_number": 1}',
+                },
+                catch_response=True,
+            ) as response:
                 if response.status_code != 200:
                     print("%s: response.status_code = %s" % (sys._getframe().f_lineno, response.status_code))
 
diff --git a/contrib/pythonanywhere/wsgi.py b/contrib/pythonanywhere/wsgi.py
index 1eff2ddd5..ccbff7899 100644
--- a/contrib/pythonanywhere/wsgi.py
+++ b/contrib/pythonanywhere/wsgi.py
@@ -10,15 +10,16 @@
 
 this_dir = os.path.dirname(os.path.abspath(__file__))
 
-site.addsitedir(this_dir + '-venv-{0}/lib/{0}/site-packages'.format(sys.executable))
+site.addsitedir(this_dir + "-venv-{0}/lib/{0}/site-packages".format(sys.executable))
 
 if not (this_dir in sys.path or this_dir.lower() in sys.path):
     sys.path.insert(0, this_dir)
 
-wiki_config = this_dir + '/wikiconfig_local.py'
+wiki_config = this_dir + "/wikiconfig_local.py"
 if not os.path.exists(wiki_config):
-    wiki_config = this_dir + '/wikiconfig.py'
+    wiki_config = this_dir + "/wikiconfig.py"
 
 # application is the Flask application
 from moin.app import create_app
+
 application = create_app(wiki_config)
diff --git a/contrib/wikiconfig/wikiconfig_editme.py b/contrib/wikiconfig/wikiconfig_editme.py
index 3da8ef817..655470f73 100644
--- a/contrib/wikiconfig/wikiconfig_editme.py
+++ b/contrib/wikiconfig/wikiconfig_editme.py
@@ -4,7 +4,6 @@
 easier than editing a larger file.
 """
 
-
 from wikiconfig import *
 from moin.storage import create_simple_mapping
 
diff --git a/contrib/wsgi/profiler.py b/contrib/wsgi/profiler.py
index 36e849187..f915dee67 100644
--- a/contrib/wsgi/profiler.py
+++ b/contrib/wsgi/profiler.py
@@ -17,19 +17,22 @@
     @copyright: 2008 MoinMoin:FlorianKrupicka,
     @license: GNU GPL, see COPYING for details.
 """
+
 from werkzeug.wsgi import get_current_url
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class ProfilerMiddleware:
-    """ Abstract base class for profiling middlewares.
+    """Abstract base class for profiling middlewares.
 
     Concrete implementations of this class should provide implementations
     of `run_profile` and `shutdown`, the latter which should be called by
     the code utilizing the profiler.
     """
+
     def __init__(self, app):
         self.app = app
 
@@ -38,7 +41,7 @@ def profile(self, environ, start_response):
         Profile the request. Exceptions encountered during the profile are
         logged before being propagated for further handling.
         """
-        method = environ.get('REQUEST_METHOD', 'GET')
+        method = environ.get("REQUEST_METHOD", "GET")
         url = get_current_url(environ)
         logging.debug("Profiling call for '%s %s'", method, url)
         try:
@@ -51,7 +54,7 @@ def profile(self, environ, start_response):
     __call__ = profile
 
     def run_profile(self, app, *args, **kwargs):
-        """ Override in subclasses.
+        """Override in subclasses.
 
         Several profilers available for python use the same call signature,
         therefore simplifying the implementation.
@@ -59,15 +62,17 @@ def run_profile(self, app, *args, **kwargs):
         raise NotImplementedError()
 
     def shutdown(self):
-        """ Override in subclasses to clean up when server/script shuts down. """
+        """Override in subclasses to clean up when server/script shuts down."""
         pass
 
 
 class CProfileMiddleware(ProfilerMiddleware):
-    """ A profiler based on the the cProfile module from the standard lib. """
+    """A profiler based on the the cProfile module from the standard lib."""
+
     def __init__(self, app, filename):
         super().__init__(app)
         import cProfile
+
         self._profile = cProfile.Profile()
         self._filename = filename
         self.run_profile = self._profile.runcall
@@ -77,14 +82,16 @@ def shutdown(self):
 
 
 class PycallgraphMiddleware(ProfilerMiddleware):
-    """ A call graphing middleware utilizing the pycallgraph 3rd party
-    module (available at http://pycallgraph.slowchop.com/). """
+    """A call graphing middleware utilizing the pycallgraph 3rd party
+    module (available at http://pycallgraph.slowchop.com/)."""
+
     def __init__(self, app, filename):
         super().__init__(app)
         import pycallgraph
-        pycallgraph.settings['include_stdlib'] = False
+
+        pycallgraph.settings["include_stdlib"] = False
         self._filename = filename
-        globs = ['pycallgraph.*', 'unknown.*']
+        globs = ["pycallgraph.*", "unknown.*"]
         f = pycallgraph.GlobbingFilter(exclude=globs, max_depth=9999)
         self._filter = f
         self.pycallgraph = pycallgraph
@@ -100,9 +107,9 @@ def run_profile(self, app, *args, **kwargs):
     def shutdown(self):
         fname = self._filename
         pycallgraph = self.pycallgraph
-        if fname.endswith('.png'):
+        if fname.endswith(".png"):
             logging.info("Saving the rendered callgraph to '%s'", fname)
             pycallgraph.make_dot_graph(fname)
-        elif fname.endswith('.dot'):
+        elif fname.endswith(".dot"):
             logging.info("Saving the raw callgraph to '%s'", fname)
             pycallgraph.save_dot(fname)
diff --git a/contrib/wsgi/proxy.py b/contrib/wsgi/proxy.py
index f4856dc18..acc50da7c 100644
--- a/contrib/wsgi/proxy.py
+++ b/contrib/wsgi/proxy.py
@@ -20,18 +20,18 @@ def __init__(self, app, proxies):
         self.proxies = proxies
 
     def __call__(self, environ, start_response):
-        if 'HTTP_X_FORWARDED_FOR' in environ:
-            addrs = environ.pop('HTTP_X_FORWARDED_FOR').split(',')
+        if "HTTP_X_FORWARDED_FOR" in environ:
+            addrs = environ.pop("HTTP_X_FORWARDED_FOR").split(",")
             addrs = [addr.strip() for addr in addrs]
-        elif 'REMOTE_ADDR' in environ:
-            addrs = [environ['REMOTE_ADDR']]
+        elif "REMOTE_ADDR" in environ:
+            addrs = [environ["REMOTE_ADDR"]]
         else:
             addrs = [None]
         result = [addr for addr in addrs if addr not in self.proxies]
         if result:
-            environ['REMOTE_ADDR'] = result[-1]
+            environ["REMOTE_ADDR"] = result[-1]
         elif addrs[-1] is not None:
-            environ['REMOTE_ADDR'] = addrs[-1]
+            environ["REMOTE_ADDR"] = addrs[-1]
         else:
-            del environ['REMOTE_ADDR']
+            del environ["REMOTE_ADDR"]
         return self.app(environ, start_response)
diff --git a/quickinstall.py b/quickinstall.py
index fe33fce9a..b8e2b5167 100755
--- a/quickinstall.py
+++ b/quickinstall.py
@@ -48,52 +48,52 @@
 
 
 if sys.hexversion < 0x3090000:
-    sys.exit("Error: MoinMoin requires Python 3.9+, current version is %s\n" % (platform.python_version(), ))
+    sys.exit("Error: MoinMoin requires Python 3.9+, current version is %s\n" % (platform.python_version(),))
 
 
-WIN_INFO = 'm.bat, activate.bat, and deactivate.bat are created by quickinstall.py'
-NIX_INFO = 'the m bash script and the activate symlink are created by quickinstall.py'
+WIN_INFO = "m.bat, activate.bat, and deactivate.bat are created by quickinstall.py"
+NIX_INFO = "the m bash script and the activate symlink are created by quickinstall.py"
 
 # text files created by commands with high volume output
-QUICKINSTALL = 'm-quickinstall.txt'
-TOX = 'm-tox.txt'
-CODING_STD = 'm-coding-std.txt'
-DOCS = 'm-docs.txt'
-NEWWIKI = 'm-new-wiki.txt'
-DELWIKI = 'm-delete-wiki.txt'
-BACKUPWIKI = 'm-backup-wiki.txt'
-DUMPHTML = 'm-dump-html.txt'
-EXTRAS = 'm-extras.txt'
-DIST = 'm-create-dist.txt'
+QUICKINSTALL = "m-quickinstall.txt"
+TOX = "m-tox.txt"
+CODING_STD = "m-coding-std.txt"
+DOCS = "m-docs.txt"
+NEWWIKI = "m-new-wiki.txt"
+DELWIKI = "m-delete-wiki.txt"
+BACKUPWIKI = "m-backup-wiki.txt"
+DUMPHTML = "m-dump-html.txt"
+EXTRAS = "m-extras.txt"
+DIST = "m-create-dist.txt"
 # default files used for backup and restore
-BACKUP_FILENAME = os.path.normpath('wiki/backup.moin')
-JUST_IN_CASE_BACKUP = os.path.normpath('wiki/deleted-backup.moin')
+BACKUP_FILENAME = os.path.normpath("wiki/backup.moin")
+JUST_IN_CASE_BACKUP = os.path.normpath("wiki/deleted-backup.moin")
 
 
-if os.name == 'nt':
-    M = 'm'  # customize help to local OS
-    SEP = ' & '
+if os.name == "nt":
+    M = "m"  # customize help to local OS
+    SEP = " & "
     WINDOWS_OS = True
-    ACTIVATE = 'activate'
+    ACTIVATE = "activate"
 else:
-    M = './m'
-    SEP = ';'
+    M = "./m"
+    SEP = ";"
     WINDOWS_OS = False
-    ACTIVATE = '. activate'
+    ACTIVATE = ". activate"
 
 
 # commands that create log files
 CMD_LOGS = {
-    'quickinstall': QUICKINSTALL,
-    'tests': TOX,
+    "quickinstall": QUICKINSTALL,
+    "tests": TOX,
     # 'coding-std': CODING_STD,  # not logged due to small output
-    'docs': DOCS,
-    'new-wiki': NEWWIKI,
-    'del-wiki': DELWIKI,
-    'backup': BACKUPWIKI,
-    'dump-html': DUMPHTML,
-    'extras': EXTRAS,
-    'dist': DIST,
+    "docs": DOCS,
+    "new-wiki": NEWWIKI,
+    "del-wiki": DELWIKI,
+    "backup": BACKUPWIKI,
+    "dump-html": DUMPHTML,
+    "extras": EXTRAS,
+    "dist": DIST,
 }
 
 
@@ -123,7 +123,9 @@
 del-wiki        create a backup, then delete all wiki data
 
 Please refer to 'moin help' to learn more about the CLI for wiki administrators.
-""".format(M)
+""".format(
+    M
+)
 
 
 def search_for_phrase(filename):
@@ -131,25 +133,52 @@ def search_for_phrase(filename):
     files = {
         # filename: (list of phrases)
         # Note: phrases must be lower-case
-        QUICKINSTALL: ('could not find', 'error', 'fail', 'timeout', 'traceback', 'success', 'cache location',
-                       'must be deactivated', 'no such option', ),
-        NEWWIKI: ('error', 'fail', 'timeout', 'traceback', 'success', ),
-        BACKUPWIKI: ('error', 'fail', 'timeout', 'traceback', 'success', ),
-        DUMPHTML: ('fail', 'timeout', 'traceback', 'success', 'cannot', 'denied', 'error', ),
+        QUICKINSTALL: (
+            "could not find",
+            "error",
+            "fail",
+            "timeout",
+            "traceback",
+            "success",
+            "cache location",
+            "must be deactivated",
+            "no such option",
+        ),
+        NEWWIKI: ("error", "fail", "timeout", "traceback", "success"),
+        BACKUPWIKI: ("error", "fail", "timeout", "traceback", "success"),
+        DUMPHTML: ("fail", "timeout", "traceback", "success", "cannot", "denied", "error"),
         # use of 'error ' below is to avoid matching .../Modules/errors.o....
-        EXTRAS: ('error ', 'error:', 'error.', 'error,', 'fail', 'timeout', 'traceback', 'active version',
-                 'successfully installed', 'finished', ),
+        EXTRAS: (
+            "error ",
+            "error:",
+            "error.",
+            "error,",
+            "fail",
+            "timeout",
+            "traceback",
+            "active version",
+            "successfully installed",
+            "finished",
+        ),
         # ': e' matches lines similar to:
         # src/moin/converters\_tests\test_moinwiki_in_out.py:294:5: E303 too many blank lines (3)
-        TOX: ('seconds =', 'internalerror', 'error:', 'traceback', ': e', ': f', ' passed, '),
-        CODING_STD: ('remove trailing blanks', 'dos line endings', 'unix line endings', 'remove empty lines', ),
-        DIST: ('creating', 'copying', 'adding', 'hard linking', ),
-        DOCS: ('build finished', 'build succeeded', 'traceback', 'failed', 'error', 'usage', 'importerror',
-               'exception occurred', ),
+        TOX: ("seconds =", "internalerror", "error:", "traceback", ": e", ": f", " passed, "),
+        CODING_STD: ("remove trailing blanks", "dos line endings", "unix line endings", "remove empty lines"),
+        DIST: ("creating", "copying", "adding", "hard linking"),
+        DOCS: (
+            "build finished",
+            "build succeeded",
+            "traceback",
+            "failed",
+            "error",
+            "usage",
+            "importerror",
+            "exception occurred",
+        ),
     }
-    ignore_phrases = {TOX: ('interpreternotfound', )}
+    ignore_phrases = {TOX: ("interpreternotfound",)}
     # for these file names, display a count of occurrances rather than each found line
-    print_counts = (CODING_STD, DIST, )
+    print_counts = (CODING_STD, DIST)
 
     with open(filename) as f:
         lines = f.readlines()
@@ -177,32 +206,32 @@ def search_for_phrase(filename):
 
 def wiki_exists():
     """Return true if a wiki exists."""
-    return bool(glob.glob('wiki/index/_all_revs_*.toc'))
+    return bool(glob.glob("wiki/index/_all_revs_*.toc"))
 
 
 def copy_config_files():
-    if not os.path.isfile('wikiconfig.py'):
-        shutil.copy('src/moin/config/wikiconfig.py', 'wikiconfig.py')
-    if not os.path.isfile('intermap.txt'):
-        shutil.copy('src/moin/contrib/intermap.txt', 'intermap.txt')
-    if not os.path.isdir('wiki_local'):
-        os.mkdir('wiki_local')
+    if not os.path.isfile("wikiconfig.py"):
+        shutil.copy("src/moin/config/wikiconfig.py", "wikiconfig.py")
+    if not os.path.isfile("intermap.txt"):
+        shutil.copy("src/moin/contrib/intermap.txt", "intermap.txt")
+    if not os.path.isdir("wiki_local"):
+        os.mkdir("wiki_local")
 
 
-def make_wiki(command, mode='w', msg='\nSuccess: a new wiki has been created.'):
+def make_wiki(command, mode="w", msg="\nSuccess: a new wiki has been created."):
     """Process command to create a new wiki."""
-    if wiki_exists() and mode == 'w':
-        print('Error: a wiki exists, delete it and try again.')
+    if wiki_exists() and mode == "w":
+        print("Error: a wiki exists, delete it and try again.")
     else:
         copy_config_files()
-        print(f'Output messages redirected to {NEWWIKI}.')
+        print(f"Output messages redirected to {NEWWIKI}.")
         with open(NEWWIKI, mode) as messages:
             result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
         if result == 0:
             print(msg)
             return True
         else:
-            print('Important messages from %s are shown below:' % NEWWIKI)
+            print("Important messages from %s are shown below:" % NEWWIKI)
             search_for_phrase(NEWWIKI)
             print('\nError: attempt to create wiki failed. Do "%s log new-wiki" to see complete log.' % M)
             return False
@@ -233,16 +262,17 @@ def get_pygments_data_location():
 def create_m():
     """Create an 'm.bat or 'm' bash script that will run quickinstall.py using this Python"""
     if WINDOWS_OS:
-        with open('m.bat', 'w') as f:
-            f.write(f':: {WIN_INFO}\n\n@{sys.executable} quickinstall.py %* --help\n')
+        with open("m.bat", "w") as f:
+            f.write(f":: {WIN_INFO}\n\n@{sys.executable} quickinstall.py %* --help\n")
     else:
-        with open('m', 'w') as f:
-            f.write(f'#!/bin/sh\n# {NIX_INFO}\n\n{sys.executable} quickinstall.py $* --help\n')
+        with open("m", "w") as f:
+            f.write(f"#!/bin/sh\n# {NIX_INFO}\n\n{sys.executable} quickinstall.py $* --help\n")
             os.fchmod(f.fileno(), 0o775)
 
 
 class Commands:
     """Each cmd_ method processes a choice on the menu."""
+
     def __init__(self):
         self.tic = timeit.default_timer()
 
@@ -250,63 +280,71 @@ def run_time(self, command):
         seconds = int(timeit.default_timer() - self.tic)
         (t_min, t_sec) = divmod(seconds, 60)
         (t_hour, t_min) = divmod(t_min, 60)
-        print(f'{command} run time (h:mm:ss) {t_hour}:{t_min:0>2}:{t_sec:0>2}')
+        print(f"{command} run time (h:mm:ss) {t_hour}:{t_min:0>2}:{t_sec:0>2}")
 
     def cmd_quickinstall(self, *args):
         """create or update a virtual environment with the required packages"""
-        if os.path.isdir('.tox'):
+        if os.path.isdir(".tox"):
             # keep tox test virtualenvs in sync with moin-env-python
-            command = '{} quickinstall.py --FirstCall {}{}tox --recreate --notest'.format(
-                sys.executable, ' '.join(args), SEP)
-            print('Running quickinstall.py and tox recreate virtualenvs... output messages redirected to {}'.format(
-                QUICKINSTALL))
+            command = "{} quickinstall.py --FirstCall {}{}tox --recreate --notest".format(
+                sys.executable, " ".join(args), SEP
+            )
+            print(
+                "Running quickinstall.py and tox recreate virtualenvs... output messages redirected to {}".format(
+                    QUICKINSTALL
+                )
+            )
         else:
-            command = f'{sys.executable} quickinstall.py --FirstCall'
-            print(f'Running quickinstall.py... output messages redirected to {QUICKINSTALL}')
-        with open(QUICKINSTALL, 'w') as messages:
+            command = f"{sys.executable} quickinstall.py --FirstCall"
+            print(f"Running quickinstall.py... output messages redirected to {QUICKINSTALL}")
+        with open(QUICKINSTALL, "w") as messages:
             # we run ourself as a subprocess so output can be captured in a log file
             subprocess.run(command, shell=True, stderr=messages, stdout=messages)
-        print('\nSearching {}, important messages are shown below... Do "{} log quickinstall" '
-              'to see complete log.\n'.format(QUICKINSTALL, M))
+        print(
+            '\nSearching {}, important messages are shown below... Do "{} log quickinstall" '
+            "to see complete log.\n".format(QUICKINSTALL, M)
+        )
         search_for_phrase(QUICKINSTALL)
-        self.run_time('Quickinstall')
+        self.run_time("Quickinstall")
 
     def cmd_docs(self, *args):
         """create local Sphinx html documentation"""
-        command = 'sphinx-apidoc -f -o docs/devel/api src/moin {0}cd docs{0} make html'.format(SEP)
-        print(f'Creating HTML docs... output messages written to {DOCS}.')
-        with open(DOCS, 'w') as messages:
+        command = "sphinx-apidoc -f -o docs/devel/api src/moin {0}cd docs{0} make html".format(SEP)
+        print(f"Creating HTML docs... output messages written to {DOCS}.")
+        with open(DOCS, "w") as messages:
             result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
-        print(f'\nSearching {DOCS}, important messages are shown below...\n')
+        print(f"\nSearching {DOCS}, important messages are shown below...\n")
         search_for_phrase(DOCS)
         if result == 0:
-            print('HTML docs successfully created in {}.'.format(os.path.normpath('docs/_build/html')))
+            print("HTML docs successfully created in {}.".format(os.path.normpath("docs/_build/html")))
         else:
-            print('Error: creation of HTML docs failed with return code "{}".'
-                  ' Do "{} log docs" to see complete log.'.format(result, M))
-        self.run_time('Docs')
+            print(
+                'Error: creation of HTML docs failed with return code "{}".'
+                ' Do "{} log docs" to see complete log.'.format(result, M)
+            )
+        self.run_time("Docs")
 
     def cmd_extras(self, *args):
         """install optional packages from requirements.d"""
-        reqs = ['requirements.d/extras.txt', 'requirements.d/development.txt', 'docs/requirements.txt', ]
+        reqs = ["requirements.d/extras.txt", "requirements.d/development.txt", "docs/requirements.txt"]
         if not WINDOWS_OS:
-            reqs.append('requirements.d/ldap.txt')
-        reqs_installer = 'pip install --upgrade -r '
+            reqs.append("requirements.d/ldap.txt")
+        reqs_installer = "pip install --upgrade -r "
         command = SEP.join(list(reqs_installer + x for x in reqs))
-        print('Installing {}.'.format(', '.join(reqs)))
-        print(f'Output messages written to {EXTRAS}.')
-        with open(EXTRAS, 'w') as messages:
+        print("Installing {}.".format(", ".join(reqs)))
+        print(f"Output messages written to {EXTRAS}.")
+        with open(EXTRAS, "w") as messages:
             subprocess.call(command, shell=True, stderr=messages, stdout=messages)
-        print('\nImportant messages from {} are shown below. Do "{} log extras" to see complete log.'.format(
-            EXTRAS, M))
+        print('\nImportant messages from {} are shown below. Do "{} log extras" to see complete log.'.format(EXTRAS, M))
         search_for_phrase(EXTRAS)
-        self.run_time('Extras')
+        self.run_time("Extras")
 
     def cmd_interwiki(self, *args):
         """refresh contrib/interwiki/intermap.txt"""
-        print('Refreshing {}...'.format(os.path.normpath('contrib/interwiki/intermap.txt')))
-        command = '{} scripts/wget.py http://master19.moinmo.in/InterWikiMap?action=raw intermap.txt'.format(
-            sys.executable)
+        print("Refreshing {}...".format(os.path.normpath("contrib/interwiki/intermap.txt")))
+        command = "{} scripts/wget.py http://master19.moinmo.in/InterWikiMap?action=raw intermap.txt".format(
+            sys.executable
+        )
         subprocess.call(command, shell=True)
 
     def cmd_log(self, *args):
@@ -315,43 +353,43 @@ def cmd_log(self, *args):
         def log_help(logs):
             """Print list of available logs to view."""
             print(f"usage: {M} log <target> where <target> is:\n\n")
-            choices = '{0: <16}- {1}'
+            choices = "{0: <16}- {1}"
             for log in sorted(logs):
                 if os.path.isfile(CMD_LOGS[log]):
                     print(choices.format(log, CMD_LOGS[log]))
                 else:
-                    print(choices.format(log, '* file does not exist'))
+                    print(choices.format(log, "* file does not exist"))
 
         logs = set(CMD_LOGS.keys())
         if args and args[0] in logs and os.path.isfile(CMD_LOGS[args[0]]):
             if WINDOWS_OS:
-                command = f'start {CMD_LOGS[args[0]]}'
+                command = f"start {CMD_LOGS[args[0]]}"
             else:
                 # .format requires {{ and }} to escape { and }
-                command = f'${{VISUAL:-${{FCEDIT:-${{EDITOR:-less}}}}}} {CMD_LOGS[args[0]]}'
+                command = f"${{VISUAL:-${{FCEDIT:-${{EDITOR:-less}}}}}} {CMD_LOGS[args[0]]}"
             subprocess.call(command, shell=True)
         else:
             log_help(logs)
 
     def cmd_new_wiki(self, *args):
         """create empty wiki"""
-        command = 'moin index-create'
-        print('Creating a new empty wiki...')
+        command = "moin index-create"
+        print("Creating a new empty wiki...")
         make_wiki(command)  # share code with restore command
 
     def cmd_restore(self, *args):
         """create wiki and load data from wiki/backup.moin or user specified path"""
-        command = 'moin index-create{0} moin load --file %s{0} moin index-build'.format(SEP)
+        command = "moin index-create{0} moin load --file %s{0} moin index-build".format(SEP)
         filename = BACKUP_FILENAME
         if args:
             filename = args[0]
         if os.path.isfile(filename):
             command = command % filename
-            print(f'Creating a new wiki and loading it with data from {filename}...')
+            print(f"Creating a new wiki and loading it with data from {filename}...")
             make_wiki(command)
         else:
-            print(f'Error: cannot create wiki because {filename} does not exist.')
-        self.run_time('Restore')
+            print(f"Error: cannot create wiki because {filename} does not exist.")
+        self.run_time("Restore")
 
     def cmd_import19(self, *args):
         """import a moin 1.9 wiki"""
@@ -363,101 +401,109 @@ def cmd_backup(self, *args):
             filename = BACKUP_FILENAME
             if args:
                 filename = args[0]
-                print(f'Creating a wiki backup to {filename}...')
+                print(f"Creating a wiki backup to {filename}...")
             else:
-                print(f'Creating a wiki backup to {filename} after rolling 3 prior backups...')
-                b3 = BACKUP_FILENAME.replace('.', '3.')
-                b2 = BACKUP_FILENAME.replace('.', '2.')
-                b1 = BACKUP_FILENAME.replace('.', '1.')
+                print(f"Creating a wiki backup to {filename} after rolling 3 prior backups...")
+                b3 = BACKUP_FILENAME.replace(".", "3.")
+                b2 = BACKUP_FILENAME.replace(".", "2.")
+                b1 = BACKUP_FILENAME.replace(".", "1.")
                 if os.path.exists(b3):
                     os.remove(b3)
                 for src, dst in ((b2, b3), (b1, b2), (BACKUP_FILENAME, b1)):
                     if os.path.exists(src):
                         os.rename(src, dst)
 
-            command = f'moin save --all-backends --file {filename}'
-            with open(BACKUPWIKI, 'w') as messages:
+            command = f"moin save --all-backends --file {filename}"
+            with open(BACKUPWIKI, "w") as messages:
                 result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
             if result == 0:
-                print(f'Success: wiki was backed up to {filename}')
+                print(f"Success: wiki was backed up to {filename}")
             else:
-                print('Important messages from {} are shown below. Do "{} log backup" to see complete log.'.format(
-                    BACKUPWIKI, M))
+                print(
+                    'Important messages from {} are shown below. Do "{} log backup" to see complete log.'.format(
+                        BACKUPWIKI, M
+                    )
+                )
                 search_for_phrase(BACKUPWIKI)
-                print('\nError: attempt to backup wiki failed.')
+                print("\nError: attempt to backup wiki failed.")
         else:
-            print('Error: cannot backup wiki because it has not been created.')
-        self.run_time('Backup')
+            print("Error: cannot backup wiki because it has not been created.")
+        self.run_time("Backup")
 
     def cmd_dump_html(self, *args):
         """create a static html dump of this wiki"""
         if wiki_exists():
-            print('Creating static HTML image of wiki...')
-            command = 'moin dump-html {}'.format(' '.join(args))
-            with open(DUMPHTML, 'w') as messages:
+            print("Creating static HTML image of wiki...")
+            command = "moin dump-html {}".format(" ".join(args))
+            with open(DUMPHTML, "w") as messages:
                 result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
             if result == 0:
-                print('Success: wiki was dumped to html files')
+                print("Success: wiki was dumped to html files")
             else:
-                print('\nError: attempt to dump wiki to html files failed.')
+                print("\nError: attempt to dump wiki to html files failed.")
             # always show errors because individual items may fail
-            print('Important messages from {} are shown below. Do "{} log dump-html" to see complete log.'.format(
-                DUMPHTML, M))
+            print(
+                'Important messages from {} are shown below. Do "{} log dump-html" to see complete log.'.format(
+                    DUMPHTML, M
+                )
+            )
             search_for_phrase(DUMPHTML)
         else:
-            print('Error: cannot dump wiki because it has not been created.')
-        self.run_time('HTML Dump')
+            print("Error: cannot dump wiki because it has not been created.")
+        self.run_time("HTML Dump")
 
     def cmd_css(self, *args):
         """run lessc to update basic theme CSS files"""
-        bootstrap_loc = get_bootstrap_data_location().strip() + '/less'
-        pygments_loc = get_pygments_data_location().strip() + '/css'
-        basic_loc = 'src/moin/themes/basic/static/custom-less'
+        bootstrap_loc = get_bootstrap_data_location().strip() + "/less"
+        pygments_loc = get_pygments_data_location().strip() + "/css"
+        basic_loc = "src/moin/themes/basic/static/custom-less"
 
-        print('Running lessc to update Basic theme CSS files...')
+        print("Running lessc to update Basic theme CSS files...")
         if WINDOWS_OS:
-            data_loc = f'{bootstrap_loc};{pygments_loc}'
+            data_loc = f"{bootstrap_loc};{pygments_loc}"
         else:
-            data_loc = f'{bootstrap_loc}:{pygments_loc}'
-        include = '--include-path=' + data_loc
-        command = f'cd {basic_loc}{SEP}lessc {include} theme.less ../css/theme.css'
+            data_loc = f"{bootstrap_loc}:{pygments_loc}"
+        include = "--include-path=" + data_loc
+        command = f"cd {basic_loc}{SEP}lessc {include} theme.less ../css/theme.css"
         result = subprocess.call(command, shell=True)
         if result == 0:
-            print('Success: Basic theme CSS files updated.')
+            print("Success: Basic theme CSS files updated.")
         else:
-            print('Error: Basic theme CSS files update failed, see error messages above.')
+            print("Error: Basic theme CSS files update failed, see error messages above.")
 
     def cmd_tests(self, *args):
         """run tests, output goes to m-tox.txt"""
-        print(f'Running tests... output written to {TOX}.')
-        command = 'tox -- {1} > {0} 2>&1'.format(TOX, ' '.join(args))
+        print(f"Running tests... output written to {TOX}.")
+        command = "tox -- {1} > {0} 2>&1".format(TOX, " ".join(args))
         subprocess.call(command, shell=True)
         print(f'Important messages from {TOX} are shown below. Do "{M} log tests" to see complete log.')
         search_for_phrase(TOX)
-        self.run_time('Tests')
+        self.run_time("Tests")
 
     def cmd_coding_std(self, *args):
         """correct scripts that taint the HG repository and clutter subsequent code reviews"""
-        print('Checking for trailing blanks, DOS line endings, Unix line endings, empty lines at eof...')
-        command = '%s scripts/coding_std.py' % sys.executable
+        print("Checking for trailing blanks, DOS line endings, Unix line endings, empty lines at eof...")
+        command = "%s scripts/coding_std.py" % sys.executable
         subprocess.call(command, shell=True)
 
     # not on menu, rarely used, similar code was in moin 1.9
     def cmd_dist(self, *args):
         """create distribution archive in dist/"""
-        print('Deleting wiki data, then creating distribution archive in /dist, output written to {}.'.format(
-            DIST))
+        print("Deleting wiki data, then creating distribution archive in /dist, output written to {}.".format(DIST))
         self.cmd_del_wiki(*args)
-        command = 'pip install build ; python -m build'
-        with open(DIST, 'w') as messages:
+        command = "pip install build ; python -m build"
+        with open(DIST, "w") as messages:
             result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
-        print(f'Summary message from {DIST} is shown below:')
+        print(f"Summary message from {DIST} is shown below:")
         search_for_phrase(DIST)
         if result == 0:
-            print('Success: a distribution archive was created in {}.'.format(os.path.normpath('/dist')))
+            print("Success: a distribution archive was created in {}.".format(os.path.normpath("/dist")))
         else:
-            print('Error: create dist failed with return code = {}. Do "{} log dist" to see complete log.'.format(
-                result, M))
+            print(
+                'Error: create dist failed with return code = {}. Do "{} log dist" to see complete log.'.format(
+                    result, M
+                )
+            )
 
     def cmd_del_all(self, *args):
         """same as running the 4 del-* commands below"""
@@ -468,39 +514,37 @@ def cmd_del_all(self, *args):
 
     def cmd_del_orig(self, *args):
         """delete all files matching *.orig"""
-        delete_files('*.orig')
+        delete_files("*.orig")
 
     def cmd_del_pyc(self, *args):
         """delete all files matching *.pyc"""
-        delete_files('*.pyc')
+        delete_files("*.pyc")
 
     def cmd_del_rej(self, *args):
         """delete all files matching *.rej"""
-        delete_files('*.rej')
+        delete_files("*.rej")
 
     def cmd_del_wiki(self, *args):
         """create a just-in-case backup, then delete all wiki data"""
-        command = f'moin save --all-backends --file {JUST_IN_CASE_BACKUP}'
+        command = f"moin save --all-backends --file {JUST_IN_CASE_BACKUP}"
         if wiki_exists():
-            print(
-                f'Creating a backup named {JUST_IN_CASE_BACKUP}; then deleting all wiki data and indexes...'
-            )
-            with open(DELWIKI, 'w') as messages:
+            print(f"Creating a backup named {JUST_IN_CASE_BACKUP}; then deleting all wiki data and indexes...")
+            with open(DELWIKI, "w") as messages:
                 result = subprocess.call(command, shell=True, stderr=messages, stdout=messages)
             if result != 0:
-                print(f'Error: backup failed with return code = {result}. Complete log is in {DELWIKI}.')
+                print(f"Error: backup failed with return code = {result}. Complete log is in {DELWIKI}.")
         # destroy wiki even if backup fails
-        if os.path.isdir('wiki/data') or os.path.isdir('wiki/index'):
-            shutil.rmtree('wiki/data')
-            shutil.rmtree('wiki/index')
-            if os.path.isdir('wiki/preview'):
-                shutil.rmtree('wiki/preview')
-            if os.path.isdir('wiki/sql'):
-                shutil.rmtree('wiki/sql')
-            print('Wiki data successfully deleted.')
+        if os.path.isdir("wiki/data") or os.path.isdir("wiki/index"):
+            shutil.rmtree("wiki/data")
+            shutil.rmtree("wiki/index")
+            if os.path.isdir("wiki/preview"):
+                shutil.rmtree("wiki/preview")
+            if os.path.isdir("wiki/sql"):
+                shutil.rmtree("wiki/sql")
+            print("Wiki data successfully deleted.")
         else:
-            print('Wiki data not deleted because it does not exist.')
-        self.run_time('Delete wiki')
+            print("Wiki data not deleted because it does not exist.")
+        self.run_time("Delete wiki")
 
 
 class QuickInstall:
@@ -508,8 +552,8 @@ class QuickInstall:
     def __init__(self, source):
         self.dir_source = source
         base, source_name = os.path.split(source)
-        executable = os.path.basename(sys.executable).split('.exe')[0]
-        venv_path = os.path.join(base, f'{source_name}-venv-{executable}')
+        executable = os.path.basename(sys.executable).split(".exe")[0]
+        venv_path = os.path.join(base, f"{source_name}-venv-{executable}")
         venv_path = os.path.abspath(venv_path)
         venv_home, venv_lib, venv_inc, venv_bin = path_locations(venv_path)
         self.dir_venv = venv_home
@@ -527,41 +571,45 @@ def do_venv(self):
 
     def do_install(self):
         args = [
-            os.path.join(self.dir_venv_bin, 'pip'),
-            'install',
-            '--upgrade',
-            '--upgrade-strategy=eager',
-            '--editable',
+            os.path.join(self.dir_venv_bin, "pip"),
+            "install",
+            "--upgrade",
+            "--upgrade-strategy=eager",
+            "--editable",
             self.dir_source,
         ]
         subprocess.check_call(args)
 
     def do_catalog(self):
-        subprocess.check_call((
-            os.path.join(self.dir_venv_bin, 'pybabel'),
-            'compile', '--statistics',
-            # needed in case user runs quickinstall.py with a cwd other than the repo root
-            '--directory', os.path.join(os.path.dirname(__file__), 'src', 'moin', 'translations'),
-        ))
+        subprocess.check_call(
+            (
+                os.path.join(self.dir_venv_bin, "pybabel"),
+                "compile",
+                "--statistics",
+                # needed in case user runs quickinstall.py with a cwd other than the repo root
+                "--directory",
+                os.path.join(os.path.dirname(__file__), "src", "moin", "translations"),
+            )
+        )
 
     def create_wrapper(self, filename, target):
         r"""Create files in the repo root that wrap files in <path-to-virtual-env>\Scripts."""  # noqa
         target = os.path.join(self.dir_venv_bin, target)
-        with open(filename, 'w') as f:
-            f.write(f':: {WIN_INFO}\n\n@call {target} %*\n')
+        with open(filename, "w") as f:
+            f.write(f":: {WIN_INFO}\n\n@call {target} %*\n")
 
     def do_helpers(self):
         """Create small helper scripts or symlinks in repo root, avoid keying the long path to virtual env."""
         create_m()
         if WINDOWS_OS:
             # windows commands are: activate | deactivate
-            self.create_wrapper('activate.bat', 'activate.bat')
-            self.create_wrapper('deactivate.bat', 'deactivate.bat')
+            self.create_wrapper("activate.bat", "activate.bat")
+            self.create_wrapper("deactivate.bat", "deactivate.bat")
         else:
             # linux commands are: source activate | deactivate
-            if os.path.exists('activate'):
-                os.unlink('activate')
-            os.symlink(os.path.join(self.dir_venv_bin, 'activate'), 'activate')  # no need to define deactivate on unix
+            if os.path.exists("activate"):
+                os.unlink("activate")
+            os.symlink(os.path.join(self.dir_venv_bin, "activate"), "activate")  # no need to define deactivate on unix
 
 
 # code below and path_locations copied from virtualenv.py v16.7.10 because path_locations dropped in v20.0.0 rewrite.
@@ -622,59 +670,60 @@ def path_locations(home_dir, dry_run=False):
     return home_dir, lib_dir, inc_dir, bin_dir
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # create a set of valid menu choices
     commands = Commands()
     choices = set()
     names = dir(commands)
     for name in names:
-        if name.startswith('cmd_'):
+        if name.startswith("cmd_"):
             choices.add(name)
     args = sys.argv[:]
 
-    if len(args) > 2 and args[-1] == '--help':
+    if len(args) > 2 and args[-1] == "--help":
         # m and m.bat have trailing --help so "./m" comes across as "python quickinstall.py --help"
         # if user did "./m <option>" we have "python quickinstall.py <option> --help"
         # then we can delete the --help and do <option>
         args = args[:-1]
 
-    if (os.path.isfile('activate') or os.path.isfile('activate.bat')) and (
-            len(args) == 2 and args[1] in ('-h', '--help')):
+    if (os.path.isfile("activate") or os.path.isfile("activate.bat")) and (
+        len(args) == 2 and args[1] in ("-h", "--help")
+    ):
         # user keyed "./m", "./m -h", or "./m --help"
         print(help)
 
     else:
-        if not (os.path.isfile('m') or os.path.isfile('m.bat')):
+        if not (os.path.isfile("m") or os.path.isfile("m.bat")):
             # user is running "python quickinstall.py" after fresh clone (or m or m.bat has been deleted)
             create_m()  # create "m" or "m.bat" file so above IF will be false next time around
-            command = getattr(commands, 'cmd_quickinstall')
+            command = getattr(commands, "cmd_quickinstall")
             # run this same script (quickinstall.py) again in a subprocess to create the virtual env
             command()
             # a few success/failure messages will have printed on users terminal, suggest next step
             print('\n> > > Type "%s" to activate venv, then "%s" for menu < < <' % (ACTIVATE, M))
 
-        elif args == ['quickinstall.py', 'quickinstall']:
+        elif args == ["quickinstall.py", "quickinstall"]:
             # user keyed "./m quickinstall" to update virtualenv
-            command = getattr(commands, 'cmd_quickinstall')
+            command = getattr(commands, "cmd_quickinstall")
             # run this same script (quickinstall.py) again in a subprocess to recreate the virtual env
             command()
 
         else:
-            if (len(args) == 1 and args[0].endswith('quickinstall.py')):
+            if len(args) == 1 and args[0].endswith("quickinstall.py"):
                 # user keyed "python quickinstall.py" instead of "./m quickinstall"
                 # run this same script (quickinstall.py) again in a subprocess to create the virtual env
-                command = getattr(commands, 'cmd_quickinstall')
+                command = getattr(commands, "cmd_quickinstall")
                 command()
 
-            elif args == ['quickinstall.py', '--FirstCall']:
+            elif args == ["quickinstall.py", "--FirstCall"]:
                 # we are in a subprocess call after "python quickinstall.py" or  "./m quickinstall"
                 QuickInstall(os.path.dirname(os.path.realpath(args[0])))()
                 copy_config_files()
 
             else:
                 # we have some simple command like "./m css" that does not update virtualenv
-                choice = 'cmd_%s' % args[1]
-                choice = choice.replace('-', '_')
+                choice = "cmd_%s" % args[1]
+                choice = choice.replace("-", "_")
                 if choice in choices:
                     choice = getattr(commands, choice)
                     choice(*args[2:])
diff --git a/scripts/coding_std.py b/scripts/coding_std.py
index 99f51ce0d..e2c2a09b4 100644
--- a/scripts/coding_std.py
+++ b/scripts/coding_std.py
@@ -44,6 +44,7 @@ class NoDupsLogger:
     """
     A simple report logger that suppresses duplicate headings and messages.
     """
+
     def __init__(self):
         self.messages = set()
         self.headings = set()
@@ -71,14 +72,14 @@ def directories_to_ignore(starting_dir):
 
 def files_to_ignore():
     """Return a list of files that will not be processed."""
-    return os.path.join('moin', '_version.py')
+    return os.path.join("moin", "_version.py")
 
 
 def calc_indentation(line):
     """
     Return tuple (length of indentation, line stripped of leading blanks).
     """
-    stripped = line.lstrip(' ')
+    stripped = line.lstrip(" ")
     indentation = len(line) - len(stripped)
     return indentation, stripped
 
@@ -89,19 +90,43 @@ def check_template_indentation(lines, filename, logger):
 
     In simple cases, non-standard indent, non-standard dedent messages tells users which lines to indent.
     """
-    indent_after = ('{% block ', '{% if ', '{% elif ', '{% else ', '{% for ', '{% macro ',
-                    '{%- block ', '{%- if ', '{%- elif ', '{%- else ', '{%- for ', '{%- macro ', '{{ gen.form.open', )
-    indent_before = ('{% endblock ', '{% endif ', '{% endfor ', '{% endmacro', '</',
-                     '{%- endblock ', '{%- endif ', '{%- endfor ', '{%- endmacro', '{{ gen.form.close', )
-    block_endings = {'{% block': ('{% endblock %}', '{%- endblock %}', '{%- endblock -%}', '{% endblock -%}', ),
-                     '{% if': ('{% endif %}', '{%- endif %}', '{%- endif -%}', '{% endif -%}', ),
-                     '{% elif': ('{% endif %}', '{%- endif %}', '{%- endif -%}', '{% endif -%}', ),
-                     '{% else': ('{% endif %}', '{%- endif %}', '{%- endif -%}', '{% endif -%}', ),
-                     '{% for': ('{% endfor %}', '{%- endfor %}', '{%- endfor -%}', '{% endfor -%}', ),
-                     '{% macro': ('{% endmacro %}', '{%- endmacro %}', '{%- endmacro -%}', '{% endmacro -%}', ),
-                     '{{ gen.form.open': ('{{ gen.form.close }}', ),
-                     }
-    ends = ('{% end', '{%- end')
+    indent_after = (
+        "{% block ",
+        "{% if ",
+        "{% elif ",
+        "{% else ",
+        "{% for ",
+        "{% macro ",
+        "{%- block ",
+        "{%- if ",
+        "{%- elif ",
+        "{%- else ",
+        "{%- for ",
+        "{%- macro ",
+        "{{ gen.form.open",
+    )
+    indent_before = (
+        "{% endblock ",
+        "{% endif ",
+        "{% endfor ",
+        "{% endmacro",
+        "</",
+        "{%- endblock ",
+        "{%- endif ",
+        "{%- endfor ",
+        "{%- endmacro",
+        "{{ gen.form.close",
+    )
+    block_endings = {
+        "{% block": ("{% endblock %}", "{%- endblock %}", "{%- endblock -%}", "{% endblock -%}"),
+        "{% if": ("{% endif %}", "{%- endif %}", "{%- endif -%}", "{% endif -%}"),
+        "{% elif": ("{% endif %}", "{%- endif %}", "{%- endif -%}", "{% endif -%}"),
+        "{% else": ("{% endif %}", "{%- endif %}", "{%- endif -%}", "{% endif -%}"),
+        "{% for": ("{% endfor %}", "{%- endfor %}", "{%- endfor -%}", "{% endfor -%}"),
+        "{% macro": ("{% endmacro %}", "{%- endmacro %}", "{%- endmacro -%}", "{% endmacro -%}"),
+        "{{ gen.form.open": ("{{ gen.form.close }}",),
+    }
+    ends = ("{% end", "{%- end")
 
     for idx, line in enumerate(lines):
         indentation, stripped = calc_indentation(line)
@@ -110,19 +135,20 @@ def check_template_indentation(lines, filename, logger):
             # we have found the beginning of a block
             incre = 1
             try:
-                while lines[idx + incre].strip() == '':
+                while lines[idx + incre].strip() == "":
                     incre += 1
                 next_indentation, next_line = calc_indentation(lines[idx + incre])
                 if next_indentation <= indentation:
                     # next non-blank line does not have expected indentation
                     # truncate "{{ gen.form.open(form, ..." to "{{ gen.form.open"; "{%- if ..." to "{% if"
-                    block_start = stripped.replace('-', '').split('(')[0].split(' ')
-                    block_start = ' '.join(block_start[:2])
+                    block_start = stripped.replace("-", "").split("(")[0].split(" ")
+                    block_start = " ".join(block_start[:2])
                     block_end = block_endings.get(block_start)
                     if not block_end:
                         # should never get here, mismatched indent_after and block_endings
-                        logger.log(filename,
-                                   "Unexpected block type '%s' discovered at line %d!" % (block_start, idx + 1))
+                        logger.log(
+                            filename, "Unexpected block type '%s' discovered at line %d!" % (block_start, idx + 1)
+                        )
                         continue
                     if any(x in stripped for x in block_end):
                         # found line similar to: {% block ... %}...{% endblock %}
@@ -138,7 +164,7 @@ def check_template_indentation(lines, filename, logger):
         elif stripped.startswith(indent_before):
             # we have found the end of a block
             decre = -1
-            while idx + decre >= 0 and lines[idx + decre].strip() == '':
+            while idx + decre >= 0 and lines[idx + decre].strip() == "":
                 decre -= 1
             if idx + decre < 0:
                 # should never get here; file begins with something like {% endblock %} or </div>
@@ -147,15 +173,15 @@ def check_template_indentation(lines, filename, logger):
             prior_indentation, prior_line = calc_indentation(lines[idx + decre])
             if prior_indentation <= indentation:
                 # prior non-blank line does not have expected indentation
-                if stripped.startswith('</'):
-                    tag_open = stripped.split('>')[0].replace('/', '')  # convert </div> to <div, etc.
+                if stripped.startswith("</"):
+                    tag_open = stripped.split(">")[0].replace("/", "")  # convert </div> to <div, etc.
                     if prior_line.startswith(tag_open):
                         # found lines similar to: <td>...\n</td>
                         continue
                 if stripped.startswith(ends):
                     # convert end of block to prior beginning of block by removing "end" and any "-"s
-                    block_end = stripped.split(' %}')[0].split(' -%}')[0].replace('end', '').replace('-', '')
-                    prior_line = prior_line.replace('-', '')
+                    block_end = stripped.split(" %}")[0].split(" -%}")[0].replace("end", "").replace("-", "")
+                    prior_line = prior_line.replace("-", "")
                     if prior_line.startswith(block_end):
                         # found lines similar to: {% block...\n{% endblock %}
                         continue
@@ -166,24 +192,39 @@ def check_template_spacing(lines, filename, logger):
     """
     Create message if there is not a blank afer {{, {%, {#, {{-, {%-, {#- and before }}, %}, #},  -}}, -%}, -#}.
     """
-    pattern = re.compile(r'(\{[{#%])|([}#%]\})')
+    pattern = re.compile(r"(\{[{#%])|([}#%]\})")
     for idx, line in enumerate(lines):
         # log missing spaces in {{-myfunction}}, {#mycomment-#}, {%-myoperator%}
         m = pattern.search(line)
         if m:
-            m_start = [m.start() for m in re.finditer('{%|{{|{#', line)]
+            m_start = [m.start() for m in re.finditer("{%|{{|{#", line)]
             for index in m_start:
-                if (not line.startswith((' ', '- '), index + 2) and
-                        not line.strip() in ('{{', '{%', '{#', '{{-', '{%-', '{#-')):
-                    logger.log(filename,
-                               'Missing space within "%s" on line %d - not fixed!' % (line[index:index + 4], idx + 1))
-            m_end = [m.start() for m in re.finditer('%}|}}|#}', line)]
+                if not line.startswith((" ", "- "), index + 2) and not line.strip() in (
+                    "{{",
+                    "{%",
+                    "{#",
+                    "{{-",
+                    "{%-",
+                    "{#-",
+                ):
+                    logger.log(
+                        filename,
+                        'Missing space within "%s" on line %d - not fixed!' % (line[index : index + 4], idx + 1),
+                    )
+            m_end = [m.start() for m in re.finditer("%}|}}|#}", line)]
             for index in m_end:
-                if (not (line.startswith(' ', index - 1) or line.startswith(' -', index - 2))
-                        and not line.strip() in ('}}', '%}', '#}', '-}}', '-%}', '-#}')):
-                    logger.log(filename,
-                               'Missing space within "%s" on line %d - not fixed!'
-                               % (line[index - 2:index + 2], idx + 1))
+                if not (line.startswith(" ", index - 1) or line.startswith(" -", index - 2)) and not line.strip() in (
+                    "}}",
+                    "%}",
+                    "#}",
+                    "-}}",
+                    "-%}",
+                    "-#}",
+                ):
+                    logger.log(
+                        filename,
+                        'Missing space within "%s" on line %d - not fixed!' % (line[index - 2 : index + 2], idx + 1),
+                    )
 
 
 def check_files(filename, suffix):
@@ -205,14 +246,14 @@ def check_files(filename, suffix):
         with open(filename, encoding="utf-8", newline="") as f:
             lines = f.readlines()
     except UnicodeDecodeError:
-        print('Skipping file due to UnicodeDecodeError:', filename)
+        print("Skipping file due to UnicodeDecodeError:", filename)
         return
 
-    if filename.endswith('.html'):
+    if filename.endswith(".html"):
         check_template_indentation(lines, filename, logger)
         check_template_spacing(lines, filename, logger)
 
-    if filename.endswith('.js'):
+    if filename.endswith(".js"):
         check_js_phrases(lines, filename)
 
     # now look at file end and get rid of all whitespace-only lines there:
@@ -226,7 +267,7 @@ def check_files(filename, suffix):
     with open(filename, "w", encoding="utf-8", newline="") as f:
         for idx, line in enumerate(lines):
             line_length = len(line)
-            line = line.replace('\t', '    ')
+            line = line.replace("\t", "    ")
             if len(line) != line_length:
                 logger.log(filename, "Tab characters replaced with 4 spaces.")
             pep8_line = line.rstrip() + line_end
@@ -269,7 +310,7 @@ def find_js_phrases(starting_dir):
     Create warning message if key and value are not equal.
     """
     global phrases
-    target = os.path.join(starting_dir, 'moin', 'templates', 'dictionary.js')
+    target = os.path.join(starting_dir, "moin", "templates", "dictionary.js")
     with open(target, encoding="utf-8") as f:
         lines = f.readlines()
 
@@ -291,13 +332,13 @@ def find_js_phrases(starting_dir):
             continue
         m = pattern.search(line)
         if m:
-            if not m.group('key') == m.group('val'):
-                print('Error: /templates/dictionary.js dict has mismatched key and value on line', count)
-                print('   ', line.lstrip())
-            phrases.add(m.group('key'))
+            if not m.group("key") == m.group("val"):
+                print("Error: /templates/dictionary.js dict has mismatched key and value on line", count)
+                print("   ", line.lstrip())
+            phrases.add(m.group("key"))
         else:
-            print('Warning: /templates/dictionary.js {key: val} are not equal on line', count)
-            print('   ', line.lstrip())
+            print("Warning: /templates/dictionary.js {key: val} are not equal on line", count)
+            print("   ", line.lstrip())
 
 
 def check_js_phrases(lines, filename):
@@ -307,16 +348,16 @@ def check_js_phrases(lines, filename):
     Print error message if not defined in phrases, else add phrase to used phrases set.
     """
     global phrases_used
-    if filename.endswith('jquery.i18n.min.js') or filename.endswith('dictionary.js'):
+    if filename.endswith("jquery.i18n.min.js") or filename.endswith("dictionary.js"):
         return
     pattern = re.compile(r"""_\("([\w\s\d~`@#$%^&*()+=:;'<,>.?/!-?]+)"\)""")
     bad_pat = re.compile(r"""_\(([\w\s\d~`@#$%^&*()+=:;'<,>.?/!-?]+)\)""")
     for count, line in enumerate(lines, start=1):
-        if line.lstrip().startswith('// '):
+        if line.lstrip().startswith("// "):
             continue
-        if line.lstrip().startswith('function '):
+        if line.lstrip().startswith("function "):
             continue
-        if line.strip() == 'return $.i18n._(text);':
+        if line.strip() == "return $.i18n._(text);":
             continue
 
         m = pattern.search(line)
@@ -325,16 +366,15 @@ def check_js_phrases(lines, filename):
                 phrases_used.add(m.group(1))
             else:
                 print(
-                    'Error: %s file at line %s has phrase not defined in /templates/dictionary.js.'
-                    % (filename, count)
+                    "Error: %s file at line %s has phrase not defined in /templates/dictionary.js." % (filename, count)
                 )
-                print('   ', line.lstrip())
+                print("   ", line.lstrip())
         else:
             m = bad_pat.search(line)
             if m:
                 # _(variablename)
-                print('Warning: cannot verify i18n phrase defined in %s line %s.' % (filename, count))
-                print('   ', line.lstrip())
+                print("Warning: cannot verify i18n phrase defined in %s line %s." % (filename, count))
+                print("   ", line.lstrip())
 
 
 def unused_phrases():
@@ -344,7 +384,7 @@ def unused_phrases():
     unused = phrases - phrases_used
     if unused:
         for phrase in unused:
-            print('Warning: unused phrase defined in /templates/dictionary.js:', phrase)
+            print("Warning: unused phrase defined in /templates/dictionary.js:", phrase)
 
 
 if __name__ == "__main__":
@@ -352,7 +392,7 @@ def unused_phrases():
         starting_dir = os.path.abspath(sys.argv[1])
     else:
         starting_dir = os.path.abspath(os.path.dirname(__file__))
-        starting_dir = os.path.join(starting_dir.split(os.sep + 'scripts')[0], 'src')
+        starting_dir = os.path.join(starting_dir.split(os.sep + "scripts")[0], "src")
     NoDupsLogger().log("Starting directory is %s\n" % starting_dir, None)
     find_js_phrases(starting_dir)
     file_picker(starting_dir)
diff --git a/scripts/dos2unix.py b/scripts/dos2unix.py
index 5fa99e3e5..485984305 100644
--- a/scripts/dos2unix.py
+++ b/scripts/dos2unix.py
@@ -20,7 +20,7 @@ def convert_file(filename):
     """Replace DOS line endings with unix line endings."""
     with open(filename, "rb") as f:
         data = f.read()
-    if '\0' in data:
+    if "\0" in data:
         # is binary file
         return
     newdata = data.replace("\r\n", "\n")
@@ -33,7 +33,7 @@ def convert_file(filename):
     if len(sys.argv) == 2:
         target = sys.argv[1]
         if os.path.isdir(target):
-            for (dirpath, dirnames, filenames) in os.walk(target):
+            for dirpath, dirnames, filenames in os.walk(target):
                 break
             for filename in filenames:
                 convert_file(os.path.join(target, filename))
diff --git a/scripts/raw_wsgi_bench.py b/scripts/raw_wsgi_bench.py
index 7a7c1afb1..6b498a0e2 100644
--- a/scripts/raw_wsgi_bench.py
+++ b/scripts/raw_wsgi_bench.py
@@ -4,6 +4,7 @@
     @copyright: 2008 MoinMoin:FlorianKrupicka
     @license: GNU GPL, see COPYING for details.
 """
+
 import time
 import sys
 import os
@@ -12,30 +13,30 @@
 
 from moin.wsgiapp import application
 
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'tests'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "tests"))
 
 RUNS = 100
 RUNS_MARKER = RUNS // 10
 DOTS_MARKER = RUNS_MARKER // 5
 
-PAGES = ('FrontPage', 'HelpOnMoinWikiSyntax', 'RecentChanges')
+PAGES = ("FrontPage", "HelpOnMoinWikiSyntax", "RecentChanges")
 
 client = Client(application)
 
 for page in PAGES:
     print('=== Run with page "%s" ===' % page)
-    print('Running %i WSGI-requests:' % RUNS)
+    print("Running %i WSGI-requests:" % RUNS)
     timing = time.time()
     for run in range(RUNS):
-        appiter, status, headers = client.get('/%s' % page)
+        appiter, status, headers = client.get("/%s" % page)
         # result = ''.join(appiter)
-        if ((run + 1) % RUNS_MARKER == 0):
-            sys.stdout.write('%i' % (run + 1))
-        elif ((run + 1) % DOTS_MARKER == 0):
-            sys.stdout.write('.')
+        if (run + 1) % RUNS_MARKER == 0:
+            sys.stdout.write("%i" % (run + 1))
+        elif (run + 1) % DOTS_MARKER == 0:
+            sys.stdout.write(".")
     timing = time.time() - timing
 
     print()
-    print('Finished %i WSGI-requests in %.2f seconds' % (RUNS, timing))
-    print('Time per request: %.4f seconds' % (timing / RUNS))
-    print('Requests per second: %.2f' % (RUNS / timing))
+    print("Finished %i WSGI-requests in %.2f seconds" % (RUNS, timing))
+    print("Time per request: %.4f seconds" % (timing / RUNS))
+    print("Requests per second: %.2f" % (RUNS / timing))
diff --git a/scripts/wget.py b/scripts/wget.py
index 9b0534f4a..6d5864983 100644
--- a/scripts/wget.py
+++ b/scripts/wget.py
@@ -13,7 +13,7 @@
 import urllib.request
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     if len(sys.argv) == 3:
         urllib.request.urlretrieve(sys.argv[1], sys.argv[2])
     else:
diff --git a/src/moin/_tests/__init__.py b/src/moin/_tests/__init__.py
index 1e2338db8..3e12b7cd2 100644
--- a/src/moin/_tests/__init__.py
+++ b/src/moin/_tests/__init__.py
@@ -29,55 +29,56 @@
 
 
 def become_valid(username="ValidUser"):
-    """ modify flaskg.user to make the user valid.
-        Note that a valid user will only be in ACL special group "Known", if
-        we have a user profile for this user as the ACL system will check if
-        there is a userid for this username.
-        Thus, for testing purposes (e.g. if you need delete rights), it is
-        easier to use become_trusted().
+    """modify flaskg.user to make the user valid.
+    Note that a valid user will only be in ACL special group "Known", if
+    we have a user profile for this user as the ACL system will check if
+    there is a userid for this username.
+    Thus, for testing purposes (e.g. if you need delete rights), it is
+    easier to use become_trusted().
     """
-    flaskg.user.profile[NAME] = [username, ]
-    flaskg.user.may.names = [username, ]  # see security.DefaultSecurityPolicy class
+    flaskg.user.profile[NAME] = [username]
+    flaskg.user.may.names = [username]  # see security.DefaultSecurityPolicy class
     flaskg.user.valid = 1
 
 
 def become_trusted(username="TrustedUser"):
-    """ modify flaskg.user to make the user valid and trusted, so it is in acl group Trusted """
+    """modify flaskg.user to make the user valid and trusted, so it is in acl group Trusted"""
     become_valid(username)
     flaskg.user.trusted = True
 
 
 # Creating and destroying test items --------------------------------
 
+
 def update_item(name, meta, data):
-    """ creates or updates an item  """
+    """creates or updates an item"""
     if isinstance(data, str):
         data = data.encode(CHARSET)
-    fqname = CompositeName('', NAME_EXACT, name)
+    fqname = CompositeName("", NAME_EXACT, name)
     item = flaskg.storage.get_item(**fqname.query)
 
     meta = meta.copy()
     if NAME not in meta:
-        meta[NAME] = [name, ]
+        meta[NAME] = [name]
     if CONTENTTYPE not in meta:
-        meta[CONTENTTYPE] = 'application/octet-stream'
+        meta[CONTENTTYPE] = "application/octet-stream"
     rev = item.store_revision(meta, BytesIO(data), return_rev=True)
     return rev
 
 
 def create_random_string_list(length=14, count=10):
-    """ creates a list of random strings """
-    chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    """creates a list of random strings"""
+    chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
     return [f"{random_string(length, chars)}" for counter in range(count)]
 
 
 def nuke_item(name):
-    """ complete destroys an item """
+    """complete destroys an item"""
     item = Item.create(name)
     item.destroy()
 
 
-def check_connection(port, host='127.0.0.1'):
+def check_connection(port, host="127.0.0.1"):
     """
     Check if we can make a connection to host:port.
 
@@ -100,7 +101,7 @@ def get_dirs(subdir: str) -> tuple[Path, Path]:
               and artifacts_dir is Path to moin/_test_artifacts/{subdir}"""
     my_dir = Path(__file__).parent.resolve()
     moin_dir = my_dir.parents[2]
-    artifacts_dir = moin_dir / '_test_artifacts' / subdir
+    artifacts_dir = moin_dir / "_test_artifacts" / subdir
     if not artifacts_dir.exists():
         artifacts_dir.mkdir(parents=True)
     return moin_dir, artifacts_dir
@@ -108,7 +109,7 @@ def get_dirs(subdir: str) -> tuple[Path, Path]:
 
 def get_open_wiki_files():
     proc = psutil.Process()
-    files = [f for f in proc.open_files() if 'wiki' in f.path]
+    files = [f for f in proc.open_files() if "wiki" in f.path]
     for file in files:
-        print(f'open wiki {file}')
+        print(f"open wiki {file}")
     return files
diff --git a/src/moin/_tests/_test_template.py b/src/moin/_tests/_test_template.py
index 988ca4f52..a76eb29eb 100644
--- a/src/moin/_tests/_test_template.py
+++ b/src/moin/_tests/_test_template.py
@@ -15,56 +15,56 @@
 
 
 class TestSimpleStuff:
-    """ The simplest MoinMoin test class
+    """The simplest MoinMoin test class
 
     Class name must start with 'Test' to be included in
     the tests.
 
     See http://codespeak.net/py/dist/test.html for reference.
     """
+
     def testSimplest(self):
-        """ module_tested: test description...
+        """module_tested: test description...
 
         Function name MUST start with 'test' to be included in the
         tests.
         """
-        result = module_tested.some_function('test_value')
-        expected = 'expected value'
+        result = module_tested.some_function("test_value")
+        expected = "expected value"
         assert result == expected
 
 
 class TestComplexStuff:
-    """ Describe these tests here...
+    """Describe these tests here...
 
     Some tests may have a list of tests related to this test case. You
     can add a test by adding another line to this list
     """
+
     _tests = (
         # description, test, expected
-        ('Line break', '<<BR>>', '<br>'),
+        ("Line break", "<<BR>>", "<br>"),
     )
 
     from moin._tests import wikiconfig
 
     class Config(wikiconfig.Config):
-        foo = 'bar'  # we want to have this non-default setting
+        foo = "bar"  # we want to have this non-default setting
 
     def setup_class(self):
-        """ Stuff that should be run to init the state of this test class
-        """
+        """Stuff that should be run to init the state of this test class"""
 
     def teardown_class(self):
-        """ Stuff that should run to clean up the state of this test class
-        """
+        """Stuff that should run to clean up the state of this test class"""
 
     def testFunction(self):
-        """ module_tested: function should... """
+        """module_tested: function should..."""
         for description, test, expected in self._tests:
             result = self._helper_function(test)
             assert result == expected
 
     def _helper_fuction(self, test):
-        """ Some tests needs extra  work to run
+        """Some tests needs extra  work to run
 
         Keep the test non interesting details out of the way.
         """
diff --git a/src/moin/_tests/ldap_testbase.py b/src/moin/_tests/ldap_testbase.py
index f1c8abb9b..1b42391c5 100644
--- a/src/moin/_tests/ldap_testbase.py
+++ b/src/moin/_tests/ldap_testbase.py
@@ -57,27 +57,27 @@ def testFunction(self):
 
 # filename of LDAP server executable - if it is not
 # in your PATH, you have to give full path/filename.
-SLAPD_EXECUTABLE = 'slapd'
+SLAPD_EXECUTABLE = "slapd"
 
 
 def check_environ():
-    """ Check the system environment whether we are able to run.
-        Either return some failure reason if we can't or None if everything
-        looks OK.
+    """Check the system environment whether we are able to run.
+    Either return some failure reason if we can't or None if everything
+    looks OK.
     """
     if ldap is None:
         return "You need python-ldap installed to use ldap_testbase."
     slapd = False
     try:
-        p = subprocess.Popen([SLAPD_EXECUTABLE, '-V'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen([SLAPD_EXECUTABLE, "-V"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         pid = p.pid
         rc = p.wait()
         if pid and rc == 1:
             slapd = True  # it works
     except OSError as err:
         import errno
-        if not (err.errno == errno.ENOENT or
-                (err.errno == 3 and os.name == 'nt')):
+
+        if not (err.errno == errno.ENOENT or (err.errno == 3 and os.name == "nt")):
             raise
     if not slapd:
         return f"Can't start {SLAPD_EXECUTABLE} (see SLAPD_EXECUTABLE)."
@@ -85,14 +85,17 @@ def check_environ():
 
 
 class Slapd:
-    """ Manage a slapd process for testing purposes """
+    """Manage a slapd process for testing purposes"""
+
     def __init__(
         self,
         config=None,  # config filename for -f
         executable=SLAPD_EXECUTABLE,
-        debug_flags='',  # None,  # for -d stats,acl,args,trace,sync,config
-        proto='ldap', ip='127.0.0.1', port=3890,  # use -h proto://ip:port
-        service_name='',  # defaults to -n executable:port, use None to not use -n
+        debug_flags="",  # None,  # for -d stats,acl,args,trace,sync,config
+        proto="ldap",
+        ip="127.0.0.1",
+        port=3890,  # use -h proto://ip:port
+        service_name="",  # defaults to -n executable:port, use None to not use -n
     ):
         self.executable = executable
         self.config = config
@@ -100,21 +103,21 @@ def __init__(
         self.proto = proto
         self.ip = ip
         self.port = port
-        self.url = f'{proto}://{ip}:{port}'  # can be used for ldap.initialize() call
-        if service_name == '':
-            self.service_name = f'{executable}:{port}'
+        self.url = f"{proto}://{ip}:{port}"  # can be used for ldap.initialize() call
+        if service_name == "":
+            self.service_name = f"{executable}:{port}"
         else:
             self.service_name = service_name
 
     def start(self, timeout=0):
-        """ start a slapd process and optionally wait up to timeout seconds until it responds """
-        args = [self.executable, '-h', self.url, ]
+        """start a slapd process and optionally wait up to timeout seconds until it responds"""
+        args = [self.executable, "-h", self.url]
         if self.config is not None:
-            args.extend(['-f', self.config])
+            args.extend(["-f", self.config])
         if self.debug_flags is not None:
-            args.extend(['-d', self.debug_flags])
+            args.extend(["-d", self.debug_flags])
         if self.service_name:
-            args.extend(['-n', self.service_name])
+            args.extend(["-n", self.service_name])
         self.process = subprocess.Popen(args)
         started = None
         if timeout:
@@ -124,7 +127,7 @@ def start(self, timeout=0):
             wait_until = time.time() + timeout
             while time.time() < wait_until:
                 try:
-                    lo.simple_bind_s('', '')
+                    lo.simple_bind_s("", "")
                     started = True
                 except ldap.SERVER_DOWN:
                     time.sleep(0.1)
@@ -133,14 +136,14 @@ def start(self, timeout=0):
         return started
 
     def stop(self):
-        """ stop this slapd process and wait until it has terminated """
+        """stop this slapd process and wait until it has terminated"""
         pid = self.process.pid
         os.kill(pid, signal.SIGTERM)
         os.waitpid(pid, 0)
 
 
 class LdapEnvironment:
-    """ Manage a (temporary) environment for running a slapd in it """
+    """Manage a (temporary) environment for running a slapd in it"""
 
     # default DB_CONFIG bdb configuration file contents
     DB_CONFIG = """\
@@ -159,10 +162,11 @@ class LdapEnvironment:
     def __init__(
         self,
         basedn,
-        rootdn, rootpw,
+        rootdn,
+        rootpw,
         instance=0,  # use different values when running multiple LdapEnvironments
-        schema_dir='/etc/ldap/schema',  # directory with schemas
-        coding='utf-8',  # coding used for config files
+        schema_dir="/etc/ldap/schema",  # directory with schemas
+        coding="utf-8",  # coding used for config files
         timeout=10,  # how long to wait for slapd starting [s]
     ):
         self.basedn = basedn
@@ -176,45 +180,45 @@ def __init__(
         self.timeout = timeout
 
     def create_env(self, slapd_config, db_config=DB_CONFIG):
-        """ create a temporary LDAP server environment in a temp. directory,
-            including writing a slapd.conf (see configure_slapd) and a
-            DB_CONFIG there.
+        """create a temporary LDAP server environment in a temp. directory,
+        including writing a slapd.conf (see configure_slapd) and a
+        DB_CONFIG there.
         """
         # create directories
-        self.ldap_dir = tempfile.mkdtemp(prefix=f'LdapEnvironment-{self.instance}.')
-        self.ldap_db_dir = os.path.join(self.ldap_dir, 'db')
+        self.ldap_dir = tempfile.mkdtemp(prefix=f"LdapEnvironment-{self.instance}.")
+        self.ldap_db_dir = os.path.join(self.ldap_dir, "db")
         os.mkdir(self.ldap_db_dir)
 
         # create DB_CONFIG for bdb backend
-        db_config_fname = os.path.join(self.ldap_db_dir, 'DB_CONFIG')
-        f = open(db_config_fname, 'w')
+        db_config_fname = os.path.join(self.ldap_db_dir, "DB_CONFIG")
+        f = open(db_config_fname, "w")
         f.write(db_config)
         f.close()
 
-        hash_pw = hashlib.new('md5', self.rootpw.encode(self.coding))
-        rootpw = '{MD5}' + base64.b64encode(hash_pw.digest()).decode()
+        hash_pw = hashlib.new("md5", self.rootpw.encode(self.coding))
+        rootpw = "{MD5}" + base64.b64encode(hash_pw.digest()).decode()
 
         # create slapd.conf from content template in slapd_config
         slapd_config = slapd_config % {
-            'ldap_dir': self.ldap_dir,
-            'ldap_db_dir': self.ldap_db_dir,
-            'schema_dir': self.schema_dir,
-            'basedn': self.basedn,
-            'rootdn': self.rootdn,
-            'rootpw': rootpw,
+            "ldap_dir": self.ldap_dir,
+            "ldap_db_dir": self.ldap_db_dir,
+            "schema_dir": self.schema_dir,
+            "basedn": self.basedn,
+            "rootdn": self.rootdn,
+            "rootpw": rootpw,
         }
         self.slapd_conf = os.path.join(self.ldap_dir, "slapd.conf")
-        with open(self.slapd_conf, 'w', encoding=self.coding) as f:
+        with open(self.slapd_conf, "w", encoding=self.coding) as f:
             f.write(slapd_config)
 
     def start_slapd(self):
-        """ start a slapd and optionally wait until it talks with us """
+        """start a slapd and optionally wait until it talks with us"""
         self.slapd = Slapd(config=self.slapd_conf, port=3890 + self.instance)
         started = self.slapd.start(timeout=self.timeout)
         return started
 
     def load_directory(self, ldif_content):
-        """ load the directory with the ldif_content (str) """
+        """load the directory with the ldif_content (str)"""
         lo = ldap.initialize(self.slapd.url)
         ldap.set_option(ldap.OPT_PROTOCOL_VERSION, ldap.VERSION3)  # ldap v2 is outdated
         lo.simple_bind_s(self.rootdn, self.rootpw)
@@ -222,15 +226,16 @@ def load_directory(self, ldif_content):
         class LDIFLoader(ldif.LDIFParser):
             def handle(self, dn, entry):
                 lo.add_s(dn, ldap.modlist.addModlist(entry))
+
         loader = LDIFLoader(StringIO(ldif_content))
         loader.parse()
 
     def stop_slapd(self):
-        """ stop a slapd """
+        """stop a slapd"""
         self.slapd.stop()
 
     def destroy_env(self):
-        """ remove the temporary LDAP server environment """
+        """remove the temporary LDAP server environment"""
         shutil.rmtree(self.ldap_dir)
 
 
@@ -238,9 +243,9 @@ def destroy_env(self):
     import pytest
 
     class LDAPTstBase:
-        """ Test base class for pytest based tests which need a LDAP server to talk to.
+        """Test base class for pytest based tests which need a LDAP server to talk to.
 
-            Inherit your test class from this base class to test LDAP stuff.
+        Inherit your test class from this base class to test LDAP stuff.
         """
 
         # You MUST define these in your derived class:
@@ -251,17 +256,19 @@ class LDAPTstBase:
         rootpw = None  # root password
 
         def setup_class(self):
-            """ Create LDAP server environment, start slapd """
+            """Create LDAP server environment, start slapd"""
             self.ldap_env = LdapEnvironment(self.basedn, self.rootdn, self.rootpw)
             self.ldap_env.create_env(slapd_config=self.slapd_config)
             started = self.ldap_env.start_slapd()
             if not started:
-                pytest.skip("Failed to start {} process, please see your syslog / log files"
-                            " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE))
+                pytest.skip(
+                    "Failed to start {} process, please see your syslog / log files"
+                    " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE)
+                )
             self.ldap_env.load_directory(ldif_content=self.ldif_content)
 
         def teardown_class(self):
-            """ Stop slapd, remove LDAP server environment """
+            """Stop slapd, remove LDAP server environment"""
             self.ldap_env.stop_slapd()
             self.ldap_env.destroy_env()
 
diff --git a/src/moin/_tests/test_error.py b/src/moin/_tests/test_error.py
index fdb10e78e..974ad9669 100644
--- a/src/moin/_tests/test_error.py
+++ b/src/moin/_tests/test_error.py
@@ -11,33 +11,33 @@
 
 
 class TestEncoding:
-    """ MoinMoin errors do work with unicode transparently """
+    """MoinMoin errors do work with unicode transparently"""
 
     def testCreateWithUnicode(self):
-        """ error: create with unicode """
-        err = error.Error('טעות')
-        assert str(err) == 'טעות'
+        """error: create with unicode"""
+        err = error.Error("טעות")
+        assert str(err) == "טעות"
 
     def testCreateWithEncodedString(self):
-        """ error: create with encoded string """
-        err = error.Error('טעות'.encode())
-        assert str(err) == 'טעות'
+        """error: create with encoded string"""
+        err = error.Error("טעות".encode())
+        assert str(err) == "טעות"
 
     def testCreateWithObject(self):
-        """ error: create with any object """
+        """error: create with any object"""
 
         class Foo:
             def __str__(self):
-                return 'טעות'
+                return "טעות"
 
         err = error.Error(Foo())
-        assert str(err) == 'טעות'
+        assert str(err) == "טעות"
 
     def testAccessLikeDict(self):
-        """ error: access error like a dict """
-        test = 'value'
+        """error: access error like a dict"""
+        test = "value"
         err = error.Error(test)
-        assert '%(message)s' % dict(message=err) == test
+        assert "%(message)s" % dict(message=err) == test
 
 
 class TestCompositeError:
@@ -49,22 +49,22 @@ def teardown_method(self, method):
         self.CompositeError_obj.innerException = None
 
     def test_exceptions(self):
-        self.CompositeError_obj.innerException = 'test_error1', 'test_error2', 'test_error3'
+        self.CompositeError_obj.innerException = "test_error1", "test_error2", "test_error3"
         result = error.CompositeError.exceptions(self.CompositeError_obj)
-        expected = [('test_error1', 'test_error2', 'test_error3')]
+        expected = [("test_error1", "test_error2", "test_error3")]
         assert expected == result
-        self.CompositeError_obj.innerException = str(error.InternalError(''))
+        self.CompositeError_obj.innerException = str(error.InternalError(""))
 
     def test_subclasses(self):
-        self.CompositeError_obj.innerException = str(error.FatalError('This is an internal Error'))
+        self.CompositeError_obj.innerException = str(error.FatalError("This is an internal Error"))
         result = error.CompositeError.exceptions(self.CompositeError_obj)
-        expected = ['This is an internal Error']
+        expected = ["This is an internal Error"]
         assert result == expected
 
-        self.CompositeError_obj.innerException = str(error.FatalError('This is a fatal Error'))
+        self.CompositeError_obj.innerException = str(error.FatalError("This is a fatal Error"))
         result = error.CompositeError.exceptions(self.CompositeError_obj)
-        expected = ['This is a fatal Error']
+        expected = ["This is a fatal Error"]
         assert result == expected
 
 
-coverage_modules = ['moin.error']
+coverage_modules = ["moin.error"]
diff --git a/src/moin/_tests/test_forms.py b/src/moin/_tests/test_forms.py
index c1e044d3d..6f285646d 100644
--- a/src/moin/_tests/test_forms.py
+++ b/src/moin/_tests/test_forms.py
@@ -21,7 +21,7 @@
 def test_datetimeunix():
     dt = datetime.datetime(2012, 12, 21, 23, 45, 59)
     timestamp = timegm(dt.timetuple())
-    dt_u = '2012-12-21 23:45:59'
+    dt_u = "2012-12-21 23:45:59"
 
     d = DateTimeUNIX(timestamp)
     assert d.value == timestamp
@@ -41,14 +41,14 @@ def test_datetimeunix():
     assert d.value == timestamp
     assert d.u == dt_u
 
-    incorrect_timestring = '2012-10-30'
+    incorrect_timestring = "2012-10-30"
     d = DateTimeUNIX(incorrect_timestring)
     assert d.value is None
     assert d.u == incorrect_timestring
 
     d = DateTimeUNIX(None)
     assert d.value is None
-    assert d.u == ''
+    assert d.u == ""
 
 
 def test_validjson():
@@ -57,28 +57,29 @@ def test_validjson():
 
     Does not apply to usersettings form.
     """
-    app.cfg.namespace_mapping = [('', 'default_backend'), ('ns1', 'default_backend'), ('users', 'other_backend')]
-    item = Item.create('users/existingname')
-    meta = {NAMESPACE: 'users', CONTENTTYPE: 'text/plain;charset=utf-8'}
+    app.cfg.namespace_mapping = [("", "default_backend"), ("ns1", "default_backend"), ("users", "other_backend")]
+    item = Item.create("users/existingname")
+    meta = {NAMESPACE: "users", CONTENTTYPE: "text/plain;charset=utf-8"}
     become_trusted()
-    item._save(meta, data='This is a valid Item.')
+    item._save(meta, data="This is a valid Item.")
 
-    valid_itemid = 'a1924e3d0a34497eab18563299d32178'
+    valid_itemid = "a1924e3d0a34497eab18563299d32178"
     # ('names', 'namespace', 'field', 'value', 'result')
-    tests = [(['somename', '@revid'], '', '', 'somename', False),  # item names cannot begin with @
-             # TODO for above? - create item @x, get error message, change name in meta to xx,
-             # get an item with names @40x and alias of xx
-             (['bar', 'ns1'], '', '', 'bar', False),  # item names cannot match namespace names
-             (['foo', 'foo', 'bar'], '', '', 'foo', False),  # names in the name list must be unique.
-             # Item names must not match with existing namespaces; items cannot be in 2 namespaces
-             (['ns1ns2ns3', 'ns1/subitem'], '', '', 'valid', False),
-             # attempts to change itemid in meta result in "Item(s) named foobar, validname already exist."
-             (['foobar', 'validname'], '', ITEMID, valid_itemid + '8080', False),
-             (['barfoo', 'validname'], '', ITEMID, valid_itemid.replace('a', 'y'), False),  # similar to above
-             # deleting all names from the metadata of an existing item will make it nameless, succeeds
-             ([], '', 'itemid', valid_itemid, True),
-             (['existingname'], 'users', '', 'existingname', False),  # item already exists
-             ]
+    tests = [
+        (["somename", "@revid"], "", "", "somename", False),  # item names cannot begin with @
+        # TODO for above? - create item @x, get error message, change name in meta to xx,
+        # get an item with names @40x and alias of xx
+        (["bar", "ns1"], "", "", "bar", False),  # item names cannot match namespace names
+        (["foo", "foo", "bar"], "", "", "foo", False),  # names in the name list must be unique.
+        # Item names must not match with existing namespaces; items cannot be in 2 namespaces
+        (["ns1ns2ns3", "ns1/subitem"], "", "", "valid", False),
+        # attempts to change itemid in meta result in "Item(s) named foobar, validname already exist."
+        (["foobar", "validname"], "", ITEMID, valid_itemid + "8080", False),
+        (["barfoo", "validname"], "", ITEMID, valid_itemid.replace("a", "y"), False),  # similar to above
+        # deleting all names from the metadata of an existing item will make it nameless, succeeds
+        ([], "", "itemid", valid_itemid, True),
+        (["existingname"], "users", "", "existingname", False),  # item already exists
+    ]
     for name, namespace, field, value, result in tests:
         meta = {NAME: name, NAMESPACE: namespace}
         x = JSON(json.dumps(meta))
diff --git a/src/moin/_tests/test_test_environ.py b/src/moin/_tests/test_test_environ.py
index 452fa0d9f..6b370a3d4 100644
--- a/src/moin/_tests/test_test_environ.py
+++ b/src/moin/_tests/test_test_environ.py
@@ -28,11 +28,11 @@ def test_fresh_backends(self):
 
         storage = flaskg.storage
         assert storage
-        assert hasattr(storage, '__getitem__')
+        assert hasattr(storage, "__getitem__")
         itemname = "this item shouldn't exist yet"
         assert not storage.has_item(itemname)
         item = storage[itemname]
-        item.store_revision({NAME: [itemname, ], CONTENTTYPE: 'text/plain;charset=utf-8'}, BytesIO(b''))
+        item.store_revision({NAME: [itemname], CONTENTTYPE: "text/plain;charset=utf-8"}, BytesIO(b""))
         assert storage.has_item(itemname)
 
 
diff --git a/src/moin/_tests/test_user.py b/src/moin/_tests/test_user.py
index bbfda9c1a..a35f55c59 100644
--- a/src/moin/_tests/test_user.py
+++ b/src/moin/_tests/test_user.py
@@ -12,7 +12,7 @@
 
 from moin import user
 from moin.items import Item
-from moin.constants.keys import (ITEMID, NAME, NAMEPREFIX, NAMERE, NAMESPACE, TAGS)
+from moin.constants.keys import ITEMID, NAME, NAMEPREFIX, NAMERE, NAMESPACE, TAGS
 
 import pytest
 
@@ -24,7 +24,7 @@ def test_create_retrieve(self):
         email = "foo@example.org"
         # nonexisting user
         u = user.User(name=name, password=password)
-        assert u.name == [name, ]
+        assert u.name == [name]
         assert not u.valid
         assert not u.exists()
         # create a user
@@ -32,7 +32,7 @@ def test_create_retrieve(self):
         assert ret is None, f"create_user returned: {ret}"
         # existing user
         u = user.User(name=name, password=password)
-        assert u.name == [name, ]
+        assert u.name == [name]
         assert u.email == email
         assert u.valid
         assert u.exists()
@@ -50,9 +50,9 @@ def saved_user(self):
     # Passwords / Login -----------------------------------------------
 
     def testAsciiPassword(self):
-        """ user: login with ascii password """
+        """user: login with ascii password"""
         # Create test user
-        name = '__Non Existent User Name__'
+        name = "__Non Existent User Name__"
         password = name
         self.createUser(name, password)
 
@@ -61,9 +61,9 @@ def testAsciiPassword(self):
         assert theUser.valid
 
     def testUnicodePassword(self):
-        """ user: login with non-ascii password """
+        """user: login with non-ascii password"""
         # Create test user
-        name = '__שם משתמש לא קיים__'  # Hebrew
+        name = "__שם משתמש לא קיים__"  # Hebrew
         password = name
         self.createUser(name, password)
 
@@ -72,9 +72,9 @@ def testUnicodePassword(self):
         assert theUser.valid
 
     def testInvalidatePassword(self):
-        """ user: test invalidation of password """
+        """user: test invalidation of password"""
         # Create test user
-        name = '__Non Existent User Name__'
+        name = "__Non Existent User Name__"
         password = name
         self.createUser(name, password)
 
@@ -100,18 +100,20 @@ def testPasswordHash(self):
         with the correct password and can not log in with a wrong password.
         """
         # Create test user
-        name = 'Test User'
+        name = "Test User"
         # sha512_crypt passlib hash for '12345':
-        pw_hash = '$6$rounds=1001$y9ObPHKb8cvRCs5G$39IW1i5w6LqXPRi4xqAu3OKv1UO'\
-                  'pVKNkwk7zPnidsKZWqi1CrQBpl2wuq36J/s6yTxjCnmaGzv/2.dAmM8fDY/'
+        pw_hash = (
+            "$6$rounds=1001$y9ObPHKb8cvRCs5G$39IW1i5w6LqXPRi4xqAu3OKv1UO"
+            "pVKNkwk7zPnidsKZWqi1CrQBpl2wuq36J/s6yTxjCnmaGzv/2.dAmM8fDY/"
+        )
         self.createUser(name, pw_hash, True)
 
         # Try to "login" with correct password
-        theuser = user.User(name=name, password='12345')
+        theuser = user.User(name=name, password="12345")
         assert theuser.valid
 
         # Try to "login" with a wrong password
-        theuser = user.User(name=name, password='wrong')
+        theuser = user.User(name=name, password="wrong")
         assert not theuser.valid
 
     # Subscriptions ---------------------------------------------------
@@ -125,7 +127,7 @@ def test_subscriptions(self):
         item = Item.create(pagename)
         meta = item.meta
 
-        name = 'bar'
+        name = "bar"
         password = name
         email = "bar@example.org"
         user.create_user(name, password, email)
@@ -135,11 +137,13 @@ def test_subscriptions(self):
         result = the_user.unsubscribe(NAME, "OneMorePageName", "")
         assert result is False
 
-        subscriptions = [(ITEMID, meta[ITEMID], None),
-                         (NAME, pagename, meta[NAMESPACE]),
-                         (TAGS, tagname, meta[NAMESPACE]),
-                         (NAMEPREFIX, pagename[:4], meta[NAMESPACE]),
-                         (NAMERE, regexp, meta[NAMESPACE])]
+        subscriptions = [
+            (ITEMID, meta[ITEMID], None),
+            (NAME, pagename, meta[NAMESPACE]),
+            (TAGS, tagname, meta[NAMESPACE]),
+            (NAMEPREFIX, pagename[:4], meta[NAMESPACE]),
+            (NAMERE, regexp, meta[NAMESPACE]),
+        ]
         for subscription in subscriptions:
             keyword, value, namespace = subscription
             the_user.subscribe(keyword, value, namespace)
@@ -150,7 +154,7 @@ def test_subscriptions(self):
     # Bookmarks -------------------------------------------------------
 
     def test_bookmark(self):
-        name = 'Test_User_bookmark'
+        name = "Test_User_bookmark"
         password = name
         self.createUser(name, password)
         theUser = user.User(name=name, password=password)
@@ -174,8 +178,8 @@ def test_quicklinks(self):
         """
         Test for the quicklinks
         """
-        pagename = 'Test_page_quicklink'
-        name = 'Test_User_quicklink'
+        pagename = "Test_page_quicklink"
+        name = "Test_User_quicklink"
         password = name
         self.createUser(name, password)
         theUser = user.User(name=name, password=password)
@@ -188,13 +192,13 @@ def test_quicklinks(self):
         assert not result
 
         # add quicklink
-        theUser.quicklink('Test_page_added')
+        theUser.quicklink("Test_page_added")
         result_on_addition = theUser.quicklinks
-        expected = ['MoinTest/Test_page_added']
+        expected = ["MoinTest/Test_page_added"]
         assert result_on_addition == expected
 
         # remove quicklink
-        theUser.quickunlink('Test_page_added')
+        theUser.quickunlink("Test_page_added")
         result_on_removal = theUser.quicklinks
         expected = []
         assert result_on_removal == expected
@@ -202,7 +206,7 @@ def test_quicklinks(self):
     # Trail -----------------------------------------------------------
 
     def test_trail(self):
-        name = 'Test_User_trail'
+        name = "Test_User_trail"
         password = name
         self.createUser(name, password)
         theUser = user.User(name=name, password=password)
@@ -213,16 +217,16 @@ def test_trail(self):
         assert result == expected
 
         # item name added to trail
-        theUser.add_trail('item_added')
+        theUser.add_trail("item_added")
         theUser = user.User(name=name, password=password)
         result = theUser.get_trail()
-        expected = ['MoinTest/item_added']
+        expected = ["MoinTest/item_added"]
         assert result == expected
 
     # Sessions -------------------------------------------------------
 
     def test_sessions(self):
-        name = 'Test_User_sessions'
+        name = "Test_User_sessions"
         password = name
         self.createUser(name, password)
         theUser = user.User(name=name, password=password)
@@ -244,18 +248,18 @@ def test_sessions(self):
     # Other ----------------------------------------------------------
 
     def test_recovery_token(self):
-        name = 'Test_User_other'
+        name = "Test_User_other"
         password = name
         self.createUser(name, password)
         theUser = user.User(name=name, password=password)
 
         # use recovery token to generate new password
         test_token = theUser.generate_recovery_token()
-        result_success = theUser.apply_recovery_token(test_token, 'test_newpass')
+        result_success = theUser.apply_recovery_token(test_token, "test_newpass")
         assert result_success
 
         # wrong token
-        result_failure = theUser.apply_recovery_token('test_wrong_token', 'test_newpass')
+        result_failure = theUser.apply_recovery_token("test_wrong_token", "test_newpass")
         assert not result_failure
 
     # Helpers ---------------------------------------------------------
@@ -268,44 +272,40 @@ def createUser(self, name, password, pwencoded=False, email=None, validate=False
 class TestGroupName:
 
     def testGroupNames(self):
-        """ user: isValidName: reject group names """
-        test = 'AdminGroup'
+        """user: isValidName: reject group names"""
+        test = "AdminGroup"
         assert not user.isValidName(test)
 
 
 class TestIsValidName:
 
     def testNonAlnumCharacters(self):
-        """ user: isValidName: reject unicode non alpha numeric characters
+        """user: isValidName: reject unicode non alpha numeric characters
 
         : and , used in acl rules, we might add more characters to the syntax.
         """
         invalid = '! # $ % ^ & * ( ) = + , : ; " | ~ / \\ \u0000 \u202a'.split()
-        base = 'User{0}Name'
+        base = "User{0}Name"
         for c in invalid:
             name = base.format(c)
             assert not user.isValidName(name)
 
     def testWhitespace(self):
-        """ user: isValidName: reject leading, trailing or multiple whitespace """
-        cases = (
-            ' User Name',
-            'User Name ',
-            'User   Name',
-        )
+        """user: isValidName: reject leading, trailing or multiple whitespace"""
+        cases = (" User Name", "User Name ", "User   Name")
         for test in cases:
             assert not user.isValidName(test)
 
     def testValid(self):
-        """ user: isValidName: accept names in any language, with spaces """
+        """user: isValidName: accept names in any language, with spaces"""
         cases = (
-            'Jürgen Hermann',  # German
-            'ניר סופר',  # Hebrew
-            'CamelCase',  # Good old camel case
-            '가각간갇갈 갉갊감 갬갯걀갼'  # Hangul (gibberish)
+            "Jürgen Hermann",  # German
+            "ניר סופר",  # Hebrew
+            "CamelCase",  # Good old camel case
+            "가각간갇갈 갉갊감 갬갯걀갼",  # Hangul (gibberish)
         )
         for test in cases:
             assert user.isValidName(test)
 
 
-coverage_modules = ['moin.user']
+coverage_modules = ["moin.user"]
diff --git a/src/moin/_tests/test_wikiutil.py b/src/moin/_tests/test_wikiutil.py
index 2f3ef3b89..732971e50 100644
--- a/src/moin/_tests/test_wikiutil.py
+++ b/src/moin/_tests/test_wikiutil.py
@@ -28,25 +28,30 @@ def testCleanInput(self):
 
 
 class TestAnchorNames:
-    @pytest.mark.parametrize('text,expected', [
-        # old note: recent werkzeug encodes a "+" to "%2B", giving ".2B" in the end,
-        #       also "-" to "%2D", giving ".2D".
-        # ('\xf6\xf6ll\xdf\xdf', 'A.2BAPYA9g.2Dll.2BAN8A3w.2D'),
-        #                                   ^^^           ^^^
-        # -----------
-        # newer note:
-        # see #1496 'werkzeug.urls.url_quote_plus' is deprecated. Use 'urllib.parse.quote' instead.
-        # Contrary to werkzeug, urllib does not do: 'also "-" to "%2D", giving ".2D".'
-        ('\xf6\xf6ll\xdf\xdf', 'A.2BAPYA9g-ll.2BAN8A3w-'),
-        #                                 ^           ^
-        ('level 2', 'level_2'),
-        ('level_2', 'level_2'),
-        ('', 'A'),
-        ('123', 'A123'),
-        # make sure that a valid anchor is not modified:
-        ('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.',
-         'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.')
-    ])
+    @pytest.mark.parametrize(
+        "text,expected",
+        [
+            # old note: recent werkzeug encodes a "+" to "%2B", giving ".2B" in the end,
+            #       also "-" to "%2D", giving ".2D".
+            # ('\xf6\xf6ll\xdf\xdf', 'A.2BAPYA9g.2Dll.2BAN8A3w.2D'),
+            #                                   ^^^           ^^^
+            # -----------
+            # newer note:
+            # see #1496 'werkzeug.urls.url_quote_plus' is deprecated. Use 'urllib.parse.quote' instead.
+            # Contrary to werkzeug, urllib does not do: 'also "-" to "%2D", giving ".2D".'
+            ("\xf6\xf6ll\xdf\xdf", "A.2BAPYA9g-ll.2BAN8A3w-"),
+            #                                 ^           ^
+            ("level 2", "level_2"),
+            ("level_2", "level_2"),
+            ("", "A"),
+            ("123", "A123"),
+            # make sure that a valid anchor is not modified:
+            (
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.",
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_.",
+            ),
+        ],
+    )
     def test_anchor_name_encoding(self, text, expected):
         encoded = wikiutil.anchor_name_from_text(text)
         assert expected == encoded
@@ -56,22 +61,22 @@ class TestRelativeTools:
     tests = [
         # test                      expected output
         # CHILD_PREFIX
-        ('MainPage', '/SubPage1', 'MainPage/SubPage1'),
-        ('MainPage', '/SubPage1/SubPage2', 'MainPage/SubPage1/SubPage2'),
-        ('MainPage/SubPage1', '/SubPage2/SubPage3', 'MainPage/SubPage1/SubPage2/SubPage3'),
-        ('', '/OtherMainPage', 'OtherMainPage'),  # strange
+        ("MainPage", "/SubPage1", "MainPage/SubPage1"),
+        ("MainPage", "/SubPage1/SubPage2", "MainPage/SubPage1/SubPage2"),
+        ("MainPage/SubPage1", "/SubPage2/SubPage3", "MainPage/SubPage1/SubPage2/SubPage3"),
+        ("", "/OtherMainPage", "OtherMainPage"),  # strange
         # PARENT_PREFIX
-        ('MainPage/SubPage', '../SisterPage', 'MainPage/SisterPage'),
-        ('MainPage/SubPage1/SubPage2', '../SisterPage', 'MainPage/SubPage1/SisterPage'),
-        ('MainPage/SubPage1/SubPage2', '../../SisterPage', 'MainPage/SisterPage'),
-        ('MainPage', '../SisterPage', 'SisterPage'),  # strange
+        ("MainPage/SubPage", "../SisterPage", "MainPage/SisterPage"),
+        ("MainPage/SubPage1/SubPage2", "../SisterPage", "MainPage/SubPage1/SisterPage"),
+        ("MainPage/SubPage1/SubPage2", "../../SisterPage", "MainPage/SisterPage"),
+        ("MainPage", "../SisterPage", "SisterPage"),  # strange
     ]
 
-    @pytest.mark.parametrize('current_page,relative_page,absolute_page', tests)
+    @pytest.mark.parametrize("current_page,relative_page,absolute_page", tests)
     def test_abs_pagename(self, current_page, relative_page, absolute_page):
         assert absolute_page == wikiutil.AbsItemName(current_page, relative_page)
 
-    @pytest.mark.parametrize('current_page,relative_page,absolute_page', tests)
+    @pytest.mark.parametrize("current_page,relative_page,absolute_page", tests)
     def test_rel_pagename(self, current_page, relative_page, absolute_page):
         assert relative_page == wikiutil.RelItemName(current_page, absolute_page)
 
@@ -79,55 +84,55 @@ def test_rel_pagename(self, current_page, relative_page, absolute_page):
 class TestNormalizePagename:
 
     def testPageInvalidChars(self):
-        """ request: normalize pagename: remove invalid unicode chars
+        """request: normalize pagename: remove invalid unicode chars
 
         Assume the default setting
         """
-        test = '\u0000\u202a\u202b\u202c\u202d\u202e'
-        expected = ''
+        test = "\u0000\u202a\u202b\u202c\u202d\u202e"
+        expected = ""
         result = wikiutil.normalize_pagename(test, app.cfg)
         assert result == expected
 
     def testNormalizeSlashes(self):
-        """ request: normalize pagename: normalize slashes """
+        """request: normalize pagename: normalize slashes"""
         cases = (
-            ('/////', ''),
-            ('/a', 'a'),
-            ('a/', 'a'),
-            ('a/////b/////c', 'a/b/c'),
-            ('a b/////c d/////e f', 'a b/c d/e f'),
+            ("/////", ""),
+            ("/a", "a"),
+            ("a/", "a"),
+            ("a/////b/////c", "a/b/c"),
+            ("a b/////c d/////e f", "a b/c d/e f"),
         )
         for test, expected in cases:
             result = wikiutil.normalize_pagename(test, app.cfg)
             assert result == expected
 
     def testNormalizeWhitespace(self):
-        """ request: normalize pagename: normalize whitespace """
+        """request: normalize pagename: normalize whitespace"""
         cases = (
-            ('         ', ''),
-            ('    a', 'a'),
-            ('a    ', 'a'),
-            ('a     b     c', 'a b c'),
-            ('a   b  /  c    d  /  e   f', 'a b/c d/e f'),
+            ("         ", ""),
+            ("    a", "a"),
+            ("a    ", "a"),
+            ("a     b     c", "a b c"),
+            ("a   b  /  c    d  /  e   f", "a b/c d/e f"),
             # All 30 unicode spaces
-            (CHARS_SPACES, ''),
+            (CHARS_SPACES, ""),
         )
         for test, expected in cases:
             result = wikiutil.normalize_pagename(test, app.cfg)
             assert result == expected
 
     def testUnderscoreTestCase(self):
-        """ request: normalize pagename: underscore convert to spaces and normalized
+        """request: normalize pagename: underscore convert to spaces and normalized
 
         Underscores should convert to spaces, then spaces should be
         normalized, order is important!
         """
         cases = (
-            ('         ', ''),
-            ('  a', 'a'),
-            ('a  ', 'a'),
-            ('a  b  c', 'a b c'),
-            ('a  b  /  c  d  /  e  f', 'a b/c d/e f'),
+            ("         ", ""),
+            ("  a", "a"),
+            ("a  ", "a"),
+            ("a  b  c", "a b c"),
+            ("a  b  /  c  d  /  e  f", "a b/c d/e f"),
         )
         for test, expected in cases:
             result = wikiutil.normalize_pagename(test, app.cfg)
@@ -137,15 +142,15 @@ def testUnderscoreTestCase(self):
 class TestGroupItems:
 
     def testNormalizeGroupName(self):
-        """ request: normalize itemname: restrict groups to alpha numeric Unicode
+        """request: normalize itemname: restrict groups to alpha numeric Unicode
 
         Spaces should normalize after invalid chars removed!
         """
         cases = (
             # current acl chars
-            ('Name,:Group', 'NameGroup'),
+            ("Name,:Group", "NameGroup"),
             # remove than normalize spaces
-            ('Name ! @ # $ % ^ & * ( ) + Group', 'Name Group'),
+            ("Name ! @ # $ % ^ & * ( ) + Group", "Name Group"),
         )
         for test, expected in cases:
             # validate we are testing valid group names
@@ -156,46 +161,46 @@ def testNormalizeGroupName(self):
 
 def testParentItemName():
     # with no parent
-    result = wikiutil.ParentItemName('itemname')
-    expected = ''
+    result = wikiutil.ParentItemName("itemname")
+    expected = ""
     assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
     # with a parent
-    result = wikiutil.ParentItemName('some/parent/itemname')
-    expected = 'some/parent'
+    result = wikiutil.ParentItemName("some/parent/itemname")
+    expected = "some/parent"
     assert result == expected
 
 
 def testdrawing2fname():
     # with extension not in DRAWING_EXTENSIONS
-    result = wikiutil.drawing2fname('Moin_drawing.txt')
-    expected = 'Moin_drawing.txt.svgdraw'
+    result = wikiutil.drawing2fname("Moin_drawing.txt")
+    expected = "Moin_drawing.txt.svgdraw"
     assert result == expected
     # with extension in DRAWING_EXTENSIONS
-    result = wikiutil.drawing2fname('Moindir.Moin_drawing.jpg')
-    expected = 'Moindir.Moin_drawing.jpg'
+    result = wikiutil.drawing2fname("Moindir.Moin_drawing.jpg")
+    expected = "Moindir.Moin_drawing.jpg"
     assert result == expected
 
 
 def testgetUnicodeIndexGroup():
-    result = wikiutil.getUnicodeIndexGroup(['moin-2', 'MoinMoin'])
-    expected = 'MOIN-2'
+    result = wikiutil.getUnicodeIndexGroup(["moin-2", "MoinMoin"])
+    expected = "MOIN-2"
     assert result == expected
     # empty char
     with pytest.raises(IndexError):
-        result = wikiutil.getUnicodeIndexGroup('')
+        result = wikiutil.getUnicodeIndexGroup("")
 
 
 def testis_URL():
-    sample_schemes = ['http', 'https', 'ftp', 'ssh']
+    sample_schemes = ["http", "https", "ftp", "ssh"]
     for scheme in sample_schemes:
-        result = wikiutil.is_URL(scheme + ':MoinMoin')
+        result = wikiutil.is_URL(scheme + ":MoinMoin")
         assert result
 
     # arg without ':' which is a mandatory requirement
-    result = wikiutil.is_URL('MoinMoin')
+    result = wikiutil.is_URL("MoinMoin")
     assert not result
     # invalid scheme
-    result = wikiutil.is_URL('invalid_scheme:MoinMoin')
+    result = wikiutil.is_URL("invalid_scheme:MoinMoin")
     assert not result
 
 
@@ -205,7 +210,7 @@ def testcontainsConflictMarker():
     assert result
 
     # text without conflict marker
-    result = wikiutil.containsConflictMarker('No conflict marker')
+    result = wikiutil.containsConflictMarker("No conflict marker")
     assert not result
 
 
@@ -214,38 +219,38 @@ def testsplit_anchor():
     TODO: add the test for for split_anchor when we have better
           approach to deal wih problems like "#MoinMoin#" returning ("#MoinMoin", "")
     """
-    result = wikiutil.split_anchor('MoinMoin')
-    expected = 'MoinMoin', ''
+    result = wikiutil.split_anchor("MoinMoin")
+    expected = "MoinMoin", ""
     assert result == expected
 
-    result = wikiutil.split_anchor('MoinMoin#test_anchor|label|attr=val')
-    expected = ['MoinMoin', 'test_anchor|label|attr=val']
+    result = wikiutil.split_anchor("MoinMoin#test_anchor|label|attr=val")
+    expected = ["MoinMoin", "test_anchor|label|attr=val"]
     assert result == expected
 
-    result = wikiutil.split_anchor('#MoinMoin#')
-    expected = ['#MoinMoin', '']
+    result = wikiutil.split_anchor("#MoinMoin#")
+    expected = ["#MoinMoin", ""]
     assert result == expected
 
 
 def testfile_headers():
     test_headers = [
         # test_file, content_type
-        ('imagefile.gif', 'image/gif'),
-        ('testfile.txt', 'text/plain'),
-        ('pdffile.pdf', 'application/pdf'),
-        ('docfile.doc', 'application/msword'),
-        (None, 'application/octet-stream'),
+        ("imagefile.gif", "image/gif"),
+        ("testfile.txt", "text/plain"),
+        ("pdffile.pdf", "application/pdf"),
+        ("docfile.doc", "application/msword"),
+        (None, "application/octet-stream"),
     ]
 
     for test_file, content_type in test_headers:
         result = wikiutil.file_headers(test_file, None, 10)
-        expected = [('Content-Type', content_type), ('Content-Length', '10')]
+        expected = [("Content-Type", content_type), ("Content-Length", "10")]
         assert result == expected
 
     # filename is none and content type has a value
-    result = wikiutil.file_headers(None, 'text/plain')
-    expected = [('Content-Type', 'text/plain')]
+    result = wikiutil.file_headers(None, "text/plain")
+    expected = [("Content-Type", "text/plain")]
     assert result == expected
 
 
-coverage_modules = ['moin.wikiutil']
+coverage_modules = ["moin.wikiutil"]
diff --git a/src/moin/app.py b/src/moin/app.py
index 344165471..fede0bde7 100644
--- a/src/moin/app.py
+++ b/src/moin/app.py
@@ -36,10 +36,11 @@
 from moin.storage.middleware import protecting, indexing, routing
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
-if os.getcwd() not in sys.path and '' not in sys.path:
+if os.getcwd() not in sys.path and "" not in sys.path:
     # required in cases where wikiconfig_local.py imports wikiconfig_editme.py, see #698
     sys.path.append(os.getcwd())
 
@@ -51,8 +52,7 @@ def create_app(config=None):
     return create_app_ext(flask_config_file=config)
 
 
-def create_app_ext(flask_config_file=None, flask_config_dict=None,
-                   moin_config_class=None, warn_default=True, **kwargs):
+def create_app_ext(flask_config_file=None, flask_config_dict=None, moin_config_class=None, warn_default=True, **kwargs):
     """
     Factory for moin wsgi apps
 
@@ -71,35 +71,35 @@ def create_app_ext(flask_config_file=None, flask_config_dict=None,
                    into the moin configuration class (before its instance is created)
     """
     clock = Clock()
-    clock.start('create_app total')
+    clock.start("create_app total")
     logging.debug("running create_app_ext")
-    app = Flask('moin')
+    app = Flask("moin")
 
     c = get_current_context(silent=True)
-    info_name = getattr(c, 'info_name', '')
-    if getattr(c, 'command', False):
-        cmd_name = getattr(c.command, 'name', '')
+    info_name = getattr(c, "info_name", "")
+    if getattr(c, "command", False):
+        cmd_name = getattr(c.command, "name", "")
     else:
-        cmd_name = ''
+        cmd_name = ""
     logging.debug("info_name: %s cmd_name: %s", info_name, cmd_name)
     # help don't need config or backend and should run independent of a valid wiki instance
     # moin --help results in info_name=moin and cmd_name=cli
-    if (info_name == 'moin' and cmd_name == 'cli') or info_name == 'help':
+    if (info_name == "moin" and cmd_name == "cli") or info_name == "help":
         return app
 
-    clock.start('create_app load config')
+    clock.start("create_app load config")
     if flask_config_file:
         app.config.from_pyfile(path.abspath(flask_config_file))
     else:
-        if not app.config.from_envvar('MOINCFG', silent=True):
+        if not app.config.from_envvar("MOINCFG", silent=True):
             # no MOINCFG env variable set, try stuff in cwd:
-            flask_config_file = path.abspath('wikiconfig_local.py')
+            flask_config_file = path.abspath("wikiconfig_local.py")
             if not path.exists(flask_config_file):
-                flask_config_file = path.abspath('wikiconfig.py')
+                flask_config_file = path.abspath("wikiconfig.py")
                 if not path.exists(flask_config_file):
-                    if info_name == 'create-instance':  # moin CLI
+                    if info_name == "create-instance":  # moin CLI
                         config_path = path.dirname(config.__file__)
-                        flask_config_file = path.join(config_path, 'wikiconfig.py')
+                        flask_config_file = path.join(config_path, "wikiconfig.py")
                     else:
                         flask_config_file = None
             if flask_config_file:
@@ -108,7 +108,7 @@ def create_app_ext(flask_config_file=None, flask_config_dict=None,
         app.config.update(flask_config_dict)
     Config = moin_config_class
     if not Config:
-        Config = app.config.get('MOINCFG')
+        Config = app.config.get("MOINCFG")
     if not Config:
         if warn_default:
             logging.warning("using builtin default configuration")
@@ -117,10 +117,10 @@ def create_app_ext(flask_config_file=None, flask_config_dict=None,
         setattr(Config, key, value)
     if Config.secrets is None:
         # reuse the secret configured for flask (which is required for sessions)
-        Config.secrets = app.config.get('SECRET_KEY')
+        Config.secrets = app.config.get("SECRET_KEY")
     app.cfg = Config()
-    clock.stop('create_app load config')
-    clock.start('create_app register')
+    clock.stop("create_app load config")
+    clock.start("create_app register")
     # register converters
     from werkzeug.routing import PathConverter
 
@@ -132,59 +132,61 @@ class ItemNameConverter(PathConverter):
             Rule('/<itemname:wikipage>')
             Rule('/<itemname:wikipage>/edit')
         """
-        regex = '[^/]+?(/[^/]+?)*'
+
+        regex = "[^/]+?(/[^/]+?)*"
         weight = 200
 
-    app.url_map.converters['itemname'] = ItemNameConverter
+    app.url_map.converters["itemname"] = ItemNameConverter
 
     # register before/after request functions
     app.before_request(before_wiki)
     app.teardown_request(teardown_wiki)
     from moin.apps.frontend import frontend
+
     app.register_blueprint(frontend)
     from moin.apps.admin import admin
-    app.register_blueprint(admin, url_prefix='/+admin')
+
+    app.register_blueprint(admin, url_prefix="/+admin")
     from moin.apps.feed import feed
-    app.register_blueprint(feed, url_prefix='/+feed')
+
+    app.register_blueprint(feed, url_prefix="/+feed")
     from moin.apps.misc import misc
-    app.register_blueprint(misc, url_prefix='/+misc')
+
+    app.register_blueprint(misc, url_prefix="/+misc")
     from moin.apps.serve import serve
-    app.register_blueprint(serve, url_prefix='/+serve')
-    clock.stop('create_app register')
-    clock.start('create_app flask-cache')
+
+    app.register_blueprint(serve, url_prefix="/+serve")
+    clock.stop("create_app register")
+    clock.start("create_app flask-cache")
     # 'SimpleCache' caching uses a dict and is not thread safe according to the docs.
-    cache = Cache(config={'CACHE_TYPE': 'SimpleCache'})
+    cache = Cache(config={"CACHE_TYPE": "SimpleCache"})
     cache.init_app(app)
     app.cache = cache
-    clock.stop('create_app flask-cache')
+    clock.stop("create_app flask-cache")
     # init storage
-    clock.start('create_app init backends')
+    clock.start("create_app init backends")
     try:
         init_backends(app)
     except EmptyIndexError:
         # create-instance has no index at start and index-* subcommands check the index individually
-        if (info_name not in ['create-instance', 'build-instance', ]
-                and not info_name.startswith('index-')):
-            clock.stop('create_app init backends')
-            clock.stop('create_app total')
+        if info_name not in ["create-instance", "build-instance"] and not info_name.startswith("index-"):
+            clock.stop("create_app init backends")
+            clock.stop("create_app total")
             logging.error("Error: Wiki index not found. Try 'moin help' or 'moin --help' to get further information.")
             raise SystemExit(1)
         logging.debug("Wiki index not found.")
-    clock.stop('create_app init backends')
-    clock.start('create_app flask-babel')
+    clock.stop("create_app init backends")
+    clock.start("create_app flask-babel")
     i18n_init(app)
-    clock.stop('create_app flask-babel')
+    clock.stop("create_app flask-babel")
     # configure templates
-    clock.start('create_app flask-theme')
+    clock.start("create_app flask-theme")
     setup_themes(app)
     if app.cfg.template_dirs:
-        app.jinja_env.loader = ChoiceLoader([
-            FileSystemLoader(app.cfg.template_dirs),
-            app.jinja_env.loader,
-        ])
+        app.jinja_env.loader = ChoiceLoader([FileSystemLoader(app.cfg.template_dirs), app.jinja_env.loader])
     app.register_error_handler(403, themed_error)
-    clock.stop('create_app flask-theme')
-    clock.stop('create_app total')
+    clock.stop("create_app flask-theme")
+    clock.stop("create_app total")
     del clock
     return app
 
@@ -202,15 +204,18 @@ def init_backends(app, create_backend=False):
     # Just initialize with unprotected backends.
     logging.debug("running init_backends")
     app.router = routing.Backend(app.cfg.namespace_mapping, app.cfg.backend_mapping)
-    if create_backend or getattr(app.cfg, 'create_backend', False):
+    if create_backend or getattr(app.cfg, "create_backend", False):
         app.router.create()
     app.router.open()
-    app.storage = indexing.IndexingMiddleware(app.cfg.index_storage, app.router,
-                                              wiki_name=app.cfg.interwikiname,
-                                              acl_rights_contents=app.cfg.acl_rights_contents)
+    app.storage = indexing.IndexingMiddleware(
+        app.cfg.index_storage,
+        app.router,
+        wiki_name=app.cfg.interwikiname,
+        acl_rights_contents=app.cfg.acl_rights_contents,
+    )
 
     logging.debug("create_backend: %s ", str(create_backend))
-    if create_backend or getattr(app.cfg, 'create_backend', False):  # 2. call of init_backends
+    if create_backend or getattr(app.cfg, "create_backend", False):  # 2. call of init_backends
         app.storage.create()
     app.storage.open()
 
@@ -244,10 +249,10 @@ def setup_user():
 
     # then handle login/logout forms
     form = request.values.to_dict()
-    if 'login_submit' in form:
+    if "login_submit" in form:
         # this is a real form, submitted by POST
         userobj = auth.handle_login(userobj, **form)
-    elif 'logout_submit' in form:
+    elif "logout_submit" in form:
         # currently just a GET link
         userobj = auth.handle_logout(userobj)
     else:
@@ -255,20 +260,20 @@ def setup_user():
 
     # if we still have no user obj, create a dummy:
     if not userobj:
-        userobj = user.User(name=ANON, auth_method='invalid')
+        userobj = user.User(name=ANON, auth_method="invalid")
     # if we have a valid user we store it in the session
     if userobj.valid:
-        session['user.itemid'] = userobj.itemid
-        session['user.trusted'] = userobj.trusted
-        session['user.auth_method'] = userobj.auth_method
-        session['user.auth_attribs'] = userobj.auth_attribs
-        session['user.session_token'] = userobj.get_session_token()
+        session["user.itemid"] = userobj.itemid
+        session["user.trusted"] = userobj.trusted
+        session["user.auth_method"] = userobj.auth_method
+        session["user.auth_attribs"] = userobj.auth_attribs
+        session["user.session_token"] = userobj.get_session_token()
     return userobj
 
 
 def setup_user_anon():
-    """ Setup anonymous user when no request available - CLI """
-    flaskg.user = user.User(name=ANON, auth_method='invalid')
+    """Setup anonymous user when no request available - CLI"""
+    flaskg.user = user.User(name=ANON, auth_method="invalid")
 
 
 def before_wiki():
@@ -277,15 +282,15 @@ def before_wiki():
     """
     logging.debug("running before_wiki")
     flaskg.clock = Clock()
-    flaskg.clock.start('total')
-    flaskg.clock.start('init')
+    flaskg.clock.start("total")
+    flaskg.clock.start("init")
     try:
         flaskg.unprotected_storage = app.storage
         cli_no_request_ctx = False
         try:
             flaskg.user = setup_user()
         except RuntimeError:  # CLI call has no valid request context, create dummy
-            flaskg.user = user.User(name=ANON, auth_method='invalid')
+            flaskg.user = user.User(name=ANON, auth_method="invalid")
             cli_no_request_ctx = True
 
         flaskg.storage = protecting.ProtectingMiddleware(app.storage, flaskg.user, app.cfg.acl_mapping)
@@ -297,9 +302,9 @@ def before_wiki():
             flaskg.add_lineno_attr = False
         else:
             setup_jinja_env()
-            flaskg.add_lineno_attr = request.headers.get('User-Agent', None) and flaskg.user.edit_on_doubleclick
+            flaskg.add_lineno_attr = request.headers.get("User-Agent", None) and flaskg.user.edit_on_doubleclick
     finally:
-        flaskg.clock.stop('init')
+        flaskg.clock.stop("init")
 
 
 def teardown_wiki(response):
@@ -308,12 +313,12 @@ def teardown_wiki(response):
     """
     logging.debug("running teardown_wiki")
     try:
-        flaskg.clock.stop('total')
+        flaskg.clock.stop("total")
         del flaskg.clock
     except AttributeError:
         # can happen if teardown_wiki() is called twice, e.g. by unit tests.
         pass
-    if hasattr(flaskg, 'edit_utils'):
+    if hasattr(flaskg, "edit_utils"):
         # if transaction fails with sql file locked, we try to free it here
         try:
             flaskg.edit_utils.conn.close()
@@ -321,11 +326,15 @@ def teardown_wiki(response):
             pass
     try:
         # whoosh cache performance
-        for cache in (flaskg.storage.parse_acl, flaskg.storage.eval_acl,
-                      flaskg.storage.get_acls, flaskg.storage.allows, ):
+        for cache in (
+            flaskg.storage.parse_acl,
+            flaskg.storage.eval_acl,
+            flaskg.storage.get_acls,
+            flaskg.storage.allows,
+        ):
             if cache.cache_info()[3] > 0:
-                msg = 'cache = %s: hits = %s, misses = %s, maxsize = %s, size = %s' % (
-                    (cache.__name__, ) + cache.cache_info()
+                msg = "cache = %s: hits = %s, misses = %s, maxsize = %s, size = %s" % (
+                    (cache.__name__,) + cache.cache_info()
                 )
                 logging.debug(msg)
     except AttributeError:
diff --git a/src/moin/apps/admin/__init__.py b/src/moin/apps/admin/__init__.py
index d256da340..1baa32bc9 100644
--- a/src/moin/apps/admin/__init__.py
+++ b/src/moin/apps/admin/__init__.py
@@ -9,5 +9,6 @@
 
 
 from flask import Blueprint
-admin = Blueprint('admin', __name__, template_folder='templates')
+
+admin = Blueprint("admin", __name__, template_folder="templates")
 import moin.apps.admin.views  # noqa
diff --git a/src/moin/apps/admin/_tests/test_admin.py b/src/moin/apps/admin/_tests/test_admin.py
index de825aaf3..dcca5b773 100644
--- a/src/moin/apps/admin/_tests/test_admin.py
+++ b/src/moin/apps/admin/_tests/test_admin.py
@@ -11,54 +11,22 @@
 
 
 @pytest.mark.parametrize(
-    'url_for_args,status,data',
+    "url_for_args,status,data",
     (
-        (
-            {'endpoint': 'admin.register_new_user'},
-            '403 FORBIDDEN',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.index'},
-            '403 FORBIDDEN',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.userprofile', 'user_name': 'DoesntExist'},
-            '403 FORBIDDEN',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.wikiconfig'},
-            '403 FORBIDDEN',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.wikiconfighelp'},
-            '403 FORBIDDEN',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.interwikihelp'},
-            '200 OK',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.highlighterhelp'},
-            '200 OK',
-            ('<html>', '</html>'),
-        ),
-        (
-            {'endpoint': 'admin.itemsize'},
-            '200 OK',
-            ('<html>', '</html>'),
-        ),
+        ({"endpoint": "admin.register_new_user"}, "403 FORBIDDEN", ("<html>", "</html>")),
+        ({"endpoint": "admin.index"}, "403 FORBIDDEN", ("<html>", "</html>")),
+        ({"endpoint": "admin.userprofile", "user_name": "DoesntExist"}, "403 FORBIDDEN", ("<html>", "</html>")),
+        ({"endpoint": "admin.wikiconfig"}, "403 FORBIDDEN", ("<html>", "</html>")),
+        ({"endpoint": "admin.wikiconfighelp"}, "403 FORBIDDEN", ("<html>", "</html>")),
+        ({"endpoint": "admin.interwikihelp"}, "200 OK", ("<html>", "</html>")),
+        ({"endpoint": "admin.highlighterhelp"}, "200 OK", ("<html>", "</html>")),
+        ({"endpoint": "admin.itemsize"}, "200 OK", ("<html>", "</html>")),
     ),
 )
 def test_admin(app, url_for_args, status, data):
     with app.test_client() as c:
         rv = c.get(url_for(**url_for_args))
         assert rv.status == status
-        assert rv.headers['Content-Type'] == 'text/html; charset=utf-8'
+        assert rv.headers["Content-Type"] == "text/html; charset=utf-8"
         for item in data:
             assert item.encode() in rv.data
diff --git a/src/moin/apps/admin/views.py b/src/moin/apps/admin/views.py
index da22e0622..a72e02251 100644
--- a/src/moin/apps/admin/views.py
+++ b/src/moin/apps/admin/views.py
@@ -29,9 +29,29 @@
 from moin.apps.admin import admin
 from moin.apps.frontend.views import _using_moin_auth
 from moin import user
-from moin.constants.keys import (NAME, ITEMID, SIZE, EMAIL, DISABLED, NAME_EXACT, WIKINAME, TRASH, NAMESPACE,
-                                 NAME_OLD, REVID, REV_NUMBER, MTIME, COMMENT, LATEST_REVS, EMAIL_UNVALIDATED,
-                                 ACL, ACTION, ACTION_SAVE, SUBSCRIPTIONS, PARENTID)
+from moin.constants.keys import (
+    NAME,
+    ITEMID,
+    SIZE,
+    EMAIL,
+    DISABLED,
+    NAME_EXACT,
+    WIKINAME,
+    TRASH,
+    NAMESPACE,
+    NAME_OLD,
+    REVID,
+    REV_NUMBER,
+    MTIME,
+    COMMENT,
+    LATEST_REVS,
+    EMAIL_UNVALIDATED,
+    ACL,
+    ACTION,
+    ACTION_SAVE,
+    SUBSCRIPTIONS,
+    PARENTID,
+)
 from moin.constants.namespaces import NAMESPACE_USERPROFILES, NAMESPACE_USERS, NAMESPACE_DEFAULT, NAMESPACE_ALL
 from moin.constants.rights import SUPERUSER, ACL_RIGHTS_CONTENTS, READ, WRITE, CREATE, ADMIN, DESTROY
 from moin.security import require_permission, ACLStringIterator
@@ -47,28 +67,30 @@
 from moin.forms import RequiredText, YourEmail
 
 
-@admin.route('/superuser')
+@admin.route("/superuser")
 @require_permission(SUPERUSER)
 def index():
-    return render_template('admin/index.html', title_name=_("Admin"))
+    return render_template("admin/index.html", title_name=_("Admin"))
 
 
-@admin.route('/user')
+@admin.route("/user")
 def index_user():
-    return render_template('user/index_user.html',
-                           title_name=_("User"),
-                           flaskg=flaskg,
-                           NAMESPACE_USERPROFILES=NAMESPACE_USERPROFILES,
-                           app=app,
-                           )
+    return render_template(
+        "user/index_user.html",
+        title_name=_("User"),
+        flaskg=flaskg,
+        NAMESPACE_USERPROFILES=NAMESPACE_USERPROFILES,
+        app=app,
+    )
 
 
 class ValidRegisterNewUser(Validator):
     """
     Validator for RegisterNewUserForm.
     """
+
     def validate(self, element, state):
-        if not (element['username'].valid and element['email'].valid):
+        if not (element["username"].valid and element["email"].valid):
             return False
         return True
 
@@ -77,47 +99,48 @@ class RegisterNewUserForm(Form):
     """
     Simple user registration form for use by SuperUsers to create new accounts.
     """
-    name = 'register_new_user'
-    username = RequiredText.using(label=L_('Username')).with_properties(placeholder=L_("User Name"), autofocus=True)
+
+    name = "register_new_user"
+    username = RequiredText.using(label=L_("Username")).with_properties(placeholder=L_("User Name"), autofocus=True)
     email = YourEmail
-    submit_label = L_('Register')
+    submit_label = L_("Register")
     validators = [ValidRegisterNewUser()]
 
 
-@admin.route('/register_new_user', methods=['GET', 'POST', ])
+@admin.route("/register_new_user", methods=["GET", "POST"])
 @require_permission(SUPERUSER)
 def register_new_user():
     """
     Create a new account and send email with link to create password.
     """
     if not _using_moin_auth():
-        return Response('No MoinAuth in auth list', 403)
+        return Response("No MoinAuth in auth list", 403)
 
-    title_name = _('Register New User')
+    title_name = _("Register New User")
     FormClass = RegisterNewUserForm
 
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = FormClass.from_defaults()
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = FormClass.from_flat(request.form)
         if form.validate():
-            username = form['username'].value
-            email = form['email'].value
+            username = form["username"].value
+            email = form["email"].value
             user_profile = user.UserProfile()
             user_profile[ITEMID] = make_uuid()
-            user_profile[NAME] = [username, ]
+            user_profile[NAME] = [username]
             user_profile[EMAIL] = email
             user_profile[DISABLED] = False
             user_profile[ACTION] = ACTION_SAVE
 
             users = user.search_users(**{NAME_EXACT: username})
             if users:
-                flash(_('User already exists'), 'error')
+                flash(_("User already exists"), "error")
             emails = None
             if app.cfg.user_email_unique:
                 emails = user.search_users(email=email)
                 if emails:
-                    flash(_("This email already belongs to somebody else."), 'error')
+                    flash(_("This email already belongs to somebody else."), "error")
             if not (users or emails):
                 user_profile.save()
                 flash(_("Account for {username} created").format(username=username), "info")
@@ -129,17 +152,18 @@ def register_new_user():
                     if not is_ok:
                         flash(msg, "error")
                     else:
-                        flash(L_("{username} has been sent a password recovery email.").format(username=username), "info")
+                        flash(
+                            L_("{username} has been sent a password recovery email.").format(username=username), "info"
+                        )
                 else:
-                    flash(_("{username} is an invalid user, no email has been sent.").format(username=username), "error")
+                    flash(
+                        _("{username} is an invalid user, no email has been sent.").format(username=username), "error"
+                    )
 
-    return render_template('admin/register_new_user.html',
-                           title_name=title_name,
-                           form=form,
-                           )
+    return render_template("admin/register_new_user.html", title_name=title_name, form=form)
 
 
-@admin.route('/userbrowser')
+@admin.route("/userbrowser")
 @require_permission(SUPERUSER)
 def userbrowser():
     """
@@ -160,30 +184,35 @@ def userbrowser():
         for name in user_names[1:]:
             user_groups = user_groups + member_groups.get(name, [])
         subscriptions = rev.meta[SUBSCRIPTIONS]
-        user_accounts.append(dict(uid=rev.meta[ITEMID],
-                                  name=user_names,
-                                  fqname=CompositeName(NAMESPACE_USERS, NAME_EXACT, rev.name),
-                                  email=rev.meta[EMAIL] if EMAIL in rev.meta else rev.meta[EMAIL_UNVALIDATED],
-                                  disabled=rev.meta[DISABLED],
-                                  groups=user_groups,
-                                  subscriptions=subscriptions))
-    return render_template('admin/userbrowser.html', user_accounts=user_accounts, title_name=_("Users"))
-
-
-@admin.route('/userprofile/<user_name>', methods=['GET', 'POST', ])
+        user_accounts.append(
+            dict(
+                uid=rev.meta[ITEMID],
+                name=user_names,
+                fqname=CompositeName(NAMESPACE_USERS, NAME_EXACT, rev.name),
+                email=rev.meta[EMAIL] if EMAIL in rev.meta else rev.meta[EMAIL_UNVALIDATED],
+                disabled=rev.meta[DISABLED],
+                groups=user_groups,
+                subscriptions=subscriptions,
+            )
+        )
+    return render_template("admin/userbrowser.html", user_accounts=user_accounts, title_name=_("Users"))
+
+
+@admin.route("/userprofile/<user_name>", methods=["GET", "POST"])
 @require_permission(SUPERUSER)
 def userprofile(user_name):
     """
     Set values in user profile
     """
     u = user.User(auth_username=user_name)
-    if request.method == 'GET':
-        return _("User profile of {username}: {email} {disabled}").format(username=user_name,
-                 email=u.email, disabled=u.disabled)
-
-    if request.method == 'POST':
-        key = request.form.get('key', '')
-        val = request.form.get('val', '')
+    if request.method == "GET":
+        return _("User profile of {username}: {email} {disabled}").format(
+            username=user_name, email=u.email, disabled=u.disabled
+        )
+
+    if request.method == "POST":
+        key = request.form.get("key", "")
+        val = request.form.get("val", "")
         ok = False
         if hasattr(u, key):
             ok = True
@@ -199,19 +228,19 @@ def userprofile(user_name):
         if ok:
             u.profile[key] = val
             u.save()
-            flash(_('{0} "{1}" status changed to "{2}"').format(user_name, key, str(val), ), "info")
+            flash(_('{0} "{1}" status changed to "{2}"').format(user_name, key, str(val)), "info")
         else:
-            flash(_('modifying {0}.{1} failed').format(user_name, key, ), "error")
-    return redirect(url_for('.userbrowser'))
+            flash(_("modifying {0}.{1} failed").format(user_name, key), "error")
+    return redirect(url_for(".userbrowser"))
 
 
-@admin.route('/mail_recovery_token', methods=['GET', 'POST', ])
+@admin.route("/mail_recovery_token", methods=["GET", "POST"])
 @require_permission(SUPERUSER)
 def mail_recovery_token():
     """
     Send user an email so he can reset his password.
     """
-    username = request.form.get('username', '')
+    username = request.form.get("username", "")
     if username:
         u = user.User(auth_username=username)
         if u.valid:
@@ -224,17 +253,17 @@ def mail_recovery_token():
             flash(_("{0} is an invalid user, no email has been sent.").format(username), "error")
     else:
         flash(_("No user name provided, no email sent."), "error")
-    return redirect(url_for('.userbrowser'))
+    return redirect(url_for(".userbrowser"))
 
 
-@admin.route('/wikiconfig', methods=['GET', ])
+@admin.route("/wikiconfig", methods=["GET"])
 @require_permission(SUPERUSER)
 def wikiconfig():
     settings = {}
     for groupname in defaultconfig.options:
         heading, desc, opts = defaultconfig.options[groupname]
         for name, default, description in opts:
-            name = groupname + '_' + name
+            name = groupname + "_" + name
             if isinstance(default, defaultconfig.DefaultExpression):
                 default = default.value
             settings[name] = default
@@ -270,15 +299,17 @@ def iter_vnames(cfg):
 
     found.sort()
     found_default.sort()
-    return render_template('admin/wikiconfig.html',
-                           title_name=_("Show Wiki Configuration"),
-                           len=len,
-                           found=found,
-                           found_default=found_default,
-                           settings=settings)
+    return render_template(
+        "admin/wikiconfig.html",
+        title_name=_("Show Wiki Configuration"),
+        len=len,
+        found=found,
+        found_default=found_default,
+        settings=settings,
+    )
 
 
-@admin.route('/wikiconfighelp', methods=['GET', ])
+@admin.route("/wikiconfighelp", methods=["GET"])
 @require_permission(SUPERUSER)
 def wikiconfighelp():
     max_len_default = 60
@@ -288,17 +319,17 @@ def format_default(default):
             default_txt = default.text
         else:
             if len(repr(default)) > max_len_default and isinstance(default, list) and len(default) > 1:
-                txt = ['[']
+                txt = ["["]
                 for entry in default:
-                    txt.append(f'&#013;{repr(entry)},')
-                txt.append('&#013;]')
-                return ''.join(txt)
+                    txt.append(f"&#013;{repr(entry)},")
+                txt.append("&#013;]")
+                return "".join(txt)
             elif len(repr(default)) > max_len_default and isinstance(default, dict) and len(default) > 1:
-                txt = ['{']
+                txt = ["{"]
                 for key, val in default.items():
-                    txt.append(f'&#013;{repr(key)}: {repr(val)},')
-                txt.append('&#013;}')
-                return ''.join(txt)
+                    txt.append(f"&#013;{repr(key)}: {repr(val)},")
+                txt.append("&#013;}")
+                return "".join(txt)
             else:
                 default_txt = repr(default)
         return default_txt
@@ -306,103 +337,98 @@ def format_default(default):
     groups = []
     for groupname in defaultconfig.options:
         heading, desc, opts = defaultconfig.options[groupname]
-        opts = sorted([(groupname + '_' + name, format_default(default), description)
-                       for name, default, description in opts])
+        opts = sorted(
+            [(groupname + "_" + name, format_default(default), description) for name, default, description in opts]
+        )
         groups.append((heading, desc, opts))
     for groupname in defaultconfig.options_no_group_name:
         heading, desc, opts = defaultconfig.options_no_group_name[groupname]
-        opts = sorted([(name, format_default(default), description)
-                       for name, default, description in opts])
+        opts = sorted([(name, format_default(default), description) for name, default, description in opts])
         groups.append((heading, desc, opts))
     groups.sort()
-    return render_template('admin/wikiconfighelp.html',
-                           title_name=_("Wiki Configuration Help"),
-                           groups=groups,
-                           len=len,
-                           max_len_default=max_len_default,
-                           )
+    return render_template(
+        "admin/wikiconfighelp.html",
+        title_name=_("Wiki Configuration Help"),
+        groups=groups,
+        len=len,
+        max_len_default=max_len_default,
+    )
 
 
-@admin.route('/highlighterhelp', methods=['GET', ])
+@admin.route("/highlighterhelp", methods=["GET"])
 def highlighterhelp():
     """display a table with list of available Pygments lexers"""
     import pygments.lexers
-    headings = [
-        _('Lexer description'),
-        _('Lexer names'),
-        _('File patterns'),
-        _('Mimetypes'),
-    ]
+
+    headings = [_("Lexer description"), _("Lexer names"), _("File patterns"), _("Mimetypes")]
     lexers = pygments.lexers.get_all_lexers()
-    rows = sorted([[desc, ' '.join(names), ' '.join(patterns), ' '.join(mimetypes), ]
-                   for desc, names, patterns, mimetypes in lexers])
-    return render_template('user/highlighterhelp.html',
-                           title_name=_("Highlighters"),
-                           headings=headings,
-                           rows=rows)
+    rows = sorted(
+        [
+            [desc, " ".join(names), " ".join(patterns), " ".join(mimetypes)]
+            for desc, names, patterns, mimetypes in lexers
+        ]
+    )
+    return render_template("user/highlighterhelp.html", title_name=_("Highlighters"), headings=headings, rows=rows)
 
 
-@admin.route('/interwikihelp', methods=['GET', ])
+@admin.route("/interwikihelp", methods=["GET"])
 def interwikihelp():
     """display a table with list of known interwiki names / urls"""
-    headings = [
-        _('InterWiki name'),
-        _('URL'),
-    ]
+    headings = [_("InterWiki name"), _("URL")]
     rows = sorted(app.cfg.interwiki_map.items())
-    return render_template('user/interwikihelp.html',
-                           title_name=_("Interwiki Names"),
-                           headings=headings,
-                           rows=rows)
+    return render_template("user/interwikihelp.html", title_name=_("Interwiki Names"), headings=headings, rows=rows)
 
 
-@admin.route('/itemsize', methods=['GET', ])
+@admin.route("/itemsize", methods=["GET"])
 def itemsize():
     """display a table with item sizes"""
-    headings = [
-        _('Size'),
-        _('Item name'),
-    ]
-    query = And([Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES)),
-                 Not(Term(TRASH, True))])
+    headings = [_("Size"), _("Item name")]
+    query = And(
+        [Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES)), Not(Term(TRASH, True))]
+    )
     revs = flaskg.storage.search_meta(query, idx_name=LATEST_REVS, sortedby=[NAME], limit=None)
-    rows = [(rev[SIZE], CompositeName(rev[NAMESPACE], NAME_EXACT, rev[NAME][0]))
-            for rev in revs]
+    rows = [(rev[SIZE], CompositeName(rev[NAMESPACE], NAME_EXACT, rev[NAME][0])) for rev in revs]
     rows = sorted(rows, reverse=True)
-    return render_template('user/itemsize.html',
-                           title_name=_("Item Sizes"),
-                           headings=headings,
-                           rows=rows)
+    return render_template("user/itemsize.html", title_name=_("Item Sizes"), headings=headings, rows=rows)
 
 
-@admin.route('/trash', defaults=dict(namespace=NAMESPACE_DEFAULT), methods=['GET'])
-@admin.route('/<namespace>/trash')
+@admin.route("/trash", defaults=dict(namespace=NAMESPACE_DEFAULT), methods=["GET"])
+@admin.route("/<namespace>/trash")
 @require_permission(SUPERUSER)
 def trash(namespace):
     """
     Returns the trashed items.
     """
     trash = _trashed(namespace)
-    return render_template('admin/trash.html',
-                           headline=_('Trashed Items'),
-                           title_name=_('Trashed Items'),
-                           results=trash)
+    return render_template(
+        "admin/trash.html", headline=_("Trashed Items"), title_name=_("Trashed Items"), results=trash
+    )
 
 
 def _trashed(namespace):
     q = And([Term(WIKINAME, app.cfg.interwikiname), Term(TRASH, True)])
     if namespace != NAMESPACE_ALL:
-        q = And([q, Term(NAMESPACE, namespace), ])
-    trashedEntry = namedtuple('trashedEntry', 'fqname oldname revid rev_number mtime comment editor parentid')
+        q = And([q, Term(NAMESPACE, namespace)])
+    trashedEntry = namedtuple("trashedEntry", "fqname oldname revid rev_number mtime comment editor parentid")
     results = []
     for meta in flaskg.storage.search_meta(q, limit=None):
         fqname = CompositeName(meta[NAMESPACE], ITEMID, meta[ITEMID])
-        results.append(trashedEntry(fqname, meta[NAME_OLD], meta[REVID], meta[REV_NUMBER], meta[MTIME],
-                                    meta[COMMENT], get_editor_info(meta), meta[PARENTID]))
+        results.append(
+            trashedEntry(
+                fqname,
+                meta[NAME_OLD],
+                meta[REVID],
+                meta[REV_NUMBER],
+                meta[MTIME],
+                meta[COMMENT],
+                get_editor_info(meta),
+                meta[PARENTID],
+            )
+        )
     return results
 
 
-@admin.route('/user_acl_report/<uid>', methods=['GET'])
+@admin.route("/user_acl_report/<uid>", methods=["GET"])
 @require_permission(SUPERUSER)
 def user_acl_report(uid):
     query = And([Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES))])
@@ -411,26 +437,32 @@ def user_acl_report(uid):
     itemwise_acl = []
     for meta in all_metas:
         fqname = gen_fqnames(meta)
-        acl_parts = {'name': meta.get(NAME),
-                     'namespace': meta.get(NAMESPACE),
-                     'itemid': meta.get(ITEMID),
-                     'fqname': fqname}
+        acl_parts = {
+            "name": meta.get(NAME),
+            "namespace": meta.get(NAMESPACE),
+            "itemid": meta.get(ITEMID),
+            "fqname": fqname,
+        }
         parentnames = tuple(parent_names(meta[NAME]))
         usernames = tuple(theuser.name)
         acl = meta.get(ACL, None)
-        last_item_result = {'read': flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], READ),
-                            'write': flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], WRITE),
-                            'create': flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], CREATE),
-                            'admin': flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], ADMIN),
-                            'destroy': flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], DESTROY)}
+        last_item_result = {
+            "read": flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], READ),
+            "write": flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], WRITE),
+            "create": flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], CREATE),
+            "admin": flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], ADMIN),
+            "destroy": flaskg.storage.allows(usernames, acl, parentnames, meta[NAMESPACE], DESTROY),
+        }
         itemwise_acl.append({**acl_parts, **last_item_result})
-    return render_template('admin/user_acl_report.html',
-                           title_name=_('User ACL Report'),
-                           user_names=theuser.name,
-                           itemwise_acl=itemwise_acl)
+    return render_template(
+        "admin/user_acl_report.html",
+        title_name=_("User ACL Report"),
+        user_names=theuser.name,
+        itemwise_acl=itemwise_acl,
+    )
 
 
-@admin.route('/groupbrowser', methods=['GET'])
+@admin.route("/groupbrowser", methods=["GET"])
 @require_permission(SUPERUSER)
 def groupbrowser():
     """
@@ -439,21 +471,23 @@ def groupbrowser():
     all_groups = flaskg.groups
     groups = []
     for group in all_groups:
-        group_type = ''
+        group_type = ""
         if isinstance(all_groups[group], WikiGroup):
-            group_type = 'WikiGroup'
+            group_type = "WikiGroup"
         else:
-            group_type = 'ConfigGroup'
-        groups.append(dict(name=all_groups[group].name,
-                           member_users=all_groups[group].members,
-                           member_groups=all_groups[group].member_groups,
-                           grouptype=group_type))
-    return render_template('admin/groupbrowser.html',
-                           title_name=_('Groups'),
-                           groups=groups)
-
-
-@admin.route('/item_acl_report', methods=['GET'])
+            group_type = "ConfigGroup"
+        groups.append(
+            dict(
+                name=all_groups[group].name,
+                member_users=all_groups[group].members,
+                member_groups=all_groups[group].member_groups,
+                grouptype=group_type,
+            )
+        )
+    return render_template("admin/groupbrowser.html", title_name=_("Groups"), groups=groups)
+
+
+@admin.route("/item_acl_report", methods=["GET"])
 @require_permission(SUPERUSER)
 def item_acl_report():
     """
@@ -462,14 +496,14 @@ def item_acl_report():
     Item names are prefixed with the namespace, if there is a non-default namespace.
     If there are multiple names, the first name is used for sorting.
     """
-    query = And([Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES)), ])
+    query = And([Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES))])
     all_metas = flaskg.storage.search_meta(query, idx_name=LATEST_REVS, sortedby=[NAMESPACE, NAME], limit=None)
     items_acls = []
     for meta in all_metas:
         item_namespace = meta.get(NAMESPACE)
         item_id = meta.get(ITEMID)
         if item_namespace:
-            item_name = [item_namespace + '/' + name for name in meta.get(NAME)]
+            item_name = [item_namespace + "/" + name for name in meta.get(NAME)]
         else:
             item_name = meta.get(NAME)
         item_acl = meta.get(ACL)
@@ -477,22 +511,28 @@ def item_acl_report():
         if acl_default:
             for namespace, acl_config in app.cfg.acl_mapping:
                 if item_namespace == namespace:
-                    item_acl = acl_config['default']
+                    item_acl = acl_config["default"]
         fqnames = gen_fqnames(meta)
-        items_acls.append({'name': item_name,
-                           'name_old': meta.get('name_old', []),
-                           'itemid': item_id,
-                           'fqnames': fqnames,
-                           'fqname': fqnames[0],
-                           'acl': item_acl,
-                           'acl_default': acl_default})
+        items_acls.append(
+            {
+                "name": item_name,
+                "name_old": meta.get("name_old", []),
+                "itemid": item_id,
+                "fqnames": fqnames,
+                "fqname": fqnames[0],
+                "acl": item_acl,
+                "acl_default": acl_default,
+            }
+        )
     # deleted items have no names; this sort places deleted items on top of the report;
     # the display name may be similar to: "9cf939f ~(DeletedItemName)"
-    items_acls = sorted(items_acls, key=lambda k: (k['name'], k['name_old']))
-    return render_template('admin/item_acl_report.html',
-                           title_name=_('Item ACL Report'),
-                           number_items=len(items_acls),
-                           items_acls=items_acls)
+    items_acls = sorted(items_acls, key=lambda k: (k["name"], k["name_old"]))
+    return render_template(
+        "admin/item_acl_report.html",
+        title_name=_("Item ACL Report"),
+        number_items=len(items_acls),
+        items_acls=items_acls,
+    )
 
 
 def search_group(group_name):
@@ -503,7 +543,7 @@ def search_group(group_name):
         raise GroupDoesNotExistError(group_name)
 
 
-@admin.route('/group_acl_report/<group_name>')
+@admin.route("/group_acl_report/<group_name>")
 @require_permission(SUPERUSER)
 def group_acl_report(group_name):
     """
@@ -514,47 +554,62 @@ def group_acl_report(group_name):
     all_metas = flaskg.storage.search_meta(query, idx_name=LATEST_REVS, sortedby=[NAMESPACE, NAME], limit=None)
     group_items = []
     for meta in all_metas:
-        acl_iterator = ACLStringIterator(ACL_RIGHTS_CONTENTS, meta.get(ACL, ''))
+        acl_iterator = ACLStringIterator(ACL_RIGHTS_CONTENTS, meta.get(ACL, ""))
         for modifier, entries, rights in acl_iterator:
             if group_name in entries:
                 fqname = gen_fqnames(meta)
-                group_items.append(dict(name=meta.get(NAME),
-                                        itemid=meta.get(ITEMID),
-                                        namespace=meta.get(NAMESPACE),
-                                        fqname=fqname,
-                                        rights=rights))
-    return render_template('admin/group_acl_report.html',
-                           title_name=_('Group ACL Report'),
-                           group_items=group_items,
-                           group_name=group_name)
-
-
-@admin.route('/modify_acl/<itemname:item_name>', methods=['POST'])
+                group_items.append(
+                    dict(
+                        name=meta.get(NAME),
+                        itemid=meta.get(ITEMID),
+                        namespace=meta.get(NAMESPACE),
+                        fqname=fqname,
+                        rights=rights,
+                    )
+                )
+    return render_template(
+        "admin/group_acl_report.html", title_name=_("Group ACL Report"), group_items=group_items, group_name=group_name
+    )
+
+
+@admin.route("/modify_acl/<itemname:item_name>", methods=["POST"])
 @require_permission(SUPERUSER)
 def modify_acl(item_name):
     fqname = split_fqname(item_name)
     item = Item.create(item_name)
     meta = dict(item.meta)
-    old_acl = meta.get(ACL, '')
+    old_acl = meta.get(ACL, "")
     new_acl = request.form.get(fqname.fullname)
     is_valid = acl_validate(new_acl)
     if is_valid:
-        if new_acl in ('Empty', ''):
-            meta[ACL] = ''
-        elif new_acl == 'None' and ACL in meta:
-            del (meta[ACL])
+        if new_acl in ("Empty", ""):
+            meta[ACL] = ""
+        elif new_acl == "None" and ACL in meta:
+            del meta[ACL]
         else:
             meta[ACL] = new_acl
         try:
             item._save(meta=meta)
         except AccessDenied:
             # superuser viewed item acl report and tried to change acl but lacked admin permission
-            flash(L_("Failed! Not authorized.<br>Item: {item_name}<br>ACL: {acl_rule}"
-                     ).format(item_name=fqname.fullname, acl_rule=old_acl), "error")
-            return redirect(url_for('.item_acl_report'))
-        flash(L_("Success! ACL saved.<br>Item: {item_name}<br>ACL: {acl_rule}"
-                 ).format(item_name=fqname.fullname, acl_rule=new_acl), "info")
+            flash(
+                L_("Failed! Not authorized.<br>Item: {item_name}<br>ACL: {acl_rule}").format(
+                    item_name=fqname.fullname, acl_rule=old_acl
+                ),
+                "error",
+            )
+            return redirect(url_for(".item_acl_report"))
+        flash(
+            L_("Success! ACL saved.<br>Item: {item_name}<br>ACL: {acl_rule}").format(
+                item_name=fqname.fullname, acl_rule=new_acl
+            ),
+            "info",
+        )
     else:
-        flash(L_("Nothing changed, invalid ACL.<br>Item: {item_name}<br>ACL: {acl_rule}"
-                 ).format(item_name=fqname.fullname, acl_rule=new_acl), "error")
-    return redirect(url_for('.item_acl_report'))
+        flash(
+            L_("Nothing changed, invalid ACL.<br>Item: {item_name}<br>ACL: {acl_rule}").format(
+                item_name=fqname.fullname, acl_rule=new_acl
+            ),
+            "error",
+        )
+    return redirect(url_for(".item_acl_report"))
diff --git a/src/moin/apps/feed/__init__.py b/src/moin/apps/feed/__init__.py
index 327e2ff35..ee12406c0 100644
--- a/src/moin/apps/feed/__init__.py
+++ b/src/moin/apps/feed/__init__.py
@@ -10,5 +10,6 @@
 
 
 from flask import Blueprint
-feed = Blueprint('feed', __name__)
+
+feed = Blueprint("feed", __name__)
 import moin.apps.feed.views  # noqa
diff --git a/src/moin/apps/feed/_tests/test_feed.py b/src/moin/apps/feed/_tests/test_feed.py
index ff05928dd..50dd08928 100644
--- a/src/moin/apps/feed/_tests/test_feed.py
+++ b/src/moin/apps/feed/_tests/test_feed.py
@@ -14,28 +14,28 @@
 class TestFeeds:
     def test_global_atom(self, app):
         with app.test_client() as c:
-            rv = c.get(url_for('feed.atom'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'application/atom+xml'
-            assert rv.data.startswith(b'<?xml')
+            rv = c.get(url_for("feed.atom"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "application/atom+xml"
+            assert rv.data.startswith(b"<?xml")
             assert b'<feed xmlns="http://www.w3.org/2005/Atom">' in rv.data
-            assert b'</feed>' in rv.data
+            assert b"</feed>" in rv.data
 
     def test_global_atom_with_an_item(self, app):
-        basename = 'Foo'
-        update_item(basename, {COMMENT: "foo data for feed item"}, '')
+        basename = "Foo"
+        update_item(basename, {COMMENT: "foo data for feed item"}, "")
         with app.test_client() as c:
-            rv = c.get(url_for('feed.atom'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'application/atom+xml'
-            assert rv.data.startswith(b'<?xml')
+            rv = c.get(url_for("feed.atom"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "application/atom+xml"
+            assert rv.data.startswith(b"<?xml")
             assert b"foo data for feed item" in rv.data
 
         # tests the cache invalidation
-        update_item(basename, {COMMENT: "checking if the cache invalidation works"}, '')
+        update_item(basename, {COMMENT: "checking if the cache invalidation works"}, "")
         with app.test_client() as c:
-            rv = c.get(url_for('feed.atom'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'application/atom+xml'
-            assert rv.data.startswith(b'<?xml')
+            rv = c.get(url_for("feed.atom"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "application/atom+xml"
+            assert rv.data.startswith(b"<?xml")
             assert b"checking if the cache invalidation works" in rv.data
diff --git a/src/moin/apps/feed/views.py b/src/moin/apps/feed/views.py
index c65e1dca0..87b3c2732 100644
--- a/src/moin/apps/feed/views.py
+++ b/src/moin/apps/feed/views.py
@@ -21,32 +21,43 @@
 
 from moin.i18n import _
 from moin.apps.feed import feed
-from moin.constants.keys import (NAME, NAME_EXACT, NAMESPACE, WIKINAME, COMMENT, MTIME, REVID,
-                                 ALL_REVS, PARENTID, LATEST_REVS)
+from moin.constants.keys import (
+    NAME,
+    NAME_EXACT,
+    NAMESPACE,
+    WIKINAME,
+    COMMENT,
+    MTIME,
+    REVID,
+    ALL_REVS,
+    PARENTID,
+    LATEST_REVS,
+)
 from moin.themes import get_editor_info, render_template
 from moin.items import Item
 from moin.utils.crypto import cache_key
 from moin.utils.interwiki import url_for_item, split_fqname
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
-@feed.route('/atom/<itemname:item_name>')
-@feed.route('/atom', defaults=dict(item_name=''))
+@feed.route("/atom/<itemname:item_name>")
+@feed.route("/atom", defaults=dict(item_name=""))
 def atom(item_name):
-    '''
+    """
     Currently atom feeds behave in the following way
     - Text diffs are shown in a side-by-side fashion
     - The current binary item is fully rendered in the feed
     - Image(binary)'s diff is shown using PIL
     - First item is always rendered fully
     - Revision meta(id, size and comment) is shown for parent and current revision
-    '''
+    """
     query = Term(WIKINAME, app.cfg.interwikiname)
     if item_name:
         fqname = split_fqname(item_name)
-        query = And([query, Term(NAME_EXACT, fqname.value), Term(NAMESPACE, fqname.namespace), ])
+        query = And([query, Term(NAME_EXACT, fqname.value), Term(NAMESPACE, fqname.namespace)])
     revs = list(flaskg.storage.search(query, idx_name=LATEST_REVS, sortedby=[MTIME], reverse=True, limit=1))
     if revs:
         rev = revs[0]
@@ -64,10 +75,10 @@ def atom(item_name):
         feed.id(request.url)
         feed.title(title)
         feed.link(href=request.host_url)
-        feed.link(href=request.url, rel='self')
+        feed.link(href=request.url, rel="self")
         query = Term(WIKINAME, app.cfg.interwikiname)
         if item_name:
-            query = And([query, Term(NAME_EXACT, fqname.value), Term(NAMESPACE, fqname.namespace), ])
+            query = And([query, Term(NAME_EXACT, fqname.value), Term(NAMESPACE, fqname.namespace)])
         history = flaskg.storage.search(query, idx_name=ALL_REVS, sortedby=[MTIME], reverse=True, limit=100)
         for rev in history:
             name = rev.fqname.fullname
@@ -81,22 +92,29 @@ def atom(item_name):
                 if previous_revid is not None:
                     # HTML diff for subsequent revisions
                     previous_rev = item[previous_revid]
-                    content = hl_item.content._render_data_diff_atom(previous_rev, this_rev,
-                                                                     fqname=this_rev.item.fqname)
+                    content = hl_item.content._render_data_diff_atom(
+                        previous_rev, this_rev, fqname=this_rev.item.fqname
+                    )
                 else:
                     # full html rendering for new items
-                    content = render_template('atom.html', get='first_revision', rev=this_rev,
-                                              content=Markup(hl_item.content._render_data()), revision=this_revid)
+                    content = render_template(
+                        "atom.html",
+                        get="first_revision",
+                        rev=this_rev,
+                        content=Markup(hl_item.content._render_data()),
+                        revision=this_revid,
+                    )
             except Exception:
                 logging.exception(f"content rendering crashed on item {name}")
-                content = _('MoinMoin feels unhappy.')
+                content = _("MoinMoin feels unhappy.")
             author = get_editor_info(rev.meta, external=True)
-            rev_comment = rev.meta.get(COMMENT, '')
+            rev_comment = rev.meta.get(COMMENT, "")
             if rev_comment:
                 # Trim down extremely long revision comment
                 if len(rev_comment) > 80:
-                    content = render_template('atom.html', get='comment_cont_merge', comment=rev_comment[79:],
-                                              content=Markup(content))
+                    content = render_template(
+                        "atom.html", get="comment_cont_merge", comment=rev_comment[79:], content=Markup(content)
+                    )
                     rev_comment = f"{rev_comment[:79]}..."
                 feed_title = f"{author.get(NAME, '')} - {rev_comment}"
             else:
@@ -106,14 +124,14 @@ def atom(item_name):
             feed_entry = feed.add_entry()
             feed_entry.id(url_for_item(name, rev=this_revid, _external=True))
             feed_entry.title(feed_title)
-            feed_entry.author({'name': author.get(NAME, '')})
+            feed_entry.author({"name": author.get(NAME, "")})
             feed_entry.link(href=url_for_item(name, rev=this_revid, _external=True))
-            feed_entry.content(content, type='html')
+            feed_entry.content(content, type="html")
         content = feed.atom_str(pretty=True).decode("utf-8")
         # Hack to add XSLT stylesheet declaration since AtomFeed doesn't allow this
         content = content.split("\n")
-        content.insert(1, render_template('atom.html', get='xml'))
+        content.insert(1, render_template("atom.html", get="xml"))
         content = "\n".join(content)
         if cid is not None:
             app.cache.set(cid, content)
-    return Response(content, content_type='application/atom+xml')
+    return Response(content, content_type="application/atom+xml")
diff --git a/src/moin/apps/frontend/__init__.py b/src/moin/apps/frontend/__init__.py
index 1a65eeda0..76a35e75e 100644
--- a/src/moin/apps/frontend/__init__.py
+++ b/src/moin/apps/frontend/__init__.py
@@ -10,5 +10,6 @@
 
 
 from flask import Blueprint
-frontend = Blueprint('frontend', __name__)
+
+frontend = Blueprint("frontend", __name__)
 import moin.apps.frontend.views  # noqa
diff --git a/src/moin/apps/frontend/_tests/test_frontend.py b/src/moin/apps/frontend/_tests/test_frontend.py
index b767a3b6c..3f6a03084 100644
--- a/src/moin/apps/frontend/_tests/test_frontend.py
+++ b/src/moin/apps/frontend/_tests/test_frontend.py
@@ -23,198 +23,257 @@ class TestFrontend:
     def custom_setup(self, app):
         self.app = app
 
-    def _test_view(self, viewname, status='200 OK', data=('<html>', '</html>'), content_types=('text/html; charset=utf-8', ), viewopts=None, params=None):
+    def _test_view(
+        self,
+        viewname,
+        status="200 OK",
+        data=("<html>", "</html>"),
+        content_types=("text/html; charset=utf-8",),
+        viewopts=None,
+        params=None,
+    ):
         if viewopts is None:
             viewopts = {}
         if params is None:
             params = {}
 
         with self.app.test_client() as c:
-            for method in ['HEAD', 'GET']:
-                print('%s %s' % (method, url_for(viewname, **viewopts)))
+            for method in ["HEAD", "GET"]:
+                print("%s %s" % (method, url_for(viewname, **viewopts)))
                 rv = c.open(url_for(viewname, **viewopts), method=method, data=params)
                 rv_data = rv.data.decode()
                 assert rv.status == status
-                assert rv.headers['Content-Type'] in content_types
-                if method == 'GET':
+                assert rv.headers["Content-Type"] in content_types
+                if method == "GET":
                     for item in data:
-                        if item == '<!doctype html':  # TODO: remove workaround when Werkzeug >= 2.1.2 is set
+                        if item == "<!doctype html":  # TODO: remove workaround when Werkzeug >= 2.1.2 is set
                             assert item in str(rv_data).lower()
                         else:
                             assert item in rv_data
         return rv
 
-    def _test_view_post(self, viewname, status='302 FOUND', content_types=('text/html; charset=utf-8', ), data=('<html>', '</html>'), form=None, viewopts=None):
+    def _test_view_post(
+        self,
+        viewname,
+        status="302 FOUND",
+        content_types=("text/html; charset=utf-8",),
+        data=("<html>", "</html>"),
+        form=None,
+        viewopts=None,
+    ):
         if viewopts is None:
             viewopts = {}
         if form is None:
             form = {}
-        print('POST %s' % url_for(viewname, **viewopts))
+        print("POST %s" % url_for(viewname, **viewopts))
         with self.app.test_client() as c:
             rv = c.post(url_for(viewname, **viewopts), data=form)
             rv_data = rv.data.decode()
             assert rv.status == status
-            assert rv.headers['Content-Type'] in content_types
+            assert rv.headers["Content-Type"] in content_types
             for item in data:
                 assert item in rv_data
             return rv
 
     def test_ajaxdelete_item_name_route(self):
-        self._test_view_post('frontend.ajaxdelete', status='200 OK', content_types=['application/json', ], data=['{', '}'], form=dict(
-            comment='Test',
-            itemnames='["DoesntExist"]',
-        ), viewopts=dict(item_name='DoesntExist'))
+        self._test_view_post(
+            "frontend.ajaxdelete",
+            status="200 OK",
+            content_types=["application/json"],
+            data=["{", "}"],
+            form=dict(comment="Test", itemnames='["DoesntExist"]'),
+            viewopts=dict(item_name="DoesntExist"),
+        )
 
     def test_ajaxdelete_no_item_name_route(self):
-        self._test_view_post('frontend.ajaxdelete', status='200 OK', content_types=['application/json', ], data=['{', '}'], form=dict(
-            comment='Test',
-            itemnames='["DoesntExist"]',
-        ))
+        self._test_view_post(
+            "frontend.ajaxdelete",
+            status="200 OK",
+            content_types=["application/json"],
+            data=["{", "}"],
+            form=dict(comment="Test", itemnames='["DoesntExist"]'),
+        )
 
     def test_ajaxdestroy_item_name_route(self):
-        self._test_view_post('frontend.ajaxdestroy', status='200 OK', content_types=['application/json', ], data=['{', '}'], form=dict(
-            comment='Test',
-            itemnames='["DoesntExist"]',
-        ), viewopts=dict(item_name='DoesntExist'))
+        self._test_view_post(
+            "frontend.ajaxdestroy",
+            status="200 OK",
+            content_types=["application/json"],
+            data=["{", "}"],
+            form=dict(comment="Test", itemnames='["DoesntExist"]'),
+            viewopts=dict(item_name="DoesntExist"),
+        )
 
     def test_ajaxdestroy_no_item_name_route(self):
-        self._test_view_post('frontend.ajaxdestroy', status='200 OK', content_types=['application/json', ], data=['{', '}'], form=dict(
-            comment='Test',
-            itemnames='["DoesntExist"]',
-        ))
+        self._test_view_post(
+            "frontend.ajaxdestroy",
+            status="200 OK",
+            content_types=["application/json"],
+            data=["{", "}"],
+            form=dict(comment="Test", itemnames='["DoesntExist"]'),
+        )
 
     def test_ajaxmodify(self):
-        self._test_view_post('frontend.ajaxmodify', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view_post("frontend.ajaxmodify", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_jfu_server(self):
-        self._test_view_post('frontend.jfu_server', status='200 OK', content_types=['application/json', ], data=['{', '}'], form=dict(
-            file_storage=FileStorage(BytesIO(b"Hello, world"), filename='C:\\fakepath\\DoesntExist.txt', content_type='text/plain; charset=utf-8'),
-        ), viewopts=dict(item_name='WillBeCreated'))
+        self._test_view_post(
+            "frontend.jfu_server",
+            status="200 OK",
+            content_types=["application/json"],
+            data=["{", "}"],
+            form=dict(
+                file_storage=FileStorage(
+                    BytesIO(b"Hello, world"),
+                    filename="C:\\fakepath\\DoesntExist.txt",
+                    content_type="text/plain; charset=utf-8",
+                )
+            ),
+            viewopts=dict(item_name="WillBeCreated"),
+        )
 
     def test_show_item(self):
-        self._test_view('frontend.show_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.show_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_show_dom(self):
-        self._test_view('frontend.show_dom', status='404 NOT FOUND', data=['<?xml', '>'], viewopts=dict(item_name='DoesntExist'), content_types=['text/xml; charset=utf-8', ])
+        self._test_view(
+            "frontend.show_dom",
+            status="404 NOT FOUND",
+            data=["<?xml", ">"],
+            viewopts=dict(item_name="DoesntExist"),
+            content_types=["text/xml; charset=utf-8"],
+        )
 
     def test_indexable(self):
-        self._test_view('frontend.indexable', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.indexable", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_highlight_item(self):
-        self._test_view('frontend.highlight_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.highlight_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_show_item_meta(self):
-        self._test_view('frontend.show_item_meta', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.show_item_meta", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_content_item(self):
-        self._test_view('frontend.content_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.content_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_get_item(self):
-        self._test_view('frontend.get_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.get_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_download_item(self):
-        self._test_view('frontend.download_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.download_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_convert_item(self):
-        self._test_view('frontend.convert_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'), params=dict(contenttype='text/plain'))
+        self._test_view(
+            "frontend.convert_item",
+            status="404 NOT FOUND",
+            viewopts=dict(item_name="DoesntExist"),
+            params=dict(contenttype="text/plain"),
+        )
 
     def test_modify_item(self):
-        self._test_view('frontend.modify_item', status='200 OK', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.modify_item", status="200 OK", viewopts=dict(item_name="DoesntExist"))
 
     def test_rename_item(self):
-        self._test_view('frontend.rename_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.rename_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_delete_item(self):
-        self._test_view('frontend.delete_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.delete_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_index(self):
-        self._test_view('frontend.index', status='200 OK', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.index", status="200 OK", viewopts=dict(item_name="DoesntExist"))
 
     def test_forwardrefs(self):
-        self._test_view('frontend.forwardrefs', status='200 OK', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.forwardrefs", status="200 OK", viewopts=dict(item_name="DoesntExist"))
 
     def test_backrefs(self):
-        self._test_view('frontend.backrefs', status='200 OK', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.backrefs", status="200 OK", viewopts=dict(item_name="DoesntExist"))
 
     def test_history(self):
-        self._test_view('frontend.history', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.history", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_diff(self):
         # TODO another test with valid rev1 and rev2 url args and an existing item is needed
-        self._test_view('frontend.diff', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.diff", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_similar_names(self):
-        self._test_view('frontend.similar_names', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.similar_names", viewopts=dict(item_name="DoesntExist"))
 
     def test_sitemap(self):
-        self._test_view('frontend.sitemap', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.sitemap", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_tagged_items(self):
-        self._test_view('frontend.tagged_items', status='200 OK', viewopts=dict(tag='DoesntExist'))
+        self._test_view("frontend.tagged_items", status="200 OK", viewopts=dict(tag="DoesntExist"))
 
     def test_root(self):
-        self._test_view('frontend.index')
+        self._test_view("frontend.index")
 
     def test_robots(self):
-        self._test_view('frontend.robots', data=['Disallow:'], content_types=['text/plain; charset=utf-8', ])
+        self._test_view("frontend.robots", data=["Disallow:"], content_types=["text/plain; charset=utf-8"])
 
     def test_search(self):
-        self._test_view('frontend.search')
+        self._test_view("frontend.search")
 
     def test_revert_item(self):
-        self._test_view('frontend.revert_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist', rev='000000'))
+        self._test_view(
+            "frontend.revert_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist", rev="000000")
+        )
 
     def test_mychanges(self):
-        self._test_view('frontend.mychanges', viewopts=dict(userid='000000'))
+        self._test_view("frontend.mychanges", viewopts=dict(userid="000000"))
 
     def test_global_history(self):
-        self._test_view('frontend.global_history')
+        self._test_view("frontend.global_history")
 
     def test_wanted_items(self):
-        self._test_view('frontend.wanted_items')
+        self._test_view("frontend.wanted_items")
 
     def test_orphaned_items(self):
-        self._test_view('frontend.orphaned_items')
+        self._test_view("frontend.orphaned_items")
 
     def test_quicklink_item(self):
-        self._test_view('frontend.quicklink_item', status='302 FOUND', viewopts=dict(item_name='DoesntExist'), data=['<!doctype html'])
+        self._test_view(
+            "frontend.quicklink_item",
+            status="302 FOUND",
+            viewopts=dict(item_name="DoesntExist"),
+            data=["<!doctype html"],
+        )
 
     def test_subscribe_item(self):
-        self._test_view('frontend.subscribe_item', status='404 NOT FOUND', viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.subscribe_item", status="404 NOT FOUND", viewopts=dict(item_name="DoesntExist"))
 
     def test_register(self):
-        self._test_view('frontend.register')
+        self._test_view("frontend.register")
 
     def test_verifyemail(self):
-        self._test_view('frontend.verifyemail', status='302 FOUND', data=['<!doctype html'])
+        self._test_view("frontend.verifyemail", status="302 FOUND", data=["<!doctype html"])
 
     def test_lostpass(self):
-        self._test_view('frontend.lostpass')
+        self._test_view("frontend.lostpass")
 
     def test_recoverpass(self):
-        self._test_view('frontend.recoverpass')
+        self._test_view("frontend.recoverpass")
 
     def test_login(self):
-        self._test_view('frontend.login')
+        self._test_view("frontend.login")
 
     def test_logout(self):
-        self._test_view('frontend.logout', status='302 FOUND', data=['<!doctype html'])
+        self._test_view("frontend.logout", status="302 FOUND", data=["<!doctype html"])
 
     def test_usersettings_notloggedin(self):
         # if a anon user visits usersettings view, he'll get redirected to the login view
-        self._test_view('frontend.usersettings', status='302 FOUND', data=['<!doctype html'])
+        self._test_view("frontend.usersettings", status="302 FOUND", data=["<!doctype html"])
 
     # TODO: implement test_usersettings_loggedin()
 
     def test_bookmark(self):
-        self._test_view('frontend.bookmark', status='302 FOUND', data=['<!doctype html'])
+        self._test_view("frontend.bookmark", status="302 FOUND", data=["<!doctype html"])
 
     def test_diffraw(self):
         # TODO another test with valid rev1 and rev2 url args and an existing item is needed
-        self._test_view('frontend.diffraw', status='404 NOT FOUND', data=[], viewopts=dict(item_name='DoesntExist'))
+        self._test_view("frontend.diffraw", status="404 NOT FOUND", data=[], viewopts=dict(item_name="DoesntExist"))
 
     def test_global_tags(self):
-        self._test_view('frontend.global_tags')
+        self._test_view("frontend.global_tags")
 
 
 class TestUsersettings:
@@ -228,26 +287,26 @@ def custom_setup(self, app):
         flaskg.user = saved_user
 
     def test_user_password_change(self):
-        self.createUser('moin', 'Xiwejr622')
-        flaskg.user = user.User(name='moin', password='Xiwejr622')
-        form = self.fillPasswordChangeForm('Xiwejr622', 'Woodoo645', 'Woodoo645')
+        self.createUser("moin", "Xiwejr622")
+        flaskg.user = user.User(name="moin", password="Xiwejr622")
+        form = self.fillPasswordChangeForm("Xiwejr622", "Woodoo645", "Woodoo645")
         valid = form.validate()
         assert valid  # form data is valid
 
     def test_user_unicode_password_change(self):
-        name = 'moin'
-        password = '__שם משתמש לא קיים__'  # Hebrew
+        name = "moin"
+        password = "__שם משתמש לא קיים__"  # Hebrew
 
         self.createUser(name, password)
         flaskg.user = user.User(name=name, password=password)
-        form = self.fillPasswordChangeForm(password, 'Woodoo645', 'Woodoo645')
+        form = self.fillPasswordChangeForm(password, "Woodoo645", "Woodoo645")
         valid = form.validate()
         assert valid  # form data is valid
 
     def test_user_password_change_to_unicode_pw(self):
-        name = 'moin'
-        password = 'Xiwejr622'
-        new_password = '__שם משתמש לא קיים__'  # Hebrew
+        name = "moin"
+        password = "Xiwejr622"
+        new_password = "__שם משתמש לא קיים__"  # Hebrew
 
         self.createUser(name, password)
         flaskg.user = user.User(name=name, password=password)
@@ -256,17 +315,17 @@ def test_user_password_change_to_unicode_pw(self):
         assert valid  # form data is valid
 
     def test_fail_user_password_change_pw_mismatch(self):
-        self.createUser('moin', 'Xiwejr622')
-        flaskg.user = user.User(name='moin', password='Xiwejr622')
-        form = self.fillPasswordChangeForm('Xiwejr622', 'Piped33', 'Woodoo645')
+        self.createUser("moin", "Xiwejr622")
+        flaskg.user = user.User(name="moin", password="Xiwejr622")
+        form = self.fillPasswordChangeForm("Xiwejr622", "Piped33", "Woodoo645")
         valid = form.validate()
         # form data is invalid because password1 != password2
         assert not valid
 
     def test_fail_password_change(self):
-        self.createUser('moin', 'Xiwejr622')
-        flaskg.user = user.User(name='moin', password='Xiwejr622')
-        form = self.fillPasswordChangeForm('Xinetd33', 'Woodoo645', 'Woodoo645')
+        self.createUser("moin", "Xiwejr622")
+        flaskg.user = user.User(name="moin", password="Xiwejr622")
+        form = self.fillPasswordChangeForm("Xinetd33", "Woodoo645", "Woodoo645")
         valid = form.validate()
         # form data is invalid because password_current != user.password
         assert not valid
@@ -274,21 +333,19 @@ def test_fail_password_change(self):
     # Helpers ---------------------------------------------------------
 
     def fillPasswordChangeForm(self, current_password, password1, password2):
-        """ helper to fill UserSettingsPasswordForm form
-        """
+        """helper to fill UserSettingsPasswordForm form"""
         FormClass = views.UserSettingsPasswordForm
         request_form = (
-            ('password_current', current_password),
-            ('password1', password1),
-            ('password2', password2),
-            ('submit', 'Save')
+            ("password_current", current_password),
+            ("password1", password1),
+            ("password2", password2),
+            ("submit", "Save"),
         )
         form = FormClass.from_flat(request_form)
         return form
 
     def createUser(self, name, password, pwencoded=False, email=None):
-        """ helper to create test user
-        """
+        """helper to create test user"""
         if email is None:
             email = "user@example.org"
         user.create_user(name, password, email, is_encrypted=pwencoded)
diff --git a/src/moin/apps/frontend/views.py b/src/moin/apps/frontend/views.py
index f1276a3ae..4ddacffa4 100644
--- a/src/moin/apps/frontend/views.py
+++ b/src/moin/apps/frontend/views.py
@@ -56,12 +56,38 @@
 from moin.i18n import _, L_
 from moin.themes import render_template, contenttype_to_class, get_editor_info
 from moin.apps.frontend import frontend
-from moin.forms import (OptionalText, RequiredText, URL, YourEmail,
-                        RequiredPassword, Checkbox, InlineCheckbox, Select, Names,
-                        Tags, Natural, Hidden, MultiSelect, Enum, Subscriptions, Quicklinks, RadioChoice,
-                        validate_name, NameNotValidError)
-from moin.items import (BaseChangeForm, Item, NonExistent, NameNotUniqueError, MissingParentError,
-                        FieldNotUniqueError, get_itemtype_specific_tags, CreateItemForm, find_matches)
+from moin.forms import (
+    OptionalText,
+    RequiredText,
+    URL,
+    YourEmail,
+    RequiredPassword,
+    Checkbox,
+    InlineCheckbox,
+    Select,
+    Names,
+    Tags,
+    Natural,
+    Hidden,
+    MultiSelect,
+    Enum,
+    Subscriptions,
+    Quicklinks,
+    RadioChoice,
+    validate_name,
+    NameNotValidError,
+)
+from moin.items import (
+    BaseChangeForm,
+    Item,
+    NonExistent,
+    NameNotUniqueError,
+    MissingParentError,
+    FieldNotUniqueError,
+    get_itemtype_specific_tags,
+    CreateItemForm,
+    find_matches,
+)
 from moin.items.content import content_registry, conv_serialize
 from moin.items.ticket import AdvancedSearchForm, render_comment_data
 from moin import user
@@ -84,31 +110,32 @@
 import moin.utils.mimetype as mime_type
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 jfu_server_lock = threading.Lock()
 
 
-@frontend.route('/+dispatch', methods=['GET', ])
+@frontend.route("/+dispatch", methods=["GET"])
 def dispatch():
     args = request.values.to_dict()
-    endpoint = str(args.pop('endpoint'))
+    endpoint = str(args.pop("endpoint"))
     # filter args given to url_for, so that no unneeded args end up in query string:
-    args = {k: args[k] for k in args
-                 if app.url_map.is_endpoint_expecting(endpoint, k)}
+    args = {k: args[k] for k in args if app.url_map.is_endpoint_expecting(endpoint, k)}
     return redirect(url_for(endpoint, **args))
 
 
-@frontend.route('/')
+@frontend.route("/")
 def show_root():
     item_name = app.cfg.root_mapping.get(NAMESPACE_DEFAULT, app.cfg.default_root)
     return redirect(url_for_item(item_name))
 
 
-@frontend.route('/robots.txt')
+@frontend.route("/robots.txt")
 def robots():
-    return Response("""\
+    return Response(
+        """\
 User-agent: *
 Crawl-delay: 20
 Disallow: /+convert/
@@ -147,40 +174,39 @@ def robots():
 Disallow: /+dispatch/
 Disallow: /+admin/
 Allow: /
-""", mimetype='text/plain')
+""",
+        mimetype="text/plain",
+    )
 
 
-@frontend.route('/all')
+@frontend.route("/all")
 def global_views():
     """
     Provides a link to all the global views.
     """
-    return render_template('all.html',
-                           title_name=_("Global Views"),
-                           fqname=CompositeName('all', NAME_EXACT, '')
-                           )
+    return render_template("all.html", title_name=_("Global Views"), fqname=CompositeName("all", NAME_EXACT, ""))
 
 
 class LookupForm(Form):
-    name = OptionalText.using(label='name')
-    name_exact = OptionalText.using(label='name_exact')
-    itemid = OptionalText.using(label='itemid')
-    revid = OptionalText.using(label='revid')
-    userid = OptionalText.using(label='userid')
-    language = OptionalText.using(label='language')
-    itemlinks = OptionalText.using(label='itemlinks')
-    itemtransclusions = OptionalText.using(label='itemtransclusions')
-    refs = OptionalText.using(label='refs')
-    tags = Tags.using(optional=True).using(label='tags')
-    history = InlineCheckbox.using(label=L_('search also in non-current revisions'))
-    submit_label = L_('Lookup')
+    name = OptionalText.using(label="name")
+    name_exact = OptionalText.using(label="name_exact")
+    itemid = OptionalText.using(label="itemid")
+    revid = OptionalText.using(label="revid")
+    userid = OptionalText.using(label="userid")
+    language = OptionalText.using(label="language")
+    itemlinks = OptionalText.using(label="itemlinks")
+    itemtransclusions = OptionalText.using(label="itemtransclusions")
+    refs = OptionalText.using(label="refs")
+    tags = Tags.using(optional=True).using(label="tags")
+    history = InlineCheckbox.using(label=L_("search also in non-current revisions"))
+    submit_label = L_("Lookup")
 
 
 def analyze(analyzer, text):
-    return [token.text for token in analyzer(text, mode='index')]
+    return [token.text for token in analyzer(text, mode="index")]
 
 
-@frontend.route('/+lookup', methods=['GET', 'POST'])
+@frontend.route("/+lookup", methods=["GET", "POST"])
 def lookup():
     """
     lookup is like search, but it only deals with specific fields that identify
@@ -206,18 +232,15 @@ def lookup():
     lookup_form = LookupForm.from_flat(request.values.items(multi=True))
     valid = lookup_form.validate()
     if valid:
-        history = bool(request.values.get('history'))
+        history = bool(request.values.get("history"))
         idx_name = ALL_REVS if history else LATEST_REVS
         terms = []
-        for key in [NAME, NAME_EXACT, ITEMID, REVID, USERID,
-                    LANGUAGE,
-                    TAGS,
-                    ITEMLINKS, ITEMTRANSCLUSIONS, 'refs', ]:
+        for key in [NAME, NAME_EXACT, ITEMID, REVID, USERID, LANGUAGE, TAGS, ITEMLINKS, ITEMTRANSCLUSIONS, "refs"]:
             value = lookup_form[key].value
             if value:
-                if key in [ITEMID, REVID, USERID, ] and len(value) < crypto.UUID_LEN or key in [NAME_EXACT]:
+                if key in [ITEMID, REVID, USERID] and len(value) < crypto.UUID_LEN or key in [NAME_EXACT]:
                     term = Prefix(key, value)
-                elif key == 'refs':
+                elif key == "refs":
                     term = Or([Term(ITEMLINKS, value), Term(ITEMTRANSCLUSIONS, value)])
                 elif key == TAGS:
                     term = And([Term(TAGS, v.value) for v in lookup_form[key]])
@@ -225,43 +248,40 @@ def lookup():
                     term = Term(key, value)
                 terms.append(term)
         if terms:
-            LookupEntry = namedtuple('LookupEntry', 'name revid wikiname')
+            LookupEntry = namedtuple("LookupEntry", "name revid wikiname")
             name = lookup_form[NAME].value
-            name_exact = lookup_form[NAME_EXACT].value or ''
+            name_exact = lookup_form[NAME_EXACT].value or ""
             terms.append(Term(WIKINAME, app.cfg.interwikiname))
             q = And(terms)
             with flaskg.storage.indexer.ix[idx_name].searcher() as searcher:
-                flaskg.clock.start('lookup')
+                flaskg.clock.start("lookup")
                 results = searcher.search(q, limit=100)
-                flaskg.clock.stop('lookup')
+                flaskg.clock.stop("lookup")
                 lookup_results = []
                 for result in results:
                     analyzer = item_name_analyzer()
-                    lookup_results += [LookupEntry(n, result[REVID], result[WIKINAME])
-                                       for n in result[NAME]
-                                       if not name or name.lower() in analyze(analyzer, n)
-                                       if n.startswith(name_exact)]
+                    lookup_results += [
+                        LookupEntry(n, result[REVID], result[WIKINAME])
+                        for n in result[NAME]
+                        if not name or name.lower() in analyze(analyzer, n)
+                        if n.startswith(name_exact)
+                    ]
 
                 if len(lookup_results) == 1:
                     result = lookup_results[0]
                     rev = result.revid if history else CURRENT
-                    url = url_for('.show_item', item_name=result.name, rev=rev)
+                    url = url_for(".show_item", item_name=result.name, rev=rev)
                     return redirect(url)
                 else:
-                    flaskg.clock.start('lookup render')
-                    html = render_template('lookup.html',
-                                           title_name=title_name,
-                                           lookup_form=lookup_form,
-                                           results=lookup_results,
-                                           )
-                    flaskg.clock.stop('lookup render')
+                    flaskg.clock.start("lookup render")
+                    html = render_template(
+                        "lookup.html", title_name=title_name, lookup_form=lookup_form, results=lookup_results
+                    )
+                    flaskg.clock.stop("lookup render")
                     if not lookup_results:
                         status = 404
                     return Response(html, status)
-    html = render_template('lookup.html',
-                           title_name=title_name,
-                           lookup_form=lookup_form,
-                           )
+    html = render_template("lookup.html", title_name=title_name, lookup_form=lookup_form)
     return Response(html, status)
 
 
@@ -292,7 +312,7 @@ def add_file_filters(_filter, filetypes):
     :param filetypes: list of selected filetypes
     :returns: the required _filter for the search query
     """
-    if filetypes and 'all' not in filetypes:
+    if filetypes and "all" not in filetypes:
         contenttypes = []
         files_filter = []
         if "markup" in filetypes:
@@ -312,7 +332,7 @@ def add_file_filters(_filter, filetypes):
         for ctype in contenttypes:
             for itemtype in ctype:
                 files_filter.append(Term("contenttype", itemtype))
-        if 'unknown' in filetypes:
+        if "unknown" in filetypes:
             known_types = []
             for known in CONTENTTYPES_MAP.keys():
                 known_types.append(Term("contenttype", known))
@@ -350,8 +370,8 @@ def add_facets(facets, time_sorting):
     return facets
 
 
-@frontend.route('/+search/<itemname:item_name>', methods=['GET', 'POST'])
-@frontend.route('/+search', defaults=dict(item_name=''), methods=['GET', 'POST'])
+@frontend.route("/+search/<itemname:item_name>", methods=["GET", "POST"])
+@frontend.route("/+search", defaults=dict(item_name=""), methods=["GET", "POST"])
 def search(item_name):
     """
     Perform a whoosh search of the index and display the matching items.
@@ -369,27 +389,27 @@ def search(item_name):
     Example URL: http://127.0.0.1:8080/+search/OtherTextItems?q=moin
     """
     search_form = SearchForm.from_flat(request.values)
-    ajax = True if request.args.get('boolajax') else False
+    ajax = True if request.args.get("boolajax") else False
     valid = search_form.validate()
     time_sorting = False
     filetypes = []
     if ajax:
-        query = request.args.get('q')
-        history = request.args.get('history') == "true"
-        time_sorting = request.args.get('time_sorting')
-        if time_sorting == 'default':
+        query = request.args.get("q")
+        history = request.args.get("history") == "true"
+        time_sorting = request.args.get("time_sorting")
+        if time_sorting == "default":
             time_sorting = False
-        filetypes = request.args.get('filetypes')
-        is_ticket = bool(request.args.get('is_ticket'))
+        filetypes = request.args.get("filetypes")
+        is_ticket = bool(request.args.get("is_ticket"))
         if filetypes:
-            filetypes = filetypes.split(',')[:-1]  # To remove the extra '' at the end of the list
+            filetypes = filetypes.split(",")[:-1]  # To remove the extra '' at the end of the list
     else:
-        query = search_form['q'].value
-        history = bool(request.values.get('history'))
+        query = search_form["q"].value
+        history = bool(request.values.get("history"))
 
     best_match = False
     # we test for query in case this is a test run
-    if query and query.startswith('\\'):
+    if query and query.startswith("\\"):
         best_match = True
         query = query[1:]
 
@@ -411,8 +431,8 @@ def search(item_name):
         _filter = []
         _filter = add_file_filters(_filter, filetypes)
         if item_name:  # Only search this item and subitems
-            prefix_name = item_name + '/'
-            terms = [Term(NAME_EXACT, item_name), Prefix(NAME_EXACT, prefix_name), ]
+            prefix_name = item_name + "/"
+            terms = [Term(NAME_EXACT, item_name), Prefix(NAME_EXACT, prefix_name)]
 
             show_transclusions = True
             if show_transclusions:
@@ -422,11 +442,11 @@ def search(item_name):
                 # Such stuff would only work if we expand transcluded items
                 # at indexing time (and we currently don't).
                 with flaskg.storage.indexer.ix[LATEST_REVS].searcher() as searcher:
-                    subq = Or([Term(NAME_EXACT, item_name), Prefix(NAME_EXACT, prefix_name), ])
-                    subq = And([subq, Every(ITEMTRANSCLUSIONS), ])
-                    flaskg.clock.start('search subitems with transclusions')
+                    subq = Or([Term(NAME_EXACT, item_name), Prefix(NAME_EXACT, prefix_name)])
+                    subq = And([subq, Every(ITEMTRANSCLUSIONS)])
+                    flaskg.clock.start("search subitems with transclusions")
                     results = searcher.search(subq, limit=None)
-                    flaskg.clock.stop('search subitems with transclusions')
+                    flaskg.clock.stop("search subitems with transclusions")
                     transcluded_names = set()
                     for hit in results:
                         name = hit[NAME]
@@ -440,60 +460,50 @@ def search(item_name):
             # terms is set to retrieve list of terms which matched, in the searchtemplate, for highlight.
             facets = []
             facets = add_facets(facets, time_sorting)
-            flaskg.clock.start('search')
+            flaskg.clock.start("search")
             try:
                 results = searcher.search(q, filter=_filter, limit=100, terms=True, sortedby=facets)
             # this may be an ajax transaction, search.js will handle a full page response
             except QueryError:
                 flash(_("""QueryError: invalid search term: {search_term}""").format(search_term=q), "error")
-                return render_template('search.html',
-                                       query=query,
-                                       medium_search_form=search_form,
-                                       item_name=item_name,
-                                       )
+                return render_template("search.html", query=query, medium_search_form=search_form, item_name=item_name)
             except TermNotFound:
                 # name:'moin has bugs'
                 flash(_("""TermNotFound: field is not indexed: {search_term}""").format(search_term=q), "error")
-                return render_template('search.html',
-                                       query=query,
-                                       medium_search_form=search_form,
-                                       item_name=item_name,
-                                       )
-            flaskg.clock.stop('search')
+                return render_template("search.html", query=query, medium_search_form=search_form, item_name=item_name)
+            flaskg.clock.stop("search")
 
             if best_match and results:
                 return redirect(url_for_item(results[0][NAMES]))
 
-            flaskg.clock.start('search render')
+            flaskg.clock.start("search render")
             if ajax:
-                html = render_template('ajaxsearch.html',
-                                       results=results,
-                                       omitted_words=', '.join(omitted_words),
-                                       history=history,
-                                       is_ticket=is_ticket,
-                                       whoosh_query=q,
-                                       whoosh_filter=_filter,
-                                       flaskg=flaskg,
-                                       )
+                html = render_template(
+                    "ajaxsearch.html",
+                    results=results,
+                    omitted_words=", ".join(omitted_words),
+                    history=history,
+                    is_ticket=is_ticket,
+                    whoosh_query=q,
+                    whoosh_filter=_filter,
+                    flaskg=flaskg,
+                )
             else:
-                html = render_template('search.html',
-                                       results=results,
-                                       query=query,
-                                       medium_search_form=search_form,
-                                       item_name=item_name,
-                                       omitted_words=', '.join(omitted_words),
-                                       history=history,
-                                       whoosh_query=q,
-                                       whoosh_filter=_filter,
-                                       flaskg=flaskg,
-                                       )
-            flaskg.clock.stop('search render')
+                html = render_template(
+                    "search.html",
+                    results=results,
+                    query=query,
+                    medium_search_form=search_form,
+                    item_name=item_name,
+                    omitted_words=", ".join(omitted_words),
+                    history=history,
+                    whoosh_query=q,
+                    whoosh_filter=_filter,
+                    flaskg=flaskg,
+                )
+            flaskg.clock.stop("search render")
     else:
-        html = render_template('search.html',
-                               query=query,
-                               medium_search_form=search_form,
-                               item_name=item_name,
-                               )
+        html = render_template("search.html", query=query, medium_search_form=search_form, item_name=item_name)
     return html
 
 
@@ -509,8 +519,9 @@ def add_presenter(wrapped, view, add_trail=False, abort404=True):
     :param add_trail: whether to call flaskg.user.add_trail
     :param abort404: whether to abort(404) for nonexistent items
     """
-    @frontend.route(f'/+{view}/+<rev>/<itemname:item_name>')
-    @frontend.route(f'/+{view}/<itemname:item_name>', defaults=dict(rev=CURRENT))
+
+    @frontend.route(f"/+{view}/+<rev>/<itemname:item_name>")
+    @frontend.route(f"/+{view}/<itemname:item_name>", defaults=dict(rev=CURRENT))
     @wraps(wrapped)
     def wrapper(item_name, rev):
         if add_trail:
@@ -522,6 +533,7 @@ def wrapper(item_name, rev):
         if abort404 and isinstance(item, NonExistent):
             abort(404, item_name)
         return wrapped(item)
+
     return wrapper
 
 
@@ -541,26 +553,25 @@ def flash_if_item_deleted(item_name, rev_id, itemrev):
         ret = False
         current_item = Item.create(item_name, rev_id=CURRENT)
         if TRASH in current_item.meta and current_item.meta[TRASH]:
-            flash(_('This item is deleted.'), "info")
+            flash(_("This item is deleted."), "info")
             ret = True
         if TRASH in itemrev.meta and itemrev.meta[TRASH]:
-            flash(_('This item revision is deleted.'), "info")
+            flash(_("This item revision is deleted."), "info")
             ret = True
         return ret
     elif TRASH in itemrev.meta and itemrev.meta[TRASH]:
-        flash(_('This item is deleted.'), "info")
+        flash(_("This item is deleted."), "info")
         return True
     return False
 
 
 # The first form accepts POST to allow modifying behavior like modify_item.
 # The second form only accepts GET since modifying a historical revision is not allowed.
-@frontend.route('/<itemname:item_name>', defaults=dict(rev=CURRENT), methods=['GET', 'POST'])
-@frontend.route('/+show/+<rev>/<itemname:item_name>', methods=['GET'])
+@frontend.route("/<itemname:item_name>", defaults=dict(rev=CURRENT), methods=["GET", "POST"])
+@frontend.route("/+show/+<rev>/<itemname:item_name>", methods=["GET"])
 def show_item(item_name, rev):
     fqname = split_fqname(item_name)
-    item_displayed.send(app._get_current_object(),
-                        fqname=fqname)
+    item_displayed.send(app._get_current_object(), fqname=fqname)
     if not fqname.value and fqname.field == NAME_EXACT:
         fqname = fqname.get_root_fqname()
         return redirect(url_for_item(fqname))
@@ -576,90 +587,93 @@ def show_item(item_name, rev):
         fq_names = []
         for rev in revs:
             fq_names.extend(rev.fqnames)
-        return render_template("link_list_no_item_panel.html",
-                               headline=_("Items with {field} {value}").format(field=fqname.field, value=fqname.value),
-                               fqname=fqname,
-                               fq_names=fq_names,
-                               item_is_deleted=item_is_deleted,
-                               )
+        return render_template(
+            "link_list_no_item_panel.html",
+            headline=_("Items with {field} {value}").format(field=fqname.field, value=fqname.value),
+            fqname=fqname,
+            fq_names=fq_names,
+            item_is_deleted=item_is_deleted,
+        )
     close_file(item.rev.data)
     return result
 
 
-@frontend.route('/<itemname:item_name>/')  # note: unwanted trailing slash
-@frontend.route('/+show/<itemname:item_name>')
+@frontend.route("/<itemname:item_name>/")  # note: unwanted trailing slash
+@frontend.route("/+show/<itemname:item_name>")
 def redirect_show_item(item_name):
     return redirect(url_for_item(item_name))
 
 
-@presenter('dom', abort404=False)
+@presenter("dom", abort404=False)
 def show_dom(item):
     if isinstance(item, NonExistent):
         status = 404
     else:
         status = 200
-    content = render_template('dom.xml',
-                              data_xml=Markup(item.content._render_data_xml()),
-                              )
-    return Response(content, status, mimetype='text/xml')
+    content = render_template("dom.xml", data_xml=Markup(item.content._render_data_xml()))
+    return Response(content, status, mimetype="text/xml")
 
 
 # XXX this is just a temporary view to test the indexing converter
-@frontend.route('/+indexable/+<rev>/<itemname:item_name>')
-@frontend.route('/+indexable/<itemname:item_name>', defaults=dict(rev=CURRENT))
+@frontend.route("/+indexable/+<rev>/<itemname:item_name>")
+@frontend.route("/+indexable/<itemname:item_name>", defaults=dict(rev=CURRENT))
 def indexable(item_name, rev):
     from moin.storage.middleware.indexing import convert_to_indexable
+
     try:
         item = flaskg.storage[item_name]
         rev = item[rev]
     except KeyError:
         abort(404, item_name)
     content = convert_to_indexable(rev.meta, rev.data, item_name)
-    return Response(content, 200, mimetype='text/plain')
+    return Response(content, 200, mimetype="text/plain")
 
 
-@presenter('highlight')
+@presenter("highlight")
 def highlight_item(item):
-    rev_navigation_ids_dates = rev_navigation.prior_next_revs(request.view_args['rev'], item.fqname)
+    rev_navigation_ids_dates = rev_navigation.prior_next_revs(request.view_args["rev"], item.fqname)
     item_is_deleted = flash_if_item_deleted(item.fqname.fullname, item.rev.meta[REVID], item)
     try:
-        ret = render_template('highlight.html',
-                              item=item, item_name=item.name,
-                              fqname=item.fqname,
-                              data_text=Markup(item.content._render_data_highlight()),
-                              rev=item.rev,
-                              rev_navigation_ids_dates=rev_navigation_ids_dates,
-                              meta=item._meta_info(),
-                              item_is_deleted=item_is_deleted,
-                              )
+        ret = render_template(
+            "highlight.html",
+            item=item,
+            item_name=item.name,
+            fqname=item.fqname,
+            data_text=Markup(item.content._render_data_highlight()),
+            rev=item.rev,
+            rev_navigation_ids_dates=rev_navigation_ids_dates,
+            meta=item._meta_info(),
+            item_is_deleted=item_is_deleted,
+        )
     except UnicodeDecodeError:
         return _crash(item, None, None)
     close_file(item.meta.revision.data)
     return ret
 
 
-@presenter('meta', add_trail=True)
+@presenter("meta", add_trail=True)
 def show_item_meta(item):
-    rev_navigation_ids_dates = rev_navigation.prior_next_revs(request.view_args['rev'], item.fqname)
+    rev_navigation_ids_dates = rev_navigation.prior_next_revs(request.view_args["rev"], item.fqname)
     item_is_deleted = flash_if_item_deleted(item.fqname.fullname, item.rev.meta[REVID], item)
-    ret = render_template('meta.html',
-                          item=item,
-                          item_name=item.name,
-                          fqname=item.fqname,
-                          rev=item.rev,
-                          contenttype=item.contenttype,
-                          rev_navigation_ids_dates=rev_navigation_ids_dates,
-                          meta=item._meta_info(),
-                          item_is_deleted=item_is_deleted,
-                          )
+    ret = render_template(
+        "meta.html",
+        item=item,
+        item_name=item.name,
+        fqname=item.fqname,
+        rev=item.rev,
+        contenttype=item.contenttype,
+        rev_navigation_ids_dates=rev_navigation_ids_dates,
+        meta=item._meta_info(),
+        item_is_deleted=item_is_deleted,
+    )
     close_file(item.meta.revision.data)
     return ret
 
 
-@frontend.route('/+content/+<rev>/<itemname:item_name>')
-@frontend.route('/+content/<itemname:item_name>', defaults=dict(rev=CURRENT))
+@frontend.route("/+content/+<rev>/<itemname:item_name>")
+@frontend.route("/+content/<itemname:item_name>", defaults=dict(rev=CURRENT))
 def content_item(item_name, rev):
-    """ same as show_item, but we only show the content """
+    """same as show_item, but we only show the content"""
     fqname = split_fqname(item_name)
     item_displayed.send(app, fqname=fqname)
     try:
@@ -668,34 +682,35 @@ def content_item(item_name, rev):
         abort(403)
     if isinstance(item, NonExistent):
         abort(404, item_name)
-    return render_template('content.html',
-                           item_name=item.name,
-                           data_rendered=Markup(item.content._render_data()),
-                           )
+    return render_template("content.html", item_name=item.name, data_rendered=Markup(item.content._render_data()))
 
 
-@presenter('get')
+@presenter("get")
 def get_item(item):
     return item.content.do_get()
 
 
-@presenter('download')
+@presenter("download")
 def download_item(item):
     mimetype = request.values.get("mimetype")
     return item.content.do_get(force_attachment=True, mimetype=mimetype)
 
 
 class ConvertForm(Form):
-    new_type = Select.using(label=L_('New Content Type')).out_of((('text/x.moin.wiki;charset=utf-8', 'MoinWiki'),
-                                                                  ('text/x-markdown;charset=utf-8', 'Markdown'),
-                                                                  ('text/x-rst;charset=utf-8', 'ReST'),
-                                                                  ('application/x-xhtml-moin-page', 'HTML'),
-                                                                  ('application/docbook+xml;charset=utf-8', 'DocBook')))
-    comment = OptionalText.using(label=L_('Comment')).with_properties(placeholder=L_("Comment about your change"), )
-    submit_label = L_('OK')
+    new_type = Select.using(label=L_("New Content Type")).out_of(
+        (
+            ("text/x.moin.wiki;charset=utf-8", "MoinWiki"),
+            ("text/x-markdown;charset=utf-8", "Markdown"),
+            ("text/x-rst;charset=utf-8", "ReST"),
+            ("application/x-xhtml-moin-page", "HTML"),
+            ("application/docbook+xml;charset=utf-8", "DocBook"),
+        )
+    )
+    comment = OptionalText.using(label=L_("Comment")).with_properties(placeholder=L_("Comment about your change"))
+    submit_label = L_("OK")
 
 
-@frontend.route('/+convert/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+convert/<itemname:item_name>", methods=["GET", "POST"])
 def convert_item(item_name):
     """
     Convert an item to a new or same content type.
@@ -713,13 +728,10 @@ def convert_item(item_name):
     if isinstance(item, NonExistent):
         abort(404, item_name)
     form = ConvertForm.from_flat(request.form)
-    if request.method in ['GET', 'HEAD']:
-        return render_template('convert.html',
-                               item=item,
-                               form=form,
-                               contenttype=item.contenttype,
-                               fqname=split_fqname(item_name),
-                               )
+    if request.method in ["GET", "HEAD"]:
+        return render_template(
+            "convert.html", item=item, form=form, contenttype=item.contenttype, fqname=split_fqname(item_name)
+        )
 
     item.rev.data.seek(0)
     content = item.rev.data.read()
@@ -727,29 +739,30 @@ def convert_item(item_name):
     dom = input_conv(content, item.contenttype)
 
     try:
-        if not item.contenttype == form['new_type'].value:
-            if not (item.contenttype in CONTENTTYPE_NO_EXPANSION
-                    and form['new_type'].value in CONTENTTYPE_NO_EXPANSION):
+        if not item.contenttype == form["new_type"].value:
+            if not (
+                item.contenttype in CONTENTTYPE_NO_EXPANSION and form["new_type"].value in CONTENTTYPE_NO_EXPANSION
+            ):
                 # expand DOM only when converting to dissimilar item types (moin and creole are similar)
                 dom = item.content._expand_document(dom)
 
-        conv_out = reg.get(type_moin_document, Type(form['new_type'].value))
+        conv_out = reg.get(type_moin_document, Type(form["new_type"].value))
         out = conv_out(dom)
     except Exception:
         logging.exception("Error converting item: %s", item.fqname)
-        flash(L_("Item conversion failed"), 'error')
+        flash(L_("Item conversion failed"), "error")
         return redirect(url_for_item(**item.fqname.split))
     meta = dict(item.meta)
-    if form['new_type'].value == 'application/x-xhtml-moin-page':
+    if form["new_type"].value == "application/x-xhtml-moin-page":
         # serialize the html tree created by the html converter, and change content type
-        out = conv_serialize(out, {html.namespace: ''})
-        meta[CONTENTTYPE] = 'text/html;charset=utf-8'
-    elif form['new_type'].value == 'application/docbook+xml;charset=utf-8':
-        namespaces = {docbook.namespace: '', }
+        out = conv_serialize(out, {html.namespace: ""})
+        meta[CONTENTTYPE] = "text/html;charset=utf-8"
+    elif form["new_type"].value == "application/docbook+xml;charset=utf-8":
+        namespaces = {docbook.namespace: ""}
         out = conv_serialize(out, namespaces)
-        meta[CONTENTTYPE] = form['new_type'].value
+        meta[CONTENTTYPE] = form["new_type"].value
     else:
-        meta[CONTENTTYPE] = form['new_type'].value
+        meta[CONTENTTYPE] = form["new_type"].value
     out = out.encode(CHARSET)
     size, hash_name, hash_digest = hash_hexdigest(out)
     out = BytesIO(out)
@@ -759,24 +772,34 @@ def convert_item(item_name):
     meta[REVID] = make_uuid()
     meta[MTIME] = int(time.time())
     meta[REV_NUMBER] = meta.get(REV_NUMBER, 0) + 1
-    meta[COMMENT] = form['comment'].value
-    del meta['dataid']
+    meta[COMMENT] = form["comment"].value
+    del meta["dataid"]
     out.seek(0)
     backend = flaskg.storage
     storage_item = backend.get_item(**item.fqname.query)
-    newrev = storage_item.store_revision(meta, out, overwrite=False,
-                                         action=str(ACTION_CONVERT),
-                                         contenttype_current=Type(form['new_type'].value),
-                                         contenttype_guessed=Type(form['new_type'].value),
-                                         return_rev=True,
-                                         )
-    item_modified.send(app, fqname=meta['name'][0], action=ACTION_CONVERT, data=BytesIO(content),
-                       meta=item.meta, new_data=out, new_meta=newrev.meta)
-    flash(L_("Item converted successfully"), 'info')
+    newrev = storage_item.store_revision(
+        meta,
+        out,
+        overwrite=False,
+        action=str(ACTION_CONVERT),
+        contenttype_current=Type(form["new_type"].value),
+        contenttype_guessed=Type(form["new_type"].value),
+        return_rev=True,
+    )
+    item_modified.send(
+        app,
+        fqname=meta["name"][0],
+        action=ACTION_CONVERT,
+        data=BytesIO(content),
+        meta=item.meta,
+        new_data=out,
+        new_meta=newrev.meta,
+    )
+    flash(L_("Item converted successfully"), "info")
     return redirect(url_for_item(**item.fqname.split))
 
 
-@frontend.route('/+modify/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+modify/<itemname:item_name>", methods=["GET", "POST"])
 def modify_item(item_name):
     """Modify the wiki item item_name.
 
@@ -785,8 +808,8 @@ def modify_item(item_name):
     After successful POST, redirects to the page.
     """
     # XXX drawing applets don't send itemtype
-    itemtype = request.values.get('itemtype', ITEMTYPE_DEFAULT)
-    contenttype = request.values.get('contenttype')
+    itemtype = request.values.get("itemtype", ITEMTYPE_DEFAULT)
+    contenttype = request.values.get("contenttype")
     try:
         item = Item.create(item_name, itemtype=itemtype, contenttype=contenttype)
     except AccessDenied:
@@ -805,7 +828,7 @@ def modify_item(item_name):
 
 
 class TargetChangeForm(BaseChangeForm):
-    target = RequiredText.using(label=L_('Target')).with_properties(
+    target = RequiredText.using(label=L_("Target")).with_properties(
         placeholder=L_("The name of the target item"), autofocus=True
     )
 
@@ -814,33 +837,34 @@ class ValidRevert(Validator):
     """
     Validator for a valid revert form.
     """
-    invalid_name_msg = ''
+
+    invalid_name_msg = ""
 
     def validate(self, element, state):
         """
         Check whether the names present in the previous meta are not taken by some other item.
         """
         try:
-            validate_name(state['meta'], state['meta'].get(ITEMID))
+            validate_name(state["meta"], state["meta"].get(ITEMID))
             return True
         except NameNotValidError as e:
             self.invalid_name_msg = _(str(e))
-            return self.note_error(element, state, 'invalid_name_msg')
+            return self.note_error(element, state, "invalid_name_msg")
 
 
 class RevertItemForm(BaseChangeForm):
-    name = 'revert_item'
+    name = "revert_item"
     validators = [ValidRevert()]
 
 
 class DeleteItemForm(BaseChangeForm):
-    name = 'delete_item'
-    delete_subitems = Checkbox.using(label=L_('Delete all subitems listed below if checked:'))
+    name = "delete_item"
+    delete_subitems = Checkbox.using(label=L_("Delete all subitems listed below if checked:"))
 
 
 class DestroyItemForm(BaseChangeForm):
-    name = 'destroy_item'
-    destroy_subitems = Checkbox.using(label=L_('Destroy all subitems listed below if checked:'))
+    name = "destroy_item"
+    destroy_subitems = Checkbox.using(label=L_("Destroy all subitems listed below if checked:"))
 
 
 class RenameItemForm(TargetChangeForm):
@@ -860,17 +884,17 @@ def validate(self, element, state):
             return False
 
 
-@frontend.route('/+create', methods=['POST'])
+@frontend.route("/+create", methods=["POST"])
 def create_item():
     """
     A user has corrected an invalid item name keyed into the +index > Create dialog or brower's URL.
     """
     form = CreateItemForm.from_flat(request.form)
-    item_name = form['target']
+    item_name = form["target"]
     return redirect(url_for_item(item_name))
 
 
-@frontend.route('/+revert/+<rev>/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+revert/+<rev>/<itemname:item_name>", methods=["GET", "POST"])
 def revert_item(item_name, rev):
     try:
         item = Item.create(item_name, rev_id=rev)
@@ -880,28 +904,29 @@ def revert_item(item_name, rev):
         abort(403)
     if isinstance(item, NonExistent):
         abort(404, item_name)
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = RevertItemForm.from_defaults()
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = RevertItemForm.from_flat(request.form)
         state = dict(fqname=item.fqname, meta=dict(item.meta))
         if form.validate(state):
-            item.revert(form['comment'])
+            item.revert(form["comment"])
             close_file(item.rev.data)
             name = CompositeName(item.fqname.namespace, NAME_EXACT, item.name)
             return redirect(url_for_item(name))
-    ret = render_template('revert.html',
-                          item=item,
-                          fqname=item.fqname,
-                          rev_id=rev,
-                          form=form,
-                          data_rendered=Markup(item.content._render_data()),
-                          )
+    ret = render_template(
+        "revert.html",
+        item=item,
+        fqname=item.fqname,
+        rev_id=rev,
+        form=form,
+        data_rendered=Markup(item.content._render_data()),
+    )
     close_file(item.rev.data)
     return ret
 
 
-@frontend.route('/+rename/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+rename/<itemname:item_name>", methods=["GET", "POST"])
 def rename_item(item_name):
     try:
         item = Item.create(item_name)
@@ -912,22 +937,22 @@ def rename_item(item_name):
     if isinstance(item, NonExistent):
         abort(404, item_name)
     subitem_names = []
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = RenameItemForm.from_defaults()
-        form['target'] = ', '.join(item.names)
+        form["target"] = ", ".join(item.names)
         subitems = item.get_subitem_revs()
-        item_names = tuple(x + '/' for x in item.names)
+        item_names = tuple(x + "/" for x in item.names)
         subitem_names = [y for x in subitems for y in x.meta[NAME] if y.startswith(item_names)]
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = RenameItemForm.from_flat(request.form)
-        target = form['target']
-        targets = [x.strip() for x in str(target).split(',') if x]
+        target = form["target"]
+        targets = [x.strip() for x in str(target).split(",") if x]
         alt_meta = {}
         alt_meta[NAME] = targets
         alt_meta[NAMESPACE] = item.meta[NAMESPACE]
 
         if form.validate(alt_meta, item.meta[ITEMID]):
-            comment = form['comment'].value
+            comment = form["comment"].value
             try:
                 fqname = CompositeName(item.fqname.namespace, item.fqname.field, targets[0])
                 item.rename(targets, comment)
@@ -938,21 +963,22 @@ def rename_item(item_name):
                 flash(str(e), "error")
             except MissingParentError as e:
                 flash(str(e), "error")
-    ret = render_template('rename.html',
-                          item=item,
-                          item_name=item_name,
-                          item_names=item.names,
-                          subitem_names=subitem_names,
-                          fqname=item.fqname,
-                          form=form,
-                          data_rendered=Markup(item.content._render_data()),
-                          len=len,
-                          )
+    ret = render_template(
+        "rename.html",
+        item=item,
+        item_name=item_name,
+        item_names=item.names,
+        subitem_names=subitem_names,
+        fqname=item.fqname,
+        form=form,
+        data_rendered=Markup(item.content._render_data()),
+        len=len,
+    )
     close_file(item.meta.revision.data)
     return ret
 
 
-@frontend.route('/+delete/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+delete/<itemname:item_name>", methods=["GET", "POST"])
 def delete_item(item_name):
     try:
         item = Item.create(item_name)
@@ -963,47 +989,48 @@ def delete_item(item_name):
     if isinstance(item, NonExistent):
         abort(404, item_name)
     subitem_names = []
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = DeleteItemForm.from_defaults()
         subitems = list(item.get_subitem_revs())
-        item_names = tuple(x + '/' for x in item.names)
+        item_names = tuple(x + "/" for x in item.names)
         subitem_names = [y for x in subitems for y in x.meta[NAME] if y.startswith(item_names)]
 
         data_rendered = Markup(item.content._render_data())
         alias_names = set(item.names) - {item_name}
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = DeleteItemForm.from_flat(request.form)
         if form.validate():
-            comment = form['comment'].value
-            do_subitems = form['delete_subitems'].value
+            comment = form["comment"].value
+            do_subitems = form["delete_subitems"].value
             try:
                 item.delete(comment, do_subitems=do_subitems)
             except AccessDenied:
                 abort(403)
             close_file(item.meta.revision.data)
             return redirect(url_for_item(item_name))
-    ret = render_template('delete.html',
-                          item=item,
-                          item_name=item_name,
-                          alias_names=tuple(alias_names),
-                          subitem_names=subitem_names,
-                          fqname=split_fqname(item_name),
-                          form=form,
-                          data_rendered=data_rendered,
-                          )
+    ret = render_template(
+        "delete.html",
+        item=item,
+        item_name=item_name,
+        alias_names=tuple(alias_names),
+        subitem_names=subitem_names,
+        fqname=split_fqname(item_name),
+        form=form,
+        data_rendered=data_rendered,
+    )
     close_file(item.rev.data)
     return ret
 
 
-@frontend.route('/+ajaxdelete/<itemname:item_name>', methods=['POST'])
-@frontend.route('/+ajaxdelete', defaults=dict(item_name=''), methods=['POST'])
+@frontend.route("/+ajaxdelete/<itemname:item_name>", methods=["POST"])
+@frontend.route("/+ajaxdelete", defaults=dict(item_name=""), methods=["POST"])
 def ajaxdelete(item_name):
-    return ajaxdestroy(item_name, req='delete')
+    return ajaxdestroy(item_name, req="delete")
 
 
-@frontend.route('/+ajaxdestroy/<itemname:item_name>', methods=['POST'])
-@frontend.route('/+ajaxdestroy', defaults=dict(item_name=''), methods=['POST'])
-def ajaxdestroy(item_name, req='destroy'):
+@frontend.route("/+ajaxdestroy/<itemname:item_name>", methods=["POST"])
+@frontend.route("/+ajaxdestroy", defaults=dict(item_name=""), methods=["POST"])
+def ajaxdestroy(item_name, req="destroy"):
     """
     Handles both ajax delete and ajax destroy.
 
@@ -1016,7 +1043,7 @@ def ajaxdestroy(item_name, req='destroy'):
     args = request.values.to_dict()
     comment = args.get("comment")
     itemnames = args.get("itemnames")
-    do_subitems = True if args.get("do_subitems") == 'true' else False
+    do_subitems = True if args.get("do_subitems") == "true" else False
     itemnames = json.loads(itemnames)
     response = {"itemnames": [], "messages": []}
     messages = []
@@ -1029,7 +1056,7 @@ def ajaxdestroy(item_name, req='destroy'):
                 # user probably checked a subitem and checked do subitems
                 response["messages"].append(_("Item '{bad_name}' does not exist.").format(bad_name=item.name))
                 continue
-            if req == 'destroy':
+            if req == "destroy":
                 subitem_names = []
                 if do_subitems:
                     subitems = item.get_subitem_revs()
@@ -1044,8 +1071,9 @@ def ajaxdestroy(item_name, req='destroy'):
                     messages, subitem_names = item.delete(comment, do_subitems=do_subitems, ajax=True)
                 except AccessDenied:
                     # some deletes may have succeeded, one failed, there may be unprocessed items
-                    msg = _("Access denied for a subitem of {bad_name}, check History for status."
-                            ).format(bad_name=itemname)
+                    msg = _("Access denied for a subitem of {bad_name}, check History for status.").format(
+                        bad_name=itemname
+                    )
                     response["messages"].append(msg)
             response["messages"] += messages
             response["itemnames"] += subitem_names + itemnames
@@ -1055,18 +1083,18 @@ def ajaxdestroy(item_name, req='destroy'):
     return jsonify(response)
 
 
-@frontend.route('/+ajaxmodify/<itemname:item_name>', methods=['POST'])
-@frontend.route('/+ajaxmodify', methods=['POST'], defaults=dict(item_name=''))
+@frontend.route("/+ajaxmodify/<itemname:item_name>", methods=["POST"])
+@frontend.route("/+ajaxmodify", methods=["POST"], defaults=dict(item_name=""))
 def ajaxmodify(item_name):
     newitem = request.values.get("newitem")
     if not newitem:
         abort(404, item_name)
     if item_name:
-        newitem = item_name + '/' + newitem
+        newitem = item_name + "/" + newitem
     return redirect(url_for_item(newitem))
 
 
-@frontend.route('/+ajaxsubitems', methods=['POST'])
+@frontend.route("/+ajaxsubitems", methods=["POST"])
 def ajaxsubitems():
     """
     Given a list of item names, return lists of alias names, subitem names,
@@ -1105,7 +1133,7 @@ def ajaxsubitems():
         alias_names = []
         subitems = list(item.get_subitem_revs())
         # TODO: add check for delete/destroy auth, add to rejected names,
-        item_names = tuple(x + '/' for x in item.names)
+        item_names = tuple(x + "/" for x in item.names)
         # subitems may have alias names pointing to sibling or parent of user selected items
         subitem_names = [y for x in subitems for y in x.meta[NAME]]
         if not [item.name] == item.names:
@@ -1114,39 +1142,42 @@ def ajaxsubitems():
         all_subitem_names += subitem_names
         all_selected_names.append(item_name)
     all_subitem_names = set(all_subitem_names)
-    response = {"subitem_names": list(all_subitem_names),
-                "alias_names": all_alias_names,
-                "selected_names": all_selected_names,
-                "rejected_names": all_rejected_names}
+    response = {
+        "subitem_names": list(all_subitem_names),
+        "alias_names": all_alias_names,
+        "selected_names": all_selected_names,
+        "rejected_names": all_rejected_names,
+    }
     return jsonify(response)
 
 
 def log_destroy_action(item, subitem_names, comment, revision=None):
     """Document the destruction of an item or item revision."""
-    destroy_info = [('An item has been destroyed', ''),
-                    ('  Names', item.meta[NAME]),
-                    ('  Old Name', item.meta[NAME_OLD]),
-                    ('  Subitem Names', subitem_names),
-                    ('  Namespace', item.meta[NAMESPACE]),
-                    ('  Last Modified Time', format_datetime(datetime.utcfromtimestamp(item.meta[MTIME]))),
-                    ('  Last Modified By', item.meta[ADDRESS]),
-                    ('  Destroyed Time', format_datetime(datetime.utcfromtimestamp(time.time()))),
-                    ('  Destroyed By', flaskg.user.name),
-                    ('  Content Type', item.meta[CONTENTTYPE]),
-                    ('  Revision Number', item.meta[REV_NUMBER]),
-                    ('  Item Size', item.meta[SIZE]),
-                    ('  Comment', comment),
-                    ]
+    destroy_info = [
+        ("An item has been destroyed", ""),
+        ("  Names", item.meta[NAME]),
+        ("  Old Name", item.meta[NAME_OLD]),
+        ("  Subitem Names", subitem_names),
+        ("  Namespace", item.meta[NAMESPACE]),
+        ("  Last Modified Time", format_datetime(datetime.utcfromtimestamp(item.meta[MTIME]))),
+        ("  Last Modified By", item.meta[ADDRESS]),
+        ("  Destroyed Time", format_datetime(datetime.utcfromtimestamp(time.time()))),
+        ("  Destroyed By", flaskg.user.name),
+        ("  Content Type", item.meta[CONTENTTYPE]),
+        ("  Revision Number", item.meta[REV_NUMBER]),
+        ("  Item Size", item.meta[SIZE]),
+        ("  Comment", comment),
+    ]
     if revision:
-        destroy_info[0] = ('An item revision has been destroyed', item.meta[REV_NUMBER])
+        destroy_info[0] = ("An item revision has been destroyed", item.meta[REV_NUMBER])
     elif subitem_names:
-        destroy_info[0] = ('An item and all item subitems have been destroyed', '')
+        destroy_info[0] = ("An item and all item subitems have been destroyed", "")
     for name, val in destroy_info:
-        logging.info(f'{name}: {val}')
+        logging.info(f"{name}: {val}")
 
 
-@frontend.route('/+destroy/+<rev>/<itemname:item_name>', methods=['GET', 'POST'])
-@frontend.route('/+destroy/<itemname:item_name>', methods=['GET', 'POST'], defaults=dict(rev=None))
+@frontend.route("/+destroy/+<rev>/<itemname:item_name>", methods=["GET", "POST"])
+@frontend.route("/+destroy/<itemname:item_name>", methods=["GET", "POST"], defaults=dict(rev=None))
 def destroy_item(item_name, rev):
     """
     If incoming item_name has alias names, then destroy processing is different than delete
@@ -1187,22 +1218,22 @@ def destroy_item(item_name, rev):
     if rev is None and item_is_deleted:
         item_name = item.meta[NAME_OLD][0]
         subitems = item.get_subitem_revs()
-        subitem_names = [y for x in subitems for y in x.meta[NAME_OLD] if y.startswith(item_name + '/')]
+        subitem_names = [y for x in subitems for y in x.meta[NAME_OLD] if y.startswith(item_name + "/")]
         if not [item_name] == item.meta[NAME_OLD]:
             alias_names = [x for x in item.meta[NAME_OLD] if not x == item_name]
     elif rev is None:
         subitems = item.get_subitem_revs()
-        subitem_names = [y for x in subitems for y in x.meta[NAME] if y.startswith(item_name + '/')]
+        subitem_names = [y for x in subitems for y in x.meta[NAME] if y.startswith(item_name + "/")]
         if not [item.name] == item.names:
             alias_names = [x for x in item.names if not x == item.name]
 
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = DestroyItemForm.from_defaults()
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = DestroyItemForm.from_flat(request.form)
         if form.validate():
-            comment = form['comment'].value
-            do_subitems = form['destroy_subitems'].value
+            comment = form["comment"].value
+            do_subitems = form["destroy_subitems"].value
             if not do_subitems:
                 subitem_names = []
             try:
@@ -1212,95 +1243,117 @@ def destroy_item(item_name, rev):
             log_destroy_action(item, subitem_names, comment, revision=rev)
             # show user item is deleted by showing "item does not exist, create it?" page
             return redirect(url_for_item(item_name))
-    ret = render_template('destroy.html',
-                          item=item,
-                          item_name=item_name,
-                          subitem_names=subitem_names,
-                          alias_names=alias_names,
-                          fqname=fqname,
-                          rev_id=rev,
-                          form=form,
-                          data_rendered=Markup(item.content._render_data()),
-                          item_is_deleted=item_is_deleted,
-                          )
+    ret = render_template(
+        "destroy.html",
+        item=item,
+        item_name=item_name,
+        subitem_names=subitem_names,
+        alias_names=alias_names,
+        fqname=fqname,
+        rev_id=rev,
+        form=form,
+        data_rendered=Markup(item.content._render_data()),
+        item_is_deleted=item_is_deleted,
+    )
     close_file(item.meta.revision.data)
     close_file(item.rev.data)
     return ret
 
 
-@frontend.route('/+jfu-server/<itemname:item_name>', methods=['POST'])
-@frontend.route('/+jfu-server', defaults=dict(item_name=''), methods=['POST'])
+@frontend.route("/+jfu-server/<itemname:item_name>", methods=["POST"])
+@frontend.route("/+jfu-server", defaults=dict(item_name=""), methods=["POST"])
 def jfu_server(item_name):
     """
     jquery-file-upload server component, returns a json response
     """
-    msg = ''
-    data_file = request.files.get('file_storage')
+    msg = ""
+    data_file = request.files.get("file_storage")
     base_file_name = os.path.basename(data_file.filename)
     file_name = secure_filename(base_file_name)
     if not file_name == base_file_name:
-        msg = _("File Successfully uploaded and renamed from {bad_name} to {good_name}. "
-                ).format(bad_name=base_file_name, good_name=file_name)
+        msg = _("File Successfully uploaded and renamed from {bad_name} to {good_name}. ").format(
+            bad_name=base_file_name, good_name=file_name
+        )
     subitem_name = file_name
     data = data_file.stream
     mt = mime_type.MimeType(filename=file_name)
-    contenttype = mt.content_type(charset='utf-8')
+    contenttype = mt.content_type(charset="utf-8")
     small_meta = {CONTENTTYPE: contenttype}
     valid = validate_data(small_meta, data)
     if not valid:
-        msg = _("UnicodeDecodeError, upload failed, not a text file, nothing saved: '{file_name}'. "
-                "Try changing the name.").format(file_name=file_name)
-        ret = make_response(jsonify({"name": subitem_name,
-                                     "files": [item_name],
-                                     "message": msg,
-                                     "class": "jfu-failed",
-                                     "contenttype": contenttype_to_class(contenttype),
-                                     }), 200)
+        msg = _(
+            "UnicodeDecodeError, upload failed, not a text file, nothing saved: '{file_name}'. "
+            "Try changing the name."
+        ).format(file_name=file_name)
+        ret = make_response(
+            jsonify(
+                {
+                    "name": subitem_name,
+                    "files": [item_name],
+                    "message": msg,
+                    "class": "jfu-failed",
+                    "contenttype": contenttype_to_class(contenttype),
+                }
+            ),
+            200,
+        )
         return ret
 
     if item_name:
-        subitem_prefix = item_name + '/'
+        subitem_prefix = item_name + "/"
     else:
-        subitem_prefix = ''
+        subitem_prefix = ""
     item_name = subitem_prefix + subitem_name
     jfu_server_lock.acquire()
     try:
         item = Item.create(item_name)
         if not isinstance(item, NonExistent):
-            msg += _("File Successfully uploaded, existing file overwritten: '{file_name}'.").format(file_name=file_name)
-        revid, size = item.modify({'itemtype': ITEMTYPE_DEFAULT, }, data, contenttype_guessed=contenttype)
+            msg += _("File Successfully uploaded, existing file overwritten: '{file_name}'.").format(
+                file_name=file_name
+            )
+        revid, size = item.modify({"itemtype": ITEMTYPE_DEFAULT}, data, contenttype_guessed=contenttype)
         jfu_server_lock.release()
     except AccessDenied:
         # return 200 status with error message
         jfu_server_lock.release()
         msg = _("Permission denied, upload failed: '{file_name}'.").format(file_name=file_name)
-        ret = make_response(jsonify({"name": subitem_name,
-                                     "files": [item_name],
-                                     "message": msg,
-                                     "class": "jfu-failed",
-                                     "contenttype": contenttype_to_class(contenttype),
-                                     }), 200)
+        ret = make_response(
+            jsonify(
+                {
+                    "name": subitem_name,
+                    "files": [item_name],
+                    "message": msg,
+                    "class": "jfu-failed",
+                    "contenttype": contenttype_to_class(contenttype),
+                }
+            ),
+            200,
+        )
         return ret
 
     data_file.close()
     item_modified.send(app, fqname=item.fqname, action=ACTION_SAVE, new_meta=item.meta)
     if not msg:
         msg = _("File Successfully uploaded: '{item_name}'.").format(item_name=item_name)
-    ret = make_response(jsonify(name=subitem_name,
-                        files=[item_name],
-                        message=msg,
-                        size=size,
-                        url=url_for('.show_item', item_name=item_name),
-                        contenttype=contenttype_to_class(contenttype),
-                        ), 200)
+    ret = make_response(
+        jsonify(
+            name=subitem_name,
+            files=[item_name],
+            message=msg,
+            size=size,
+            url=url_for(".show_item", item_name=item_name),
+            contenttype=contenttype_to_class(contenttype),
+        ),
+        200,
+    )
     return ret
 
 
 def contenttype_selects_gen():
     for g in content_registry.group_names:
-        description = ', '.join([e.display_name for e in content_registry.groups[g]])
+        description = ", ".join([e.display_name for e in content_registry.groups[g]])
         yield g, None, description
-    yield 'Unknown Items', None, 'Items of contenttype unknown to MoinMoin'
+    yield "Unknown Items", None, "Items of contenttype unknown to MoinMoin"
 
 
 ContenttypeGroup = MultiSelect.of(Enum.out_of(contenttype_selects_gen())).using(optional=True)
@@ -1308,11 +1361,11 @@ def contenttype_selects_gen():
 
 class IndexForm(Form):
     contenttype = ContenttypeGroup
-    submit_label = L_('Apply Filter')
+    submit_label = L_("Apply Filter")
 
 
-@frontend.route('/+index/', defaults=dict(item_name=''), methods=['GET', 'POST'])
-@frontend.route('/+index/<itemname:item_name>', methods=['GET', 'POST'])
+@frontend.route("/+index/", defaults=dict(item_name=""), methods=["GET", "POST"])
+@frontend.route("/+index/<itemname:item_name>", methods=["GET", "POST"])
 def index(item_name):
     """
     Generate data for various index reports: global, sub-item, starts with character,
@@ -1346,20 +1399,20 @@ def name_initial(files, uppercase=False, lowercase=False):
     # more.
 
     form = IndexForm.from_flat(request.args.items(multi=True))
-    selected_groups = form['contenttype'].value
+    selected_groups = form["contenttype"].value
     startswith = request.values.get("startswith")
     dirs, files = item.get_index(startswith, selected_groups)
     dirs_fullname = [x.fullname for x in dirs]
     initials = request.values.get("initials")
     if initials:
-        initials = initials.split(',')
+        initials = initials.split(",")
     else:
         initials = name_initial(files, uppercase=True)
     fqname = item.fqname
     if fqname.value == NAMESPACE_ALL:
-        fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, '')
-    item_names = item_name.split('/')
-    ns_len = len(item.meta['namespace']) + 1 if item.meta['namespace'] else 0
+        fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, "")
+    item_names = item_name.split("/")
+    ns_len = len(item.meta["namespace"]) + 1 if item.meta["namespace"] else 0
 
     # detect orphan subitems and make a list of their missing parents
     used_dirs = set()
@@ -1380,11 +1433,11 @@ def name_initial(files, uppercase=False, lowercase=False):
         missing_dirs = missing
 
     if item_name:
-        what = ''
+        what = ""
         if item.fqname.value == NAMESPACE_ALL:
             title = _("Global Index of All Namespaces")
-        elif item.meta['namespace']:
-            what = _("Namespace '{name}' ").format(name=item.meta['namespace'])
+        elif item.meta["namespace"]:
+            what = _("Namespace '{name}' ").format(name=item.meta["namespace"])
             subitem = item_name[ns_len:]
             if subitem:
                 what = what + _("subitems '{item_name}'").format(item_name=subitem)
@@ -1395,29 +1448,30 @@ def name_initial(files, uppercase=False, lowercase=False):
         title = _("Global Index")
     close_file(item.rev.data)
 
-    return render_template('index.html',
-                           title_name='Global Index',
-                           item_names=item_names,
-                           item_name=item_name,
-                           fqname=fqname,
-                           files=files,
-                           dirs=dirs,
-                           dirs_fullname=dirs_fullname,
-                           missing_dirs=missing_dirs,
-                           initials=initials,
-                           startswith=startswith,
-                           form=form,
-                           item=item,
-                           title=title,
-                           NAMESPACE_USERPROFILES=NAMESPACE_USERPROFILES,
-                           editors=editor_info_for_reports(),
-                           selected_groups=selected_groups,
-                           str=str,
-                           app=app,
-                           )
-
-
-@frontend.route('/+mychanges')
+    return render_template(
+        "index.html",
+        title_name="Global Index",
+        item_names=item_names,
+        item_name=item_name,
+        fqname=fqname,
+        files=files,
+        dirs=dirs,
+        dirs_fullname=dirs_fullname,
+        missing_dirs=missing_dirs,
+        initials=initials,
+        startswith=startswith,
+        form=form,
+        item=item,
+        title=title,
+        NAMESPACE_USERPROFILES=NAMESPACE_USERPROFILES,
+        editors=editor_info_for_reports(),
+        selected_groups=selected_groups,
+        str=str,
+        app=app,
+    )
+
+
+@frontend.route("/+mychanges")
 def mychanges():
     """
     Returns the list of all revisions the current user has modified. The list is
@@ -1429,9 +1483,9 @@ def mychanges():
     if flaskg.user.valid:
         results_per_page = flaskg.user.results_per_page
     else:
-        flash(_('You must be logged in to see your changes.'), "error")
+        flash(_("You must be logged in to see your changes."), "error")
         results_per_page = app.cfg.results_per_page
-    page_num = request.values.get('page_num', 1)
+    page_num = request.values.get("page_num", 1)
     page_num = max(int(page_num), 1)
 
     query = And([Term(WIKINAME, app.cfg.interwikiname), Term(USERID, flaskg.user.itemid)])
@@ -1451,36 +1505,37 @@ def mychanges():
     my_changes = []
     for meta in metas:
         entry = {}
-        for key in (MTIME, SIZE, REV_NUMBER, REVID, CONTENTTYPE, ):
+        for key in (MTIME, SIZE, REV_NUMBER, REVID, CONTENTTYPE):
             entry[key] = meta[key]
-        entry[COMMENT] = meta.get(COMMENT, '')
+        entry[COMMENT] = meta.get(COMMENT, "")
         entry[FQNAMES] = gen_fqnames(meta)
-        entry[PARENTID] = meta.get(PARENTID, '')
+        entry[PARENTID] = meta.get(PARENTID, "")
         entry[TRASH] = meta.get(TRASH, False)
         entry[SUMMARY] = meta.get(SUMMARY, False)
         entry[NAME_OLD] = meta.get(NAME_OLD, False)
         my_changes.append(entry)
 
-    return render_template('mychanges.html',
-                           title_name=_('My Changes'),
-                           headline=_('My Changes'),
-                           my_changes=my_changes,
-                           page_num=page_num,
-                           pages=pages,
-                           url=request.url.split('?')[0],
-                           )
+    return render_template(
+        "mychanges.html",
+        title_name=_("My Changes"),
+        headline=_("My Changes"),
+        my_changes=my_changes,
+        page_num=page_num,
+        pages=pages,
+        url=request.url.split("?")[0],
+    )
 
 
 def shorten_item_id(name, length=7):
     """
     Shorten IDs starting with @itemid/ to specified length,
     """
-    if name.startswith('@itemid/'):
-        return name[8:8 + length]
+    if name.startswith("@itemid/"):
+        return name[8 : 8 + length]
     return name
 
 
-@frontend.route('/+forwardrefs/<itemname:item_name>')
+@frontend.route("/+forwardrefs/<itemname:item_name>")
 def forwardrefs(item_name):
     """
     Returns the list of all links or transclusions of item item_name
@@ -1490,13 +1545,13 @@ def forwardrefs(item_name):
     :returns: a page with all the items linked from this item
     """
     refs = _forwardrefs(item_name)
-    return render_template('link_list_item_panel.html',
-                           item_name=item_name,
-                           fqname=split_fqname(item_name),
-                           headline=_("Items that are referred by '{item_name}'"
-                                      ).format(item_name=shorten_item_id(item_name)),
-                           fq_names=split_fqname_list(refs),
-                           )
+    return render_template(
+        "link_list_item_panel.html",
+        item_name=item_name,
+        fqname=split_fqname(item_name),
+        headline=_("Items that are referred by '{item_name}'").format(item_name=shorten_item_id(item_name)),
+        fq_names=split_fqname_list(refs),
+    )
 
 
 def _forwardrefs(item_name):
@@ -1518,7 +1573,7 @@ def _forwardrefs(item_name):
     return set(refs)
 
 
-@frontend.route('/+backrefs/<itemname:item_name>')
+@frontend.route("/+backrefs/<itemname:item_name>")
 def backrefs(item_name):
     """
     Returns a list of all items that link or transclude item_name.
@@ -1532,13 +1587,14 @@ def backrefs(item_name):
     except AccessDenied:
         abort(403)
     refs_here = _backrefs(item_name)
-    return render_template('link_list_item_panel.html',
-                           item=item,
-                           item_name=item_name,
-                           fqname=split_fqname(item_name),
-                           headline=_("Items which refer to '{item_name}'").format(item_name=shorten_item_id(item_name)),
-                           fq_names=refs_here,
-                           )
+    return render_template(
+        "link_list_item_panel.html",
+        item=item,
+        item_name=item_name,
+        fqname=split_fqname(item_name),
+        headline=_("Items which refer to '{item_name}'").format(item_name=shorten_item_id(item_name)),
+        fq_names=refs_here,
+    )
 
 
 def _backrefs(item_name):
@@ -1549,13 +1605,14 @@ def _backrefs(item_name):
     :type item_name: unicode
     :returns: the list of all items which ref fq_name
     """
-    q = And([Term(WIKINAME, app.cfg.interwikiname),
-             Or([Term(ITEMTRANSCLUSIONS, item_name), Term(ITEMLINKS, item_name)])])
+    q = And(
+        [Term(WIKINAME, app.cfg.interwikiname), Or([Term(ITEMTRANSCLUSIONS, item_name), Term(ITEMLINKS, item_name)])]
+    )
     metas = flaskg.storage.search_meta(q)
     return {fqname for meta in metas for fqname in meta[FQNAMES]}
 
 
-@frontend.route('/+history/<itemname:item_name>')
+@frontend.route("/+history/<itemname:item_name>")
 def history(item_name):
     fqname = split_fqname(item_name)
     try:
@@ -1566,14 +1623,14 @@ def history(item_name):
         abort(404, item_name)
 
     item_is_deleted = flash_if_item_deleted(item_name, CURRENT, item)
-    page_num = request.values.get('page_num', 1)
+    page_num = request.values.get("page_num", 1)
     page_num = max(int(page_num), 1)
-    bookmark_time = int(request.values.get('bookmark', 0))
+    bookmark_time = int(request.values.get("bookmark", 0))
     if flaskg.user.valid:
         results_per_page = flaskg.user.results_per_page
     else:
         results_per_page = app.cfg.results_per_page
-    terms = [Term(WIKINAME, app.cfg.interwikiname), ]
+    terms = [Term(WIKINAME, app.cfg.interwikiname)]
     terms.extend(Term(term, value) for term, value in fqname.query.items())
     if bookmark_time:
         terms.append(DateRange(MTIME, start=datetime.utcfromtimestamp(bookmark_time), end=None))
@@ -1598,7 +1655,7 @@ def history(item_name):
         entry[FQNAMES] = gen_fqnames(meta)
         history.append(entry)
     close_file(item.rev.data)
-    trash = item.meta['trash'] if 'trash' in item.meta else False
+    trash = item.meta["trash"] if "trash" in item.meta else False
 
     # avoid repeated IO to get user profile when same user edits this item multiple times
     editor_infos = {}  # userid: user_info
@@ -1606,22 +1663,23 @@ def history(item_name):
         uid = hist_meta.get(USERID) or hist_meta.get(ADDRESS)
         if uid not in editor_infos:
             editor_infos[uid] = get_editor_info(hist_meta)
-    flaskg.clock.start('renderrevs')
-    ret = render_template('history.html',
-                          fqname=fqname,
-                          item=item,
-                          item_name=item_name,
-                          history=history,
-                          page_num=page_num,
-                          pages=pages,
-                          editor_infos=editor_infos,
-                          bookmark_time=bookmark_time,
-                          NAME_EXACT=NAME_EXACT,
-                          len=len,
-                          trash=trash,
-                          item_is_deleted=item_is_deleted,
-                          )
-    flaskg.clock.stop('renderrevs')
+    flaskg.clock.start("renderrevs")
+    ret = render_template(
+        "history.html",
+        fqname=fqname,
+        item=item,
+        item_name=item_name,
+        history=history,
+        page_num=page_num,
+        pages=pages,
+        editor_infos=editor_infos,
+        bookmark_time=bookmark_time,
+        NAME_EXACT=NAME_EXACT,
+        len=len,
+        trash=trash,
+        item_is_deleted=item_is_deleted,
+    )
+    flaskg.clock.stop("renderrevs")
     close_file(item.rev.data)
     return ret
 
@@ -1642,10 +1700,10 @@ def editor_info_for_reports():
     return editors
 
 
-@frontend.route('/<namespace>/+history')
-@frontend.route('/+history', defaults=dict(namespace=NAMESPACE_DEFAULT), methods=['GET'])
+@frontend.route("/<namespace>/+history")
+@frontend.route("/+history", defaults=dict(namespace=NAMESPACE_DEFAULT), methods=["GET"])
 def global_history(namespace):
-    all_revs = bool(request.values.get('all'))  # no UI help, user must add ?all=1 to url
+    all_revs = bool(request.values.get("all"))  # no UI help, user must add ?all=1 to url
     idx_name = ALL_REVS if all_revs else LATEST_REVS
 
     if flaskg.user.valid:
@@ -1653,10 +1711,10 @@ def global_history(namespace):
     else:
         results_per_page = app.cfg.results_per_page
 
-    page_num = request.values.get('page_num', 1)
+    page_num = request.values.get("page_num", 1)
     page_num = max(int(page_num), 1)
     terms = [Term(WIKINAME, app.cfg.interwikiname)]
-    fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, '')
+    fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, "")
     if namespace != NAMESPACE_ALL:
         terms.append(Term(NAMESPACE, namespace))
         fqname = split_fqname(namespace)
@@ -1669,9 +1727,9 @@ def global_history(namespace):
 
     if results_per_page:
         len_revs = flaskg.storage.search_results_size(query, idx_name=idx_name)
-        metas = flaskg.storage.search_meta_page(query, idx_name=idx_name, sortedby=[MTIME],
-                                                reverse=True, pagenum=page_num,
-                                                pagelen=results_per_page)
+        metas = flaskg.storage.search_meta_page(
+            query, idx_name=idx_name, sortedby=[MTIME], reverse=True, pagenum=page_num, pagelen=results_per_page
+        )
         pages = (len_revs + results_per_page - 1) // results_per_page
         if page_num > pages:
             page_num = pages
@@ -1680,8 +1738,8 @@ def global_history(namespace):
         metas = flaskg.storage.search_meta(query, idx_name=idx_name, sortedby=[MTIME], reverse=True, limit=None)
     # Group by date
     history = []
-    day_history = namedtuple('day_history', ['day', 'entries'])
-    prev_date = '0000-00-00'
+    day_history = namedtuple("day_history", ["day", "entries"])
+    prev_date = "0000-00-00"
     dh = day_history(prev_date, [])  # dummy
     for meta in metas:
         meta[MTIME] = int(meta[MTIME].replace(tzinfo=timezone.utc).timestamp())
@@ -1696,7 +1754,7 @@ def global_history(namespace):
     else:
         history.append(dh)
     del history[0]  # kill the dummy
-    title_name = _('Global History')
+    title_name = _("Global History")
     if namespace == NAMESPACE_ALL:
         title = _("Global History of All Namespaces")
     elif namespace:
@@ -1704,18 +1762,19 @@ def global_history(namespace):
     else:
         title = _("Global History")
     current_timestamp = int(time.time())
-    return render_template('global_history.html',
-                           title_name=title_name,
-                           history=history,
-                           current_timestamp=current_timestamp,
-                           bookmark_time=bookmark_time,
-                           fqname=fqname,
-                           title=title,
-                           int=int,
-                           page_num=page_num,
-                           pages=pages,
-                           url=request.url.split('?')[0],
-                           )
+    return render_template(
+        "global_history.html",
+        title_name=title_name,
+        history=history,
+        current_timestamp=current_timestamp,
+        bookmark_time=bookmark_time,
+        fqname=fqname,
+        title=title,
+        int=int,
+        page_num=page_num,
+        pages=pages,
+        url=request.url.split("?")[0],
+    )
 
 
 def _compute_item_sets(wanted=False):
@@ -1726,8 +1785,9 @@ def _compute_item_sets(wanted=False):
     transcluded = set()
     existing = set()
     who_wants = {}
-    query = And([Term(WIKINAME, app.cfg.interwikiname),
-                 Not(Term(NAMESPACE, NAMESPACE_USERPROFILES)), Not(Term(TRASH, True))])
+    query = And(
+        [Term(WIKINAME, app.cfg.interwikiname), Not(Term(NAMESPACE, NAMESPACE_USERPROFILES)), Not(Term(TRASH, True))]
+    )
     metas = flaskg.storage.search_meta(query, idx_name=LATEST_REVS, sortedby=[NAME], limit=None)
     if wanted:
         for meta in metas:
@@ -1754,7 +1814,7 @@ def split_fqname_list(names):
     return [split_fqname(name) for name in names]
 
 
-@frontend.route('/+wanteds')
+@frontend.route("/+wanteds")
 def wanted_items():
     """
     Returns a list view of non-existing items that are linked to or
@@ -1768,15 +1828,13 @@ def wanted_items():
     existing, linked, transcluded, who_wants = _compute_item_sets(wanted=True)
     referred = linked | transcluded
     wanteds = referred - existing
-    title_name = _('Wanted Items')
-    return render_template('wanteds.html',
-                           headline=_('Wanted Items'),
-                           title_name=title_name,
-                           who_wants=who_wants,
-                           fq_names=wanteds)
+    title_name = _("Wanted Items")
+    return render_template(
+        "wanteds.html", headline=_("Wanted Items"), title_name=title_name, who_wants=who_wants, fq_names=wanteds
+    )
 
 
-@frontend.route('/+orphans')
+@frontend.route("/+orphans")
 def orphaned_items():
     """
     Return a list view of existing items not being linked or transcluded
@@ -1785,34 +1843,33 @@ def orphaned_items():
     existing, linked, transcluded, who_wants = _compute_item_sets()
     referred = linked | transcluded
     orphans = existing - referred
-    title_name = _('Orphaned Items')
-    return render_template('link_list_no_item_panel.html',
-                           title_name=title_name,
-                           headline=_('Orphaned Items'),
-                           fq_names=orphans)
+    title_name = _("Orphaned Items")
+    return render_template(
+        "link_list_no_item_panel.html", title_name=title_name, headline=_("Orphaned Items"), fq_names=orphans
+    )
 
 
-@frontend.route('/+quicklink/<itemname:item_name>')
+@frontend.route("/+quicklink/<itemname:item_name>")
 def quicklink_item(item_name):
-    """ Add/Remove the current wiki page to/from the user quicklinks """
+    """Add/Remove the current wiki page to/from the user quicklinks"""
     u = flaskg.user
     msg = None
     if not u.valid:
         msg = _("You must login to use this action: {action}.").format(action="quicklink/quickunlink"), "error"
     elif not flaskg.user.is_quicklinked_to([item_name]):
         if not u.quicklink(item_name):
-            msg = _('A quicklink to this page could not be added for you.'), "error"
+            msg = _("A quicklink to this page could not be added for you."), "error"
     else:
         if not u.quickunlink(item_name):
-            msg = _('Your quicklink to this page could not be removed.'), "error"
+            msg = _("Your quicklink to this page could not be removed."), "error"
     if msg:
         flash(*msg)
     return redirect(url_for_item(item_name))
 
 
-@frontend.route('/+subscribe/<itemname:item_name>')
+@frontend.route("/+subscribe/<itemname:item_name>")
 def subscribe_item(item_name):
-    """ Add/Remove the current wiki item to/from the user's subscriptions """
+    """Add/Remove the current wiki item to/from the user's subscriptions"""
     u = flaskg.user
     msg = None
     try:
@@ -1828,44 +1885,51 @@ def subscribe_item(item_name):
     elif u.is_subscribed_to(item):
         # Try to unsubscribe
         if not u.unsubscribe(ITEMID, item.meta[ITEMID]):
-            msg = _(
-                "Can't remove the subscription! You are subscribed to this page, but not by itemid.") + ' ' + _(
-                "Please edit the subscription in your settings."), "error"
+            msg = (
+                _("Can't remove the subscription! You are subscribed to this page, but not by itemid.")
+                + " "
+                + _("Please edit the subscription in your settings."),
+                "error",
+            )
     else:
         # Try to subscribe
         if not u.subscribe(ITEMID, item.meta[ITEMID]):
-            msg = _('You could not get subscribed to this item.'), "error"
+            msg = _("You could not get subscribed to this item."), "error"
     if msg:
         flash(*msg)
     return redirect(url_for_item(item_name))
 
 
 class ValidRegistration(Validator):
-    """Validator for a valid registration form
-    """
-    passwords_mismatch_msg = L_('The passwords do not match.')
+    """Validator for a valid registration form"""
+
+    passwords_mismatch_msg = L_("The passwords do not match.")
 
     def validate(self, element, state):
-        if not (element['username'].valid and
-                element['password1'].valid and element['password2'].valid and
-                element['email'].valid):
+        if not (
+            element["username"].valid
+            and element["password1"].valid
+            and element["password2"].valid
+            and element["email"].valid
+        ):
             return False
-        if element['password1'].value != element['password2'].value:
-            return self.note_error(element, state, 'passwords_mismatch_msg')
+        if element["password1"].value != element["password2"].value:
+            return self.note_error(element, state, "passwords_mismatch_msg")
         return True
 
 
 class RegistrationForm(Form):
     """a simple user registration form"""
-    name = 'register'
 
-    username = RequiredText.using(label=L_('Username')).with_properties(
+    name = "register"
+
+    username = RequiredText.using(label=L_("Username")).with_properties(
         placeholder=L_("The login username you want to use"), autofocus=True
     )
     password1 = RequiredPassword.with_properties(placeholder=L_("The login password you want to use"))
     password2 = RequiredPassword.with_properties(placeholder=L_("Repeat the same password"))
     email = YourEmail
-    submit_label = L_('Register')
+    submit_label = L_("Register")
 
     validators = [ValidRegistration()]
 
@@ -1876,135 +1940,139 @@ def _using_moin_auth():
     Only then users can register with moin or change their password via moin.
     """
     from moin.auth import MoinAuth
+
     for auth in app.cfg.auth:
         if isinstance(auth, MoinAuth):
             return True
     return False
 
 
-@frontend.route('/+register', methods=['GET', 'POST'])
+@frontend.route("/+register", methods=["GET", "POST"])
 def register():
     if app.cfg.registration_only_by_superuser and not getattr(flaskg.user.may, SUPERUSER)():
         # deny registration to bots
         abort(404)
 
     if not _using_moin_auth():
-        return Response('No MoinAuth in auth list', 403)
+        return Response("No MoinAuth in auth list", 403)
 
-    title_name = _('Register')
-    template = 'register.html'
+    title_name = _("Register")
+    template = "register.html"
     FormClass = RegistrationForm
 
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = FormClass.from_defaults()
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = FormClass.from_flat(request.form)
         if form.validate():
             user_kwargs = {
-                'username': form['username'].value,
-                'password': form['password1'].value,
-                'email': form['email'].value,
+                "username": form["username"].value,
+                "password": form["password1"].value,
+                "email": form["email"].value,
             }
             if app.cfg.user_email_verification:
-                user_kwargs['is_disabled'] = True
-                user_kwargs['verify_email'] = True
+                user_kwargs["is_disabled"] = True
+                user_kwargs["verify_email"] = True
             msg = user.create_user(**user_kwargs)
             if msg:
                 flash(msg, "error")
             else:
                 if app.cfg.user_email_verification:
-                    u = user.User(auth_username=user_kwargs['username'])
+                    u = user.User(auth_username=user_kwargs["username"])
                     is_ok, msg = u.mail_email_verification()
                     if is_ok:
-                        flash(_('Account verification required, please see the email we sent to your address.'), "info")
+                        flash(_("Account verification required, please see the email we sent to your address."), "info")
                     else:
-                        flash(_('An error occurred while sending the verification email: "{message}" '
-                                'Please contact an administrator to activate your account.'
-                                ).format(message=msg), "error")
+                        flash(
+                            _(
+                                'An error occurred while sending the verification email: "{message}" '
+                                "Please contact an administrator to activate your account."
+                            ).format(message=msg),
+                            "error",
+                        )
                 else:
-                    flash(_('Account created, please log in now.'), "info")
-                return redirect(url_for('.show_root'))
+                    flash(_("Account created, please log in now."), "info")
+                return redirect(url_for(".show_root"))
 
-    return render_template(template,
-                           title_name=title_name,
-                           form=form,
-                           )
+    return render_template(template, title_name=title_name, form=form)
 
 
-@frontend.route('/+verifyemail', methods=['GET'])
+@frontend.route("/+verifyemail", methods=["GET"])
 def verifyemail():
     u = token = None
-    if 'username' in request.values and 'token' in request.values:
-        u = user.User(auth_username=request.values['username'])
-        token = request.values['token']
+    if "username" in request.values and "token" in request.values:
+        u = user.User(auth_username=request.values["username"])
+        token = request.values["token"]
     success = False
     if u and token and u.validate_recovery_token(token):
         unvalidated_email = u.profile[EMAIL_UNVALIDATED]
         if app.cfg.user_email_unique and user.search_users(**{EMAIL: unvalidated_email}):
-            msg = _('This email is already in use.')
+            msg = _("This email is already in use.")
         else:
             if u.disabled:
                 u.profile[DISABLED] = False
-                msg = _('Your account has been activated, you can log in now.')
+                msg = _("Your account has been activated, you can log in now.")
             else:
-                msg = _('Your new email address has been confirmed.')
+                msg = _("Your new email address has been confirmed.")
             u.profile[EMAIL] = unvalidated_email
             del u.profile[EMAIL_UNVALIDATED]
             del u.profile[RECOVERPASS_KEY]
             success = True
     else:
-        msg = _('Your username and/or token is invalid!')
+        msg = _("Your username and/or token is invalid!")
     if success:
         u.save()
-        flash(msg, 'info')
+        flash(msg, "info")
     else:
-        flash(msg, 'error')
-    return redirect(url_for('.show_root'))
+        flash(msg, "error")
+    return redirect(url_for(".show_root"))
 
 
 class ValidLostPassword(Validator):
-    """Validator for a valid lost password form
-    """
-    name_or_email_needed_msg = L_('Your user name or your email address is needed.')
+    """Validator for a valid lost password form"""
+
+    name_or_email_needed_msg = L_("Your user name or your email address is needed.")
 
     def validate(self, element, state):
-        if not (element['username'].valid and element['username'].value or
-                element['email'].valid and element['email'].value):
-            return self.note_error(element, state, 'name_or_email_needed_msg')
+        if not (
+            element["username"].valid and element["username"].value or element["email"].valid and element["email"].value
+        ):
+            return self.note_error(element, state, "name_or_email_needed_msg")
 
         return True
 
 
 class PasswordLostForm(Form):
     """a simple password lost form"""
-    name = 'lostpass'
 
-    username = OptionalText.using(label=L_('Name')).with_properties(placeholder=L_("Your login name"))
+    name = "lostpass"
+
+    username = OptionalText.using(label=L_("Name")).with_properties(placeholder=L_("Your login name"))
     email = YourEmail.using(optional=True)
-    submit_label = L_('Recover password')
+    submit_label = L_("Recover password")
 
     validators = [ValidLostPassword()]
 
 
-@frontend.route('/+lostpass', methods=['GET', 'POST'])
+@frontend.route("/+lostpass", methods=["GET", "POST"])
 def lostpass():
     # TODO use ?next=next_location check if target is in the wiki and not outside domain
-    title_name = _('Lost Password')
+    title_name = _("Lost Password")
 
     if not _using_moin_auth():
-        return Response('No MoinAuth in auth list', 403)
+        return Response("No MoinAuth in auth list", 403)
 
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = PasswordLostForm.from_defaults()
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = PasswordLostForm.from_flat(request.form)
         if form.validate():
             u = None
-            username = form['username'].value
+            username = form["username"].value
             if username:
                 u = user.User(auth_username=username)
-            email = form['email'].value
-            if form['email'].valid and email:
+            email = form["email"].value
+            if form["email"].valid and email:
                 users = user.search_users(email=email)
                 u = users and user.User(users[0].meta[ITEMID])
             if u and u.valid:
@@ -2012,83 +2080,82 @@ def lostpass():
                 if not is_ok:
                     flash(msg, "error")
             flash(_("If this account exists, you will be notified."), "info")
-            return redirect(url_for('.show_root'))
-    return render_template('lostpass.html',
-                           title_name=title_name,
-                           form=form,
-                           )
+            return redirect(url_for(".show_root"))
+    return render_template("lostpass.html", title_name=title_name, form=form)
 
 
 class ValidPasswordRecovery(Validator):
-    """Validator for a valid password recovery form
-    """
-    passwords_mismatch_msg = L_('The passwords do not match.')
-    password_problem_msg = L_('New password is unacceptable, could not get processed.')
+    """Validator for a valid password recovery form"""
+
+    passwords_mismatch_msg = L_("The passwords do not match.")
+    password_problem_msg = L_("New password is unacceptable, could not get processed.")
 
     def validate(self, element, state):
-        if element['password1'].value != element['password2'].value:
-            return self.note_error(element, state, 'passwords_mismatch_msg')
+        if element["password1"].value != element["password2"].value:
+            return self.note_error(element, state, "passwords_mismatch_msg")
 
-        password = element['password1'].value
+        password = element["password1"].value
         try:
             app.cfg.cache.pwd_context.hash(password)
         except (ValueError, TypeError):
-            return self.note_error(element, state, 'password_problem_msg')
+            return self.note_error(element, state, "password_problem_msg")
 
         return True
 
 
 class PasswordRecoveryForm(Form):
     """a simple password recovery form"""
-    name = 'recoverpass'
 
-    username = RequiredText.using(label=L_('Name')).with_properties(placeholder=L_("Your login name"))
-    token = RequiredText.using(label=L_('Recovery token')).with_properties(
-        placeholder=L_("The recovery token that has been sent to you"))
-    password1 = RequiredPassword.using(label=L_('New password')).with_properties(
-        placeholder=L_("The login password you want to use"))
-    password2 = RequiredPassword.using(label=L_('New password (repeat)')).with_properties(
-        placeholder=L_("Repeat the same password"))
-    submit_label = L_('Change password')
+    name = "recoverpass"
+
+    username = RequiredText.using(label=L_("Name")).with_properties(placeholder=L_("Your login name"))
+    token = RequiredText.using(label=L_("Recovery token")).with_properties(
+        placeholder=L_("The recovery token that has been sent to you")
+    )
+    password1 = RequiredPassword.using(label=L_("New password")).with_properties(
+        placeholder=L_("The login password you want to use")
+    )
+    password2 = RequiredPassword.using(label=L_("New password (repeat)")).with_properties(
+        placeholder=L_("Repeat the same password")
+    )
+    submit_label = L_("Change password")
 
     validators = [ValidPasswordRecovery()]
 
 
-@frontend.route('/+recoverpass', methods=['GET', 'POST'])
+@frontend.route("/+recoverpass", methods=["GET", "POST"])
 def recoverpass():
     # TODO use ?next=next_location check if target is in the wiki and not outside domain
-    title_name = _('Recover Password')
+    title_name = _("Recover Password")
 
     if not _using_moin_auth():
-        return Response('No MoinAuth in auth list', 403)
+        return Response("No MoinAuth in auth list", 403)
 
-    if request.method in ['GET', 'HEAD']:
+    if request.method in ["GET", "HEAD"]:
         form = PasswordRecoveryForm.from_defaults()
         form.update(request.values)
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = PasswordRecoveryForm.from_flat(request.form)
         if form.validate():
-            u = user.User(auth_username=form['username'].value)
-            if u and u.valid and u.apply_recovery_token(form['token'].value, form['password1'].value):
+            u = user.User(auth_username=form["username"].value)
+            if u and u.valid and u.apply_recovery_token(form["token"].value, form["password1"].value):
                 flash(_("Your password has been changed, you can log in now."), "info")
             else:
-                flash(_('Your token is invalid!'), "error")
-            return redirect(url_for('.show_root'))
-    return render_template('recoverpass.html',
-                           title_name=title_name,
-                           form=form,
-                           )
+                flash(_("Your token is invalid!"), "error")
+            return redirect(url_for(".show_root"))
+    return render_template("recoverpass.html", title_name=title_name, form=form)
 
 
 class ValidLogin(Validator):
     """
     Login validator
     """
-    moin_fail_msg = L_('Either your username or password was invalid.')
+
+    moin_fail_msg = L_("Either your username or password was invalid.")
 
     def validate(self, element, state):
         # get the result from the other validators
-        moin_valid = element['username'].valid and element['password'].valid
+        moin_valid = element["username"].valid and element["password"].valid
 
         # none of them was valid
         if not moin_valid:
@@ -2099,86 +2166,83 @@ def validate(self, element, state):
         # no valid user -> show appropriate message
         else:
             if not moin_valid:
-                return self.note_error(element, state, 'moin_fail_msg')
+                return self.note_error(element, state, "moin_fail_msg")
 
 
 class LoginForm(Form):
     """
     Login form
     """
-    name = 'login'
 
-    username = RequiredText.using(label=L_('Username'), optional=False).with_properties(autofocus=True)
+    name = "login"
+
+    username = RequiredText.using(label=L_("Username"), optional=False).with_properties(autofocus=True)
     password = RequiredPassword
-    nexturl = Hidden.using(default='')
+    nexturl = Hidden.using(default="")
     # This field results in a login_submit field in the POST form, which is in
     # turn looked for by setup_user() in app.py as marker for login requests.
-    submit = Hidden.using(default='1')
-    submit_label = L_('Log in')
+    submit = Hidden.using(default="1")
+    submit_label = L_("Log in")
 
     validators = [ValidLogin()]
 
 
-@frontend.route('/+login', methods=['GET', 'POST'])
+@frontend.route("/+login", methods=["GET", "POST"])
 def login():
-    title_name = _('Login')
-    if request.method in ['GET', 'HEAD']:
+    title_name = _("Login")
+    if request.method in ["GET", "HEAD"]:
         form = LoginForm.from_defaults()
-        next_url = request.referrer or url_for('.show_root')
-        if not next_url.startswith(request.host_url) or '/+' in next_url:
-            next_url = url_for('.show_root')
-        form['nexturl'].set(next_url)
+        next_url = request.referrer or url_for(".show_root")
+        if not next_url.startswith(request.host_url) or "/+" in next_url:
+            next_url = url_for(".show_root")
+        form["nexturl"].set(next_url)
         for authmethod in app.cfg.auth:
             hint = authmethod.login_hint()
             if hint:
                 flash(hint, "info")
-    elif request.method == 'POST':
+    elif request.method == "POST":
         form = LoginForm.from_flat(request.form)
         if form.validate():
             flash(_("You are logged in."), "info")
-            nexturl = form['nexturl']
+            nexturl = form["nexturl"]
             return redirect(str(nexturl))
         # this is executed when login fails due to bad ID or pw - app.py > def setup_user does successful logins
         for msg in flaskg._login_messages:
             # flash the error messages for failed login
             flash(msg, "error")
-    return render_template('login.html',
-                           title_name=title_name,
-                           login_inputs=app.cfg.auth_login_inputs,
-                           form=form,
-                           )
+    return render_template("login.html", title_name=title_name, login_inputs=app.cfg.auth_login_inputs, form=form)
 
 
-@frontend.route('/+logout')
+@frontend.route("/+logout")
 def logout():
     flash(_("You are logged out."), "info")
     flaskg.user.logout_session()
-    next_url = request.referrer or url_for('.show_root')
-    if not next_url.startswith(request.host_url) or '/+' in next_url:
-        next_url = url_for('.show_root')
+    next_url = request.referrer or url_for(".show_root")
+    if not next_url.startswith(request.host_url) or "/+" in next_url:
+        next_url = url_for(".show_root")
     return redirect(next_url)
 
 
 class ValidChangePass(Validator):
-    """Validator for a valid password change
-    """
-    passwords_mismatch_msg = L_('The passwords do not match.')
-    current_password_wrong_msg = L_('The current password was wrong.')
-    password_problem_msg = L_('New password is unacceptable, could not get processed.')
+    """Validator for a valid password change"""
+
+    passwords_mismatch_msg = L_("The passwords do not match.")
+    current_password_wrong_msg = L_("The current password was wrong.")
+    password_problem_msg = L_("New password is unacceptable, could not get processed.")
 
     def validate(self, element, state):
-        password_not_accepted_msg = L_('New password not acceptable: ')
+        password_not_accepted_msg = L_("New password not acceptable: ")
 
-        if not (element['password_current'].valid and element['password1'].valid and element['password2'].valid):
+        if not (element["password_current"].valid and element["password1"].valid and element["password2"].valid):
             return False
 
-        if not user.User(name=flaskg.user.name, password=element['password_current'].value).valid:
-            return self.note_error(element, state, 'current_password_wrong_msg')
+        if not user.User(name=flaskg.user.name, password=element["password_current"].value).valid:
+            return self.note_error(element, state, "current_password_wrong_msg")
 
-        if element['password1'].value != element['password2'].value:
-            return self.note_error(element, state, 'passwords_mismatch_msg')
+        if element["password1"].value != element["password2"].value:
+            return self.note_error(element, state, "passwords_mismatch_msg")
 
-        password = element['password1'].value
+        password = element["password1"].value
         pw_checker = app.cfg.password_checker
         if pw_checker:
             pw_error = pw_checker(flaskg.user.name[0], password)
@@ -2187,27 +2251,30 @@ def validate(self, element, state):
         try:
             app.cfg.cache.pwd_context.hash(password)
         except (ValueError, TypeError):
-            return self.note_error(element, state, 'password_problem_msg')
+            return self.note_error(element, state, "password_problem_msg")
         return True
 
 
 class UserSettingsPasswordForm(Form):
-    form_name = 'usersettings_password'
+    form_name = "usersettings_password"
     validators = [ValidChangePass()]
 
-    password_current = RequiredPassword.using(label=L_('Current Password')).with_properties(
-        placeholder=L_("Your current login password"))
-    password1 = RequiredPassword.using(label=L_('New password')).with_properties(
-        placeholder=L_("The login password you want to use"))
-    password2 = RequiredPassword.using(label=L_('New password (repeat)')).with_properties(
-        placeholder=L_("Repeat the same password"))
-    submit_label = L_('Change password')
+    password_current = RequiredPassword.using(label=L_("Current Password")).with_properties(
+        placeholder=L_("Your current login password")
+    )
+    password1 = RequiredPassword.using(label=L_("New password")).with_properties(
+        placeholder=L_("The login password you want to use")
+    )
+    password2 = RequiredPassword.using(label=L_("New password (repeat)")).with_properties(
+        placeholder=L_("Repeat the same password")
+    )
+    submit_label = L_("Change password")
 
 
 class UserSettingsNotificationForm(Form):
-    form_name = 'usersettings_notification'
+    form_name = "usersettings_notification"
     email = YourEmail
-    submit_label = L_('Save')
+    submit_label = L_("Save")
 
 
 class UserSettingsQuicklinksForm(Form):
@@ -2216,33 +2283,32 @@ class UserSettingsQuicklinksForm(Form):
     external links, mailto, external wiki links ...
     """
 
-    form_name = 'usersettings_quicklinks'
+    form_name = "usersettings_quicklinks"
     quicklinks = Quicklinks
-    submit_label = L_('Save')
+    submit_label = L_("Save")
 
 
 class UserSettingsOptionsForm(Form):
-    form_name = 'usersettings_options'
-    iso_8601 = Checkbox.using(label=L_('Always use ISO 8601 date-time format'))
-    mailto_author = Checkbox.using(label=L_('Publish my email (not my wiki homepage) in author info'))
-    edit_on_doubleclick = Checkbox.using(label=L_('Open editor on double click'))
-    scroll_page_after_edit = Checkbox.using(label=L_('Scroll page after edit'))
-    show_comments = Checkbox.using(label=L_('Show comment sections'))
-    disabled = Checkbox.using(label=L_('Disable this account forever'))
-    submit_label = L_('Save')
+    form_name = "usersettings_options"
+    iso_8601 = Checkbox.using(label=L_("Always use ISO 8601 date-time format"))
+    mailto_author = Checkbox.using(label=L_("Publish my email (not my wiki homepage) in author info"))
+    edit_on_doubleclick = Checkbox.using(label=L_("Open editor on double click"))
+    scroll_page_after_edit = Checkbox.using(label=L_("Scroll page after edit"))
+    show_comments = Checkbox.using(label=L_("Show comment sections"))
+    disabled = Checkbox.using(label=L_("Disable this account forever"))
+    submit_label = L_("Save")
 
 
 class ValidSubscriptions(Validator):
-    """Validator for a subscriptions change
-    """
+    """Validator for a subscriptions change"""
 
     def validate(self, element, state):
         # TODO: is additional validation for namespaces, itemids, names, or name prefixes needed?
-        invalid_subscription_msg = L_('Invalid subscription syntax: ')
-        invalid_keyword = L_('Invalid keyword: ')
-        invalid_re_expression = L_('Invalid RE syntax: ')
+        invalid_subscription_msg = L_("Invalid subscription syntax: ")
+        invalid_keyword = L_("Invalid keyword: ")
+        invalid_re_expression = L_("Invalid RE syntax: ")
         errors = []
-        for subscription in element.value['subscriptions']:
+        for subscription in element.value["subscriptions"]:
             try:
                 keyword, value = subscription.split(":", 1)
             except ValueError:
@@ -2265,53 +2331,59 @@ def validate(self, element, state):
                     errors.append(invalid_re_expression + subscription)
                     continue
         if errors:
-            return self.note_error(element, state, message=', '.join(errors))
+            return self.note_error(element, state, message=", ".join(errors))
         return True
 
 
 class UserSettingsSubscriptionsForm(Form):
-    form_name = 'usersettings_subscriptions'
+    form_name = "usersettings_subscriptions"
     subscriptions = Subscriptions
-    submit_label = L_('Save')
+    submit_label = L_("Save")
 
     validators = [ValidSubscriptions()]
 
 
-@frontend.route('/+usersettings', methods=['GET', 'POST'])
+@frontend.route("/+usersettings", methods=["GET", "POST"])
 def usersettings():
     # TODO use ?next=next_location check if target is in the wiki and not outside domain
-    title_name = _('User Settings')
+    title_name = _("User Settings")
 
     # werkzeug 1.0.0 dropped support for request.is_xhr,
     # was True if the request was triggered via a JavaScript XMLHttpRequest
     # TODO: maybe "is_xhr = request.method == 'POST'" would work
-    is_xhr = request.accept_mimetypes.best in ("application/json", "text/javascript", )
+    is_xhr = request.accept_mimetypes.best in ("application/json", "text/javascript")
 
     # these forms can't be global because we need app object, which is only available within a request:
     class UserSettingsPersonalForm(Form):
-        form_name = 'usersettings_personal'
-        name = Names.using(label=L_('Usernames')).with_properties(placeholder=L_("The login usernames you want to use"))
-        display_name = OptionalText.using(label=L_('Display-Name')).with_properties(
-            placeholder=L_("Your display name (informational)"))
+        form_name = "usersettings_personal"
+        name = Names.using(label=L_("Usernames")).with_properties(placeholder=L_("The login usernames you want to use"))
+        display_name = OptionalText.using(label=L_("Display-Name")).with_properties(
+            placeholder=L_("Your display name (informational)")
+        )
         # _timezones_keys = sorted(Locale('en').time_zones.keys())
         _timezones_keys = [str(tz) for tz in pytz.common_timezones]
-        timezone = Select.using(label=L_('Timezone')).out_of((e, e) for e in _timezones_keys)
-        _supported_locales = [Locale('en')] + app.extensions['babel'].instance.list_translations()
-        locale = Select.using(label=L_('Locale')).out_of(
-            ((str(locale), locale.display_name) for locale in _supported_locales), sort_by=1)
-        submit_label = L_('Save')
+        timezone = Select.using(label=L_("Timezone")).out_of((e, e) for e in _timezones_keys)
+        _supported_locales = [Locale("en")] + app.extensions["babel"].instance.list_translations()
+        locale = Select.using(label=L_("Locale")).out_of(
+            ((str(locale), locale.display_name) for locale in _supported_locales), sort_by=1
+        )
+        submit_label = L_("Save")
 
     class UserSettingsUIForm(Form):
-        form_name = 'usersettings_ui'
-        theme_name = RadioChoice.using(label=L_('Theme name')).with_properties(
-            choices=((str(t.identifier), t.name) for t in get_themes_list()))
-        css_url = URL.using(label=L_('User CSS URL'), optional=True).with_properties(
-            placeholder=L_("Give the URL of your custom CSS (optional)"))
-        edit_rows = Natural.using(label=L_('Number rows in edit textarea')).with_properties(
-            placeholder=L_("Editor textarea height (0=auto)"))
-        results_per_page = Natural.using(label=L_('History results per page')).with_properties(
-            placeholder=L_("Number of results per page (0=no paging)"))
-        submit_label = L_('Save')
+        form_name = "usersettings_ui"
+        theme_name = RadioChoice.using(label=L_("Theme name")).with_properties(
+            choices=((str(t.identifier), t.name) for t in get_themes_list())
+        )
+        css_url = URL.using(label=L_("User CSS URL"), optional=True).with_properties(
+            placeholder=L_("Give the URL of your custom CSS (optional)")
+        )
+        edit_rows = Natural.using(label=L_("Number rows in edit textarea")).with_properties(
+            placeholder=L_("Editor textarea height (0=auto)")
+        )
+        results_per_page = Natural.using(label=L_("History results per page")).with_properties(
+            placeholder=L_("Number of results per page (0=no paging)")
+        )
+        submit_label = L_("Save")
 
     form_classes = dict(
         personal=UserSettingsPersonalForm,
@@ -2325,10 +2397,10 @@ class UserSettingsUIForm(Form):
     forms = dict()
 
     if not flaskg.user.valid:
-        return redirect(url_for('.login'))
+        return redirect(url_for(".login"))
 
-    if request.method == 'POST':
-        part = request.form.get('part')
+    if request.method == "POST":
+        part = request.form.get("part")
         if part not in form_classes:
             # the current part does not exist
             if is_xhr:
@@ -2342,89 +2414,100 @@ class UserSettingsUIForm(Form):
             form = form_classes[part].from_flat(request.form)
 
             # save response to a dict as we can't use HTTP redirects or flash() for XHR requests
-            response = dict(
-                form=None,
-                flash=[],
-                redirect=None,
-            )
+            response = dict(form=None, flash=[], redirect=None)
 
             if form.validate():
                 # successfully modified everything
                 success = True
-                if part == 'password':
-                    flaskg.user.set_password(form['password1'].value)
+                if part == "password":
+                    flaskg.user.set_password(form["password1"].value)
                     flaskg.user.save()
-                    response['flash'].append((_("Your password has been changed."), "info"))
+                    response["flash"].append((_("Your password has been changed."), "info"))
                 else:
-                    if part == 'personal':
-                        if set(form['name'].value) != set(flaskg.user.name):
-                            new_names = set(form['name'].value) - set(flaskg.user.name)
+                    if part == "personal":
+                        if set(form["name"].value) != set(flaskg.user.name):
+                            new_names = set(form["name"].value) - set(flaskg.user.name)
                             for name in new_names:
                                 if user.search_users(**{NAME_EXACT: name}):
                                     # duplicate name
-                                    response['flash'].append(
+                                    response["flash"].append(
                                         (_("The username '{name}' is already in use.").format(name=name), "error")
                                     )
                                     success = False
-                    if part == 'notification':
-                        if (form['email'].value != flaskg.user.email and
-                                user.search_users(**{EMAIL: form['email'].value}) and app.cfg.user_email_unique):
+                    if part == "notification":
+                        if (
+                            form["email"].value != flaskg.user.email
+                            and user.search_users(**{EMAIL: form["email"].value})
+                            and app.cfg.user_email_unique
+                        ):
                             # duplicate email
-                            response['flash'].append((_('This email is already in use'), 'error'))
+                            response["flash"].append((_("This email is already in use"), "error"))
                             success = False
                     if success:
                         user_old_email = flaskg.user.email
                         d = dict(form.value)
                         for k, v in d.items():
                             flaskg.user.profile[k] = v
-                        if (part == 'notification' and app.cfg.user_email_verification and
-                                form['email'].value != user_old_email):
+                        if (
+                            part == "notification"
+                            and app.cfg.user_email_verification
+                            and form["email"].value != user_old_email
+                        ):
                             flaskg.user.profile[EMAIL] = user_old_email
-                            flaskg.user.profile[EMAIL_UNVALIDATED] = form['email'].value
+                            flaskg.user.profile[EMAIL_UNVALIDATED] = form["email"].value
                             # send verification mail
                             is_ok, msg = flaskg.user.mail_email_verification()
                             if is_ok:
-                                response['flash'].append(
-                                    (_('A confirmation email has been sent to your '
-                                       'newly configured email address.'), "info"))
-                                response['redirect'] = url_for('.show_root')
+                                response["flash"].append(
+                                    (
+                                        _(
+                                            "A confirmation email has been sent to your "
+                                            "newly configured email address."
+                                        ),
+                                        "info",
+                                    )
+                                )
+                                response["redirect"] = url_for(".show_root")
                             else:
                                 # sending the verification email didn't work.
                                 # delete the unvalidated email and alert the user.
                                 del flaskg.user.profile[EMAIL_UNVALIDATED]
-                                response['flash'].append((_('Your email address was not changed because sending the '
-                                                            'verification email failed. Please try again later.'),
-                                                          "error"))
+                                response["flash"].append(
+                                    (
+                                        _(
+                                            "Your email address was not changed because sending the "
+                                            "verification email failed. Please try again later."
+                                        ),
+                                        "error",
+                                    )
+                                )
                         else:
                             try:
                                 flaskg.user.save()
                             except ValueError as err:
-                                response['flash'].append((str(err), 'error'))
+                                response["flash"].append((str(err), "error"))
 
             else:
                 # validation failed
-                response['flash'].append((_("Nothing saved."), "error"))
-            if not response['flash']:
+                response["flash"].append((_("Nothing saved."), "error"))
+            if not response["flash"]:
                 # if no flash message was added until here, we add a generic success message
-                response['flash'].append((_("Your changes have been saved."), "info"))
+                response["flash"].append((_("Your changes have been saved."), "info"))
 
-            if response['redirect'] is not None or not is_xhr:
+            if response["redirect"] is not None or not is_xhr:
                 # if we redirect or it is no XHR request, we just flash() the messages normally
-                for f in response['flash']:
+                for f in response["flash"]:
                     flash(*f)
 
             if is_xhr:
                 # if it is a XHR request, render the part from the usersettings_ajax.html template
                 # and send the response encoded as an JSON object
-                response['form'] = render_template('usersettings_ajax.html',
-                                                   part=part,
-                                                   form=form,
-                                                   )
+                response["form"] = render_template("usersettings_ajax.html", part=part, form=form)
                 return jsonify(**response)
             else:
                 # if it is not a XHR request but there is an redirect pending, we use a normal HTTP redirect
-                if response['redirect'] is not None:
-                    return redirect(response['redirect'])
+                if response["redirect"] is not None:
+                    return redirect(response["redirect"])
 
             # if the view did not return until here, we add the current form to the forms dict
             # and continue with rendering the normal template
@@ -2435,19 +2518,16 @@ class UserSettingsUIForm(Form):
         if p not in forms:
             forms[p] = FormClass.from_object(flaskg.user)
 
-    return render_template('usersettings.html',
-                           title_name=title_name,
-                           form_objs=forms,
-                           )
+    return render_template("usersettings.html", title_name=title_name, form_objs=forms)
 
 
-@frontend.route('/+bookmark')
+@frontend.route("/+bookmark")
 def bookmark():
-    """ set bookmark (in time) for recent changes (or delete them) """
+    """set bookmark (in time) for recent changes (or delete them)"""
     if flaskg.user.valid:
-        timestamp = request.values.get('time')
+        timestamp = request.values.get("time")
         if timestamp is not None:
-            if timestamp == 'del':
+            if timestamp == "del":
                 tm = None
             else:
                 try:
@@ -2459,15 +2539,15 @@ def bookmark():
         flaskg.user.bookmark = tm
     else:
         flash(_("You must log in to use bookmarks."), "error")
-    return redirect(url_for('.global_history'))
+    return redirect(url_for(".global_history"))
 
 
 def get_revs():
     """
     get 2 revids from values
     """
-    rev1 = request.values.get('rev1')
-    rev2 = request.values.get('rev2')
+    rev1 = request.values.get("rev1")
+    rev2 = request.values.get("rev2")
     if rev1 is None:
         # we require at least rev1
         abort(404)
@@ -2477,7 +2557,7 @@ def get_revs():
     return rev1, rev2
 
 
-@frontend.route('/+diffraw/<itemname:item_name>')
+@frontend.route("/+diffraw/<itemname:item_name>")
 def diffraw(item_name):
     # TODO get_item and get_revision calls may raise an AccessDenied.
     #      If this happens for get_item, don't show the diff at all
@@ -2491,7 +2571,7 @@ def diffraw(item_name):
     return _diff_raw(item, rev1, rev2)
 
 
-@frontend.route('/+diff/<itemname:item_name>')
+@frontend.route("/+diff/<itemname:item_name>")
 def diff(item_name):
     """
     Return an html fragment displaying an item diff and a rendered item revision.
@@ -2518,10 +2598,10 @@ def diff(item_name):
     if isinstance(item, NonExistent):
         abort(404, item_name)
 
-    offset = request.values.get('offset', 0)
+    offset = request.values.get("offset", 0)
     offset = max(int(offset), 0)
-    bookmark_time = int(request.values.get('bookmark', 0))
-    terms = [Term(WIKINAME, app.cfg.interwikiname), ]
+    bookmark_time = int(request.values.get("bookmark", 0))
+    terms = [Term(WIKINAME, app.cfg.interwikiname)]
     terms.extend(Term(term, value) for term, value in fqname.query.items())
     query = And(terms)
     metas = flaskg.storage.search_meta(query, idx_name=ALL_REVS, sortedby=[MTIME], reverse=True, limit=None)
@@ -2545,14 +2625,14 @@ def diff(item_name):
         rev2 = revs[0][1]  # and compare it with the current revision
     else:
         # otherwise we try get the 2 revids directly
-        rev1 = request.values.get('rev1')
-        rev2 = request.values.get('rev2')
+        rev1 = request.values.get("rev1")
+        rev2 = request.values.get("rev2")
         if rev1 not in rev_ids:
             if len(metas) > 1:
                 rev1 = metas[1][1]  # take second newest rev
             else:
                 rev1 = metas[0][1]  # we will compare rev to itself
-                flash(_('There is only one revision eligible for diff.'), "info")
+                flash(_("There is only one revision eligible for diff."), "info")
         if rev2 not in rev_ids:
             rev2 = metas[0][1]  # the newest rev we have
     return _diff(item, rev1, rev2, fqname, rev_ids)
@@ -2563,14 +2643,14 @@ def _common_type(ct1, ct2):
         # easy, exactly the same content type, call do_diff for it
         commonmt = ct1
     else:
-        major1 = ct1.split('/')[0]
-        major2 = ct2.split('/')[0]
+        major1 = ct1.split("/")[0]
+        major2 = ct2.split("/")[0]
         if major1 == major2:
             # at least same major mimetype, use common base item class
-            commonmt = major1 + '/'
+            commonmt = major1 + "/"
         else:
             # nothing in common
-            commonmt = ''
+            commonmt = ""
     return commonmt
 
 
@@ -2578,15 +2658,16 @@ def _crash(item, oldrev, newrev):
     """This is called from several places, need to handle passed message"""
     error_id = uuid.uuid4()
     logging.exception(f"An exception happened in _render_data (error_id = {error_id} ):")
-    return render_template("crash_view.html",
-                           server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"),
-                           url=request.url,
-                           error_id=error_id,
-                           oldrev=oldrev,
-                           newrev=newrev,
-                           fqname=item.fqname,
-                           item=item,
-                           )
+    return render_template(
+        "crash_view.html",
+        server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"),
+        url=request.url,
+        error_id=error_id,
+        oldrev=oldrev,
+        newrev=newrev,
+        fqname=item.fqname,
+        item=item,
+    )
 
 
 def _diff(item, revid1, revid2, fqname, rev_ids):
@@ -2599,7 +2680,7 @@ def _diff(item, revid1, revid2, fqname, rev_ids):
         newrev = item[revid2]
     except KeyError:
         abort(404)
-    if oldrev.meta['mtime'] > newrev.meta['mtime']:
+    if oldrev.meta["mtime"] > newrev.meta["mtime"]:
         # within diff, always place oldest on left, newest on right
         oldrev, newrev = newrev, oldrev
         revid1, revid2 = revid2, revid1
@@ -2616,36 +2697,32 @@ def _diff(item, revid1, revid2, fqname, rev_ids):
         rev1_idx = rev_ids.index(revid1)
         rev2_idx = rev_ids.index(revid2)
         if rev1_idx > 0:
-            rev_links['r1_oldest'] = rev_ids[0]
-            rev_links['r1_older'] = rev_ids[rev1_idx - 1]
+            rev_links["r1_oldest"] = rev_ids[0]
+            rev_links["r1_older"] = rev_ids[rev1_idx - 1]
         if rev2_idx > rev1_idx + 1:
-            rev_links['r1_newer'] = rev_ids[rev1_idx + 1]
+            rev_links["r1_newer"] = rev_ids[rev1_idx + 1]
         end = len(rev_ids) - 1
         if rev2_idx < end:
-            rev_links['r2_newer'] = rev_ids[rev2_idx + 1]
-            rev_links['r2_newest'] = rev_ids[-1]
+            rev_links["r2_newer"] = rev_ids[rev2_idx + 1]
+            rev_links["r2_newest"] = rev_ids[-1]
         if rev2_idx > rev1_idx + 1:
-            rev_links['r2_older'] = rev_ids[rev2_idx - 1]
+            rev_links["r2_older"] = rev_ids[rev2_idx - 1]
     if rev_links:
-        rev_links['revid1'] = revid1
-        rev_links['revid2'] = revid2
+        rev_links["revid1"] = revid1
+        rev_links["revid2"] = revid2
 
     try:
         diff_html = Markup(item.content._render_data_diff(oldrev, newrev, rev_links=rev_links, fqname=fqname))
     except Exception:
         return _crash(item, oldrev, newrev)
 
-    return render_template('diff.html',
-                           item_name=item.name,
-                           fqname=item.fqname,
-                           diff_html=diff_html,
-                           )
+    return render_template("diff.html", item_name=item.name, fqname=item.fqname, diff_html=diff_html)
 
 
 def _diff_raw(item, revid1, revid2):
     oldrev = item[revid1]
     newrev = item[revid2]
-    if oldrev.meta['mtime'] > newrev.meta['mtime']:
+    if oldrev.meta["mtime"] > newrev.meta["mtime"]:
         oldrev, newrev = newrev, oldrev
         revid1, revid2 = revid2, revid1
     commonmt = _common_type(oldrev.meta[CONTENTTYPE], newrev.meta[CONTENTTYPE])
@@ -2657,7 +2734,7 @@ def _diff_raw(item, revid1, revid2):
     return item.content._render_data_diff_raw(oldrev, newrev)
 
 
-@frontend.route('/+similar_names/<itemname:item_name>')
+@frontend.route("/+similar_names/<itemname:item_name>")
 def similar_names(item_name):
     """
     list similar item names
@@ -2676,21 +2753,22 @@ def similar_names(item_name):
     # 1 "{0}...".format(start)
     # 2 "...{1}".format(end)
     fq_names = []
-    for wanted_rank in [8, 4, 3, 1, 2, ]:
+    for wanted_rank in [8, 4, 3, 1, 2]:
         for fqname in keys:
             rank = matches[fqname]
             if rank == wanted_rank:
                 fq_names.append(fqname)
-    return render_template("link_list_item_panel.html",
-                           headline=_("Items with similar names to '{item_name}'"
-                                      ).format(item_name=shorten_item_id(item_name)),
-                           item=item,
-                           item_name=item_name,  # XXX no item
-                           fqname=split_fqname(item_name),
-                           fq_names=fq_names)
+    return render_template(
+        "link_list_item_panel.html",
+        headline=_("Items with similar names to '{item_name}'").format(item_name=shorten_item_id(item_name)),
+        item=item,
+        item_name=item_name,  # XXX no item
+        fqname=split_fqname(item_name),
+        fq_names=fq_names,
+    )
 
 
-@frontend.route('/+sitemap/<itemname:item_name>')
+@frontend.route("/+sitemap/<itemname:item_name>")
 def sitemap(item_name):
     """
     sitemap view shows item link structure relative to item_name.
@@ -2712,15 +2790,16 @@ def sitemap(item_name):
     del backrefs[0]  # don't show current item name as sole toplevel list item
     sitemap, no_read_auth, missing = NestedItemListBuilder().recurse_build([fq_name])
     del sitemap[0]  # don't show current item name as sole toplevel list item
-    return render_template('sitemap.html',
-                           item=item,
-                           item_name=item_name,
-                           backrefs=backrefs,
-                           sitemap=sitemap,
-                           fqname=fq_name,
-                           no_read_auth=no_read_auth,
-                           missing=missing,
-                           )
+    return render_template(
+        "sitemap.html",
+        item=item,
+        item_name=item_name,
+        backrefs=backrefs,
+        sitemap=sitemap,
+        fqname=fq_name,
+        no_read_auth=no_read_auth,
+        missing=missing,
+    )
 
 
 class NestedItemListBuilder:
@@ -2768,8 +2847,8 @@ def childs(self, fq_name, backrefs=False):
         return sorted([child for child in itemlinks if child not in self.children])
 
 
-@frontend.route('/+tags', defaults=dict(namespace=NAMESPACE_DEFAULT), methods=['GET'])
-@frontend.route('/<namespace>/+tags')
+@frontend.route("/+tags", defaults=dict(namespace=NAMESPACE_DEFAULT), methods=["GET"])
+@frontend.route("/<namespace>/+tags")
 def global_tags(namespace):
     """
     Show a list or tag cloud of tags in this wiki.
@@ -2778,10 +2857,10 @@ def global_tags(namespace):
     If namespace == '' tags from the default namespace are shown.
     If namespace == '<namespace>' tags from that namespace are shown.
     """
-    title_name = _('Global Tags')
+    title_name = _("Global Tags")
     if namespace == NAMESPACE_ALL:
         query = And([Term(WIKINAME, app.cfg.interwikiname), Term(HAS_TAG, True)])
-        fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, '')
+        fqname = CompositeName(NAMESPACE_ALL, NAME_EXACT, "")
     else:
         query = And([Term(WIKINAME, app.cfg.interwikiname), Term(NAMESPACE, namespace), Term(HAS_TAG, True)])
         fqname = split_fqname(namespace)
@@ -2814,18 +2893,15 @@ def cls(count):
             # return the css class for this tag
             weight = scale * (count - count_min)
             return f"weight{int(weight)}"  # weight0, ..., weight9
+
         tags = [(cls(count), tag) for tag, count in tags_counts]
     else:
         tags = []
-    return render_template("global_tags.html",
-                           headline=headline,
-                           title_name=title_name,
-                           fqname=fqname,
-                           tags=tags)
+    return render_template("global_tags.html", headline=headline, title_name=title_name, fqname=fqname, tags=tags)
 
 
-@frontend.route('/+tags/<itemname:tag>', defaults=dict(namespace=NAMESPACE_DEFAULT), methods=['GET'])
-@frontend.route('/<namespace>/+tags/<itemname:tag>')
+@frontend.route("/+tags/<itemname:tag>", defaults=dict(namespace=NAMESPACE_DEFAULT), methods=["GET"])
+@frontend.route("/<namespace>/+tags/<itemname:tag>")
 def tagged_items(tag, namespace):
     """
     show all items' names that have tag <tag> and belong to namespace <namespace>
@@ -2837,13 +2913,15 @@ def tagged_items(tag, namespace):
     metas = flaskg.storage.search_meta(query, limit=None)
     fq_names = [gen_fqnames(meta) for meta in metas]
     fq_names = [fqn for sublist in fq_names for fqn in sublist]
-    return render_template("link_list_no_item_panel.html",
-                           headline=_("Items tagged with {tag}").format(tag=tag),
-                           item_name=tag,
-                           fq_names=fq_names)
+    return render_template(
+        "link_list_no_item_panel.html",
+        headline=_("Items tagged with {tag}").format(tag=tag),
+        item_name=tag,
+        fq_names=fq_names,
+    )
 
 
-@frontend.route('/+template/<path:filename>')
+@frontend.route("/+template/<path:filename>")
 def template(filename):
     """
     Serve a rendered template from <filename>
@@ -2852,8 +2930,8 @@ def template(filename):
     """
     content = render_template(filename)
     ct, enc = mimetypes.guess_type(filename)
-    response = make_response((content, 200, {'content-type': ct or 'text/plain;charset=utf-8'}))
-    if ct in ['application/javascript', 'text/css', 'text/html']:
+    response = make_response((content, 200, {"content-type": ct or "text/plain;charset=utf-8"}))
+    if ct in ["application/javascript", "text/css", "text/html"]:
         # this is assuming that:
         # * js / css / html templates rarely change (maybe just on sw updates)
         # * we are using templates for these to translate them, translations rarely change
@@ -2873,17 +2951,17 @@ def template(filename):
     return response
 
 
-@frontend.route('/+tickets', methods=['GET', 'POST'])
+@frontend.route("/+tickets", methods=["GET", "POST"])
 def tickets():
     """
     Show a list of ticket items
     """
-    if request.method == 'POST':
-        query = request.form['q']
-        status = request.form['status']
+    if request.method == "POST":
+        query = request.form["q"]
+        status = request.form["status"]
     else:
         query = None
-        status = 'open'
+        status = "open"
 
     current_timestamp = datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
     idx_name = ALL_REVS
@@ -2893,12 +2971,12 @@ def tickets():
     if query:
         term2.append(qp.parse(query))
 
-    if status == 'open':
+    if status == "open":
         term1.append(Term(CLOSED, False))
-    elif status == 'closed':
+    elif status == "closed":
         term1.append(Term(CLOSED, True))
 
-    selected_tags = set(request.args.getlist('selected_tags'))
+    selected_tags = set(request.args.getlist("selected_tags"))
     term1.extend(Term(TAGS, tag) for tag in selected_tags)
     assigned_username = request.args.get(ASSIGNED_TO) or query
     user = [Term(NAME, assigned_username)]
@@ -2933,17 +3011,18 @@ def tickets():
         q = And(term1)
         results = searcher.search(q, limit=None)
         tags = get_itemtype_specific_tags(ITEMTYPE_TICKET)
-        return render_template('tickets.html',
-                               results=results,
-                               query=query,
-                               status=status,
-                               tags=tags,
-                               selected_tags=selected_tags,
-                               current_timestamp=current_timestamp,
-                               )
+        return render_template(
+            "tickets.html",
+            results=results,
+            query=query,
+            status=status,
+            tags=tags,
+            selected_tags=selected_tags,
+            current_timestamp=current_timestamp,
+        )
 
 
-@frontend.route('/+tickets/query', methods=['GET', 'POST'])
+@frontend.route("/+tickets/query", methods=["GET", "POST"])
 def ticket_search():
     """
     Suggest duplicate tickets while a new ticket is being created. Executed multiple times as user types/clicks.
@@ -2957,14 +3036,14 @@ def ticket_search():
     results = []
 
     with flaskg.storage.indexer.ix[LATEST_REVS].searcher() as searcher:
-        if request.method == 'POST':
-            effort = request.form.get('effort')
-            difficulty = request.form.get('difficulty')
-            severity = request.form.get('severity')
-            priority = request.form.get('priority')
-            tags = request.form.get('tags')
-            assigned_to = request.form.get('assigned_to')
-            author = request.form.get('author')
+        if request.method == "POST":
+            effort = request.form.get("effort")
+            difficulty = request.form.get("difficulty")
+            severity = request.form.get("severity")
+            priority = request.form.get("priority")
+            tags = request.form.get("tags")
+            assigned_to = request.form.get("assigned_to")
+            author = request.form.get("author")
             term = [Term(ITEMTYPE, ITEMTYPE_TICKET)]
             if effort:
                 term.append(Term(EFFORT, effort))
@@ -2984,40 +3063,46 @@ def ticket_search():
             query = And(term)
             results = searcher.search(query, sortedby=NAME_EXACT, limit=None)
 
-        return render_template('ticket/advanced.html',
-                               search_form=form,
-                               ticket_results=results,
-                               suggested_tags=suggested_tags,
-                               timestamp=datetime.fromtimestamp,
-                               is_ticket=True,
-                               )
+        return render_template(
+            "ticket/advanced.html",
+            search_form=form,
+            ticket_results=results,
+            suggested_tags=suggested_tags,
+            timestamp=datetime.fromtimestamp,
+            is_ticket=True,
+        )
 
 
-@frontend.route('/+comment', defaults=dict(item_name=''), methods=['POST'])
+@frontend.route("/+comment", defaults=dict(item_name=""), methods=["POST"])
 def comment(item_name):
     """
     Initiated by tickets.js when user clicks Save button adding a reply to a prior comment.
 
     An html fragment formatting a new comment is produced. It is inserted into the page via javascript.
     """
-    itemid = request.form.get('refers_to')
-    reply_to = request.form.get('reply_to')
-    data = request.form.get('data')
+    itemid = request.form.get("refers_to")
+    reply_to = request.form.get("reply_to")
+    data = request.form.get("data")
     if data:
         current_timestamp = datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
-        item_name = str(itemid) + '/' + 'comment_' + str(current_timestamp)
+        item_name = str(itemid) + "/" + "comment_" + str(current_timestamp)
         item = Item.create(item_name)
-        item.modify({}, data=data, element='comment', contenttype_guessed='text/x.moin.wiki;charset=utf-8',
-                    refers_to=itemid, reply_to=reply_to, author=flaskg.user.name[0])
+        item.modify(
+            {},
+            data=data,
+            element="comment",
+            contenttype_guessed="text/x.moin.wiki;charset=utf-8",
+            refers_to=itemid,
+            reply_to=reply_to,
+            author=flaskg.user.name[0],
+        )
         item = Item.create(item.name, rev_id=CURRENT)
-        return render_template('ticket/comment.html',
-                               comment=item,
-                               render_comment_data=render_comment_data,
-                               datetime=datetime,
-                               )
+        return render_template(
+            "ticket/comment.html", comment=item, render_comment_data=render_comment_data, datetime=datetime
+        )
 
 
-@frontend.route('/+new', methods=['GET', 'POST'])
+@frontend.route("/+new", methods=["GET", "POST"])
 def new():
     # TODO: Implement creation of blog entries and ticket items
     raise NotImplementedError
@@ -3025,6 +3110,4 @@ def new():
 
 @frontend.errorhandler(404)
 def page_not_found(e):
-    return render_template('404.html',
-                           path=request.path,
-                           item_name=e.description), 404
+    return render_template("404.html", path=request.path, item_name=e.description), 404
diff --git a/src/moin/apps/misc/__init__.py b/src/moin/apps/misc/__init__.py
index ce1f6ad1c..fd7af9ee3 100644
--- a/src/moin/apps/misc/__init__.py
+++ b/src/moin/apps/misc/__init__.py
@@ -9,5 +9,6 @@
 
 
 from flask import Blueprint
-misc = Blueprint('misc', __name__, template_folder='templates')
+
+misc = Blueprint("misc", __name__, template_folder="templates")
 import moin.apps.misc.views  # noqa
diff --git a/src/moin/apps/misc/_tests/test_misc.py b/src/moin/apps/misc/_tests/test_misc.py
index fa38b0fdf..9802e0b62 100644
--- a/src/moin/apps/misc/_tests/test_misc.py
+++ b/src/moin/apps/misc/_tests/test_misc.py
@@ -11,15 +11,15 @@
 class TestMisc:
     def test_global_sitemap(self, app):
         with app.test_client() as c:
-            rv = c.get(url_for('misc.sitemap'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'text/xml; charset=utf-8'
-            assert rv.data.startswith(b'<?xml')
+            rv = c.get(url_for("misc.sitemap"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "text/xml; charset=utf-8"
+            assert rv.data.startswith(b"<?xml")
             assert b'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' in rv.data
-            assert b'</urlset>' in rv.data
+            assert b"</urlset>" in rv.data
 
     def test_urls_names(self, app):
         with app.test_client() as c:
-            rv = c.get(url_for('misc.urls_names'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'text/plain; charset=utf-8'
+            rv = c.get(url_for("misc.urls_names"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "text/plain; charset=utf-8"
diff --git a/src/moin/apps/misc/views.py b/src/moin/apps/misc/views.py
index 55dd92354..48a63bc47 100644
--- a/src/moin/apps/misc/views.py
+++ b/src/moin/apps/misc/views.py
@@ -21,11 +21,12 @@
 from moin.themes import render_template
 
 
-@misc.route('/sitemap')
+@misc.route("/sitemap")
 def sitemap():
     """
     Google (and others) XML sitemap
     """
+
     def format_timestamp(t):
         tm = time.gmtime(t)
         return time.strftime("%Y-%m-%dT%H:%M:%S+00:00", tm)
@@ -39,18 +40,20 @@ def format_timestamp(t):
         priority = "0.5"
         sitemap += [(fqname, format_timestamp(mtime), changefreq, priority) for fqname in fqnames]
     # add entries for root urls
-    root_mapping = [(namespace, app.cfg.root_mapping.get(namespace, app.cfg.default_root))
-                    for namespace, _ in app.cfg.namespace_mapping]
+    root_mapping = [
+        (namespace, app.cfg.root_mapping.get(namespace, app.cfg.default_root))
+        for namespace, _ in app.cfg.namespace_mapping
+    ]
     query = Or([And([Term(NAME_EXACT, root), Term(NAMESPACE, namespace)]) for namespace, root in root_mapping])
     for rev in flaskg.storage.search(q=query):
         mtime = rev.meta[MTIME]
         sitemap.append((rev.meta[NAMESPACE], format_timestamp(mtime), "hourly", "1.0"))
     sitemap.sort()
-    content = render_template('misc/sitemap.xml', sitemap=sitemap)
-    return Response(content, mimetype='text/xml')
+    content = render_template("misc/sitemap.xml", sitemap=sitemap)
+    return Response(content, mimetype="text/xml")
 
 
-@misc.route('/urls_names')
+@misc.route("/urls_names")
 def urls_names():
     """
     List of all item URLs and names, e.g. for sisteritems.
@@ -63,5 +66,5 @@ def urls_names():
     fq_names = []
     for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
         fq_names += [fqname for fqname in rev.fqnames]
-    content = render_template('misc/urls_names.txt', fq_names=fq_names)
-    return Response(content, mimetype='text/plain')
+    content = render_template("misc/urls_names.txt", fq_names=fq_names)
+    return Response(content, mimetype="text/plain")
diff --git a/src/moin/apps/serve/__init__.py b/src/moin/apps/serve/__init__.py
index db4affbb4..3c11d8d67 100644
--- a/src/moin/apps/serve/__init__.py
+++ b/src/moin/apps/serve/__init__.py
@@ -11,5 +11,6 @@
 
 
 from flask import Blueprint
-serve = Blueprint('serve', __name__)
+
+serve = Blueprint("serve", __name__)
 import moin.apps.serve.views  # noqa
diff --git a/src/moin/apps/serve/_tests/test_serve.py b/src/moin/apps/serve/_tests/test_serve.py
index 4b1a74e66..867f704d2 100644
--- a/src/moin/apps/serve/_tests/test_serve.py
+++ b/src/moin/apps/serve/_tests/test_serve.py
@@ -11,14 +11,14 @@
 class TestServe:
     def test_index(self, app):
         with app.test_client() as c:
-            rv = c.get(url_for('serve.index'))
-            assert rv.status == '200 OK'
-            assert rv.headers['Content-Type'] == 'text/plain'
+            rv = c.get(url_for("serve.index"))
+            assert rv.status == "200 OK"
+            assert rv.headers["Content-Type"] == "text/plain"
 
     def test_files(self, app):
         with app.test_client() as c:
-            rv = c.get(url_for('serve.files', name="DoesntExist"))
-            assert rv.status == '404 NOT FOUND'
-            assert rv.headers['Content-Type'] == 'text/html; charset=utf-8'
+            rv = c.get(url_for("serve.files", name="DoesntExist"))
+            assert rv.status == "404 NOT FOUND"
+            assert rv.headers["Content-Type"] == "text/html; charset=utf-8"
             # TODO: remove workaround when Werkzeug >= 2.1.2 is set (PR 1325)
-            assert '<!doctype html' in str(rv.data).lower()
+            assert "<!doctype html" in str(rv.data).lower()
diff --git a/src/moin/apps/serve/views.py b/src/moin/apps/serve/views.py
index 83e465fcf..dccd312b5 100644
--- a/src/moin/apps/serve/views.py
+++ b/src/moin/apps/serve/views.py
@@ -14,18 +14,19 @@
 from moin.apps.serve import serve
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
-@serve.route('/')
+@serve.route("/")
 def index():
     # show what we have (but not where in the filesystem)
     content = "\n".join(app.cfg.serve_files.keys())
-    return Response(content, content_type='text/plain')
+    return Response(content, content_type="text/plain")
 
 
-@serve.route('/<name>/', defaults=dict(filename=''))
-@serve.route('/<name>/<path:filename>')
+@serve.route("/<name>/", defaults=dict(filename=""))
+@serve.route("/<name>/<path:filename>")
 def files(name, filename):
     try:
         base_path = app.cfg.serve_files[name]
diff --git a/src/moin/auth/__init__.py b/src/moin/auth/__init__.py
index 908008c2b..3632ad397 100644
--- a/src/moin/auth/__init__.py
+++ b/src/moin/auth/__init__.py
@@ -147,6 +147,7 @@
 from moin.i18n import _
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -165,7 +166,7 @@ def get_multistage_continuation_url(auth_name, extra_fields={}):
     # live in auth so people do auth.get_multistage_continuation_url()
 
     # the url should be absolute so we use _external
-    url = url_for('frontend.login', login_submit='1', stage=auth_name, _external=True, **extra_fields)
+    url = url_for("frontend.login", login_submit="1", stage=auth_name, _external=True, **extra_fields)
     logging.debug(f"multistage_continuation_url: {url}")
     return url
 
@@ -173,8 +174,7 @@ def get_multistage_continuation_url(auth_name, extra_fields={}):
 class LoginReturn:
     """LoginReturn - base class for auth method login() return value"""
 
-    def __init__(self, user_obj, continue_flag, message=None, multistage=None,
-                 redirect_to=None):
+    def __init__(self, user_obj, continue_flag, message=None, multistage=None, redirect_to=None):
         self.user_obj = user_obj
         self.continue_flag = continue_flag
         self.message = message
@@ -183,27 +183,29 @@ def __init__(self, user_obj, continue_flag, message=None, multistage=None,
 
 
 class ContinueLogin(LoginReturn):
-    """ ContinueLogin - helper for auth method login that just continues """
+    """ContinueLogin - helper for auth method login that just continues"""
+
     def __init__(self, user_obj, message=None):
         LoginReturn.__init__(self, user_obj, True, message=message)
 
 
 class CancelLogin(LoginReturn):
-    """ CancelLogin - cancel login showing a message """
+    """CancelLogin - cancel login showing a message"""
 
     def __init__(self, message):
         LoginReturn.__init__(self, None, False, message=message)
 
 
 class MultistageFormLogin(LoginReturn):
-    """ MultistageFormLogin - require user to fill in another form """
+    """MultistageFormLogin - require user to fill in another form"""
 
     def __init__(self, multistage):
         LoginReturn.__init__(self, None, False, multistage=multistage)
 
 
 class MultistageRedirectLogin(LoginReturn):
-    """ MultistageRedirectLogin - redirect user to another site before continuing login """
+    """MultistageRedirectLogin - redirect user to another site before continuing login"""
+
     def __init__(self, url):
         LoginReturn.__init__(self, None, False, redirect_to=url)
 
@@ -235,17 +237,18 @@ def login_hint(self):
 
 
 class MoinAuth(BaseAuth):
-    """ handle login from moin login form """
+    """handle login from moin login form"""
+
     def __init__(self, **kw):
         super().__init__(**kw)
 
-    login_inputs = ['username', 'password']
-    name = 'moin'
+    login_inputs = ["username", "password"]
+    name = "moin"
     logout_possible = True
 
     def login(self, user_obj, **kw):
-        username = kw.get('username')
-        password = kw.get('password')
+        username = kw.get("username")
+        password = kw.get("password")
 
         # simply continue if something else already logged in successfully
         if user_obj and user_obj.valid:
@@ -257,7 +260,7 @@ def login(self, user_obj, **kw):
         logging.debug(f"{self.name}: performing login action")
 
         if username and not password:
-            return ContinueLogin(user_obj, _('Missing password. Please enter user name and password.'))
+            return ContinueLogin(user_obj, _("Missing password. Please enter user name and password."))
 
         u = user.User(name=username, password=password, auth_method=self.name, trusted=self.trusted)
         if u.valid:
@@ -269,35 +272,38 @@ def login(self, user_obj, **kw):
 
     def login_hint(self):
         if app.cfg.registration_only_by_superuser:
-            msg = app.cfg.registration_hint + ' '
+            msg = app.cfg.registration_hint + " "
         else:
-            msg = _('If you do not have an account, <a href="{register_url}">you can create one now</a>. '
-                   ).format(register_url=url_for('frontend.register'))
-        msg += _('<a href="{recover_url}">Forgot your password?</a>').format(recover_url=url_for('frontend.lostpass'))
+            msg = _('If you do not have an account, <a href="{register_url}">you can create one now</a>. ').format(
+                register_url=url_for("frontend.register")
+            )
+        msg += _('<a href="{recover_url}">Forgot your password?</a>').format(recover_url=url_for("frontend.lostpass"))
         return Markup(msg)
 
 
 class GivenAuth(BaseAuth):
-    """ reuse a given authentication, e.g. http basic auth (or any other auth)
-        done by the web server, that sets REMOTE_USER environment variable.
-        This is the default behaviour.
-        You can also specify to read another environment variable (env_var).
-        Alternatively you can directly give a fixed user name (user_name)
-        that will be considered as authenticated.
+    """reuse a given authentication, e.g. http basic auth (or any other auth)
+    done by the web server, that sets REMOTE_USER environment variable.
+    This is the default behaviour.
+    You can also specify to read another environment variable (env_var).
+    Alternatively you can directly give a fixed user name (user_name)
+    that will be considered as authenticated.
     """
-    name = 'given'  # was 'http' in 1.8.x and before
-
-    def __init__(self,
-                 env_var=None,  # environment variable we want to read (default: REMOTE_USER)
-                 user_name=None,  # can be used to just give a specific user name to log in
-                 autocreate=False,  # create/update the user profile for the auth. user
-                 strip_maildomain=False,  # joe@example.org -> joe
-                 strip_windomain=False,  # DOMAIN\joe -> joe
-                 titlecase=False,  # joe doe -> Joe Doe
-                 remove_blanks=False,  # Joe Doe -> JoeDoe
-                 coding='utf-8',  # for decoding REMOTE_USER correctly
-                 **kw
-                 ):
+
+    name = "given"  # was 'http' in 1.8.x and before
+
+    def __init__(
+        self,
+        env_var=None,  # environment variable we want to read (default: REMOTE_USER)
+        user_name=None,  # can be used to just give a specific user name to log in
+        autocreate=False,  # create/update the user profile for the auth. user
+        strip_maildomain=False,  # joe@example.org -> joe
+        strip_windomain=False,  # DOMAIN\joe -> joe
+        titlecase=False,  # joe doe -> Joe Doe
+        remove_blanks=False,  # Joe Doe -> JoeDoe
+        coding="utf-8",  # for decoding REMOTE_USER correctly
+        **kw,
+    ):
         super().__init__(**kw)
         self.env_var = env_var
         self.user_name = user_name
@@ -309,25 +315,25 @@ def __init__(self,
         self.coding = coding
 
     def decode_username(self, name):
-        """ decode the name we got from the environment var to unicode """
+        """decode the name we got from the environment var to unicode"""
         if isinstance(name, bytes):
             name = name.decode(self.coding)
         return name
 
     def transform_username(self, name):
-        """ transform the name we got (unicode in, unicode out)
+        """transform the name we got (unicode in, unicode out)
 
-            Note: if you need something more special, you could create your own
-                  auth class, inherit from this class and overwrite this function.
+        Note: if you need something more special, you could create your own
+              auth class, inherit from this class and overwrite this function.
         """
         assert isinstance(name, str)
         if self.strip_maildomain:
             # split off mail domain, e.g. "user@example.org" -> "user"
-            name = name.split('@')[0]
+            name = name.split("@")[0]
 
         if self.strip_windomain:
             # split off window domain, e.g. "DOMAIN\user" -> "user"
-            name = name.split('\\')[-1]
+            name = name.split("\\")[-1]
 
         if self.titlecase:
             # this "normalizes" the login name, e.g. meier, Meier, MEIER -> Meier
@@ -335,7 +341,7 @@ def transform_username(self, name):
 
         if self.remove_blanks:
             # remove blanks e.g. "Joe Doe" -> "JoeDoe"
-            name = ''.join(name.split())
+            name = "".join(name.split())
 
         return name
 
@@ -361,8 +367,12 @@ def request(self, user_obj, **kw):
             auth_username = self.decode_username(auth_username)
             auth_username = self.transform_username(auth_username)
             logging.debug(f"auth_username (after decode/transform) = {auth_username!r}")
-            u = user.User(auth_username=auth_username,
-                          auth_method=self.name, auth_attribs=('name', 'password'), trusted=self.trusted)
+            u = user.User(
+                auth_username=auth_username,
+                auth_method=self.name,
+                auth_attribs=("name", "password"),
+                trusted=self.trusted,
+            )
 
         logging.debug(f"u: {u!r}")
         if u and self.autocreate:
@@ -383,12 +393,13 @@ def handle_login(userobj, **kw):
     detail at the top of this file.
     """
 
-    stage = kw.get('stage')
-    params = {'username': kw.get('login_username'),
-              'password': kw.get('login_password'),
-              'multistage': (stage and True) or None,
-              'attended': True
-              }
+    stage = kw.get("stage")
+    params = {
+        "username": kw.get("login_username"),
+        "password": kw.get("login_password"),
+        "multistage": (stage and True) or None,
+        "attended": True,
+    }
     # add the other parameters from the form
     for param in kw.keys():
         params[param] = kw.get(param)
@@ -402,7 +413,7 @@ def handle_login(userobj, **kw):
         cont = ret.continue_flag
         if stage:
             stage = None
-            del params['multistage']
+            del params["multistage"]
 
         if ret.multistage:
             flaskg._login_multistage = ret.multistage
@@ -412,8 +423,8 @@ def handle_login(userobj, **kw):
         if ret.redirect_to:
             nextstage = get_multistage_continuation_url(authmethod.name)
             url = ret.redirect_to
-            url = url.replace('%return_form', quote_plus(nextstage))
-            url = url.replace('%return', quote(nextstage))
+            url = url.replace("%return_form", quote_plus(nextstage))
+            url = url.replace("%return", quote(nextstage))
             abort(redirect(url))
         msg = ret.message
         if msg and msg not in flaskg._login_messages:
@@ -426,7 +437,7 @@ def handle_login(userobj, **kw):
 
 
 def handle_logout(userobj):
-    """ Logout the passed user from every configured authentication method. """
+    """Logout the passed user from every configured authentication method."""
     if userobj is None:
         # not logged in
         return userobj
@@ -439,7 +450,7 @@ def handle_logout(userobj):
 
 
 def handle_request(userobj):
-    """ Handle the per-request callbacks of the configured authentication methods. """
+    """Handle the per-request callbacks of the configured authentication methods."""
     for authmethod in app.cfg.auth:
         userobj, cont = authmethod.request(userobj)
         if not cont:
@@ -449,19 +460,16 @@ def handle_request(userobj):
 
 def setup_from_session():
     userobj = None
-    if 'user.itemid' in session:
-        itemid = session['user.itemid']
-        trusted = session['user.trusted']
-        auth_method = session['user.auth_method']
-        auth_attribs = session['user.auth_attribs']
-        session_token = session['user.session_token']
+    if "user.itemid" in session:
+        itemid = session["user.itemid"]
+        trusted = session["user.trusted"]
+        auth_method = session["user.auth_method"]
+        auth_attribs = session["user.auth_attribs"]
+        session_token = session["user.session_token"]
         logging.debug(f"got from session: {itemid!r} {trusted!r} {auth_method!r} {auth_attribs!r}")
         logging.debug(f"current auth methods: {app.cfg.auth_methods!r}")
         if auth_method and auth_method in app.cfg.auth_methods:
-            userobj = user.User(itemid,
-                                auth_method=auth_method,
-                                auth_attribs=auth_attribs,
-                                trusted=trusted)
+            userobj = user.User(itemid, auth_method=auth_method, auth_attribs=auth_attribs, trusted=trusted)
             if not userobj.validate_session(session_token):
                 logging.debug("session token doesn't validate")
                 # Destroy current session since it's no longer valid.
diff --git a/src/moin/auth/_tests/test_auth.py b/src/moin/auth/_tests/test_auth.py
index 6a1f962a3..a93507b6e 100644
--- a/src/moin/auth/_tests/test_auth.py
+++ b/src/moin/auth/_tests/test_auth.py
@@ -16,24 +16,26 @@
 
 
 class TestConfiguredGivenAuth:
-    """ Test: configured GivenAuth """
+    """Test: configured GivenAuth"""
+
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            auth = [GivenAuth(user_name='JoeDoe', autocreate=True)]
+            auth = [GivenAuth(user_name="JoeDoe", autocreate=True)]
 
         return Config
 
     def test(self):
-        assert flaskg.user.name == ['JoeDoe', ]
+        assert flaskg.user.name == ["JoeDoe"]
 
 
 class TestGivenAuth:
-    """ Test: GivenAuth """
+    """Test: GivenAuth"""
+
     def test_decode_username(self):
         givenauth_obj = GivenAuth()
-        result1 = givenauth_obj.decode_username('test_name')
-        assert result1 == 'test_name'
+        result1 = givenauth_obj.decode_username("test_name")
+        assert result1 == "test_name"
         result2 = givenauth_obj.decode_username(123.45)
         assert result2 == 123.45
 
@@ -43,28 +45,28 @@ def test_transform_username(self):
         givenauth_obj.strip_windomain = True
         givenauth_obj.titlecase = True
         givenauth_obj.remove_blanks = True
-        result = givenauth_obj.transform_username('testDomain\\test name@moinmoin.org')
-        assert result == 'TestName'
+        result = givenauth_obj.transform_username("testDomain\\test name@moinmoin.org")
+        assert result == "TestName"
 
     def test_request(self):
         givenauth_obj = GivenAuth()
-        flaskg.user.auth_method = 'given'
-        givenauth_obj.user_name = 'testDomain\\test_user@moinmoin.org'
+        flaskg.user.auth_method = "given"
+        givenauth_obj.user_name = "testDomain\\test_user@moinmoin.org"
         givenauth_obj.strip_maildomain = True
         givenauth_obj.strip_windomain = True
         givenauth_obj.titlecase = True
         givenauth_obj.remove_blanks = True
-        create_user('Test_User', 'test_pass', 'test@moinmoin.org')
+        create_user("Test_User", "test_pass", "test@moinmoin.org")
         test_user, bool_value = givenauth_obj.request(flaskg.user)
         assert test_user.valid
-        assert test_user.name == ['Test_User', ]
+        assert test_user.name == ["Test_User"]
 
 
 def test_handle_login():
     # no messages in the beginning
     assert not flaskg._login_messages
-    test_user1 = handle_login(flaskg.user, login_username='test_user', login_password='test_password', stage='moin')
-    test_login_message = ['Invalid username or password.']
+    test_user1 = handle_login(flaskg.user, login_username="test_user", login_password="test_password", stage="moin")
+    test_login_message = ["Invalid username or password."]
     assert flaskg._login_messages == test_login_message
     assert test_user1.name0 == ANON
     assert not test_user1.valid
@@ -72,20 +74,21 @@ def test_handle_login():
     flaskg._login_messages.pop()
     # try with a valid user
     givenauth_obj = GivenAuth()
-    flaskg.user.auth_method = 'given'
-    givenauth_obj.user_name = 'Test_User'
-    create_user('Test_User', 'test_pass', 'test@moinmoin.org')
+    flaskg.user.auth_method = "given"
+    givenauth_obj.user_name = "Test_User"
+    create_user("Test_User", "test_pass", "test@moinmoin.org")
     test_user, bool_value = givenauth_obj.request(flaskg.user)
-    test_user2 = handle_login(test_user, login_username='Test_User', login_password='test_pass', stage='moin')
+    test_user2 = handle_login(test_user, login_username="Test_User", login_password="test_pass", stage="moin")
     assert not flaskg._login_messages
-    assert test_user2.name == ['Test_User', ]
+    assert test_user2.name == ["Test_User"]
     assert test_user2.valid
 
 
 def test_get_multistage_continuation_url():
-    test_url = get_multistage_continuation_url('test_auth_name',
-                                               extra_fields={'password': 'test_pass', 'test_key': 'test_value'})
-    assert 'test_key=test_value' in test_url
-    assert 'password=test_pass' in test_url
-    assert 'stage=test_auth_name' in test_url
-    assert 'login_submit=1' in test_url
+    test_url = get_multistage_continuation_url(
+        "test_auth_name", extra_fields={"password": "test_pass", "test_key": "test_value"}
+    )
+    assert "test_key=test_value" in test_url
+    assert "password=test_pass" in test_url
+    assert "stage=test_auth_name" in test_url
+    assert "login_submit=1" in test_url
diff --git a/src/moin/auth/_tests/test_http.py b/src/moin/auth/_tests/test_http.py
index 4f39aa045..eb3746b2e 100644
--- a/src/moin/auth/_tests/test_http.py
+++ b/src/moin/auth/_tests/test_http.py
@@ -17,34 +17,34 @@
 
 
 class TestHTTPAuthMoin:
-    """ Test: HTTPAuthMoin """
+    """Test: HTTPAuthMoin"""
 
     @pytest.fixture(autouse=True)
     def custom_setup(self):
         class Auth:
             def __init__(self):
-                self.username = 'ValidUser'
-                self.password = 'test_pass'
+                self.username = "ValidUser"
+                self.password = "test_pass"
 
-        flaskg.user.auth_method = 'http'
+        flaskg.user.auth_method = "http"
         flask_request.authorization = Auth()
 
         yield
 
-        flaskg.user.auth_method = 'invalid'
+        flaskg.user.auth_method = "invalid"
         flask_request.authorization = None
 
     def test_request(self):
         # create a new user
-        create_user('ValidUser', 'test_pass', 'test_email@moinmoin')
+        create_user("ValidUser", "test_pass", "test_email@moinmoin")
         httpauthmoin_obj = HTTPAuthMoin()
         test_user, bool_val = httpauthmoin_obj.request(flaskg.user)
         assert test_user.valid
-        assert test_user.name == ['ValidUser', ]
+        assert test_user.name == ["ValidUser"]
         assert bool_val
 
         # when auth_method is not 'http'
-        flaskg.user.auth_method = 'invalid'
+        flaskg.user.auth_method = "invalid"
         test_user, bool_val = httpauthmoin_obj.request(flaskg.user)
         assert not test_user.valid
         assert test_user.name0 == ANON
diff --git a/src/moin/auth/_tests/test_ldap_login.py b/src/moin/auth/_tests/test_ldap_login.py
index 88ec80313..c73609304 100644
--- a/src/moin/auth/_tests/test_ldap_login.py
+++ b/src/moin/auth/_tests/test_ldap_login.py
@@ -20,7 +20,7 @@
     pytestmark = pytest.mark.skip(msg)
 del msg
 
-ldap = pytest.importorskip('ldap')
+ldap = pytest.importorskip("ldap")
 
 
 class TestLDAPServer(LDAPTstBase):
@@ -31,16 +31,16 @@ class TestLDAPServer(LDAPTstBase):
     ldif_content = LDIF_CONTENT
 
     def testLDAP(self):
-        """ Just try accessing the LDAP server and see if usera and userb are in LDAP. """
+        """Just try accessing the LDAP server and see if usera and userb are in LDAP."""
         server_uri = self.ldap_env.slapd.url
         base_dn = self.ldap_env.basedn
         lo = ldap.initialize(server_uri)
         ldap.set_option(ldap.OPT_PROTOCOL_VERSION, ldap.VERSION3)  # ldap v2 is outdated
-        lo.simple_bind_s('', '')
-        lusers = lo.search_st(base_dn, ldap.SCOPE_SUBTREE, '(uid=*)')
-        uids = [ldap_dict['uid'][0] for dn, ldap_dict in lusers]
-        assert b'usera' in uids
-        assert b'userb' in uids
+        lo.simple_bind_s("", "")
+        lusers = lo.search_st(base_dn, ldap.SCOPE_SUBTREE, "(uid=*)")
+        uids = [ldap_dict["uid"][0] for dn, ldap_dict in lusers]
+        assert b"usera" in uids
+        assert b"userb" in uids
 
 
 class TestMoinLDAPLogin(LDAPTstBase):
@@ -54,37 +54,39 @@ class TestMoinLDAPLogin(LDAPTstBase):
     def cfg(self):
         class Config(wikiconfig.Config):
             from moin.auth.ldap_login import LDAPAuth
+
             # ToDo get these vars from the test environment
-            server_uri = 'ldap://127.0.0.1:3890'
-            base_dn = 'ou=testing,dc=example,dc=org'
+            server_uri = "ldap://127.0.0.1:3890"
+            base_dn = "ou=testing,dc=example,dc=org"
             ldap_auth1 = LDAPAuth(server_uri=server_uri, base_dn=base_dn, autocreate=True)
-            auth = [ldap_auth1, ]
+            auth = [ldap_auth1]
+
         return Config
 
     def testMoinLDAPLogin(self):
-        """ Just try accessing the LDAP server and see if usera and userb are in LDAP. """
+        """Just try accessing the LDAP server and see if usera and userb are in LDAP."""
 
         # tests that must not authenticate:
-        u = handle_login(None, username='', password='')
+        u = handle_login(None, username="", password="")
         assert u is None
-        u = handle_login(None, username='usera', password='')
+        u = handle_login(None, username="usera", password="")
         assert u is None
-        u = handle_login(None, username='usera', password='userawrong')
+        u = handle_login(None, username="usera", password="userawrong")
         assert u is None
-        u = handle_login(None, username='userawrong', password='usera')
+        u = handle_login(None, username="userawrong", password="usera")
         assert u is None
 
         # tests that must authenticate:
-        u1 = handle_login(None, username='usera', password='usera')
+        u1 = handle_login(None, username="usera", password="usera")
         assert u1 is not None
         assert u1.valid
 
-        u2 = handle_login(None, username='userb', password='userb')
+        u2 = handle_login(None, username="userb", password="userb")
         assert u2 is not None
         assert u2.valid
 
         # check if usera and userb have different ids:
-        assert u1.profile['itemid'] != u2.profile['itemid']
+        assert u1.profile["itemid"] != u2.profile["itemid"]
 
 
 class TestBugDefaultPasswd(LDAPTstBase):
@@ -99,26 +101,28 @@ def cfg(self):
         class Config(wikiconfig.Config):
             from moin.auth.ldap_login import LDAPAuth
             from moin.auth import MoinAuth
+
             # ToDo get these vars from the test environment
-            server_uri = 'ldap://127.0.0.1:3890'
-            base_dn = 'ou=testing,dc=example,dc=org'
+            server_uri = "ldap://127.0.0.1:3890"
+            base_dn = "ou=testing,dc=example,dc=org"
             ldap_auth = LDAPAuth(server_uri=server_uri, base_dn=base_dn, autocreate=True)
             moin_auth = MoinAuth()
             auth = [ldap_auth, moin_auth]
+
         return Config
 
     def teardown_class(self):
-        """ Stop slapd, remove LDAP server environment """
+        """Stop slapd, remove LDAP server environment"""
         self.ldap_env.stop_slapd()
         self.ldap_env.destroy_env()
 
     def testBugDefaultPasswd(self):
-        """ Login via LDAP (this creates user profile and up to 1.7.0rc1 it put
-            a default password there), then try logging in via moin login using
-            that default password or an empty password.
+        """Login via LDAP (this creates user profile and up to 1.7.0rc1 it put
+        a default password there), then try logging in via moin login using
+        that default password or an empty password.
         """
         # do a LDAPAuth login (as a side effect, this autocreates the user profile):
-        u1 = handle_login(None, username='usera', password='usera')
+        u1 = handle_login(None, username="usera", password="usera")
         assert u1 is not None
         assert u1.valid
 
@@ -127,15 +131,15 @@ def testBugDefaultPasswd(self):
 
         # now try a MoinAuth login:
         # try the default password that worked in 1.7 up to rc1:
-        u2 = handle_login(None, username='usera', password='{SHA}NotStored')
+        u2 = handle_login(None, username="usera", password="{SHA}NotStored")
         assert u2 is None
 
         # try using no password:
-        u2 = handle_login(None, username='usera', password='')
+        u2 = handle_login(None, username="usera", password="")
         assert u2 is None
 
         # try using wrong password:
-        u2 = handle_login(None, username='usera', password='wrong')
+        u2 = handle_login(None, username="usera", password="wrong")
         assert u2 is None
 
 
@@ -147,36 +151,38 @@ class TestTwoLdapServers:
     ldif_content = LDIF_CONTENT
 
     def setup_class(self):
-        """ Create LDAP servers environment, start slapds """
+        """Create LDAP servers environment, start slapds"""
         self.ldap_envs = []
         for instance in range(2):
             ldap_env = LdapEnvironment(self.basedn, self.rootdn, self.rootpw, instance=instance)
             ldap_env.create_env(slapd_config=self.slapd_config)
             started = ldap_env.start_slapd()
             if not started:
-                pytest.skip("Failed to start {} process, please see your syslog / log files"
-                            " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE))
+                pytest.skip(
+                    "Failed to start {} process, please see your syslog / log files"
+                    " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE)
+                )
             ldap_env.load_directory(ldif_content=self.ldif_content)
             self.ldap_envs.append(ldap_env)
 
     def teardown_class(self):
-        """ Stop slapd, remove LDAP server environment """
+        """Stop slapd, remove LDAP server environment"""
         for ldap_env in self.ldap_envs:
             ldap_env.stop_slapd()
             ldap_env.destroy_env()
 
     def testLDAP(self):
-        """ Just try accessing the LDAP servers and see if usera and userb are in LDAP. """
+        """Just try accessing the LDAP servers and see if usera and userb are in LDAP."""
         for ldap_env in self.ldap_envs:
             server_uri = ldap_env.slapd.url
             base_dn = ldap_env.basedn
             lo = ldap.initialize(server_uri)
             ldap.set_option(ldap.OPT_PROTOCOL_VERSION, ldap.VERSION3)  # ldap v2 is outdated
-            lo.simple_bind_s('', '')
-            lusers = lo.search_st(base_dn, ldap.SCOPE_SUBTREE, '(uid=*)')
-            uids = [ldap_dict['uid'][0] for dn, ldap_dict in lusers]
-            assert b'usera' in uids
-            assert b'userb' in uids
+            lo.simple_bind_s("", "")
+            lusers = lo.search_st(base_dn, ldap.SCOPE_SUBTREE, "(uid=*)")
+            uids = [ldap_dict["uid"][0] for dn, ldap_dict in lusers]
+            assert b"usera" in uids
+            assert b"userb" in uids
 
 
 class TestLdapFailover:
@@ -187,15 +193,17 @@ class TestLdapFailover:
     ldif_content = LDIF_CONTENT
 
     def setup_class(self):
-        """ Create LDAP servers environment, start slapds """
+        """Create LDAP servers environment, start slapds"""
         self.ldap_envs = []
         for instance in range(2):
             ldap_env = LdapEnvironment(self.basedn, self.rootdn, self.rootpw, instance=instance)
             ldap_env.create_env(slapd_config=self.slapd_config)
             started = ldap_env.start_slapd()
             if not started:
-                pytest.skip("Failed to start {} process, please see your syslog / log files"
-                            " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE))
+                pytest.skip(
+                    "Failed to start {} process, please see your syslog / log files"
+                    " (and check if stopping apparmor helps, in case you use it).".format(SLAPD_EXECUTABLE)
+                )
             ldap_env.load_directory(ldif_content=self.ldif_content)
             self.ldap_envs.append(ldap_env)
 
@@ -203,22 +211,20 @@ def setup_class(self):
     def cfg(self):
         class Config(wikiconfig.Config):
             from moin.auth.ldap_login import LDAPAuth
+
             # ToDo get these vars from the test environment
-            server_uri = 'ldap://127.0.0.1:3891'
-            base_dn = 'ou=testing,dc=example,dc=org'
-            ldap_auth1 = LDAPAuth(server_uri=server_uri, base_dn=base_dn,
-                                  name="ldap1", autocreate=True,
-                                  timeout=1)
+            server_uri = "ldap://127.0.0.1:3891"
+            base_dn = "ou=testing,dc=example,dc=org"
+            ldap_auth1 = LDAPAuth(server_uri=server_uri, base_dn=base_dn, name="ldap1", autocreate=True, timeout=1)
             # short timeout, faster testing
-            server_uri = 'ldap://127.0.0.1:3892'
-            ldap_auth2 = LDAPAuth(server_uri=server_uri, base_dn=base_dn,
-                                  name="ldap2", autocreate=True,
-                                  timeout=1)
+            server_uri = "ldap://127.0.0.1:3892"
+            ldap_auth2 = LDAPAuth(server_uri=server_uri, base_dn=base_dn, name="ldap2", autocreate=True, timeout=1)
             auth = [ldap_auth1, ldap_auth2]
+
         return Config
 
     def teardown_class(self):
-        """ Stop slapd, remove LDAP server environment """
+        """Stop slapd, remove LDAP server environment"""
         for ldap_env in self.ldap_envs:
             try:
                 ldap_env.stop_slapd()
@@ -227,10 +233,10 @@ def teardown_class(self):
             ldap_env.destroy_env()
 
     def testMoinLDAPFailOver(self):
-        """ Try if it does a failover to a secondary LDAP, if the primary fails. """
+        """Try if it does a failover to a secondary LDAP, if the primary fails."""
 
         # authenticate user (with primary slapd):
-        u1 = handle_login(None, username='usera', password='usera')
+        u1 = handle_login(None, username="usera", password="usera")
         assert u1 is not None
         assert u1.valid
 
@@ -238,6 +244,6 @@ def testMoinLDAPFailOver(self):
         self.ldap_envs[0].slapd.stop()
 
         # try if we can still authenticate (with the second slapd):
-        u2 = handle_login(None, username='usera', password='usera')
+        u2 = handle_login(None, username="usera", password="usera")
         assert u2 is not None
         assert u2.valid
diff --git a/src/moin/auth/_tests/test_log.py b/src/moin/auth/_tests/test_log.py
index eaee76e5f..53f5197b6 100644
--- a/src/moin/auth/_tests/test_log.py
+++ b/src/moin/auth/_tests/test_log.py
@@ -12,11 +12,13 @@
 from moin.constants.misc import ANON
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class TestAuthLog:
-    """ Test: TestAuthLog """
+    """Test: TestAuthLog"""
+
     def test_login(self):
         authlog_obj = AuthLog()
         result = authlog_obj.login(flaskg.user)
diff --git a/src/moin/auth/http.py b/src/moin/auth/http.py
index efa3525c4..3370a3c68 100644
--- a/src/moin/auth/http.py
+++ b/src/moin/auth/http.py
@@ -24,14 +24,16 @@
 from moin.auth import BaseAuth
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class HTTPAuthMoin(BaseAuth):
-    """ authenticate via http (basic) auth """
-    name = 'http'
+    """authenticate via http (basic) auth"""
+
+    name = "http"
 
-    def __init__(self, trusted=True, autocreate=False, realm='MoinMoin', coding='utf-8', **kw):
+    def __init__(self, trusted=True, autocreate=False, realm="MoinMoin", coding="utf-8", **kw):
         super().__init__(**kw)
         self.autocreate = autocreate
         self.realm = realm
@@ -49,15 +51,16 @@ def request(self, user_obj, **kw):
         auth = request.authorization
         if auth and auth.username and auth.password is not None:
             logging.debug(f"http basic auth, received username: {auth.username!r} password: {auth.password!r}")
-            u = user.User(name=auth.username, password=auth.password,
-                          auth_method=self.name, auth_attribs=[], trusted=self.trusted)
+            u = user.User(
+                name=auth.username, password=auth.password, auth_method=self.name, auth_attribs=[], trusted=self.trusted
+            )
             logging.debug(f"user: {u!r}")
 
         if not u or not u.valid:
             from werkzeug import Response
             from werkzeug.exceptions import abort
-            response = Response(_('Please log in first.'), 401,
-                                {'WWW-Authenticate': f'Basic realm="{self.realm}"'})
+
+            response = Response(_("Please log in first."), 401, {"WWW-Authenticate": f'Basic realm="{self.realm}"'})
             abort(response)
 
         logging.debug(f"u: {u!r}")
diff --git a/src/moin/auth/ldap_login.py b/src/moin/auth/ldap_login.py
index 960b2db99..e5777544b 100644
--- a/src/moin/auth/ldap_login.py
+++ b/src/moin/auth/ldap_login.py
@@ -24,6 +24,7 @@
 from moin.auth import BaseAuth, CancelLogin, ContinueLogin
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 try:
@@ -34,43 +35,43 @@
 
 
 class LDAPAuth(BaseAuth):
-    """ get authentication data from form, authenticate against LDAP (or Active
-        Directory), fetch some user infos from LDAP and create a user object
-        for that user. The session is kept by moin automatically.
+    """get authentication data from form, authenticate against LDAP (or Active
+    Directory), fetch some user infos from LDAP and create a user object
+    for that user. The session is kept by moin automatically.
     """
 
-    login_inputs = ['username', 'password']
+    login_inputs = ["username", "password"]
     logout_possible = True
-    name = 'ldap'
+    name = "ldap"
 
     def __init__(
         self,
         trusted=True,
-        server_uri='ldap://localhost',  # ldap / active directory server URI
-                                        # use ldaps://server:636 url for ldaps,
-                                        # use  ldap://server for ldap without tls (and set start_tls to 0),
-                                        # use  ldap://server for ldap with tls (and set start_tls to 1 or 2).
-        bind_dn='',  # We can either use some fixed user and password for binding to LDAP.
-                     # Be careful if you need a % char in those strings - as they are used as
-                     # a format string, you have to write %% to get a single % in the end.
-                     # bind_dn = 'binduser@example.org' # (AD)
-                     # bind_dn = 'cn=admin,dc=example,dc=org' # (OpenLDAP)
-                     # bind_pw = 'secret'
-                     # or we can use the username and password we got from the user:
-                     # bind_dn = '%(username)s@example.org' # DN we use for first bind (AD)
-                     # bind_pw = '%(password)s' # password we use for first bind
-                     # or we can bind anonymously (if that is supported by your directory).
-                     # In any case, bind_dn and bind_pw must be defined.
-        bind_pw='',
-        base_dn='',  # base DN we use for searching
-                     # base_dn = 'ou=SOMEUNIT,dc=example,dc=org'
+        server_uri="ldap://localhost",  # ldap / active directory server URI
+        # use ldaps://server:636 url for ldaps,
+        # use  ldap://server for ldap without tls (and set start_tls to 0),
+        # use  ldap://server for ldap with tls (and set start_tls to 1 or 2).
+        bind_dn="",  # We can either use some fixed user and password for binding to LDAP.
+        # Be careful if you need a % char in those strings - as they are used as
+        # a format string, you have to write %% to get a single % in the end.
+        # bind_dn = 'binduser@example.org' # (AD)
+        # bind_dn = 'cn=admin,dc=example,dc=org' # (OpenLDAP)
+        # bind_pw = 'secret'
+        # or we can use the username and password we got from the user:
+        # bind_dn = '%(username)s@example.org' # DN we use for first bind (AD)
+        # bind_pw = '%(password)s' # password we use for first bind
+        # or we can bind anonymously (if that is supported by your directory).
+        # In any case, bind_dn and bind_pw must be defined.
+        bind_pw="",
+        base_dn="",  # base DN we use for searching
+        # base_dn = 'ou=SOMEUNIT,dc=example,dc=org'
         scope=ldap.SCOPE_SUBTREE,  # scope of the search we do (2 == ldap.SCOPE_SUBTREE)
         referrals=0,  # LDAP REFERRALS (0 needed for AD)
-        search_filter='(uid=%(username)s)',  # ldap filter used for searching:
-                                             # search_filter = '(sAMAccountName=%(username)s)' # (AD)
-                                             # search_filter = '(uid=%(username)s)' # (OpenLDAP)
-                                             # you can also do more complex filtering like:
-                                             # "(&(cn=%(username)s)(memberOf=CN=WikiUsers,OU=Groups,DC=example,DC=org))"
+        search_filter="(uid=%(username)s)",  # ldap filter used for searching:
+        # search_filter = '(sAMAccountName=%(username)s)' # (AD)
+        # search_filter = '(uid=%(username)s)' # (OpenLDAP)
+        # you can also do more complex filtering like:
+        # "(&(cn=%(username)s)(memberOf=CN=WikiUsers,OU=Groups,DC=example,DC=org))"
         # some attribute names we use to extract information from LDAP:
         givenname_attribute=None,  # ('givenName') ldap attribute we get the first name from
         surname_attribute=None,  # ('sn') ldap attribute we get the family name from
@@ -78,7 +79,7 @@ def __init__(
         email_attribute=None,  # ('mail') ldap attribute we get the email address from
         email_callback=None,  # called to make up email address
         name_callback=None,  # called to use a Wiki name different from the login name
-        coding='utf-8',  # coding used for ldap queries and result values
+        coding="utf-8",  # coding used for ldap queries and result values
         timeout=10,  # how long we wait for the ldap server [s]
         start_tls=0,  # 0 = No, 1 = Try, 2 = Required
         tls_cacertdir=None,
@@ -88,9 +89,9 @@ def __init__(
         tls_require_cert=0,  # 0 == ldap.OPT_X_TLS_NEVER (needed for self-signed certs)
         bind_once=False,  # set to True to only do one bind - useful if configured to bind as the user on first attempt
         autocreate=False,  # set to True if you want to autocreate user profiles
-        name='ldap',  # use e.g. 'ldap_pdc' and 'ldap_bdc' (or 'ldap1' and 'ldap2') if you auth against 2 ldap servers
+        name="ldap",  # use e.g. 'ldap_pdc' and 'ldap_bdc' (or 'ldap1' and 'ldap2') if you auth against 2 ldap servers
         report_invalid_credentials=True,  # whether to emit "invalid username or password" msg at login time or not
-        **kw
+        **kw,
     ):
         super().__init__(**kw)
         self.server_uri = server_uri
@@ -125,13 +126,13 @@ def __init__(
         self.report_invalid_credentials = report_invalid_credentials
 
     def login(self, user_obj, **kw):
-        username = kw.get('username')
-        password = kw.get('password')
+        username = kw.get("username")
+        password = kw.get("password")
 
         # we require non-empty password as ldap bind does a anon (not password
         # protected) bind if the password is empty and SUCCEEDS!
         if not password:
-            return ContinueLogin(user_obj, _('Missing password. Please enter user name and password.'))
+            return ContinueLogin(user_obj, _("Missing password. Please enter user name and password."))
 
         try:
             try:
@@ -144,7 +145,7 @@ def login(self, user_obj, **kw):
                 ldap.set_option(ldap.OPT_REFERRALS, self.referrals)
                 ldap.set_option(ldap.OPT_NETWORK_TIMEOUT, self.timeout)
 
-                if hasattr(ldap, 'TLS_AVAIL') and ldap.TLS_AVAIL:
+                if hasattr(ldap, "TLS_AVAIL") and ldap.TLS_AVAIL:
                     for option, value in (
                         (ldap.OPT_X_TLS_CACERTDIR, self.tls_cacertdir),
                         (ldap.OPT_X_TLS_CACERTFILE, self.tls_cacertfile),
@@ -161,7 +162,7 @@ def login(self, user_obj, **kw):
                 conn = ldap.initialize(server)
                 logging.debug(f"Connected to LDAP server {server!r}.")
 
-                if self.start_tls and server.startswith('ldap:'):
+                if self.start_tls and server.startswith("ldap:"):
                     logging.debug(f"Trying to start TLS to {server!r}.")
                     try:
                         conn.start_tls_s()
@@ -179,14 +180,12 @@ def login(self, user_obj, **kw):
                 # you can use %(username)s here to get the stuff entered in the form:
                 filterstr = self.search_filter % locals()
                 logging.debug(f"Searching {filterstr!r}")
-                attrs = [getattr(self, attr) for attr in [
-                    'email_attribute',
-                    'displayname_attribute',
-                    'surname_attribute',
-                    'givenname_attribute',
-                ] if getattr(self, attr) is not None]
-                lusers = conn.search_st(self.base_dn, self.scope, filterstr,
-                                        attrlist=attrs, timeout=self.timeout)
+                attrs = [
+                    getattr(self, attr)
+                    for attr in ["email_attribute", "displayname_attribute", "surname_attribute", "givenname_attribute"]
+                    if getattr(self, attr) is not None
+                ]
+                lusers = conn.search_st(self.base_dn, self.scope, filterstr, attrlist=attrs, timeout=self.timeout)
                 # we remove entries with dn == None to get the real result list:
                 lusers = [(_dn, _ldap_dict) for _dn, _ldap_dict in lusers if _dn is not None]
                 for _dn, _ldap_dict in lusers:
@@ -213,20 +212,20 @@ def login(self, user_obj, **kw):
 
                 if self.email_callback is None:
                     if self.email_attribute:
-                        email = ldap_dict.get(self.email_attribute, [''])[0]
+                        email = ldap_dict.get(self.email_attribute, [""])[0]
                     else:
                         email = None
                 else:
                     email = self.email_callback(ldap_dict)
 
-                display_name = ''
+                display_name = ""
                 try:
                     display_name = ldap_dict[self.displayname_attribute][0]
                 except (KeyError, IndexError):
                     pass
                 if not display_name:
-                    sn = ldap_dict.get(self.surname_attribute, [''])[0]
-                    gn = ldap_dict.get(self.givenname_attribute, [''])[0]
+                    sn = ldap_dict.get(self.surname_attribute, [""])[0]
+                    gn = ldap_dict.get(self.givenname_attribute, [""])[0]
                     if sn and gn:
                         display_name = f"{sn}, {gn}"
                     elif sn:
@@ -236,18 +235,27 @@ def login(self, user_obj, **kw):
                     username = self.name_callback(ldap_dict)
 
                 if email:
-                    u = user.User(auth_username=username, auth_method=self.name,
-                                  auth_attribs=('name', 'password', 'email', 'mailto_author', ),
-                                  trusted=self.trusted)
+                    u = user.User(
+                        auth_username=username,
+                        auth_method=self.name,
+                        auth_attribs=("name", "password", "email", "mailto_author"),
+                        trusted=self.trusted,
+                    )
                     u.email = email
                 else:
-                    u = user.User(auth_username=username, auth_method=self.name,
-                                  auth_attribs=('name', 'password', 'mailto_author', ),
-                                  trusted=self.trusted)
+                    u = user.User(
+                        auth_username=username,
+                        auth_method=self.name,
+                        auth_attribs=("name", "password", "mailto_author"),
+                        trusted=self.trusted,
+                    )
                 u.name = username
                 u.display_name = display_name
-                logging.debug("creating user object with name {!r} email {!r} display name {!r}".format(
-                    username, email, display_name))
+                logging.debug(
+                    "creating user object with name {!r} email {!r} display name {!r}".format(
+                        username, email, display_name
+                    )
+                )
 
             except ldap.INVALID_CREDENTIALS:
                 logging.debug(f"invalid credentials (wrong password?) for dn {dn!r} (username: {username!r})")
diff --git a/src/moin/auth/log.py b/src/moin/auth/log.py
index 7f55d96fc..2cbca23b4 100644
--- a/src/moin/auth/log.py
+++ b/src/moin/auth/log.py
@@ -12,27 +12,29 @@
 from moin.auth import BaseAuth, ContinueLogin
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class AuthLog(BaseAuth):
-    """ just log the call, do nothing else """
+    """just log the call, do nothing else"""
+
     name = "log"
 
     def __init__(self, **kw):
         super().__init__(**kw)
 
     def log(self, action, user_obj, kw):
-        logging.info(f'{action}: user_obj={user_obj!r} kw={kw!r}')
+        logging.info(f"{action}: user_obj={user_obj!r} kw={kw!r}")
 
     def login(self, user_obj, **kw):
-        self.log('login', user_obj, kw)
+        self.log("login", user_obj, kw)
         return ContinueLogin(user_obj)
 
     def request(self, user_obj, **kw):
-        self.log('session', user_obj, kw)
+        self.log("session", user_obj, kw)
         return user_obj, True
 
     def logout(self, user_obj, **kw):
-        self.log('logout', user_obj, kw)
+        self.log("logout", user_obj, kw)
         return user_obj, True
diff --git a/src/moin/auth/smb_mount.py b/src/moin/auth/smb_mount.py
index 593fd95d1..3f27e672f 100644
--- a/src/moin/auth/smb_mount.py
+++ b/src/moin/auth/smb_mount.py
@@ -14,29 +14,31 @@
 from moin.auth import BaseAuth, ContinueLogin
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class SMBMount(BaseAuth):
-    """ auth plugin for (un)mounting an smb share,
-        this is a wrapper around mount.cifs -o <options> //server/share mountpoint
+    """auth plugin for (un)mounting an smb share,
+    this is a wrapper around mount.cifs -o <options> //server/share mountpoint
 
-        See man mount.cifs for details.
+    See man mount.cifs for details.
     """
+
     def __init__(
         self,
         server,  # mount.cifs //server/share
         share,  # mount.cifs //server/share
         mountpoint_fn,  # function of username to determine the mountpoint, e.g.:
-                        # lambda username: '/mnt/wiki/%s' % username
+        # lambda username: '/mnt/wiki/%s' % username
         dir_user,  # username to get the uid that is used for mount.cifs -o uid=... (e.g. 'www-data')
         domain,  # mount.cifs -o domain=...
-        dir_mode='0700',  # mount.cifs -o dir_mode=...
-        file_mode='0600',  # mount.cifs -o file_mode=...
-        iocharset='utf-8',  # mount.cifs -o iocharset=... (try 'iso8859-1' if default does not work)
-        coding='utf-8',  # encoding used for username/password/cmdline (try 'iso8859-1' if default does not work)
-        log='/dev/null',  # logfile for mount.cifs output
-        **kw
+        dir_mode="0700",  # mount.cifs -o dir_mode=...
+        file_mode="0600",  # mount.cifs -o file_mode=...
+        iocharset="utf-8",  # mount.cifs -o iocharset=... (try 'iso8859-1' if default does not work)
+        coding="utf-8",  # encoding used for username/password/cmdline (try 'iso8859-1' if default does not work)
+        log="/dev/null",  # logfile for mount.cifs output
+        **kw,
     ):
         super().__init__(**kw)
         self.server = server
@@ -56,27 +58,30 @@ def do_smb(self, username, password, login):
         import os
         import pwd
         import subprocess
+
         web_username = self.dir_user
         web_uid = pwd.getpwnam(web_username)[2]  # XXX better just use current uid?
 
         mountpoint = self.mountpoint_fn(username)
         if login:
-            cmd = ("sudo mount -t cifs -o user=%(user)s,domain=%(domain)s,uid=%(uid)d,dir_mode=%(dir_mode)s,file_mode="
-                   "%(file_mode)s,iocharset=%(iocharset)s //%(server)s/%(share)s %(mountpoint)s >>%(log)s 2>&1")
+            cmd = (
+                "sudo mount -t cifs -o user=%(user)s,domain=%(domain)s,uid=%(uid)d,dir_mode=%(dir_mode)s,file_mode="
+                "%(file_mode)s,iocharset=%(iocharset)s //%(server)s/%(share)s %(mountpoint)s >>%(log)s 2>&1"
+            )
         else:
             cmd = "sudo umount %(mountpoint)s >>%(log)s 2>&1"
 
         cmd = cmd % {
-            'user': username,
-            'uid': web_uid,
-            'domain': self.domain,
-            'server': self.server,
-            'share': self.share,
-            'mountpoint': mountpoint,
-            'dir_mode': self.dir_mode,
-            'file_mode': self.file_mode,
-            'iocharset': self.iocharset,
-            'log': self.log,
+            "user": username,
+            "uid": web_uid,
+            "domain": self.domain,
+            "server": self.server,
+            "share": self.share,
+            "mountpoint": mountpoint,
+            "dir_mode": self.dir_mode,
+            "file_mode": self.file_mode,
+            "iocharset": self.iocharset,
+            "log": self.log,
         }
         env = os.environ.copy()
         if login:
@@ -85,12 +90,12 @@ def do_smb(self, username, password, login):
                     os.makedirs(mountpoint)  # the dir containing the mountpoint must be writeable for us!
             except OSError:
                 pass
-            env['PASSWD'] = password.encode(self.coding)
+            env["PASSWD"] = password.encode(self.coding)
         subprocess.call(cmd.encode(self.coding), env=env, shell=True)
 
     def login(self, user_obj, **kw):
-        username = kw.get('username')
-        password = kw.get('password')
+        username = kw.get("username")
+        password = kw.get("password")
         if user_obj and user_obj.valid:
             self.do_smb(username, password, True)
         return ContinueLogin(user_obj)
diff --git a/src/moin/cli/__init__.py b/src/moin/cli/__init__.py
index 34dcf555e..654cefb1b 100644
--- a/src/moin/cli/__init__.py
+++ b/src/moin/cli/__init__.py
@@ -18,12 +18,14 @@
 from moin.cli.migration.moin19 import import19
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 def Help():
-    """ Moin initial help"""
-    print("""\
+    """Moin initial help"""
+    print(
+        """\
 Quick help / most important commands overview:
 
   moin create-instance  # Create wikiconfig and wiki instance directories
@@ -42,21 +44,22 @@ def Help():
   moin <subcommand> --help
 
 or read the Docs at https://moin-20.readthedocs.io/
-""")
+"""
+    )
 
 
 # @click.option('--config', required=False, default=None)
 @click.group(cls=FlaskGroup, create_app=create_app, invoke_without_command=True)
 @click.pass_context
 def cli(ctx):
-    """ Moin extensions to the Flask CLI"""
+    """Moin extensions to the Flask CLI"""
     logging.debug("invoked_subcommand: %s", ctx.invoked_subcommand)
     if ctx.invoked_subcommand is None:
         Help()
     sys.stdout.reconfigure(encoding="utf-8")
 
 
-@cli.command('help', help='Quick help')
+@cli.command("help", help="Quick help")
 def _Help():
     Help()
 
diff --git a/src/moin/cli/_tests/__init__.py b/src/moin/cli/_tests/__init__.py
index c3bb6eb9a..4d4ca8c35 100644
--- a/src/moin/cli/_tests/__init__.py
+++ b/src/moin/cli/_tests/__init__.py
@@ -20,8 +20,9 @@
 logging = log.getLogger(__name__)
 
 
-def run(cmd: list[str], log=None, wait: bool = True, timeout: int = None, env=None) \
-        -> Union[subprocess.CompletedProcess, subprocess.Popen]:
+def run(
+    cmd: list[str], log=None, wait: bool = True, timeout: int = None, env=None
+) -> Union[subprocess.CompletedProcess, subprocess.Popen]:
     """run a shell command, redirecting output to log
     :param cmd: list of strings containing command arguments
     :param log: open file handle to log file (binary mode) or None in which case output will be captured
@@ -30,10 +31,10 @@ def run(cmd: list[str], log=None, wait: bool = True, timeout: int = None, env=No
     :param env: dictionary of environment variables to add to current env for subprocess
     :return: CompletedProcess object if wait else Popen object"""
     subprocess_environ = copy(os.environ)
-    subprocess_environ['PYTHONIOENCODING'] = 'cp1252'  # simulate windows terminal to ferret out encoding issues
+    subprocess_environ["PYTHONIOENCODING"] = "cp1252"  # simulate windows terminal to ferret out encoding issues
     if env:
         subprocess_environ.update(env)
-    logging.info(f'running {cmd}')
+    logging.info(f"running {cmd}")
     if stdout := log:
         stderr = subprocess.STDOUT
     else:  # log is None
@@ -43,10 +44,10 @@ def run(cmd: list[str], log=None, wait: bool = True, timeout: int = None, env=No
     flags = 0
     if wait:
         run_func = subprocess.run
-        kwargs['timeout'] = timeout
+        kwargs["timeout"] = timeout
     else:
         run_func = subprocess.Popen
-        if sys.platform == 'win32':
+        if sys.platform == "win32":
             flags = subprocess.CREATE_NEW_PROCESS_GROUP  # needed for use of os.kill
     return run_func(cmd, stdout=stdout, stderr=stderr, creationflags=flags, env=subprocess_environ, **kwargs)
 
@@ -56,13 +57,13 @@ def assert_p_succcess(p: subprocess.CompletedProcess):
     try:
         assert p.returncode == 0
     except AssertionError:
-        logging.error(f'failure for {p.args} stdout = {p.stdout} stderr = {p.stderr}')
+        logging.error(f"failure for {p.args} stdout = {p.stdout} stderr = {p.stderr}")
         raise
 
 
-ARRAY_SPLIT_RE = re.compile(r'[\[\],]')
-DATETIME_RE = re.compile(r'datetime\.datetime\([\d, ]*\)')
-COUNT_SLASHES_RE = re.compile(r'([\\]*)$')
+ARRAY_SPLIT_RE = re.compile(r"[\[\],]")
+DATETIME_RE = re.compile(r"datetime\.datetime\([\d, ]*\)")
+COUNT_SLASHES_RE = re.compile(r"([\\]*)$")
 
 
 def _is_eval_safe(s: str) -> bool:
@@ -75,7 +76,7 @@ def _is_eval_safe(s: str) -> bool:
     []
     123
     datetime.datetime(2023, 4, 17, 22, 52, 43)"""
-    if s.startswith('['):
+    if s.startswith("["):
         words = ARRAY_SPLIT_RE.split(s)
     else:
         words = [s]
@@ -109,7 +110,7 @@ def _is_eval_safe(s: str) -> bool:
                     pass
                 if DATETIME_RE.fullmatch(s):
                     safe = True
-                if s in {'True', 'False'}:
+                if s in {"True", "False"}:
                     safe = True
         if not safe:
             return False
@@ -123,20 +124,20 @@ def read_index_dump(out: str, latest=False):
     :param latest: if True yield only the latest revs
     :return: list of dicts with key value pairs from output"""
     if not isinstance(out, str):
-        raise ValueError('read_index_dump_latest_revs expects str, did you forget to .decode()')
+        raise ValueError("read_index_dump_latest_revs expects str, did you forget to .decode()")
     item = {}
     for line in out.splitlines():
-        if not line.strip() or line.startswith(' '):
+        if not line.strip() or line.startswith(" "):
             if item:
                 yield item
                 item = {}
-            if latest and 'all_revs' in line:
+            if latest and "all_revs" in line:
                 break
             continue
-        space_index = line.index(' ')
-        v_str = line[space_index + 1:].strip()
+        space_index = line.index(" ")
+        v_str = line[space_index + 1 :].strip()
         if not _is_eval_safe(v_str):
-            warn(f'invalid line in stdout of moin index-dump: {repr(line.strip())}')
+            warn(f"invalid line in stdout of moin index-dump: {repr(line.strip())}")
             continue
         item[line[0:space_index]] = eval(v_str)
 
@@ -147,5 +148,5 @@ def read_index_dump_latest_revs(out: str):
 
 
 def getBackupPath(backup_name):
-    _, artifact_base_dir = get_dirs('')
+    _, artifact_base_dir = get_dirs("")
     return artifact_base_dir / backup_name
diff --git a/src/moin/cli/_tests/conftest.py b/src/moin/cli/_tests/conftest.py
index 5dc6fa1c9..aa1043c40 100644
--- a/src/moin/cli/_tests/conftest.py
+++ b/src/moin/cli/_tests/conftest.py
@@ -31,6 +31,7 @@
 from moin.cli._tests import run, getBackupPath
 from moin.cli._tests.scrapy.moincrawler.items import CrawlResult
 from moin import log
+
 try:
     from moin.cli._tests import settings
 except ImportError:
@@ -44,10 +45,10 @@ def artifact_dir():
     """create and cd to and yield directory for wiki which persists thru all tests
 
     directory is deleted at end of all tests"""
-    _, artifact_dir = get_dirs('cli')
+    _, artifact_dir = get_dirs("cli")
     cwd = os.getcwd()
     os.chdir(artifact_dir)
-    logging.info(f'artifact_dir = {str(artifact_dir)}')
+    logging.info(f"artifact_dir = {str(artifact_dir)}")
     yield artifact_dir
     os.chdir(cwd)
     shutil.rmtree(artifact_dir, ignore_errors=True)
@@ -56,10 +57,10 @@ def artifact_dir():
 @pytest.fixture
 def artifact_dir2():
     """create and cd to and yield directory for wiki which gets deleted at end of each test function"""
-    _, artifact_dir = get_dirs('cli2')
+    _, artifact_dir = get_dirs("cli2")
     cwd = os.getcwd()
     os.chdir(artifact_dir)
-    logging.info(f'artifact_dir = {str(artifact_dir)}')
+    logging.info(f"artifact_dir = {str(artifact_dir)}")
     yield artifact_dir
     os.chdir(cwd)
     shutil.rmtree(artifact_dir, ignore_errors=True)
@@ -67,56 +68,56 @@ def artifact_dir2():
 
 @pytest.fixture(scope="package")
 def create_instance(artifact_dir):
-    return run(['moin', 'create-instance'])
+    return run(["moin", "create-instance"])
 
 
 @pytest.fixture(scope="package")
 def index_create(create_instance):
-    return run(['moin', 'index-create'])
+    return run(["moin", "index-create"])
 
 
 @pytest.fixture(scope="package")
 def load_help(index_create):
-    load_help_common = run(['moin', 'load-help', '-n', 'help-common'])
-    load_help_en = run(['moin', 'load-help', '-n', 'help-en'])
+    load_help_common = run(["moin", "load-help", "-n", "help-common"])
+    load_help_en = run(["moin", "load-help", "-n", "help-en"])
     return load_help_common, load_help_en
 
 
 @pytest.fixture(scope="package")
 def welcome(index_create):
-    return run(['moin', 'welcome'])
+    return run(["moin", "welcome"])
 
 
 @pytest.fixture(scope="package")
 def save_all(load_help, welcome):
-    return run(['moin', 'save', '-a', '-f', getBackupPath('backup.moin')])
+    return run(["moin", "save", "-a", "-f", getBackupPath("backup.moin")])
 
 
 @pytest.fixture(scope="package")
 def save_default(welcome):
-    return run(['moin', 'save', '-b', 'default', '-f', getBackupPath('backup_default.moin')])
+    return run(["moin", "save", "-b", "default", "-f", getBackupPath("backup_default.moin")])
 
 
 def get_crawl_server_log_path():
-    _, artifact_base_dir = get_dirs('')
-    return artifact_base_dir / 'server-crawl.log'
+    _, artifact_base_dir = get_dirs("")
+    return artifact_base_dir / "server-crawl.log"
 
 
 def get_crawl_log_path():
-    _, artifact_base_dir = get_dirs('')
-    return artifact_base_dir / 'crawl.log'
+    _, artifact_base_dir = get_dirs("")
+    return artifact_base_dir / "crawl.log"
 
 
 def get_crawl_csv_path():
-    _, artifact_base_dir = get_dirs('')
-    return artifact_base_dir / 'crawl.csv'
+    _, artifact_base_dir = get_dirs("")
+    return artifact_base_dir / "crawl.csv"
 
 
 @pytest.fixture(scope="package")
 def server(welcome, load_help, artifact_dir):
     started = False
-    server_log = open(get_crawl_server_log_path(), 'wb')
-    server = run(['moin', 'run', '-p', '9080'], server_log, wait=False)
+    server_log = open(get_crawl_server_log_path(), "wb")
+    server = run(["moin", "run", "-p", "9080"], server_log, wait=False)
     wait_count = 0
     while not started and wait_count < 12:
         wait_count += 1
@@ -124,7 +125,7 @@ def server(welcome, load_help, artifact_dir):
         try:
             check_connection(9080)
         except Exception as e:
-            logging.info(f'waiting for server startup {e}')
+            logging.info(f"waiting for server startup {e}")
         else:
             started = True
 
@@ -132,7 +133,7 @@ def server(welcome, load_help, artifact_dir):
         yield started
 
     if not server:  # unexpected error
-        logging.error(f'server is {server}')
+        logging.error(f"server is {server}")
         yield False
     else:
         if sys.platform == "win32":
@@ -146,44 +147,44 @@ def server(welcome, load_help, artifact_dir):
             server.communicate()
         server_log.close()
         if not started:
-            logging.error('server not started. server.log:')
+            logging.error("server not started. server.log:")
             try:
                 with open(get_crawl_server_log_path()) as f:
                     logging.error(f.read())
             except OSError as e:
-                logging.error(f'{repr(e)} when trying to open server log')
+                logging.error(f"{repr(e)} when trying to open server log")
             yield started
 
 
 @pytest.fixture(scope="package")
 def do_crawl(request, artifact_dir):
-    moin_dir, artifact_base_dir = get_dirs('')
+    moin_dir, artifact_base_dir = get_dirs("")
     # initialize output files
-    with open(get_crawl_log_path(), 'w'):
+    with open(get_crawl_log_path(), "w"):
         pass
-    with open(get_crawl_csv_path(), 'w'):
+    with open(get_crawl_csv_path(), "w"):
         pass
     server_started = True
     crawl_success = True
-    if settings.SITE_HOST == '127.0.0.1:9080':
-        server_started = request.getfixturevalue('server')
+    if settings.SITE_HOST == "127.0.0.1:9080":
+        server_started = request.getfixturevalue("server")
         if not server_started:
             crawl_success = False
     if server_started:
-        logging.info('starting crawl')
-        os.chdir(moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'scrapy')
+        logging.info("starting crawl")
+        os.chdir(moin_dir / "src" / "moin" / "cli" / "_tests" / "scrapy")
         try:
-            com = ['scrapy', 'crawl', '-a', f'url={settings.CRAWL_START}', 'ref_checker']
-            with open(get_crawl_log_path(), 'wb') as crawl_log:
+            com = ["scrapy", "crawl", "-a", f"url={settings.CRAWL_START}", "ref_checker"]
+            with open(get_crawl_log_path(), "wb") as crawl_log:
                 try:
-                    p = run(com, crawl_log, timeout=600, env={'MOIN_SCRAPY_CRAWL_CSV': str(get_crawl_csv_path())})
+                    p = run(com, crawl_log, timeout=600, env={"MOIN_SCRAPY_CRAWL_CSV": str(get_crawl_csv_path())})
                 except subprocess.TimeoutExpired as e:
-                    crawl_log.write(f'\n{repr(e)}\n'.encode())
+                    crawl_log.write(f"\n{repr(e)}\n".encode())
                     raise
             if p.returncode != 0:
                 crawl_success = False
             if not crawl_success:
-                logging.error('crawl failed. crawl.log:')
+                logging.error("crawl failed. crawl.log:")
                 with open(get_crawl_log_path()) as f:
                     logging.error(f.read())
         finally:
@@ -193,36 +194,36 @@ def do_crawl(request, artifact_dir):
 
 @pytest.fixture(scope="package")
 def crawl_results(request, artifact_dir) -> list[CrawlResult]:
-    _, artifact_base_dir = get_dirs('')
+    _, artifact_base_dir = get_dirs("")
     crawl_success = True
     if settings.DO_CRAWL:
-        crawl_success = request.getfixturevalue('do_crawl')
+        crawl_success = request.getfixturevalue("do_crawl")
     if crawl_success:
         try:
-            logging.info(f'reading {get_crawl_csv_path()}')
+            logging.info(f"reading {get_crawl_csv_path()}")
             with open(get_crawl_csv_path()) as f:
                 in_csv = csv.DictReader(f)
                 return [CrawlResult(**r) for r in in_csv], crawl_success
         except Exception as e:
             crawl_success = False
-            logging.error(f'exception reading crawl.csv {repr(e)}')
+            logging.error(f"exception reading crawl.csv {repr(e)}")
     if not crawl_success:
-        logging.error('crawl failed')
+        logging.error("crawl failed")
         return [], crawl_success
 
 
 @pytest.fixture(scope="package")
 def server_crawl_log(crawl_results):
     if not settings.DO_CRAWL:
-        logging.warning('using existing server-crawl.log')
+        logging.warning("using existing server-crawl.log")
     return get_crawl_server_log_path()
 
 
 @pytest.fixture
 def create_instance2(artifact_dir2):
-    return run(['moin', 'create-instance'])
+    return run(["moin", "create-instance"])
 
 
 @pytest.fixture
 def index_create2(create_instance2):
-    return run(['moin', 'index-create'])
+    return run(["moin", "index-create"])
diff --git a/src/moin/cli/_tests/default_settings.py b/src/moin/cli/_tests/default_settings.py
index a4fdb93a1..bd2493adf 100644
--- a/src/moin/cli/_tests/default_settings.py
+++ b/src/moin/cli/_tests/default_settings.py
@@ -10,9 +10,9 @@
 
 from moin.utils.iri import Iri
 
-SITE_SCHEME = 'http'
-SITE_HOST = '127.0.0.1:9080'
-SITE_WIKI_ROOT = ''  # must start with '/' if set
-CRAWL_NAMESPACE = '/help-en'
-CRAWL_START = Iri(scheme=SITE_SCHEME, authority=SITE_HOST, path=f'{SITE_WIKI_ROOT}{CRAWL_NAMESPACE}')
+SITE_SCHEME = "http"
+SITE_HOST = "127.0.0.1:9080"
+SITE_WIKI_ROOT = ""  # must start with '/' if set
+CRAWL_NAMESPACE = "/help-en"
+CRAWL_START = Iri(scheme=SITE_SCHEME, authority=SITE_HOST, path=f"{SITE_WIKI_ROOT}{CRAWL_NAMESPACE}")
 DO_CRAWL = True  # for test development, skip the crawl, load most recent crawl.csv
diff --git a/src/moin/cli/_tests/scrapy/moincrawler/items.py b/src/moin/cli/_tests/scrapy/moincrawler/items.py
index f8ee96375..e5e4e84ce 100644
--- a/src/moin/cli/_tests/scrapy/moincrawler/items.py
+++ b/src/moin/cli/_tests/scrapy/moincrawler/items.py
@@ -9,6 +9,7 @@
 from dataclasses import dataclass, fields, field
 
 from moin.utils.iri import Iri
+
 try:
     from moin.cli._tests import settings
 except ImportError:
@@ -18,12 +19,13 @@
 @dataclass
 class CrawlResult:
     """class representing result of a GET in the crawl, written to crawl.csv at spider close"""
-    url: Iri = ''
-    from_url: Iri = ''
-    from_text: str = ''  # link text if any
-    from_type: str = ''  # attribute name where this href was found
-    response_code: int = ''
-    response_exc: str = ''  # exeption if any
+
+    url: Iri = ""
+    from_url: Iri = ""
+    from_text: str = ""  # link text if any
+    from_type: str = ""  # attribute name where this href was found
+    response_code: int = ""
+    response_exc: str = ""  # exeption if any
 
     def __post_init__(self):
         if self.url:
@@ -34,12 +36,15 @@ def __post_init__(self):
             self.response_code = int(self.response_code)
 
     def __str__(self):
-        return f'url="{str(self.url)}", from_url="{str(self.from_url)}", ' +\
-               f'from_text={repr(self.from_text)}, ' + f'from_type={repr(self.from_type)}, ' +\
-               f'response_code={self.response_code}, response_exc="{self.response_exc}"'
+        return (
+            f'url="{str(self.url)}", from_url="{str(self.from_url)}", '
+            + f"from_text={repr(self.from_text)}, "
+            + f"from_type={repr(self.from_type)}, "
+            + f'response_code={self.response_code}, response_exc="{self.response_exc}"'
+        )
 
     def __repr__(self):
-        return f'CrawlResult({str(self)})'
+        return f"CrawlResult({str(self)})"
 
 
 @dataclass
@@ -48,6 +53,7 @@ class CrawlResultMatch(CrawlResult):
 
     if initialiized with relative url, prepend CRAWL_START for matching
         e.g. '/html' -> 'http:127.0.0.1:9080/help-en/html"""
+
     url_path_components: list[str] = field(default_factory=list)  # list of path components to match on
 
     def match(self, other: CrawlResult) -> bool:
@@ -71,9 +77,12 @@ def match(self, other: CrawlResult) -> bool:
     def _relative_to_absolute(url: Iri):
         """prepend CRAWL_START to relative url"""
         if url and not url.scheme:
-            url_path = url.path.fullquoted if url.path else ''
-            return Iri(scheme=settings.SITE_SCHEME, authority=settings.SITE_HOST,
-                       path=f'{settings.SITE_WIKI_ROOT}{settings.CRAWL_NAMESPACE}{url_path}')
+            url_path = url.path.fullquoted if url.path else ""
+            return Iri(
+                scheme=settings.SITE_SCHEME,
+                authority=settings.SITE_HOST,
+                path=f"{settings.SITE_WIKI_ROOT}{settings.CRAWL_NAMESPACE}{url_path}",
+            )
         return url
 
     def __post_init__(self):
@@ -82,7 +91,7 @@ def __post_init__(self):
         self.from_url = self._relative_to_absolute(self.from_url)
 
     def __str__(self):
-        return super().__str__() + f' url_path_components={repr(self.url_path_components)}'
+        return super().__str__() + f" url_path_components={repr(self.url_path_components)}"
 
     def __repr__(self):
-        return f'CrawlResultMatch({str(self)})'
+        return f"CrawlResultMatch({str(self)})"
diff --git a/src/moin/cli/_tests/scrapy/moincrawler/spiders/ref_checker.py b/src/moin/cli/_tests/scrapy/moincrawler/spiders/ref_checker.py
index cf661fe09..b94dbe933 100644
--- a/src/moin/cli/_tests/scrapy/moincrawler/spiders/ref_checker.py
+++ b/src/moin/cli/_tests/scrapy/moincrawler/spiders/ref_checker.py
@@ -40,15 +40,16 @@ class RefCheckerSpider(scrapy.Spider):
     crawl.csv will be read by test_scrapy_crawl
     original design shamelessly stolen (with permission) from
         https://www.linode.com/docs/guides/use-scrapy-to-extract-data-from-html-tags/"""
-    name = 'ref_checker'
 
-    def __init__(self, url='http://127.0.0.1:8080/', *args, **kwargs):
+    name = "ref_checker"
+
+    def __init__(self, url="http://127.0.0.1:8080/", *args, **kwargs):
         """:param url: start url for crawl, overridden by settings.CRAWL_START in moin.cli.conftest.do_crawl"""
         super().__init__(*args, **kwargs)
         self.start_urls = [url]
-        self.no_crawl_paths = ['/MoinWikiMacros/MonthCalendar']  # lots of 404s for the dates
+        self.no_crawl_paths = ["/MoinWikiMacros/MonthCalendar"]  # lots of 404s for the dates
         self.results = []
-        self.domain = ''
+        self.domain = ""
 
     @classmethod
     def from_crawler(cls, crawler, *args, **kwargs):
@@ -58,22 +59,22 @@ def from_crawler(cls, crawler, *args, **kwargs):
         return spider
 
     def spider_closed(self):
-        logging.info('entering spider_closed')
+        logging.info("entering spider_closed")
         try:
-            _, artifact_base_dir = get_dirs('')
+            _, artifact_base_dir = get_dirs("")
             for k, c in self.crawler.stats.get_stats().items():  # bubble up spider exceptions into test failures
-                if k.startswith('spider_exceptions'):
-                    logging.error(f'spider_exception: {c}')
-                    self.results.append(CrawlResult(response_exc=f'crawler stats: {k} = {c}'))
-            crawl_csv_path = os.environ.get('MOIN_SCRAPY_CRAWL_CSV', get_crawl_csv_path())
-            logging.info(f'writing {len(self.results)} to {crawl_csv_path}')
-            with open(crawl_csv_path, 'w') as fh:
-                out_csv = csv.writer(fh, lineterminator='\n')
+                if k.startswith("spider_exceptions"):
+                    logging.error(f"spider_exception: {c}")
+                    self.results.append(CrawlResult(response_exc=f"crawler stats: {k} = {c}"))
+            crawl_csv_path = os.environ.get("MOIN_SCRAPY_CRAWL_CSV", get_crawl_csv_path())
+            logging.info(f"writing {len(self.results)} to {crawl_csv_path}")
+            with open(crawl_csv_path, "w") as fh:
+                out_csv = csv.writer(fh, lineterminator="\n")
                 out_csv.writerow([f.name for f in fields(CrawlResult)])
                 for result in self.results:
                     out_csv.writerow(astuple(result))
         except Exception as e:  # noqa
-            logging.error(f'exception in spider_closed {repr(e)}')
+            logging.error(f"exception in spider_closed {repr(e)}")
             print_exc()
             raise
 
@@ -82,7 +83,7 @@ def _parse(self, response, **kwargs):
 
         requests yielded from this method are added to the crawl queue"""
         try:
-            result = response.meta['my_data']
+            result = response.meta["my_data"]
         except KeyError:
             result = CrawlResult(response.url)
         result.response_code = response.status
@@ -99,41 +100,42 @@ def _parse(self, response, **kwargs):
         parsed_uri = Iri(response.url)
         result.url = parsed_uri  # in case of redirect show final url in crawl.csv
         if not (url_path := parsed_uri.path):
-            logging.debug(f'not crawling blank path {response.url}')
+            logging.debug(f"not crawling blank path {response.url}")
             follow = False
-        if 'Content-Type' in response.headers and response.headers['Content-Type'] != b'text/html; charset=utf-8':
+        if "Content-Type" in response.headers and response.headers["Content-Type"] != b"text/html; charset=utf-8":
             logging.debug(f'not crawling Content-Type {response.headers["Content-Type"]} {response.url}')
             follow = False
         # If first response, update domain (to manage redirect cases)
         if not self.domain:
             self.domain = parsed_uri.authority
         if parsed_uri.authority != self.domain:
-            logging.debug(f'not crawling external link {response.url}')
+            logging.debug(f"not crawling external link {response.url}")
             follow = False
         if follow and parsed_uri.path:
-            if '+history' in url_path:
-                logging.debug(f'not crawling history {response.url}')
+            if "+history" in url_path:
+                logging.debug(f"not crawling history {response.url}")
                 follow = False
             url_path_str = parsed_uri.path.fullquoted
             for no_crawl_path in self.no_crawl_paths:
                 if no_crawl_path in url_path_str:
                     follow = False
-                    logging.debug(f'not crawling no_crawl_path {response.url}')
+                    logging.debug(f"not crawling no_crawl_path {response.url}")
                     break
-            if (settings.CRAWL_NAMESPACE
-                    and not url_path_str.startswith(f'{settings.SITE_WIKI_ROOT}{settings.CRAWL_NAMESPACE}')):
+            if settings.CRAWL_NAMESPACE and not url_path_str.startswith(
+                f"{settings.SITE_WIKI_ROOT}{settings.CRAWL_NAMESPACE}"
+            ):
                 logging.debug(f'not crawling outside of CRAWL_NAMESPACE "{settings.CRAWL_NAMESPACE}" {url_path_str}')
                 follow = False
         if follow:
-            for attrib in ['href', 'data-href', 'src', 'data']:
-                attrib_selectors = response.xpath(f'//*[@{attrib}]')
+            for attrib in ["href", "data-href", "src", "data"]:
+                attrib_selectors = response.xpath(f"//*[@{attrib}]")
                 for selector in attrib_selectors:
-                    link = selector.xpath(f'@{attrib}').extract_first()
-                    text = selector.xpath('text()').extract_first()
+                    link = selector.xpath(f"@{attrib}").extract_first()
+                    text = selector.xpath("text()").extract_first()
                     if isinstance(text, str):
-                        text = text.strip().replace('\n', '\\n')
+                        text = text.strip().replace("\n", "\\n")
                     new_result = CrawlResult(link, response.url, text, attrib)
-                    if new_result.url.scheme in {'javascript', 'file', 'mailto'}:
+                    if new_result.url.scheme in {"javascript", "file", "mailto"}:
                         continue
                     try:
                         request = response.follow(link, callback=self.parse, errback=self.errback)
@@ -142,10 +144,10 @@ def _parse(self, response, **kwargs):
                         # for badly formed href, append to results with response_exc
                         # so issue will be shown in test failures
                         # but do not yield as we cannot follow this link
-                        new_result.response_exc = f'unable to create request from {link}: {repr(e)}'
+                        new_result.response_exc = f"unable to create request from {link}: {repr(e)}"
                         self.results.append(new_result)
                         continue
-                    request.meta['my_data'] = new_result
+                    request.meta["my_data"] = new_result
                     yield request
 
     def parse(self, response, **kwargs):
@@ -153,7 +155,7 @@ def parse(self, response, **kwargs):
         try:
             yield from self._parse(response, **kwargs)
         except Exception as e:  # noqa
-            logging.error(f'parse exception : {repr(e)}')
+            logging.error(f"parse exception : {repr(e)}")
             print_exc()
             raise
 
@@ -163,7 +165,7 @@ def errback(self, failure):
             return
         request = failure.request
         try:
-            result = request.meta['my_data']
+            result = request.meta["my_data"]
         except KeyError:
             result = CrawlResult(request.url)
         try:
diff --git a/src/moin/cli/_tests/test_cli.py b/src/moin/cli/_tests/test_cli.py
index 0d5ca1ab2..0c1ec0d56 100644
--- a/src/moin/cli/_tests/test_cli.py
+++ b/src/moin/cli/_tests/test_cli.py
@@ -11,18 +11,18 @@
 
 
 def test_moin(artifact_dir):
-    moin_p = run(['moin'])
+    moin_p = run(["moin"])
     assert_p_succcess(moin_p)
     assert moin_p.stdout.startswith(b"Quick help")
 
 
 def test_moin_help(artifact_dir):
-    moin_p = run(['moin', 'help'])
+    moin_p = run(["moin", "help"])
     assert_p_succcess(moin_p)
     assert moin_p.stdout.startswith(b"Quick help")
 
 
 def test_moin_dash_dash_help(artifact_dir):
-    moin_p = run(['moin', '--help'])
+    moin_p = run(["moin", "--help"])
     assert_p_succcess(moin_p)
     assert moin_p.stdout.startswith(b"Usage: moin")
diff --git a/src/moin/cli/_tests/test_create_instance.py b/src/moin/cli/_tests/test_create_instance.py
index fcf301e70..293335253 100644
--- a/src/moin/cli/_tests/test_create_instance.py
+++ b/src/moin/cli/_tests/test_create_instance.py
@@ -10,6 +10,6 @@
 
 def test_create_instance(artifact_dir, create_instance):
     assert_p_succcess(create_instance)
-    assert (artifact_dir / 'wikiconfig.py').exists()
-    assert (artifact_dir / 'intermap.txt').exists()
-    assert (artifact_dir / 'wiki_local').exists()
+    assert (artifact_dir / "wikiconfig.py").exists()
+    assert (artifact_dir / "intermap.txt").exists()
+    assert (artifact_dir / "wiki_local").exists()
diff --git a/src/moin/cli/_tests/test_index.py b/src/moin/cli/_tests/test_index.py
index 34ed20772..1491f87a3 100644
--- a/src/moin/cli/_tests/test_index.py
+++ b/src/moin/cli/_tests/test_index.py
@@ -13,40 +13,40 @@
 def test_index_create(index_create):
     assert_p_succcess(index_create)
     for p in [
-              'wiki',
-              'wiki/data',
-              'wiki/data/default',
-              'wiki/data/default/meta',
-              'wiki/data/default/data',
-              'wiki/data/users',
-              'wiki/data/users/meta',
-              'wiki/data/users/data',
-              'wiki/data/userprofiles',
-              'wiki/data/userprofiles/meta',
-              'wiki/data/userprofiles/data',
-              'wiki/data/help-common',
-              'wiki/data/help-common/meta',
-              'wiki/data/help-common/data',
-              'wiki/data/help-en',
-              'wiki/data/help-en/meta',
-              'wiki/data/help-en/data',
-              'wiki/index',
-              'wiki/index/_latest_revs_0.toc',
-              'wiki/index/_all_revs_0.toc',
-            ]:
+        "wiki",
+        "wiki/data",
+        "wiki/data/default",
+        "wiki/data/default/meta",
+        "wiki/data/default/data",
+        "wiki/data/users",
+        "wiki/data/users/meta",
+        "wiki/data/users/data",
+        "wiki/data/userprofiles",
+        "wiki/data/userprofiles/meta",
+        "wiki/data/userprofiles/data",
+        "wiki/data/help-common",
+        "wiki/data/help-common/meta",
+        "wiki/data/help-common/data",
+        "wiki/data/help-en",
+        "wiki/data/help-en/meta",
+        "wiki/data/help-en/data",
+        "wiki/index",
+        "wiki/index/_latest_revs_0.toc",
+        "wiki/index/_all_revs_0.toc",
+    ]:
         assert Path(p).exists()
 
 
 def test_index_dump(load_help):
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
     assert_p_succcess(index_dump)
     items = read_index_dump_latest_revs(index_dump.stdout.decode())
-    cats = [i for i in items if 'cat.jpg' in i['name']]
+    cats = [i for i in items if "cat.jpg" in i["name"]]
     assert len(cats) == 1
     cat = cats[0]
     assert "contenttype" in cat
-    assert cat["contenttype"] == 'image/jpeg'
+    assert cat["contenttype"] == "image/jpeg"
     assert "namespace" in cat
-    assert cat["namespace"] == 'help-common'
+    assert cat["namespace"] == "help-common"
     assert "rev_number" in cat
     assert cat["rev_number"] == 1
diff --git a/src/moin/cli/_tests/test_modify_item.py b/src/moin/cli/_tests/test_modify_item.py
index 8002b1ae5..627241244 100644
--- a/src/moin/cli/_tests/test_modify_item.py
+++ b/src/moin/cli/_tests/test_modify_item.py
@@ -16,13 +16,13 @@
 
 def validate_meta(expected, actual, message):
     for d in expected, actual:
-        del d['address']  # remove elements which may not match
-        del d['mtime']
+        del d["address"]  # remove elements which may not match
+        del d["mtime"]
         try:
-            del d['userid']
+            del d["userid"]
         except KeyError:
             pass
-        for k in ['externallinks', 'itemtransclusions', 'itemlinks']:
+        for k in ["externallinks", "itemtransclusions", "itemlinks"]:
             d[k] = set(d[k])  # ignore ordering for these keys
     assert expected == actual, message
 
@@ -37,50 +37,56 @@ def test_welcome(welcome):
 
 
 def test_dump_help(load_help):
-    moin_dir, artifact_dir = get_dirs('cli')
-    help_dir = Path('my_help')
-    source_help_dir = moin_dir / 'src' / 'moin' / 'help'
-    with open(source_help_dir / 'help-en' / 'Home.data', newline='') as f:
-        crlf_option = '--crlf' if '\r\n' in f.read() else '--no-crlf'
-    for help_subdir in ['help-common', 'help-en']:
+    moin_dir, artifact_dir = get_dirs("cli")
+    help_dir = Path("my_help")
+    source_help_dir = moin_dir / "src" / "moin" / "help"
+    with open(source_help_dir / "help-en" / "Home.data", newline="") as f:
+        crlf_option = "--crlf" if "\r\n" in f.read() else "--no-crlf"
+    for help_subdir in ["help-common", "help-en"]:
         help_subdir_path = help_dir / help_subdir
         if not help_subdir_path.exists():
             help_subdir_path.mkdir(parents=True)
-        dump_help = run(['moin', 'dump-help', '-n', help_subdir, '-p', help_dir, crlf_option])
+        dump_help = run(["moin", "dump-help", "-n", help_subdir, "-p", help_dir, crlf_option])
         assert_p_succcess(dump_help)
         source_help_subdir = source_help_dir / help_subdir
-        expected_data_file_names = {p.name for p in source_help_subdir.glob('*.data')}
-        data_file_names = {p.name for p in help_subdir_path.glob('*.data')}
+        expected_data_file_names = {p.name for p in source_help_subdir.glob("*.data")}
+        data_file_names = {p.name for p in help_subdir_path.glob("*.data")}
         assert expected_data_file_names == data_file_names
         for data_file_name in expected_data_file_names:
-            with open(help_subdir_path / data_file_name, 'rb') as f:
+            with open(help_subdir_path / data_file_name, "rb") as f:
                 data = f.read()
-            with open(source_help_subdir / data_file_name, 'rb') as f:
+            with open(source_help_subdir / data_file_name, "rb") as f:
                 expected_data = f.read()
-            assert expected_data == data, f'{data_file_name} in dump not matching to source'
-            meta_file_name = f'{str(data_file_name)[0:-5]}.meta'
+            assert expected_data == data, f"{data_file_name} in dump not matching to source"
+            meta_file_name = f"{str(data_file_name)[0:-5]}.meta"
             with open(help_subdir_path / meta_file_name) as f:
                 meta = json.load(f)
             with open(source_help_subdir / meta_file_name) as f:
                 expected_meta = json.load(f)
-            validate_meta(expected_meta, meta, f'{source_help_subdir / meta_file_name} != {help_subdir_path / meta_file_name}')
+            validate_meta(
+                expected_meta, meta, f"{source_help_subdir / meta_file_name} != {help_subdir_path / meta_file_name}"
+            )
 
 
 def test_item_get(load_help):
     """extract an item from help and validate data and meta match original files in moin/help"""
-    item_get = run(['moin', 'item-get', '-n', 'help-common/cat.jpg', '-m', 'cat.meta', '-d', 'cat.data'])
+    item_get = run(["moin", "item-get", "-n", "help-common/cat.jpg", "-m", "cat.meta", "-d", "cat.data"])
     assert_p_succcess(item_get)
-    assert Path('cat.data').exists()
-    assert Path('cat.meta').exists()
-    moin_dir, _ = get_dirs('cli')
-    with open('cat.meta') as f:
+    assert Path("cat.data").exists()
+    assert Path("cat.meta").exists()
+    moin_dir, _ = get_dirs("cli")
+    with open("cat.meta") as f:
         meta_cat = json.load(f)
-    with open(moin_dir / 'src' / 'moin' / 'help' / 'help-common' / 'cat.jpg.meta') as f:
+    with open(moin_dir / "src" / "moin" / "help" / "help-common" / "cat.jpg.meta") as f:
         meta_cat_expected = json.load(f)
-    validate_meta(meta_cat_expected, meta_cat, f"{moin_dir / 'src' / 'moin' / 'help' / 'help-common' / 'cat.jpg.meta'} != cat.meta")
-    with open('cat.data', 'rb') as f:
+    validate_meta(
+        meta_cat_expected,
+        meta_cat,
+        f"{moin_dir / 'src' / 'moin' / 'help' / 'help-common' / 'cat.jpg.meta'} != cat.meta",
+    )
+    with open("cat.data", "rb") as f:
         cat_bytes = f.read()
-    with open(moin_dir / 'src' / 'moin' / 'help' / 'help-common' / 'cat.jpg.data', 'rb') as f:
+    with open(moin_dir / "src" / "moin" / "help" / "help-common" / "cat.jpg.data", "rb") as f:
         cat_bytes_expected = f.read()
     assert cat_bytes_expected == cat_bytes
 
@@ -91,23 +97,27 @@ def test_item_put(index_create2):
     include an item with non-ascii characters in name, tags and summary
 
     check for ability to handle non-ascii characters in index-dump"""
-    for page in ['Home', 'help-common/Home', 'MyRussianPage']:
-        page_filename = page.replace('/', '-')
-        item_get_fail = run(['moin', 'item-get', '-n', page, '-m', f'{page_filename}.meta', '-d', f'{page_filename}.data'])
+    for page in ["Home", "help-common/Home", "MyRussianPage"]:
+        page_filename = page.replace("/", "-")
+        item_get_fail = run(
+            ["moin", "item-get", "-n", page, "-m", f"{page_filename}.meta", "-d", f"{page_filename}.data"]
+        )
         assert item_get_fail.returncode != 0
-        moin_dir, _ = get_dirs('')
-        data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
-        item_put = run(['moin', 'item-put', '-m', data_dir / f'{page_filename}.meta', '-d', data_dir / f'{page_filename}.data'])
+        moin_dir, _ = get_dirs("")
+        data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
+        item_put = run(
+            ["moin", "item-put", "-m", data_dir / f"{page_filename}.meta", "-d", data_dir / f"{page_filename}.data"]
+        )
         assert_p_succcess(item_put)
-        item_get = run(['moin', 'item-get', '-n', page, '-m', f'{page_filename}.meta', '-d', f'{page_filename}.data'])
+        item_get = run(["moin", "item-get", "-n", page, "-m", f"{page_filename}.meta", "-d", f"{page_filename}.data"])
         assert_p_succcess(item_get)
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
     index_dump_data = read_index_dump_latest_revs(index_dump.stdout.decode())
-    my_items = [i for i in index_dump_data if 'МояСтраница' in i['name']]
+    my_items = [i for i in index_dump_data if "МояСтраница" in i["name"]]
     assert 1 == len(my_items)
     my_item = my_items[0]
-    assert "тест на использование ру́сского алфави́т" == my_item['summary']
-    assert ["русский"] == my_item['tags']
+    assert "тест на использование ру́сского алфави́т" == my_item["summary"]
+    assert ["русский"] == my_item["tags"]
 
 
 def test_item_rev(index_create2):
@@ -120,135 +130,147 @@ def test_item_rev(index_create2):
     *  MyPage-v1 does not have newline at end in storage (size = 16)
     *  MyPage-v2 has newline at end in storage (size = 18)
     *  in both cases, item-get will write file with \n at end of file"""
-    moin_dir, _ = get_dirs('cli2')
-    data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
-    put1 = run(['moin', 'item-put', '-m', data_dir / 'MyPage-v1.meta', '-d', data_dir / 'MyPage-v1.data', '-o'])
+    moin_dir, _ = get_dirs("cli2")
+    data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
+    put1 = run(["moin", "item-put", "-m", data_dir / "MyPage-v1.meta", "-d", data_dir / "MyPage-v1.data", "-o"])
     assert_p_succcess(put1)
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    put2 = run(['moin', 'item-put', '-m', data_dir / 'MyPage-v2.meta', '-d', data_dir / 'MyPage-v2.data', '-o'])
+    put2 = run(["moin", "item-put", "-m", data_dir / "MyPage-v2.meta", "-d", data_dir / "MyPage-v2.data", "-o"])
     assert_p_succcess(put2)
-    item_get2 = run(['moin', 'item-get', '-n', 'MyPage', '-m', 'MyPage-v2.meta', '-d', 'MyPage-v2.data', '--crlf'])
+    item_get2 = run(["moin", "item-get", "-n", "MyPage", "-m", "MyPage-v2.meta", "-d", "MyPage-v2.data", "--crlf"])
     assert_p_succcess(item_get2)
-    with open('MyPage-v2.data', newline='') as f:
-        assert f.read() == 'MyPage version 2\r\n'
-    with open('MyPage-v2.meta') as f:
+    with open("MyPage-v2.data", newline="") as f:
+        assert f.read() == "MyPage version 2\r\n"
+    with open("MyPage-v2.meta") as f:
         v2_meta = json.load(f)
-    assert v2_meta['size'] == 18  # newline at end is 2 chars \r\n
-    with open(data_dir / 'MyPage-v1.meta') as f:
+    assert v2_meta["size"] == 18  # newline at end is 2 chars \r\n
+    with open(data_dir / "MyPage-v1.meta") as f:
         v1_meta = json.load(f)
-    v1_revid = v1_meta['revid']
-    assert v1_meta['size'] == 16
-    item_get1 = run(['moin', 'item-get', '-n', 'MyPage', '-m', 'MyPage-v1.meta', '-d', 'MyPage-v1.data', '-r', v1_revid, '--crlf'])
+    v1_revid = v1_meta["revid"]
+    assert v1_meta["size"] == 16
+    item_get1 = run(
+        ["moin", "item-get", "-n", "MyPage", "-m", "MyPage-v1.meta", "-d", "MyPage-v1.data", "-r", v1_revid, "--crlf"]
+    )
     assert_p_succcess(item_get1)
-    with open('MyPage-v1.data', newline='') as f:
-        assert f.read() == 'MyPage version 1\r\n'
-    put3 = run(['moin', 'item-put', '-m', 'MyPage-v1.meta', '-d', 'MyPage-v1.data'])
+    with open("MyPage-v1.data", newline="") as f:
+        assert f.read() == "MyPage version 1\r\n"
+    put3 = run(["moin", "item-put", "-m", "MyPage-v1.meta", "-d", "MyPage-v1.data"])
     assert_p_succcess(put3)
-    item_get1_1 = run(['moin', 'item-get', '-n', 'MyPage', '-m', 'MyPage-v1_1.meta', '-d', 'MyPage-v1_1.data', '--crlf'])
+    item_get1_1 = run(
+        ["moin", "item-get", "-n", "MyPage", "-m", "MyPage-v1_1.meta", "-d", "MyPage-v1_1.data", "--crlf"]
+    )
     assert_p_succcess(item_get1_1)
-    with open('MyPage-v1_1.data', newline='') as f:
-        assert f.read() == 'MyPage version 1\r\n'
-    with open('MyPage-v1_1.meta') as f:
+    with open("MyPage-v1_1.data", newline="") as f:
+        assert f.read() == "MyPage version 1\r\n"
+    with open("MyPage-v1_1.meta") as f:
         v1_1_meta = json.load(f)
-    assert v1_1_meta['revid'] != v1_revid  # validate absence of -o option
-    assert v1_1_meta['size'] == 16  # validate no newline at end in storage
+    assert v1_1_meta["revid"] != v1_revid  # validate absence of -o option
+    assert v1_1_meta["size"] == 16  # validate no newline at end in storage
 
 
 def test_validate_metadata(index_create2):
-    moin_dir, _ = get_dirs('')
-    data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'MyPage-v1.meta', '-d', data_dir / 'MyPage-v1.data', '-o'])
+    moin_dir, _ = get_dirs("")
+    data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
+    item_put = run(["moin", "item-put", "-m", data_dir / "MyPage-v1.meta", "-d", data_dir / "MyPage-v1.data", "-o"])
     assert_p_succcess(item_put)
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'MyPage-v2.meta', '-d', data_dir / 'MyPage-v2.data', '-o'])
+    item_put = run(["moin", "item-put", "-m", data_dir / "MyPage-v2.meta", "-d", data_dir / "MyPage-v2.data", "-o"])
     assert_p_succcess(item_put)
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-v'])
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-v"])
     assert_p_succcess(validate)
     outlines = validate.stdout.splitlines()
     assert 1 == len(outlines)
-    assert b'0 items with invalid metadata found' == outlines[0]
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'Corrupt.meta', '-d', data_dir / 'Corrupt.data', '-o'])
+    assert b"0 items with invalid metadata found" == outlines[0]
+    item_put = run(["moin", "item-put", "-m", data_dir / "Corrupt.meta", "-d", data_dir / "Corrupt.data", "-o"])
     assert_p_succcess(item_put)
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'Corrupt2.meta', '-d', data_dir / 'Corrupt2.data', '-o'])
+    item_put = run(["moin", "item-put", "-m", data_dir / "Corrupt2.meta", "-d", data_dir / "Corrupt2.data", "-o"])
     assert_p_succcess(item_put)
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'Corrupt3.meta', '-d', data_dir / 'Corrupt3.data', '-o'])
+    item_put = run(["moin", "item-put", "-m", data_dir / "Corrupt3.meta", "-d", data_dir / "Corrupt3.data", "-o"])
     assert_p_succcess(item_put)
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-v'])
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-v"])
     assert_p_succcess(validate)
     outlines = validate.stdout.decode().splitlines()
     assert 4 == len(outlines)
-    rev_id1 = '7ed018d7ceda49409e18b8efb914f5ff'  # Corrupt.meta
-    rev_id2 = '0a2f1b476b6c42be80908b3b799df3fd'  # Corrupt2.meta
-    rev_id3 = '39c8fe8da0a048c0b7839bf8aa02cd04'  # Corrupt3.meta
-    rev_id4 = '484e73725601407e9f9ab0bcaa151fb6'  # MyPage-v1.meta
-    rev_id5 = 'b0b07c407c3143aabc4d34aac1b1d303'  # MyPage-v2.meta
+    rev_id1 = "7ed018d7ceda49409e18b8efb914f5ff"  # Corrupt.meta
+    rev_id2 = "0a2f1b476b6c42be80908b3b799df3fd"  # Corrupt2.meta
+    rev_id3 = "39c8fe8da0a048c0b7839bf8aa02cd04"  # Corrupt3.meta
+    rev_id4 = "484e73725601407e9f9ab0bcaa151fb6"  # MyPage-v1.meta
+    rev_id5 = "b0b07c407c3143aabc4d34aac1b1d303"  # MyPage-v2.meta
     outlines_by_rev_id = {}
     for outline in outlines:
         words = iter(outline.split())
         for word in words:
-            if word == 'rev_id:':
+            if word == "rev_id:":
                 outlines_by_rev_id[next(words)] = outline
                 break
     assert {rev_id1, rev_id2, rev_id3} == set(outlines_by_rev_id.keys())
-    assert 'size_error name: Home item: cbd6fc46f88740acbc1dca90bb1eb8f3 rev_number: 1 rev_id: 7ed018d7ceda49409e18b8efb914f5ff '\
-           'meta_size: 8 real_size: 11' == outlines_by_rev_id[rev_id1]
-    assert 'sha1_error name: Page2 item: 9999989aca5e45cc8683432f986a0e50 rev_number: 1 rev_id: 0a2f1b476b6c42be80908b3b799df3fd '\
-           'meta_sha1: 25ff6d28976a9e0feb97710a0c4b08ae197a0000 '\
-           'real_sha1: 25ff6d28976a9e0feb97710a0c4b08ae197afbfe' == outlines_by_rev_id[rev_id2]
-    assert 'parentid_error name: Page3 item: 3c7e36466726441faf6d7d266ac224e2 rev_number: 2 rev_id: 39c8fe8da0a048c0b7839bf8aa02cd04 '\
-           'meta_parentid: 002e5210cc884010b0dd75a1c337032d correct_parentid: None meta_revision_number: 2' \
-           == outlines_by_rev_id[rev_id3]
-    assert '3 items with invalid metadata found' == outlines[3]
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-f'])
+    assert (
+        "size_error name: Home item: cbd6fc46f88740acbc1dca90bb1eb8f3 rev_number: 1 rev_id: 7ed018d7ceda49409e18b8efb914f5ff "
+        "meta_size: 8 real_size: 11" == outlines_by_rev_id[rev_id1]
+    )
+    assert (
+        "sha1_error name: Page2 item: 9999989aca5e45cc8683432f986a0e50 rev_number: 1 rev_id: 0a2f1b476b6c42be80908b3b799df3fd "
+        "meta_sha1: 25ff6d28976a9e0feb97710a0c4b08ae197a0000 "
+        "real_sha1: 25ff6d28976a9e0feb97710a0c4b08ae197afbfe" == outlines_by_rev_id[rev_id2]
+    )
+    assert (
+        "parentid_error name: Page3 item: 3c7e36466726441faf6d7d266ac224e2 rev_number: 2 rev_id: 39c8fe8da0a048c0b7839bf8aa02cd04 "
+        "meta_parentid: 002e5210cc884010b0dd75a1c337032d correct_parentid: None meta_revision_number: 2"
+        == outlines_by_rev_id[rev_id3]
+    )
+    assert "3 items with invalid metadata found" == outlines[3]
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-f"])
     assert_p_succcess(validate)
     outlines = validate.stdout.splitlines()
     assert 1 == len(outlines)
-    assert b'3 items with invalid metadata found and fixed' == outlines[0]
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-v'])
+    assert b"3 items with invalid metadata found and fixed" == outlines[0]
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-v"])
     assert_p_succcess(validate)
     outlines = validate.stdout.splitlines()
     assert 1 == len(outlines)
-    assert b'0 items with invalid metadata found' == outlines[0]
+    assert b"0 items with invalid metadata found" == outlines[0]
     # validate index is updated
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
     metas = {m[REVID]: m for m in read_index_dump(index_dump.stdout.decode())}
     assert {rev_id1, rev_id2, rev_id3, rev_id4, rev_id5} == set(metas.keys())
     assert 11 == metas[rev_id1][SIZE]
     assert PARENTID not in metas[rev_id3]
     # create a repeated revision_number
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'MyPage-v2.meta', '-d', data_dir / 'MyPage-v2.data'])
+    item_put = run(["moin", "item-put", "-m", data_dir / "MyPage-v2.meta", "-d", data_dir / "MyPage-v2.data"])
     assert_p_succcess(item_put)
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-v', '-f'])
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-v", "-f"])
     assert_p_succcess(validate)
     outlines = validate.stdout.decode().splitlines()
-    assert '1 items with invalid metadata found and fixed' == outlines[-1]
+    assert "1 items with invalid metadata found and fixed" == outlines[-1]
     assert 3 == len(outlines)
     outlines_by_error = {}
     for outline in outlines[0:2]:
         words = outline.split()
         outlines_by_error[words[0]] = outline
-    assert {'parentid_error', 'revision_number_error'} == set(outlines_by_error.keys())
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
-    rev_numbers = {m[REV_NUMBER]: m for m in read_index_dump(index_dump.stdout.decode()) if m[NAMES] == 'MyPage'}
+    assert {"parentid_error", "revision_number_error"} == set(outlines_by_error.keys())
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
+    rev_numbers = {m[REV_NUMBER]: m for m in read_index_dump(index_dump.stdout.decode()) if m[NAMES] == "MyPage"}
     assert {1, 2, 3} == set(rev_numbers.keys())
     assert rev_numbers[1][REVID] == rev_id4
     assert rev_numbers[2][REVID] == rev_id5
 
 
 def test_validate_metadata_missing_rev_num(index_create2):
-    moin_dir, _ = get_dirs('')
-    data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'MyPage-vblank.meta', '-d', data_dir / 'MyPage-v1.data', '-o'])
+    moin_dir, _ = get_dirs("")
+    data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
+    item_put = run(["moin", "item-put", "-m", data_dir / "MyPage-vblank.meta", "-d", data_dir / "MyPage-v1.data", "-o"])
     assert_p_succcess(item_put)
     sleep(1.1)  # MTIME is stored as int in index file, sleep here to guarntee proper sorting of revs for index_revision
-    item_put = run(['moin', 'item-put', '-m', data_dir / 'MyPage-vblank2.meta', '-d', data_dir / 'MyPage-v1.data', '-o'])
+    item_put = run(
+        ["moin", "item-put", "-m", data_dir / "MyPage-vblank2.meta", "-d", data_dir / "MyPage-v1.data", "-o"]
+    )
     assert_p_succcess(item_put)
-    validate = run(['moin', 'maint-validate-metadata', '-b', 'default', '-v', '-f'])
+    validate = run(["moin", "maint-validate-metadata", "-b", "default", "-v", "-f"])
     assert_p_succcess(validate)
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
     print(index_dump.stdout.decode())
-    rev_numbers = {m[REV_NUMBER]: m for m in read_index_dump(index_dump.stdout.decode()) if m[NAMES] == 'MyPage'}
+    rev_numbers = {m[REV_NUMBER]: m for m in read_index_dump(index_dump.stdout.decode()) if m[NAMES] == "MyPage"}
     assert {1, 2} == set(rev_numbers.keys())
diff --git a/src/moin/cli/_tests/test_scrapy_crawl.py b/src/moin/cli/_tests/test_scrapy_crawl.py
index adb45d8fe..a5e99382a 100644
--- a/src/moin/cli/_tests/test_scrapy_crawl.py
+++ b/src/moin/cli/_tests/test_scrapy_crawl.py
@@ -23,17 +23,21 @@
 class TestSiteCrawl:
     EXPECTED_404 = [
         CrawlResultMatch(
-            url_path_components=['MissingSubItem', 'MissingSubitem', 'MissingPage', 'MissingItem', 'MissingSibling']),
+            url_path_components=["MissingSubItem", "MissingSubitem", "MissingPage", "MissingItem", "MissingSibling"]
+        )
     ]
     KNOWN_ISSUES = [
-        CrawlResultMatch(url=Iri(scheme=settings.SITE_SCHEME, authority=settings.SITE_HOST,
-                                 path='/+get/help-common/logo.png'),
-                         from_url='/markdown'),  # only with wiki_root
-        CrawlResultMatch(url='http://localhost:8080/+serve/ckeditor/plugins/smiley/images/shades_smile.gif',
-                         from_url='/html'),
-        CrawlResultMatch(url=Iri(scheme=settings.SITE_SCHEME, authority=settings.SITE_HOST, path='/users/Home'),
-                         from_url='/html')  # only with wiki_root
-        ]
+        CrawlResultMatch(
+            url=Iri(scheme=settings.SITE_SCHEME, authority=settings.SITE_HOST, path="/+get/help-common/logo.png"),
+            from_url="/markdown",
+        ),  # only with wiki_root
+        CrawlResultMatch(
+            url="http://localhost:8080/+serve/ckeditor/plugins/smiley/images/shades_smile.gif", from_url="/html"
+        ),
+        CrawlResultMatch(
+            url=Iri(scheme=settings.SITE_SCHEME, authority=settings.SITE_HOST, path="/users/Home"), from_url="/html"
+        ),  # only with wiki_root
+    ]
     line_number = 0
     line_buffer = []
     gathered_log_lines = {}
@@ -52,21 +56,24 @@ def is_expected_404(self, r):
         return self._matches_one_of(r, self.EXPECTED_404)
 
     def test_home_page(self, crawl_results):
-        assert crawl_results[1], f'crawl failed, check {get_crawl_log_path()}'
-        for line in open(get_crawl_log_path(), 'rb'):
-            if b'crawl.csv' in line:
-                logging.info(f'{line} from {get_crawl_log_path()}')
+        assert crawl_results[1], f"crawl failed, check {get_crawl_log_path()}"
+        for line in open(get_crawl_log_path(), "rb"):
+            if b"crawl.csv" in line:
+                logging.info(f"{line} from {get_crawl_log_path()}")
         assert len(crawl_results[0]) > 0
         r = crawl_results[0][0]
-        expected = CrawlResultMatch(url='/Home')
-        assert expected.match(r), f'unexpected redirect for / {r}'
+        expected = CrawlResultMatch(url="/Home")
+        assert expected.match(r), f"unexpected redirect for / {r}"
 
     def test_200(self, crawl_results):
-        assert crawl_results[1], f'crawl failed, check {get_crawl_log_path()}'
+        assert crawl_results[1], f"crawl failed, check {get_crawl_log_path()}"
         failures = []
-        for r in [r for r in crawl_results[0] if r.url
-                  and r.url.authority == settings.SITE_HOST and not self.is_known_issue(r)]:
-            if 'Discussion' in r.url.path:
+        for r in [
+            r
+            for r in crawl_results[0]
+            if r.url and r.url.authority == settings.SITE_HOST and not self.is_known_issue(r)
+        ]:
+            if "Discussion" in r.url.path:
                 expected = {200, 404}
             elif self.is_expected_404(r):
                 expected = {404}
@@ -74,16 +81,16 @@ def test_200(self, crawl_results):
                 expected = {200}
             if r.response_code not in expected:
                 failures.append(r)
-                logging.error(f'expected {expected} got {r.response_code} for {r}')
+                logging.error(f"expected {expected} got {r.response_code} for {r}")
         assert len(failures) == 0
 
-    @pytest.mark.xfail(reason='issue #1414 - remaining bad links in help')
+    @pytest.mark.xfail(reason="issue #1414 - remaining bad links in help")
     def test_expected_failures(self, crawl_results):
-        assert crawl_results[1], f'crawl failed, check {get_crawl_log_path()}'
+        assert crawl_results[1], f"crawl failed, check {get_crawl_log_path()}"
         failures = []
         for r in [r for r in crawl_results[0] if self.is_known_issue(r)]:
             if r.response_code != 200:
-                logging.info(f'known issue {r}')
+                logging.info(f"known issue {r}")
                 failures.append(r)
         assert len(failures) == 0
 
@@ -92,7 +99,7 @@ def test_known_issues_exist(self, crawl_results):
         """enable this test to check for KNOWN_ISSUES which can be removed
         after removing, be sure to confirm by crawling a host with non-blank SITE_WIKI_ROOT
         as some issues only exist when moin is running behind apache"""
-        assert crawl_results[1], f'crawl failed, check {get_crawl_log_path()}'
+        assert crawl_results[1], f"crawl failed, check {get_crawl_log_path()}"
         fixed = []
         for m in self.KNOWN_ISSUES:
             seen = False
@@ -106,19 +113,19 @@ def test_known_issues_exist(self, crawl_results):
                     my_not_fixed.append(r)
             if not my_not_fixed:
                 for r in my_fixed:
-                    logging.error(f'{r} matching {m} is fixed')
+                    logging.error(f"{r} matching {m} is fixed")
                     fixed.append((m, r))
             if not seen:
-                logging.error(f'match {m} not seen')
+                logging.error(f"match {m} not seen")
                 fixed.append((m, None))
         assert len(fixed) == 0
 
     def test_valid_request(self, crawl_results):
-        assert crawl_results[1], f'crawl failed, check {get_crawl_log_path()}'
+        assert crawl_results[1], f"crawl failed, check {get_crawl_log_path()}"
         failures = []
         for r in [r for r in crawl_results[0] if not self.is_known_issue(r)]:
             if not r.response_code:
-                logging.error(f'no response code for {r}')
+                logging.error(f"no response code for {r}")
                 failures.append(r)
         assert len(failures) == 0
 
@@ -149,8 +156,8 @@ def test_server_log(self, server_crawl_log):
             error_count = 0
             while self._next_server_log_line():
                 # when error line is seen, print including traceback block with two leading and two trailing lines
-                start_traceback = ('Traceback' in self.line)
-                is_error = (' ERROR ' in self.line)
+                start_traceback = "Traceback" in self.line
+                is_error = " ERROR " in self.line
                 if is_error or start_traceback:
                     error_count += 1
                 if not is_traceback:
@@ -168,8 +175,8 @@ def test_server_log(self, server_crawl_log):
                 if gather or trailing_line_count:
                     self._gather_current_log_line()
                     if is_traceback:
-                        if not (self.line.startswith(' ') or start_traceback):
+                        if not (self.line.startswith(" ") or start_traceback):
                             is_traceback = False
         for i, server_log_line in self.gathered_log_lines.items():
-            logging.info(f'{server_crawl_log.name} {i}: {server_log_line.strip()}')
-        assert 0 == error_count, f'{error_count} errors in {str(server_crawl_log)}'
+            logging.info(f"{server_crawl_log.name} {i}: {server_log_line.strip()}")
+        assert 0 == error_count, f"{error_count} errors in {str(server_crawl_log)}"
diff --git a/src/moin/cli/_tests/test_serialization.py b/src/moin/cli/_tests/test_serialization.py
index a58511278..41354d623 100644
--- a/src/moin/cli/_tests/test_serialization.py
+++ b/src/moin/cli/_tests/test_serialization.py
@@ -20,16 +20,18 @@
 
 def test_save_all(artifact_dir, save_all):
     assert_p_succcess(save_all)
-    assert getBackupPath('backup.moin').exists()
+    assert getBackupPath("backup.moin").exists()
 
 
 def load(restore_dir, backup_name, artifact_dir, args=None):
     restore_dir.mkdir()
     os.chdir(restore_dir)
     try:
-        for command in (['moin', 'create-instance'],
-                        ['moin', 'index-create'],
-                        ['moin', 'load', '-f', getBackupPath(backup_name)] + (args if args else []),):
+        for command in (
+            ["moin", "create-instance"],
+            ["moin", "index-create"],
+            ["moin", "load", "-f", getBackupPath(backup_name)] + (args if args else []),
+        ):
             p = run(command)
             assert_p_succcess(p)
     finally:
@@ -37,31 +39,31 @@ def load(restore_dir, backup_name, artifact_dir, args=None):
 
 
 def test_load_all(artifact_dir, save_all):
-    restore_dir = Path(artifact_dir / 'restore_all')
-    load(restore_dir, 'backup.moin', artifact_dir)
+    restore_dir = Path(artifact_dir / "restore_all")
+    load(restore_dir, "backup.moin", artifact_dir)
 
 
 def test_save_default_ns(artifact_dir, save_default):
     assert_p_succcess(save_default)
-    assert getBackupPath('backup_default.moin').exists()
+    assert getBackupPath("backup_default.moin").exists()
 
 
 def test_load_default_ns(artifact_dir, save_default):
-    moin_dir, _ = get_dirs('')
-    welcome_dir = moin_dir / 'src' / 'moin' / 'help' / 'welcome'
+    moin_dir, _ = get_dirs("")
+    welcome_dir = moin_dir / "src" / "moin" / "help" / "welcome"
     expected_metas = {}
-    for data_fn in welcome_dir.glob('*.meta'):
+    for data_fn in welcome_dir.glob("*.meta"):
         with open(data_fn) as f:
             meta = json.load(f)
-            if meta[NAMESPACE] != '':
+            if meta[NAMESPACE] != "":
                 continue
             name = meta[NAME][0]
             expected_metas[name] = meta
-    restore_dir = Path(artifact_dir / 'restore_default')
-    load(restore_dir, 'backup_default.moin', artifact_dir)
+    restore_dir = Path(artifact_dir / "restore_default")
+    load(restore_dir, "backup_default.moin", artifact_dir)
     os.chdir(restore_dir)
     try:
-        index_dump = run(['moin', 'index-dump', '--no-truncate'])
+        index_dump = run(["moin", "index-dump", "--no-truncate"])
         metas = {}
         contents = {}
         items = read_index_dump_latest_revs(index_dump.stdout.decode())
@@ -77,9 +79,9 @@ def test_load_default_ns(artifact_dir, save_default):
                     if k == MTIME:
                         continue  # load replaces all mtimes
                     expected_v = expected_meta[k]
-                    assert expected_v == v, f'key {k} {name}.meta = {repr(expected_v)} index-dump = {repr(v)}'
+                    assert expected_v == v, f"key {k} {name}.meta = {repr(expected_v)} index-dump = {repr(v)}"
         for name, content in contents.items():
-            with open(welcome_dir / f'{name}.data') as f:
+            with open(welcome_dir / f"{name}.data") as f:
                 expected_content = f.read()
                 assert expected_content, content
     finally:
@@ -87,28 +89,28 @@ def test_load_default_ns(artifact_dir, save_default):
 
 
 def test_load_new_ns(artifact_dir, save_default):
-    restore_dir = Path(artifact_dir / 'restore_new_ns')
-    load(restore_dir, 'backup_default.moin', artifact_dir, ['-o', '', '-n', 'help-en'])
+    restore_dir = Path(artifact_dir / "restore_new_ns")
+    load(restore_dir, "backup_default.moin", artifact_dir, ["-o", "", "-n", "help-en"])
     os.chdir(restore_dir)
     try:
-        index_dump = run(['moin', 'index-dump', '--no-truncate'])
+        index_dump = run(["moin", "index-dump", "--no-truncate"])
         items = list(read_index_dump_latest_revs(index_dump.stdout.decode()))
         assert 1 == len(items)
         item = items[0]
-        assert ['Home'] == item[NAME]
-        assert 'help-en' == item[BACKENDNAME]
+        assert ["Home"] == item[NAME]
+        assert "help-en" == item[BACKENDNAME]
     finally:
         os.chdir(artifact_dir)  # insure we return to archive_dir for other tests
 
 
 def test_load_corrupt(artifact_dir2, index_create2):
-    moin_dir, _ = get_dirs('cli')
-    data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
+    moin_dir, _ = get_dirs("cli")
+    data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
     # item-put below errors out without the -o, see moin.storage.backends.stores.store
-    p = run(['moin', 'item-put', '-m', data_dir / 'Corrupt.meta', '-d', data_dir / 'Corrupt.data', '-o'])
+    p = run(["moin", "item-put", "-m", data_dir / "Corrupt.meta", "-d", data_dir / "Corrupt.data", "-o"])
     assert_p_succcess(p)
-    backup_name = 'backup_corrupt.moin'
-    p = run(['moin', 'save', '-b', 'default', '-f', getBackupPath(backup_name)])
+    backup_name = "backup_corrupt.moin"
+    p = run(["moin", "save", "-b", "default", "-f", getBackupPath(backup_name)])
     assert_p_succcess(p)
-    restore_dir = Path(artifact_dir2 / 'restore_new_ns')
+    restore_dir = Path(artifact_dir2 / "restore_new_ns")
     load(restore_dir, backup_name, artifact_dir2)
diff --git a/src/moin/cli/_tests/test_set_meta.py b/src/moin/cli/_tests/test_set_meta.py
index 64089325a..dc05de24d 100644
--- a/src/moin/cli/_tests/test_set_meta.py
+++ b/src/moin/cli/_tests/test_set_meta.py
@@ -11,13 +11,13 @@
 
 
 def test_set_meta(index_create2):
-    moin_dir, _ = get_dirs('')
-    data_dir = moin_dir / 'src' / 'moin' / 'cli' / '_tests' / 'data'
-    put = run(['moin', 'item-put', '-m', data_dir / 'Home.meta', '-d', data_dir / 'Home.data', '-o'])
+    moin_dir, _ = get_dirs("")
+    data_dir = moin_dir / "src" / "moin" / "cli" / "_tests" / "data"
+    put = run(["moin", "item-put", "-m", data_dir / "Home.meta", "-d", data_dir / "Home.data", "-o"])
     assert_p_succcess(put)
-    set_meta = run(['moin', 'maint-set-meta', '-q', 'Home', '-k', NAME, '-v', '["Home", "AnotherName"]'])
+    set_meta = run(["moin", "maint-set-meta", "-q", "Home", "-k", NAME, "-v", '["Home", "AnotherName"]'])
     assert_p_succcess(set_meta)
-    index_dump = run(['moin', 'index-dump', '--no-truncate'])
+    index_dump = run(["moin", "index-dump", "--no-truncate"])
     assert_p_succcess(index_dump)
     items = {item[REV_NUMBER]: item for item in read_index_dump(index_dump.stdout.decode())}
     assert {1, 2} == set(items.keys())
diff --git a/src/moin/cli/_util.py b/src/moin/cli/_util.py
index 8ca0cc19b..e559a359b 100644
--- a/src/moin/cli/_util.py
+++ b/src/moin/cli/_util.py
@@ -23,7 +23,7 @@ def get_backends(backends: Optional[str], all_backends: bool) -> set[Backend]:
         return set(app.cfg.backend_mapping.values())
     if backends:
         existing_backends = set(app.cfg.backend_mapping)
-        backends = set(backends.split(','))
+        backends = set(backends.split(","))
         if backends.issubset(existing_backends):
             return {app.cfg.backend_mapping.get(backend_name) for backend_name in backends}
         else:
@@ -31,7 +31,7 @@ def get_backends(backends: Optional[str], all_backends: bool) -> set[Backend]:
             print("Given Backends: %r" % backends)
             print("Configured Backends: %r" % existing_backends)
     else:
-        logging.warning('no backends specified')
+        logging.warning("no backends specified")
         return set()
 
 
diff --git a/src/moin/cli/account/create.py b/src/moin/cli/account/create.py
index 6c239b014..b163141e2 100644
--- a/src/moin/cli/account/create.py
+++ b/src/moin/cli/account/create.py
@@ -23,21 +23,24 @@ def cli():
     pass
 
 
-@cli.command('account-create', help='Create a user account')
-@click.option('-n', '--name', required=True, type=str, help="Set the wiki user name to NAME.")
-@click.option('-e', '--email', required=True, type=str, help="Set the user's email address to EMAIL.")
-@click.option('-p', '--password', required=True, type=str, help="Set the user's password to PASSWORD.")
-@click.option('-d', '--display-name', required=False, type=str,
-              help="Set the wiki user's display name to DISPLAY_NAME (e.g. in case the NAME is cryptic).")
+@cli.command("account-create", help="Create a user account")
+@click.option("-n", "--name", required=True, type=str, help="Set the wiki user name to NAME.")
+@click.option("-e", "--email", required=True, type=str, help="Set the user's email address to EMAIL.")
+@click.option("-p", "--password", required=True, type=str, help="Set the user's password to PASSWORD.")
+@click.option(
+    "-d",
+    "--display-name",
+    required=False,
+    type=str,
+    help="Set the wiki user's display name to DISPLAY_NAME (e.g. in case the NAME is cryptic).",
+)
 def CreateUser(name, display_name, email, password):
-    '''Create a new user account'''
+    """Create a new user account"""
     logging.debug("display_name: %s", str(display_name))
     before_wiki()
 
     # TODO: add display_name to create_user
-    msg = user.create_user(username=name,
-                           password=password,
-                           email=email)
+    msg = user.create_user(username=name, password=password, email=email)
 
     if msg:
         print(msg)
diff --git a/src/moin/cli/account/disable.py b/src/moin/cli/account/disable.py
index a0e3a622a..4c8c046b7 100644
--- a/src/moin/cli/account/disable.py
+++ b/src/moin/cli/account/disable.py
@@ -22,14 +22,15 @@ def cli():
     pass
 
 
-@cli.command('account-disable', help='Disable user accounts')
-@click.option('--name', '-n', required=False, type=str, help='Disable the user with user name NAME.')
-@click.option('--uid', '-u', required=False, type=str, help='Disable the user with user id UID.')
+@cli.command("account-disable", help="Disable user accounts")
+@click.option("--name", "-n", required=False, type=str, help="Disable the user with user name NAME.")
+@click.option("--uid", "-u", required=False, type=str, help="Disable the user with user id UID.")
 def DisableUser(name, uid):
     flags_given = name or uid
     if not flags_given:
-        print('incorrect number of arguments')
+        print("incorrect number of arguments")
         import sys
+
         sys.exit()
 
     before_wiki()
@@ -42,7 +43,7 @@ def DisableUser(name, uid):
         print(f'This user "{u.name!r}" does not exists!')
         return
 
-    print(f" {u.itemid:<20} {u.name!r:<25} {u.email:<35}", end=' ')
+    print(f" {u.itemid:<20} {u.name!r:<25} {u.email:<35}", end=" ")
     if not u.disabled:  # only disable once
         u.disabled = True
         u.name = f"{u.name}-{u.itemid}"
diff --git a/src/moin/cli/account/resetpw.py b/src/moin/cli/account/resetpw.py
index 17f1f97fe..a2b4ce486 100644
--- a/src/moin/cli/account/resetpw.py
+++ b/src/moin/cli/account/resetpw.py
@@ -51,38 +51,56 @@ def set_password(uid, password, notify=False, skip_invalid=False, subject=None,
         u.save()
         if notify and not u.disabled:
             if not u.email:
-                raise UserHasNoEMail('Notification was requested, but User profile does not have '
-                                     'a validated E-Mail address (name: %r id: %r)!' % (u.name, u.itemid))
+                raise UserHasNoEMail(
+                    "Notification was requested, but User profile does not have "
+                    "a validated E-Mail address (name: %r id: %r)!" % (u.name, u.itemid)
+                )
             mailok, msg = u.mail_password_recovery(subject=subject, text=text)
             if not mailok:
                 raise MailFailed(msg)
     else:
-        raise NoSuchUser('User does not exist (name: %r id: %r)!' % (u.name, u.id))
-
-
-@cli.command('account-password', help='Set user passwords')
-@click.option('--name', '-n', required=False, type=str, help='Set password for the user with user name NAME.')
-@click.option('--uid', '-u', required=False, type=str, help='Set password for the user with user id UID.')
-@click.option('--password', '-p', required=False, type=str, help='New password for this account.')
-@click.option('--all-users', '-a', is_flag=True, required=False, default=False,
-              help='Reset password for ALL users.')
-@click.option('--notify', '-N', is_flag=True, required=False, default=False,
-              help='Notify user(s), send them an E-Mail with a password reset link.')
-@click.option('--verbose', '-v', is_flag=True, required=False, default=False, help='Verbose operation')
-@click.option('--subject', required=False, type=str,
-              help='Subject text for the password reset notification E-Mail.')
-@click.option('--text', required=False, type=str,
-              help='Template text for the password reset notification E-Mail. '
-                   'Default: use the builtin standard template')
-@click.option('--text-from-file', required=False, type=str,
-              help='Read full template for the password reset notification E-Mail from the given file, '
-                   'overrides --text. Default: None')
-@click.option('--skip-invalid', is_flag=True, required=False, default=False,
-              help='If a user\'s password hash is already invalid (pw is already reset), skip this user.')
+        raise NoSuchUser("User does not exist (name: %r id: %r)!" % (u.name, u.id))
+
+
+@cli.command("account-password", help="Set user passwords")
+@click.option("--name", "-n", required=False, type=str, help="Set password for the user with user name NAME.")
+@click.option("--uid", "-u", required=False, type=str, help="Set password for the user with user id UID.")
+@click.option("--password", "-p", required=False, type=str, help="New password for this account.")
+@click.option("--all-users", "-a", is_flag=True, required=False, default=False, help="Reset password for ALL users.")
+@click.option(
+    "--notify",
+    "-N",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="Notify user(s), send them an E-Mail with a password reset link.",
+)
+@click.option("--verbose", "-v", is_flag=True, required=False, default=False, help="Verbose operation")
+@click.option("--subject", required=False, type=str, help="Subject text for the password reset notification E-Mail.")
+@click.option(
+    "--text",
+    required=False,
+    type=str,
+    help="Template text for the password reset notification E-Mail. " "Default: use the builtin standard template",
+)
+@click.option(
+    "--text-from-file",
+    required=False,
+    type=str,
+    help="Read full template for the password reset notification E-Mail from the given file, "
+    "overrides --text. Default: None",
+)
+@click.option(
+    "--skip-invalid",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="If a user's password hash is already invalid (pw is already reset), skip this user.",
+)
 def SetPassword(name, uid, password, all_users, notify, verbose, subject, text, text_from_file, skip_invalid):
     flags_given = name or uid or all_users
     if not flags_given:
-        print('incorrect number of arguments')
+        print("incorrect number of arguments")
         sys.exit(1)
 
     if notify and not app.cfg.mail_enabled:
@@ -91,7 +109,7 @@ def SetPassword(name, uid, password, all_users, notify, verbose, subject, text,
 
     if text_from_file:
         with open(text_from_file) as f:
-            text = f.read().decode('utf-8')
+            text = f.read().decode("utf-8")
 
     before_wiki()
     if uid:
@@ -105,7 +123,7 @@ def SetPassword(name, uid, password, all_users, notify, verbose, subject, text,
     uids_metas = sorted([(rev.meta[ITEMID], rev.meta) for rev in user.search_users(**query)])
     total = len(uids_metas)
     if not total:
-        raise NoSuchUser('User not found.')
+        raise NoSuchUser("User not found.")
 
     logging.debug("Number of users found: %s", format(str(total)))
     for nr, (uid, meta) in enumerate(uids_metas, start=1):
@@ -114,12 +132,13 @@ def SetPassword(name, uid, password, all_users, notify, verbose, subject, text,
         if email is None:
             email = meta.get(EMAIL_UNVALIDATED)
             if email is None:
-                raise ValueError("neither EMAIL nor EMAIL_UNVALIDATED key is present in "
-                                 "user profile metadata of uid %r name %r" % (uid, name))
-            email += '[email_unvalidated]'
+                raise ValueError(
+                    "neither EMAIL nor EMAIL_UNVALIDATED key is present in "
+                    "user profile metadata of uid %r name %r" % (uid, name)
+                )
+            email += "[email_unvalidated]"
         try:
-            set_password(uid, password, notify=notify, skip_invalid=skip_invalid,
-                         subject=subject, text=text)
+            set_password(uid, password, notify=notify, skip_invalid=skip_invalid, subject=subject, text=text)
         except Fault as err:
             status = "FAILURE: [%s]" % str(err)
         else:
diff --git a/src/moin/cli/maint/create_instance.py b/src/moin/cli/maint/create_instance.py
index 8ece02f9a..06b41411d 100644
--- a/src/moin/cli/maint/create_instance.py
+++ b/src/moin/cli/maint/create_instance.py
@@ -47,64 +47,71 @@ def cli():
 
 
 @cli.command("create-instance", help="Create wikiconfig and wiki instance directories and copy required files")
-@click.option('--full', '-f', required=False, is_flag=True, default=False,
-              help='full setup including index creation and load of help data and welcome page')
-@click.option('--path', '-p', required=False, type=str,
-              help='Path to new wikiconfig dir, defaults to CWD if not specified.')
+@click.option(
+    "--full",
+    "-f",
+    required=False,
+    is_flag=True,
+    default=False,
+    help="full setup including index creation and load of help data and welcome page",
+)
+@click.option(
+    "--path", "-p", required=False, type=str, help="Path to new wikiconfig dir, defaults to CWD if not specified."
+)
 def cli_CreateInstance(full, path):
     return CreateInstance(full, path=path)
 
 
 def CreateInstance(full, **kwargs):
-    '''
+    """
     Create wikiconfig and wiki instance directories and copy required files.
-    '''
-    logging.debug('Instance creation started.')
+    """
+    logging.debug("Instance creation started.")
     config_path = os.path.dirname(config.__file__)
     contrib_path = os.path.dirname(contrib.__file__)
-    path = kwargs.get('path', None)
+    path = kwargs.get("path", None)
     if not path:
         path = os.getcwd()
     if os.path.exists(path):
-        logging.info('Directory %s already exists, using as wikiconfig dir.', os.path.abspath(path))
+        logging.info("Directory %s already exists, using as wikiconfig dir.", os.path.abspath(path))
     else:
         os.makedirs(path)
-        logging.info('Directory %s created.', os.path.abspath(path))
+        logging.info("Directory %s created.", os.path.abspath(path))
 
-    if os.path.isfile(os.path.join(path, 'wikiconfig.py')):
-        logging.info('wikiconfig.py already exists, not copied.')
+    if os.path.isfile(os.path.join(path, "wikiconfig.py")):
+        logging.info("wikiconfig.py already exists, not copied.")
     else:
-        shutil.copy(os.path.join(config_path, 'wikiconfig.py'), path)
+        shutil.copy(os.path.join(config_path, "wikiconfig.py"), path)
 
-    if os.path.isfile(os.path.join(path, 'intermap.txt')):
-        logging.info('intermap.txt already exists, not copied.')
+    if os.path.isfile(os.path.join(path, "intermap.txt")):
+        logging.info("intermap.txt already exists, not copied.")
     else:
-        shutil.copy(os.path.join(contrib_path, 'intermap.txt'), path)
-    local_path = os.path.join(path, 'wiki_local')
+        shutil.copy(os.path.join(contrib_path, "intermap.txt"), path)
+    local_path = os.path.join(path, "wiki_local")
     if not os.path.isdir(local_path):
         os.mkdir(local_path)
-    logging.info('Instance creation finished.')
+    logging.info("Instance creation finished.")
 
     if full:
         if path != os.getcwd():
             os.chdir(path)
-        subprocess.call('moin build-instance', shell=True)
+        subprocess.call("moin build-instance", shell=True)
 
 
 @cli.command("build-instance", hidden=True)
 def cli_BuildInstance():
-    '''
+    """
     Create and build index, load help data and welcome page.
     This command is hidden in help. For internal use in "create-instance --full" only!
-    '''
-    logging.info('Build Instance started.')
-    logging.debug('CWD: %s', os.getcwd())
+    """
+    logging.info("Build Instance started.")
+    logging.debug("CWD: %s", os.getcwd())
     if index.IndexCreate():
-        modify_item.LoadHelp(namespace='help-en', path_to_help=None)
-        modify_item.LoadHelp(namespace='help-common', path_to_help=None)
+        modify_item.LoadHelp(namespace="help-en", path_to_help=None)
+        modify_item.LoadHelp(namespace="help-common", path_to_help=None)
         modify_item.LoadWelcome()
         index.IndexOptimize(tmp=False)
-        logging.info('Full instance setup finished.')
+        logging.info("Full instance setup finished.")
         logging.info('You can now use "moin run" to start the builtin server.')
     else:
-        logging.error('Build Instance failed.')
+        logging.error("Build Instance failed.")
diff --git a/src/moin/cli/maint/dump_html.py b/src/moin/cli/maint/dump_html.py
index 5d31c662e..39b0194be 100644
--- a/src/moin/cli/maint/dump_html.py
+++ b/src/moin/cli/maint/dump_html.py
@@ -58,9 +58,10 @@
 from moin.items import Item
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-PARENT_DIR = '../'
+PARENT_DIR = "../"
 
 
 @click.group(cls=FlaskGroup, create_app=create_app)
@@ -68,21 +69,36 @@ def cli():
     pass
 
 
-@cli.command('dump-html', help='Create a static HTML image of this wiki')
-@click.option('--directory', '-d', type=str, required=False, default='HTML',
-              help='Directory name containing the output files, default HTML')
-@click.option('--theme', '-t', required=False, default='topside_cms',
-              help='Name of theme used in creating output pages, default topside_cms')
-@click.option('--exclude-ns', '-e', required=False, default='userprofiles',
-              help='Comma separated list of excluded namespaces, default userprofiles')
-@click.option('--query', '-q', required=False, default=None,
-              help='name or regex of items to be included')
-def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=None, query=None):
+@cli.command("dump-html", help="Create a static HTML image of this wiki")
+@click.option(
+    "--directory",
+    "-d",
+    type=str,
+    required=False,
+    default="HTML",
+    help="Directory name containing the output files, default HTML",
+)
+@click.option(
+    "--theme",
+    "-t",
+    required=False,
+    default="topside_cms",
+    help="Name of theme used in creating output pages, default topside_cms",
+)
+@click.option(
+    "--exclude-ns",
+    "-e",
+    required=False,
+    default="userprofiles",
+    help="Comma separated list of excluded namespaces, default userprofiles",
+)
+@click.option("--query", "-q", required=False, default=None, help="name or regex of items to be included")
+def Dump(directory="HTML", theme="topside_cms", exclude_ns="userprofiles", user=None, query=None):
     with app.test_request_context():
         logging.info("Dump html started")
         if theme:
             app.cfg.user_defaults[THEME_NAME] = theme
-        exclude_ns = exclude_ns.split(',') if exclude_ns else []
+        exclude_ns = exclude_ns.split(",") if exclude_ns else []
 
         before_wiki()
         setup_user_anon()
@@ -93,7 +109,7 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
         wiki_root = norm(app.cfg.wikiconfig_dir)
         moinmoin = os.path.dirname(log.__file__)  # log is imported from moin -> this is src/moin
         logging.debug("wiki_root dir: %s, moin src dir: %s", wiki_root, moinmoin)
-        if '/' in directory:
+        if "/" in directory:
             # user has specified complete path to root
             html_root = directory
         else:
@@ -101,35 +117,35 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
 
         # override ACLs with permission to read all items
         for _, acls in app.cfg.acl_mapping:
-            acls['before'] = 'All:read'
+            acls["before"] = "All:read"
 
         # create an empty output directory after deleting any existing directory
-        print(f'Creating output directory {html_root}, starting to copy supporting files')
+        print(f"Creating output directory {html_root}, starting to copy supporting files")
         if os.path.exists(html_root):
             shutil.rmtree(html_root, ignore_errors=False)
         else:
             os.makedirs(html_root)
 
         # create subdirectories and copy static css, icons, images into "static" subdirectory
-        shutil.copytree(norm(join(moinmoin, 'static')), norm(join(html_root, 'static')))
-        shutil.copytree(norm(join(wiki_root, 'wiki_local')), norm(join(html_root, '+serve/wiki_local')))
+        shutil.copytree(norm(join(moinmoin, "static")), norm(join(html_root, "static")))
+        shutil.copytree(norm(join(wiki_root, "wiki_local")), norm(join(html_root, "+serve/wiki_local")))
 
         # copy files from xstatic packaging into "+serve" subdirectory
         pkg = app.cfg.pkg
-        xstatic_dirs = ['font_awesome', 'jquery', 'jquery_tablesorter', 'autosize']
-        if theme in ['basic', ]:
-            xstatic_dirs.append('bootstrap')
+        xstatic_dirs = ["font_awesome", "jquery", "jquery_tablesorter", "autosize"]
+        if theme in ["basic"]:
+            xstatic_dirs.append("bootstrap")
         for dirs in xstatic_dirs:
-            xs = XStatic(getattr(pkg, dirs), root_url='/static', provider='local', protocol='http')
-            shutil.copytree(xs.base_dir, norm(join(html_root, '+serve', dirs)))
+            xs = XStatic(getattr(pkg, dirs), root_url="/static", provider="local", protocol="http")
+            shutil.copytree(xs.base_dir, norm(join(html_root, "+serve", dirs)))
 
         # copy directories for theme's static files
-        if theme == 'topside_cms':
+        if theme == "topside_cms":
             # topside_cms uses topside CSS files
-            from_dir = norm(join(moinmoin, 'themes/topside/static'))
+            from_dir = norm(join(moinmoin, "themes/topside/static"))
         else:
-            from_dir = norm(join(moinmoin, 'themes', theme, 'static'))
-        to_dir = norm(join(html_root, '_themes', theme))
+            from_dir = norm(join(moinmoin, "themes", theme, "static"))
+        to_dir = norm(join(html_root, "_themes", theme))
         shutil.copytree(from_dir, to_dir)
 
         # convert: <img alt="svg" src="/+get/+7cb364b8ca5d4b7e960a4927c99a2912/svg" />
@@ -139,7 +155,7 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
         # get ready to render and copy individual items
         names = []
         home_page = None
-        get_dir = norm(join(html_root, '+get'))  # images and other raw data from wiki content
+        get_dir = norm(join(html_root, "+get"))  # images and other raw data from wiki content
         os.makedirs(get_dir)
 
         if query:
@@ -147,7 +163,7 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
         else:
             q = Every()
 
-        print('Starting to dump items')
+        print("Starting to dump items")
         used_dirs = get_used_dirs(query=q)
         # In the filesystem the item cannot have the same name as the directory.
         # so we append .html to the filename for items in used_dirs.
@@ -163,25 +179,25 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
                 item_name = current_rev.fqname.fullname
                 rendered = show_item(item_name, CURRENT)
                 if item_name in used_dirs:
-                    file_name = item_name + '.html'
+                    file_name = item_name + ".html"
                 else:
                     file_name = item_name
                 filename = norm(join(html_root, file_name))
                 names.append(item_name)  # save item_names for index
             except Forbidden:
-                print(f'Failed to dump {current_rev.name}: Forbidden')
+                print(f"Failed to dump {current_rev.name}: Forbidden")
                 continue
             except KeyError:
-                print(f'Failed to dump {current_rev.name}: KeyError')
+                print(f"Failed to dump {current_rev.name}: KeyError")
                 continue
 
             if not isinstance(rendered, str):
-                print(f'Rendering failed for {file_name} with response {rendered}')
+                print(f"Rendering failed for {file_name} with response {rendered}")
                 continue
             # make hrefs relative to root folder
-            rel_path2root = PARENT_DIR * len(re.findall('/', item_name))
+            rel_path2root = PARENT_DIR * len(re.findall("/", item_name))
             rendered = rendered.replace('href="/', 'href="' + rel_path2root)
-            rendered = rendered.replace('src="/static/', 'src="' + rel_path2root + 'static/')
+            rendered = rendered.replace('src="/static/', 'src="' + rel_path2root + "static/")
             rendered = rendered.replace('src="/+serve/', 'src="+serve/')
             rendered = rendered.replace('href="+index/"', 'href="+index"')  # trailing slash changes relative position
             # TODO: fix basic theme
@@ -197,77 +213,80 @@ def Dump(directory='HTML', theme='topside_cms', exclude_ns='userprofiles', user=
             # images are required, text items are of marginal/no benefit
             item = app.storage[current_rev.fqname.fullname]
             rev = item[CURRENT]
-            full_file_name = get_dir + '/' + file_name
+            full_file_name = get_dir + "/" + file_name
             os.makedirs(os.path.dirname(full_file_name), exist_ok=True)
-            with open(full_file_name, 'wb') as f:
+            with open(full_file_name, "wb") as f:
                 shutil.copyfileobj(rev.data, f)
 
             # save rendered items or raw data to dump directory root
-            contenttype = item.meta['contenttype'].split(';')[0]
+            contenttype = item.meta["contenttype"].split(";")[0]
             os.makedirs(os.path.dirname(filename), exist_ok=True)
             if contenttype in CONTENTTYPE_MEDIA and filename.endswith(CONTENTTYPE_MEDIA_SUFFIX):
                 # do not put a rendered html-formatted file with a name like video.mp4 into root;
                 # browsers want raw data
-                with open(filename, 'wb') as f:
+                with open(filename, "wb") as f:
                     rev.data.seek(0)
                     shutil.copyfileobj(rev.data, f)
                     try:
-                        print(f'Saved file named {filename} as raw data')
+                        print(f"Saved file named {filename} as raw data")
                     except UnicodeEncodeError:
-                        print('Saved file named {} as raw data'.format(filename.encode('ascii', errors='replace')))
+                        print("Saved file named {} as raw data".format(filename.encode("ascii", errors="replace")))
 
             else:
-                with open(filename, 'wb') as f:
-                    f.write(rendered.encode('utf8'))
+                with open(filename, "wb") as f:
+                    f.write(rendered.encode("utf8"))
                     try:
-                        print(f'Saved file named {filename}')
+                        print(f"Saved file named {filename}")
                     except UnicodeEncodeError:
-                        print('Saved file named {}'.format(filename.encode('ascii', errors='replace')))
+                        print("Saved file named {}".format(filename.encode("ascii", errors="replace")))
 
             if current_rev.fqname.fullname == app.cfg.default_root:
                 # make duplicates of home page that are easy to find in directory list and open with a click
-                for target in [(current_rev.name + '.html'), ('_' + current_rev.name + '.html')]:
-                    with open(norm(join(html_root, target)), 'wb') as f:
-                        f.write(rendered.encode('utf8'))
+                for target in [(current_rev.name + ".html"), ("_" + current_rev.name + ".html")]:
+                    with open(norm(join(html_root, target)), "wb") as f:
+                        f.write(rendered.encode("utf8"))
                 home_page = rendered  # save a copy for creation of index page
 
         if home_page:
             # create an index page by replacing the content of the home page with a list of items
             # work around differences in basic and modernized theme layout
             # TODO: this is likely to break as new themes are added
-            if theme == 'basic':
+            if theme == "basic":
                 start = '<div class="moin-content" role="main">'  # basic
                 end = '<footer class="navbar moin-footer">'
-                div_end = '</div>'
+                div_end = "</div>"
             else:
                 start = '<div id="moin-content">'  # modernized , topside, topside cms
                 end = '<footer id="moin-footer">'
-                div_end = '</div></div>'
+                div_end = "</div></div>"
             # build a page named "+index" containing links to all wiki items
-            ul = '<h1>Index</h1><ul>{0}</ul>'
+            ul = "<h1>Index</h1><ul>{0}</ul>"
             li = '<li><a href="{0}">{1}</a></li>'
             links = []
             names.sort()
             for name in names:
                 if name in used_dirs:
-                    li_name = name + '.html'
+                    li_name = name + ".html"
                 else:
                     li_name = name
                 links.append(li.format(li_name, name))
-            name_links = ul.format('\n'.join(links))
+            name_links = ul.format("\n".join(links))
             try:
                 part1 = home_page.split(start)[0]
                 part2 = home_page.split(end)[1]
                 page = part1 + start + name_links + div_end + end + part2
             except IndexError:
                 page = home_page
-                print(f'Error: failed to find {end} in item named {app.cfg.default_root}')
-            for target in ['+index', '_+index.html']:
-                with open(norm(join(html_root, target)), 'wb') as f:
-                    f.write(page.encode('utf8'))
+                print(f"Error: failed to find {end} in item named {app.cfg.default_root}")
+            for target in ["+index", "_+index.html"]:
+                with open(norm(join(html_root, target)), "wb") as f:
+                    f.write(page.encode("utf8"))
         else:
-            print('Error: index pages not created because no home page exists, expected an item named "{}".'.format(
-                app.cfg.default_root))
+            print(
+                'Error: index pages not created because no home page exists, expected an item named "{}".'.format(
+                    app.cfg.default_root
+                )
+            )
         logging.info("Dump html complete")
 
 
@@ -283,8 +302,8 @@ def get_used_dirs(query):
     used_dirs = set()
     for file_ in used_dir_fullnames:
         if file_.namespace:
-            used_dirs.add('/'.join((file_.namespace, file_.value)))
+            used_dirs.add("/".join((file_.namespace, file_.value)))
         else:
             used_dirs.add(file_.value)
-    logging.debug('used_dirs: %s', str(used_dirs))
+    logging.debug("used_dirs: %s", str(used_dirs))
     return used_dirs
diff --git a/src/moin/cli/maint/index.py b/src/moin/cli/maint/index.py
index ae463b77b..ff8fdb7bb 100644
--- a/src/moin/cli/maint/index.py
+++ b/src/moin/cli/maint/index.py
@@ -23,16 +23,16 @@
 
 ERR_NO_INDEX = "Error: Wiki index does not exist."
 
+
 @click.group(cls=FlaskGroup, create_app=create_app)
 def cli():
     pass
 
 
-@cli.command('index-create', help='Create empty indexes')
-@click.option('--tmp', is_flag=True, required=False, default=False,
-              help='use the temporary location.')
-@click.option('-i', '--index-create', is_flag=True, required=False, default=False, help='(deprecated)')
-@click.option('-s', '--storage-create', is_flag=True, required=False, default=False, help='(deprecated)')
+@cli.command("index-create", help="Create empty indexes")
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
+@click.option("-i", "--index-create", is_flag=True, required=False, default=False, help="(deprecated)")
+@click.option("-s", "--storage-create", is_flag=True, required=False, default=False, help="(deprecated)")
 def cli_IndexCreate(tmp, index_create, storage_create):
     if index_create:
         logging.info("options -i or --index-create are obsolete and will be ignored")
@@ -50,15 +50,14 @@ def IndexCreate(**kwargs):
         return False
     logging.info("Index creation started")
     init_backends(app, create_backend=True)
-    tmp = kwargs.get('tmp')
+    tmp = kwargs.get("tmp")
     app.storage.create(tmp=tmp)
     logging.info("Index creation finished")
     return True
 
 
-@cli.command('index-destroy', help='Destroy the indexes')
-@click.option('--tmp', is_flag=True, required=False, default=False,
-              help='use the temporary location.')
+@cli.command("index-destroy", help="Destroy the indexes")
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
 def IndexDestroy(tmp):
     if not wiki_index_exists():
         logging.error(ERR_NO_INDEX)
@@ -68,14 +67,19 @@ def IndexDestroy(tmp):
     logging.info("Index destroy finished")
 
 
-@cli.command('index-build', help='Build the indexes')
-@click.option('--procs', '-p', required=False, type=int, default=1,
-              help='Number of processors the writer will use.')
-@click.option('--limitmb', '-l', required=False, type=int, default=10,
-              help='Maximum memory (in megabytes) each index-writer will use for the indexing pool.')
-@click.option('--tmp', is_flag=True, required=False, default=False, help='use the temporary location.')
-@click.option('--index-create', '-i', is_flag=True, required=False, default=False)
-@click.option('--storage-create', '-s', is_flag=True, required=False, default=False)
+@cli.command("index-build", help="Build the indexes")
+@click.option("--procs", "-p", required=False, type=int, default=1, help="Number of processors the writer will use.")
+@click.option(
+    "--limitmb",
+    "-l",
+    required=False,
+    type=int,
+    default=10,
+    help="Maximum memory (in megabytes) each index-writer will use for the indexing pool.",
+)
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
+@click.option("--index-create", "-i", is_flag=True, required=False, default=False)
+@click.option("--storage-create", "-s", is_flag=True, required=False, default=False)
 def IndexBuild(tmp, procs, limitmb, **kwargs):
     if not wiki_index_exists():
         logging.error(f"{ERR_NO_INDEX} Run 'moin index-create' first.")
@@ -86,8 +90,8 @@ def IndexBuild(tmp, procs, limitmb, **kwargs):
     logging.info("Index build finished")
 
 
-@cli.command('index-update', help='Update the indexes')
-@click.option('--tmp', is_flag=True, required=False, default=False, help='use the temporary location.')
+@cli.command("index-update", help="Update the indexes")
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
 def IndexUpdate(tmp):
     if not wiki_index_exists():
         logging.error(ERR_NO_INDEX)
@@ -97,15 +101,15 @@ def IndexUpdate(tmp):
     logging.info("Index update started")
 
 
-@cli.command('index-move', help='Move the indexes from the temporary to the normal location')
+@cli.command("index-move", help="Move the indexes from the temporary to the normal location")
 def IndexMove():
     logging.info("Index move started")
     app.storage.move_index()
     logging.info("Index move finished")
 
 
-@cli.command('index-optimize', help='Optimize the indexes')
-@click.option('--tmp', is_flag=True, required=False, default=False, help='use the temporary location.')
+@cli.command("index-optimize", help="Optimize the indexes")
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
 def cli_IndexOptimize(tmp):
     return IndexOptimize(tmp)
 
@@ -122,9 +126,9 @@ def IndexOptimize(tmp):
     logging.info("Index optimization finished")
 
 
-@cli.command('index-dump', help='Dump the indexes in readable form to stdout')
-@click.option('--tmp', is_flag=True, required=False, default=False, help='use the temporary location.')
-@click.option('--truncate/--no-truncate', default=True, help='truncate long entries')
+@cli.command("index-dump", help="Dump the indexes in readable form to stdout")
+@click.option("--tmp", is_flag=True, required=False, default=False, help="use the temporary location.")
+@click.option("--truncate/--no-truncate", default=True, help="truncate long entries")
 def IndexDump(tmp, truncate):
     if not wiki_index_exists():
         logging.error(ERR_NO_INDEX)
diff --git a/src/moin/cli/maint/modify_item.py b/src/moin/cli/maint/modify_item.py
index f11cd67e2..1eaf34881 100644
--- a/src/moin/cli/maint/modify_item.py
+++ b/src/moin/cli/maint/modify_item.py
@@ -33,7 +33,7 @@
 logging = log.getLogger(__name__)
 
 
-def _get_path_to_help(subdir=''):
+def _get_path_to_help(subdir=""):
     help_path = os.path.dirname(moin_help.__file__)
     return os.path.normpath(os.path.join(help_path, subdir))
 
@@ -43,22 +43,28 @@ def cli():
     pass
 
 
-@cli.command('item-get', help='Get an item revision from the wiki')
-@click.option('--name', '-n', type=str, required=True, help='Name of the item to get.')
-@click.option('--meta', '-m', '--meta_file', type=str, required=True,
-              help='Filename of file to create for the metadata.')
-@click.option('--data', '-d', '--data_file', type=str, required=True,
-              help='Filename of file to create for the data.')
-@click.option('--revid', '-r', type=str, required=False, default=CURRENT,
-              help='Revision ID of the revision to get (default: current rev).')
-@click.option('--crlf/--no-crlf', help='use windows line endings in output files')
+@cli.command("item-get", help="Get an item revision from the wiki")
+@click.option("--name", "-n", type=str, required=True, help="Name of the item to get.")
+@click.option(
+    "--meta", "-m", "--meta_file", type=str, required=True, help="Filename of file to create for the metadata."
+)
+@click.option("--data", "-d", "--data_file", type=str, required=True, help="Filename of file to create for the data.")
+@click.option(
+    "--revid",
+    "-r",
+    type=str,
+    required=False,
+    default=CURRENT,
+    help="Revision ID of the revision to get (default: current rev).",
+)
+@click.option("--crlf/--no-crlf", help="use windows line endings in output files")
 def cli_GetItem(name, meta, data, revid, crlf):
     logging.info("Get item started")
-    GetItem(name, meta, data, revid, '\r\n' if crlf else '\n')
+    GetItem(name, meta, data, revid, "\r\n" if crlf else "\n")
     logging.info("Get item finished")
 
 
-def GetItem(name, meta_file, data_file, revid, newline='\n'):
+def GetItem(name, meta_file, data_file, revid, newline="\n"):
     """
     Get an item revision from the wiki and save meta and data in separate files.
     If this revision has alias names, return a list of all names, else return None.
@@ -68,36 +74,35 @@ def GetItem(name, meta_file, data_file, revid, newline='\n'):
     rev = item[revid]
     alias_names = None if len(rev.meta[NAME]) < 2 else rev.meta[NAME]
     meta = json.dumps(dict(rev.meta), sort_keys=True, indent=2, ensure_ascii=False)
-    with open(meta_file, 'w', encoding='utf-8', newline=newline) as mf:
-        mf.write(meta + '\n')
-    if 'charset' in rev.meta['contenttype']:
+    with open(meta_file, "w", encoding="utf-8", newline=newline) as mf:
+        mf.write(meta + "\n")
+    if "charset" in rev.meta["contenttype"]:
         # input data will have \r\n line endings, output will have specified endings
         # those running on windows with git autocrlf=true will want --crlf
         # those running on linux or with autocrlf=input will want --no-crlf
-        charset = rev.meta['contenttype'].split('charset=')[1]
+        charset = rev.meta["contenttype"].split("charset=")[1]
         data = rev.data.read().decode(charset)
         lines = data.splitlines()
         # add trailing line ending which may have been removed by splitlines,
         # or add extra trailing line ending which will be removed in _PutItem if file is imported
-        lines = '\n'.join(lines) + '\n'
-        with open(data_file, 'w', encoding=charset, newline=newline) as df:
+        lines = "\n".join(lines) + "\n"
+        with open(data_file, "w", encoding=charset, newline=newline) as df:
             df.write(lines)
         return alias_names
 
     data = rev.data.read()
-    with open(data_file, 'wb') as df:
+    with open(data_file, "wb") as df:
         df.write(data)
     logging.info("Get item finished")
     return alias_names
 
 
-@cli.command('item-put', help='Put an item revision into the wiki')
-@click.option('--meta', '-m', '--meta-file', type=str, required=True,
-              help='Filename of file to read as metadata.')
-@click.option('--data', '-d', '--data-file', type=str, required=True,
-              help='Filename of file to read as data.')
-@click.option('--overwrite', '-o', is_flag=True, default=False,
-              help='If given, overwrite existing revisions, if requested.')
+@cli.command("item-put", help="Put an item revision into the wiki")
+@click.option("--meta", "-m", "--meta-file", type=str, required=True, help="Filename of file to read as metadata.")
+@click.option("--data", "-d", "--data-file", type=str, required=True, help="Filename of file to read as data.")
+@click.option(
+    "--overwrite", "-o", is_flag=True, default=False, help="If given, overwrite existing revisions, if requested."
+)
 def cli_PutItem(meta, data, overwrite):
     logging.info("Put item started")
     PutItem(meta, data, overwrite)
@@ -109,11 +114,11 @@ def PutItem(meta_file, data_file, overwrite):
     Put an item revision from file into the wiki
     """
     flaskg.add_lineno_attr = False
-    with open(meta_file, 'rb') as mf:
+    with open(meta_file, "rb") as mf:
         meta = mf.read()
-    meta = meta.decode('utf-8')
+    meta = meta.decode("utf-8")
     meta = json.loads(meta)
-    to_kill = [WIKINAME, ]  # use target wiki name
+    to_kill = [WIKINAME]  # use target wiki name
     for key in to_kill:
         meta.pop(key, None)
     if overwrite:
@@ -129,15 +134,15 @@ def PutItem(meta_file, data_file, overwrite):
     item = app.storage.get_item(**query)
 
     # we want \r\n line endings in data out because \r\n is required in form textareas
-    if 'charset' in meta['contenttype']:
-        charset = meta['contenttype'].split('charset=')[1]
-        with open(data_file, 'rb') as df:
+    if "charset" in meta["contenttype"]:
+        charset = meta["contenttype"].split("charset=")[1]
+        with open(data_file, "rb") as df:
             data = df.read().decode(charset)
-        if '\r\n' not in data and '\n' in data:
-            data = data.replace('\n', '\r\n')
+        if "\r\n" not in data and "\n" in data:
+            data = data.replace("\n", "\r\n")
         data = data.encode(charset)
-        if 0 < len(data) - meta['size'] <= 2:
-            data = data[0:meta['size']]  # potentially truncate trailing newline added by _GetItem
+        if 0 < len(data) - meta["size"] <= 2:
+            data = data[0 : meta["size"]]  # potentially truncate trailing newline added by _GetItem
         buffer = io.BytesIO()
         buffer.write(data)
         buffer.seek(0)
@@ -145,15 +150,13 @@ def PutItem(meta_file, data_file, overwrite):
         buffer.close()
         return
 
-    with open(data_file, 'rb') as df:
+    with open(data_file, "rb") as df:
         item.store_revision(meta, df, overwrite=overwrite)
 
 
-@cli.command('load-help', help='Load a directory of help .data and .meta file pairs into a wiki namespace')
-@click.option('--namespace', '-n', type=str, required=True,
-              help='Namespace to be loaded: help-common, help-en, etc.')
-@click.option('--path_to_help', '--path', '-p', type=str,
-              help='Override source directory, default is src/moin/help')
+@cli.command("load-help", help="Load a directory of help .data and .meta file pairs into a wiki namespace")
+@click.option("--namespace", "-n", type=str, required=True, help="Namespace to be loaded: help-common, help-en, etc.")
+@click.option("--path_to_help", "--path", "-p", type=str, help="Override source directory, default is src/moin/help")
 def cli_LoadHelp(namespace, path_to_help):
     return LoadHelp(namespace, path_to_help)
 
@@ -167,32 +170,30 @@ def LoadHelp(namespace, path_to_help):
         path_to_help = _get_path_to_help()
     path_to_items = os.path.normpath(os.path.join(path_to_help, namespace))
     if not os.path.isdir(path_to_items):
-        print(f'Abort: the {path_to_items} directory does not exist')
+        print(f"Abort: the {path_to_items} directory does not exist")
         return
     file_list = os.listdir(path_to_items)
     if len(file_list) == 0:
-        print(f'Abort: the {path_to_items} directory is empty')
+        print(f"Abort: the {path_to_items} directory is empty")
         return
     count = 0
     for f in file_list:
-        if f.endswith('.meta'):
+        if f.endswith(".meta"):
             # filenames must have / characters replaced with %2f, item will be saved with name(s) in metadata
-            item_name = f[:-5].replace('%2f', '/')
-            data_file = f.replace('.meta', '.data')
+            item_name = f[:-5].replace("%2f", "/")
+            data_file = f.replace(".meta", ".data")
             meta_file = os.path.join(path_to_items, f)
             data_file = os.path.join(path_to_items, data_file)
             PutItem(meta_file, data_file, "true")
-            print('Item loaded:', item_name)
+            print("Item loaded:", item_name)
             count += 1
-    print(f'Success: help namespace {namespace} loaded successfully with {count} items')
+    print(f"Success: help namespace {namespace} loaded successfully with {count} items")
 
 
-@cli.command('dump-help', help='Dump a namespace of user help items to .data and .meta file pairs')
-@click.option('--namespace', '-n', type=str, required=True,
-              help='Namespace to be dumped: help-common, help-en, etc.')
-@click.option('--path_to_help', '--path', '-p', type=str,
-              help='Override output directory, default is src/moin/help')
-@click.option('--crlf/--no-crlf', help='use windows line endings in output files')
+@cli.command("dump-help", help="Dump a namespace of user help items to .data and .meta file pairs")
+@click.option("--namespace", "-n", type=str, required=True, help="Namespace to be dumped: help-common, help-en, etc.")
+@click.option("--path_to_help", "--path", "-p", type=str, help="Override output directory, default is src/moin/help")
+@click.option("--crlf/--no-crlf", help="use windows line endings in output files")
 def DumpHelp(namespace, path_to_help, crlf):
     """
     Save an entire help namespace to the distribution source.
@@ -212,27 +213,23 @@ def DumpHelp(namespace, path_to_help, crlf):
         if file_.relname in no_alias_dups:
             continue
         # convert / characters to avoid invalid paths
-        esc_name = file_.relname.replace('/', '%2f')
-        meta_file = os.path.join(path_to_help, namespace, esc_name + '.meta')
-        data_file = os.path.join(path_to_help, namespace, esc_name + '.data')
-        alias_names = GetItem(str(file_.fullname), meta_file, data_file, CURRENT, '\r\n' if crlf else '\n')
+        esc_name = file_.relname.replace("/", "%2f")
+        meta_file = os.path.join(path_to_help, namespace, esc_name + ".meta")
+        data_file = os.path.join(path_to_help, namespace, esc_name + ".data")
+        alias_names = GetItem(str(file_.fullname), meta_file, data_file, CURRENT, "\r\n" if crlf else "\n")
         if alias_names:
             # no harm in adding current name to no_alias_dups
             no_alias_dups += alias_names
-        print('Item dumped::', file_.relname)
+        print("Item dumped::", file_.relname)
         count += 1
-    print(f'Success: help namespace {namespace} saved with {count} items')
-
-
-@cli.command('maint-validate-metadata', help='Find and optionally fix issues with item metadata')
-@click.option('--backends', '-b', type=str, required=False,
-              help='Backend names to serialize (comma separated).')
-@click.option('--all-backends', '-a', is_flag=True,
-              help='Serialize all configured backends.')
-@click.option('--verbose/--no-verbose', '-v', default=False,
-              help='Display detailed list of invalid metadata.')
-@click.option('--fix/--no-fix', '-f', default=False,
-              help='Fix invalid data.')
+    print(f"Success: help namespace {namespace} saved with {count} items")
+
+
+@cli.command("maint-validate-metadata", help="Find and optionally fix issues with item metadata")
+@click.option("--backends", "-b", type=str, required=False, help="Backend names to serialize (comma separated).")
+@click.option("--all-backends", "-a", is_flag=True, help="Serialize all configured backends.")
+@click.option("--verbose/--no-verbose", "-v", default=False, help="Display detailed list of invalid metadata.")
+@click.option("--fix/--no-fix", "-f", default=False, help="Fix invalid data.")
 def cli_ValidateMetadata(backends=None, all_backends=False, verbose=False, fix=False):
     ValidateMetadata(backends, all_backends, verbose, fix)
 
@@ -246,7 +243,7 @@ def _fix_if_bad(bad, meta, data, bad_revids, fix, backend):
                 rev = item.get_revision(meta[REVID])
                 dict(rev.meta)  # force load to validate rev is in index
             except KeyError:
-                logging.warning(f'bad revision not found in index {get_rev_str(meta)}')
+                logging.warning(f"bad revision not found in index {get_rev_str(meta)}")
                 backend.store(meta, data)
             else:
                 item.store_revision(meta, data, overwrite=True, trusted=True)
@@ -255,6 +252,7 @@ def _fix_if_bad(bad, meta, data, bad_revids, fix, backend):
 @dataclass
 class RevData:
     """class for storing data used to correct rev_number and parentid"""
+
     rev_id: str
     rev_number: int
     mtime: int
@@ -269,8 +267,9 @@ def ValidateMetadata(backends=None, all_backends=False, verbose=False, fix=False
     for backend in backends:
         revs: dict[str, list[RevData]] = defaultdict(list)
         for meta, data, issues in correcting_rev_iter(backend):
-            revs[meta[ITEMID]].append(RevData(meta[REVID], meta.get(REV_NUMBER, -1), meta.get(MTIME, -1),
-                                              meta.get(PARENTID)))
+            revs[meta[ITEMID]].append(
+                RevData(meta[REVID], meta.get(REV_NUMBER, -1), meta.get(MTIME, -1), meta.get(PARENTID))
+            )
             bad = len(issues) > 0
             if verbose:
                 for issue in issues:
@@ -283,18 +282,18 @@ def ValidateMetadata(backends=None, all_backends=False, verbose=False, fix=False
             for rev_data in rev_datum:
                 if prev_rev_data is None:
                     if rev_data.parent_id:
-                        rev_data.issues.append('parentid_error')
+                        rev_data.issues.append("parentid_error")
                         rev_data.parent_id = None
                     if rev_data.rev_number == -1:
-                        rev_data.issues.append('revision_number_error')
+                        rev_data.issues.append("revision_number_error")
                         rev_data.rev_number = 1
                 else:  # prev_rev_data is not None
                     if rev_data.parent_id != prev_rev_data.rev_id:
                         rev_data.parent_id = prev_rev_data.rev_id
-                        rev_data.issues.append('parentid_error')
+                        rev_data.issues.append("parentid_error")
                     if rev_data.rev_number <= prev_rev_data.rev_number:
                         rev_data.rev_number = prev_rev_data.rev_number + 1
-                        rev_data.issues.append('revision_number_error')
+                        rev_data.issues.append("revision_number_error")
                 prev_rev_data = rev_data
             for rev_data in [r for r in rev_datum if r.issues]:
                 bad = True
@@ -302,13 +301,17 @@ def ValidateMetadata(backends=None, all_backends=False, verbose=False, fix=False
                 rev_str = get_rev_str(meta)
                 if verbose:
                     for issue in rev_data.issues:
-                        if issue == 'parentid_error':
-                            print(f'{issue} {rev_str} meta_parentid: {meta.get(PARENTID)} '
-                                  f'correct_parentid: {rev_data.parent_id} '
-                                  f'meta_revision_number: {meta.get(REV_NUMBER)}')
+                        if issue == "parentid_error":
+                            print(
+                                f"{issue} {rev_str} meta_parentid: {meta.get(PARENTID)} "
+                                f"correct_parentid: {rev_data.parent_id} "
+                                f"meta_revision_number: {meta.get(REV_NUMBER)}"
+                            )
                         else:  # issue == 'revision_number_error'
-                            print(f'{issue} {rev_str} meta_revision_number: {meta.get(REV_NUMBER)} '
-                                  f'correct_revision_number: {rev_data.rev_number}')
+                            print(
+                                f"{issue} {rev_str} meta_revision_number: {meta.get(REV_NUMBER)} "
+                                f"correct_revision_number: {rev_data.rev_number}"
+                            )
                 if rev_data.parent_id:
                     meta[PARENTID] = rev_data.parent_id
                 else:
@@ -322,7 +325,7 @@ def ValidateMetadata(backends=None, all_backends=False, verbose=False, fix=False
     return bad_revids
 
 
-@cli.command('welcome', help='Load initial welcome page into an empty wiki')
+@cli.command("welcome", help="Load initial welcome page into an empty wiki")
 def cli_LoadWelcome():
     return LoadWelcome()
 
@@ -332,12 +335,12 @@ def LoadWelcome():
     Load a welcome page as initial home from distribution source.
     """
     logging.info("Load welcome page started")
-    path_to_items = _get_path_to_help('welcome')
-    for name in ['Home', 'users-Home']:
+    path_to_items = _get_path_to_help("welcome")
+    for name in ["Home", "users-Home"]:
         if app.storage.has_item(name):
-            logging.warning('Item with name %s exists and will not be overwritten.', name)
+            logging.warning("Item with name %s exists and will not be overwritten.", name)
         else:
-            meta_file = os.path.join(path_to_items, f'{name}.meta')
-            data_file = os.path.join(path_to_items, f'{name}.data')
+            meta_file = os.path.join(path_to_items, f"{name}.meta")
+            data_file = os.path.join(path_to_items, f"{name}.data")
             PutItem(meta_file, data_file, "true")
     logging.info("Load welcome finished")
diff --git a/src/moin/cli/maint/reduce_revisions.py b/src/moin/cli/maint/reduce_revisions.py
index 54bfa6fc3..b241f2573 100644
--- a/src/moin/cli/maint/reduce_revisions.py
+++ b/src/moin/cli/maint/reduce_revisions.py
@@ -24,6 +24,7 @@
 from moin.app import create_app, before_wiki
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -32,14 +33,18 @@ def cli():
     pass
 
 
-@cli.command("maint-reduce-revisions",
-             help="Remove all revisions but the last one from all selected items.")
-@click.option('--query', '-q', type=str, default='',
-              help='Only perform the operation on items found by the given query.')
-@click.option('--namespace', '-n', type=str, default='',
-              help='Limit selection to a namespace; use "default" for default namespace.')
-@click.option('--test', '-t', type=bool, default=0,
-              help='List selected items, but do not update.')
+@cli.command("maint-reduce-revisions", help="Remove all revisions but the last one from all selected items.")
+@click.option(
+    "--query", "-q", type=str, default="", help="Only perform the operation on items found by the given query."
+)
+@click.option(
+    "--namespace",
+    "-n",
+    type=str,
+    default="",
+    help='Limit selection to a namespace; use "default" for default namespace.',
+)
+@click.option("--test", "-t", type=bool, default=0, help="List selected items, but do not update.")
 def ReduceRevisions(query, namespace, test):
     logging.info("Reduce revisions started")
     before_wiki()
@@ -48,8 +53,8 @@ def ReduceRevisions(query, namespace, test):
         if query:
             q = And([q, Regex(NAME_EXACT, query)])
         if namespace:
-            if namespace == 'default':
-                namespace = ''
+            if namespace == "default":
+                namespace = ""
             q = And([q, Term(NAMESPACE, namespace)])
     else:
         q = Not(Term(NAMESPACE, NAMESPACE_USERPROFILES))
@@ -59,10 +64,11 @@ def ReduceRevisions(query, namespace, test):
         current_revid = current_rev.meta[REVID]
         current_namespace = current_rev.meta[NAMESPACE]
         current_revno = current_rev.meta[REV_NUMBER]
-        current_full_name = current_namespace + '/' + current_name[0] if current_namespace else current_name
+        current_full_name = current_namespace + "/" + current_name[0] if current_namespace else current_name
         if test:
-            print("Item named {!r} selected but not updated, has {} revisions :".format(current_full_name,
-                                                                                          current_revno))
+            print(
+                "Item named {!r} selected but not updated, has {} revisions :".format(current_full_name, current_revno)
+            )
         else:
             print(f"Destroying historical revisions of {current_full_name!r}:")
             has_historical_revision = False
diff --git a/src/moin/cli/maint/serialization.py b/src/moin/cli/maint/serialization.py
index be3931348..f05a44a08 100644
--- a/src/moin/cli/maint/serialization.py
+++ b/src/moin/cli/maint/serialization.py
@@ -18,6 +18,7 @@
 from moin.cli._util import get_backends, drop_and_recreate_index
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -40,6 +41,7 @@ def open_file(filename, mode):
         if sys.platform == "win32" and "b" in mode:
             import os
             import msvcrt
+
             msvcrt.setmode(stream.fileno(), os.O_BINARY)
 
         f = stream
@@ -48,13 +50,10 @@ def open_file(filename, mode):
     return f
 
 
-@cli.command('save', help='Serialize the backend into a file')
-@click.option('--file', '-f', type=str, required=False,
-              help='Filename of the output file.')
-@click.option('--backends', '-b', type=str, required=False,
-              help='Backend names to serialize (comma separated).')
-@click.option('--all-backends', '-a', is_flag=True,
-              help='Serialize all configured backends.')
+@cli.command("save", help="Serialize the backend into a file")
+@click.option("--file", "-f", type=str, required=False, help="Filename of the output file.")
+@click.option("--backends", "-b", type=str, required=False, help="Backend names to serialize (comma separated).")
+@click.option("--all-backends", "-a", is_flag=True, help="Serialize all configured backends.")
 def Serialize(file=None, backends=None, all_backends=False):
     logging.info("Backup started")
     if file is None:
@@ -70,15 +69,32 @@ def Serialize(file=None, backends=None, all_backends=False):
     logging.info("Backup finished")
 
 
-@cli.command('load', help='Deserialize a file into the backend; with options to rename or remove a namespace')
-@click.option('--file', '-f', type=str, required=True,
-              help='Filename of the input file.')
-@click.option('--new-ns', '-n', type=str, required=False, default=None,
-              help='New namespace name to receive items from the old namespace name.')
-@click.option('--old-ns', '-o', type=str, required=False, default=None,
-              help='Old namespace that will be deleted, all items to be restored to new namespace.')
-@click.option('--kill-ns', '-k', type=str, required=False, default=None,
-              help='Namespace name to be deleted, no items within this namespace will be loaded.')
+@cli.command("load", help="Deserialize a file into the backend; with options to rename or remove a namespace")
+@click.option("--file", "-f", type=str, required=True, help="Filename of the input file.")
+@click.option(
+    "--new-ns",
+    "-n",
+    type=str,
+    required=False,
+    default=None,
+    help="New namespace name to receive items from the old namespace name.",
+)
+@click.option(
+    "--old-ns",
+    "-o",
+    type=str,
+    required=False,
+    default=None,
+    help="Old namespace that will be deleted, all items to be restored to new namespace.",
+)
+@click.option(
+    "--kill-ns",
+    "-k",
+    type=str,
+    required=False,
+    default=None,
+    help="Namespace name to be deleted, no items within this namespace will be loaded.",
+)
 def Deserialize(file=None, new_ns=None, old_ns=None, kill_ns=None):
     logging.info("Load backup started")
     with open_file(file, "rb") as f:
diff --git a/src/moin/cli/maint/set_meta.py b/src/moin/cli/maint/set_meta.py
index fa7b8f359..0843dd696 100644
--- a/src/moin/cli/maint/set_meta.py
+++ b/src/moin/cli/maint/set_meta.py
@@ -36,20 +36,27 @@ def cli():
     pass
 
 
-@cli.command('maint-set-meta', help='Set meta data of a new revision')
-@click.option('--key', '-k', required=False, type=str,
-              help="The key you want to set/change in the new revision")
-@click.option('--value', '-v', type=str, help='The value to set for the given key.')
-@click.option('--remove', '-r', is_flag=True, required=False, default=False,
-              help='If you want to delete the key given, add this flag.')
-@click.option('--query', '-q', type=str, default='',
-              help='Only perform the operation on items found by the given query.')
+@cli.command("maint-set-meta", help="Set meta data of a new revision")
+@click.option("--key", "-k", required=False, type=str, help="The key you want to set/change in the new revision")
+@click.option("--value", "-v", type=str, help="The value to set for the given key.")
+@click.option(
+    "--remove",
+    "-r",
+    is_flag=True,
+    required=False,
+    default=False,
+    help="If you want to delete the key given, add this flag.",
+)
+@click.option(
+    "--query", "-q", type=str, default="", help="Only perform the operation on items found by the given query."
+)
 def SetMeta(key, value, remove, query):
     logging.info("Set meta started")
     flaskg.add_lineno_attr = False
     if not ((key and value) or (key and remove)) or (key and value and remove):
-        sys.exit("You need to either specify a proper key/value pair or "
-                 "only a key you want to delete (with -r set).")
+        sys.exit(
+            "You need to either specify a proper key/value pair or " "only a key you want to delete (with -r set)."
+        )
 
     if not remove:
         try:
@@ -58,7 +65,7 @@ def SetMeta(key, value, remove, query):
             sys.exit("You need to specify a valid Python literal as the argument")
 
     if query:
-        qp = app.storage.query_parser([NAME_EXACT, ])
+        qp = app.storage.query_parser([NAME_EXACT])
         q = qp.parse(query)
     else:
         q = Every()
diff --git a/src/moin/cli/migration/moin19/_logfile19.py b/src/moin/cli/migration/moin19/_logfile19.py
index 56216c469..b6b87aa6b 100644
--- a/src/moin/cli/migration/moin19/_logfile19.py
+++ b/src/moin/cli/migration/moin19/_logfile19.py
@@ -13,17 +13,18 @@
 import errno
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-CHARSET = 'utf-8'
+CHARSET = "utf-8"
 
 
 class LogError(Exception):
-    """ Base class for log errors """
+    """Base class for log errors"""
 
 
 class LogMissing(LogError):
-    """ Raised when the log is missing """
+    """Raised when the log is missing"""
 
 
 class LineBuffer:
@@ -35,6 +36,7 @@ class LineBuffer:
     :ivar offsets: list of file offsets for each line. additionally the position
                    after the last read line is stored into self.offsets[-1]
     """
+
     def __init__(self, file, offset, size, forward=True):
         """
 
@@ -112,7 +114,7 @@ def __iter__(self):
         return self
 
     def reverse(self):
-        """ yield log entries in reverse direction starting from last one
+        """yield log entries in reverse direction starting from last one
 
         :rtype: iterator
         """
@@ -126,7 +128,7 @@ def reverse(self):
             yield result
 
     def sanityCheck(self):
-        """ Check for log file write access.
+        """Check for log file write access.
 
         :rtype: string (error message) or None
         """
@@ -141,9 +143,7 @@ def __getattr__(self, name):
         if name == "_LogFile__rel_index":  # Python black magic: this is the real name of the __rel_index attribute
             # starting iteration from begin
             self.__buffer1 = LineBuffer(self._input, 0, self.buffer_size)
-            self.__buffer2 = LineBuffer(self._input,
-                                        self.__buffer1.offsets[-1],
-                                        self.buffer_size)
+            self.__buffer2 = LineBuffer(self._input, self.__buffer1.offsets[-1], self.buffer_size)
             self.__buffer = self.__buffer1
             self.__rel_index = 0
             return 0
@@ -151,28 +151,28 @@ def __getattr__(self, name):
             try:
                 # Open the file (NOT using codecs.open, it breaks our offset calculation. We decode it later.).
                 # Use binary mode in order to retain \r - otherwise the offset calculation would fail.
-                self._input = open(self.__filename, "rb", )
+                self._input = open(self.__filename, "rb")
             except OSError as err:
                 if err.errno == errno.ENOENT:  # "file not found"
                     # XXX workaround if edit-log does not exist: just create it empty
                     # if this workaround raises another error, we don't catch
                     # it, so the admin will see it.
                     f = open(self.__filename, "ab")
-                    f.write('')
+                    f.write("")
                     f.close()
-                    self._input = open(self.__filename, "rb", )
+                    self._input = open(self.__filename, "rb")
                 else:
                     logging.error(f"logfile: {self.__filename!r} IOERROR errno {err.errno} ({os.strerror(err.errno)})")
                     raise
             return self._input
         elif name == "_output":
-            self._output = codecs.open(self.__filename, 'a', CHARSET)
+            self._output = codecs.open(self.__filename, "a", CHARSET)
             return self._output
         else:
             raise AttributeError(name)
 
     def size(self):
-        """ Return log size in bytes
+        """Return log size in bytes
 
         Return 0 if the file does not exist. Raises other OSError.
 
@@ -187,7 +187,7 @@ def size(self):
             raise
 
     def lines(self):
-        """ Return number of lines in the log file
+        """Return number of lines in the log file
 
         Return 0 if the file does not exist. Raises other OSError.
 
@@ -211,7 +211,7 @@ def lines(self):
             raise
 
     def peek(self, lines):
-        """ Move position in file forward or backwards by "lines" count
+        """Move position in file forward or backwards by "lines" count
 
         It adjusts .__lineno if set.
         This function is not aware of filters!
@@ -243,10 +243,7 @@ def peek(self, lines):
                 else:
                     # load previous lines
                     self.__buffer2 = self.__buffer1
-                    self.__buffer1 = LineBuffer(self._input,
-                                                self.__buffer.offsets[0],
-                                                self.buffer_size,
-                                                forward=False)
+                    self.__buffer1 = LineBuffer(self._input, self.__buffer.offsets[0], self.buffer_size, forward=False)
                     self.__buffer = self.__buffer1
                     self.__rel_index += self.__buffer.len
 
@@ -257,13 +254,11 @@ def peek(self, lines):
                 self.__buffer = self.__buffer2
             else:  # self.__buffer is self.__buffer2
                 # try to load next buffer
-                tmpbuff = LineBuffer(self._input,
-                                     self.__buffer.offsets[-1],
-                                     self.buffer_size)
+                tmpbuff = LineBuffer(self._input, self.__buffer.offsets[-1], self.buffer_size)
                 if tmpbuff.len == 0:
                     # end of file
                     if self.__lineno is not None:
-                        self.__lineno += (lines - (self.__rel_index - self.__buffer.len))
+                        self.__lineno += lines - (self.__rel_index - self.__buffer.len)
                     self.__rel_index = self.__buffer.len  # point to after last read line
                     return True
                 # shift buffers
@@ -324,12 +319,8 @@ def to_begin(self):
         """moves file position to the begin"""
         logging.log(self.loglevel, f"LogFile.to_begin {self.__filename}")
         if self.__buffer1 is None or self.__buffer1.offsets[0] != 0:
-            self.__buffer1 = LineBuffer(self._input,
-                                        0,
-                                        self.buffer_size)
-            self.__buffer2 = LineBuffer(self._input,
-                                        self.__buffer1.offsets[-1],
-                                        self.buffer_size)
+            self.__buffer1 = LineBuffer(self._input, 0, self.buffer_size)
+            self.__buffer2 = LineBuffer(self._input, self.__buffer1.offsets[-1], self.buffer_size)
         self.__buffer = self.__buffer1
         self.__rel_index = 0
         self.__lineno = 0
@@ -340,21 +331,15 @@ def to_end(self):
         self._input.seek(0, 2)  # to end of file
         size = self._input.tell()
         if self.__buffer2 is None or size > self.__buffer2.offsets[-1]:
-            self.__buffer2 = LineBuffer(self._input,
-                                        size,
-                                        self.buffer_size,
-                                        forward=False)
-
-            self.__buffer1 = LineBuffer(self._input,
-                                        self.__buffer2.offsets[0],
-                                        self.buffer_size,
-                                        forward=False)
+            self.__buffer2 = LineBuffer(self._input, size, self.buffer_size, forward=False)
+
+            self.__buffer1 = LineBuffer(self._input, self.__buffer2.offsets[0], self.buffer_size, forward=False)
         self.__buffer = self.__buffer2
         self.__rel_index = self.__buffer2.len
         self.__lineno = None
 
     def position(self):
-        """ Return the current file position
+        """Return the current file position
 
         This can be converted into a String using back-ticks and then be rebuild.
         For this plain file implementation position is an Integer.
@@ -362,7 +347,7 @@ def position(self):
         return self.__buffer.offsets[self.__rel_index]
 
     def seek(self, position, line_no=None):
-        """ moves file position to an value formerly gotten from .position().
+        """moves file position to an value formerly gotten from .position().
         To enable line counting line_no must be provided.
         .seek is much more efficient for moving long distances than .peek.
         raises ValueError if position is invalid
@@ -382,28 +367,19 @@ def seek(self, position, line_no=None):
             self.__buffer = self.__buffer2
         elif self.__buffer1 and self.__buffer1.offsets[-1] == position:
             # we already have one buffer directly before where we want to go
-            self.__buffer2 = LineBuffer(self._input,
-                                        position,
-                                        self.buffer_size)
+            self.__buffer2 = LineBuffer(self._input, position, self.buffer_size)
             self.__buffer = self.__buffer2
             self.__rel_index = 0
         elif self.__buffer2 and self.__buffer2.offsets[-1] == position:
             # we already have one buffer directly before where we want to go
             self.__buffer1 = self.__buffer2
-            self.__buffer2 = LineBuffer(self._input,
-                                        position,
-                                        self.buffer_size)
+            self.__buffer2 = LineBuffer(self._input, position, self.buffer_size)
             self.__buffer = self.__buffer2
             self.__rel_index = 0
         else:
             # load buffers around position
-            self.__buffer1 = LineBuffer(self._input,
-                                        position,
-                                        self.buffer_size,
-                                        forward=False)
-            self.__buffer2 = LineBuffer(self._input,
-                                        position,
-                                        self.buffer_size)
+            self.__buffer1 = LineBuffer(self._input, position, self.buffer_size, forward=False)
+            self.__buffer2 = LineBuffer(self._input, position, self.buffer_size)
             self.__buffer = self.__buffer2
             self.__rel_index = 0
             # XXX test for valid position
@@ -414,7 +390,7 @@ def line_no(self):
         return self.__lineno
 
     def calculate_line_no(self):
-        """ Calculate the current line number from buffer offsets
+        """Calculate the current line number from buffer offsets
 
         If line number is unknown it is calculated by parsing the whole file.
         This may be expensive.
@@ -451,8 +427,8 @@ def _add(self, line):
         write on entry in the log file
         """
         if line is not None:
-            if line[-1] != '\n':
-                line += '\n'
+            if line[-1] != "\n":
+                line += "\n"
             self._output.write(line)
             self._output.close()  # does this maybe help against the
             # sporadic fedora wikis 160 \0 bytes in the edit-log?
diff --git a/src/moin/cli/migration/moin19/_utils19.py b/src/moin/cli/migration/moin19/_utils19.py
index 7ae9f6401..ed31dd3ae 100644
--- a/src/moin/cli/migration/moin19/_utils19.py
+++ b/src/moin/cli/migration/moin19/_utils19.py
@@ -12,8 +12,8 @@
 
 
 # Precompiled patterns for file name [un]quoting
-UNSAFE = re.compile(r'[^a-zA-Z0-9_]+')
-QUOTED = re.compile(r'\(([a-fA-F0-9]+)\)')
+UNSAFE = re.compile(r"[^a-zA-Z0-9_]+")
+QUOTED = re.compile(r"\(([a-fA-F0-9]+)\)")
 
 
 def split_body(body):
@@ -27,35 +27,35 @@ def split_body(body):
     """
     pi = {}
     comments = []
-    while body.startswith('#'):
+    while body.startswith("#"):
         try:
-            line, body = body.split('\n', 1)  # extract first line
-            line = line.rstrip('\r')
+            line, body = body.split("\n", 1)  # extract first line
+            line = line.rstrip("\r")
         except ValueError:
             line = body
-            body = ''
+            body = ""
 
         # end parsing on empty (invalid) PI
         if line == "#":
-            body = line + '\n' + body
+            body = line + "\n" + body
             break
 
-        if line[1] == '#':  # two hash marks are a comment
-            comments.append(line + '\n')
+        if line[1] == "#":  # two hash marks are a comment
+            comments.append(line + "\n")
         else:
-            verb, args = (line[1:] + ' ').split(' ', 1)  # split at the first blank
+            verb, args = (line[1:] + " ").split(" ", 1)  # split at the first blank
             pi.setdefault(verb.lower(), []).append(args.strip())
 
     for key, value in pi.items():
-        if key in ['acl', ]:
+        if key in ["acl"]:
             # join the list of values to a single value
-            pi[key] = ' '.join(value)
+            pi[key] = " ".join(value)
         else:
             # for keys that can't occur multiple times, don't use a list:
             pi[key] = value[-1]  # use the last value to copy 1.9 parsing behaviour
 
     if comments:
-        body = ''.join(comments) + body
+        body = "".join(comments) + body
 
     return pi, body
 
@@ -64,7 +64,7 @@ def add_metadata_to_body(metadata, data):
     """
     Adds the processing instructions to the data.
     """
-    meta_keys = [NAME, ACL, CONTENTTYPE, MTIME, LANGUAGE, ]
+    meta_keys = [NAME, ACL, CONTENTTYPE, MTIME, LANGUAGE]
 
     metadata_data = ""
     for key, value in metadata.items():
@@ -97,21 +97,22 @@ def quoteWikinameFS(wikiname, charset=CHARSET19):
     location = 0
     for needle in UNSAFE.finditer(filename):
         # append leading safe stuff
-        quoted.append(filename[location:needle.start()])
+        quoted.append(filename[location : needle.start()])
         location = needle.end()
         # Quote and append unsafe stuff
-        quoted.append('(')
+        quoted.append("(")
         for character in needle.group():
             quoted.append(f"{ord(character):02x}")
-        quoted.append(')')
+        quoted.append(")")
 
     # append rest of string
     quoted.append(filename[location:])
-    return ''.join(quoted)
+    return "".join(quoted)
 
 
 class InvalidFileNameError(Exception):
-    """ Called when we find an invalid file name """
+    """Called when we find an invalid file name"""
+
     pass
 
 
@@ -130,16 +131,16 @@ def unquoteWikiname(filename, charset=CHARSET19):
     start = 0
     for needle in QUOTED.finditer(filename):
         # append leading unquoted stuff
-        parts.append(filename[start:needle.start()].encode(charset))
+        parts.append(filename[start : needle.start()].encode(charset))
         start = needle.end()
         # Append quoted stuff
         group = needle.group(1)
         # Filter invalid filenames
-        if (len(group) % 2 != 0):
+        if len(group) % 2 != 0:
             raise InvalidFileNameError(filename)
         try:
             for i in range(0, len(group), 2):
-                byte = group[i:i + 2]
+                byte = group[i : i + 2]
                 parts.append(bytes.fromhex(byte))
         except ValueError:
             # byte not in hex, e.g 'xy'
@@ -149,7 +150,7 @@ def unquoteWikiname(filename, charset=CHARSET19):
     if start == 0:
         wikiname = filename.encode(charset)
     else:
-        parts.append(filename[start:len(filename)].encode(charset))
-        wikiname = b''.join(parts)
+        parts.append(filename[start : len(filename)].encode(charset))
+        wikiname = b"".join(parts)
 
     return wikiname.decode(charset)
diff --git a/src/moin/cli/migration/moin19/import19.py b/src/moin/cli/migration/moin19/import19.py
index 25e3f0727..9061ae14b 100644
--- a/src/moin/cli/migration/moin19/import19.py
+++ b/src/moin/cli/migration/moin19/import19.py
@@ -46,6 +46,7 @@
 from moin.utils.tree import moin_page, xlink
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -54,31 +55,31 @@ def cli():
     pass
 
 
-UID_OLD = 'old_user_id'  # dynamic field *_id, so we don't have to change schema
+UID_OLD = "old_user_id"  # dynamic field *_id, so we don't have to change schema
 
-ACL_RIGHTS_CONTENTS = ['read', 'write', 'create', 'destroy', 'admin', ]
+ACL_RIGHTS_CONTENTS = ["read", "write", "create", "destroy", "admin"]
 
-DELETED_MODE_KEEP = 'keep'
-DELETED_MODE_KILL = 'kill'
+DELETED_MODE_KEEP = "keep"
+DELETED_MODE_KILL = "kill"
 
-CONTENTTYPE_DEFAULT = 'text/plain;charset=utf-8'
-CONTENTTYPE_MOINWIKI = 'text/x.moin.wiki;format=1.9;charset=utf-8'
+CONTENTTYPE_DEFAULT = "text/plain;charset=utf-8"
+CONTENTTYPE_MOINWIKI = "text/x.moin.wiki;format=1.9;charset=utf-8"
 FORMAT_TO_CONTENTTYPE = {
-    'wiki': CONTENTTYPE_MOINWIKI,
-    'text/wiki': CONTENTTYPE_MOINWIKI,
-    'text/moin-wiki': CONTENTTYPE_MOINWIKI,
-    'creole': 'text/x.moin.creole;charset=utf-8',
-    'python': 'text/x-python;charset=utf-8',
-    'text/creole': 'text/x.moin.creole;charset=utf-8',
-    'rst': 'text/x-rst;charset=utf-8',
-    'text/rst': 'text/x-rst;charset=utf-8',
-    'plain': 'text/plain;charset=utf-8',
-    'text/plain': 'text/plain;charset=utf-8',
-    'csv': 'text/csv;charset=utf-8',
-    'text/csv': 'text/csv;charset=utf-8',
-    'docbook': 'application/docbook+xml;charset=utf-8',
+    "wiki": CONTENTTYPE_MOINWIKI,
+    "text/wiki": CONTENTTYPE_MOINWIKI,
+    "text/moin-wiki": CONTENTTYPE_MOINWIKI,
+    "creole": "text/x.moin.creole;charset=utf-8",
+    "python": "text/x-python;charset=utf-8",
+    "text/creole": "text/x.moin.creole;charset=utf-8",
+    "rst": "text/x-rst;charset=utf-8",
+    "text/rst": "text/x-rst;charset=utf-8",
+    "plain": "text/plain;charset=utf-8",
+    "text/plain": "text/plain;charset=utf-8",
+    "csv": "text/csv;charset=utf-8",
+    "text/csv": "text/csv;charset=utf-8",
+    "docbook": "application/docbook+xml;charset=utf-8",
 }
-MIGR_STAT_KEYS = ['revs', 'items', 'attachments', 'users', 'missing_user', 'missing_file', 'del_item']
+MIGR_STAT_KEYS = ["revs", "items", "attachments", "users", "missing_user", "missing_file", "del_item"]
 
 special_users_lower = [user.lower() for user in SPECIAL_USERS]
 
@@ -91,11 +92,11 @@ def cli():
 
 
 def migr_logging(msg_id, log_msg):
-    '''
+    """
     The logging function writes the first messages of each type
     with warning level and the rest with debug level only.
     See docs/examples/config/logging/logfile_cli for logging configuration example
-    '''
+    """
     migr_stat[msg_id] += 1
     if migr_stat[msg_id] < migr_warn_max:
         logging.warning(log_msg)
@@ -113,7 +114,7 @@ def migr_statistics(unknown_macros):
     logging.info(f"Revisions:   {migr_stat['revs']:6d}")
     logging.info(f"Attachments: {migr_stat['attachments']:6d}")
 
-    for message in ['missing_user', 'missing_file', 'del_item']:
+    for message in ["missing_user", "missing_file", "del_item"]:
         if migr_stat[message] > 0:
             logging.info(f"Warnings:    {migr_stat[message]:6d} - {message}")
 
@@ -121,15 +122,28 @@ def migr_statistics(unknown_macros):
         logging.info(f"Warnings:    {len(unknown_macros):6d} - unknown macros {str(unknown_macros)[1:-1]}")
 
 
-@cli.command('import19', help='Import content and user data from a moin 1.9 wiki')
-@click.option('--data_dir', '-d', type=str, required=True,
-              help='moin 1.9 data_dir (contains pages and users subdirectories).')
-@click.option('--markup_out', '-m', type=click.Choice(CONTENTTYPE_MARKUP_OUT.keys()),
-              required=False, default='moinwiki', help='target markup.')
-@click.option('--namespace', '-n', type=str, required=False, default=NAMESPACE_DEFAULT,
-              help='target namespace, e.g. used for members of a wikifarm.')
+@cli.command("import19", help="Import content and user data from a moin 1.9 wiki")
+@click.option(
+    "--data_dir", "-d", type=str, required=True, help="moin 1.9 data_dir (contains pages and users subdirectories)."
+)
+@click.option(
+    "--markup_out",
+    "-m",
+    type=click.Choice(CONTENTTYPE_MARKUP_OUT.keys()),
+    required=False,
+    default="moinwiki",
+    help="target markup.",
+)
+@click.option(
+    "--namespace",
+    "-n",
+    type=str,
+    required=False,
+    default=NAMESPACE_DEFAULT,
+    help="target namespace, e.g. used for members of a wikifarm.",
+)
 def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
-    '''  Import content and user data from a moin wiki with version 1.9 '''
+    """Import content and user data from a moin wiki with version 1.9"""
 
     target_namespace = namespace
     flaskg.add_lineno_attr = False
@@ -142,7 +156,7 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
     custom_namespaces = namespaces()
 
     logging.info("PHASE1: Converting Users ...")
-    user_dir = os.path.join(data_dir, 'user')
+    user_dir = os.path.join(data_dir, "user")
     if os.path.isdir(user_dir):
         for rev in UserBackend(user_dir):
             global user_names
@@ -151,11 +165,12 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
             backend.store(rev.meta, rev.data)
 
     logging.info("PHASE2: Converting Pages and Attachments ...")
-    for rev in PageBackend(data_dir, deleted_mode=DELETED_MODE_KILL,
-                           default_markup='wiki', target_namespace=target_namespace):
+    for rev in PageBackend(
+        data_dir, deleted_mode=DELETED_MODE_KILL, default_markup="wiki", target_namespace=target_namespace
+    ):
         for user_name in user_names:
-            if rev.meta[NAME][0] == user_name or rev.meta[NAME][0].startswith(user_name + '/'):
-                rev.meta[NAMESPACE] = 'users'
+            if rev.meta[NAME][0] == user_name or rev.meta[NAME][0].startswith(user_name + "/"):
+                rev.meta[NAMESPACE] = "users"
                 users_itemlist.add(rev.meta[NAME][0])  # save itemname for link migration
                 break
 
@@ -164,11 +179,14 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
                 rev.meta[USERID] = userid_old2new[rev.meta[USERID]]
             except KeyError:
                 # user profile lost, but userid referred by revision
-                migr_logging('missing_user',
-                             'Missing userid {!r}, editor of {} revision {}'.format(
-                                 rev.meta[USERID], rev.meta[NAME][0], rev.meta[REVID]))
+                migr_logging(
+                    "missing_user",
+                    "Missing userid {!r}, editor of {} revision {}".format(
+                        rev.meta[USERID], rev.meta[NAME][0], rev.meta[REVID]
+                    ),
+                )
                 del rev.meta[USERID]
-        migr_stat['revs'] += 1
+        migr_stat["revs"] += 1
         backend.store(rev.meta, rev.data)
         # item_name to itemid xref required for migrating user subscriptions
         flaskg.item_name2id[rev.meta[NAME][0]] = rev.meta[ITEMID]
@@ -178,20 +196,23 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
     conv_out_module = importlib.import_module("moin.converters." + markup_out + "_out")
     conv_out = conv_out_module.Converter()
     reg = default_registry
-    refs_conv = reg.get(type_moin_document, type_moin_document, items='refs')
+    refs_conv = reg.get(type_moin_document, type_moin_document, items="refs")
     for item_name, (revno, namespace) in sorted(last_moin19_rev.items()):
         try:
             logging.debug(f'Processing item "{item_name}", namespace "{namespace}", revision "{revno}"')
         except UnicodeEncodeError:
-            logging.debug('Processing item "{}", namespace "{}", revision "{}"'.format(
-                item_name.encode('ascii', errors='replace'), namespace, revno))
-        if namespace == '':
-            namespace = 'default'
+            logging.debug(
+                'Processing item "{}", namespace "{}", revision "{}"'.format(
+                    item_name.encode("ascii", errors="replace"), namespace, revno
+                )
+            )
+        if namespace == "":
+            namespace = "default"
         meta, data = backend.retrieve(namespace, revno)
         data_in = data.read().decode(CHARSET19)
         dom = conv_in(data_in, CONTENTTYPE_MOINWIKI)
 
-        iri = Iri(scheme='wiki', authority='', path='/' + item_name)
+        iri = Iri(scheme="wiki", authority="", path="/" + item_name)
         dom.set(moin_page.page_href, str(iri))
         refs_conv(dom)
 
@@ -201,12 +222,12 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
         user_itemlinks2chg = []
         namespace_itemlinks2chg = []
         for link in itemlinks_19:
-            if link in users_itemlist or link.split('/')[0] in users_itemlist:
+            if link in users_itemlist or link.split("/")[0] in users_itemlist:
                 user_itemlinks2chg.append(link)
-            elif link not in custom_namespaces and link.split('/')[0] not in custom_namespaces:
+            elif link not in custom_namespaces and link.split("/")[0] not in custom_namespaces:
                 namespace_itemlinks2chg.append(link)
         if len(user_itemlinks2chg) > 0:
-            migrate_itemlinks(dom,  NAMESPACE_USERS, user_itemlinks2chg)
+            migrate_itemlinks(dom, NAMESPACE_USERS, user_itemlinks2chg)
         if len(namespace_itemlinks2chg) > 0:
             migrate_itemlinks(dom, target_namespace, namespace_itemlinks2chg)
 
@@ -229,12 +250,12 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
         meta[REV_NUMBER] = meta[REV_NUMBER] + 1
         # bumping modified time makes global and item history views more useful
         meta[MTIME] = meta[MTIME] + 1
-        meta[COMMENT] = 'Converted moin 1.9 markup to ' + markup_out + ' markup'
-        if meta[NAME][0].endswith('Group') and meta[USERGROUP]:
-            msg = 'Moin1.x user list moved to User Group metadata; item content ignored. Use ShowUserGroup macro. '
+        meta[COMMENT] = "Converted moin 1.9 markup to " + markup_out + " markup"
+        if meta[NAME][0].endswith("Group") and meta[USERGROUP]:
+            msg = "Moin1.x user list moved to User Group metadata; item content ignored. Use ShowUserGroup macro. "
             meta[COMMENT] = msg + meta[COMMENT]
-        if meta[NAME][0].endswith('Dict') and meta[WIKIDICT]:
-            msg = 'Moin1.x Wiki Dict data moved to Wiki Dict metadata; item content ignored. Use ShowWikiDict macro. '
+        if meta[NAME][0].endswith("Dict") and meta[WIKIDICT]:
+            msg = "Moin1.x Wiki Dict data moved to Wiki Dict metadata; item content ignored. Use ShowWikiDict macro. "
             meta[COMMENT] = msg + meta[COMMENT]
         meta[CONTENTTYPE] = CONTENTTYPE_MARKUP_OUT[markup_out]
         del meta[DATAID]
@@ -245,7 +266,7 @@ def ImportMoin19(data_dir=None, markup_out=None, namespace=None):
     drop_and_recreate_index(app.storage)
 
     logging.info("Finished conversion!")
-    if hasattr(conv_out, 'unknown_macro_list'):
+    if hasattr(conv_out, "unknown_macro_list"):
         migr_statistics(unknown_macros=conv_out.unknown_macro_list)
     else:
         migr_statistics([])
@@ -259,10 +280,15 @@ class PageBackend:
     """
     moin 1.9 page directory
     """
-    def __init__(self, path, deleted_mode=DELETED_MODE_KEEP,
-                 default_markup='wiki',
-                 target_namespace='',
-                 item_category_regex=r'(?P<all>Category(?P<key>(?!Template)\S+))'):
+
+    def __init__(
+        self,
+        path,
+        deleted_mode=DELETED_MODE_KEEP,
+        default_markup="wiki",
+        target_namespace="",
+        item_category_regex=r"(?P<all>Category(?P<key>(?!Template)\S+))",
+    ):
         """
         :param path: storage path (data_dir)
         :param deleted_mode: 'kill' - just ignore deleted pages (pages with
@@ -278,14 +304,14 @@ def __init__(self, path, deleted_mode=DELETED_MODE_KEEP,
         :param target_namespace : target namespace
         """
         self._path = path
-        assert deleted_mode in (DELETED_MODE_KILL, DELETED_MODE_KEEP, )
+        assert deleted_mode in (DELETED_MODE_KILL, DELETED_MODE_KEEP)
         self.deleted_mode = deleted_mode
         self.format_default = default_markup
         self.target_namespace = target_namespace
         self.item_category_regex = re.compile(item_category_regex, re.UNICODE)
 
     def __iter__(self):
-        pages_dir = os.path.join(self._path, 'pages')
+        pages_dir = os.path.join(self._path, "pages")
         # sort by moin 1.9 directory names, non-ascii characters converted to 2 hex characters and enclosed in (..)
         pages = sorted(os.listdir(pages_dir))
         for f in pages:
@@ -295,12 +321,13 @@ def __iter__(self):
             except KillRequested:
                 pass  # a message was already output
             except (OSError, AttributeError):
-                migr_logging('missing_file',
-                             f"Missing file 'current' or 'edit-log' for {os.path.normcase(os.path.join(pages_dir, f))}"
-                             )
+                migr_logging(
+                    "missing_file",
+                    f"Missing file 'current' or 'edit-log' for {os.path.normcase(os.path.join(pages_dir, f))}",
+                )
 
             except Exception:
-                logging.exception(f"PageItem {itemname!r} raised exception:").encode('utf-8')
+                logging.exception(f"PageItem {itemname!r} raised exception:").encode("utf-8")
             else:
                 yield from item.iter_revisions()
                 yield from item.iter_attachments()
@@ -310,6 +337,7 @@ class PageItem:
     """
     moin 1.9 page
     """
+
     def __init__(self, backend, path, itemname, target_namespace):
         self.backend = backend
         self.name = itemname
@@ -320,25 +348,23 @@ def __init__(self, backend, path, itemname, target_namespace):
             logging.debug(f"Processing item {itemname}")
         except UnicodeEncodeError:
             logging.debug(f"Processing item {itemname.encode('ascii', errors='replace')}")
-        currentpath = os.path.join(self.path, 'current')
+        currentpath = os.path.join(self.path, "current")
         with open(currentpath) as f:
             self.current = int(f.read().strip())
-        editlogpath = os.path.join(self.path, 'edit-log')
+        editlogpath = os.path.join(self.path, "edit-log")
         self.editlog = EditLog(editlogpath)
         self.acl = None
         self.itemid = make_uuid()
         if backend.deleted_mode == DELETED_MODE_KILL:
-            revpath = os.path.join(self.path, 'revisions', f'{self.current:08d}')
+            revpath = os.path.join(self.path, "revisions", f"{self.current:08d}")
             if not os.path.exists(revpath):
-                migr_logging('del_item',
-                             f'Deleted item not migrated: {itemname}, last revision no: {self.current}'
-                             )
-                raise KillRequested('deleted_mode wants killing/ignoring')
+                migr_logging("del_item", f"Deleted item not migrated: {itemname}, last revision no: {self.current}")
+                raise KillRequested("deleted_mode wants killing/ignoring")
             else:
-                migr_stat['items'] += 1
+                migr_stat["items"] += 1
 
     def iter_revisions(self):
-        revisionspath = os.path.join(self.path, 'revisions')
+        revisionspath = os.path.join(self.path, "revisions")
         try:
             # alternative method is to generate file names using range(1, self.current+1)
             fnames = sorted(os.listdir(revisionspath))
@@ -360,7 +386,7 @@ def iter_revisions(self):
                 logging.exception(f"PageRevision {self.name!r} {fname!r} raised exception:")
 
     def iter_attachments(self):
-        attachmentspath = os.path.join(self.path, 'attachments')
+        attachmentspath = os.path.join(self.path, "attachments")
         try:
             fnames = os.listdir(attachmentspath)
         except OSError:
@@ -368,8 +394,9 @@ def iter_attachments(self):
         for fname in fnames:
             attachname = fname
             try:
-                yield AttachmentRevision(self.name, attachname, os.path.join(attachmentspath, fname),
-                                         self.editlog, self.acl)
+                yield AttachmentRevision(
+                    self.name, attachname, os.path.join(attachmentspath, fname), self.editlog, self.acl
+                )
             except Exception:
                 logging.exception(f"AttachmentRevision {self.name!r}/{attachname!r} raised exception:")
 
@@ -378,6 +405,7 @@ class PageRevision:
     """
     moin 1.9 page revision
     """
+
     def __init__(self, item, revno, path, target_namespace):
         item_name = item.name
         itemid = item.itemid
@@ -386,43 +414,42 @@ def __init__(self, item, revno, path, target_namespace):
         editlog.to_begin()
         # we just read the page and parse it here, makes the rest of the code simpler:
         try:
-            with codecs.open(path, 'r', CHARSET19) as f:
+            with codecs.open(path, "r", CHARSET19) as f:
                 content = f.read()
         except OSError:
             # handle deleted revisions (for all revnos with 0<=revno<=current) here
             # we prepare some values for the case we don't find a better value in edit-log:
-            meta = {MTIME: -1,  # fake, will get 0 in the end
-                    NAME: [item_name],  # will get overwritten with name from edit-log
-                                        # if we have an entry there
-                    }
+            meta = {
+                MTIME: -1,  # fake, will get 0 in the end
+                NAME: [item_name],  # will get overwritten with name from edit-log
+                # if we have an entry there
+            }
             try:
-                revpath = os.path.join(item.path, 'revisions', f'{revno - 1:08d}')
+                revpath = os.path.join(item.path, "revisions", f"{revno - 1:08d}")
                 previous_meta = PageRevision(item, revno - 1, revpath, target_namespace).meta
                 # if this page revision is deleted, we have no on-page metadata.
                 # but some metadata is required, thus we have to copy it from the
                 # (non-deleted) revision revno-1:
-                for key in [ACL, NAME, CONTENTTYPE, MTIME, ]:
+                for key in [ACL, NAME, CONTENTTYPE, MTIME]:
                     if key in previous_meta:
                         meta[key] = previous_meta[key]
             except NoSuchRevisionError:
                 pass  # should not happen
             meta[MTIME] += 1  # it is now either 0 or prev rev mtime + 1
-            data = ''
+            data = ""
             try:
                 editlog_data = editlog.find_rev(revno)
             except KeyError:
-                logging.warning(f'Missing edit log data: item = {item_name}, revision = {revno}')
+                logging.warning(f"Missing edit log data: item = {item_name}, revision = {revno}")
                 if 0 <= revno <= item.current:
-                    editlog_data = {  # make something up
-                        ACTION: 'SAVE/DELETE',
-                    }
+                    editlog_data = {ACTION: "SAVE/DELETE"}  # make something up
                 else:
-                    raise NoSuchRevisionError(f'Item {item.name!r} has no revision {revno} (not even a deleted one)!')
+                    raise NoSuchRevisionError(f"Item {item.name!r} has no revision {revno} (not even a deleted one)!")
         else:
             try:
                 editlog_data = editlog.find_rev(revno)
             except KeyError:
-                logging.warning(f'Missing edit log data: name = {item_name}, revision = {revno}')
+                logging.warning(f"Missing edit log data: name = {item_name}, revision = {revno}")
                 if 1 <= revno <= item.current:
                     editlog_data = {  # make something up
                         NAME: [item.name],
@@ -431,12 +458,12 @@ def __init__(self, item, revno, path, target_namespace):
                     }
             meta, data = split_body(content)
         meta.update(editlog_data)
-        format = meta.pop('format', self.backend.format_default)
-        if format.startswith('csv'):
-            format = 'csv'  # drop trailing sep character as in "format csv ;"
+        format = meta.pop("format", self.backend.format_default)
+        if format.startswith("csv"):
+            format = "csv"  # drop trailing sep character as in "format csv ;"
         meta[CONTENTTYPE] = FORMAT_TO_CONTENTTYPE.get(format, CONTENTTYPE_DEFAULT)
         data = self._process_data(meta, data)
-        if format == 'csv':
+        if format == "csv":
             data = data.lstrip()  # leading blank lines confuses csv.sniffer
         data = data.encode(CHARSET19)
         size, hash_name, hash_digest = hash_hexdigest(data)
@@ -449,14 +476,14 @@ def __init__(self, item, revno, path, target_namespace):
         meta[ITEMTYPE] = ITEMTYPE_DEFAULT
         if LANGUAGE not in meta:
             meta[LANGUAGE] = app.cfg.language_default
-        if meta[NAME][0].endswith('Template'):
+        if meta[NAME][0].endswith("Template"):
             if TAGS in meta:
                 meta[TAGS].append(TEMPLATE)
             else:
                 meta[TAGS] = [TEMPLATE]
-        if meta[NAME][0].endswith('Group'):
+        if meta[NAME][0].endswith("Group"):
             meta[USERGROUP] = self._parse_acl_list(content)
-        if meta[NAME][0].endswith('Dict'):
+        if meta[NAME][0].endswith("Dict"):
             meta[WIKIDICT] = self._parse_wikidict(content)
 
         # if this revision matches a custom namespace defined in wikiconfig,
@@ -469,12 +496,15 @@ def __init__(self, item, revno, path, target_namespace):
                 meta[NAMESPACE] = custom_namespace
                 meta[NAME] = [new_name]
                 break
-            if meta[NAME][0].startswith(custom_namespace + '/'):
+            if meta[NAME][0].startswith(custom_namespace + "/"):
                 # split the namespace from the name
-                logging.warning("Converting {} to namespace:itemname {}:{}".format(
-                    meta[NAME][0], custom_namespace, meta[NAME][0][len(custom_namespace) + 1:]))
+                logging.warning(
+                    "Converting {} to namespace:itemname {}:{}".format(
+                        meta[NAME][0], custom_namespace, meta[NAME][0][len(custom_namespace) + 1 :]
+                    )
+                )
                 meta[NAMESPACE] = custom_namespace
-                meta[NAME] = [meta[NAME][0][len(custom_namespace) + 1:]]
+                meta[NAME] = [meta[NAME][0][len(custom_namespace) + 1 :]]
                 break
         self.meta = {}
         for k, v in meta.items():
@@ -488,8 +518,8 @@ def __init__(self, item, revno, path, target_namespace):
             self.meta[ACL] = regenerate_acl(acl_line)
 
         for user_name in user_names:
-            if meta[NAME][0] == user_name or meta[NAME][0].startswith(user_name + '/'):
-                meta[NAMESPACE] = 'users'
+            if meta[NAME][0] == user_name or meta[NAME][0].startswith(user_name + "/"):
+                meta[NAMESPACE] = "users"
                 break
 
         # match item create process that adds some keys with none-like values
@@ -500,16 +530,16 @@ def __init__(self, item, revno, path, target_namespace):
                 self.meta[k] = []
         for k in (COMMENT, SUMMARY):
             if k not in self.meta:
-                self.meta[k] = ''
+                self.meta[k] = ""
         self.meta[WIKINAME] = app.cfg.sitename  # old 1.9 sitename is not available
         global last_moin19_rev
         if meta[CONTENTTYPE] == CONTENTTYPE_MOINWIKI:
             last_moin19_rev[item_name] = (meta[REVID], meta[NAMESPACE])
 
     def _process_data(self, meta, data):
-        """ In moin 1.x markup, not all metadata is stored in the page's header.
-            E.g. categories are stored in the footer of the page content. For
-            moin2, we extract that stuff from content and put it into metadata.
+        """In moin 1.x markup, not all metadata is stored in the page's header.
+        E.g. categories are stored in the footer of the page content. For
+        moin2, we extract that stuff from content and put it into metadata.
         """
         if meta[CONTENTTYPE] == CONTENTTYPE_MOINWIKI:
             data = process_categories(meta, data, self.backend.item_category_regex)
@@ -521,24 +551,24 @@ def _parse_acl_list(self, content):
         """
         ret = []
         first_user = True
-        start = 'not a hit yet'
+        start = "not a hit yet"
         lines = content.splitlines()
         for line in lines:
             if first_user:
-                parts = line.split('*')
-                if len(parts) == 2 and parts[1].startswith(' '):
+                parts = line.split("*")
+                if len(parts) == 2 and parts[1].startswith(" "):
                     # only select lines with consistent indentation
-                    start = parts[0] + '* '
+                    start = parts[0] + "* "
                     first_user = False
             if line.startswith(start):
-                parts = line.split('*')
-                if len(parts) == 2 and parts[1].startswith(' '):
+                parts = line.split("*")
+                if len(parts) == 2 and parts[1].startswith(" "):
                     username = parts[1].strip()
                     # link conversion may have enclosed all links with [[...]], maybe a leading +/-: "+[[UserName]]"
-                    if username.startswith('[[') and username.endswith(']]'):
+                    if username.startswith("[[") and username.endswith("]]"):
                         ret.append(username[2:-2])
-                    elif username.startswith('+[[') or username.startswith('-[[') and username.endswith(']]'):
-                        username.replace('[', '')
+                    elif username.startswith("+[[") or username.startswith("-[[") and username.endswith("]]"):
+                        username.replace("[", "")
                         ret.append(username[:-2])
                     else:
                         ret.append(username)
@@ -552,14 +582,14 @@ def _parse_wikidict(self, content):
         lines = content.splitlines()
         for line in lines:
             line = line.strip()
-            parts = line.split(':: ')
+            parts = line.split(":: ")
             if len(parts) == 2:
                 ret[parts[0]] = parts[1]
         return ret
 
 
 def migrate_itemlinks(dom, namespace, itemlinks2chg):
-    """ Walk the DOM tree and change itemlinks to users namespace
+    """Walk the DOM tree and change itemlinks to users namespace
 
     :param dom: the tree to check for elements to migrate
     :param namespace: target namespace
@@ -569,17 +599,17 @@ def migrate_itemlinks(dom, namespace, itemlinks2chg):
 
     for node in dom.iter_elements_tree():
         # do not change email nodes, these have type(node.attrib[xlink.href]) == 'string'
-        if node.tag.name == 'a' and not isinstance(node.attrib[xlink.href], str):
+        if node.tag.name == "a" and not isinstance(node.attrib[xlink.href], str):
             path_19 = str(node.attrib[xlink.href].path)
-            if node.attrib[xlink.href].scheme == 'wiki.local' and path_19 in itemlinks2chg:
+            if node.attrib[xlink.href].scheme == "wiki.local" and path_19 in itemlinks2chg:
                 logging.debug(f"Changing link from {path_19} to {namespace}/{path_19}")
-                node.attrib[xlink.href].path = f'{namespace}/{path_19}'
+                node.attrib[xlink.href].path = f"{namespace}/{path_19}"
 
 
 def process_categories(meta, data, item_category_regex):
     # process categories to tags
     # find last ---- in the data plus the categories below it
-    m = re.search(r'\n\r?\s*-----*', data[::-1])
+    m = re.search(r"\n\r?\s*-----*", data[::-1])
     if m:
         start = m.start()
         end = m.end()
@@ -587,22 +617,22 @@ def process_categories(meta, data, item_category_regex):
         if start > 0:
             categories = data[-start:]
         else:
-            categories = ''
+            categories = ""
         if categories:
             # for CategoryFoo, group 'all' matches CategoryFoo, group 'key' matches just Foo
             # we use 'all' so we don't need to rename category items
             matches = list(item_category_regex.finditer(categories))
             if matches:
                 data = data[:-end]  # remove the ---- line from the content
-                tags = [_m.group('all') for _m in matches]
+                tags = [_m.group("all") for _m in matches]
                 meta.setdefault(TAGS, []).extend(tags)
                 # remove everything between first and last category from the content
                 # unexpected text before and after categories survives, any text between categories is deleted
                 start = matches[0].start()
                 end = matches[-1].end()
                 rest = categories[:start] + categories[end:]
-                data += '\r\n' + rest.lstrip()
-        data = data.rstrip() + '\r\n'
+                data += "\r\n" + rest.lstrip()
+        data = data.rstrip() + "\r\n"
     return data
 
 
@@ -610,21 +640,19 @@ class AttachmentRevision:
     """
     moin 1.9 attachment (there is no revisioning, just 1 revision per attachment)
     """
+
     def __init__(self, item_name, attach_name, attpath, editlog, acl):
         try:
             meta = editlog.find_attach(attach_name)
         except KeyError:
-            meta = {  # make something up
-                MTIME: int(os.path.getmtime(attpath)),
-                ACTION: ACTION_SAVE,
-            }
-        migr_stat['attachments'] += 1
-        meta[NAME] = [f'{item_name}/{attach_name}']
-        logging.debug(f'Migrating attachment {meta[NAME]}')
+            meta = {MTIME: int(os.path.getmtime(attpath)), ACTION: ACTION_SAVE}  # make something up
+        migr_stat["attachments"] += 1
+        meta[NAME] = [f"{item_name}/{attach_name}"]
+        logging.debug(f"Migrating attachment {meta[NAME]}")
         if acl is not None:
             meta[ACL] = acl
         meta[CONTENTTYPE] = str(MimeType(filename=attach_name).content_type())
-        f = open(attpath, 'rb')
+        f = open(attpath, "rb")
         size, hash_name, hash_digest = hash_hexdigest(f)
         f.seek(0)
         self.data = f
@@ -637,42 +665,43 @@ def __init__(self, item_name, attach_name, attpath, editlog, acl):
         if LANGUAGE not in meta:
             meta[LANGUAGE] = app.cfg.language_default
         meta[WIKINAME] = app.cfg.sitename  # old 1.9 sitename is not available
-        for attr in (COMMENT, SUMMARY, ):
+        for attr in (COMMENT, SUMMARY):
             meta[attr] = ""
-        for attr in (EXTERNALLINKS, ITEMLINKS, ITEMTRANSCLUSIONS, NAME_OLD, TAGS, ):
+        for attr in (EXTERNALLINKS, ITEMLINKS, ITEMTRANSCLUSIONS, NAME_OLD, TAGS):
             meta[attr] = []
         self.meta = meta
 
 
 class EditLog(LogFile):
-    """ Access the edit-log and return metadata as the new api wants it. """
+    """Access the edit-log and return metadata as the new api wants it."""
+
     def __init__(self, filename, buffer_size=4096):
         LogFile.__init__(self, filename, buffer_size)
         self._NUM_FIELDS = 9
 
     def parser(self, line):
-        """ Parse edit-log line into fields """
-        fields = line.strip().split('\t')
-        fields = (fields + [''] * self._NUM_FIELDS)[:self._NUM_FIELDS]
-        keys = (MTIME, '__rev', ACTION, NAME, ADDRESS, HOSTNAME, USERID, EXTRA, COMMENT)
+        """Parse edit-log line into fields"""
+        fields = line.strip().split("\t")
+        fields = (fields + [""] * self._NUM_FIELDS)[: self._NUM_FIELDS]
+        keys = (MTIME, "__rev", ACTION, NAME, ADDRESS, HOSTNAME, USERID, EXTRA, COMMENT)
         result = dict(zip(keys, fields))
         # do some conversions/cleanups/fallbacks:
         del result[HOSTNAME]  # HOSTNAME not used in moin 2.0
         result[MTIME] = int(result[MTIME] or 0) // 1000000  # convert usecs to secs
-        result['__rev'] = int(result['__rev'])
+        result["__rev"] = int(result["__rev"])
         result[NAME] = [unquoteWikiname(result[NAME])]
         action = result[ACTION]
         extra = result[EXTRA]
         if extra:
-            if action.startswith('ATT'):
-                result[NAME] += '/' + extra  # append filename to pagename
+            if action.startswith("ATT"):
+                result[NAME] += "/" + extra  # append filename to pagename
                 # keep EXTRA for find_attach
-            elif action == 'SAVE/RENAME':
+            elif action == "SAVE/RENAME":
                 if extra:
                     result[NAME_OLD] = [extra]
                 del result[EXTRA]
                 result[ACTION] = ACTION_RENAME
-            elif action == 'SAVE/REVERT':
+            elif action == "SAVE/REVERT":
                 if extra:
                     result[REVERTED_TO] = int(extra)
                 del result[EXTRA]
@@ -684,30 +713,28 @@ def parser(self, line):
         return result
 
     def find_rev(self, revno):
-        """ Find metadata for some revno revision in the edit-log. """
+        """Find metadata for some revno revision in the edit-log."""
         for meta in self:
-            if meta['__rev'] == revno:
+            if meta["__rev"] == revno:
                 break
         else:
             raise KeyError
-        del meta['__rev']
+        del meta["__rev"]
         meta = {k: v for k, v in meta.items() if v}  # remove keys with empty values
-        if meta.get(ACTION) == 'SAVENEW':
+        if meta.get(ACTION) == "SAVENEW":
             # replace SAVENEW with just SAVE
             meta[ACTION] = ACTION_SAVE
         return meta
 
     def find_attach(self, attachname):
-        """ Find metadata for some attachment name in the edit-log. """
+        """Find metadata for some attachment name in the edit-log."""
         for meta in self.reverse():  # use reverse iteration to get the latest upload's data
-            if (meta['__rev'] == 99999999 and
-                    meta[ACTION] == 'ATTNEW' and
-                    meta[EXTRA] == attachname):
+            if meta["__rev"] == 99999999 and meta[ACTION] == "ATTNEW" and meta[EXTRA] == attachname:
                 break
         else:
             self.to_end()
             raise KeyError
-        del meta['__rev']
+        del meta["__rev"]
         del meta[EXTRA]  # we have full name in NAME
         meta[ACTION] = ACTION_SAVE
         meta = {k: v for k, v in meta.items() if v}  # remove keys with empty values
@@ -715,11 +742,11 @@ def find_attach(self, attachname):
 
 
 def regenerate_acl(acl_string, acl_rights_valid=ACL_RIGHTS_CONTENTS):
-    """ recreate ACL string to remove invalid rights """
+    """recreate ACL string to remove invalid rights"""
     assert isinstance(acl_string, str)
     result = []
     for modifier, entries, rights in security.ACLStringIterator(acl_rights_valid, acl_string):
-        if (entries, rights) == (['Default'], []):
+        if (entries, rights) == (["Default"], []):
             result.append("Default")
         else:
             entries_valid = []
@@ -728,12 +755,12 @@ def regenerate_acl(acl_string, acl_rights_valid=ACL_RIGHTS_CONTENTS):
                     entries_valid.append(entry.capitalize())
                 else:
                     entries_valid.append(entry)
-            result.append("{}{}:{}".format(
-                          modifier,
-                          ','.join(entries_valid),
-                          ','.join(rights)  # iterator has removed invalid rights
-                          ))
-    result = ' '.join(result)
+            result.append(
+                "{}{}:{}".format(
+                    modifier, ",".join(entries_valid), ",".join(rights)  # iterator has removed invalid rights
+                )
+            )
+    result = " ".join(result)
     if result != acl_string:
         logging.debug(f"regenerate_acl {acl_string!r} -> {result!r}")
     return result
@@ -747,7 +774,7 @@ def _decode_list(line):
     :rtype: list of unicode strings
     :returns: list of items in encoded in line
     """
-    items = [item.strip() for item in line.split('\t')]
+    items = [item.strip() for item in line.split("\t")]
     items = [item for item in items if item]
     return tuple(items)
 
@@ -760,9 +787,9 @@ def _decode_dict(line):
     :rtype: dict
     :returns: dict  unicode:unicode items
     """
-    items = [item.strip() for item in line.split('\t')]
+    items = [item.strip() for item in line.split("\t")]
     items = [item for item in items if item]
-    items = [item.split(':', 1) for item in items]
+    items = [item.split(":", 1) for item in items]
     return dict(items)
 
 
@@ -770,6 +797,7 @@ class UserRevision:
     """
     moin 1.9 user
     """
+
     def __init__(self, path, uid):
         self.path = path
         self.uid = uid
@@ -781,22 +809,22 @@ def __init__(self, path, uid):
         meta[SIZE] = 0
         meta[ACTION] = ACTION_SAVE
         self.meta = meta
-        self.data = BytesIO(b'')
+        self.data = BytesIO(b"")
 
     def _parse_userprofile(self):
         with codecs.open(os.path.join(self.path, self.uid), "r", CHARSET19) as meta_file:
             metadata = {}
             for line in meta_file:
-                if line.startswith('#') or line.strip() == "":
+                if line.startswith("#") or line.strip() == "":
                     continue
-                key, value = line.strip().split('=', 1)
+                key, value = line.strip().split("=", 1)
                 # Decode list values
-                if key.endswith('[]'):
+                if key.endswith("[]"):
                     key = key[:-2]
                     value = _decode_list(value)
 
                 # Decode dict values
-                elif key.endswith('{}'):
+                elif key.endswith("{}"):
                     key = key[:-2]
                     value = _decode_dict(value)
 
@@ -806,20 +834,18 @@ def _parse_userprofile(self):
     def _process_usermeta(self, metadata):
         # stuff we want to have stored as boolean:
         bool_defaults = [  # taken from cfg.checkbox_defaults
-            (SHOW_COMMENTS, 'False'),
-            (EDIT_ON_DOUBLECLICK, 'True'),
-            (SCROLL_PAGE_AFTER_EDIT, 'True'),
-            (WANT_TRIVIAL, 'False'),
-            (MAILTO_AUTHOR, 'False'),
-            (DISABLED, 'False'),
+            (SHOW_COMMENTS, "False"),
+            (EDIT_ON_DOUBLECLICK, "True"),
+            (SCROLL_PAGE_AFTER_EDIT, "True"),
+            (WANT_TRIVIAL, "False"),
+            (MAILTO_AUTHOR, "False"),
+            (DISABLED, "False"),
         ]
         for key, default in bool_defaults:
-            metadata[key] = metadata.get(key, default) in ['True', 'true', '1']
+            metadata[key] = metadata.get(key, default) in ["True", "true", "1"]
 
         # stuff we want to have stored as integer:
-        int_defaults = [
-            (EDIT_ROWS, '0'),
-        ]
+        int_defaults = [(EDIT_ROWS, "0")]
         for key, default in int_defaults:
             metadata[key] = int(metadata.get(key, default))
 
@@ -827,67 +853,76 @@ def _process_usermeta(self, metadata):
         metadata[NAME] = [metadata[NAME]]
 
         # rename last_saved to MTIME, int MTIME should be enough:
-        metadata[MTIME] = int(float(metadata.get('last_saved', '0')))
+        metadata[MTIME] = int(float(metadata.get("last_saved", "0")))
 
         # rename aliasname to display_name:
-        metadata[DISPLAY_NAME] = metadata.get('aliasname')
+        metadata[DISPLAY_NAME] = metadata.get("aliasname")
         logging.debug(f"Processing user {metadata[NAME][0]} {self.uid} {metadata[EMAIL]}")
-        migr_stat['users'] += 1
+        migr_stat["users"] += 1
 
         # transfer subscribed_pages to subscription_patterns
-        metadata[SUBSCRIPTIONS] = self.migrate_subscriptions(metadata.get('subscribed_pages', []))
+        metadata[SUBSCRIPTIONS] = self.migrate_subscriptions(metadata.get("subscribed_pages", []))
 
         # convert bookmarks from usecs (and str) to secs (int)
-        metadata[BOOKMARKS] = [(interwiki, int(bookmark) // 1000000)
-                               for interwiki, bookmark in metadata.get(BOOKMARKS, {}).items()]
+        metadata[BOOKMARKS] = [
+            (interwiki, int(bookmark) // 1000000) for interwiki, bookmark in metadata.get(BOOKMARKS, {}).items()
+        ]
 
         # stuff we want to get rid of:
-        kill = ['aliasname',  # renamed to display_name
-                'real_language',  # crap (use 'language')
-                'wikiname_add_spaces',  # crap magic (you get it like it is)
-                'recoverpass_key',  # user can recover again if needed
-                'editor_default',  # not used any more
-                'editor_ui',  # not used any more
-                'external_target',  # ancient, not used any more
-                'passwd',  # ancient, not used any more (use enc_password)
-                'show_emoticons',  # ancient, not used any more
-                'show_fancy_diff',  # kind of diff display now depends on mimetype
-                'show_fancy_links',  # not used any more (now link rendering depends on theme)
-                'show_toolbar',  # not used any more
-                'show_topbottom',  # crap
-                'show_nonexist_qm',  # crap, can be done by css
-                'show_page_trail',  # theme decides whether to show trail
-                'remember_last_visit',  # we show trail, user can click there
-                'remember_me',  # don't keep sessions open for a long time
-                'subscribed_pages',  # renamed to subscribed_items
-                'edit_cols',  # not used any more
-                'jid',  # no jabber support
-                'tz_offset',  # we have real timezone now
-                'date_fmt',  # not used any more
-                'datetime_fmt',  # not used any more
-                'last_saved',  # renamed to MTIME
-                'email_subscribed_events',  # XXX no support yet
-                'jabber_subscribed_events',  # XXX no support yet
-                ]
+        kill = [
+            "aliasname",  # renamed to display_name
+            "real_language",  # crap (use 'language')
+            "wikiname_add_spaces",  # crap magic (you get it like it is)
+            "recoverpass_key",  # user can recover again if needed
+            "editor_default",  # not used any more
+            "editor_ui",  # not used any more
+            "external_target",  # ancient, not used any more
+            "passwd",  # ancient, not used any more (use enc_password)
+            "show_emoticons",  # ancient, not used any more
+            "show_fancy_diff",  # kind of diff display now depends on mimetype
+            "show_fancy_links",  # not used any more (now link rendering depends on theme)
+            "show_toolbar",  # not used any more
+            "show_topbottom",  # crap
+            "show_nonexist_qm",  # crap, can be done by css
+            "show_page_trail",  # theme decides whether to show trail
+            "remember_last_visit",  # we show trail, user can click there
+            "remember_me",  # don't keep sessions open for a long time
+            "subscribed_pages",  # renamed to subscribed_items
+            "edit_cols",  # not used any more
+            "jid",  # no jabber support
+            "tz_offset",  # we have real timezone now
+            "date_fmt",  # not used any more
+            "datetime_fmt",  # not used any more
+            "last_saved",  # renamed to MTIME
+            "email_subscribed_events",  # XXX no support yet
+            "jabber_subscribed_events",  # XXX no support yet
+        ]
         for key in kill:
             if key in metadata:
                 del metadata[key]
 
         # finally, remove some empty values (that have empty defaults anyway or
         # make no sense when empty):
-        empty_kill = ['aliasname', DISPLAY_NAME, BOOKMARKS, ENC_PASSWORD,
-                      'language', CSS_URL, EMAIL, ]  # XXX check subscribed_items, quicklinks
+        empty_kill = [
+            "aliasname",
+            DISPLAY_NAME,
+            BOOKMARKS,
+            ENC_PASSWORD,
+            "language",
+            CSS_URL,
+            EMAIL,
+        ]  # XXX check subscribed_items, quicklinks
         for key in empty_kill:
-            if key in metadata and metadata[key] in ['', tuple(), {}, [], ]:
+            if key in metadata and metadata[key] in ["", tuple(), {}, []]:
                 del metadata[key]
 
         # moin2 only supports passlib generated hashes, drop everything else
         # (users need to do pw recovery in case they are affected)
         pw = metadata.get(ENC_PASSWORD)
         if pw is not None:
-            if pw.startswith('{PASSLIB}'):
+            if pw.startswith("{PASSLIB}"):
                 # take it, but strip the prefix as moin2 does not use that any more
-                metadata[ENC_PASSWORD] = pw[len('{PASSLIB}'):]
+                metadata[ENC_PASSWORD] = pw[len("{PASSLIB}") :]
             else:
                 # drop old, unsupported (and also more or less unsafe) hashing scheme
                 del metadata[ENC_PASSWORD]
@@ -902,17 +937,17 @@ def _process_usermeta(self, metadata):
         return metadata
 
     def migrate_subscriptions(self, subscribed_items):
-        """ Transfer subscribed_items meta to subscriptions meta
+        """Transfer subscribed_items meta to subscriptions meta
 
         WikiFarmNames are converted to namespace names.
 
         :param subscribed_items: a list of moin19-format subscribed_items
         :return: subscriptions
         """
-        RECHARS = r'.^$*+?{\|('
+        RECHARS = r".^$*+?{\|("
         subscriptions = []
         for subscribed_item in subscribed_items:
-            logging.debug(f'User is subscribed to {subscribed_item}')
+            logging.debug(f"User is subscribed to {subscribed_item}")
             if flaskg.item_name2id.get(subscribed_item):
                 subscriptions.append(f"{ITEMID}:{flaskg.item_name2id.get(subscribed_item)}")
             else:
@@ -922,9 +957,12 @@ def migrate_subscriptions(self, subscribed_items):
 
                 if not any(x in subscribed_item for x in RECHARS):
                     subscriptions.append(f"{NAME}:{wikiname}:{subscribed_item}")
-                elif (subscribed_item.endswith(".*") and len(subscribed_item) > 2
-                        and not subscribed_item.endswith("/.*")
-                        and not any(x in subscribed_item[:-2] for x in RECHARS)):
+                elif (
+                    subscribed_item.endswith(".*")
+                    and len(subscribed_item) > 2
+                    and not subscribed_item.endswith("/.*")
+                    and not any(x in subscribed_item[:-2] for x in RECHARS)
+                ):
                     subscriptions.append(f"{NAMEPREFIX}:{wikiname}:{subscribed_item[:-2]}")
                 else:
                     subscriptions.append(f"{NAMERE}:{wikiname}:{subscribed_item}")
@@ -936,6 +974,7 @@ class UserBackend:
     """
     moin 1.9 user directory
     """
+
     def __init__(self, path):
         """
         :param path: user_dir path
@@ -943,7 +982,7 @@ def __init__(self, path):
         self.path = path
 
     def __iter__(self):
-        user_re = re.compile(r'^\d+\.\d+(\.\d+)?$')
+        user_re = re.compile(r"^\d+\.\d+(\.\d+)?$")
         for uid in os.listdir(self.path):
             if user_re.match(uid):
                 try:
@@ -962,7 +1001,7 @@ def namespaces():
     """
     blacklist = ["default", "userprofiles", "users", ""]
     try:
-        custom_namespaces = [x.rstrip('/') for x in app.cfg.namespaces.keys() if x not in blacklist]
+        custom_namespaces = [x.rstrip("/") for x in app.cfg.namespaces.keys() if x not in blacklist]
         custom_namespaces.sort(key=len, reverse=True)
     except AttributeError:
         return []
diff --git a/src/moin/cli/migration/moin19/macro_migration.py b/src/moin/cli/migration/moin19/macro_migration.py
index 0a00a9db4..463d39be1 100644
--- a/src/moin/cli/migration/moin19/macro_migration.py
+++ b/src/moin/cli/migration/moin19/macro_migration.py
@@ -13,7 +13,7 @@
 
 
 def migrate_macros(dom):
-    """ Walk the DOM tree and call known migration functions
+    """Walk the DOM tree and call known migration functions
 
     While walking the DOM tree any element of a content type
     with a matching migration callback function will be passed
@@ -24,7 +24,7 @@ def migrate_macros(dom):
     """
 
     for node in dom.iter_elements_tree():
-        if node.tag.name == 'part' or node.tag.name == 'inline-part':
+        if node.tag.name == "part" or node.tag.name == "inline-part":
 
             # if a callback is registered for this content type
             # let it manipulate the DOM node
@@ -33,7 +33,7 @@ def migrate_macros(dom):
 
 
 def register_macro_migration(content_type, migration_callback):
-    """ Register callback for migrating elements of a certain content type
+    """Register callback for migrating elements of a certain content type
 
     Once registered, the migration will walk the DOM tree and use the callback
     function to manipulate elements of the given content type for migration.
diff --git a/src/moin/cli/migration/moin19/macros/MonthCalendar.py b/src/moin/cli/migration/moin19/macros/MonthCalendar.py
index 4da080f11..a8022559d 100644
--- a/src/moin/cli/migration/moin19/macros/MonthCalendar.py
+++ b/src/moin/cli/migration/moin19/macros/MonthCalendar.py
@@ -13,6 +13,7 @@
 from moin.utils.tree import moin_page
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -21,9 +22,9 @@
 
 
 def parseargs_legacy(
-        args, defpagename, defyear, defmonth, defoffset, defoffset2, defheight6, defanniversary, deftemplate
+    args, defpagename, defyear, defmonth, defoffset, defoffset2, defheight6, defanniversary, deftemplate
 ):
-    """ Slightly modified parsing function from MonthCalendar.py in moin-1.9
+    """Slightly modified parsing function from MonthCalendar.py in moin-1.9
 
     From the moin-1.9 version of the function
     * the request argument was dropped
@@ -32,20 +33,20 @@ def parseargs_legacy(
     args = paramparser.parse_quoted_separated(args, name_value=False)
     args += [None] * 8  # fill up with None to trigger defaults
     parmpagename, parmyear, parmmonth, parmoffset, parmoffset2, parmheight6, parmanniversary, parmtemplate = args[:8]
-    parmpagename = paramparser.get_str(parmpagename, 'pagename', defpagename)
-    parmyear = paramparser.get_int(parmyear, 'year', defyear)
-    parmmonth = paramparser.get_int(parmmonth, 'month', defmonth)
-    parmoffset = paramparser.get_int(parmoffset, 'offset', defoffset)
-    parmoffset2 = paramparser.get_int(parmoffset2, 'offset2', defoffset2)
-    parmheight6 = paramparser.get_bool(parmheight6, 'height6', defheight6)
-    parmanniversary = paramparser.get_bool(parmanniversary, 'anniversary', defanniversary)
-    parmtemplate = paramparser.get_str(parmtemplate, 'template', deftemplate)
+    parmpagename = paramparser.get_str(parmpagename, "pagename", defpagename)
+    parmyear = paramparser.get_int(parmyear, "year", defyear)
+    parmmonth = paramparser.get_int(parmmonth, "month", defmonth)
+    parmoffset = paramparser.get_int(parmoffset, "offset", defoffset)
+    parmoffset2 = paramparser.get_int(parmoffset2, "offset2", defoffset2)
+    parmheight6 = paramparser.get_bool(parmheight6, "height6", defheight6)
+    parmanniversary = paramparser.get_bool(parmanniversary, "anniversary", defanniversary)
+    parmtemplate = paramparser.get_str(parmtemplate, "template", deftemplate)
 
     return parmpagename, parmyear, parmmonth, parmoffset, parmoffset2, parmheight6, parmanniversary, parmtemplate
 
 
 def convert_month_calendar_macro_syntax(node):
-    """ Convert the given MonthCalendar macro node to the new syntax in-place
+    """Convert the given MonthCalendar macro node to the new syntax in-place
 
     MonthCalendar used to have unnamed parameters in moin-1.9. The syntax
     has been changed to name-value parameters in moin2. Migrate the given
@@ -67,18 +68,19 @@ def convert_month_calendar_macro_syntax(node):
     """
 
     # content type
-    new_content_type = CONTENT_TYPE_MACRO_FORMATTER.format('MonthCalendar')
+    new_content_type = CONTENT_TYPE_MACRO_FORMATTER.format("MonthCalendar")
     node.set(moin_page.content_type, new_content_type)
 
     # arguments
     args_before = None
-    args_after = ''
+    args_after = ""
     for elem in node.iter_elements():
-        if elem.tag.name == 'arguments':
+        if elem.tag.name == "arguments":
             args_before = elem.text
     if args_before:
-        (parmpagename, parmyear, parmmonth, parmoffset, parmoffset2, parmheight6, parmanniversary, parmtemplate,
-         ) = parseargs_legacy(args_before, None, None, None, None, None, False, False, None)
+        (parmpagename, parmyear, parmmonth, parmoffset, parmoffset2, parmheight6, parmanniversary, parmtemplate) = (
+            parseargs_legacy(args_before, None, None, None, None, None, False, False, None)
+        )
 
         # Warn if parmoffset2 or parmtemplate are set,
         # they are not supported by the current
@@ -90,29 +92,26 @@ def convert_month_calendar_macro_syntax(node):
             logging.warning("MonthCalendar macro parameter 'template' cannot be migrated")
 
         args_after_dict = {
-            'item': f'"{parmpagename}"' if parmpagename else None,
-            'year': parmyear,
-            'month': parmmonth,
-            'month_offset': parmoffset,
-            'fixed_height': 'true' if parmheight6 else False,
-            'anniversary': 'true' if parmanniversary else False,
+            "item": f'"{parmpagename}"' if parmpagename else None,
+            "year": parmyear,
+            "month": parmmonth,
+            "month_offset": parmoffset,
+            "fixed_height": "true" if parmheight6 else False,
+            "anniversary": "true" if parmanniversary else False,
         }
 
-        args_after = ','.join(
-            [f"{key}={args_after_dict[key]}" for key in args_after_dict if args_after_dict[key]]
-        )
+        args_after = ",".join([f"{key}={args_after_dict[key]}" for key in args_after_dict if args_after_dict[key]])
 
     for elem in node.iter_elements():
-        if elem.tag.name == 'arguments':
+        if elem.tag.name == "arguments":
             elem.clear()
             elem.append(args_after)
 
     # 'alt' attribute
-    new_alt = f'<<MonthCalendar({args_after})>>'
+    new_alt = f"<<MonthCalendar({args_after})>>"
     node.set(moin_page.alt, new_alt)
 
 
 macro_migration.register_macro_migration(
-    CONTENT_TYPE_MACRO_FORMATTER.format(MACRO_NAME_MONTH_CALENDAR),
-    convert_month_calendar_macro_syntax
+    CONTENT_TYPE_MACRO_FORMATTER.format(MACRO_NAME_MONTH_CALENDAR), convert_month_calendar_macro_syntax
 )
diff --git a/src/moin/cli/migration/moin19/macros/PageList.py b/src/moin/cli/migration/moin19/macros/PageList.py
index 8ed8890aa..b2e532e53 100644
--- a/src/moin/cli/migration/moin19/macros/PageList.py
+++ b/src/moin/cli/migration/moin19/macros/PageList.py
@@ -16,7 +16,7 @@
 
 
 def convert_page_list_macro_to_item_list(node):
-    """ Convert the given PageList macro node to an ItemList macro in-place
+    """Convert the given PageList macro node to an ItemList macro in-place
 
     The moin1.0 PageList macro used to pass all arguments to the FullSearch
     macro, so they were essentially all treated as regular expression search queries.
@@ -40,18 +40,18 @@ def convert_page_list_macro_to_item_list(node):
     """
 
     # content type
-    new_content_type = CONTENT_TYPE_MACRO_FORMATTER.format('ItemList')
+    new_content_type = CONTENT_TYPE_MACRO_FORMATTER.format("ItemList")
     node.set(moin_page.content_type, new_content_type)
 
     # arguments
     args_before = None
-    args_after = ''
+    args_after = ""
     for elem in node.iter_elements():
-        if elem.tag.name == 'arguments':
+        if elem.tag.name == "arguments":
             args_before = elem.text
     if args_before:
         # strip the "regex:" prefix if necessary
-        args_intermediate = re.sub(r'^regex:', '', args_before)
+        args_intermediate = re.sub(r"^regex:", "", args_before)
         # wrap argument in new keyword argument "regex"
         args_after = f'item="",regex="{args_intermediate}"'
     else:
@@ -61,16 +61,15 @@ def convert_page_list_macro_to_item_list(node):
         args_after = 'item=""'
 
     for elem in node.iter_elements():
-        if elem.tag.name == 'arguments':
+        if elem.tag.name == "arguments":
             elem.clear()
             elem.append(args_after)
 
     # 'alt' attribute
-    new_alt = f'<<ItemList({args_after})>>'
+    new_alt = f"<<ItemList({args_after})>>"
     node.set(moin_page.alt, new_alt)
 
 
 macro_migration.register_macro_migration(
-    CONTENT_TYPE_MACRO_FORMATTER.format(MACRO_NAME_PAGE_LIST),
-    convert_page_list_macro_to_item_list
+    CONTENT_TYPE_MACRO_FORMATTER.format(MACRO_NAME_PAGE_LIST), convert_page_list_macro_to_item_list
 )
diff --git a/src/moin/cli/migration/moin19/macros/_tests/test_MonthCalendar_migration.py b/src/moin/cli/migration/moin19/macros/_tests/test_MonthCalendar_migration.py
index c64039a33..257b1afc5 100644
--- a/src/moin/cli/migration/moin19/macros/_tests/test_MonthCalendar_migration.py
+++ b/src/moin/cli/migration/moin19/macros/_tests/test_MonthCalendar_migration.py
@@ -16,14 +16,21 @@
 from moin.utils.tree import moin_page
 
 
-@pytest.mark.parametrize('legacy_macro,expected_args', [
-    ("<<MonthCalendar()>>", ''),
-    ("<<MonthCalendar('TestPage')>>", 'item="TestPage"'),
-    ("<<MonthCalendar('TestPage',1995,3,2,,1,,)>>",
-     'item="TestPage",year=1995,month=3,month_offset=2,fixed_height=true'),
-    ("<<MonthCalendar('CalendarOne*CalendarTwo',,,-2,,,true)>>",
-     'item="CalendarOne*CalendarTwo",month_offset=-2,anniversary=true'),
-])
+@pytest.mark.parametrize(
+    "legacy_macro,expected_args",
+    [
+        ("<<MonthCalendar()>>", ""),
+        ("<<MonthCalendar('TestPage')>>", 'item="TestPage"'),
+        (
+            "<<MonthCalendar('TestPage',1995,3,2,,1,,)>>",
+            'item="TestPage",year=1995,month=3,month_offset=2,fixed_height=true',
+        ),
+        (
+            "<<MonthCalendar('CalendarOne*CalendarTwo',,,-2,,,true)>>",
+            'item="CalendarOne*CalendarTwo",month_offset=-2,anniversary=true',
+        ),
+    ],
+)
 def test_macro_conversion(legacy_macro, expected_args):
     converter = ConverterFormat19()
     dom = converter(legacy_macro, import19.CONTENTTYPE_MOINWIKI)
@@ -32,8 +39,8 @@ def test_macro_conversion(legacy_macro, expected_args):
     body = list(dom)[0]
     part = list(body)[0]
 
-    assert part.get(moin_page.content_type) == 'x-moin/macro;name=MonthCalendar'
-    assert part.get(moin_page.alt) == f'<<MonthCalendar({expected_args})>>'
+    assert part.get(moin_page.content_type) == "x-moin/macro;name=MonthCalendar"
+    assert part.get(moin_page.alt) == f"<<MonthCalendar({expected_args})>>"
 
     if len(list(part)) > 0:
         arguments = list(part)[0]
diff --git a/src/moin/cli/migration/moin19/macros/_tests/test_PageList_migration.py b/src/moin/cli/migration/moin19/macros/_tests/test_PageList_migration.py
index bbf9f5111..f5b6c67db 100644
--- a/src/moin/cli/migration/moin19/macros/_tests/test_PageList_migration.py
+++ b/src/moin/cli/migration/moin19/macros/_tests/test_PageList_migration.py
@@ -16,15 +16,18 @@
 from moin.utils.tree import moin_page
 
 
-@pytest.mark.parametrize('legacy_macro,expected_args', [
-    ("<<PageList>>", 'item=""'),
-    ("<<PageList()>>", 'item=""'),
-    ("<<PageList(regex:InterestingPage/*)>>", 'item="",regex="InterestingPage/*"'),
-    ("<<PageList(Calendar/2014-08-22/)>>", 'item="",regex="Calendar/2014-08-22/"'),
-    ("<<PageList(regex:SecondCalendar/2011[^/]*$)>>", 'item="",regex="SecondCalendar/2011[^/]*$"'),
-    ("<<PageList(^WikiPageAboutRegularExpressions/*)>>", 'item="",regex="^WikiPageAboutRegularExpressions/*"'),
-    ("<<PageList(regex:ArticleCollection/[^/]*)>>", 'item="",regex="ArticleCollection/[^/]*"'),
-])
+@pytest.mark.parametrize(
+    "legacy_macro,expected_args",
+    [
+        ("<<PageList>>", 'item=""'),
+        ("<<PageList()>>", 'item=""'),
+        ("<<PageList(regex:InterestingPage/*)>>", 'item="",regex="InterestingPage/*"'),
+        ("<<PageList(Calendar/2014-08-22/)>>", 'item="",regex="Calendar/2014-08-22/"'),
+        ("<<PageList(regex:SecondCalendar/2011[^/]*$)>>", 'item="",regex="SecondCalendar/2011[^/]*$"'),
+        ("<<PageList(^WikiPageAboutRegularExpressions/*)>>", 'item="",regex="^WikiPageAboutRegularExpressions/*"'),
+        ("<<PageList(regex:ArticleCollection/[^/]*)>>", 'item="",regex="ArticleCollection/[^/]*"'),
+    ],
+)
 def test_macro_conversion(legacy_macro, expected_args):
     converter = ConverterFormat19()
     dom = converter(legacy_macro, import19.CONTENTTYPE_MOINWIKI)
@@ -33,7 +36,7 @@ def test_macro_conversion(legacy_macro, expected_args):
     body = list(dom)[0]
     part = list(body)[0]
 
-    assert part.get(moin_page.content_type) == 'x-moin/macro;name=ItemList'
+    assert part.get(moin_page.content_type) == "x-moin/macro;name=ItemList"
     assert part.get(moin_page.alt) == f"<<ItemList({expected_args})>>"
 
     if len(list(part)) > 0:
diff --git a/src/moin/config/_tests/test_defaultconfig.py b/src/moin/config/_tests/test_defaultconfig.py
index a09dc644c..c54bdae5d 100644
--- a/src/moin/config/_tests/test_defaultconfig.py
+++ b/src/moin/config/_tests/test_defaultconfig.py
@@ -14,18 +14,18 @@
 class TestPasswordChecker:
     username = "SomeUser"
     tests_builtin = [
-        ('', False),  # empty
-        ('1966', False),  # too short
-        ('asdfghjk', False),  # keyboard sequence
-        ('QwertZuiop', False),  # german keyboard sequence, with uppercase
-        ('mnbvcx', False),  # reverse keyboard sequence
-        ('12345678', False),  # keyboard sequence, too easy
-        ('aaaaaaaa', False),  # not enough different chars
-        ('BBBaaaddd', False),  # not enough different chars
+        ("", False),  # empty
+        ("1966", False),  # too short
+        ("asdfghjk", False),  # keyboard sequence
+        ("QwertZuiop", False),  # german keyboard sequence, with uppercase
+        ("mnbvcx", False),  # reverse keyboard sequence
+        ("12345678", False),  # keyboard sequence, too easy
+        ("aaaaaaaa", False),  # not enough different chars
+        ("BBBaaaddd", False),  # not enough different chars
         (username, False),  # username == password
         (username[1:-1], False),  # password in username
         (f"XXX{username}XXX", False),  # username in password
-        ('Moin-2007', True),  # this should be OK
+        ("Moin-2007", True),  # this should be OK
     ]
 
     def testBuiltinPasswordChecker(self):
@@ -39,4 +39,4 @@ def testBuiltinPasswordChecker(self):
                 assert result == (pw_error is None)
 
 
-coverage_modules = ['moin.config.default']
+coverage_modules = ["moin.config.default"]
diff --git a/src/moin/config/default.py b/src/moin/config/default.py
index 4c42f4663..97098ada5 100644
--- a/src/moin/config/default.py
+++ b/src/moin/config/default.py
@@ -28,19 +28,21 @@
 from moin.security import AccessControlList, DefaultSecurityPolicy
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class CacheClass:
-    """ just a container for stuff we cache """
+    """just a container for stuff we cache"""
+
     pass
 
 
 class ConfigFunctionality:
-    """ Configuration base class with config class behaviour.
+    """Configuration base class with config class behaviour.
 
-        This class contains the functionality for the DefaultConfig
-        class for the benefit of the WikiConfig macro.
+    This class contains the functionality for the DefaultConfig
+    class for the benefit of the WikiConfig macro.
     """
 
     # attributes of this class that should not be shown
@@ -54,7 +56,7 @@ class for the benefit of the WikiConfig macro.
     _site_plugin_lists = None
 
     def __init__(self):
-        """ Init Config instance """
+        """Init Config instance"""
         self.cache = CacheClass()
 
         if self.config_check_enabled:
@@ -72,8 +74,8 @@ def __init__(self):
         self.cache.item_group_regex = re.compile(self.item_group_regex, re.UNICODE)
 
         # the ..._regexact versions only match if nothing is left (exact match)
-        self.cache.item_dict_regexact = re.compile(f'^{self.item_dict_regex}$', re.UNICODE)
-        self.cache.item_group_regexact = re.compile(f'^{self.item_group_regex}$', re.UNICODE)
+        self.cache.item_dict_regexact = re.compile(f"^{self.item_dict_regex}$", re.UNICODE)
+        self.cache.item_group_regexact = re.compile(f"^{self.item_group_regex}$", re.UNICODE)
 
         # compiled functions ACL
         self.cache.acl_functions = AccessControlList([self.acl_functions], valid=self.acl_rights_functions)
@@ -118,7 +120,9 @@ def __init__(self):
         self.mail_enabled = self.mail_enabled and True or False
 
         if self.namespace_mapping is None:
-            raise error.ConfigurationError("No storage configuration specified! You need to define a namespace_mapping.")
+            raise error.ConfigurationError(
+                "No storage configuration specified! You need to define a namespace_mapping."
+            )
 
         if self.backend_mapping is None:
             raise error.ConfigurationError("No storage configuration specified! You need to define a backend_mapping.")
@@ -128,21 +132,24 @@ def __init__(self):
 
         if self.secrets is None:  # admin did not setup a real secret
             raise error.ConfigurationError(
-                "No secret configured! You need to set secrets = 'somelongsecretstring' in your wiki config.")
+                "No secret configured! You need to set secrets = 'somelongsecretstring' in your wiki config."
+            )
 
         if self.interwikiname is None:  # admin did not setup a real interwikiname
             raise error.ConfigurationError(
                 "No interwikiname configured! "
-                "You need to set interwikiname = 'YourUniqueStableInterwikiName' in your wiki config.")
+                "You need to set interwikiname = 'YourUniqueStableInterwikiName' in your wiki config."
+            )
 
-        secret_key_names = ['security/ticket', ]
+        secret_key_names = ["security/ticket"]
 
         secret_min_length = 10
         if isinstance(self.secrets, str):
             if len(self.secrets) < secret_min_length:
                 raise error.ConfigurationError(
                     "The secrets = '...' wiki config setting is a way too short string "
-                    "(minimum length is {} chars)!".format(secret_min_length))
+                    "(minimum length is {} chars)!".format(secret_min_length)
+                )
             # for lazy people: set all required secrets to same value
             secrets = {}
             for key in secret_key_names:
@@ -158,9 +165,12 @@ def __init__(self):
             except (KeyError, ValueError):
                 raise error.ConfigurationError(
                     "You must set a (at least {} chars long) secret string for secrets['{}']!".format(
-                        secret_min_length, secret_key_name))
+                        secret_min_length, secret_key_name
+                    )
+                )
 
         from passlib.context import CryptContext
+
         try:
             self.cache.pwd_context = CryptContext(**self.passlib_crypt_context)
         except ValueError as err:
@@ -171,9 +181,8 @@ def __init__(self):
         elif len(self.contenttype_disabled):
             content_registry_disable(self.contenttype_disabled)
 
-
     def _config_check(self):
-        """ Check namespace and warn about unknown names
+        """Check namespace and warn about unknown names
 
         Warn about names which are not used by DefaultConfig, except
         modules, classes, _private or __magic__ names.
@@ -181,21 +190,26 @@ def _config_check(self):
         This check is disabled by default, when enabled, it will show an
         error message with unknown names.
         """
-        unknown = [f'"{name}"' for name in dir(self)
-                   if not name.startswith('_') and
-                   name not in DefaultConfig.__dict__ and
-                   not isinstance(getattr(self, name), (type(re), type(DefaultConfig)))]
+        unknown = [
+            f'"{name}"'
+            for name in dir(self)
+            if not name.startswith("_")
+            and name not in DefaultConfig.__dict__
+            and not isinstance(getattr(self, name), (type(re), type(DefaultConfig)))
+        ]
         if unknown:
             msg = """
 Unknown configuration options: {}.
 
 For more information, see configuration docs. Please check your
 configuration for typos before requesting support or reporting a bug.
-""".format(', '.join(unknown))
+""".format(
+                ", ".join(unknown)
+            )
             raise error.ConfigurationError(msg)
 
     def _decode(self):
-        """ Try to decode certain names, ignore unicode values
+        """Try to decode certain names, ignore unicode values
 
         Try to decode str using utf-8. If the decode fail, raise FatalError.
 
@@ -203,7 +217,7 @@ def _decode(self):
         should be defined with 'text' syntax. Python will decode these if
         the file has a 'coding' line.
         """
-        charset = 'utf-8'
+        charset = "utf-8"
         message = """
 "{name}" configuration variable is a string, but should be
 unicode. Use {name} = "value" syntax for unicode variables.
@@ -213,12 +227,20 @@ def _decode(self):
 """
 
         decode_names = (
-            'sitename', 'interwikiname', 'user_homewiki',
-            'interwiki_preferred',
-            'item_license', 'mail_from',
-            'item_dict_regex', 'item_group_regex',
-            'acl_functions', 'supplementation_item_names', 'html_pagetitle',
-            'theme_default', 'timezone_default', 'locale_default',
+            "sitename",
+            "interwikiname",
+            "user_homewiki",
+            "interwiki_preferred",
+            "item_license",
+            "mail_from",
+            "item_dict_regex",
+            "item_group_regex",
+            "acl_functions",
+            "supplementation_item_names",
+            "html_pagetitle",
+            "theme_default",
+            "timezone_default",
+            "locale_default",
         )
 
         for name in decode_names:
@@ -241,54 +263,59 @@ def _decode(self):
                                 raise error.ConfigurationError(message.format(name=name))
 
     def __getitem__(self, item):
-        """ Make it possible to access a config object like a dict """
+        """Make it possible to access a config object like a dict"""
         return getattr(self, item)
 
 
 class DefaultConfig(ConfigFunctionality):
-    """ Configuration base class with default config values
-        (added below)
+    """Configuration base class with default config values
+    (added below)
     """
+
     # Do not add anything into this class. Functionality must
     # be added above to avoid having the methods show up in
     # the WikiConfig macro. Settings must be added below to
     # the options dictionary.
 
 
-def _default_password_checker(cfg, username, password,
-                              min_length=8, min_different=5):
-    """ Check if a password is secure enough.
-        We use a built-in check to get rid of the worst passwords.
+def _default_password_checker(cfg, username, password, min_length=8, min_different=5):
+    """Check if a password is secure enough.
+    We use a built-in check to get rid of the worst passwords.
 
-        We do NOT use cracklib / python-crack here any more because it is
-        not thread-safe (we experienced segmentation faults when using it).
+    We do NOT use cracklib / python-crack here any more because it is
+    not thread-safe (we experienced segmentation faults when using it).
 
-        If you don't want to check passwords, use password_checker = None.
+    If you don't want to check passwords, use password_checker = None.
 
-        :returns: None if there is no problem with the password,
-                 some unicode object with an error msg, if the password is problematic.
+    :returns: None if there is no problem with the password,
+             some unicode object with an error msg, if the password is problematic.
     """
     # in any case, do a very simple built-in check to avoid the worst passwords
     if len(password) < min_length:
-        return _("For a password a minimum length of {min_length:d} characters is required.",
-                 min_length=min_length)
+        return _("For a password a minimum length of {min_length:d} characters is required.", min_length=min_length)
     if len(set(password)) < min_different:
-        return _("For a password a minimum of {min_different:d} different characters is required.",
-                 min_different=min_different)
+        return _(
+            "For a password a minimum of {min_different:d} different characters is required.",
+            min_different=min_different,
+        )
 
     username_lower = username.lower()
     password_lower = password.lower()
-    if username in password or password in username or \
-       username_lower in password_lower or password_lower in username_lower:
+    if (
+        username in password
+        or password in username
+        or username_lower in password_lower
+        or password_lower in username_lower
+    ):
         return _("Password is too easy to guess (password contains name or name contains password).")
 
-    keyboards = (r"`1234567890-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./",  # US kbd
-                 r"^1234567890ß´qwertzuiopü+asdfghjklöä#yxcvbnm,.-",  # german kbd
+    keyboards = (
+        r"`1234567890-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./",  # US kbd
+        r"^1234567890ß´qwertzuiopü+asdfghjklöä#yxcvbnm,.-",  # german kbd
     )  # TODO add more keyboards!
     for kbd in keyboards:
         rev_kbd = kbd[::-1]
-        if password in kbd or password in rev_kbd or \
-           password_lower in kbd or password_lower in rev_kbd:
+        if password in kbd or password in rev_kbd or password_lower in kbd or password_lower in rev_kbd:
             return _("Password is too easy to guess (keyboard sequence).")
     return None
 
@@ -306,221 +333,310 @@ def __init__(self, exprstr):
 #
 options_no_group_name = {
     # ==========================================================================
-    'datastructures': ('Datastruct', None, (
-        # ('dicts', lambda cfg: datastructures.ConfigDicts({}),
-        ('dicts', lambda cfg: datastructures.WikiDicts(),
-         "function f(cfg) that returns a backend which is used to access dicts definitions."),
-        # ('groups', lambda cfg: datastructures.ConfigGroups({}),
-        ('groups', lambda cfg: datastructures.WikiGroups(),
-         "function f(cfg) that returns a backend which is used to access groups definitions."),
-    )),
+    "datastructures": (
+        "Datastruct",
+        None,
+        (
+            # ('dicts', lambda cfg: datastructures.ConfigDicts({}),
+            (
+                "dicts",
+                lambda cfg: datastructures.WikiDicts(),
+                "function f(cfg) that returns a backend which is used to access dicts definitions.",
+            ),
+            # ('groups', lambda cfg: datastructures.ConfigGroups({}),
+            (
+                "groups",
+                lambda cfg: datastructures.WikiGroups(),
+                "function f(cfg) that returns a backend which is used to access groups definitions.",
+            ),
+        ),
+    ),
     # ==========================================================================
-    'auth': ('Authentication / Authorization / Security', None, (
-        ('auth', DefaultExpression('[MoinAuth()]'),
-         "list of auth objects, to be called in order as specified"),
-        ('secrets', None, """Either a long shared secret string used for multiple purposes or a dict {"purpose": "longsecretstring", ...} for setting up different shared secrets for different purposes."""),
-        ('SecurityPolicy',
-         DefaultSecurityPolicy,
-         "Class object hook for implementing security restrictions or relaxations"),
-        ('endpoints_excluded',
-         [],
-         "Exclude unwanted endpoints (list of strings)"),
-        ('password_checker', DefaultExpression('_default_password_checker'),
-         'does simple checks whether a password is acceptable (you can switch this off by using "None" or enhance it by using a custom checker)'),
-
-        ('passlib_crypt_context', dict(
-            # schemes we want to support (or deprecated schemes for which we still have
-            # hashes in our storage).
-            # note about bcrypt: it needs additional code (that is not pure python and
-            # thus either needs compiling or installing platform-specific binaries)
-            schemes=["sha512_crypt", ],
-            # default scheme for creating new pw hashes (if not given, passlib uses first from schemes)
-            # default="sha512_crypt",
-            # deprecated schemes get auto-upgraded to the default scheme at login
-            # time or when setting a password (including doing a moin account pwreset).
-            # deprecated=["auto"],
-            # vary rounds parameter randomly when creating new hashes...
-            # all__vary_rounds=0.1,
-        ), "passlib CryptContext arguments, see passlib docs"),
-        ('allow_style_attributes', False, 'trust editors to not abuse style attribute security holes within HTML (CKEditor) or Markdown items'),
-    )),
+    "auth": (
+        "Authentication / Authorization / Security",
+        None,
+        (
+            ("auth", DefaultExpression("[MoinAuth()]"), "list of auth objects, to be called in order as specified"),
+            (
+                "secrets",
+                None,
+                """Either a long shared secret string used for multiple purposes or a dict {"purpose": "longsecretstring", ...} for setting up different shared secrets for different purposes.""",
+            ),
+            (
+                "SecurityPolicy",
+                DefaultSecurityPolicy,
+                "Class object hook for implementing security restrictions or relaxations",
+            ),
+            ("endpoints_excluded", [], "Exclude unwanted endpoints (list of strings)"),
+            (
+                "password_checker",
+                DefaultExpression("_default_password_checker"),
+                'does simple checks whether a password is acceptable (you can switch this off by using "None" or enhance it by using a custom checker)',
+            ),
+            (
+                "passlib_crypt_context",
+                dict(
+                    # schemes we want to support (or deprecated schemes for which we still have
+                    # hashes in our storage).
+                    # note about bcrypt: it needs additional code (that is not pure python and
+                    # thus either needs compiling or installing platform-specific binaries)
+                    schemes=["sha512_crypt"],
+                    # default scheme for creating new pw hashes (if not given, passlib uses first from schemes)
+                    # default="sha512_crypt",
+                    # deprecated schemes get auto-upgraded to the default scheme at login
+                    # time or when setting a password (including doing a moin account pwreset).
+                    # deprecated=["auto"],
+                    # vary rounds parameter randomly when creating new hashes...
+                    # all__vary_rounds=0.1,
+                ),
+                "passlib CryptContext arguments, see passlib docs",
+            ),
+            (
+                "allow_style_attributes",
+                False,
+                "trust editors to not abuse style attribute security holes within HTML (CKEditor) or Markdown items",
+            ),
+        ),
+    ),
     # ==========================================================================
-    'style': ('Style / Theme / UI', 'These settings control how the wiki user interface will look like.', (
-        ('sitename', 'Untitled Wiki',
-         "Short description of your wiki site, displayed below the logo on each page, and used in RSS documents as the channel title [Unicode]"),
-        ('interwikiname', None, "unique, stable and required InterWiki name (prefix, moniker) of the site [Unicode]"),
-        ('html_pagetitle', None, "Allows you to set a specific HTML page title (if None, it defaults to the value of 'sitename') [Unicode]"),
-        ('navi_bar', [
-            # cls, endpoint, args, link_text, title
-            ('wikilink', 'frontend.show_root', dict(), L_('Home'), L_('Home Page')),
-            ('wikilink', 'frontend.global_history', dict(), L_('History'), L_('Global History')),
-            ('wikilink', 'frontend.index', dict(), L_('Index'), L_('Global Index')),
-            ('wikilink', 'frontend.global_tags', dict(), L_('Tags'), L_('Global Tags Index')),
-            ('wikilink', 'admin.index_user', dict(), L_('User'), L_('User')),
-            ('wikilink', 'admin.index', dict(), L_('Admin'), L_('Administration & Docs')),
-            # TODO: tickets are broken
-            # ('wikilink', 'frontend.tickets', dict(), L_('Tickets'), L_('List of Tickets')),
-        ], 'Data to create the navi_bar from. Users can add more items in their quick links in user preferences. You need to configure a list of tuples (css_class, endpoint, args, label, title). Use L_() for translating. [list of tuples]'),
-        ('expanded_quicklinks_size', 8,
-         "Number of quicklinks to show as expanded in navi bar"),
-
-        ('theme_default', 'topside', "Default theme."),
-
-        ('serve_files', {},
-         """
+    "style": (
+        "Style / Theme / UI",
+        "These settings control how the wiki user interface will look like.",
+        (
+            (
+                "sitename",
+                "Untitled Wiki",
+                "Short description of your wiki site, displayed below the logo on each page, and used in RSS documents as the channel title [Unicode]",
+            ),
+            (
+                "interwikiname",
+                None,
+                "unique, stable and required InterWiki name (prefix, moniker) of the site [Unicode]",
+            ),
+            (
+                "html_pagetitle",
+                None,
+                "Allows you to set a specific HTML page title (if None, it defaults to the value of 'sitename') [Unicode]",
+            ),
+            (
+                "navi_bar",
+                [
+                    # cls, endpoint, args, link_text, title
+                    ("wikilink", "frontend.show_root", dict(), L_("Home"), L_("Home Page")),
+                    ("wikilink", "frontend.global_history", dict(), L_("History"), L_("Global History")),
+                    ("wikilink", "frontend.index", dict(), L_("Index"), L_("Global Index")),
+                    ("wikilink", "frontend.global_tags", dict(), L_("Tags"), L_("Global Tags Index")),
+                    ("wikilink", "admin.index_user", dict(), L_("User"), L_("User")),
+                    ("wikilink", "admin.index", dict(), L_("Admin"), L_("Administration & Docs")),
+                    # TODO: tickets are broken
+                    # ('wikilink', 'frontend.tickets', dict(), L_('Tickets'), L_('List of Tickets')),
+                ],
+                "Data to create the navi_bar from. Users can add more items in their quick links in user preferences. You need to configure a list of tuples (css_class, endpoint, args, label, title). Use L_() for translating. [list of tuples]",
+            ),
+            ("expanded_quicklinks_size", 8, "Number of quicklinks to show as expanded in navi bar"),
+            ("theme_default", "topside", "Default theme."),
+            (
+                "serve_files",
+                {},
+                """
          Dictionary of name: filesystem_path for static file resources to serve
          from the filesystem as url .../+serve/<name>/...
-         """),
-
-        ('supplementation_item_names', [_('Discussion'), ],
-         "List of names of the supplementation (sub)items [Unicode]"),
-
-        ('interwiki_preferred', [], "In dialogues, show those wikis at the top of the list [list of Unicode]."),
-        ('sistersites', [], "list of tuples: (<WikiName>, <sisterpagelist_fetch_url>)"),
-
-        ('trail_size', 5,
-         "Number of items in the trail of recently visited items"),
-
-        ('item_views', [
-            # (endpointname, label, title, check_item_exists
-            ('frontend.show_item', L_('Show'), L_('Show'), False, ),
-            ('frontend.modify_item', L_('Modify'), L_('Edit or Upload'), False, ),
-            ('frontend.history', L_('History'), L_('Revision History'), True, ),
-            ('frontend.download_item', L_('Download'), L_('Download'), True, ),
-            ('frontend.delete_item', L_('Delete'), L_('Delete this item'), True, ),
-            ('frontend.quicklink_item', None, L_('Create or remove a navigation link to this item'), False, ),
-            ('frontend.subscribe_item', None, L_('Switch notifications about item changes on or off'), False, ),
-            ('frontend.index', L_('Subitems'), L_('Subitems Index'), False, ),
-            ('special.supplementation', None, None, False, ),
-            ('frontend.rename_item', L_('Rename'), L_('Rename this item'), True, ),
-            ('frontend.highlight_item', L_('Highlight'), L_('Show with Syntax-Highlighting'), True, ),
-            ('frontend.show_item_meta', L_('Meta'), L_('Display Metadata'), True, ),
-            ('frontend.sitemap', L_('Site Map'), L_('Local Site Map of this item'), True, ),
-            ('frontend.similar_names', L_('Similar'), L_('Items with similar names'), False, ),
-            ('frontend.convert_item', L_('Convert'), L_('Convert this item'), True, ),
-            ('frontend.destroy_item', L_('Destroy'), L_('Completely destroy this item'), True, ),
-            ('special.comments', L_('Comments'), L_('Hide comments'), True, ),
-            ('special.transclusions', L_('Transclusions'), L_('Show transclusions'), True, ),
-        ], 'list of edit bar entries (list of tuples (endpoint, label, title, exists))'),
-
-        ('show_hosts', True,
-         "if True, show host names and IPs. Set to False to hide them."),
-        ('show_interwiki', False,
-         "if True, let the theme display your interwiki name"),
-        ('show_names', True,
-         "if True, show user names in the revision history. Set to False to hide them."),
-        ('show_section_numbers', False,
-         'show section numbers in headings by default'),
-        ('show_rename_redirect', False, "if True, offer creation of redirect pages when renaming wiki pages"),
-
-        ('template_dirs', [], "list of directories with templates that will override theme and base templates."),
-    )),
+         """,
+            ),
+            (
+                "supplementation_item_names",
+                [_("Discussion")],
+                "List of names of the supplementation (sub)items [Unicode]",
+            ),
+            ("interwiki_preferred", [], "In dialogues, show those wikis at the top of the list [list of Unicode]."),
+            ("sistersites", [], "list of tuples: (<WikiName>, <sisterpagelist_fetch_url>)"),
+            ("trail_size", 5, "Number of items in the trail of recently visited items"),
+            (
+                "item_views",
+                [
+                    # (endpointname, label, title, check_item_exists
+                    ("frontend.show_item", L_("Show"), L_("Show"), False),
+                    ("frontend.modify_item", L_("Modify"), L_("Edit or Upload"), False),
+                    ("frontend.history", L_("History"), L_("Revision History"), True),
+                    ("frontend.download_item", L_("Download"), L_("Download"), True),
+                    ("frontend.delete_item", L_("Delete"), L_("Delete this item"), True),
+                    ("frontend.quicklink_item", None, L_("Create or remove a navigation link to this item"), False),
+                    ("frontend.subscribe_item", None, L_("Switch notifications about item changes on or off"), False),
+                    ("frontend.index", L_("Subitems"), L_("Subitems Index"), False),
+                    ("special.supplementation", None, None, False),
+                    ("frontend.rename_item", L_("Rename"), L_("Rename this item"), True),
+                    ("frontend.highlight_item", L_("Highlight"), L_("Show with Syntax-Highlighting"), True),
+                    ("frontend.show_item_meta", L_("Meta"), L_("Display Metadata"), True),
+                    ("frontend.sitemap", L_("Site Map"), L_("Local Site Map of this item"), True),
+                    ("frontend.similar_names", L_("Similar"), L_("Items with similar names"), False),
+                    ("frontend.convert_item", L_("Convert"), L_("Convert this item"), True),
+                    ("frontend.destroy_item", L_("Destroy"), L_("Completely destroy this item"), True),
+                    ("special.comments", L_("Comments"), L_("Hide comments"), True),
+                    ("special.transclusions", L_("Transclusions"), L_("Show transclusions"), True),
+                ],
+                "list of edit bar entries (list of tuples (endpoint, label, title, exists))",
+            ),
+            ("show_hosts", True, "if True, show host names and IPs. Set to False to hide them."),
+            ("show_interwiki", False, "if True, let the theme display your interwiki name"),
+            ("show_names", True, "if True, show user names in the revision history. Set to False to hide them."),
+            ("show_section_numbers", False, "show section numbers in headings by default"),
+            ("show_rename_redirect", False, "if True, offer creation of redirect pages when renaming wiki pages"),
+            ("template_dirs", [], "list of directories with templates that will override theme and base templates."),
+        ),
+    ),
     # ==========================================================================
-    'editor': ('Editor', None, (
-        ('edit_locking_policy', 'lock', "Editor locking policy: None or 'lock'"),  # 'warn' as in 1.9.x is not supported
-        ('edit_lock_time', 10, "Time, in minutes, to hold or renew edit lock at start of edit or preview"),
-        # ('item_license', '', 'not used: maybe page_license_enabled from 1.9.x; if set, show the license item within the editor. [Unicode]'),
-        # ('edit_ticketing', True, 'not used: maybe a remnant of https://moinmo.in/TicketSystem'),
-    )),
+    "editor": (
+        "Editor",
+        None,
+        (
+            (
+                "edit_locking_policy",
+                "lock",
+                "Editor locking policy: None or 'lock'",
+            ),  # 'warn' as in 1.9.x is not supported
+            ("edit_lock_time", 10, "Time, in minutes, to hold or renew edit lock at start of edit or preview"),
+            # ('item_license', '', 'not used: maybe page_license_enabled from 1.9.x; if set, show the license item within the editor. [Unicode]'),
+            # ('edit_ticketing', True, 'not used: maybe a remnant of https://moinmo.in/TicketSystem'),
+        ),
+    ),
     # ==========================================================================
-    'paging': ('Paging', None, (
-        ('results_per_page', 50, "Number of results to be shown on a single page in pagination"),
-    )),
+    "paging": (
+        "Paging",
+        None,
+        (("results_per_page", 50, "Number of results to be shown on a single page in pagination"),),
+    ),
     # ==========================================================================
-    'data': ('Data Storage', None, (
-        ('data_dir', './data/', "Path to the data directory."),
-        ('plugin_dirs', [], "Plugin directories."),
-
-        ('interwiki_map', {},
-         "Dictionary of wiki_name -> wiki_url"),
-        ('namespace_mapping', None,
-         "A list of tuples, each tuple containing: Namespace identifier, backend name. " +
-         "E.g.: [('', 'default')), ]."),
-        ('backend_mapping', None,
-         "A dictionary that maps backend names to backends. " +
-         "E.g.: {'default': Backend(), }."),
-        ('acl_mapping', None,
-         "This needs to point to a list of tuples, each tuple containing: name prefix, acl protection to be applied to matching items. " +
-         "E.g.: [('', dict(default='All:read,write,create,admin')), ]."),
-        ('mimetypes_to_index_as_empty', [], "List of mimetypes which are indexed as though they were empty."),
-    )),
+    "data": (
+        "Data Storage",
+        None,
+        (
+            ("data_dir", "./data/", "Path to the data directory."),
+            ("plugin_dirs", [], "Plugin directories."),
+            ("interwiki_map", {}, "Dictionary of wiki_name -> wiki_url"),
+            (
+                "namespace_mapping",
+                None,
+                "A list of tuples, each tuple containing: Namespace identifier, backend name. "
+                + "E.g.: [('', 'default')), ].",
+            ),
+            (
+                "backend_mapping",
+                None,
+                "A dictionary that maps backend names to backends. " + "E.g.: {'default': Backend(), }.",
+            ),
+            (
+                "acl_mapping",
+                None,
+                "This needs to point to a list of tuples, each tuple containing: name prefix, acl protection to be applied to matching items. "
+                + "E.g.: [('', dict(default='All:read,write,create,admin')), ].",
+            ),
+            ("mimetypes_to_index_as_empty", [], "List of mimetypes which are indexed as though they were empty."),
+        ),
+    ),
     # ==========================================================================
-    'items': ('Special Item Names', None, (
-        ('default_root', 'Home', "Default root, use this value in case no match is found in root_mapping. [Unicode]"),
-        ('root_mapping', {}, "mapping of namespaces to item_roots."),
-
-        # the following regexes should match the complete name when used in free text
-        # the group 'all' shall match all, while the group 'key' shall match the key only
-        # e.g. FooGroup -> group 'all' ==  FooGroup, group 'key' == Foo
-        # moin's code will add ^ / $ at beginning / end when needed
-        ('item_dict_regex', r'(?P<all>(?P<key>\S+)Dict)',
-         'Item names exactly matching this regex are regarded as items containing variable dictionary definitions [Unicode]'),
-        ('item_group_regex', r'(?P<all>(?P<key>\S+)Group)',
-         'Item names exactly matching this regex are regarded as items containing group definitions [Unicode]'),
-    )),
+    "items": (
+        "Special Item Names",
+        None,
+        (
+            (
+                "default_root",
+                "Home",
+                "Default root, use this value in case no match is found in root_mapping. [Unicode]",
+            ),
+            ("root_mapping", {}, "mapping of namespaces to item_roots."),
+            # the following regexes should match the complete name when used in free text
+            # the group 'all' shall match all, while the group 'key' shall match the key only
+            # e.g. FooGroup -> group 'all' ==  FooGroup, group 'key' == Foo
+            # moin's code will add ^ / $ at beginning / end when needed
+            (
+                "item_dict_regex",
+                r"(?P<all>(?P<key>\S+)Dict)",
+                "Item names exactly matching this regex are regarded as items containing variable dictionary definitions [Unicode]",
+            ),
+            (
+                "item_group_regex",
+                r"(?P<all>(?P<key>\S+)Group)",
+                "Item names exactly matching this regex are regarded as items containing group definitions [Unicode]",
+            ),
+        ),
+    ),
     # ==========================================================================
-    'user': ('User Preferences', None, (
-        ('user_defaults', {
-            NAME: [],
-            DISPLAY_NAME: None,
-            EMAIL: None,
-            CSS_URL: None,
-            ISO_8601: False,
-            MAILTO_AUTHOR: False,
-            EDIT_ON_DOUBLECLICK: True,
-            SCROLL_PAGE_AFTER_EDIT: True,
-            SHOW_COMMENTS: False,
-            WANT_TRIVIAL: False,
-            ENC_PASSWORD: '',  # empty value == invalid hash
-            RECOVERPASS_KEY: '',  # empty value == invalid key
-            SESSION_KEY: '',  # empty value == invalid key
-            DISABLED: False,
-            BOOKMARKS: {},
-            QUICKLINKS: [],
-            SUBSCRIPTIONS: [],
-            EMAIL_SUBSCRIBED_EVENTS: [
-                # XXX PageChangedEvent.__name__
-                # XXX PageRenamedEvent.__name__
-                # XXX PageDeletedEvent.__name__
-                # XXX PageCopiedEvent.__name__
-                # XXX PageRevertedEvent.__name__
-            ],
-            THEME_NAME: None,  # None -> use cfg.theme_default
-            EDIT_ROWS: 0,
-            RESULTS_PER_PAGE: 50,
-            LOCALE: None,  # None -> do browser language detection, otherwise just use this locale
-            TIMEZONE: None,  # None -> use cfg.timezone_default
-            EMAIL_UNVALIDATED: None,
-        }, 'Default attributes of the user object'),
-    )),
+    "user": (
+        "User Preferences",
+        None,
+        (
+            (
+                "user_defaults",
+                {
+                    NAME: [],
+                    DISPLAY_NAME: None,
+                    EMAIL: None,
+                    CSS_URL: None,
+                    ISO_8601: False,
+                    MAILTO_AUTHOR: False,
+                    EDIT_ON_DOUBLECLICK: True,
+                    SCROLL_PAGE_AFTER_EDIT: True,
+                    SHOW_COMMENTS: False,
+                    WANT_TRIVIAL: False,
+                    ENC_PASSWORD: "",  # empty value == invalid hash
+                    RECOVERPASS_KEY: "",  # empty value == invalid key
+                    SESSION_KEY: "",  # empty value == invalid key
+                    DISABLED: False,
+                    BOOKMARKS: {},
+                    QUICKLINKS: [],
+                    SUBSCRIPTIONS: [],
+                    EMAIL_SUBSCRIBED_EVENTS: [
+                        # XXX PageChangedEvent.__name__
+                        # XXX PageRenamedEvent.__name__
+                        # XXX PageDeletedEvent.__name__
+                        # XXX PageCopiedEvent.__name__
+                        # XXX PageRevertedEvent.__name__
+                    ],
+                    THEME_NAME: None,  # None -> use cfg.theme_default
+                    EDIT_ROWS: 0,
+                    RESULTS_PER_PAGE: 50,
+                    LOCALE: None,  # None -> do browser language detection, otherwise just use this locale
+                    TIMEZONE: None,  # None -> use cfg.timezone_default
+                    EMAIL_UNVALIDATED: None,
+                },
+                "Default attributes of the user object",
+            ),
+        ),
+    ),
     # ==========================================================================
-    'various': ('Various', None, (
-        # ('bang_meta', True, 'if True, enable {{{#!NoWikiName}}} markup'),
-
-        ('config_check_enabled', False, "if True, check configuration for unknown settings."),
-
-        ('timezone_default', 'UTC', "Default time zone."),
-        ('locale_default', 'en_US', "Default locale for user interface and content."),
-
-        # ('log_remote_addr', True, "if True, log the remote IP address (and maybe hostname)."),
-        ('log_reverse_dns_lookups', True,
-         "if True, do a reverse DNS lookup on page SAVE. If your DNS is broken, set this to False to speed up SAVE."),
-
-        # some dangerous mimetypes (we don't use "content-disposition: inline" for them when a user
-        # downloads such data, because the browser might execute e.g. Javascript contained
-        # in the HTML and steal your moin session cookie or do other nasty stuff)
-        ('mimetypes_xss_protect', [
-            'text/html',
-            'application/x-shockwave-flash',
-            'application/xhtml+xml',
-        ], '"content-disposition: inline" is not used for downloads of such data'),
-
-        # ('refresh', None, "refresh = (minimum_delay_s, targets_allowed) enables use of '#refresh 5 PageName' processing instruction, targets_allowed must be either 'internal' or 'external'"),
-        ('siteid', 'MoinMoin', None),  # XXX just default to some existing module name to
-                                       # make plugin loader etc. work for now
-        ('contenttype_disabled', [], "List of disabled content types. Ignored if contenttype_enabled is set."),
-        ('contenttype_enabled', [], "List of available content types for new items. Default: [] (all types enabled)."),
-    )),
+    "various": (
+        "Various",
+        None,
+        (
+            # ('bang_meta', True, 'if True, enable {{{#!NoWikiName}}} markup'),
+            ("config_check_enabled", False, "if True, check configuration for unknown settings."),
+            ("timezone_default", "UTC", "Default time zone."),
+            ("locale_default", "en_US", "Default locale for user interface and content."),
+            # ('log_remote_addr', True, "if True, log the remote IP address (and maybe hostname)."),
+            (
+                "log_reverse_dns_lookups",
+                True,
+                "if True, do a reverse DNS lookup on page SAVE. If your DNS is broken, set this to False to speed up SAVE.",
+            ),
+            # some dangerous mimetypes (we don't use "content-disposition: inline" for them when a user
+            # downloads such data, because the browser might execute e.g. Javascript contained
+            # in the HTML and steal your moin session cookie or do other nasty stuff)
+            (
+                "mimetypes_xss_protect",
+                ["text/html", "application/x-shockwave-flash", "application/xhtml+xml"],
+                '"content-disposition: inline" is not used for downloads of such data',
+            ),
+            # ('refresh', None, "refresh = (minimum_delay_s, targets_allowed) enables use of '#refresh 5 PageName' processing instruction, targets_allowed must be either 'internal' or 'external'"),
+            ("siteid", "MoinMoin", None),  # XXX just default to some existing module name to
+            # make plugin loader etc. work for now
+            ("contenttype_disabled", [], "List of disabled content types. Ignored if contenttype_enabled is set."),
+            (
+                "contenttype_enabled",
+                [],
+                "List of available content types for new items. Default: [] (all types enabled).",
+            ),
+        ),
+    ),
 }
 
 #
@@ -545,44 +661,75 @@ def __init__(self, exprstr):
 #
 #
 options = {
-    'acl': ('Access Control Lists', 'ACLs control who may do what.', (
-        ('functions', '', 'Access Control List for functions.'),
-        ('rights_contents', ACL_RIGHTS_CONTENTS, 'Valid tokens for right sides of content ACL entries.'),
-        ('rights_functions', ACL_RIGHTS_FUNCTIONS, 'Valid tokens for right sides of function ACL entries.'),
-    )),
-
-    'ns': ('Storage Namespaces',
-           "Storage namespaces can be defined for all sorts of data. "
-           "All items sharing a common namespace as prefix are then stored within the same backend. "
-           "The common prefix for all data is ''.", (
-        ('content', '/', "All content is by default stored below /, hence the prefix is ''."),  # Not really necessary. Just for completeness.
-        ('user_profile', 'userprofiles/', 'User profiles (i.e. user data, not their homepage) are stored in this namespace.'),
-        ('user_homepage', 'users/', 'All user homepages are stored in this namespace.'),
-    )),
-
-    'user': ('User', None, (
-        ('email_unique', True,
-         "if True, check email addresses for uniqueness and don't accept duplicates."),
-        ('email_verification', False,
-         "if True, require a new user to verify his or her email address before the first login."),
-
-        ('homewiki', 'Self',
-         "interwiki name of the wiki where the user home pages are located [Unicode] - useful if you have ''many'' users. You could even link to nonwiki \"user pages\" if the wiki username is in the target URL."),
-        ('use_gravatar', False, "if True, gravatar.com will be used to find User's avatar")
-    )),
-
-    'mail': ('Mail', 'These settings control outgoing and incoming email from and to the wiki.', (
-        ('from', None, "Used as From: address for generated mail. [Unicode]"),
-        ('username', None, "Username for SMTP server authentication (None = don't use auth)."),
-        ('password', None, "Password for SMTP server authentication (None = don't use auth)."),
-        ('smarthost', None, "Address of SMTP server to use for sending mail (None = don't use SMTP server)."),
-        ('sendmail', None, "sendmail command to use for sending mail (None = don't use sendmail)"),
-    )),
-
-    'registration': ('Registration', 'These settings control registration options', (
-        ('only_by_superuser', False, 'True is recommended value for public wikis on the internet.'),
-        ('hint', _('To request an account, see bottom of Home page.'), 'message on login page when only_by_superuser is True'),
-    )),
+    "acl": (
+        "Access Control Lists",
+        "ACLs control who may do what.",
+        (
+            ("functions", "", "Access Control List for functions."),
+            ("rights_contents", ACL_RIGHTS_CONTENTS, "Valid tokens for right sides of content ACL entries."),
+            ("rights_functions", ACL_RIGHTS_FUNCTIONS, "Valid tokens for right sides of function ACL entries."),
+        ),
+    ),
+    "ns": (
+        "Storage Namespaces",
+        "Storage namespaces can be defined for all sorts of data. "
+        "All items sharing a common namespace as prefix are then stored within the same backend. "
+        "The common prefix for all data is ''.",
+        (
+            (
+                "content",
+                "/",
+                "All content is by default stored below /, hence the prefix is ''.",
+            ),  # Not really necessary. Just for completeness.
+            (
+                "user_profile",
+                "userprofiles/",
+                "User profiles (i.e. user data, not their homepage) are stored in this namespace.",
+            ),
+            ("user_homepage", "users/", "All user homepages are stored in this namespace."),
+        ),
+    ),
+    "user": (
+        "User",
+        None,
+        (
+            ("email_unique", True, "if True, check email addresses for uniqueness and don't accept duplicates."),
+            (
+                "email_verification",
+                False,
+                "if True, require a new user to verify his or her email address before the first login.",
+            ),
+            (
+                "homewiki",
+                "Self",
+                "interwiki name of the wiki where the user home pages are located [Unicode] - useful if you have ''many'' users. You could even link to nonwiki \"user pages\" if the wiki username is in the target URL.",
+            ),
+            ("use_gravatar", False, "if True, gravatar.com will be used to find User's avatar"),
+        ),
+    ),
+    "mail": (
+        "Mail",
+        "These settings control outgoing and incoming email from and to the wiki.",
+        (
+            ("from", None, "Used as From: address for generated mail. [Unicode]"),
+            ("username", None, "Username for SMTP server authentication (None = don't use auth)."),
+            ("password", None, "Password for SMTP server authentication (None = don't use auth)."),
+            ("smarthost", None, "Address of SMTP server to use for sending mail (None = don't use SMTP server)."),
+            ("sendmail", None, "sendmail command to use for sending mail (None = don't use sendmail)"),
+        ),
+    ),
+    "registration": (
+        "Registration",
+        "These settings control registration options",
+        (
+            ("only_by_superuser", False, "True is recommended value for public wikis on the internet."),
+            (
+                "hint",
+                _("To request an account, see bottom of Home page."),
+                "message on login page when only_by_superuser is True",
+            ),
+        ),
+    ),
 }
 
 
@@ -591,10 +738,11 @@ def _add_options_to_defconfig(opts, addgroup=True):
         group_short, group_doc, group_opts = opts[groupname]
         for name, default, doc in group_opts:
             if addgroup:
-                name = groupname + '_' + name
+                name = groupname + "_" + name
             if isinstance(default, DefaultExpression):
                 default = default.value
             setattr(DefaultConfig, name, default)
 
+
 _add_options_to_defconfig(options)
 _add_options_to_defconfig(options_no_group_name, False)
diff --git a/src/moin/conftest.py b/src/moin/conftest.py
index b2c3576bd..23909a6b7 100644
--- a/src/moin/conftest.py
+++ b/src/moin/conftest.py
@@ -28,14 +28,14 @@
 
 # exclude some directories from pytest test discovery, pathes relative to this file
 collect_ignore = [
-    'static',  # same
-    '../wiki',  # no tests there
-    '../instance',  # tw likes to use this for wiki data (non-revisioned)
+    "static",  # same
+    "../wiki",  # no tests there
+    "../instance",  # tw likes to use this for wiki data (non-revisioned)
 ]
 
 # Logging for tests to avoid useless output like timing information on stderr on test failures
 Moindir = py.path.local(moin.__file__).dirname
-config_file = Moindir + '/_tests/test_logging.conf'
+config_file = Moindir + "/_tests/test_logging.conf"
 moin.log.load_config(config_file)
 
 
@@ -46,10 +46,7 @@ def cfg():
 
 @pytest.fixture
 def app_ctx(cfg):
-    namespace_mapping, backend_mapping, acl_mapping = create_simple_mapping(
-        "stores:memory:",
-        cfg.default_acl
-    )
+    namespace_mapping, backend_mapping, acl_mapping = create_simple_mapping("stores:memory:", cfg.default_acl)
     more_config = dict(
         namespace_mapping=namespace_mapping,
         backend_mapping=backend_mapping,
@@ -57,18 +54,14 @@ def app_ctx(cfg):
         create_backend=True,  # create backend storage and index
         destroy_backend=True,  # remove index and storage at app shutdown
     )
-    app = create_app_ext(
-        flask_config_dict=dict(SECRET_KEY='foobarfoobar'),
-        moin_config_class=cfg,
-        **more_config
-    )
-    ctx = app.test_request_context('/', base_url="http://localhost:8080/")
+    app = create_app_ext(flask_config_dict=dict(SECRET_KEY="foobarfoobar"), moin_config_class=cfg, **more_config)
+    ctx = app.test_request_context("/", base_url="http://localhost:8080/")
     ctx.push()
     before_wiki()
 
     yield app, ctx
 
-    teardown_wiki('')
+    teardown_wiki("")
     ctx.pop()
     try:
         # simulate ERROR PermissionError:
diff --git a/src/moin/constants/contenttypes.py b/src/moin/constants/contenttypes.py
index 7a71dd018..ae9ffd182 100644
--- a/src/moin/constants/contenttypes.py
+++ b/src/moin/constants/contenttypes.py
@@ -13,144 +13,144 @@
 # Charset - we support only 'utf-8'. While older encodings might work,
 # we don't have the resources to test them, and there is no real
 # benefit for the user. IMPORTANT: use only lowercase 'utf-8'!
-CHARSET = 'utf-8'
-CHARSET19 = 'utf-8'
+CHARSET = "utf-8"
+CHARSET19 = "utf-8"
 
 # Parser to use mimetype text
 PARSER_TEXT_MIMETYPE = [
-    'plain', 'csv', 'rst', 'docbook', 'latex', 'tex', 'html', 'css',
-    'xml', 'python', 'perl', 'php', 'ruby', 'javascript',
-    'cplusplus', 'java', 'pascal', 'diff', 'gettext', 'xslt', 'creole',
+    "plain",
+    "csv",
+    "rst",
+    "docbook",
+    "latex",
+    "tex",
+    "html",
+    "css",
+    "xml",
+    "python",
+    "perl",
+    "php",
+    "ruby",
+    "javascript",
+    "cplusplus",
+    "java",
+    "pascal",
+    "diff",
+    "gettext",
+    "xslt",
+    "creole",
 ]
 
-CONTENTTYPE_USER = 'application/x.moin.userprofile'
-CONTENTTYPE_DEFAULT = 'application/octet-stream'
-CONTENTTYPE_NONEXISTENT = 'application/x-nonexistent'
+CONTENTTYPE_USER = "application/x.moin.userprofile"
+CONTENTTYPE_DEFAULT = "application/octet-stream"
+CONTENTTYPE_NONEXISTENT = "application/x-nonexistent"
 
 CONTENTTYPE_MARKUP = [
-    'text/x.moin.wiki;charset=utf-8',
-    'text/x-mediawiki;charset=utf-8',
-    'text/x.moin.creole;charset=utf-8',
-    'text/x-markdown;charset=utf-8',
-    'text/x-rst;charset=utf-8',
-    'text/html;charset=utf-8',
-    'application/docbook+xml;charset=utf-8',
+    "text/x.moin.wiki;charset=utf-8",
+    "text/x-mediawiki;charset=utf-8",
+    "text/x.moin.creole;charset=utf-8",
+    "text/x-markdown;charset=utf-8",
+    "text/x-rst;charset=utf-8",
+    "text/html;charset=utf-8",
+    "application/docbook+xml;charset=utf-8",
 ]
 
 CONTENTTYPE_MARKUP_OUT = {
-    'moinwiki': 'text/x.moin.wiki;charset=utf-8',
+    "moinwiki": "text/x.moin.wiki;charset=utf-8",
     # 'mediawiki': 'text/x-mediawiki;charset=utf-8',  # no output converter
     # 'creole': 'text/x.moin.creole;charset=utf-8',  # no output converter
-    'markdown': 'text/x-markdown;charset=utf-8',
-    'rst': 'text/x-rst;charset=utf-8',
-    'html': 'text/html;charset=utf-8',
-    'docbook': 'application/docbook+xml;charset=utf-8',
+    "markdown": "text/x-markdown;charset=utf-8",
+    "rst": "text/x-rst;charset=utf-8",
+    "html": "text/html;charset=utf-8",
+    "docbook": "application/docbook+xml;charset=utf-8",
 }
 
 CONTENTTYPE_NO_EXPANSION = [
     # no need to expand transclusions, etc. when converting to/from these types
-    'text/x.moin.wiki;charset=utf-8',
-    'text/x.moin.creole;charset=utf-8',
+    "text/x.moin.wiki;charset=utf-8",
+    "text/x.moin.creole;charset=utf-8",
 ]
 
 CONTENTTYPE_VARIABLES = [
     # content types that support variables: @SIG@, @EMAIL@, @TIME@, @DATE@, etc
-    'text/x.moin.wiki;charset=utf-8',
-    'text/x.moin.wiki;format=1.9;charset=utf-8',
+    "text/x.moin.wiki;charset=utf-8",
+    "text/x.moin.wiki;format=1.9;charset=utf-8",
 ]
 
-CONTENTTYPE_MOIN_19 = [
-    'text/x.moin.wiki;format=1.9;charset=utf-8',
-]
+CONTENTTYPE_MOIN_19 = ["text/x.moin.wiki;format=1.9;charset=utf-8"]
 
 CONTENTTYPE_TEXT = [
-    'text/plain;charset=utf-8',
-    'text/x-diff;charset=utf-8',
-    'text/x-python;charset=utf-8',
-    'text/csv;charset=utf-8',
-    'text/x-irclog;charset=utf-8',
+    "text/plain;charset=utf-8",
+    "text/x-diff;charset=utf-8",
+    "text/x-python;charset=utf-8",
+    "text/csv;charset=utf-8",
+    "text/x-irclog;charset=utf-8",
 ]
 
-CONTENTTYPE_IMAGE = [
-    'image/svg+xml',
-    'image/png',
-    'image/jpeg',
-    'image/gif',
-]
+CONTENTTYPE_IMAGE = ["image/svg+xml", "image/png", "image/jpeg", "image/gif"]
 
-CONTENTTYPE_AUDIO = [
-    'audio/wave',
-    'audio/ogg',
-    'audio/mpeg',
-    'audio/webm',
-]
+CONTENTTYPE_AUDIO = ["audio/wave", "audio/ogg", "audio/mpeg", "audio/webm"]
 
-CONTENTTYPE_VIDEO = [
-    'video/ogg',
-    'video/webm',
-    'video/mp4',
-]
+CONTENTTYPE_VIDEO = ["video/ogg", "video/webm", "video/mp4"]
 
 # TODO: is there a source that maps all (or common) file suffixes to media contenttypes as used by /maint/dump_html.py
 CONTENTTYPE_MEDIA = CONTENTTYPE_VIDEO + CONTENTTYPE_AUDIO + CONTENTTYPE_IMAGE
 CONTENTTYPE_MEDIA_SUFFIX = tuple(
-    '.svg .png .jpg .jpeg .gif .wave .wav .ogg .oga .ogv.mpeg .mpg .mp3 .webm .mp4'.split()
+    ".svg .png .jpg .jpeg .gif .wave .wav .ogg .oga .ogv.mpeg .mpg .mp3 .webm .mp4".split()
 )
 
-CONTENTTYPE_DRAWING = [
-    'application/x-svgdraw',
-]
+CONTENTTYPE_DRAWING = ["application/x-svgdraw"]
 
 CONTENTTYPE_OTHER = [
-    'application/octet-stream',
-    'application/x-tar',
-    'application/x-gtar',
-    'application/zip',
-    'application/pdf',
+    "application/octet-stream",
+    "application/x-tar",
+    "application/x-gtar",
+    "application/zip",
+    "application/pdf",
 ]
 
 CONTENTTYPES_MAP = {
-    'text/x.moin.wiki;charset=utf-8': 'Moinmoin',
-    'text/x.moin.wiki;format=1.9;charset=utf-8': 'Moinmoin 1.9',
-    'text/x-mediawiki;charset=utf-8': 'MediaWiki',
-    'text/x.moin.creole;charset=utf-8': 'Creole',
-    'text/x-markdown;charset=utf-8': 'Markdown',
-    'text/x-rst;charset=utf-8': 'ReST',
-    'text/html;charset=utf-8': 'HTML',
-    'application/docbook+xml;charset=utf-8': 'DocBook',
-    'text/plain;charset=utf-8': 'Plain Text',
-    'text/x-diff;charset=utf-8': 'Diff/Patch',
-    'text/x-python;charset=utf-8': 'Python Code',
-    'text/csv;charset=utf-8': 'CSV',
-    'text/x-irclog;charset=utf-8': 'IRC Log',
-    'image/svg+xml': 'SVG Image',
-    'image/png': 'PNG Image',
-    'image/jpeg': 'JPEG Image',
-    'image/gif': 'GIF Image',
-    'audio/wave': 'WAV Audio',
-    'audio/ogg': 'OGG Audio',
-    'audio/mpeg': 'MP3 Audio',
-    'audio/webm': 'WebM Audio',
-    'video/ogg': 'OGG Video',
-    'video/webm': 'WebM Video',
-    'video/mp4': 'MP4 Video',
-    'application/x-svgdraw': 'SVGDRAW',
-    'application/octet-stream': 'Binary File',
-    'application/x-tar': 'TAR',
-    'application/x-gtar': 'TGZ',
-    'application/zip': 'ZIP',
-    'application/pdf': 'PDF',
+    "text/x.moin.wiki;charset=utf-8": "Moinmoin",
+    "text/x.moin.wiki;format=1.9;charset=utf-8": "Moinmoin 1.9",
+    "text/x-mediawiki;charset=utf-8": "MediaWiki",
+    "text/x.moin.creole;charset=utf-8": "Creole",
+    "text/x-markdown;charset=utf-8": "Markdown",
+    "text/x-rst;charset=utf-8": "ReST",
+    "text/html;charset=utf-8": "HTML",
+    "application/docbook+xml;charset=utf-8": "DocBook",
+    "text/plain;charset=utf-8": "Plain Text",
+    "text/x-diff;charset=utf-8": "Diff/Patch",
+    "text/x-python;charset=utf-8": "Python Code",
+    "text/csv;charset=utf-8": "CSV",
+    "text/x-irclog;charset=utf-8": "IRC Log",
+    "image/svg+xml": "SVG Image",
+    "image/png": "PNG Image",
+    "image/jpeg": "JPEG Image",
+    "image/gif": "GIF Image",
+    "audio/wave": "WAV Audio",
+    "audio/ogg": "OGG Audio",
+    "audio/mpeg": "MP3 Audio",
+    "audio/webm": "WebM Audio",
+    "video/ogg": "OGG Video",
+    "video/webm": "WebM Video",
+    "video/mp4": "MP4 Video",
+    "application/x-svgdraw": "SVGDRAW",
+    "application/octet-stream": "Binary File",
+    "application/x-tar": "TAR",
+    "application/x-gtar": "TGZ",
+    "application/zip": "ZIP",
+    "application/pdf": "PDF",
 }
 
-GROUP_MARKUP_TEXT = 'Markup Text Items'
-GROUP_OTHER_TEXT = 'Other Text Items'
-GROUP_IMAGE = 'Image Items'
-GROUP_AUDIO = 'Audio Items'
-GROUP_VIDEO = 'Video Items'
-GROUP_DRAWING = 'Drawing Items'
-GROUP_OTHER = 'Other Items'
+GROUP_MARKUP_TEXT = "Markup Text Items"
+GROUP_OTHER_TEXT = "Other Text Items"
+GROUP_IMAGE = "Image Items"
+GROUP_AUDIO = "Audio Items"
+GROUP_VIDEO = "Video Items"
+GROUP_DRAWING = "Drawing Items"
+GROUP_OTHER = "Other Items"
 
-DRAWING_EXTENSIONS = ['.svg', '.png', '.jpg', '.jpeg', '.gif', ]
+DRAWING_EXTENSIONS = [".svg", ".png", ".jpg", ".jpeg", ".gif"]
 
 
 # help for wiki editors based on content type
@@ -160,45 +160,47 @@ def ext_link(href, link_text=None):
 
 help_on_plain_text = _("This is a plain text item, there is no markup.")
 help_on_binary = _("This item can not be edited, upload a revised file.")
-help_on_csv = ' '.join((
-    _("Use a semicolon or comma to separate cells."),
-    _("If the first row is recognized as a header, the table will be sortable."),
-    ext_link("https://en.wikipedia.org/wiki/Comma-separated_values"),
-))
+help_on_csv = " ".join(
+    (
+        _("Use a semicolon or comma to separate cells."),
+        _("If the first row is recognized as a header, the table will be sortable."),
+        ext_link("https://en.wikipedia.org/wiki/Comma-separated_values"),
+    )
+)
 
 
 CONTENTTYPES_HELP_DOCS = {
     # content type: tuple - content type, button text; link generated later based on user preferred language
-    'text/x.moin.wiki;charset=utf-8': (('moin', _("Click for help on Moin Wiki markup."))),
-    'text/x.moin.wiki;format=1.9;charset=utf-8': (('moin', _("Moinmoin 1.9 format is deprecated, convert to moin 2."))),
-    'text/x-mediawiki;charset=utf-8': (('mediawiki', _("Click for help on Media Wiki markup."))),
-    'text/x.moin.creole;charset=utf-8': (('creole', _("Click for help on Creole Wiki markup."))),
-    'text/x-markdown;charset=utf-8': (('markdown', _("Click for help on Markdown Wiki markup."))),
-    'text/x-rst;charset=utf-8': (('rst', _("Click for help on reST Wiki markup."))),
-    'application/docbook+xml;charset=utf-8': (('docbook', _("Click for help on Docbook Wiki markup."))),
+    "text/x.moin.wiki;charset=utf-8": (("moin", _("Click for help on Moin Wiki markup."))),
+    "text/x.moin.wiki;format=1.9;charset=utf-8": (("moin", _("Moinmoin 1.9 format is deprecated, convert to moin 2."))),
+    "text/x-mediawiki;charset=utf-8": (("mediawiki", _("Click for help on Media Wiki markup."))),
+    "text/x.moin.creole;charset=utf-8": (("creole", _("Click for help on Creole Wiki markup."))),
+    "text/x-markdown;charset=utf-8": (("markdown", _("Click for help on Markdown Wiki markup."))),
+    "text/x-rst;charset=utf-8": (("rst", _("Click for help on reST Wiki markup."))),
+    "application/docbook+xml;charset=utf-8": (("docbook", _("Click for help on Docbook Wiki markup."))),
     # content type: help string
-    'text/html;charset=utf-8': ext_link('http://ckeditor.com/'),
-    'text/plain;charset=utf-8': help_on_plain_text,
-    'text/x-diff;charset=utf-8': help_on_plain_text,
-    'text/x-python;charset=utf-8': help_on_plain_text,
-    'text/csv;charset=utf-8': help_on_csv,
-    'text/x-irclog;charset=utf-8': help_on_plain_text,
-    'image/svg+xml': help_on_binary,
-    'image/png': help_on_binary,
-    'image/jpeg': help_on_binary,
-    'image/gif': help_on_binary,
-    'audio/wave': help_on_binary,
-    'audio/ogg': help_on_binary,
-    'audio/mpeg': help_on_binary,
-    'audio/webm': help_on_binary,
-    'video/ogg': help_on_binary,
-    'video/webm': help_on_binary,
-    'video/mp4': help_on_binary,
-    'application/x-svgdraw': ext_link('http://code.google.com/p/svg-edit/'),
-    'application/octet-stream': help_on_binary,
-    'application/x-tar': help_on_binary,
-    'application/x-gtar': help_on_binary,
-    'application/zip': help_on_binary,
-    'application/pdf': help_on_binary,
+    "text/html;charset=utf-8": ext_link("http://ckeditor.com/"),
+    "text/plain;charset=utf-8": help_on_plain_text,
+    "text/x-diff;charset=utf-8": help_on_plain_text,
+    "text/x-python;charset=utf-8": help_on_plain_text,
+    "text/csv;charset=utf-8": help_on_csv,
+    "text/x-irclog;charset=utf-8": help_on_plain_text,
+    "image/svg+xml": help_on_binary,
+    "image/png": help_on_binary,
+    "image/jpeg": help_on_binary,
+    "image/gif": help_on_binary,
+    "audio/wave": help_on_binary,
+    "audio/ogg": help_on_binary,
+    "audio/mpeg": help_on_binary,
+    "audio/webm": help_on_binary,
+    "video/ogg": help_on_binary,
+    "video/webm": help_on_binary,
+    "video/mp4": help_on_binary,
+    "application/x-svgdraw": ext_link("http://code.google.com/p/svg-edit/"),
+    "application/octet-stream": help_on_binary,
+    "application/x-tar": help_on_binary,
+    "application/x-gtar": help_on_binary,
+    "application/zip": help_on_binary,
+    "application/pdf": help_on_binary,
 }
-CONTENTTYPES_HELP_DOCS = defaultdict(lambda: _('No help for unknown content type.'), CONTENTTYPES_HELP_DOCS)
+CONTENTTYPES_HELP_DOCS = defaultdict(lambda: _("No help for unknown content type."), CONTENTTYPES_HELP_DOCS)
diff --git a/src/moin/constants/forms.py b/src/moin/constants/forms.py
index 71b2f942d..ac821405d 100644
--- a/src/moin/constants/forms.py
+++ b/src/moin/constants/forms.py
@@ -7,29 +7,29 @@
 
 # Widget types
 
-WIDGET_TEXT = 'text'  # single-line text
-WIDGET_MULTILINE_TEXT = 'multiline_text'
-WIDGET_URL = 'url'
-WIDGET_EMAIL = 'email'
-WIDGET_PASSWORD = 'password'
-WIDGET_CHECKBOX = 'checkbox'
-WIDGET_INLINE_CHECKBOX = 'inline_checkbox'
-WIDGET_ANY_INTEGER = 'any_integer'
-WIDGET_SMALL_NATURAL = 'small_natural'
-WIDGET_RADIO_CHOICE = 'radio_choice'
-WIDGET_DATETIME = 'datetime'
+WIDGET_TEXT = "text"  # single-line text
+WIDGET_MULTILINE_TEXT = "multiline_text"
+WIDGET_URL = "url"
+WIDGET_EMAIL = "email"
+WIDGET_PASSWORD = "password"
+WIDGET_CHECKBOX = "checkbox"
+WIDGET_INLINE_CHECKBOX = "inline_checkbox"
+WIDGET_ANY_INTEGER = "any_integer"
+WIDGET_SMALL_NATURAL = "small_natural"
+WIDGET_RADIO_CHOICE = "radio_choice"
+WIDGET_DATETIME = "datetime"
 
-WIDGET_FILE = 'file'
-WIDGET_SEARCH = 'search'
-WIDGET_SUBMIT = 'submit'
-WIDGET_HIDDEN = 'hidden'
+WIDGET_FILE = "file"
+WIDGET_SEARCH = "search"
+WIDGET_SUBMIT = "submit"
+WIDGET_HIDDEN = "hidden"
 
-WIDGET_SELECT = 'select'
-WIDGET_SELECT_SUBMIT = 'select_submit'
-WIDGET_MULTI_SELECT = 'multi_select'
+WIDGET_SELECT = "select"
+WIDGET_SELECT_SUBMIT = "select_submit"
+WIDGET_MULTI_SELECT = "multi_select"
 
-WIDGET_READONLY_STRING_LIST = 'readonly_string_list'
-WIDGET_READONLY_ITEM_LINK_LIST = 'readonly_item_link_list'
+WIDGET_READONLY_STRING_LIST = "readonly_string_list"
+WIDGET_READONLY_ITEM_LINK_LIST = "readonly_item_link_list"
 
 # CSS Classes
-CLASS_BUTTON = 'button'
+CLASS_BUTTON = "button"
diff --git a/src/moin/constants/itemtypes.py b/src/moin/constants/itemtypes.py
index 4b51d0d67..8483fc189 100644
--- a/src/moin/constants/itemtypes.py
+++ b/src/moin/constants/itemtypes.py
@@ -5,9 +5,9 @@
 MoinMoin - itemtype related constants
 """
 
-ITEMTYPE_NONEXISTENT = 'nonexistent'
-ITEMTYPE_USERPROFILE = 'userprofile'
-ITEMTYPE_DEFAULT = 'default'  # == wiki-like
-ITEMTYPE_TICKET = 'ticket'
-ITEMTYPE_BLOG = 'blog'
-ITEMTYPE_BLOGENTRY = 'blogentry'
+ITEMTYPE_NONEXISTENT = "nonexistent"
+ITEMTYPE_USERPROFILE = "userprofile"
+ITEMTYPE_DEFAULT = "default"  # == wiki-like
+ITEMTYPE_TICKET = "ticket"
+ITEMTYPE_BLOG = "blog"
+ITEMTYPE_BLOGENTRY = "blogentry"
diff --git a/src/moin/constants/keys.py b/src/moin/constants/keys.py
index 7d4be3dde..dcad2eb97 100644
--- a/src/moin/constants/keys.py
+++ b/src/moin/constants/keys.py
@@ -128,10 +128,25 @@
 
 USEROBJ_ATTRS = [
     # User objects proxy these attributes of the UserProfile objects:
-    NAME, DISABLED, ITEMID, DISPLAY_NAME, ENC_PASSWORD, EMAIL,
-    ISO_8601, MAILTO_AUTHOR, SHOW_COMMENTS, RESULTS_PER_PAGE,
-    EDIT_ON_DOUBLECLICK, SCROLL_PAGE_AFTER_EDIT,
-    EDIT_ROWS, THEME_NAME, LOCALE, TIMEZONE, SUBSCRIPTIONS, QUICKLINKS, CSS_URL,
+    NAME,
+    DISABLED,
+    ITEMID,
+    DISPLAY_NAME,
+    ENC_PASSWORD,
+    EMAIL,
+    ISO_8601,
+    MAILTO_AUTHOR,
+    SHOW_COMMENTS,
+    RESULTS_PER_PAGE,
+    EDIT_ON_DOUBLECLICK,
+    SCROLL_PAGE_AFTER_EDIT,
+    EDIT_ROWS,
+    THEME_NAME,
+    LOCALE,
+    TIMEZONE,
+    SUBSCRIPTIONS,
+    QUICKLINKS,
+    CSS_URL,
 ]
 
 # keys for blog homepages
@@ -153,8 +168,8 @@
 REPLY_TO = "reply_to"
 
 # index names
-LATEST_REVS = 'latest_revs'
-ALL_REVS = 'all_revs'
+LATEST_REVS = "latest_revs"
+ALL_REVS = "all_revs"
 
 # values for ACTION key
 ACTION_SAVE = "SAVE"
@@ -168,15 +183,11 @@
 DEFAULT_LOCALE = "en"
 
 # key for composite name
-FQNAME = 'fqname'
-FQNAMES = 'fqnames'
+FQNAME = "fqname"
+FQNAMES = "fqnames"
 # Values that FIELD can take in the composite name: [NAMESPACE/][@FIELD/]NAME
-FIELDS = [
-    NAME_EXACT, ITEMID, REVID, TAGS, USERID, ITEMLINKS, ITEMTRANSCLUSIONS,
-]
+FIELDS = [NAME_EXACT, ITEMID, REVID, TAGS, USERID, ITEMLINKS, ITEMTRANSCLUSIONS]
 # Fields that can be used as a unique identifier.
-UFIELDS = [
-    NAME_EXACT, ITEMID, REVID,
-]
+UFIELDS = [NAME_EXACT, ITEMID, REVID]
 # Unique fields that are stored as list.
-UFIELDS_TYPELIST = [NAME_EXACT, ]
+UFIELDS_TYPELIST = [NAME_EXACT]
diff --git a/src/moin/constants/misc.py b/src/moin/constants/misc.py
index 5dfe333f5..08627bbac 100644
--- a/src/moin/constants/misc.py
+++ b/src/moin/constants/misc.py
@@ -7,7 +7,7 @@
 
 import re
 
-ANON = 'anonymous'
+ANON = "anonymous"
 
 # Invalid characters - invisible characters that should not be in page
 # names. Prevent user confusion and wiki abuse, e.g '\u202aFrontPage'.
@@ -22,33 +22,50 @@
     \u202D | # LRM
     \u202E   # RLM
     """,
-    re.UNICODE | re.VERBOSE
+    re.UNICODE | re.VERBOSE,
 )
 
 CLEAN_INPUT_TRANSLATION_MAP = {
     # these chars will be replaced by blanks
-    ord('\t'): ' ',
-    ord('\r'): ' ',
-    ord('\n'): ' ',
+    ord("\t"): " ",
+    ord("\r"): " ",
+    ord("\n"): " ",
 }
-for c in ('\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11'
-          '\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'):
+for c in (
+    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11"
+    "\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
+):
     # these chars will be removed
     CLEAN_INPUT_TRANSLATION_MAP[ord(c)] = None
 del c
 
 # Other stuff
 URI_SCHEMES = [
-    'http', 'https', 'ftp', 'file',
-    'mailto', 'nntp', 'news',
-    'ssh', 'telnet', 'irc', 'ircs', 'xmpp', 'mumble',
-    'webcal', 'ed2k', 'apt', 'rootz',
-    'gopher',
-    'notes',
-    'rtp', 'rtsp', 'rtcp',
+    "http",
+    "https",
+    "ftp",
+    "file",
+    "mailto",
+    "nntp",
+    "news",
+    "ssh",
+    "telnet",
+    "irc",
+    "ircs",
+    "xmpp",
+    "mumble",
+    "webcal",
+    "ed2k",
+    "apt",
+    "rootz",
+    "gopher",
+    "notes",
+    "rtp",
+    "rtsp",
+    "rtcp",
 ]
 
 # "ok" constants returned by /utils/edit_locking as in: ok, message = edit_utils.xxx()
 NO_LOCK = 0  # false, someone else holds lock for current item
 LOCKED = 1  # true, current user has obtained or renewed lock
-LOCK = 'lock'
+LOCK = "lock"
diff --git a/src/moin/constants/namespaces.py b/src/moin/constants/namespaces.py
index 45d61cc08..4b194fe18 100644
--- a/src/moin/constants/namespaces.py
+++ b/src/moin/constants/namespaces.py
@@ -5,10 +5,10 @@
 MoinMoin - namespaces related constants
 """
 
-NAMESPACE_DEFAULT = ''
-NAMESPACE_USERPROFILES = 'userprofiles'
-NAMESPACE_USERS = 'users'
-NAMESPACE_HELP_COMMON = 'help-common'
-NAMESPACE_HELP_EN = 'help-en'
-NAMESPACE_ALL = 'all'  # An identifier namespace which acts like a union of all the namespaces.
-NAMESPACES_IDENTIFIER = [NAMESPACE_ALL, ]  # List containing all the identifier namespaces.
+NAMESPACE_DEFAULT = ""
+NAMESPACE_USERPROFILES = "userprofiles"
+NAMESPACE_USERS = "users"
+NAMESPACE_HELP_COMMON = "help-common"
+NAMESPACE_HELP_EN = "help-en"
+NAMESPACE_ALL = "all"  # An identifier namespace which acts like a union of all the namespaces.
+NAMESPACES_IDENTIFIER = [NAMESPACE_ALL]  # List containing all the identifier namespaces.
diff --git a/src/moin/constants/rights.py b/src/moin/constants/rights.py
index 32492ba27..a1f1cffca 100644
--- a/src/moin/constants/rights.py
+++ b/src/moin/constants/rights.py
@@ -10,35 +10,35 @@
 
 # superuser enables access to some critical functionality,
 # it is not related to CONTENT rights.
-SUPERUSER = 'superuser'
+SUPERUSER = "superuser"
 
 # rights that control access to specific functionality
-ACL_RIGHTS_FUNCTIONS = [SUPERUSER, ]
+ACL_RIGHTS_FUNCTIONS = [SUPERUSER]
 
 
 # admin means to be able to change, add, remove ACLs (change meta[ACL])
-ADMIN = 'admin'
+ADMIN = "admin"
 
 # read means to be able to read revision data, unconditionally
 # TODO: define revision meta read behaviour
-READ = 'read'
+READ = "read"
 
 # pubread means to be able to read revision data when published
-PUBREAD = 'pubread'
+PUBREAD = "pubread"
 
 # write means to be able to change meta/data by creating a new revision,
 # so the previous data is still there, unchanged.
-WRITE = 'write'
+WRITE = "write"
 
 # create means to be able to create a new item (no older revisions, new ITEMID)
-CREATE = 'create'
+CREATE = "create"
 
 # destroy means to be able to change or remove one or all existing revisions,
 # this includes overwriting existing revision meta/data with new meta/data.
-DESTROY = 'destroy'
+DESTROY = "destroy"
 
 # rights that control access to operations on contents
-ACL_RIGHTS_CONTENTS = [READ, PUBREAD, WRITE, CREATE, ADMIN, DESTROY, ]
+ACL_RIGHTS_CONTENTS = [READ, PUBREAD, WRITE, CREATE, ADMIN, DESTROY]
 
 # special user groups - order is important
-SPECIAL_USERS = ['All', 'Known', 'Trusted', ]
+SPECIAL_USERS = ["All", "Known", "Trusted"]
diff --git a/src/moin/constants/tools/chartypes_create.py b/src/moin/constants/tools/chartypes_create.py
index 3a6f9fe0d..198f50097 100644
--- a/src/moin/constants/tools/chartypes_create.py
+++ b/src/moin/constants/tools/chartypes_create.py
@@ -24,12 +24,13 @@ def main():
         elif c.isspace():
             space.append(string)
 
-    chars_upper = ''.join(uppercase)
-    chars_lower = ''.join(lowercase + digits)
-    chars_digits = ''.join(digits)
-    chars_spaces = ''.join(space)
+    chars_upper = "".join(uppercase)
+    chars_lower = "".join(lowercase + digits)
+    chars_digits = "".join(digits)
+    chars_spaces = "".join(space)
 
-    print("""
+    print(
+        """
 CHARS_UPPER = "%(chars_upper)s"
 
 CHARS_LOWER = "%(chars_lower)s"
@@ -39,8 +40,10 @@ def main():
 CHARS_SPACES = "%(chars_spaces)s"
 
 
-""" % locals())
+"""
+        % locals()
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/moin/contrib/moin2wsgi.py b/src/moin/contrib/moin2wsgi.py
index 517ef9f47..8cad85795 100644
--- a/src/moin/contrib/moin2wsgi.py
+++ b/src/moin/contrib/moin2wsgi.py
@@ -22,7 +22,7 @@
 if not (moin_dir in sys.path or moin_dir.lower() in sys.path):
     sys.path.insert(0, moin_dir)
 
-wiki_config = moin_dir + '/wikiconfig.py'
+wiki_config = moin_dir + "/wikiconfig.py"
 
 # create the Moin (Flask) WSGI application
 application = create_app(wiki_config)
diff --git a/src/moin/converters/__init__.py b/src/moin/converters/__init__.py
index 762e8a0ae..d9c51beb7 100644
--- a/src/moin/converters/__init__.py
+++ b/src/moin/converters/__init__.py
@@ -30,10 +30,9 @@ class ElementException(RuntimeError):
 
 
 class RegistryConverter(RegistryBase):
-    class Entry(namedtuple('Entry', 'factory type_input type_output priority')):
+    class Entry(namedtuple("Entry", "factory type_input type_output priority")):
         def __call__(self, type_input, type_output, **kw):
-            if (self.type_output.issupertype(type_output) and
-                    self.type_input.issupertype(type_input)):
+            if self.type_output.issupertype(type_output) and self.type_input.issupertype(type_input):
                 return self.factory(type_input, type_output, **kw)
 
         def __lt__(self, other):
diff --git a/src/moin/converters/_args.py b/src/moin/converters/_args.py
index 4640c1052..f2b99f19d 100644
--- a/src/moin/converters/_args.py
+++ b/src/moin/converters/_args.py
@@ -10,7 +10,8 @@ class Arguments:
     """
     Represent an argument list that may contain positional or keyword args.
     """
-    __slots__ = 'positional', 'keyword'
+
+    __slots__ = "positional", "keyword"
 
     def __init__(self, positional=None, keyword=None):
         self.positional = positional and positional[:] or []
@@ -37,7 +38,7 @@ def __len__(self):
         return len(self.positional) + len(self.keyword)
 
     def __repr__(self):
-        return f'<{self.__class__.__name__}({self.positional!r}, {self.keyword!r})>'
+        return f"<{self.__class__.__name__}({self.positional!r}, {self.keyword!r})>"
 
     def items(self):
         """
diff --git a/src/moin/converters/_args_wiki.py b/src/moin/converters/_args_wiki.py
index 84f1ba557..5565096e7 100644
--- a/src/moin/converters/_args_wiki.py
+++ b/src/moin/converters/_args_wiki.py
@@ -11,7 +11,7 @@
 
 # default parsing rules, splits on blank spaces, see parse() docstring for example
 # input: can be like: a b c d=e f="g h" i='j k' l="\"m\" n" o='\'p\' q'
-_parse_rules = r'''
+_parse_rules = r"""
 (?:
     ([-&\w]+)
     =
@@ -27,12 +27,12 @@
     (.*?)
     (?<!\\)'
 )
-'''
+"""
 parse_re = re.compile(_parse_rules, re.X | re.U)
 
 # parsing rules for object keyword parameters, similar to default parsing rules, but
 # input value may have trailing %: width=100%
-_parse_rules = r'''
+_parse_rules = r"""
 (?:
     ([-&\w]+)
     =
@@ -48,14 +48,14 @@
     (.*?)
     (?<!\\)'
 )
-'''
+"""
 object_re = re.compile(_parse_rules, re.X | re.U)
 
 # rules for include macro, splits on commas, allows leading ^ and embedded /
 # <<Include(pagename, heading, level, from="regex", to="regex", sort=ascending|descending,
 #           items=n, skipitems=n, titlesonly, editlink)>>
 # <<Include(^Prefix..-..-..,,to="^----",sort=descending,items=3)>>
-_include_rules = r'''
+_include_rules = r"""
 (?:
     ([-&\w]+)
     =
@@ -71,7 +71,7 @@
     (.*?)
     (?<!\\)'
 )
-'''
+"""
 include_re = re.compile(_include_rules, re.X | re.U)
 
 
@@ -86,8 +86,11 @@ def parse(input, parse_re=parse_re):
     ret = Arguments()
     for match in parse_re.finditer(input):
         key = match.group(1)
-        value = ((match.group(2) or match.group(3) or match.group(4))
-                 .encode('ascii', errors='backslashreplace').decode('unicode-escape'))
+        value = (
+            (match.group(2) or match.group(3) or match.group(4))
+            .encode("ascii", errors="backslashreplace")
+            .decode("unicode-escape")
+        )
         if key:
             ret.keyword[key] = value
         else:
@@ -95,7 +98,7 @@ def parse(input, parse_re=parse_re):
     return ret
 
 
-_unparse_rules = r'''^[-\w]+$'''
+_unparse_rules = r"""^[-\w]+$"""
 _unparse_re = re.compile(_unparse_rules, re.X)
 
 
@@ -108,8 +111,9 @@ def unparse(args):
     :param args: Argument instance
     :returns: argument unicode object
     """
+
     def quote(s):
-        return '"%s"' % s.encode('unicode-escape').decode('ascii')
+        return '"%s"' % s.encode("unicode-escape").decode("ascii")
 
     ret = []
 
@@ -125,6 +129,6 @@ def quote(s):
             raise ValueError("Invalid keyword string")
         if not _unparse_re.match(value):
             value = quote(value)
-        ret.append(key + '=' + value)
+        ret.append(key + "=" + value)
 
-    return ' '.join(ret)
+    return " ".join(ret)
diff --git a/src/moin/converters/_table.py b/src/moin/converters/_table.py
index 910e9dc29..d13278c2a 100644
--- a/src/moin/converters/_table.py
+++ b/src/moin/converters/_table.py
@@ -15,6 +15,7 @@ class TableMixin:
     """
     Mixin to support building a DOM table.
     """
+
     def add_numeric_class(self, cell, table_cell):
         """
         Add numeric class attribute if cell is numeric.
@@ -24,7 +25,7 @@ def add_numeric_class(self, cell, table_cell):
         except (ValueError, TypeError):
             pass
         else:
-            table_cell.attrib[moin_page('class')] = 'moin-integer'
+            table_cell.attrib[moin_page("class")] = "moin-integer"
 
     def build_dom_table(self, rows, head=None, cls=None):
         """
@@ -32,12 +33,12 @@ def build_dom_table(self, rows, head=None, cls=None):
         """
         table = moin_page.table()
         if cls is not None:
-            table.attrib[moin_page('class')] = cls
+            table.attrib[moin_page("class")] = cls
         if head is not None:
             table_head = moin_page.table_header()
             table_row = moin_page.table_row()
             for idx, cell in enumerate(head):
-                table_cell = moin_page.table_cell(children=[cell, ],)
+                table_cell = moin_page.table_cell(children=[cell])
                 if rows and len(rows[0]) == len(head):
                     # add "align: right" to heading cell if cell in first data row is numeric
                     self.add_numeric_class(rows[0][idx], table_cell)
@@ -48,14 +49,19 @@ def build_dom_table(self, rows, head=None, cls=None):
         for row in rows:
             table_row = moin_page.table_row()
             for cell in row:
-                if isinstance(cell, ET.Node) and len(cell) and isinstance(cell[0], str) \
-                   and len(cell[0].split()) == 1 and len(cell[0]) > WORDBREAK_LEN:
+                if (
+                    isinstance(cell, ET.Node)
+                    and len(cell)
+                    and isinstance(cell[0], str)
+                    and len(cell[0].split()) == 1
+                    and len(cell[0]) > WORDBREAK_LEN
+                ):
                     # avoid destroying table layout by applying special styling to cells with long file name hyperlinks
-                    table_cell = moin_page.table_cell(children=[cell, ], attrib={moin_page.class_: 'moin-wordbreak'})
+                    table_cell = moin_page.table_cell(children=[cell], attrib={moin_page.class_: "moin-wordbreak"})
                 elif isinstance(cell, ET.Node):
-                    table_cell = moin_page.table_cell(children=[cell, ])
+                    table_cell = moin_page.table_cell(children=[cell])
                 else:
-                    table_cell = moin_page.table_cell(children=[cell, ],)
+                    table_cell = moin_page.table_cell(children=[cell])
                     self.add_numeric_class(cell, table_cell)
                 table_row.append(table_cell)
             table_body.append(table_row)
diff --git a/src/moin/converters/_tests/__init__.py b/src/moin/converters/_tests/__init__.py
index 2c1c33496..250608449 100644
--- a/src/moin/converters/_tests/__init__.py
+++ b/src/moin/converters/_tests/__init__.py
@@ -13,4 +13,4 @@ def serialize(elem, **options):
 XMLNS_RE2 = re.compile(r'(\s+xmlns(:\w+)?="[^"]+?"|xmlns\(\w+=[^)]+?\)\s+)')
 XMLNS_RE3 = re.compile(r'\s+xmlns="[^"]+?"')
 
-TAGSTART_RE = re.compile(r'^(<[a-z:]+)')
+TAGSTART_RE = re.compile(r"^(<[a-z:]+)")
diff --git a/src/moin/converters/_tests/test__args.py b/src/moin/converters/_tests/test__args.py
index f338fa271..b060416cb 100644
--- a/src/moin/converters/_tests/test__args.py
+++ b/src/moin/converters/_tests/test__args.py
@@ -24,36 +24,36 @@ def test_Arguments___init__():
 
 
 def test_Arguments___contains__():
-    positional = ['positional', 'both']
-    keyword = {'keyword': None, 'both': None}
+    positional = ["positional", "both"]
+    keyword = {"keyword": None, "both": None}
 
     a = Arguments(positional, keyword)
 
-    assert 'positional' in a
-    assert 'keyword' in a
-    assert 'both' in a
-    assert 'none' not in a
+    assert "positional" in a
+    assert "keyword" in a
+    assert "both" in a
+    assert "none" not in a
 
 
 def test_Arguments___getitem__():
-    positional = ['positional', 'both']
-    keyword = {'keyword': None, 'both': None}
+    positional = ["positional", "both"]
+    keyword = {"keyword": None, "both": None}
 
     a = Arguments(positional, keyword)
 
-    assert a[0] == 'positional'
-    assert a[1] == 'both'
+    assert a[0] == "positional"
+    assert a[1] == "both"
     assert a[:] == positional
-    assert a['keyword'] is None
-    assert a['both'] is None
+    assert a["keyword"] is None
+    assert a["both"] is None
 
     pytest.raises(IndexError, a.__getitem__, 2)
-    pytest.raises(KeyError, a.__getitem__, 'none')
+    pytest.raises(KeyError, a.__getitem__, "none")
 
 
 def test_Arguments___len__():
-    positional = ['positional', 'both']
-    keyword = {'keyword': None, 'both': None}
+    positional = ["positional", "both"]
+    keyword = {"keyword": None, "both": None}
 
     a = Arguments(positional, keyword)
 
@@ -61,43 +61,43 @@ def test_Arguments___len__():
 
 
 def test_Arguments_items():
-    positional = ['positional', 'both']
-    keyword = {'keyword': True, 'both': False}
+    positional = ["positional", "both"]
+    keyword = {"keyword": True, "both": False}
 
     a = Arguments(positional, keyword)
 
     args = list(a.items())
 
     assert len(args) == 4
-    assert args[0] == (None, 'positional')
-    assert args[1] == (None, 'both')
-    assert ('keyword', True) in args
-    assert ('both', False) in args
+    assert args[0] == (None, "positional")
+    assert args[1] == (None, "both")
+    assert ("keyword", True) in args
+    assert ("both", False) in args
 
 
 def test_Arguments_keys():
-    positional = ['positional', 'both']
-    keyword = {'keyword': True, 'both': False}
+    positional = ["positional", "both"]
+    keyword = {"keyword": True, "both": False}
 
     a = Arguments(positional, keyword)
 
     args = list(a.keys())
 
     assert len(args) == 2
-    assert 'keyword' in args
-    assert 'both' in args
+    assert "keyword" in args
+    assert "both" in args
 
 
 def test_Arguments_values():
-    positional = ['positional', 'both']
-    keyword = {'keyword': True, 'both': False}
+    positional = ["positional", "both"]
+    keyword = {"keyword": True, "both": False}
 
     a = Arguments(positional, keyword)
 
     args = list(a.values())
 
     assert len(args) == 4
-    assert args[0] == 'positional'
-    assert args[1] == 'both'
+    assert args[0] == "positional"
+    assert args[1] == "both"
     assert True in args
     assert False in args
diff --git a/src/moin/converters/_tests/test__args_wiki.py b/src/moin/converters/_tests/test__args_wiki.py
index e51a8cd17..68bbb825c 100644
--- a/src/moin/converters/_tests/test__args_wiki.py
+++ b/src/moin/converters/_tests/test__args_wiki.py
@@ -10,19 +10,14 @@
 from moin.converters._args_wiki import Arguments, parse, unparse, include_re, object_re
 
 
-@pytest.mark.parametrize('wiki,positional,keyword', [
-    (r'both positional both=foo keyword=bar',
-     ['both', 'positional'],
-     {'both': 'foo', 'keyword': 'bar'}),
-
-    (r'a-b a_b a-c=foo a_c=bar',
-     ['a-b', 'a_b'],
-     {'a-c': 'foo', 'a_c': 'bar'}),
-
-    (r'''"a b\tc\nd" k="a b\tc\nd"''',
-     ['a b\tc\nd'],
-     {'k': 'a b\tc\nd'}),
-])
+@pytest.mark.parametrize(
+    "wiki,positional,keyword",
+    [
+        (r"both positional both=foo keyword=bar", ["both", "positional"], {"both": "foo", "keyword": "bar"}),
+        (r"a-b a_b a-c=foo a_c=bar", ["a-b", "a_b"], {"a-c": "foo", "a_c": "bar"}),
+        (r'''"a b\tc\nd" k="a b\tc\nd"''', ["a b\tc\nd"], {"k": "a b\tc\nd"}),
+    ],
+)
 def test(wiki, positional, keyword):
     a = parse(wiki)
     assert a.positional == positional
@@ -34,17 +29,17 @@ def test(wiki, positional, keyword):
 
 def test_parse():
     a = parse(r''''a b\tc\nd',k="a b\tc\nd"''')
-    assert a.positional == ['a b\tc\nd']
-    assert a.keyword == {'k': 'a b\tc\nd'}
+    assert a.positional == ["a b\tc\nd"]
+    assert a.keyword == {"k": "a b\tc\nd"}
 
 
 def test_include_re():
     a = parse(r''''^User/Prefix,,to="^----",sort=descending,items=3"''', parse_re=include_re)
-    assert a.positional == ['^User/Prefix']
-    assert a.keyword == {'to': '^----', 'sort': 'descending', 'items': '3'}
+    assert a.positional == ["^User/Prefix"]
+    assert a.keyword == {"to": "^----", "sort": "descending", "items": "3"}
 
 
 def test_object_re():
     a = parse(r''''width=100% height="100%"''', parse_re=object_re)
     assert a.positional == []
-    assert a.keyword == {'width': '100%', 'height': '100%'}
+    assert a.keyword == {"width": "100%", "height": "100%"}
diff --git a/src/moin/converters/_tests/test__wiki_macro.py b/src/moin/converters/_tests/test__wiki_macro.py
index 83682a560..41095eda2 100644
--- a/src/moin/converters/_tests/test__wiki_macro.py
+++ b/src/moin/converters/_tests/test__wiki_macro.py
@@ -15,11 +15,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page.namespace: '',
-        xinclude.namespace: 'xi',
-        xlink.namespace: 'xlink',
-    }
+    namespaces = {moin_page.namespace: "", xinclude.namespace: "xi", xlink.namespace: "xlink"}
 
     output_re = XMLNS_RE2
 
@@ -27,85 +23,131 @@ def setup_class(self):
         self.conv = ConverterMacro()
 
     data = [
-        ('Macro', None, 'text',
-         '<part alt="text" content-type="x-moin/macro;name=Macro" />',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro" />'),
-        ('Macro', 'arg1', 'text',
-         '<part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1</arguments></part>',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1</arguments></inline-part>'),
+        (
+            "Macro",
+            None,
+            "text",
+            '<part alt="text" content-type="x-moin/macro;name=Macro" />',
+            '<inline-part alt="text" content-type="x-moin/macro;name=Macro" />',
+        ),
+        (
+            "Macro",
+            "arg1",
+            "text",
+            '<part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1</arguments></part>',
+            '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1</arguments></inline-part>',
+        ),
     ]
 
-    @pytest.mark.parametrize('name,args,text,output_block,output_inline', data)
+    @pytest.mark.parametrize("name,args,text,output_block,output_inline", data)
     def test_macro(self, name, args, text, output_block, output_inline):
         self._do(name, args, text, True, output_block)
         self._do(name, args, text, False, output_inline)
 
     data = [
-        ('Macro', None, 'text',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro" />'),
-        ('Macro', 'arg1,arg2', 'text',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1,arg2</arguments></inline-part>'),
-        ('Macro', 'key=value', 'text',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>key=value</arguments></inline-part>'),
-        ('Macro', 'arg1,arg2,key=value', 'text',
-         '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1,arg2,key=value</arguments></inline-part>'),
+        ("Macro", None, "text", '<inline-part alt="text" content-type="x-moin/macro;name=Macro" />'),
+        (
+            "Macro",
+            "arg1,arg2",
+            "text",
+            '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1,arg2</arguments></inline-part>',
+        ),
+        (
+            "Macro",
+            "key=value",
+            "text",
+            '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>key=value</arguments></inline-part>',
+        ),
+        (
+            "Macro",
+            "arg1,arg2,key=value",
+            "text",
+            '<inline-part alt="text" content-type="x-moin/macro;name=Macro"><arguments>arg1,arg2,key=value</arguments></inline-part>',
+        ),
     ]
 
-    @pytest.mark.parametrize('name,args,text,output', data)
+    @pytest.mark.parametrize("name,args,text,output", data)
     def test_macro_arguments(self, name, args, text, output):
         self._do(name, args, text, False, output)
 
     data = [
-        ('BR', None, 'text',
-         None,
-         '<line-break />'),
-        ('FootNote', 'note', 'text',
-         '<p><note note-class="footnote"><note-body>note</note-body></note></p>',
-         '<note note-class="footnote"><note-body>note</note-body></note>'),
-        ('TableOfContents', None, 'text',
-         '<table-of-content />',
-         'text'),
-        ('Include', 'page', 'text',
-         '<div class="moin-p"><xi:include xi:href="wiki.local:page" /></div>',
-         '<xi:include xi:href="wiki.local:page" />'),
-        ('Include', '^page', 'text',
-         '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page))" /></div>',
-         '<xi:include xi:xpointer="page:include(pages(^^page))" />'),
+        ("BR", None, "text", None, "<line-break />"),
+        (
+            "FootNote",
+            "note",
+            "text",
+            '<p><note note-class="footnote"><note-body>note</note-body></note></p>',
+            '<note note-class="footnote"><note-body>note</note-body></note>',
+        ),
+        ("TableOfContents", None, "text", "<table-of-content />", "text"),
+        (
+            "Include",
+            "page",
+            "text",
+            '<div class="moin-p"><xi:include xi:href="wiki.local:page" /></div>',
+            '<xi:include xi:href="wiki.local:page" />',
+        ),
+        (
+            "Include",
+            "^page",
+            "text",
+            '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page))" /></div>',
+            '<xi:include xi:xpointer="page:include(pages(^^page))" />',
+        ),
         # each Include macro performs its own parsing as needed
-        ('Include', '^page, sort=ascending', 'text',
-         '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) sort(ascending))" /></div>',
-         '<xi:include xi:xpointer="page:include(pages(^^page) sort(ascending))" />'),
-        ('Include', '^page, sort=descending', 'text',
-         '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) sort(descending))" /></div>',
-         '<xi:include xi:xpointer="page:include(pages(^^page) sort(descending))" />'),
-        ('Include', '^page, items=5', 'text',
-         '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) items(5))" /></div>',
-         '<xi:include xi:xpointer="page:include(pages(^^page) items(5))" />'),
-        ('Include', '^page, skipitems=5', 'text',
-         '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) skipitems(5))" /></div>',
-         '<xi:include xi:xpointer="page:include(pages(^^page) skipitems(5))" />'),
+        (
+            "Include",
+            "^page, sort=ascending",
+            "text",
+            '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) sort(ascending))" /></div>',
+            '<xi:include xi:xpointer="page:include(pages(^^page) sort(ascending))" />',
+        ),
+        (
+            "Include",
+            "^page, sort=descending",
+            "text",
+            '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) sort(descending))" /></div>',
+            '<xi:include xi:xpointer="page:include(pages(^^page) sort(descending))" />',
+        ),
+        (
+            "Include",
+            "^page, items=5",
+            "text",
+            '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) items(5))" /></div>',
+            '<xi:include xi:xpointer="page:include(pages(^^page) items(5))" />',
+        ),
+        (
+            "Include",
+            "^page, skipitems=5",
+            "text",
+            '<div class="moin-p"><xi:include xi:xpointer="page:include(pages(^^page) skipitems(5))" /></div>',
+            '<xi:include xi:xpointer="page:include(pages(^^page) skipitems(5))" />',
+        ),
     ]
 
-    @pytest.mark.parametrize('name,args,text,output_block,output_inline', data)
+    @pytest.mark.parametrize("name,args,text,output_block,output_inline", data)
     def test_pseudomacro(self, name, args, text, output_block, output_inline):
         self._do(name, args, text, True, output_block)
         self._do(name, args, text, False, output_inline)
 
     data = [
-        ('test', None, ('text',),
-         '<part content-type="x-moin/format;name=test"><body>text</body></part>'),
+        ("test", None, ("text",), '<part content-type="x-moin/format;name=test"><body>text</body></part>'),
         # this form works, but is no longer used
-        ('test', Arguments(['arg1']), ('text',),
-         '<part content-type="x-moin/format;name=test"><arguments><argument>arg1</argument></arguments><body>text</body></part>'),
+        (
+            "test",
+            Arguments(["arg1"]),
+            ("text",),
+            '<part content-type="x-moin/format;name=test"><arguments><argument>arg1</argument></arguments><body>text</body></part>',
+        ),
     ]
 
-    @pytest.mark.parametrize('name,args,text,output', data)
+    @pytest.mark.parametrize("name,args,text,output", data)
     def test_parser(self, name, args, text, output):
         self._do_parser(name, args, text, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def _do(self, name, args, text, context_block, output):
         result = self.conv.macro(name, args, text, context_block)
diff --git a/src/moin/converters/_tests/test_creole_in.py b/src/moin/converters/_tests/test_creole_in.py
index bd52e5ef4..15d5d0d75 100644
--- a/src/moin/converters/_tests/test_creole_in.py
+++ b/src/moin/converters/_tests/test_creole_in.py
@@ -16,12 +16,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page: '',
-        xlink: 'xlink',
-        html: 'xhtml',
-        xinclude: 'xinclude',
-    }
+    namespaces = {moin_page: "", xlink: "xlink", html: "xhtml", xinclude: "xinclude"}
 
     output_re = XMLNS_RE
 
@@ -29,262 +24,313 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('Text',
-         '<page><body><p>Text</p></body></page>'),
-        ('Text\nTest',
-         '<page><body><p>Text\nTest</p></body></page>'),
-        ('Text\n\nTest',
-         '<page><body><p>Text</p><p>Test</p></body></page>'),
-        ('Line\\\\Break',
-         '<page><body><p>Line<line-break />Break</p></body></page>'),
-        ('Line\\\\\nBreak',
-         '<page><body><p>Line<line-break />\nBreak</p></body></page>'),
-        ('http://moinmo.in/',
-         '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>'),
-        ('[[http://moinmo.in/]]',
-         '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>'),
-        ('[[MoinMoin:InterWiki]]',
-         '<page><body><p><a xlink:href="wiki://MoinMoin/InterWiki">InterWiki</a></p></body></page>'),
-        ('[[mailto:fred@flinstones.org|drop me a note]]',
-         '<page><body><p><a xlink:href="mailto:fred@flinstones.org">drop me a note</a></p></body></page>'),
-        ('[[xmpp:room@conference.example.com?join|the chatroom]]',
-         '<page><body><p><a xlink:href="xmpp:room@conference.example.com?join">the chatroom</a></p></body></page>'),
+        ("Text", "<page><body><p>Text</p></body></page>"),
+        ("Text\nTest", "<page><body><p>Text\nTest</p></body></page>"),
+        ("Text\n\nTest", "<page><body><p>Text</p><p>Test</p></body></page>"),
+        ("Line\\\\Break", "<page><body><p>Line<line-break />Break</p></body></page>"),
+        ("Line\\\\\nBreak", "<page><body><p>Line<line-break />\nBreak</p></body></page>"),
+        (
+            "http://moinmo.in/",
+            '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>',
+        ),
+        (
+            "[[http://moinmo.in/]]",
+            '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>',
+        ),
+        (
+            "[[MoinMoin:InterWiki]]",
+            '<page><body><p><a xlink:href="wiki://MoinMoin/InterWiki">InterWiki</a></p></body></page>',
+        ),
+        (
+            "[[mailto:fred@flinstones.org|drop me a note]]",
+            '<page><body><p><a xlink:href="mailto:fred@flinstones.org">drop me a note</a></p></body></page>',
+        ),
+        (
+            "[[xmpp:room@conference.example.com?join|the chatroom]]",
+            '<page><body><p><a xlink:href="xmpp:room@conference.example.com?join">the chatroom</a></p></body></page>',
+        ),
         # garbage input defaults to wiki.local name
-        ('[[invalid:fred@flinstones.org|drop me a note]]',
-         '<page><body><p><a xlink:href="wiki.local:invalid:fred@flinstones.org">drop me a note</a></p></body></page>'),
-        ('[[javascript:alert("xss")]]',
-         '<page><body><p><a xlink:href="wiki.local:javascript:alert%28%22xss%22%29">javascript:alert("xss")</a></p></body></page>'),
-        ('[[http://moinmo.in/|MoinMoin]]',
-         '<page><body><p><a xlink:href="http://moinmo.in/">MoinMoin</a></p></body></page>'),
-        ('[[MoinMoin]]',
-         '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
-        ('{{http://moinmo.in/}}',
-         '<page><body><p><object xlink:href="http://moinmo.in/">Your Browser does not support HTML5 audio/video element.</object></p></body></page>'),
-        ('{{http://moinmo.in/|MoinMoin}}',
-         '<page><body><p><object xhtml:alt="MoinMoin" xlink:href="http://moinmo.in/">Your Browser does not support HTML5 audio/video element.</object></p></body></page>'),
-        ('{{my.png}}',
-         '<page><body><p><xinclude:include xinclude:href="wiki.local:my.png" /></p></body></page>'),
-        ('----',
-         '<page><body><separator class="moin-hr3" /></body></page>'),
+        (
+            "[[invalid:fred@flinstones.org|drop me a note]]",
+            '<page><body><p><a xlink:href="wiki.local:invalid:fred@flinstones.org">drop me a note</a></p></body></page>',
+        ),
+        (
+            '[[javascript:alert("xss")]]',
+            '<page><body><p><a xlink:href="wiki.local:javascript:alert%28%22xss%22%29">javascript:alert("xss")</a></p></body></page>',
+        ),
+        (
+            "[[http://moinmo.in/|MoinMoin]]",
+            '<page><body><p><a xlink:href="http://moinmo.in/">MoinMoin</a></p></body></page>',
+        ),
+        ("[[MoinMoin]]", '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
+        (
+            "{{http://moinmo.in/}}",
+            '<page><body><p><object xlink:href="http://moinmo.in/">Your Browser does not support HTML5 audio/video element.</object></p></body></page>',
+        ),
+        (
+            "{{http://moinmo.in/|MoinMoin}}",
+            '<page><body><p><object xhtml:alt="MoinMoin" xlink:href="http://moinmo.in/">Your Browser does not support HTML5 audio/video element.</object></p></body></page>',
+        ),
+        ("{{my.png}}", '<page><body><p><xinclude:include xinclude:href="wiki.local:my.png" /></p></body></page>'),
+        ("----", '<page><body><separator class="moin-hr3" /></body></page>'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Text',
-         '<page><body style="background-color: red"><p>Text</p></body></page>',
-         {'arguments': Arguments(keyword={'style': 'background-color: red'})}),
+        (
+            "Text",
+            '<page><body style="background-color: red"><p>Text</p></body></page>',
+            {"arguments": Arguments(keyword={"style": "background-color: red"})},
+        )
     ]
 
-    @pytest.mark.parametrize('args', data)
+    @pytest.mark.parametrize("args", data)
     def test_args(self, args):
         self.do(*args)
 
     data = [
-        ('//Emphasis//',
-         '<page><body><p><emphasis>Emphasis</emphasis></p></body></page>'),
-        ('**Strong**',
-         '<page><body><p><strong>Strong</strong></p></body></page>'),
-        ('//**Both**//',
-         '<page><body><p><emphasis><strong>Both</strong></emphasis></p></body></page>'),
-        ('**//Both//**',
-         '<page><body><p><strong><emphasis>Both</emphasis></strong></p></body></page>'),
-        ('Text //Emphasis\n//Text',
-         '<page><body><p>Text <emphasis>Emphasis\n</emphasis>Text</p></body></page>'),
-        ('Text //Emphasis\n\nText',
-         '<page><body><p>Text <emphasis>Emphasis</emphasis></p><p>Text</p></body></page>'),
+        ("//Emphasis//", "<page><body><p><emphasis>Emphasis</emphasis></p></body></page>"),
+        ("**Strong**", "<page><body><p><strong>Strong</strong></p></body></page>"),
+        ("//**Both**//", "<page><body><p><emphasis><strong>Both</strong></emphasis></p></body></page>"),
+        ("**//Both//**", "<page><body><p><strong><emphasis>Both</emphasis></strong></p></body></page>"),
+        ("Text //Emphasis\n//Text", "<page><body><p>Text <emphasis>Emphasis\n</emphasis>Text</p></body></page>"),
+        ("Text //Emphasis\n\nText", "<page><body><p>Text <emphasis>Emphasis</emphasis></p><p>Text</p></body></page>"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_emphasis(self, input, output):
         self.do(input, output)
 
     data = [
-        ('~http://moinmo.in/',
-         '<page><body><p>http://moinmo.in/</p></body></page>'),
-        ('~[[escape]]',
-         '<page><body><p>[[escape]]</p></body></page>'),
-        ('~<<escape>>',
-         '<page><body><p>&lt;&lt;escape&gt;&gt;</p></body></page>'),
-        ('~{~{{escape}}}',
-         '<page><body><p>{{{escape}}}</p></body></page>'),
+        ("~http://moinmo.in/", "<page><body><p>http://moinmo.in/</p></body></page>"),
+        ("~[[escape]]", "<page><body><p>[[escape]]</p></body></page>"),
+        ("~<<escape>>", "<page><body><p>&lt;&lt;escape&gt;&gt;</p></body></page>"),
+        ("~{~{{escape}}}", "<page><body><p>{{{escape}}}</p></body></page>"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_escape(self, input, output):
         self.do(input, output)
 
     data = [
-        ('= Heading 1',
-         '<page><body><h outline-level="1">Heading 1</h></body></page>'),
-        ('== Heading 2',
-         '<page><body><h outline-level="2">Heading 2</h></body></page>'),
-        ('=== Heading 3',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
-        ('==== Heading 4',
-         '<page><body><h outline-level="4">Heading 4</h></body></page>'),
-        ('===== Heading 5',
-         '<page><body><h outline-level="5">Heading 5</h></body></page>'),
-        ('====== Heading 6',
-         '<page><body><h outline-level="6">Heading 6</h></body></page>'),
-        ('= Heading 1 =',
-         '<page><body><h outline-level="1">Heading 1</h></body></page>'),
-        ('== Heading 2 ==',
-         '<page><body><h outline-level="2">Heading 2</h></body></page>'),
-        ('=== Heading 3 ===',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
-        ('==== Heading 4 ====',
-         '<page><body><h outline-level="4">Heading 4</h></body></page>'),
-        ('===== Heading 5 =====',
-         '<page><body><h outline-level="5">Heading 5</h></body></page>'),
-        ('====== Heading 6 ======',
-         '<page><body><h outline-level="6">Heading 6</h></body></page>'),
-        ('=== Heading 3',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
-        ('=== Heading 3 =',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
-        ('=== Heading 3 ==',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("= Heading 1", '<page><body><h outline-level="1">Heading 1</h></body></page>'),
+        ("== Heading 2", '<page><body><h outline-level="2">Heading 2</h></body></page>'),
+        ("=== Heading 3", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("==== Heading 4", '<page><body><h outline-level="4">Heading 4</h></body></page>'),
+        ("===== Heading 5", '<page><body><h outline-level="5">Heading 5</h></body></page>'),
+        ("====== Heading 6", '<page><body><h outline-level="6">Heading 6</h></body></page>'),
+        ("= Heading 1 =", '<page><body><h outline-level="1">Heading 1</h></body></page>'),
+        ("== Heading 2 ==", '<page><body><h outline-level="2">Heading 2</h></body></page>'),
+        ("=== Heading 3 ===", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("==== Heading 4 ====", '<page><body><h outline-level="4">Heading 4</h></body></page>'),
+        ("===== Heading 5 =====", '<page><body><h outline-level="5">Heading 5</h></body></page>'),
+        ("====== Heading 6 ======", '<page><body><h outline-level="6">Heading 6</h></body></page>'),
+        ("=== Heading 3", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("=== Heading 3 =", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("=== Heading 3 ==", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_heading(self, input, output):
         self.do(input, output)
 
     data = [
-        ('* Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        (' *Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        ('*Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        ('* Item\nItem',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list></body></page>'),
-        ('* Item 1\n*Item 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>'),
-        ('* Item 1\n** Item 1.2\n* Item 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>'),
-        ('* List 1\n\n* List 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>'),
-        ('# Item',
-         '<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        ('* List 1\n# List 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="ordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>'),
+        (
+            "* Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " *Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "*Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* Item\nItem",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* Item 1\n*Item 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* Item 1\n** Item 1.2\n* Item 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* List 1\n\n* List 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "# Item",
+            '<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* List 1\n# List 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="ordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<<BR>>',
-         '<page><body /></page>'),
-        ('Text<<BR>>Text',
-         '<page><body><p>Text<line-break />Text</p></body></page>'),
-        ('<<Macro>>',
-         '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('<<Macro>><<Macro>>',
-         '<page><body><p><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('<<Macro(arg)>>',
-         '<page><body><part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></part></body></page>'),
-        (' <<Macro>> ',
-         '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('Text <<Macro>>',
-         '<page><body><p>Text <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('Text <<Macro(arg)>>',
-         '<page><body><p>Text <inline-part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></p></body></page>'),
-        ('Text\n<<Macro>>',
-         '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('Text\nText <<Macro>>',
-         '<page><body><p>Text\nText <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('Text\n\n<<Macro>>',
-         '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
+        ("<<BR>>", "<page><body /></page>"),
+        ("Text<<BR>>Text", "<page><body><p>Text<line-break />Text</p></body></page>"),
+        (
+            "<<Macro>>",
+            '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
+        (
+            "<<Macro>><<Macro>>",
+            '<page><body><p><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "<<Macro(arg)>>",
+            '<page><body><part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></part></body></page>',
+        ),
+        (
+            " <<Macro>> ",
+            '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
+        (
+            "Text <<Macro>>",
+            '<page><body><p>Text <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "Text <<Macro(arg)>>",
+            '<page><body><p>Text <inline-part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></p></body></page>',
+        ),
+        (
+            "Text\n<<Macro>>",
+            '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
+        (
+            "Text\nText <<Macro>>",
+            '<page><body><p>Text\nText <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "Text\n\n<<Macro>>",
+            '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macro(self, input, output):
         self.do(input, output)
 
     data = [
-        ('|Cell',
-         '<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('|    Cell     ',
-         '<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('|Cell|',
-         '<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('|=Heading|',
-         '<page><body><table><table-body><table-row><table-cell class="moin-thead">Heading</table-cell></table-row></table-body></table></body></page>'),
-        ('|Cell 1|Cell 2',
-         '<page><body><table><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>'),
-        ('|Cell 1|Cell 2|',
-         '<page><body><table><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>'),
-        ('|Row 1\n|Row 2\n',
-         '<page><body><table><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>'),
-        ('|Row 1|\n|Row 2|\n',
-         '<page><body><table><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>'),
-        ('|Cell 1.1|Cell 1.2|\n|Cell 2.1|Cell 2.2|\n',
-         '<page><body><table><table-body><table-row><table-cell>Cell 1.1</table-cell><table-cell>Cell 1.2</table-cell></table-row><table-row><table-cell>Cell 2.1</table-cell><table-cell>Cell 2.2</table-cell></table-row></table-body></table></body></page>'),
+        (
+            "|Cell",
+            "<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|    Cell     ",
+            "<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|Cell|",
+            "<page><body><table><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|=Heading|",
+            '<page><body><table><table-body><table-row><table-cell class="moin-thead">Heading</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "|Cell 1|Cell 2",
+            "<page><body><table><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|Cell 1|Cell 2|",
+            "<page><body><table><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|Row 1\n|Row 2\n",
+            "<page><body><table><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|Row 1|\n|Row 2|\n",
+            "<page><body><table><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            "|Cell 1.1|Cell 1.2|\n|Cell 2.1|Cell 2.2|\n",
+            "<page><body><table><table-body><table-row><table-cell>Cell 1.1</table-cell><table-cell>Cell 1.2</table-cell></table-row><table-row><table-cell>Cell 2.1</table-cell><table-cell>Cell 2.2</table-cell></table-row></table-body></table></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('{{{nowiki}}}',
-         '<page><body><p><code>nowiki</code></p></body></page>'),
-        ('{{{{nowiki}}}}',
-         '<page><body><p><code>{nowiki}</code></p></body></page>'),
-        ('text: {{{nowiki}}}, text',
-         '<page><body><p>text: <code>nowiki</code>, text</p></body></page>'),
-        ('{{{\nnowiki\n}}}',
-         '<page><body><blockcode>nowiki</blockcode></body></page>'),
-        ('{{{\nnowiki\nno\nwiki\n}}}',
-         '<page><body><blockcode>nowiki\nno\nwiki</blockcode></body></page>'),
-        ('{{{nowiki}}} {{{nowiki}}}',
-         '<page><body><p><code>nowiki</code> <code>nowiki</code></p></body></page>'),
+        ("{{{nowiki}}}", "<page><body><p><code>nowiki</code></p></body></page>"),
+        ("{{{{nowiki}}}}", "<page><body><p><code>{nowiki}</code></p></body></page>"),
+        ("text: {{{nowiki}}}, text", "<page><body><p>text: <code>nowiki</code>, text</p></body></page>"),
+        ("{{{\nnowiki\n}}}", "<page><body><blockcode>nowiki</blockcode></body></page>"),
+        ("{{{\nnowiki\nno\nwiki\n}}}", "<page><body><blockcode>nowiki\nno\nwiki</blockcode></body></page>"),
+        ("{{{nowiki}}} {{{nowiki}}}", "<page><body><p><code>nowiki</code> <code>nowiki</code></p></body></page>"),
         # XXX: Is <page> correct?
-        ('{{{\n#!\nwiki\n}}}',
-         '<page><body><page><body><p>wiki</p></body></page></body></page>'),
-        ('{{{\n#!(style="background-color: red")\nwiki\n}}}',
-         '<page><body><page><body style="background-color: red"><p>wiki</p></body></page></body></page>'),
-        ('{{{\n#!creole\nwiki\n}}}',
-         '<page><body><page><body><p>wiki</p></body></page></body></page>'),
-        ('{{{\n#!creole(style="background-color: red")\nwiki\n}}}',
-         '<page><body><page><body style="background-color: red"><p>wiki</p></body></page></body></page>'),
-        ('{{{\n#!text/plain\ntext\n}}}',
-         '<page><body><part content-type="text/plain"><body>text</body></part></body></page>'),
+        ("{{{\n#!\nwiki\n}}}", "<page><body><page><body><p>wiki</p></body></page></body></page>"),
+        (
+            '{{{\n#!(style="background-color: red")\nwiki\n}}}',
+            '<page><body><page><body style="background-color: red"><p>wiki</p></body></page></body></page>',
+        ),
+        ("{{{\n#!creole\nwiki\n}}}", "<page><body><page><body><p>wiki</p></body></page></body></page>"),
+        (
+            '{{{\n#!creole(style="background-color: red")\nwiki\n}}}',
+            '<page><body><page><body style="background-color: red"><p>wiki</p></body></page></body></page>',
+        ),
+        (
+            "{{{\n#!text/plain\ntext\n}}}",
+            '<page><body><part content-type="text/plain"><body>text</body></part></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_nowiki(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Text\n* Item\n\nText',
-         '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>'),
-        ('Text\n* Item\n= Heading',
-         '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><h outline-level="1">Heading</h></body></page>'),
-        ('Text\n* Item\n{{{\nnowiki\n}}}',
-         '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><blockcode>nowiki</blockcode></body></page>'),
-        ('Text\n* Item\n|Item',
-         '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><table><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table></body></page>'),
-        ('Text\n|Item\nText',
-         '<page><body><p>Text</p><table><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table><p>Text</p></body></page>'),
-        ('| text [[http://localhost | link]] |',
-         '<page><body><table><table-body><table-row><table-cell>text <a xlink:href="http://localhost">link</a></table-cell></table-row></table-body></table></body></page>'),
+        (
+            "Text\n* Item\n\nText",
+            '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>',
+        ),
+        (
+            "Text\n* Item\n= Heading",
+            '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><h outline-level="1">Heading</h></body></page>',
+        ),
+        (
+            "Text\n* Item\n{{{\nnowiki\n}}}",
+            '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><blockcode>nowiki</blockcode></body></page>',
+        ),
+        (
+            "Text\n* Item\n|Item",
+            '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><table><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "Text\n|Item\nText",
+            "<page><body><p>Text</p><table><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table><p>Text</p></body></page>",
+        ),
+        (
+            "| text [[http://localhost | link]] |",
+            '<page><body><table><table-body><table-row><table-cell>text <a xlink:href="http://localhost">link</a></table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_composite(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}):
-        out = self.conv(input, 'text/x.moin.creole;charset=utf-8', **args)
+        out = self.conv(input, "text/x.moin.creole;charset=utf-8", **args)
         assert self.serialize_strip(out) == output
diff --git a/src/moin/converters/_tests/test_csv_in.py b/src/moin/converters/_tests/test_csv_in.py
index b37792705..b665f1ee1 100644
--- a/src/moin/converters/_tests/test_csv_in.py
+++ b/src/moin/converters/_tests/test_csv_in.py
@@ -15,12 +15,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page: '',
-        xlink: 'xlink',
-        html: 'xhtml',
-        xinclude: 'xinclude',
-    }
+    namespaces = {moin_page: "", xlink: "xlink", html: "xhtml", xinclude: "xinclude"}
 
     output_re = XMLNS_RE
 
@@ -29,21 +24,25 @@ def setup_class(self):
 
     data = [
         # first row not recognized as a header by Python csv module
-        ('Head A,Head B\na,bb\nccc,dddd',
-         '<page><body><table><table-body><table-row><table-cell>Head A</table-cell><table-cell>Head B</table-cell></table-row><table-row><table-cell>a</table-cell><table-cell>bb</table-cell></table-row><table-row><table-cell>ccc</table-cell><table-cell>dddd</table-cell></table-row></table-body></table></body></page>'),
+        (
+            "Head A,Head B\na,bb\nccc,dddd",
+            "<page><body><table><table-body><table-row><table-cell>Head A</table-cell><table-cell>Head B</table-cell></table-row><table-row><table-cell>a</table-cell><table-cell>bb</table-cell></table-row><table-row><table-cell>ccc</table-cell><table-cell>dddd</table-cell></table-row></table-body></table></body></page>",
+        ),
         # first row recognized as header
-        ('Head A;Head B\n1;2\n3;4',
-         '<page><body><table class="moin-sortable"><table-header><table-row><table-cell class="moin-integer">Head A</table-cell><table-cell class="moin-integer">Head B</table-cell></table-row></table-header><table-body><table-row><table-cell class="moin-integer">1</table-cell><table-cell class="moin-integer">2</table-cell></table-row><table-row><table-cell class="moin-integer">3</table-cell><table-cell class="moin-integer">4</table-cell></table-row></table-body></table></body></page>'),
+        (
+            "Head A;Head B\n1;2\n3;4",
+            '<page><body><table class="moin-sortable"><table-header><table-row><table-cell class="moin-integer">Head A</table-cell><table-cell class="moin-integer">Head B</table-cell></table-row></table-header><table-body><table-row><table-cell class="moin-integer">1</table-cell><table-cell class="moin-integer">2</table-cell></table-row><table-row><table-cell class="moin-integer">3</table-cell><table-cell class="moin-integer">4</table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_csv(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}):
-        out = self.conv(input, 'text/csv;charset=utf-8', **args)
+        out = self.conv(input, "text/csv;charset=utf-8", **args)
         assert self.serialize_strip(out) == output
diff --git a/src/moin/converters/_tests/test_docbook_in.py b/src/moin/converters/_tests/test_docbook_in.py
index 484f07f63..4dbaba0ed 100644
--- a/src/moin/converters/_tests/test_docbook_in.py
+++ b/src/moin/converters/_tests/test_docbook_in.py
@@ -15,54 +15,56 @@
 from moin.converters.docbook_in import Converter
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
 class Base:
     input_namespaces = ns_all = f'xmlns="{docbook.namespace}" xmlns:xlink="{xlink.namespace}"'
     output_namespaces = {
-        moin_page.namespace: '',
-        xlink.namespace: 'xlink',
-        xml.namespace: 'xml',
-        html.namespace: 'html',
-        xinclude.namespace: 'xinclude',
+        moin_page.namespace: "",
+        xlink.namespace: "xlink",
+        xml.namespace: "xml",
+        html.namespace: "html",
+        xinclude.namespace: "xinclude",
     }
 
-    namespaces_xpath = {'xlink': xlink.namespace,
-                        'xml': xml.namespace,
-                        'html': html.namespace,
-                        'xinclude': xinclude.namespace,
-                        }
+    namespaces_xpath = {
+        "xlink": xlink.namespace,
+        "xml": xml.namespace,
+        "html": html.namespace,
+        "xinclude": xinclude.namespace,
+    }
 
     input_re = TAGSTART_RE
     output_re = XMLNS_RE3
 
     def handle_input(self, input):
-        return self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        return self.input_re.sub(r"\1 " + self.input_namespaces, input)
 
     def handle_output(self, input, **args):
-        if 'nonamespace' not in args:
+        if "nonamespace" not in args:
             to_conv = self.handle_input(input)
-        elif args['nonamespace']:
+        elif args["nonamespace"]:
             to_conv = input
-        out = self.conv(to_conv, 'application/docbook+xml;charset=utf-8')
+        out = self.conv(to_conv, "application/docbook+xml;charset=utf-8")
         output = serialize(out, namespaces=self.output_namespaces)
-        return self.output_re.sub('', output)
+        return self.output_re.sub("", output)
 
     def do(self, input, xpath_query):
         string_to_parse = self.handle_output(input)
         logging.debug(f"After the DOCBOOK_IN conversion : {string_to_parse}")
         tree = etree.parse(StringIO(string_to_parse))
-        print('string_to_parse = %s' % string_to_parse)  # provide a clue for failing tests
-        assert (tree.xpath(xpath_query, namespaces=self.namespaces_xpath))
+        print("string_to_parse = %s" % string_to_parse)  # provide a clue for failing tests
+        assert tree.xpath(xpath_query, namespaces=self.namespaces_xpath)
 
     def do_nonamespace(self, input, xpath_query):
         string_to_parse = self.handle_output(input, nonamespace=True)
         logging.debug(f"After the DOCBOOK_IN conversion : {string_to_parse}")
         tree = etree.parse(StringIO(string_to_parse))
-        assert (tree.xpath(xpath_query, namespaces=self.namespaces_xpath))
+        assert tree.xpath(xpath_query, namespaces=self.namespaces_xpath)
 
 
 class TestConverter(Base):
@@ -70,404 +72,526 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('<article><para>Test</para></article>',
-         # <page><body><div html:class="db-article"><p>Test</p></div></body></page>
-         '/page/body/div[@html:class="db-article"][p="Test"]'),
-        ('<article><simpara>Test</simpara></article>',
-         # <page><body><div html:class="article"><p>Test</p></div></body></page>
-         '/page/body/div[p="Test"]'),
-        ('<article><formalpara><title>Title</title><para>Test</para></formalpara></article>',
-         # <page><body><div html:class="article"><p html:title="Title">Test</p></div></body></page>
-         '/page/body/div/p[text()="Test"][@html:title="Title"]'),
-        ('<article><sect1><title>Heading 1</title> <para>First Paragraph</para></sect1></article>',
-         # <page><body><div html:class="article"><h outline-level="1">Heading 1</h><p>First Paragraph</p></div></body></page>
-         '/page/body/div[./h[@outline-level="1"][text()="Heading 1"]][./p[text()="First Paragraph"]]'),
+        (
+            "<article><para>Test</para></article>",
+            # <page><body><div html:class="db-article"><p>Test</p></div></body></page>
+            '/page/body/div[@html:class="db-article"][p="Test"]',
+        ),
+        (
+            "<article><simpara>Test</simpara></article>",
+            # <page><body><div html:class="article"><p>Test</p></div></body></page>
+            '/page/body/div[p="Test"]',
+        ),
+        (
+            "<article><formalpara><title>Title</title><para>Test</para></formalpara></article>",
+            # <page><body><div html:class="article"><p html:title="Title">Test</p></div></body></page>
+            '/page/body/div/p[text()="Test"][@html:title="Title"]',
+        ),
+        (
+            "<article><sect1><title>Heading 1</title> <para>First Paragraph</para></sect1></article>",
+            # <page><body><div html:class="article"><h outline-level="1">Heading 1</h><p>First Paragraph</p></div></body></page>
+            '/page/body/div[./h[@outline-level="1"][text()="Heading 1"]][./p[text()="First Paragraph"]]',
+        ),
         # Test for conversion with unicode char
-        ('<article><para>안녕 유빈</para></article>',
-         # <page><body><div html:class="article"><p>안녕 유빈</p></div></body></page>
-         '/page/body/div[p="안녕 유빈"]'),
+        (
+            "<article><para>안녕 유빈</para></article>",
+            # <page><body><div html:class="article"><p>안녕 유빈</p></div></body></page>
+            '/page/body/div[p="안녕 유빈"]',
+        ),
         # Ignored tags
-        ('<article><info><title>Title</title><author>Author</author></info><para>text</para></article>',
-         # <page><body><div html:class="article"><p>text</p></div></body></page>
-         '/page/body/div[p="text"]'),
+        (
+            "<article><info><title>Title</title><author>Author</author></info><para>text</para></article>",
+            # <page><body><div html:class="article"><p>text</p></div></body></page>
+            '/page/body/div[p="text"]',
+        ),
         # XML attributes: We support all the xml standard attributes
-        ('<article><para xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</para></article>',
-         # <page><body><div html:class="article"><p xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></div></body></page>
-         '/page/body/div/p[@xml:base="http://base.tld"][@xml:id="id"][@xml:lang="en"][text()="Text"]'),
+        (
+            '<article><para xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</para></article>',
+            # <page><body><div html:class="article"><p xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></div></body></page>
+            '/page/body/div/p[@xml:base="http://base.tld"][@xml:id="id"][@xml:lang="en"][text()="Text"]',
+        ),
         # ANCHOR --> SPAN
-        ('<article><para>bla bla<anchor xml:id="point_1" />bla bla</para></article>',
-         # <page><body><div html:class="article"><p>bla bla<span class="db-anchor" xml:id="point_1" />bla bla</p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-anchor"][@xml:id="point_1"]'),
+        (
+            '<article><para>bla bla<anchor xml:id="point_1" />bla bla</para></article>',
+            # <page><body><div html:class="article"><p>bla bla<span class="db-anchor" xml:id="point_1" />bla bla</p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-anchor"][@xml:id="point_1"]',
+        ),
         # BOOK Document
-        ('<book><para>Test</para></book>',
-         # <page><body><div html:class="db-book"><p>Test</p></div></body></page>
-         '/page/body/div[@html:class="db-book"][p="Test"]'),
+        (
+            "<book><para>Test</para></book>",
+            # <page><body><div html:class="db-book"><p>Test</p></div></body></page>
+            '/page/body/div[@html:class="db-book"][p="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_base(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Test simple numbered section conversion into headings.
-        ('<article><sect1><title>Heading 1</title> <para>First</para><sect2><title>Heading 2</title><para>Second</para></sect2></sect1></article>',
-         # <page><body><table-of-content><div html:class="article"><h outline-level="1">Heading 1</h><p>First</p><h outline-level="2">Heading 2</h><p>Second</p></div></body></page>
-         '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2"]][p[2][text()="Second"]]'),
-
-        ('<article><section><title>Heading 1</title> <para>First</para><section><title>Heading 2</title><para>Second</para></section></section></article>',
-         # <page><body><table-of-content><div html:class="article"><h outline-level="1">Heading 1</h><p>First</p><h outline-level="2">Heading 2</h><p>Second</p></div></body></page>
-         '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2"]][p[2][text()="Second"]]'),
-
+        (
+            "<article><sect1><title>Heading 1</title> <para>First</para><sect2><title>Heading 2</title><para>Second</para></sect2></sect1></article>",
+            # <page><body><table-of-content><div html:class="article"><h outline-level="1">Heading 1</h><p>First</p><h outline-level="2">Heading 2</h><p>Second</p></div></body></page>
+            '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2"]][p[2][text()="Second"]]',
+        ),
+        (
+            "<article><section><title>Heading 1</title> <para>First</para><section><title>Heading 2</title><para>Second</para></section></section></article>",
+            # <page><body><table-of-content><div html:class="article"><h outline-level="1">Heading 1</h><p>First</p><h outline-level="2">Heading 2</h><p>Second</p></div></body></page>
+            '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2"]][p[2][text()="Second"]]',
+        ),
         # Test complex recursive section conversion into headings.
-        ('<article><section><title>Heading 1 A</title><para>First</para><section><title>Heading 2 A</title><para>Second</para><section><title>Heading 3 A</title><para>Third</para></section></section></section><section><title>Heading 1 B</title><para>Fourth</para></section></article>',
-         # <page><body><table-of-content /><div html:class="article"><h outline-level="1">Heading 1 A</h><p>First</p><h outline-level="2">Heading 2 A</h><p>Second</p><h outline-level="3">Heading 3 A</h><p>Third</p><h outline-level="1">Heading 1 B</h><p>Fourth</p></div></body></page>
-         '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1 A"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2 A"]][p[2][text()="Second"]][h[3][@outline-level="3"][text()="Heading 3 A"]][p[3][text()="Third"]][h[4][@outline-level="1"][text()="Heading 1 B"]][p[4][text()="Fourth"]]'),
+        (
+            "<article><section><title>Heading 1 A</title><para>First</para><section><title>Heading 2 A</title><para>Second</para><section><title>Heading 3 A</title><para>Third</para></section></section></section><section><title>Heading 1 B</title><para>Fourth</para></section></article>",
+            # <page><body><table-of-content /><div html:class="article"><h outline-level="1">Heading 1 A</h><p>First</p><h outline-level="2">Heading 2 A</h><p>Second</p><h outline-level="3">Heading 3 A</h><p>Third</p><h outline-level="1">Heading 1 B</h><p>Fourth</p></div></body></page>
+            '/page/body[table-of-content]/div[h[1][@outline-level="1"][text()="Heading 1 A"]][p[1][text()="First"]][h[2][@outline-level="2"][text()="Heading 2 A"]][p[2][text()="Second"]][h[3][@outline-level="3"][text()="Heading 3 A"]][p[3][text()="Third"]][h[4][@outline-level="1"][text()="Heading 1 B"]][p[4][text()="Fourth"]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_title(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # ITEMIZED LIST --> unordered list
-        ('<article><itemizedlist><listitem>Unordered Item 1</listitem><listitem>Unordered Item 2</listitem></itemizedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generate="unordered"><list-item><list-item-body>Unordered Item 1</list-item-body></list-item><list-item><list-item-body>Unordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Unordered Item 1"]][list-item[2]/list-item-body[text()="Unordered Item 2"]]'),
-
+        (
+            "<article><itemizedlist><listitem>Unordered Item 1</listitem><listitem>Unordered Item 2</listitem></itemizedlist></article>",
+            # <page><body><div html:class="article"><list item-label-generate="unordered"><list-item><list-item-body>Unordered Item 1</list-item-body></list-item><list-item><list-item-body>Unordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Unordered Item 1"]][list-item[2]/list-item-body[text()="Unordered Item 2"]]',
+        ),
         # ORDERED LIST --> ordered list
-        ('<article><orderedlist><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]'),
-
+        (
+            "<article><orderedlist><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>",
+            # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]',
+        ),
         # ORDERED LIST with upperalpha numeration --> ordered list with upper-alpha list-style-type
-        ('<article><orderedlist numeration="upperalpha"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="upper-alpha"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]'),
-
+        (
+            '<article><orderedlist numeration="upperalpha"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
+            # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="upper-alpha"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]',
+        ),
         # ORDERED LIST with loweralpha numeration --> ordered list with lower-alpha list-style-type
-        ('<article><orderedlist numeration="loweralpha"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="lower-alpha"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]'),
-
+        (
+            '<article><orderedlist numeration="loweralpha"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
+            # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="lower-alpha"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]',
+        ),
         # ORDERED LIST with upperroman numeration --> ordered list with upper-roman list-style-type
-        ('<article><orderedlist numeration="upperroman"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="upper-roman"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="upper-roman"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]'),
-
+        (
+            '<article><orderedlist numeration="upperroman"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
+            # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="upper-roman"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="upper-roman"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]',
+        ),
         # ORDERED LIST with lowerroman numeration --> ordered list with lower-roman list-style-type
-        ('<article><orderedlist numeration="lowerroman"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
-         # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="lower-roman"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="lower-roman"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]'),
-
+        (
+            '<article><orderedlist numeration="lowerroman"><listitem>Ordered Item 1</listitem><listitem>Ordered Item 2</listitem></orderedlist></article>',
+            # <page><body><div html:class="article"><list item-label-generage="ordered" list-style-type="lower-roman"><list-item><list-item-body>Ordered Item 1</list-item-body></list-item><list-item><list-item-body>Ordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][@list-style-type="lower-roman"][list-item[1]/list-item-body[text()="Ordered Item 1"]][list-item[2]/list-item-body[text()="Ordered Item 2"]]',
+        ),
         # VARIABLE LIST --> list
-        ('<article><variablelist><varlistentry><term>Term 1</term><listitem>Definition 1</listitem></varlistentry><varlistentry><term>Term 2</term><listitem>Definition 2</listitem></varlistentry></variablelist></article>',
-         # <page><body><div html:class="article"><list><list-item><list-item-label>Termm 1</list-item-label><list-item-body>Definition 1</list-item-body></list-item><list-item><list-item-label>Term 2</list-item-label><list-item-body>Definition 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body="Definition 1"]][list-item[2][list-item-label="Term 2"][list-item-body="Definition 2"]]'),
-
+        (
+            "<article><variablelist><varlistentry><term>Term 1</term><listitem>Definition 1</listitem></varlistentry><varlistentry><term>Term 2</term><listitem>Definition 2</listitem></varlistentry></variablelist></article>",
+            # <page><body><div html:class="article"><list><list-item><list-item-label>Termm 1</list-item-label><list-item-body>Definition 1</list-item-body></list-item><list-item><list-item-label>Term 2</list-item-label><list-item-body>Definition 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body="Definition 1"]][list-item[2][list-item-label="Term 2"][list-item-body="Definition 2"]]',
+        ),
         # PROCEDURE --> ordered list (with arabic numeration)
-        ('<article><procedure><step>First Step</step><step>Second Step</step></procedure></article>',
-         # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body>Second Step</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list-item[2]/list-item-body[text()="Second Step"]]'),
-
+        (
+            "<article><procedure><step>First Step</step><step>Second Step</step></procedure></article>",
+            # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body>Second Step</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list-item[2]/list-item-body[text()="Second Step"]]',
+        ),
         # PROCEDURE --> ordered list (with arabic numeration) (with stepalternative)
-        ('<article><procedure><step>First Step</step><stepalternatives>Second Step</stepalternatives></procedure></article>',
-         # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body>Second Step</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list-item[2]/list-item-body[text()="Second Step"]]'),
-
+        (
+            "<article><procedure><step>First Step</step><stepalternatives>Second Step</stepalternatives></procedure></article>",
+            # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body>Second Step</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list-item[2]/list-item-body[text()="Second Step"]]',
+        ),
         # PROCEDURE with SUBSTEPS
-        ('<article><procedure><step>First Step</step><substeps><step>Second Step</step></substeps></procedure></article>',
-         # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body><list item-label-generate="ordered">Second Step</list-item-body></list-item></list></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list[@item-label-generate="ordered"]/list-item/list-item-body[text()="Second Step"]]'),
-
+        (
+            "<article><procedure><step>First Step</step><substeps><step>Second Step</step></substeps></procedure></article>",
+            # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body>First Step</list-item-body></list-item><list-item><list-item-body><list item-label-generate="ordered">Second Step</list-item-body></list-item></list></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[text()="First Step"]][list[@item-label-generate="ordered"]/list-item/list-item-body[text()="Second Step"]]',
+        ),
         # GLOSS LIST --> Definition list
-        ('<article><glosslist><glossentry><glossterm>Term 1</glossterm><glossdef><para>Definition 1</para></glossdef></glossentry><glossentry><glossterm>Term 2</glossterm><glossdef><para>Definition 2</para></glossdef></glossentry></glosslist></article>',
-         # <page><body><div html:class="article"><list><list-item><list-item-label>Termm 1</list-item-label><list-item-body>Definition 1</list-item-body></list-item><list-item><list-item-label>Term 2</list-item-label><list-item-body>Definition 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body[p="Definition 1"]]][list-item[2][list-item-label="Term 2"][list-item-body[p="Definition 2"]]]'),
-
+        (
+            "<article><glosslist><glossentry><glossterm>Term 1</glossterm><glossdef><para>Definition 1</para></glossdef></glossentry><glossentry><glossterm>Term 2</glossterm><glossdef><para>Definition 2</para></glossdef></glossentry></glosslist></article>",
+            # <page><body><div html:class="article"><list><list-item><list-item-label>Termm 1</list-item-label><list-item-body>Definition 1</list-item-body></list-item><list-item><list-item-label>Term 2</list-item-label><list-item-body>Definition 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body[p="Definition 1"]]][list-item[2][list-item-label="Term 2"][list-item-body[p="Definition 2"]]]',
+        ),
         # SEGMENTED LIST --> Definition List
-        ('<article><segmentedlist><segtitle>Term 1</segtitle><segtitle>Term 2</segtitle><segtitle>Term 3</segtitle><seglistitem><seg>Def 1:1</seg><seg>Def 1:2</seg><seg>Def 1:3</seg></seglistitem><seglistitem><seg>Def 2:1</seg><seg>Def 2:2</seg><seg>Def 2:3</seg></seglistitem></segmentedlist></article>',
-         '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body="Def 1:1"]][list-item[2][list-item-label="Term 2"][list-item-body="Def 1:2"]][list-item[3][list-item-label="Term 3"][list-item-body="Def 1:3"]][list-item[4][list-item-label="Term 1"][list-item-body="Def 2:1"]][list-item[5][list-item-label="Term 2"][list-item-body="Def 2:2"]][list-item[6][list-item-label="Term 3"][list-item-body="Def 2:3"]]'),
-
+        (
+            "<article><segmentedlist><segtitle>Term 1</segtitle><segtitle>Term 2</segtitle><segtitle>Term 3</segtitle><seglistitem><seg>Def 1:1</seg><seg>Def 1:2</seg><seg>Def 1:3</seg></seglistitem><seglistitem><seg>Def 2:1</seg><seg>Def 2:2</seg><seg>Def 2:3</seg></seglistitem></segmentedlist></article>",
+            '/page/body/div/list[list-item[1][list-item-label="Term 1"][list-item-body="Def 1:1"]][list-item[2][list-item-label="Term 2"][list-item-body="Def 1:2"]][list-item[3][list-item-label="Term 3"][list-item-body="Def 1:3"]][list-item[4][list-item-label="Term 1"][list-item-body="Def 2:1"]][list-item[5][list-item-label="Term 2"][list-item-body="Def 2:2"]][list-item[6][list-item-label="Term 3"][list-item-body="Def 2:3"]]',
+        ),
         # SIMPLE LIST --> unordered list
-        ('<article><simplelist><member>Item 1</member><member>Item 2</member></simplelist></article>',
-         # <page><body><div html:class="article"><list item-label-generate="unordered"><list-item><list-item-body>Unordered Item 1</list-item-body></list-item><list-item><list-item-body>Unordered Item 2</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Item 1"]][list-item[2]/list-item-body[text()="Item 2"]]'),
-
+        (
+            "<article><simplelist><member>Item 1</member><member>Item 2</member></simplelist></article>",
+            # <page><body><div html:class="article"><list item-label-generate="unordered"><list-item><list-item-body>Unordered Item 1</list-item-body></list-item><list-item><list-item-body>Unordered Item 2</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Item 1"]][list-item[2]/list-item-body[text()="Item 2"]]',
+        ),
         # Q and A set with defaultlabel = number --> ordered list
-        ("<article><qandaset defaultlabel='number'><qandaentry><question><para>Question 1</para></question><answer><para>Answer 1</para></answer></qandaentry><qandaentry><question><para>Question 2</para></question><answer><para>Answer 2</para></answer></qandaentry></qandaset></article> ",
-         # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body><p>Question1</p><p>Answer 1</p></list-item-body></list-item><list-item><list-item-body><p>Question 2</p><p>Answer 2</p></list-item-body></list-item></div></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[p[1][text()="Question 1"]][p[2][text()="Answer 1"]]][list-item[2]/list-item-body[p[1][text()="Question 2"]][p[2][text()="Answer 2"]]]'),
-
+        (
+            "<article><qandaset defaultlabel='number'><qandaentry><question><para>Question 1</para></question><answer><para>Answer 1</para></answer></qandaentry><qandaentry><question><para>Question 2</para></question><answer><para>Answer 2</para></answer></qandaentry></qandaset></article> ",
+            # <page><body><div html:class="article"><list item-label-generate="ordered"><list-item><list-item-body><p>Question1</p><p>Answer 1</p></list-item-body></list-item><list-item><list-item-body><p>Question 2</p><p>Answer 2</p></list-item-body></list-item></div></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"][list-item[1]/list-item-body[p[1][text()="Question 1"]][p[2][text()="Answer 1"]]][list-item[2]/list-item-body[p[1][text()="Question 2"]][p[2][text()="Answer 2"]]]',
+        ),
         # Q and A set with defaultlabel = qanda --> definition list, with Q: and A: for the label
-        ("<article><qandaset defaultlabel='qanda'><qandaentry><question><para>Question 1</para></question><answer><para>Answer 1</para></answer></qandaentry><qandaentry><question><para>Question 2</para></question><answer><para>Answer 2</para></answer></qandaentry></qandaset></article> ",
-         # <page><body><div html:class="article"><list><list-item><list-item-label>Q: </list-item-label><list-item-body>Question 1</list-item-body></list-item><list-item><list-item-label>A: </list-item-label><list-item-body>Answer 1</list-item-body></list-item><list-item><list-item-label>Q: </list-item-label><list-item-body>Question 2</list-item-body></list-item><list-item><list-item-label>A: </list-item-label><list-item-body>Answer 2</list-item-body></list-item>
-         '/page/body/div/list[list-item[1][list-item-label="Q:"][list-item-body="Question 1"]][list-item[2][list-item-label="A:"][list-item-body="Answer 1"]][list-item[3][list-item-label="Q:"][list-item-body="Question 2"]][list-item[4][list-item-label="A:"][list-item-body="Answer 2"]]'),
+        (
+            "<article><qandaset defaultlabel='qanda'><qandaentry><question><para>Question 1</para></question><answer><para>Answer 1</para></answer></qandaentry><qandaentry><question><para>Question 2</para></question><answer><para>Answer 2</para></answer></qandaentry></qandaset></article> ",
+            # <page><body><div html:class="article"><list><list-item><list-item-label>Q: </list-item-label><list-item-body>Question 1</list-item-body></list-item><list-item><list-item-label>A: </list-item-label><list-item-body>Answer 1</list-item-body></list-item><list-item><list-item-label>Q: </list-item-label><list-item-body>Question 2</list-item-body></list-item><list-item><list-item-label>A: </list-item-label><list-item-body>Answer 2</list-item-body></list-item>
+            '/page/body/div/list[list-item[1][list-item-label="Q:"][list-item-body="Question 1"]][list-item[2][list-item-label="A:"][list-item-body="Answer 1"]][list-item[3][list-item-label="Q:"][list-item-body="Question 2"]][list-item[4][list-item-label="A:"][list-item-body="Answer 2"]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_list(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<article><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></article>',
-         # <page><body><div html:class="article"><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-row></table-cell></table></div></body></page>
-         '/page/body/div/table[./table-header/table-row[table-cell="Header"]][./table-footer/table-row[table-cell="Footer"]][./table-body/table-row[table-cell="Cell"]]'),
-
-        ('<article><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></article>',
-         # <page><body><div html:class="article"><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></div></body></page>
-         '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-columns-spanned="2"]'),
-
-        ('<article><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></article>',
-         # <page><body><div html:class="article"><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></div></body></page>
-         '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-rows-spanned="2"]'),
-
+        (
+            "<article><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></article>",
+            # <page><body><div html:class="article"><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-row></table-cell></table></div></body></page>
+            '/page/body/div/table[./table-header/table-row[table-cell="Header"]][./table-footer/table-row[table-cell="Footer"]][./table-body/table-row[table-cell="Cell"]]',
+        ),
+        (
+            '<article><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></article>',
+            # <page><body><div html:class="article"><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></div></body></page>
+            '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-columns-spanned="2"]',
+        ),
+        (
+            '<article><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></article>',
+            # <page><body><div html:class="article"><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></div></body></page>
+            '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-rows-spanned="2"]',
+        ),
         # Simple db.cals.table
-        ('<article><table xml:id="ex.calstable"><tgroup cols="2"><thead><row><entry>a1</entry><entry>a2</entry></row></thead><tfoot><row><entry>f1</entry><entry>f2</entry></row></tfoot><tbody><row><entry>b1</entry><entry>b2</entry></row></tbody></tgroup></table></article>',
-         # <page><body><div html:class="article"><table><table-header><table-row><table-cell>a1</table-cell><table-cell>a2</table-cell></table-row></table-header><table-footer><table-row><table-cell>f1</table-cell><table-cell>f2</table-cell></table-row></table-footer><table-body><table-row><table-cell>b1</table-row><table-cell>b2</table-row></table-cell></table></div></body></page>
-         '/page/body/div/table[./table-header/table-row[table-cell="a1"][table-cell="a2"]][./table-footer/table-row[table-cell="f1"][table-cell="f2"]][./table-body/table-row[table-cell="b1"][table-cell="b2"]]'),
-
+        (
+            '<article><table xml:id="ex.calstable"><tgroup cols="2"><thead><row><entry>a1</entry><entry>a2</entry></row></thead><tfoot><row><entry>f1</entry><entry>f2</entry></row></tfoot><tbody><row><entry>b1</entry><entry>b2</entry></row></tbody></tgroup></table></article>',
+            # <page><body><div html:class="article"><table><table-header><table-row><table-cell>a1</table-cell><table-cell>a2</table-cell></table-row></table-header><table-footer><table-row><table-cell>f1</table-cell><table-cell>f2</table-cell></table-row></table-footer><table-body><table-row><table-cell>b1</table-row><table-cell>b2</table-row></table-cell></table></div></body></page>
+            '/page/body/div/table[./table-header/table-row[table-cell="a1"][table-cell="a2"]][./table-footer/table-row[table-cell="f1"][table-cell="f2"]][./table-body/table-row[table-cell="b1"][table-cell="b2"]]',
+        ),
         # db.cals.table with entry table.
-        ('<article><table xml:id="ex.calstable"><tgroup cols="1"><thead><row><entry>a1</entry></row></thead><tfoot><row><entry>f1</entry></row></tfoot><tbody><row><entrytbl cols="1"><tbody><row><entry>s1</entry></row></tbody></entrytbl></row></tbody></tgroup></table></article>',
-         # <page><body><div html:class="article"><table><table-header><table-row><table-cell>a1</table-cell></table-row></table-header><table-footer><table-row><table-cell>f1</table-cell></table-row></table-footer><table-body><table-row><table-cell><table><table-body><table-row><table-cell>s1</table-cell></table-row></table-body></table></table-row></table-cell></table></div></body></page>
-         '/page/body/div/table[./table-header/table-row[table-cell="a1"]][./table-footer/table-row[table-cell="f1"]][./table-body/table-row[table-cell/table/table-body/table-row[table-cell="s1"]]]'),
+        (
+            '<article><table xml:id="ex.calstable"><tgroup cols="1"><thead><row><entry>a1</entry></row></thead><tfoot><row><entry>f1</entry></row></tfoot><tbody><row><entrytbl cols="1"><tbody><row><entry>s1</entry></row></tbody></entrytbl></row></tbody></tgroup></table></article>',
+            # <page><body><div html:class="article"><table><table-header><table-row><table-cell>a1</table-cell></table-row></table-header><table-footer><table-row><table-cell>f1</table-cell></table-row></table-footer><table-body><table-row><table-cell><table><table-body><table-row><table-cell>s1</table-cell></table-row></table-body></table></table-row></table-cell></table></div></body></page>
+            '/page/body/div/table[./table-header/table-row[table-cell="a1"]][./table-footer/table-row[table-cell="f1"]][./table-body/table-row[table-cell/table/table-body/table-row[table-cell="s1"]]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_table(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<article><para>Text Para<footnote><para>Text Footnote</para></footnote></para></article>',
-         # <page><body><div html:class="article"><p>Text Para<note note-class="footnote"><note-body><p>Text Footnote</p></note-body></note></p></div></body></page>
-         '/page/body/div/p[text()="Text Para"]/note[@note-class="footnote"]/note-body/p[text()="Text Footnote"]'),
-        ('<article><para><quote>text</quote></para></article>',
-         # <page><body><div html:class="article"><p><quote>text</quote></para></article>
-         '/page/body/div/p[quote="text"]'),
+        (
+            "<article><para>Text Para<footnote><para>Text Footnote</para></footnote></para></article>",
+            # <page><body><div html:class="article"><p>Text Para<note note-class="footnote"><note-body><p>Text Footnote</p></note-body></note></p></div></body></page>
+            '/page/body/div/p[text()="Text Para"]/note[@note-class="footnote"]/note-body/p[text()="Text Footnote"]',
+        ),
+        (
+            "<article><para><quote>text</quote></para></article>",
+            # <page><body><div html:class="article"><p><quote>text</quote></para></article>
+            '/page/body/div/p[quote="text"]',
+        ),
         # Test span for inline element
-        ('<article><para><abbrev>ABBREV</abbrev></para></article>',
-         # <page><body><div html:class="article"><p><span class="db-abbrev">ABBREV</span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-abbrev"][text()="ABBREV"]'),
+        (
+            "<article><para><abbrev>ABBREV</abbrev></para></article>",
+            # <page><body><div html:class="article"><p><span class="db-abbrev">ABBREV</span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-abbrev"][text()="ABBREV"]',
+        ),
         # Test div for block element
-        ('<article><acknowledgements><para>Text</para></acknowledgements></article>',
-         # <page><body><div html:class="article"><div html:class="db-acknowledgements"><p>Text</p></div></div></body></page>
-         '/page/body/div/div[@html:class="db-acknowledgements"][p="Text"]'),
+        (
+            "<article><acknowledgements><para>Text</para></acknowledgements></article>",
+            # <page><body><div html:class="article"><div html:class="db-acknowledgements"><p>Text</p></div></div></body></page>
+            '/page/body/div/div[@html:class="db-acknowledgements"][p="Text"]',
+        ),
         # Test for <informalequation>
-        ('<article><informalequation><para>E = mc^2</para></informalequation></article>',
-         # <page><body><div html:class="article"><div html:class="db-equation"><p>E = mc^2</p></div></div></body></page>
-         '/page/body/div/div[@html:class="db-equation"][p="E = mc^2"]'),
+        (
+            "<article><informalequation><para>E = mc^2</para></informalequation></article>",
+            # <page><body><div html:class="article"><div html:class="db-equation"><p>E = mc^2</p></div></div></body></page>
+            '/page/body/div/div[@html:class="db-equation"][p="E = mc^2"]',
+        ),
         # Test for <informalexample>
-        ('<article><informalexample><para>example</para></informalexample></article>',
-         # <page><body><div html:class="article"><div html:class="db-example"><p>example</p></div></div></body></page>
-         '/page/body/div/div[@html:class="db-example"][p="example"]'),
+        (
+            "<article><informalexample><para>example</para></informalexample></article>",
+            # <page><body><div html:class="article"><div html:class="db-example"><p>example</p></div></div></body></page>
+            '/page/body/div/div[@html:class="db-example"][p="example"]',
+        ),
         # Test for <sbr />
-        ('<article><cmdsynopsis><para>Line 1<sbr />Line 2</para></cmdsynopsis></article>',
-         # <page><body><div html:class="article"><div html:class="db-cmdsynopsis"><p>Line 1<line-break />Line 2</p></div></div></body></page>
-         '/page/body/div/div[@html:class="db-cmdsynopsis"]/p/line-break'),
+        (
+            "<article><cmdsynopsis><para>Line 1<sbr />Line 2</para></cmdsynopsis></article>",
+            # <page><body><div html:class="article"><div html:class="db-cmdsynopsis"><p>Line 1<line-break />Line 2</p></div></div></body></page>
+            '/page/body/div/div[@html:class="db-cmdsynopsis"]/p/line-break',
+        ),
         # Test for <tag> element with class and namespace attribute
-        ('<article><para><tag class="attribute" namespace="namespace">TAG</tag></para></article>',
-         # <page><body><div html:class="article"><p><span class="db-tag-attribute">{namespace}TAG</span></p></div></article>
-         '/page/body/div/p/span[@html:class="db-tag-attribute"][text()="{namespace}TAG"]'),
+        (
+            '<article><para><tag class="attribute" namespace="namespace">TAG</tag></para></article>',
+            # <page><body><div html:class="article"><p><span class="db-tag-attribute">{namespace}TAG</span></p></div></article>
+            '/page/body/div/p/span[@html:class="db-tag-attribute"][text()="{namespace}TAG"]',
+        ),
         # Test for <tag> element without class and namespace attribute
-        ('<article><para><tag>TAG</tag></para></article>',
-         # <page><body><div html:class="article"><p><span class="db-tag">TAG</span></p></div></article>
-         '/page/body/div/p/span[@html:class="db-tag"][text()="TAG"]'),
+        (
+            "<article><para><tag>TAG</tag></para></article>",
+            # <page><body><div html:class="article"><p><span class="db-tag">TAG</span></p></div></article>
+            '/page/body/div/p/span[@html:class="db-tag"][text()="TAG"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_misc(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Normal link, with conversion of all the xlink attributes
-        ('<article><para><link xlink:href="http:test" xlink:title="title">link</link></para></article>',
-         # <page><body><div html:class="article"><p><a xlink:href="http:test" xlink:title="title">link</a></p></div></body></page>
-         '/page/body/div/p/a[@xlink:href="http:test"][@html:title="title"][text()="link"]'),
+        (
+            '<article><para><link xlink:href="http:test" xlink:title="title">link</link></para></article>',
+            # <page><body><div html:class="article"><p><a xlink:href="http:test" xlink:title="title">link</a></p></div></body></page>
+            '/page/body/div/p/a[@xlink:href="http:test"][@html:title="title"][text()="link"]',
+        ),
         # Old link from DocBook v.4.X for backward compatibility
-        ('<article><para><ulink url="http:test">link</ulink></para></article>',
-         # <page><body><div html:class="article"><p><a xlink:href="http:test">link</a></p></div></body></page>
-         '/page/body/div/p/a[@xlink:href="http:test"][text()="link"]'),
+        (
+            '<article><para><ulink url="http:test">link</ulink></para></article>',
+            # <page><body><div html:class="article"><p><a xlink:href="http:test">link</a></p></div></body></page>
+            '/page/body/div/p/a[@xlink:href="http:test"][text()="link"]',
+        ),
         # Normal link, with linkend attribute
-        ('<article><para><link linkend="anchor">link</link></para></article>',
-         # <page><body><div html:class="article"><p><a xlink:href="#anchor">link</a></p></div></body></page>
-         '/page/body/div/p/a[@xlink:href="wiki.local:#anchor"][text()="link"]'),
+        (
+            '<article><para><link linkend="anchor">link</link></para></article>',
+            # <page><body><div html:class="article"><p><a xlink:href="#anchor">link</a></p></div></body></page>
+            '/page/body/div/p/a[@xlink:href="wiki.local:#anchor"][text()="link"]',
+        ),
         # OLINK
-        ('<article><para><olink targetdoc="uri" targetptr="anchor">link</olink></para></article>',
-         # <page><body><div html:class="article"><para><a xlink:href="uri#anchor">link</a></para></div></body></page>
-         '/page/body/div/p/a[@xlink:href="uri#anchor"][text()="link"]'),
+        (
+            '<article><para><olink targetdoc="uri" targetptr="anchor">link</olink></para></article>',
+            # <page><body><div html:class="article"><para><a xlink:href="uri#anchor">link</a></para></div></body></page>
+            '/page/body/div/p/a[@xlink:href="uri#anchor"][text()="link"]',
+        ),
         # Link w/ javascript: scheme
-        ('<article><para><ulink url="javascript:alert(\'xss\')">link</ulink></para></article>',
-         # the href attribute will default to None because javascript is not an allowed url scheme
-         # we don't care how it gets rendered as long as the javascript doesn't show up
-         # <page><body><div html:class="article"><p><a xlink:href="None">link</a></p></div></body></page>
-         '/page/body/div/p/a[@xlink:href="None"][text()="link"]'),
+        (
+            "<article><para><ulink url=\"javascript:alert('xss')\">link</ulink></para></article>",
+            # the href attribute will default to None because javascript is not an allowed url scheme
+            # we don't care how it gets rendered as long as the javascript doesn't show up
+            # <page><body><div html:class="article"><p><a xlink:href="None">link</a></p></div></body></page>
+            '/page/body/div/p/a[@xlink:href="None"][text()="link"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_link(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<article><screen>Text</screen></article>',
-         # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
-         '/page/body/div[blockcode="Text"]'),
+        (
+            "<article><screen>Text</screen></article>",
+            # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
+            '/page/body/div[blockcode="Text"]',
+        ),
         # Test for <screen> with CDATA
-        ('<article><screen><![CDATA[Text]]></screen></article>',
-         # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
-         '/page/body/div[blockcode="Text"]'),
+        (
+            "<article><screen><![CDATA[Text]]></screen></article>",
+            # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
+            '/page/body/div[blockcode="Text"]',
+        ),
         # PROGRAMLISTING --> BLOCKCODE
-        ('<article><programlisting>Text</programlisting></article>',
-         # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
-         '/page/body/div[blockcode="Text"]'),
+        (
+            "<article><programlisting>Text</programlisting></article>",
+            # <page><body><div html:class="article"><blockcode>Text</blockcode></div></body></page>
+            '/page/body/div[blockcode="Text"]',
+        ),
         # LITERAL --> CODE
-        ('<article><para>text<literal>literal</literal></para></article>',
-         # <page><body><div html:class="article"><p>text<code>literal</code></p></div></body></page>
-         '/page/body/div/p[text()="text"][code="literal"]'),
-        ('<article><blockquote><attribution>author</attribution>text</blockquote></article>',
-         # <page><body><div html:class="article"><blockquote source="author">text</blockquote></div></body></page>
-         '/page/body/div/blockquote[@source="author"][text()="text"]'),
+        (
+            "<article><para>text<literal>literal</literal></para></article>",
+            # <page><body><div html:class="article"><p>text<code>literal</code></p></div></body></page>
+            '/page/body/div/p[text()="text"][code="literal"]',
+        ),
+        (
+            "<article><blockquote><attribution>author</attribution>text</blockquote></article>",
+            # <page><body><div html:class="article"><blockquote source="author">text</blockquote></div></body></page>
+            '/page/body/div/blockquote[@source="author"][text()="text"]',
+        ),
         # CODE --> CODE
-        ('<article><para><code>Text</code></para></article>',
-         # <page><body><div html:class="article"><p><code>Text</code></p></article>
-         '/page/body/div/p[code="Text"]'),
+        (
+            "<article><para><code>Text</code></para></article>",
+            # <page><body><div html:class="article"><p><code>Text</code></p></article>
+            '/page/body/div/p[code="Text"]',
+        ),
         # COMPUTEROUTPUT --> CODE
-        ('<article><para><computeroutput>Text</computeroutput></para></article>',
-         # <page><body><div html:class="article"><p><code>Text</code></p></article>
-         '/page/body/div/p[code="Text"]'),
+        (
+            "<article><para><computeroutput>Text</computeroutput></para></article>",
+            # <page><body><div html:class="article"><p><code>Text</code></p></article>
+            '/page/body/div/p[code="Text"]',
+        ),
         # MARKUP --> CODE
-        ('<article><para><markup>Text</markup></para></article>',
-         # <page><body><div html:class="article"><p><code>Text</code></p></article>
-         '/page/body/div/p[code="Text"]'),
+        (
+            "<article><para><markup>Text</markup></para></article>",
+            # <page><body><div html:class="article"><p><code>Text</code></p></article>
+            '/page/body/div/p[code="Text"]',
+        ),
         # LITERALLAYOUT --> BLOCKCODE
-        ('<article><literallayout>Text</literallayout></article>',
-         # <page><body><div html:class="article"><blockcode html:class="db-literallayout">Text</blockcode></div></body></page>
-         '/page/body/div/blockcode[text()="Text"][@html:class="db-literallayout"]'),
+        (
+            "<article><literallayout>Text</literallayout></article>",
+            # <page><body><div html:class="article"><blockcode html:class="db-literallayout">Text</blockcode></div></body></page>
+            '/page/body/div/blockcode[text()="Text"][@html:class="db-literallayout"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_code(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Test for image object
-        ('<article><para><inlinemediaobject><imageobject><imagedata fileref="test.png"/></imageobject></inlinemediaobject></para></article>',
-         # <page><body><div html:class="db-article"><p><xinclude:include html:alt="test.png" xinclude:href="wiki.local:test.png" /></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-inlinemediaobject"]/xinclude:include[@html:alt="test.png"][@xinclude:href="wiki.local:test.png"]'),
-
+        (
+            '<article><para><inlinemediaobject><imageobject><imagedata fileref="test.png"/></imageobject></inlinemediaobject></para></article>',
+            # <page><body><div html:class="db-article"><p><xinclude:include html:alt="test.png" xinclude:href="wiki.local:test.png" /></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-inlinemediaobject"]/xinclude:include[@html:alt="test.png"][@xinclude:href="wiki.local:test.png"]',
+        ),
         # Test for audio object
-        ('<article><para><inlinemediaobject><audioobject><audiodata fileref="test.wav"/></audioobject></inlinemediaobject></para></article>',
-         # <page><body><div html:class="db-article"><p><span html:class="db-inlinemediaobject"><xinclude:include type="audio/" html:alt="test.wav" xinclude:href="wiki.local:test.wav" /></span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-inlinemediaobject"]/xinclude:include[@xinclude:href="wiki.local:test.wav"][@type="audio/"]'),
-
+        (
+            '<article><para><inlinemediaobject><audioobject><audiodata fileref="test.wav"/></audioobject></inlinemediaobject></para></article>',
+            # <page><body><div html:class="db-article"><p><span html:class="db-inlinemediaobject"><xinclude:include type="audio/" html:alt="test.wav" xinclude:href="wiki.local:test.wav" /></span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-inlinemediaobject"]/xinclude:include[@xinclude:href="wiki.local:test.wav"][@type="audio/"]',
+        ),
         # Test for video object
-        ('<article><para><mediaobject><videoobject><videodata fileref="test.avi"/></videoobject></mediaobject></para></article>',
-         # <page><body><div html:class="db-article"><p><div html:class="db-mediaobject"><xinclude:include type="video/" html:alt="test.avi" xinclude:href="wiki.local:test.avi" /></div></p></div></body></page>
-         '/page/body/div/p/div[@html:class="db-mediaobject"]/xinclude:include[@xinclude:href="wiki.local:test.avi"][@type="video/"]'),
-
+        (
+            '<article><para><mediaobject><videoobject><videodata fileref="test.avi"/></videoobject></mediaobject></para></article>',
+            # <page><body><div html:class="db-article"><p><div html:class="db-mediaobject"><xinclude:include type="video/" html:alt="test.avi" xinclude:href="wiki.local:test.avi" /></div></p></div></body></page>
+            '/page/body/div/p/div[@html:class="db-mediaobject"]/xinclude:include[@xinclude:href="wiki.local:test.avi"][@type="video/"]',
+        ),
         # Test for image object with different imagedata
-        ('<article><mediaobject><imageobject><imagedata fileref="figures/eiffeltower.eps" format="EPS"/></imageobject><imageobject><imagedata fileref="figures/eiffeltower.png" format="PNG"/></imageobject><textobject><phrase>The Eiffel Tower</phrase> </textobject><caption><para>Designed by Gustave Eiffel in 1889, The Eiffel Tower is one of the most widely recognized buildings in the world.</para>  </caption></mediaobject></article>',
-         # <page><body><div html:class="db-article"><div html:class="db-mediaobject"><span><xinclude:include type="image/png" html:alt="figures/eiffeltower.png" xinclude:href="wiki.local:figures/eiffeltower.png" /><span class="db-caption"><p>Designed by Gustave Eiffel in 1889, The Eiffel Tower is one of the most widely recognized buildings in the world.</p></span></span></div></div></body></page>
-         '/page/body/div/div[@html:class="db-mediaobject"]/span/xinclude:include[@xinclude:href="wiki.local:figures/eiffeltower.png"][@type="image/png"]'),
+        (
+            '<article><mediaobject><imageobject><imagedata fileref="figures/eiffeltower.eps" format="EPS"/></imageobject><imageobject><imagedata fileref="figures/eiffeltower.png" format="PNG"/></imageobject><textobject><phrase>The Eiffel Tower</phrase> </textobject><caption><para>Designed by Gustave Eiffel in 1889, The Eiffel Tower is one of the most widely recognized buildings in the world.</para>  </caption></mediaobject></article>',
+            # <page><body><div html:class="db-article"><div html:class="db-mediaobject"><span><xinclude:include type="image/png" html:alt="figures/eiffeltower.png" xinclude:href="wiki.local:figures/eiffeltower.png" /><span class="db-caption"><p>Designed by Gustave Eiffel in 1889, The Eiffel Tower is one of the most widely recognized buildings in the world.</p></span></span></div></div></body></page>
+            '/page/body/div/div[@html:class="db-mediaobject"]/span/xinclude:include[@xinclude:href="wiki.local:figures/eiffeltower.png"][@type="image/png"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_object(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # EMPHASIS --> EMPHASIS
-        ('<article><para>text<emphasis>emphasis</emphasis></para></article>',
-         # <page><body><div html:class="article"><p>text<emphasis>emphasis</emphasis></p></div></body></page>
-         '/page/body/div/p[text()="text"][emphasis="emphasis"]'),
+        (
+            "<article><para>text<emphasis>emphasis</emphasis></para></article>",
+            # <page><body><div html:class="article"><p>text<emphasis>emphasis</emphasis></p></div></body></page>
+            '/page/body/div/p[text()="text"][emphasis="emphasis"]',
+        ),
         # EMPHASIS role='strong' --> STRONG
-        ('<article><para>text<emphasis role="strong">strong</emphasis></para></article>',
-         # <page><body><div html:class="db-article"><p>text<emphasis>strong</emphasis></p></div></body></page>
-         '/page/body/div/p[text()="text"]/emphasis[text()="strong"]'),
+        (
+            '<article><para>text<emphasis role="strong">strong</emphasis></para></article>',
+            # <page><body><div html:class="db-article"><p>text<emphasis>strong</emphasis></p></div></body></page>
+            '/page/body/div/p[text()="text"]/emphasis[text()="strong"]',
+        ),
         # SUBSCRIPT --> SPAN baseline-shift = 'sub'
-        ('<article><para><subscript>sub</subscript>script</para></article>',
-         # <page><body><div html:class="article"><p>script<span baseline-shift="sub">sub</span></p></div></body></page>
-         '/page/body/div/p[text()="script"]/span[@baseline-shift="sub"][text()="sub"]'),
+        (
+            "<article><para><subscript>sub</subscript>script</para></article>",
+            # <page><body><div html:class="article"><p>script<span baseline-shift="sub">sub</span></p></div></body></page>
+            '/page/body/div/p[text()="script"]/span[@baseline-shift="sub"][text()="sub"]',
+        ),
         # SUPERSCRIPT --> SPAN baseline-shift = 'super'
-        ('<article><para><superscript>super</superscript>script</para></article>',
-         # <page><body><div html:class="article"><p>script<span baseline-shift="super">super</span></p></div></body></page>
-         '/page/body/div/p[text()="script"]/span[@baseline-shift="super"][text()="super"]'),
+        (
+            "<article><para><superscript>super</superscript>script</para></article>",
+            # <page><body><div html:class="article"><p>script<span baseline-shift="super">super</span></p></div></body></page>
+            '/page/body/div/p[text()="script"]/span[@baseline-shift="super"][text()="super"]',
+        ),
         # PHRASE --> SPAN
-        ('<article><para><phrase>text</phrase></para></article>',
-         # <page><body><div html:class="article"><p><span>text</span></p></div></body></page>
-         '/page/body/div/p[span="text"]'),
+        (
+            "<article><para><phrase>text</phrase></para></article>",
+            # <page><body><div html:class="article"><p><span>text</span></p></div></body></page>
+            '/page/body/div/p[span="text"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_style_element(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Test for caution admonition
-        ('<article><caution><para>text</para></caution></article>',
-         # <page><body><div html:class="article"><admonition type='caution'><p>text<p></admonition></div></body></page>
-         '/page/body/div/admonition[@type="caution"][p="text"]'),
+        (
+            "<article><caution><para>text</para></caution></article>",
+            # <page><body><div html:class="article"><admonition type='caution'><p>text<p></admonition></div></body></page>
+            '/page/body/div/admonition[@type="caution"][p="text"]',
+        ),
         # Test for important admonition
-        ('<article><important><para>text</para></important></article>',
-         # <page><body><div html:class="article"><admonition type='important'><p>text<p></admonition></div></body></page>
-         '/page/body/div/admonition[@type="important"][p="text"]'),
+        (
+            "<article><important><para>text</para></important></article>",
+            # <page><body><div html:class="article"><admonition type='important'><p>text<p></admonition></div></body></page>
+            '/page/body/div/admonition[@type="important"][p="text"]',
+        ),
         # Test for note admonition
-        ('<article><note><para>text</para></note></article>',
-         # <page><body><div html:class="article"><admonition type='note'><p>text<p></admonition></div></body></page>
-         '/page/body/div/admonition[@type="note"][p="text"]'),
+        (
+            "<article><note><para>text</para></note></article>",
+            # <page><body><div html:class="article"><admonition type='note'><p>text<p></admonition></div></body></page>
+            '/page/body/div/admonition[@type="note"][p="text"]',
+        ),
         # Test for tip admonition
-        ('<article><tip><para>text</para></tip></article>',
-         # <page><body><div html:class="article"><admonition type='tip'><p>text<p></admonition></div></body></page>
-         '/page/body/div/admonition[@type="tip"][p="text"]'),
+        (
+            "<article><tip><para>text</para></tip></article>",
+            # <page><body><div html:class="article"><admonition type='tip'><p>text<p></admonition></div></body></page>
+            '/page/body/div/admonition[@type="tip"][p="text"]',
+        ),
         # Test for warning admonition
-        ('<article><warning><para>text</para></warning></article>',
-         # <page><body><div html:class="article"><admonition type='warning'><p>text<p></admonition></div></body></page>
-         '/page/body/div/admonition[@type="warning"][p="text"]'),
+        (
+            "<article><warning><para>text</para></warning></article>",
+            # <page><body><div html:class="article"><admonition type='warning'><p>text<p></admonition></div></body></page>
+            '/page/body/div/admonition[@type="warning"][p="text"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_admonition(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<article><para><trademark class="copyright">MoinMoin</trademark></para></article>',
-         # <page><body><div html:class="db-article"><p><span html:class="db-trademark">\xa9  MoinMoin</span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-trademark"][text()="\xa9 MoinMoin"]'),
-        ('<article><para><trademark class="registered">Nutshell Handbook</trademark></para></article>',
-         # <page><body><div html:class="db-article"><p><span html:class="db-trademark">Nutshell Handbook\xae</span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-trademark"][text()="Nutshell Handbook\xae"]'),
-        ('<article><para><trademark class="trade">Foo Bar</trademark></para></article>',
-         # <page><body><div html:class="db-article"><p><span html:class="db-trademark">Foo Bar\u2122</span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-trademark"][text()="Foo Bar\u2122"]'),
-        ('<article><para><trademark class="service">MoinMoin</trademark></para></article>',
-         # <page><body><div html:class="article"><p><span class="db-trademark">MoinMoin<span baseline-shift="super">SM</span></span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-trademark"][text()="MoinMoin"]/span[@baseline-shift="super"][text()="SM"]'),
-        ('<article><para><trademark>MoinMoin</trademark></para></article>',
-         # <page><body><div html:class="article"><p><span class="db-trademark">MoinMoin</span></p></div></body></page>
-         '/page/body/div/p/span[@html:class="db-trademark"][text()="MoinMoin"]'),
+        (
+            '<article><para><trademark class="copyright">MoinMoin</trademark></para></article>',
+            # <page><body><div html:class="db-article"><p><span html:class="db-trademark">\xa9  MoinMoin</span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-trademark"][text()="\xa9 MoinMoin"]',
+        ),
+        (
+            '<article><para><trademark class="registered">Nutshell Handbook</trademark></para></article>',
+            # <page><body><div html:class="db-article"><p><span html:class="db-trademark">Nutshell Handbook\xae</span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-trademark"][text()="Nutshell Handbook\xae"]',
+        ),
+        (
+            '<article><para><trademark class="trade">Foo Bar</trademark></para></article>',
+            # <page><body><div html:class="db-article"><p><span html:class="db-trademark">Foo Bar\u2122</span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-trademark"][text()="Foo Bar\u2122"]',
+        ),
+        (
+            '<article><para><trademark class="service">MoinMoin</trademark></para></article>',
+            # <page><body><div html:class="article"><p><span class="db-trademark">MoinMoin<span baseline-shift="super">SM</span></span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-trademark"][text()="MoinMoin"]/span[@baseline-shift="super"][text()="SM"]',
+        ),
+        (
+            "<article><para><trademark>MoinMoin</trademark></para></article>",
+            # <page><body><div html:class="article"><p><span class="db-trademark">MoinMoin</span></p></div></body></page>
+            '/page/body/div/p/span[@html:class="db-trademark"][text()="MoinMoin"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_trademark(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Error: Xml not correctly formatted
-        ('<article><para>Text</para>',
-         '/page/body/part/error'),
+        ("<article><para>Text</para>", "/page/body/part/error"),
         # Error: Root Element is not correct
-        ('<link xlink:href="uri">link</link>',
-         '/page/body/part/error'),
+        ('<link xlink:href="uri">link</link>', "/page/body/part/error"),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_error(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Error: Missing namespace
-        ('<article><para>Text</para></article>',
-         '/page/body/part/error'),
+        ("<article><para>Text</para></article>", "/page/body/part/error")
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_namespace(self, input, xpath):
         self.do_nonamespace(input, xpath)
diff --git a/src/moin/converters/_tests/test_docbook_out.py b/src/moin/converters/_tests/test_docbook_out.py
index 099bf78dc..66884f0b2 100644
--- a/src/moin/converters/_tests/test_docbook_out.py
+++ b/src/moin/converters/_tests/test_docbook_out.py
@@ -17,41 +17,42 @@
 from moin.converters.docbook_out import Converter
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
 class Base:
-    input_namespaces = ns_all = f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:html="{html.namespace}" xmlns:xlink="{xlink.namespace}" xmlns:xml="{xml.namespace}"'
+    input_namespaces = ns_all = (
+        f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:html="{html.namespace}" xmlns:xlink="{xlink.namespace}" xmlns:xml="{xml.namespace}"'
+    )
     output_namespaces = {
-        docbook.namespace: '',
-        moin_page.namespace: 'page',
-        xlink.namespace: 'xlink',
-        xml.namespace: 'xml',
+        docbook.namespace: "",
+        moin_page.namespace: "page",
+        xlink.namespace: "xlink",
+        xml.namespace: "xml",
     }
 
-    namespaces_xpath = {'xlink': xlink.namespace,
-                        'xml': xml.namespace,
-                        }
+    namespaces_xpath = {"xlink": xlink.namespace, "xml": xml.namespace}
 
     input_re = TAGSTART_RE
     output_re = XMLNS_RE3
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
         output = serialize(elem, namespaces=self.output_namespaces, **options)
-        return self.output_re.sub('', output)
+        return self.output_re.sub("", output)
 
     def do(self, input, xpath, args={}):
         out = self.conv(self.handle_input(input), **args)
         string_to_parse = self.handle_output(out)
         logging.debug(f"After the docbook_OUT conversion : {string_to_parse}")
         tree = etree.parse(StringIO(string_to_parse))
-        assert (tree.xpath(xpath, namespaces=self.namespaces_xpath))
+        assert tree.xpath(xpath, namespaces=self.namespaces_xpath)
 
 
 class TestConverter(Base):
@@ -61,179 +62,223 @@ def setup_class(self):
     data = [
         # NB: All the output contain the <info> section, but for a better
         #     readability, I did not wrote it in the snippet except this one
-        ('<page><body><p>Test</p></body></page>',
-         # <article><info><title>Untitled</title></info><simpara>Test</simpara></article>
-         '/article[./info[title="Untitled"]][simpara="Test"]'),
+        (
+            "<page><body><p>Test</p></body></page>",
+            # <article><info><title>Untitled</title></info><simpara>Test</simpara></article>
+            '/article[./info[title="Untitled"]][simpara="Test"]',
+        ),
         # ADMONITION type --> type
-        ('<page><body><admonition page:type="warning"><p>Text</p></admonition></body></page>',
-         # <article><warning><simpara>Text</simpara></warning></article>
-         '/article/warning[simpara="Text"]'),
+        (
+            '<page><body><admonition page:type="warning"><p>Text</p></admonition></body></page>',
+            # <article><warning><simpara>Text</simpara></warning></article>
+            '/article/warning[simpara="Text"]',
+        ),
         # Unknown admonition
-        ('<page><body><admonition page:type="none"><p>Text</p></admonition></body></page>',
-         '/article[simpara="Text"]'),
+        ('<page><body><admonition page:type="none"><p>Text</p></admonition></body></page>', '/article[simpara="Text"]'),
         # XML attributes: we support all the xml standard attributes
-        ('<page><body><p xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>',
-         # <article><simpara xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>
-         '/article/simpara[@xml:base="http://base.tld"][@xml:id="id"][@xml:lang="en"][text()="Text"]'),
+        (
+            '<page><body><p xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>',
+            # <article><simpara xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>
+            '/article/simpara[@xml:base="http://base.tld"][@xml:id="id"][@xml:lang="en"][text()="Text"]',
+        ),
         # Para with title
-        ('<page><body><p html:title="Title">Text</p></body></page>',
-         # <article><simpara xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>
-         '/article/para[text()="Text"][title="Title"]'),
+        (
+            '<page><body><p html:title="Title">Text</p></body></page>',
+            # <article><simpara xml:base="http://base.tld" xml:id="id" xml:lang="en">Text</p></body></page>
+            '/article/para[text()="Text"][title="Title"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_base(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><h page:outline-level="1">Heading 1</h><p>First</p><h page:outline-level="2">Heading 2</h><p>Second</p></body></page>',
-         '/article/sect1[title="Heading 1"][simpara="First"]/sect2[title="Heading 2"][simpara="Second"]'),
+        (
+            '<page><body><h page:outline-level="1">Heading 1</h><p>First</p><h page:outline-level="2">Heading 2</h><p>Second</p></body></page>',
+            '/article/sect1[title="Heading 1"][simpara="First"]/sect2[title="Heading 2"][simpara="Second"]',
+        )
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_title(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Simple unordered list
-        ('<page><body><list page:item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><itemizedlist><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></itemizedlist></article>
-         '/article/itemizedlist[listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><itemizedlist><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></itemizedlist></article>
+            '/article/itemizedlist[listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple ordered list (use default arabic numeration)
-        ('<page><body><list page:item-label-generate="ordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><orderedlist numeration="arabic"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
-         '/article/orderedlist[@numeration="arabic"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="ordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><orderedlist numeration="arabic"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
+            '/article/orderedlist[@numeration="arabic"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple ordered list with upper-alpha numeration
-        ('<page><body><list page:item-label-generate="ordered" page:list-style-type="upper-alpha"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><orderedlist numeration="upperalpha"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
-         '/article/orderedlist[@numeration="upperalpha"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="ordered" page:list-style-type="upper-alpha"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><orderedlist numeration="upperalpha"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
+            '/article/orderedlist[@numeration="upperalpha"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple ordered list with lower-alpha numeration
-        ('<page><body><list page:item-label-generate="ordered" page:list-style-type="lower-alpha"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><orderedlist numeration="loweralpha"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
-         '/article/orderedlist[@numeration="loweralpha"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="ordered" page:list-style-type="lower-alpha"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><orderedlist numeration="loweralpha"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
+            '/article/orderedlist[@numeration="loweralpha"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple ordered list with upper-roman numeration
-        ('<page><body><list page:item-label-generate="ordered" page:list-style-type="upper-roman"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><orderedlist numeration="upperroman"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
-         '/article/orderedlist[@numeration="upperroman"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="ordered" page:list-style-type="upper-roman"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><orderedlist numeration="upperroman"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
+            '/article/orderedlist[@numeration="upperroman"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple ordered list with lower-roman numeration
-        ('<page><body><list page:item-label-generate="ordered" page:list-style-type="lower-roman"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
-         # <article><orderedlist numeration="lowerroman"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
-         '/article/orderedlist[@numeration="lowerroman"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]'),
-
+        (
+            '<page><body><list page:item-label-generate="ordered" page:list-style-type="lower-roman"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+            # <article><orderedlist numeration="lowerroman"><listitem><simpara>Item 1</simpara></listitem><listitem><simpara>Item 2</simpara></listitem></orderedlist></article>
+            '/article/orderedlist[@numeration="lowerroman"][listitem[1]/simpara[text()="Item 1"]][listitem[2]/simpara[text()="Item 2"]]',
+        ),
         # Simple definition list
-        ('<page><body><list><list-item><list-item-label>First Term</list-item-label><list-item-body>First Definition</list-item-body></list-item><list-item><list-item-label>Second Term</list-item-label><list-item-body>Second Definition</list-item-body></list-item></list></body></page>',
-         # <article><variablelist><varlistentry><term>First Term</term><listitem><simpara>First Definition</simpara></listitem></varlistentry><varlistentry><term>Second term</term><listitem><simpara>Second Definition</simpara></listitem></varlistentry></variablelist></article>
-         '/article/variablelist[varlistentry[1][./term[text()="First Term"]][./listitem/simpara[text()="First Definition"]]][varlistentry[2][./term[text()="Second Term"]][./listitem/simpara[text()="Second Definition"]]]')
+        (
+            "<page><body><list><list-item><list-item-label>First Term</list-item-label><list-item-body>First Definition</list-item-body></list-item><list-item><list-item-label>Second Term</list-item-label><list-item-body>Second Definition</list-item-body></list-item></list></body></page>",
+            # <article><variablelist><varlistentry><term>First Term</term><listitem><simpara>First Definition</simpara></listitem></varlistentry><varlistentry><term>Second term</term><listitem><simpara>Second Definition</simpara></listitem></varlistentry></variablelist></article>
+            '/article/variablelist[varlistentry[1][./term[text()="First Term"]][./listitem/simpara[text()="First Definition"]]][varlistentry[2][./term[text()="Second Term"]][./listitem/simpara[text()="Second Definition"]]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_list(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # All the table output caption, just wrote a test and snippet
         # for the two first tests.
-        ('<page><body><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
-         # <article><table><caption>Table 0</caption><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table>
-         '/article/table[caption="Table 0"][thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]'),
-        ('<page><body><table html:title="Title"><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
-         # <article><table><caption>Title</caption><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table>
-         '/article/table[caption="Title"][thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]'),
-        ('<page><body><table><table-body><table-row><table-cell page:number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
-         # <article><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></article>
-         '/article/table/tbody/tr/td[@colspan="2"][text()="Cell"]'),
-        ('<page><body><table><table-body><table-row><table-cell page:number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
-         # <article><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></article>
-         '/article/table/tbody/tr/td[@rowspan="2"][text()="Cell"]'),
+        (
+            "<page><body><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>",
+            # <article><table><caption>Table 0</caption><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table>
+            '/article/table[caption="Table 0"][thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]',
+        ),
+        (
+            '<page><body><table html:title="Title"><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+            # <article><table><caption>Title</caption><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table>
+            '/article/table[caption="Title"][thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]',
+        ),
+        (
+            '<page><body><table><table-body><table-row><table-cell page:number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+            # <article><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></article>
+            '/article/table/tbody/tr/td[@colspan="2"][text()="Cell"]',
+        ),
+        (
+            '<page><body><table><table-body><table-row><table-cell page:number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+            # <article><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></article>
+            '/article/table/tbody/tr/td[@rowspan="2"][text()="Cell"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_table(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Footnote conversion
-        ('<page><body><p>Text simpara<note page:note-class="footnote"><note-body>Text Footnote</note-body></note></p></body></page>',
-         # <article><simpara>Text simpara<footnote>Text Footnote</footnote></simpara></article>
-         '/article/simpara[text()="Text simpara"]/footnote[simpara="Text Footnote"]'),
-
+        (
+            '<page><body><p>Text simpara<note page:note-class="footnote"><note-body>Text Footnote</note-body></note></p></body></page>',
+            # <article><simpara>Text simpara<footnote>Text Footnote</footnote></simpara></article>
+            '/article/simpara[text()="Text simpara"]/footnote[simpara="Text Footnote"]',
+        ),
         # Link conversion
-        ('<page><body><p><a xlink:href="uri:test" xlink:title="title">link</a></p></body></page>',
-         # <article><simpara><link xlink:href="uri:test" xlink:title="title">link</link></simpara></article>
-         '/article/simpara/link[@xlink:href="uri:test"][@xlink:title="title"][text()="link"]'),
-
+        (
+            '<page><body><p><a xlink:href="uri:test" xlink:title="title">link</a></p></body></page>',
+            # <article><simpara><link xlink:href="uri:test" xlink:title="title">link</link></simpara></article>
+            '/article/simpara/link[@xlink:href="uri:test"][@xlink:title="title"][text()="link"]',
+        ),
         # Blockcode conversion into <screen> with CDATA
-        ('<page><body><blockcode>Text</blockcode></body></page>',
-         # <article><screen><![CDATA[Text]]></screen></article>
-         '/article[screen="<![CDATA[Text]]>"]'),
-
+        (
+            "<page><body><blockcode>Text</blockcode></body></page>",
+            # <article><screen><![CDATA[Text]]></screen></article>
+            '/article[screen="<![CDATA[Text]]>"]',
+        ),
         # Code conversion into <literal>
-        ('<page><body><p><code>Text</code></p></body></page>',
-         # <article><simpara><literal>Text</literal></simpara></article>
-         '/article/simpara[literal="Text"]'),
-
+        (
+            "<page><body><p><code>Text</code></p></body></page>",
+            # <article><simpara><literal>Text</literal></simpara></article>
+            '/article/simpara[literal="Text"]',
+        ),
         # SPAN --> PHRASE
-        ('<page><body><p><span>Text</span></p></body></page>',
-         # <article><simpara><phrase>Text</phrase></simpara></article>
-         '/article/simpara[phrase="Text"]'),
-
+        (
+            "<page><body><p><span>Text</span></p></body></page>",
+            # <article><simpara><phrase>Text</phrase></simpara></article>
+            '/article/simpara[phrase="Text"]',
+        ),
         # SPAN baseline-shift=sub --> subscript
-        ('<page><body><p>sub<span page:baseline-shift="sub">sub</span>script</p></body></page>',
-         # <article><simpara>script<subscript>sub</subscript></simpara></article>
-         '/article/simpara[text()="script"][subscript="sub"]'),
-
+        (
+            '<page><body><p>sub<span page:baseline-shift="sub">sub</span>script</p></body></page>',
+            # <article><simpara>script<subscript>sub</subscript></simpara></article>
+            '/article/simpara[text()="script"][subscript="sub"]',
+        ),
         # SPAN baseline-shift=super --> superscript
-        ('<page><body><p>sub<span page:baseline-shift="super">super</span>script</p></body></page>',
-         # <article><simpara>script</simpara><superscript>super</superscript></article>
-         '/article/simpara[text()="script"][superscript="super"]'),
-
+        (
+            '<page><body><p>sub<span page:baseline-shift="super">super</span>script</p></body></page>',
+            # <article><simpara>script</simpara><superscript>super</superscript></article>
+            '/article/simpara[text()="script"][superscript="super"]',
+        ),
         # STRONG --> EMPHASIS role='strong'
-        ('<page><body><p>text<strong>strong</strong></p></body></page>',
-         # <article><simpara>text<emphasis role="strong">strong</emphasis></simpara>
-         '/article/simpara[text()="text"]/emphasis[@role="strong"][text()="strong"]'),
-
+        (
+            "<page><body><p>text<strong>strong</strong></p></body></page>",
+            # <article><simpara>text<emphasis role="strong">strong</emphasis></simpara>
+            '/article/simpara[text()="text"]/emphasis[@role="strong"][text()="strong"]',
+        ),
         # EMPHASIS --> EMPHASIS
-        ('<page><body><p>text<emphasis>emphasis</emphasis></p></body></page>',
-         # <article><simpara>text<emphasis>emphasis</emphasis></simpara>
-         '/article/simpara[text()="text"][emphasis="emphasis"]'),
-
+        (
+            "<page><body><p>text<emphasis>emphasis</emphasis></p></body></page>",
+            # <article><simpara>text<emphasis>emphasis</emphasis></simpara>
+            '/article/simpara[text()="text"][emphasis="emphasis"]',
+        ),
         # LINE-BREAK --> SBR
-        ('<page><body><p>Line 1<line-break />Line 2</p></body></page>',
-         # <article><simpara>Line 1<sbr />Line 2</simpara></article>
-         '/article/simpara[text()="Line 1"]/sbr'),
-
+        (
+            "<page><body><p>Line 1<line-break />Line 2</p></body></page>",
+            # <article><simpara>Line 1<sbr />Line 2</simpara></article>
+            '/article/simpara[text()="Line 1"]/sbr',
+        ),
         # QUOTE --> QUOTE
-        ('<page><body><p>Text<quote>quotation</quote></p></body></page>',
-         # <article><simpara>Text<quote>quotation</quote></simpara></body></page>
-         '/article/simpara[text()="Text"][quote="quotation"]'),
-
+        (
+            "<page><body><p>Text<quote>quotation</quote></p></body></page>",
+            # <article><simpara>Text<quote>quotation</quote></simpara></body></page>
+            '/article/simpara[text()="Text"][quote="quotation"]',
+        ),
         # BLOCKQUOTE --> BLOCKQUOTE
-        ('<page><body><blockquote page:source="Socrates">One thing only I know, and that is that I know nothing.</blockquote></body></page>',
-         # <article><blockquote><attribution>Socrates</attribution><simpara>One thing ... nothing</simpara></blockquote></article>
-         '/article/blockquote[attribution="Socrates"][simpara="One thing only I know, and that is that I know nothing."]'),
+        (
+            '<page><body><blockquote page:source="Socrates">One thing only I know, and that is that I know nothing.</blockquote></body></page>',
+            # <article><blockquote><attribution>Socrates</attribution><simpara>One thing ... nothing</simpara></blockquote></article>
+            '/article/blockquote[attribution="Socrates"][simpara="One thing only I know, and that is that I know nothing."]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_simparagraph_elements(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><p><object xlink:href="pics.png" page:type="image/" /></p></body></page>',
-         # <article><simpara><inlinemediaobject><imageobject><imagedata fileref="pics.png"></imageobject></inlinemediaobject></simpara></article>
-         '/article/simpara/inlinemediaobject/imageobject/imagedata[@fileref="pics.png"]'),
-        ('<page><body><p><object xlink:href="sound.wav" page:type="audio/" /></p></body></page>',
-         # <article><simpara><inlinemediaobject><audioobject><audiodata fileref="sound.wav"></audioobject></inlinemediaobject></simpara></article>
-         '/article/simpara/inlinemediaobject/audioobject/audiodata[@fileref="sound.wav"]'),
-        ('<page><body><p><object xlink:href="video.ogg" page:type="video/" /></p></body></page>',
-         # <article><simpara><inlinemediaobject><videoobject><videodata fileref="video.ogg"></videoobject></inlinemediaobject></simpara></article>
-         '/article/simpara/inlinemediaobject/videoobject/videodata[@fileref="video.ogg"]'),
+        (
+            '<page><body><p><object xlink:href="pics.png" page:type="image/" /></p></body></page>',
+            # <article><simpara><inlinemediaobject><imageobject><imagedata fileref="pics.png"></imageobject></inlinemediaobject></simpara></article>
+            '/article/simpara/inlinemediaobject/imageobject/imagedata[@fileref="pics.png"]',
+        ),
+        (
+            '<page><body><p><object xlink:href="sound.wav" page:type="audio/" /></p></body></page>',
+            # <article><simpara><inlinemediaobject><audioobject><audiodata fileref="sound.wav"></audioobject></inlinemediaobject></simpara></article>
+            '/article/simpara/inlinemediaobject/audioobject/audiodata[@fileref="sound.wav"]',
+        ),
+        (
+            '<page><body><p><object xlink:href="video.ogg" page:type="video/" /></p></body></page>',
+            # <article><simpara><inlinemediaobject><videoobject><videodata fileref="video.ogg"></videoobject></inlinemediaobject></simpara></article>
+            '/article/simpara/inlinemediaobject/videoobject/videodata[@fileref="video.ogg"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_object(self, input, xpath):
         self.do(input, xpath)
diff --git a/src/moin/converters/_tests/test_html_in.py b/src/moin/converters/_tests/test_html_in.py
index 4fd839cfb..56ea2a7c1 100644
--- a/src/moin/converters/_tests/test_html_in.py
+++ b/src/moin/converters/_tests/test_html_in.py
@@ -16,38 +16,30 @@
 from moin.converters.html_in import Converter
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
 class Base:
-    namespaces = {
-        moin_page.namespace: '',
-        xlink.namespace: 'xlink',
-        html.namespace: 'html',
-        xml.namespace: 'xml',
-    }
-
-    namespaces_xpath = {
-        'xlink': xlink.namespace,
-        'html': html.namespace,
-        'xml': xml.namespace,
-    }
+    namespaces = {moin_page.namespace: "", xlink.namespace: "xlink", html.namespace: "html", xml.namespace: "xml"}
+
+    namespaces_xpath = {"xlink": xlink.namespace, "html": html.namespace, "xml": xml.namespace}
 
     output_re = XMLNS_RE3
 
     def handle_input(self, input, args):
         out = self.conv(input, **args)
         output = serialize(out, namespaces=self.namespaces)
-        return self.output_re.sub('', output)
+        return self.output_re.sub("", output)
 
     def do(self, input, path):
         string_to_parse = self.handle_input(input, args={})
         logging.debug(f"After the HTML_IN conversion : {string_to_parse}")
         tree = etree.parse(StringIO(string_to_parse))
-        print('string_to_parse = %s' % string_to_parse)
-        assert (tree.xpath(path, namespaces=self.namespaces_xpath))
+        print("string_to_parse = %s" % string_to_parse)
+        assert tree.xpath(path, namespaces=self.namespaces_xpath)
 
 
 class TestConverter(Base):
@@ -55,240 +47,343 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('<html><div><p>Test</p></div></html>',
-         # <page><body><div><p>Test</p></div></body></page>
-         '/page/body/div[p="Test"]'),
-        ('<html><div><p>First paragraph</p><h1>Title</h1><p><em>Paragraph</em></p></div></html>',
-         # <page><body><div><p>First paragraph</p><h outline-level="1">Title</h><p><emphasis>Paragraph</em></p></div></page></body>
-         '/page/body/div/p[2][emphasis="Paragraph"]'),
-        ('<html><div><p>First Line<br />Second Line</p></div></html>',
-         # <page><body><div>First Line<line-break />Second Line></div></body></page>
-         '/page/body/div/p[1]/line-break'),
-        ('<html><div><p>First Paragraph</p><hr /><p>Second Paragraph</p></div></html>',
-         # <page><body><div><p>First Paragraph</p><hr /><p>Second Paragraph</p></div></html>
-         '/page/body/div/separator'),
-        ('<div><p>Test</p></div>',
-         # <page><body><div><p>Test</p></div></body></page>
-         '/page/body/div[p="Test"]'),
+        (
+            "<html><div><p>Test</p></div></html>",
+            # <page><body><div><p>Test</p></div></body></page>
+            '/page/body/div[p="Test"]',
+        ),
+        (
+            "<html><div><p>First paragraph</p><h1>Title</h1><p><em>Paragraph</em></p></div></html>",
+            # <page><body><div><p>First paragraph</p><h outline-level="1">Title</h><p><emphasis>Paragraph</em></p></div></page></body>
+            '/page/body/div/p[2][emphasis="Paragraph"]',
+        ),
+        (
+            "<html><div><p>First Line<br />Second Line</p></div></html>",
+            # <page><body><div>First Line<line-break />Second Line></div></body></page>
+            "/page/body/div/p[1]/line-break",
+        ),
+        (
+            "<html><div><p>First Paragraph</p><hr /><p>Second Paragraph</p></div></html>",
+            # <page><body><div><p>First Paragraph</p><hr /><p>Second Paragraph</p></div></html>
+            "/page/body/div/separator",
+        ),
+        (
+            "<div><p>Test</p></div>",
+            # <page><body><div><p>Test</p></div></body></page>
+            '/page/body/div[p="Test"]',
+        ),
         # Test attributes conversion
-        ('<div><p class="class text" style="style text" title="title text">Test</p></div>',
-         # <page><body><div><p html:class="class text" html:style="style text" html:title="title text">Test</p></div></body></page>
-         '/page/body/div/p[@html:class="class text"][@html:style="style text"][@html:title="title text"][text()="Test"]'),
+        (
+            '<div><p class="class text" style="style text" title="title text">Test</p></div>',
+            # <page><body><div><p html:class="class text" html:style="style text" html:title="title text">Test</p></div></body></page>
+            '/page/body/div/p[@html:class="class text"][@html:style="style text"][@html:title="title text"][text()="Test"]',
+        ),
         # Test id
-        ('<div><p id="first">Text<strong id="second">strong</strong></p></div>',
-         # <page><body><div><p xml:id="first">Text<strong xml:id="second">strong</strong></p></div></body></page>
-         '/page/body/div/p[@xml:id="first"][text()="Text"]/strong[@xml:id="second"][text()="strong"]'),
+        (
+            '<div><p id="first">Text<strong id="second">strong</strong></p></div>',
+            # <page><body><div><p xml:id="first">Text<strong xml:id="second">strong</strong></p></div></body></page>
+            '/page/body/div/p[@xml:id="first"][text()="Text"]/strong[@xml:id="second"][text()="strong"]',
+        ),
         # test trailing div part 1
-        ('<p>Paragraph</p><div>Div</div>',
-         # <page><body><p>paragraph</p><div>div</div></body></page>
-         '/page/body[p="Paragraph"]'),
+        (
+            "<p>Paragraph</p><div>Div</div>",
+            # <page><body><p>paragraph</p><div>div</div></body></page>
+            '/page/body[p="Paragraph"]',
+        ),
         # test trailing div part 2
-        ('<p>Paragraph</p><div>Div</div>',
-         # <page><body><p>paragraph</p><div>div</div></body></page>
-         '/page/body/div/text()="Div"'),
+        (
+            "<p>Paragraph</p><div>Div</div>",
+            # <page><body><p>paragraph</p><div>div</div></body></page>
+            '/page/body/div/text()="Div"',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_base(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><h2>Test</h2></html>',
-         # <page><body><h outline-level="2">Test</h></body></page>
-         '/page/body/h[text()="Test"][@outline-level=2]'),
-        ('<html><h6>Test</h6></html>',
-         # <page><body><h outline-level="6">Test</h></body></page>
-         '/page/body/h[text()="Test"][@outline-level=6]'),
+        (
+            "<html><h2>Test</h2></html>",
+            # <page><body><h outline-level="2">Test</h></body></page>
+            '/page/body/h[text()="Test"][@outline-level=2]',
+        ),
+        (
+            "<html><h6>Test</h6></html>",
+            # <page><body><h outline-level="6">Test</h></body></page>
+            '/page/body/h[text()="Test"][@outline-level=6]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_title(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><em>Test</em></p></html>',
-         # <page><body><p><emphasis>Test</emphasis></body></page>
-         '/page/body/p[emphasis="Test"]'),
-        ('<html><p><i>Test</i></p></html>',
-         # <page><body><p><emphasis>Test</emphasis></body></page>
-         '/page/body/p[emphasis="Test"]'),
-        ('<html><p><strong>Test</strong></p></html>',
-         # <page><body><p><strong>Test</strong></p></body></page>
-         '/page/body/p[strong="Test"]'),
-        ('<html><p><b>Test</b></p></html>',
-         # <page><body><p><strong>Test</strong></p></body></page>
-         '/page/body/p[strong="Test"]'),
+        (
+            "<html><p><em>Test</em></p></html>",
+            # <page><body><p><emphasis>Test</emphasis></body></page>
+            '/page/body/p[emphasis="Test"]',
+        ),
+        (
+            "<html><p><i>Test</i></p></html>",
+            # <page><body><p><emphasis>Test</emphasis></body></page>
+            '/page/body/p[emphasis="Test"]',
+        ),
+        (
+            "<html><p><strong>Test</strong></p></html>",
+            # <page><body><p><strong>Test</strong></p></body></page>
+            '/page/body/p[strong="Test"]',
+        ),
+        (
+            "<html><p><b>Test</b></p></html>",
+            # <page><body><p><strong>Test</strong></p></body></page>
+            '/page/body/p[strong="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_basic_style(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><sub>sub</sub>script</p></html>',
-         # <page><body><p><span baseline-shift="sub">sub</span></p></body></page>
-         '/page/body/p/span[text()="sub"][@baseline-shift="sub"]'),
-        ('<html><p><sup>super</sup>script</p></html>',
-         # <page><body><p><span baseline-shift="super">super</span></p></body></page>
-         '/page/body/p/span[text()="super"][@baseline-shift="super"]'),
-        ('<html><p><u>underline</u></p></html>',
-         # <page><body><p><u>underline</u></p></body></page>
-         '/page/body/p/u[text()="underline"]'),
-        ('<html><p><big>Test</big></p></html>',
-         # <page><body><p><span font-size="120%">Test</span></p></body></page>
-         '/page/body/p/span[text()="Test"][@font-size="120%"]'),
-        ('<html><p><small>Test</small></p></html>',
-         # <page><body><p><span font-size="85%">Test</span></p></body></page>
-         '/page/body/p/span[text()="Test"][@font-size="85%"]'),
-        ('<html><p><ins>underline</ins></p></html>',
-         # <page><body><p><ins>underline</ins></p></body></page>
-         '/page/body/p/ins[text()="underline"]'),
-        ('<html><p><del>Test</del></p></html>',
-         # <page><body><p><del>Test</del></p></body></page>
-         '/page/body/p/del[text()="Test"]'),
-        ('<html><p><s>Test</s></p></html>',
-         # <page><body><p><s>Test</s></p></body></page>
-         '/page/body/p/s[text()="Test"]'),
-        ('<html><p><strike>Test</strike></p></html>',
-         # <page><body><p><s>Test</s></p></body></page>
-         '/page/body/p/s[text()="Test"]'),
+        (
+            "<html><p><sub>sub</sub>script</p></html>",
+            # <page><body><p><span baseline-shift="sub">sub</span></p></body></page>
+            '/page/body/p/span[text()="sub"][@baseline-shift="sub"]',
+        ),
+        (
+            "<html><p><sup>super</sup>script</p></html>",
+            # <page><body><p><span baseline-shift="super">super</span></p></body></page>
+            '/page/body/p/span[text()="super"][@baseline-shift="super"]',
+        ),
+        (
+            "<html><p><u>underline</u></p></html>",
+            # <page><body><p><u>underline</u></p></body></page>
+            '/page/body/p/u[text()="underline"]',
+        ),
+        (
+            "<html><p><big>Test</big></p></html>",
+            # <page><body><p><span font-size="120%">Test</span></p></body></page>
+            '/page/body/p/span[text()="Test"][@font-size="120%"]',
+        ),
+        (
+            "<html><p><small>Test</small></p></html>",
+            # <page><body><p><span font-size="85%">Test</span></p></body></page>
+            '/page/body/p/span[text()="Test"][@font-size="85%"]',
+        ),
+        (
+            "<html><p><ins>underline</ins></p></html>",
+            # <page><body><p><ins>underline</ins></p></body></page>
+            '/page/body/p/ins[text()="underline"]',
+        ),
+        (
+            "<html><p><del>Test</del></p></html>",
+            # <page><body><p><del>Test</del></p></body></page>
+            '/page/body/p/del[text()="Test"]',
+        ),
+        (
+            "<html><p><s>Test</s></p></html>",
+            # <page><body><p><s>Test</s></p></body></page>
+            '/page/body/p/s[text()="Test"]',
+        ),
+        (
+            "<html><p><strike>Test</strike></p></html>",
+            # <page><body><p><s>Test</s></p></body></page>
+            '/page/body/p/s[text()="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_span(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><abbr>Text</abbr></p></html>',
-         # <page><body><span html:class="html-abbr">Text</span></body></page>
-         '/page/body/p/span[text()="Text"][@html:class="html-abbr"]'),
-        ('<html><p><acronym>Text</acronym></p></html>',
-         # <page><body><span html:class="html-acronym">Text</span></body></page>
-         '/page/body/p/span[text()="Text"][@html:class="html-acronym"]'),
-        ('<html><p><address>Text</address></p></html>',
-         # <page><body><span html:class="html-address">Text</span></body></page>
-         '/page/body/p/span[text()="Text"][@html:class="html-address"]'),
-        ('<html><p><dfn>Text</dfn></p></html>',
-         # <page><body><span html:class="html-dfn">Text</span></body></page>
-         '/page/body/p/span[text()="Text"][@html:class="html-dfn"]'),
-        ('<html><p><kbd>Text</kbd></p></html>',
-         # <page><body><span html:class="html-kbd">Text</span></body></page>
-         '/page/body/p/span[text()="Text"][@html:class="html-kbd"]'),
+        (
+            "<html><p><abbr>Text</abbr></p></html>",
+            # <page><body><span html:class="html-abbr">Text</span></body></page>
+            '/page/body/p/span[text()="Text"][@html:class="html-abbr"]',
+        ),
+        (
+            "<html><p><acronym>Text</acronym></p></html>",
+            # <page><body><span html:class="html-acronym">Text</span></body></page>
+            '/page/body/p/span[text()="Text"][@html:class="html-acronym"]',
+        ),
+        (
+            "<html><p><address>Text</address></p></html>",
+            # <page><body><span html:class="html-address">Text</span></body></page>
+            '/page/body/p/span[text()="Text"][@html:class="html-address"]',
+        ),
+        (
+            "<html><p><dfn>Text</dfn></p></html>",
+            # <page><body><span html:class="html-dfn">Text</span></body></page>
+            '/page/body/p/span[text()="Text"][@html:class="html-dfn"]',
+        ),
+        (
+            "<html><p><kbd>Text</kbd></p></html>",
+            # <page><body><span html:class="html-kbd">Text</span></body></page>
+            '/page/body/p/span[text()="Text"][@html:class="html-kbd"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_span_html_element(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><a href="http:test">Test</a></p></html>',
-         # <page><body><p><a xlink:href="http:test">Test</a></p></body></page>
-         '/page/body/p/a[text()="Test"][@xlink:href="http:test"]'),
-        ('<html><base href="http://www.base-url.com/" /><body><div><p><a href="myPage.html">Test</a></p></div></body></html>',
-         # <page><body><div><p><a xlink:href="http://www.base-url.com/myPage.html">Test</a></p></div></body></page>
-         '/page/body/div/p/a[@xlink:href="http://www.base-url.com/myPage.html"]'),
-
+        (
+            '<html><p><a href="http:test">Test</a></p></html>',
+            # <page><body><p><a xlink:href="http:test">Test</a></p></body></page>
+            '/page/body/p/a[text()="Test"][@xlink:href="http:test"]',
+        ),
+        (
+            '<html><base href="http://www.base-url.com/" /><body><div><p><a href="myPage.html">Test</a></p></div></body></html>',
+            # <page><body><div><p><a xlink:href="http://www.base-url.com/myPage.html">Test</a></p></div></body></page>
+            '/page/body/div/p/a[@xlink:href="http://www.base-url.com/myPage.html"]',
+        ),
         # verify invalid or forbidden uri schemes are removed
-        ('''<html><p><a href="javascript:alert('hi')">Test</a></p></html>''',
-         # <page><body><p>javascript:alert('hi')</p></body></page>
-         '''/page/body/p[text()="javascript:alert('hi')"]'''),
+        (
+            """<html><p><a href="javascript:alert('hi')">Test</a></p></html>""",
+            # <page><body><p>javascript:alert('hi')</p></body></page>
+            """/page/body/p[text()="javascript:alert('hi')"]""",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_link(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><code>Code</code></div></html>',
-         # <page><body><div><code>Code</code></div></body></page>
-         '/page/body/div[code="Code"]'),
-        ('<html><div><samp>Code</samp></div></html>',
-         # <page><body><div><code>Code</code></div></body></page>
-         '/page/body/div[code="Code"]'),
-        ('<html><pre>Code</pre></html>',
-         # <page><body><blockcode>Code</blockcode></body></page>
-         '/page/body[blockcode="Code"]'),
-        ('<html><p><tt>Code</tt></p></html>',
-         # <page><body><p><code>Code</code></p></body></page>
-         '/page/body/p[code="Code"]'),
+        (
+            "<html><div><code>Code</code></div></html>",
+            # <page><body><div><code>Code</code></div></body></page>
+            '/page/body/div[code="Code"]',
+        ),
+        (
+            "<html><div><samp>Code</samp></div></html>",
+            # <page><body><div><code>Code</code></div></body></page>
+            '/page/body/div[code="Code"]',
+        ),
+        (
+            "<html><pre>Code</pre></html>",
+            # <page><body><blockcode>Code</blockcode></body></page>
+            '/page/body[blockcode="Code"]',
+        ),
+        (
+            "<html><p><tt>Code</tt></p></html>",
+            # <page><body><p><code>Code</code></p></body></page>
+            '/page/body/p[code="Code"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_code(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><p><quote>Inline quote</quote></p></div></html>',
-         # <page><body><div><p><quote>Inline quote</quote></p></body></page>
-         '/page/body/div/p[quote="Inline quote"]'),
-        ('<html><div><blockquote>Block quote</blockquote></div></html>',
-         # <page><body><div><blockquote>Block quote</blockquote></body></page>
-         '/page/body/div[blockquote="Block quote"]'),
+        (
+            "<html><div><p><quote>Inline quote</quote></p></div></html>",
+            # <page><body><div><p><quote>Inline quote</quote></p></body></page>
+            '/page/body/div/p[quote="Inline quote"]',
+        ),
+        (
+            "<html><div><blockquote>Block quote</blockquote></div></html>",
+            # <page><body><div><blockquote>Block quote</blockquote></body></page>
+            '/page/body/div[blockquote="Block quote"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_quote(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><ul><li>Item</li></ul></div></html>',
-         # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="unordered"]/list-item[list-item-body="Item"]'),
-        ('<html><div><ol><li>Item</li></ol></div></html>',
-         # <page><body><div><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="ordered"]/list-item[list-item-body="Item"]'),
-        ('<html><div><ol type="A"><li>Item</li></ol></div></html>',
-         # <page><body><div><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="upper-alpha"]/list-item[list-item-body="Item"]'),
-        ('<html><div><ol type="I"><li>Item</li></ol></div></html>',
-         # <page><body><div><list item-label-generate="ordered" list-style-type="upper-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="upper-roman"]/list-item[list-item-body="Item"]'),
-        ('<html><div><ol type="a"><li>Item</li></ol></div></html>',
-         # <page><body><div><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="lower-alpha"]/list-item[list-item-body="Item"]'),
-        ('<html><div><ol type="i"><li>Item</li></ol></div></html>',
-         # <page><body><div><list item-label-generate="ordered" list-style-type="lower-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="lower-roman"]/list-item[list-item-body="Item"]'),
-        ('<html><div><dl><dt>Label</dt><dd>Item</dd></dl></div></html>',
-         # <page><body><div><list><list-item><list-item-label>Label</list-item-label><list-item-body>Item</list-item-body></list-item></list></div></body></page>
-         '/page/body/div/list/list-item[list-item-label="Label"][list-item-body="Item"]'),
-        ('<html><div><dir><li>Item</li></dir></div></html>',
-         # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="unordered"]/list-item[list-item-body="Item"]'),
-        ('<div><ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul></div>',
-         # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item><list-item><list-item-body>Item 3</list-item-body></list-item></list></div></page></body></page>
-         '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Item 1"]][list-item[2]/list-item-body[text()="Item 2"]][list-item[3]/list-item-body[text()="Item 3"]]'),
+        (
+            "<html><div><ul><li>Item</li></ul></div></html>",
+            # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="unordered"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            "<html><div><ol><li>Item</li></ol></div></html>",
+            # <page><body><div><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="ordered"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            '<html><div><ol type="A"><li>Item</li></ol></div></html>',
+            # <page><body><div><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="upper-alpha"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            '<html><div><ol type="I"><li>Item</li></ol></div></html>',
+            # <page><body><div><list item-label-generate="ordered" list-style-type="upper-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="upper-roman"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            '<html><div><ol type="a"><li>Item</li></ol></div></html>',
+            # <page><body><div><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="lower-alpha"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            '<html><div><ol type="i"><li>Item</li></ol></div></html>',
+            # <page><body><div><list item-label-generate="ordered" list-style-type="lower-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="ordered" and @list-style-type="lower-roman"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            "<html><div><dl><dt>Label</dt><dd>Item</dd></dl></div></html>",
+            # <page><body><div><list><list-item><list-item-label>Label</list-item-label><list-item-body>Item</list-item-body></list-item></list></div></body></page>
+            '/page/body/div/list/list-item[list-item-label="Label"][list-item-body="Item"]',
+        ),
+        (
+            "<html><div><dir><li>Item</li></dir></div></html>",
+            # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="unordered"]/list-item[list-item-body="Item"]',
+        ),
+        (
+            "<div><ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul></div>",
+            # <page><body><div><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item><list-item><list-item-body>Item 3</list-item-body></list-item></list></div></page></body></page>
+            '/page/body/div/list[@item-label-generate="unordered"][list-item[1]/list-item-body[text()="Item 1"]][list-item[2]/list-item-body[text()="Item 2"]][list-item[3]/list-item-body[text()="Item 3"]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_list(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><img src="uri:test" /></div></html>',
-         # <page><body><div><object xlink:href="uri:test" /></div></body></page>
-         '/page/body/div/object/@xlink:href="uri:test"'),
-        ('<html><div><object data="href"></object></div></html>',
-         # <page><body><div><object xlink:href="href" /></div></body></page>
-         '/page/body/div/object/@xlink:href="href"'),
+        (
+            '<html><div><img src="uri:test" /></div></html>',
+            # <page><body><div><object xlink:href="uri:test" /></div></body></page>
+            '/page/body/div/object/@xlink:href="uri:test"',
+        ),
+        (
+            '<html><div><object data="href"></object></div></html>',
+            # <page><body><div><object xlink:href="href" /></div></body></page>
+            '/page/body/div/object/@xlink:href="href"',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_object(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></div></html>',
-         # <page><body><div><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></div></body></page>
-         '/page/body/div/table[./table-header/table-row[table-cell="Header"]][./table-footer/table-row[table-cell="Footer"]][./table-body/table-row[table-cell="Cell"]]'),
-        ('<html><div><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></div></html>',
-         # <page><body><div><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>
-         '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-columns-spanned="2"]'),
-        ('<html><div><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></div></html>',
-         # <page><body><div><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>
-         '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-rows-spanned="2"]'),
+        (
+            "<html><div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></div></html>",
+            # <page><body><div><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></div></body></page>
+            '/page/body/div/table[./table-header/table-row[table-cell="Header"]][./table-footer/table-row[table-cell="Footer"]][./table-body/table-row[table-cell="Cell"]]',
+        ),
+        (
+            '<html><div><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></div></html>',
+            # <page><body><div><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>
+            '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-columns-spanned="2"]',
+        ),
+        (
+            '<html><div><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></div></html>',
+            # <page><body><div><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>
+            '/page/body/div/table/table-body/table-row/table-cell[text()="Cell"][@number-rows-spanned="2"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_table(self, input, xpath):
         self.do(input, xpath)
diff --git a/src/moin/converters/_tests/test_html_in_out.py b/src/moin/converters/_tests/test_html_in_out.py
index 3ec1d47f2..96dedbb28 100644
--- a/src/moin/converters/_tests/test_html_in_out.py
+++ b/src/moin/converters/_tests/test_html_in_out.py
@@ -19,35 +19,32 @@
 from moin.utils.tree import html, moin_page, xlink
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
 class Base:
 
-    namespaces = {
-        html.namespace: '',
-        moin_page.namespace: '',
-        xlink.namespace: 'xlink',
-    }
+    namespaces = {html.namespace: "", moin_page.namespace: "", xlink.namespace: "xlink"}
 
     output_re = XMLNS_RE3
 
     def handle_input(self, input, args):
         out = self.conv_html_dom(input, **args)
         output = serialize(out, namespaces=self.namespaces)
-        logging.debug("After the HTML_IN conversion : {}".format(self.output_re.sub('', output)))
+        logging.debug("After the HTML_IN conversion : {}".format(self.output_re.sub("", output)))
         out = self.conv_dom_html(out, **args)
         output = serialize(out, namespaces=self.namespaces)
-        return self.output_re.sub('', output)
+        return self.output_re.sub("", output)
 
     def do(self, input, path):
         string_to_parse = self.handle_input(input, args={})
         logging.debug(f"After the roundtrip : {string_to_parse}")
-        print('string_to_parse = %s' % string_to_parse)
+        print("string_to_parse = %s" % string_to_parse)
         tree = etree.parse(StringIO(string_to_parse))
-        assert (tree.xpath(path))
+        assert tree.xpath(path)
 
 
 class TestConverter(Base):
@@ -56,173 +53,175 @@ def setup_class(self):
         self.conv_dom_html = HTML_OUT()
 
     data = [
-        ('<html><div><p>Test</p></div></html>',
-         '/div/div[p="Test"]'),
-        ('<html><div><p>First paragraph</p><h1>Title</h1><p><em>Paragraph</em></p></div></html>',
-         '/div/div/p[2][em="Paragraph"]'),
-        ('<html><div><p>First Line<br />Second line</p></div></html>',
-         '/div/div/p[1]/br'),
-        ('<div><p>Test</p></div>',
-         '/div/div[p="Test"]'),
-        ('<div><p class="class" title="title">Test</p></div>',
-         '/div/div/p[@class="class"][@title="title"][text()="Test"]'),
+        ("<html><div><p>Test</p></div></html>", '/div/div[p="Test"]'),
+        (
+            "<html><div><p>First paragraph</p><h1>Title</h1><p><em>Paragraph</em></p></div></html>",
+            '/div/div/p[2][em="Paragraph"]',
+        ),
+        ("<html><div><p>First Line<br />Second line</p></div></html>", "/div/div/p[1]/br"),
+        ("<div><p>Test</p></div>", '/div/div[p="Test"]'),
+        (
+            '<div><p class="class" title="title">Test</p></div>',
+            '/div/div/p[@class="class"][@title="title"][text()="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_base(self, input, xpath):
         self.do(input, xpath)
 
-    data = [
-        ('<html><h2>Test</h2></html>',
-         '/div[h2="Test"]'),
-        ('<html><h6>Test</h6></html>',
-         '/div[h6="Test"]'),
-    ]
+    data = [("<html><h2>Test</h2></html>", '/div[h2="Test"]'), ("<html><h6>Test</h6></html>", '/div[h6="Test"]')]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_title(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><em>Test</em></p></html>',
-         '/div/p[em="Test"]'),
-        ('<html><p><i>Test</i></p></html>',
-         '/div/p[em="Test"]'),
-        ('<html><p><strong>Test</strong></p></html>',
-         '/div/p[strong="Test"]'),
-        ('<html><p><b>Test</b></p></html>',
-         '/div/p[strong="Test"]'),
+        ("<html><p><em>Test</em></p></html>", '/div/p[em="Test"]'),
+        ("<html><p><i>Test</i></p></html>", '/div/p[em="Test"]'),
+        ("<html><p><strong>Test</strong></p></html>", '/div/p[strong="Test"]'),
+        ("<html><p><b>Test</b></p></html>", '/div/p[strong="Test"]'),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_basic_style(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><sub>sub</sub>script</p></html>',
-         '/div/p[sub="sub"]'),
-        ('<html><p><sup>super</sup>script</p></html>',
-         '/div/p[sup="super"]'),
-        ('<html><p><u>underline</u></p></html>',
-         # <div><p><u>underline</u></p></div>
-         '/div/p/u [text()="underline"]'),
-        ('<html><p><big>Test</big></p></html>',
-         '/div/p/span[@class="moin-big"][text()="Test"]'),
-        ('<html><p><small>Test</small></p></html>',
-         '/div/p/span[@class="moin-small"][text()="Test"]'),
-        ('<html><p><ins>underline</ins></p></html>',
-         # <div><p><ins>underline</ins></p></div>
-         '/div/p/ins [text()="underline"]'),
-        ('<html><p><del>Test</del></p></html>',
-         '/div/p[del="Test"]'),
-        ('<html><p><s>Test</s></p></html>',
-         # <div><p><s>Test</s></p></div>
-         '/div/p/s [text()="Test"]'),
-        ('<html><p><strike>Test</strike></p></html>',
-         # <div><p><s>Test</s></p></div>
-         '/div/p/s [text()="Test"]'),
+        ("<html><p><sub>sub</sub>script</p></html>", '/div/p[sub="sub"]'),
+        ("<html><p><sup>super</sup>script</p></html>", '/div/p[sup="super"]'),
+        (
+            "<html><p><u>underline</u></p></html>",
+            # <div><p><u>underline</u></p></div>
+            '/div/p/u [text()="underline"]',
+        ),
+        ("<html><p><big>Test</big></p></html>", '/div/p/span[@class="moin-big"][text()="Test"]'),
+        ("<html><p><small>Test</small></p></html>", '/div/p/span[@class="moin-small"][text()="Test"]'),
+        (
+            "<html><p><ins>underline</ins></p></html>",
+            # <div><p><ins>underline</ins></p></div>
+            '/div/p/ins [text()="underline"]',
+        ),
+        ("<html><p><del>Test</del></p></html>", '/div/p[del="Test"]'),
+        (
+            "<html><p><s>Test</s></p></html>",
+            # <div><p><s>Test</s></p></div>
+            '/div/p/s [text()="Test"]',
+        ),
+        (
+            "<html><p><strike>Test</strike></p></html>",
+            # <div><p><s>Test</s></p></div>
+            '/div/p/s [text()="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_span(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><p><abbr>Text</abbr></p></html>',
-         '/div/p/span[@class="html-abbr"][text()="Text"]'),
-        ('<html><p><acronym>Text</acronym></p></html>',
-         '/div/p/span[@class="html-acronym"][text()="Text"]'),
-        ('<html><p><address>Text</address></p></html>',
-         '/div/p/span[@class="html-address"][text()="Text"]'),
-        ('<html><p><dfn>Text</dfn></p></html>',
-         '/div/p/span[@class="html-dfn"][text()="Text"]'),
-        ('<html><p><kbd>Text</kbd></p></html>',
-         '/div/p/span[@class="html-kbd"][text()="Text"]'),
+        ("<html><p><abbr>Text</abbr></p></html>", '/div/p/span[@class="html-abbr"][text()="Text"]'),
+        ("<html><p><acronym>Text</acronym></p></html>", '/div/p/span[@class="html-acronym"][text()="Text"]'),
+        ("<html><p><address>Text</address></p></html>", '/div/p/span[@class="html-address"][text()="Text"]'),
+        ("<html><p><dfn>Text</dfn></p></html>", '/div/p/span[@class="html-dfn"][text()="Text"]'),
+        ("<html><p><kbd>Text</kbd></p></html>", '/div/p/span[@class="html-kbd"][text()="Text"]'),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_span_html_element(self, input, xpath):
         self.do(input, xpath)
 
-    data = [
-        ('<html><p><a href="http:test">Test</a></p></html>',
-         '/div/p/a[text()="Test"][@href="http:test"]'),
-    ]
+    data = [('<html><p><a href="http:test">Test</a></p></html>', '/div/p/a[text()="Test"][@href="http:test"]')]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_link(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><code>Code</code></div></html>',
-         '/div/div[code="Code"]'),
-        ('<html><div><samp>Code</samp></div></html>',
-         '/div/div[code="Code"]'),
-        ('<html><pre>Code</pre></html>',
-         '/div[pre="Code"]'),
-        ('<html><p><tt>Code</tt></p></html>',
-         '/div/p[code="Code"]'),
+        ("<html><div><code>Code</code></div></html>", '/div/div[code="Code"]'),
+        ("<html><div><samp>Code</samp></div></html>", '/div/div[code="Code"]'),
+        ("<html><pre>Code</pre></html>", '/div[pre="Code"]'),
+        ("<html><p><tt>Code</tt></p></html>", '/div/p[code="Code"]'),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_code(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><ul><li>Item</li></ul></div></html>',
-         '/div/div/ul[li="Item"]'),
-        ('<html><div><ol><li>Item</li></ol></div></html>',
-         '/div/div/ol[li="Item"]'),
-        ('<html><div><ol type="A"><li>Item</li></ol></div></html>',
-         '/div/div/ol[@class="moin-upperalpha-list"][li="Item"]'),
-        ('<html><div><ol type="I"><li>Item</li></ol></div></html>',
-         '/div/div/ol[@class="moin-upperroman-list"][li="Item"]'),
-        ('<html><div><ol type="a"><li>Item</li></ol></div></html>',
-         '/div/div/ol[@class="moin-loweralpha-list"][li="Item"]'),
-        ('<html><div><ol type="i"><li>Item<li></ol></div></html>',
-         '/div/div/ol[@class="moin-lowerroman-list"][li="Item"]'),
-        ('<html><div><dl><dt>Label</dt><dd>Item</dd></dl></div></html>',
-         '/div/div/dl[dt="Label"][dd="Item"]'),
-        ('<html><div><dir><li>Item</li></dir></div></html>',
-         '/div/div/ul[li="Item"]'),
-        ('<div><ul><li>Item 1</li><p>Pouet</p><li>Item 2</li><li>Item 3</li></ul></div>',
-         '/div/div/ul[li[1]="Item 1"][li[2]="Item 2"][li[3]="Item 3"]'),
+        ("<html><div><ul><li>Item</li></ul></div></html>", '/div/div/ul[li="Item"]'),
+        ("<html><div><ol><li>Item</li></ol></div></html>", '/div/div/ol[li="Item"]'),
+        (
+            '<html><div><ol type="A"><li>Item</li></ol></div></html>',
+            '/div/div/ol[@class="moin-upperalpha-list"][li="Item"]',
+        ),
+        (
+            '<html><div><ol type="I"><li>Item</li></ol></div></html>',
+            '/div/div/ol[@class="moin-upperroman-list"][li="Item"]',
+        ),
+        (
+            '<html><div><ol type="a"><li>Item</li></ol></div></html>',
+            '/div/div/ol[@class="moin-loweralpha-list"][li="Item"]',
+        ),
+        (
+            '<html><div><ol type="i"><li>Item<li></ol></div></html>',
+            '/div/div/ol[@class="moin-lowerroman-list"][li="Item"]',
+        ),
+        ("<html><div><dl><dt>Label</dt><dd>Item</dd></dl></div></html>", '/div/div/dl[dt="Label"][dd="Item"]'),
+        ("<html><div><dir><li>Item</li></dir></div></html>", '/div/div/ul[li="Item"]'),
+        (
+            "<div><ul><li>Item 1</li><p>Pouet</p><li>Item 2</li><li>Item 3</li></ul></div>",
+            '/div/div/ul[li[1]="Item 1"][li[2]="Item 2"][li[3]="Item 3"]',
+        ),
         # Test for bug with line return and spaces
-        ('<div><ul><li>\n Item 1</li>\n<li>\n Item 2</li>\n<li>\n Item 3</li>\n</ul></div>',
-         '/div/div/ul[li[1]="\n Item 1"][li[2]="\n Item 2"][li[3]="\n Item 3"]'),
-        ('<div><ol><li>\n Item 1</li>\n<li>\n Item 2</li>\n<li>\n Item 3</li>\n</ol></div>',
-         '/div/div/ol[li[1]="\n Item 1"][li[2]="\n Item 2"][li[3]="\n Item 3"]'),
+        (
+            "<div><ul><li>\n Item 1</li>\n<li>\n Item 2</li>\n<li>\n Item 3</li>\n</ul></div>",
+            '/div/div/ul[li[1]="\n Item 1"][li[2]="\n Item 2"][li[3]="\n Item 3"]',
+        ),
+        (
+            "<div><ol><li>\n Item 1</li>\n<li>\n Item 2</li>\n<li>\n Item 3</li>\n</ol></div>",
+            '/div/div/ol[li[1]="\n Item 1"][li[2]="\n Item 2"][li[3]="\n Item 3"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_list(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # ('<html><div><img src="uri:test" /></div></html>',
         #  '/page/body/div/object/@xlink:href="uri:test"'),
-        ('<html><div><object data="href"></object></div></html>',
-         '/div/div/object[@data="href"]'),
+        ('<html><div><object data="href"></object></div></html>', '/div/div/object[@data="href"]')
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_object(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<html><div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></div></html>',
-         '/div/div/table[./thead/tr[td="Header"]][./tfoot/tr[td="Footer"]][./tbody/tr[td="Cell"]]'),
-        ('<html><div><table><thead><tr><td>Header</td></tr></thead><tbody><tr><td>Cell</td></tr></tbody><tfoot><tr><td>Footer</td></tr></tfoot></table></div></html>',
-         '/div/div/table[./thead/tr[td="Header"]][./tfoot/tr[td="Footer"]][./tbody/tr[td="Cell"]]'),
-        ('<html><div><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></div></html>',
-         '/div/div/table/tbody/tr/td[text()="Cell"][@colspan="2"]'),
-        ('<html><div><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></div></html>',
-         '/div/div/table/tbody/tr/td[text()="Cell"][@rowspan="2"]'),
+        (
+            "<html><div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tbody><tr><td>Cell</td></tr></tbody></table></div></html>",
+            '/div/div/table[./thead/tr[td="Header"]][./tfoot/tr[td="Footer"]][./tbody/tr[td="Cell"]]',
+        ),
+        (
+            "<html><div><table><thead><tr><td>Header</td></tr></thead><tbody><tr><td>Cell</td></tr></tbody><tfoot><tr><td>Footer</td></tr></tfoot></table></div></html>",
+            '/div/div/table[./thead/tr[td="Header"]][./tfoot/tr[td="Footer"]][./tbody/tr[td="Cell"]]',
+        ),
+        (
+            '<html><div><table><tbody><tr><td colspan="2">Cell</td></tr></tbody></table></div></html>',
+            '/div/div/table/tbody/tr/td[text()="Cell"][@colspan="2"]',
+        ),
+        (
+            '<html><div><table><tbody><tr><td rowspan="2">Cell</td></tr></tbody></table></div></html>',
+            '/div/div/table/tbody/tr/td[text()="Cell"][@rowspan="2"]',
+        ),
         # Test for bug with newline between cell
-        ('<div><table>\n<tbody>\n<tr>\n<td>\n Cell 1:1</td>\n<td>\n Cell 1:2</td>\n</tr>\n<tr>\n<td>\n Cell 2:1</td>\n<td>\n Cell 2:2</td>\n</tr>\n</tbody>\n</table></div>',
-         '/div/div/table/tbody[tr[1][td[1]="\n Cell 1:1"][td[2]="\n Cell 1:2"]][tr[2][td[1]="\n Cell 2:1"][td[2]="\n Cell 2:2"]]'),
+        (
+            "<div><table>\n<tbody>\n<tr>\n<td>\n Cell 1:1</td>\n<td>\n Cell 1:2</td>\n</tr>\n<tr>\n<td>\n Cell 2:1</td>\n<td>\n Cell 2:2</td>\n</tr>\n</tbody>\n</table></div>",
+            '/div/div/table/tbody[tr[1][td[1]="\n Cell 1:1"][td[2]="\n Cell 1:2"]][tr[2][td[1]="\n Cell 2:1"][td[2]="\n Cell 2:2"]]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_table(self, input, xpath):
         self.do(input, xpath)
diff --git a/src/moin/converters/_tests/test_html_out.py b/src/moin/converters/_tests/test_html_out.py
index 223a533a0..f8a75587e 100644
--- a/src/moin/converters/_tests/test_html_out.py
+++ b/src/moin/converters/_tests/test_html_out.py
@@ -18,36 +18,35 @@
 from moin.converters.html_out import Converter, ConverterPage, ElementException
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
 class Base:
-    input_namespaces = ns_all = f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:html="{html.namespace}" xmlns:xlink="{xlink.namespace}" xmlns:xml="{xml.namespace}"'
-    output_namespaces = {
-        html.namespace: '',
-        moin_page.namespace: 'page',
-        xml.namespace: 'xml',
-    }
+    input_namespaces = ns_all = (
+        f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:html="{html.namespace}" xmlns:xlink="{xlink.namespace}" xmlns:xml="{xml.namespace}"'
+    )
+    output_namespaces = {html.namespace: "", moin_page.namespace: "page", xml.namespace: "xml"}
 
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
         output = serialize(elem, namespaces=self.output_namespaces, **options)
-        return self.output_re.sub('', output)
+        return self.output_re.sub("", output)
 
     def do(self, input, xpath, args={}):
         out = self.conv(self.handle_input(input), **args)
         string_to_parse = self.handle_output(out)
         logging.debug(f"After the HTML_OUT conversion : {string_to_parse}")
         tree = etree.parse(StringIO(string_to_parse))
-        assert (tree.xpath(xpath))
+        assert tree.xpath(xpath)
 
 
 class TestConverter(Base):
@@ -55,205 +54,258 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('<page:page><page:body><page:p>Test</page:p></page:body></page:page>',
-         '/div[p="Test"]'),
-        ('<page:page><page:body><page:h>Test</page:h></page:body></page:page>',
-         '/div[h1="Test"]'),
-        ('<page:page><page:body><page:h page:outline-level="2">Test</page:h></page:body></page:page>',
-         '/div[h2="Test"]'),
-        ('<page:page><page:body><page:h page:outline-level="6">Test</page:h></page:body></page:page>',
-         '/div[h6="Test"]'),
-        ('<page:page><page:body><page:h page:outline-level="7">Test</page:h></page:body></page:page>',
-         '/div[h6="Test"]'),
-        ('<page:page><page:body><page:p>Test<page:line-break/>Test</page:p></page:body></page:page>',
-         '/div/p/br'),
-        ('<page:page><page:body><page:p>Test<page:span>Test</page:span></page:p></page:body></page:page>',
-         '/div/p[text()="Test"]/span[text()="Test"]'),
-        ('<page:page><page:body><page:p><page:emphasis>Test</page:emphasis></page:p></page:body></page:page>',
-         '/div/p[em="Test"]'),
-        ('<page:page><page:body><page:p><page:strong>Test</page:strong></page:p></page:body></page:page>',
-         '/div/p[strong="Test"]'),
-        ('<page:page><page:body><page:blockcode>Code</page:blockcode></page:body></page:page>',
-         '/div[pre="Code"]'),
-        ('<page:page><page:body><page:p><page:code>Code</page:code></page:p></page:body></page:page>',
-         '/div/p[code="Code"]'),
-        ('<page:page><page:body><page:separator/></page:body></page:page>',
-         '/div/hr'),
-        ('<page:page><page:body><page:div><page:p>Text</page:p></page:div></page:body></page:page>',
-         '/div/div[p="Text"]'),
-        ('<page:page><page:body><page:div><page:blockquote>Quotation</page:blockquote></page:div></page:body></page:page>',
-         '/div/div[blockquote="Quotation"]'),
-        ('<page:page><page:body><page:div><page:p><page:quote>Quotation</page:quote></page:p></page:div></page:body></page:page>',
-         '/div/div/p/q[text()="Quotation"]'),
+        ("<page:page><page:body><page:p>Test</page:p></page:body></page:page>", '/div[p="Test"]'),
+        ("<page:page><page:body><page:h>Test</page:h></page:body></page:page>", '/div[h1="Test"]'),
+        (
+            '<page:page><page:body><page:h page:outline-level="2">Test</page:h></page:body></page:page>',
+            '/div[h2="Test"]',
+        ),
+        (
+            '<page:page><page:body><page:h page:outline-level="6">Test</page:h></page:body></page:page>',
+            '/div[h6="Test"]',
+        ),
+        (
+            '<page:page><page:body><page:h page:outline-level="7">Test</page:h></page:body></page:page>',
+            '/div[h6="Test"]',
+        ),
+        ("<page:page><page:body><page:p>Test<page:line-break/>Test</page:p></page:body></page:page>", "/div/p/br"),
+        (
+            "<page:page><page:body><page:p>Test<page:span>Test</page:span></page:p></page:body></page:page>",
+            '/div/p[text()="Test"]/span[text()="Test"]',
+        ),
+        (
+            "<page:page><page:body><page:p><page:emphasis>Test</page:emphasis></page:p></page:body></page:page>",
+            '/div/p[em="Test"]',
+        ),
+        (
+            "<page:page><page:body><page:p><page:strong>Test</page:strong></page:p></page:body></page:page>",
+            '/div/p[strong="Test"]',
+        ),
+        ("<page:page><page:body><page:blockcode>Code</page:blockcode></page:body></page:page>", '/div[pre="Code"]'),
+        (
+            "<page:page><page:body><page:p><page:code>Code</page:code></page:p></page:body></page:page>",
+            '/div/p[code="Code"]',
+        ),
+        ("<page:page><page:body><page:separator/></page:body></page:page>", "/div/hr"),
+        (
+            "<page:page><page:body><page:div><page:p>Text</page:p></page:div></page:body></page:page>",
+            '/div/div[p="Text"]',
+        ),
+        (
+            "<page:page><page:body><page:div><page:blockquote>Quotation</page:blockquote></page:div></page:body></page:page>",
+            '/div/div[blockquote="Quotation"]',
+        ),
+        (
+            "<page:page><page:body><page:div><page:p><page:quote>Quotation</page:quote></page:p></page:div></page:body></page:page>",
+            '/div/div/p/q[text()="Quotation"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_base(self, input, xpath):
         self.do(input, xpath)
 
-    data = [
-        ('<page><body /></page>',
-         '/div'),
-        ('<page><body class="red" /></page>',
-         '/div[@class="red"]'),
-    ]
+    data = [("<page><body /></page>", "/div"), ('<page><body class="red" /></page>', '/div[@class="red"]')]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_body(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # Basic Links
-        ('<page:page><page:body><page:a xlink:href="uri:test">Test</page:a></page:body></page:page>',
-         '/div/a[text()="Test"][@href="uri:test"]'),
+        (
+            '<page:page><page:body><page:a xlink:href="uri:test">Test</page:a></page:body></page:page>',
+            '/div/a[text()="Test"][@href="uri:test"]',
+        ),
         # Links with xml:base
-        ('<page xml:base="http://base.tld/"><body><p><a xlink:href="/page.html">Test</a></p></body></page>',
-         # <span xml:base="http://base.tld/"><a href="/page.html">Test</a></span>
-         # TODO: commented out test below was added in 2010-08-05 bfa5c9a354b8 - seems to be no code to support
-         # '/span/a[@href="http://base.tld/page.html"][text()="Test"]'),
-         '/span/a[@href="/page.html"][text()="Test"]'),
+        (
+            '<page xml:base="http://base.tld/"><body><p><a xlink:href="/page.html">Test</a></p></body></page>',
+            # <span xml:base="http://base.tld/"><a href="/page.html">Test</a></span>
+            # TODO: commented out test below was added in 2010-08-05 bfa5c9a354b8 - seems to be no code to support
+            # '/span/a[@href="http://base.tld/page.html"][text()="Test"]'),
+            '/span/a[@href="/page.html"][text()="Test"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_link(self, input, xpath):
         self.do(input, xpath)
 
     data = [
         # TODO: should this input work, see 5f63b38816ff 2010-06-30 and 628e532d4365 2008-06-12
         # ('<html:div html:id="a" id="b"><html:p id="c">Test</html:p></html:div>',
-        ('<div html:id="a" id="b"><p id="c">Test</p></div>',
-         '/div[@id="a"]/p[@id="c"][text()="Test"]'),
+        ('<div html:id="a" id="b"><p id="c">Test</p></div>', '/div[@id="a"]/p[@id="c"][text()="Test"]')
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_html(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><p><inline-part><inline-body>Test</inline-body></inline-part></p></body></page>',
-         '/div/p[span="Test"]'),
-        ('<page><body><p><inline-part alt="Alt" /></p></body></page>',
-         '/div/p[span="Alt"]'),
-        ('<page><body><p><inline-part><error /></inline-part></p></body></page>',
-         # <div><p><span class="moin-error">Error</span></p></div>
-         '/div/p/span[@class="moin-error"][text()="Error"]'),
-        ('<page><body><p><inline-part><error>Text</error></inline-part></p></body></page>',
-         # <div><p><span class="moin-error">Text</span></p></div>
-         '/div/p/span[@class="moin-error"][text()="Text"]'),
+        (
+            "<page><body><p><inline-part><inline-body>Test</inline-body></inline-part></p></body></page>",
+            '/div/p[span="Test"]',
+        ),
+        ('<page><body><p><inline-part alt="Alt" /></p></body></page>', '/div/p[span="Alt"]'),
+        (
+            "<page><body><p><inline-part><error /></inline-part></p></body></page>",
+            # <div><p><span class="moin-error">Error</span></p></div>
+            '/div/p/span[@class="moin-error"][text()="Error"]',
+        ),
+        (
+            "<page><body><p><inline-part><error>Text</error></inline-part></p></body></page>",
+            # <div><p><span class="moin-error">Text</span></p></div>
+            '/div/p/span[@class="moin-error"][text()="Text"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_inline_part(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><p><span baseline-shift="sub">sub</span>script</p></body></page>',
-         '/div/p[text()="script"][sub="sub"]'),
-        ('<page><body><p><span baseline-shift="super">super</span>script</p></body></page>',
-         '/div/p[text()="script"][sup="super"]'),
-        ('<page><body><p><u>underline</u></p></body></page>',
-         '/div/p/u [text()="underline"]'),
-        ('<page><body><p><ins>underline</ins></p></body></page>',
-         '/div/p/ins [text()="underline"]'),
-        ('<page><body><p><s>stroke</s></p></body></page>',
-         '/div/p/s [text()="stroke"]'),
-        ('<page><body><p><del>stroke</del></p></body></page>',
-         '/div/p/del [text()="stroke"]'),
-        ('<page><body><p><span font-size="85%">small</span></p></body></page>',
-         '/div/p/span[@class="moin-small"][text()="small"]'),
-        ('<page><body><p><span font-size="120%">big</span></p></body></page>',
-         '/div/p/span[@class="moin-big"][text()="big"]'),
+        (
+            '<page><body><p><span baseline-shift="sub">sub</span>script</p></body></page>',
+            '/div/p[text()="script"][sub="sub"]',
+        ),
+        (
+            '<page><body><p><span baseline-shift="super">super</span>script</p></body></page>',
+            '/div/p[text()="script"][sup="super"]',
+        ),
+        ("<page><body><p><u>underline</u></p></body></page>", '/div/p/u [text()="underline"]'),
+        ("<page><body><p><ins>underline</ins></p></body></page>", '/div/p/ins [text()="underline"]'),
+        ("<page><body><p><s>stroke</s></p></body></page>", '/div/p/s [text()="stroke"]'),
+        ("<page><body><p><del>stroke</del></p></body></page>", '/div/p/del [text()="stroke"]'),
+        (
+            '<page><body><p><span font-size="85%">small</span></p></body></page>',
+            '/div/p/span[@class="moin-small"][text()="small"]',
+        ),
+        (
+            '<page><body><p><span font-size="120%">big</span></p></body></page>',
+            '/div/p/span[@class="moin-big"][text()="big"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_span(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ul[li="Item"]'),
-        ('<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ol[li="Item"]'),
-        ('<page><body><list><list-item><list-item-label>Label</list-item-label><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/dl[dt="Label"][dd="Item"]'),
-        ('<page><body><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ol[@class="moin-upperalpha-list"][li="Item"]'),
-        ('<page><body><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ol[@class="moin-loweralpha-list"][li="Item"]'),
-        ('<page><body><list item-label-generate="ordered" list-style-type="upper-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ol[@class="moin-upperroman-list"][li="Item"]'),
-        ('<page><body><list item-label-generate="ordered" list-style-type="lower-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
-         '/div/ol[@class="moin-lowerroman-list"][li="Item"]'),
+        (
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ul[li="Item"]',
+        ),
+        (
+            '<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ol[li="Item"]',
+        ),
+        (
+            "<page><body><list><list-item><list-item-label>Label</list-item-label><list-item-body>Item</list-item-body></list-item></list></body></page>",
+            '/div/dl[dt="Label"][dd="Item"]',
+        ),
+        (
+            '<page><body><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ol[@class="moin-upperalpha-list"][li="Item"]',
+        ),
+        (
+            '<page><body><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ol[@class="moin-loweralpha-list"][li="Item"]',
+        ),
+        (
+            '<page><body><list item-label-generate="ordered" list-style-type="upper-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ol[@class="moin-upperroman-list"][li="Item"]',
+        ),
+        (
+            '<page><body><list item-label-generate="ordered" list-style-type="lower-roman"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+            '/div/ol[@class="moin-lowerroman-list"][li="Item"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_list(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><object xlink:href="href"/></body></page>',
-         '/div/object[@data="href"]'),
-        ('<page><body><object xlink:href="href.png" page:type="image/png"/></body></page>',
-         '/div/img[@src="href.png"]'),
-        ('<page xml:base="http://base.tld/"><body><object xlink:href="href.png" page:type="image/png"/></body></page>',
-         # <span xml:base="http://base.tld/"><img alt="href.png" src="href.png" /></span>
-         # TODO: commented out test below was added in 2010-08-05 bfa5c9a354b8 - seems to be no code to support
-         # '/span/img[@src="http://base.tld/href.png"]'),
-         '/span/img[@src="href.png"]'),
+        ('<page><body><object xlink:href="href"/></body></page>', '/div/object[@data="href"]'),
+        (
+            '<page><body><object xlink:href="href.png" page:type="image/png"/></body></page>',
+            '/div/img[@src="href.png"]',
+        ),
+        (
+            '<page xml:base="http://base.tld/"><body><object xlink:href="href.png" page:type="image/png"/></body></page>',
+            # <span xml:base="http://base.tld/"><img alt="href.png" src="href.png" /></span>
+            # TODO: commented out test below was added in 2010-08-05 bfa5c9a354b8 - seems to be no code to support
+            # '/span/img[@src="http://base.tld/href.png"]'),
+            '/span/img[@src="href.png"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_object(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><part><body><p>Test</p></body></part></body></page>',
-         '/div/div[p="Test"]'),
-        ('<page><body><part alt="Alt" /></body></page>',
-         '/div[p="Alt"]'),
-        ('<page><body><part><error /></part></body></page>',
-         # <div><p class="moin-error">Error</p></div>
-         '/div/p[text()="Error"][@class="moin-error"]'),
-        ('<page><body><part><error>Error</error></part></body></page>',
-         # <div><p class="moin-error">Error</p></div>
-         '/div/p[@class="moin-error"][text()="Error"]'),
+        ("<page><body><part><body><p>Test</p></body></part></body></page>", '/div/div[p="Test"]'),
+        ('<page><body><part alt="Alt" /></body></page>', '/div[p="Alt"]'),
+        (
+            "<page><body><part><error /></part></body></page>",
+            # <div><p class="moin-error">Error</p></div>
+            '/div/p[text()="Error"][@class="moin-error"]',
+        ),
+        (
+            "<page><body><part><error>Error</error></part></body></page>",
+            # <div><p class="moin-error">Error</p></div>
+            '/div/p[@class="moin-error"][text()="Error"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_part(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><p style="font-size: 1em">Text</p></body></page>',
-         '/div/p[@style="font-size: 1em"][text()="Text"]'),
-        ('<page><body><p style="color: black; font-size: 1em">Text</p></body></page>',
-         '/div/p[@style="color: black; font-size: 1em"][text()="Text"]'),
+        (
+            '<page><body><p style="font-size: 1em">Text</p></body></page>',
+            '/div/p[@style="font-size: 1em"][text()="Text"]',
+        ),
+        (
+            '<page><body><p style="color: black; font-size: 1em">Text</p></body></page>',
+            '/div/p[@style="color: black; font-size: 1em"][text()="Text"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_style(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
-         # <div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tfoot><tr><td>Cell</td></tr></tfoot></table></div>
-         '/div/table[thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]'),
-        ('<page><body><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
-         '/div/table/tbody/tr/td[@colspan="2"][text()="Cell"]'),
-        ('<page><body><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
-         '/div/table/tbody/tr/td[@rowspan="2"][text()="Cell"]'),
+        (
+            "<page><body><table><table-header><table-row><table-cell>Header</table-cell></table-row></table-header><table-footer><table-row><table-cell>Footer</table-cell></table-row></table-footer><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>",
+            # <div><table><thead><tr><td>Header</td></tr></thead><tfoot><tr><td>Footer</td></tr></tfoot><tfoot><tr><td>Cell</td></tr></tfoot></table></div>
+            '/div/table[thead/tr[td="Header"]][tfoot/tr[td="Footer"]][tbody/tr[td="Cell"]]',
+        ),
+        (
+            '<page><body><table><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+            '/div/table/tbody/tr/td[@colspan="2"][text()="Cell"]',
+        ),
+        (
+            '<page><body><table><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+            '/div/table/tbody/tr/td[@rowspan="2"][text()="Cell"]',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_table(self, input, xpath):
         self.do(input, xpath)
 
     data = [
-        ('<page><body><admonition page:type="warning"><p>text</p></admonition></body></page>',
-         '/div/div[@class="warning"][p="text"]'),
+        (
+            '<page><body><admonition page:type="warning"><p>text</p></admonition></body></page>',
+            '/div/div[@class="warning"][p="text"]',
+        )
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_admonition(self, input, xpath):
         self.do(input, xpath)
 
@@ -263,12 +315,14 @@ def setup_class(self):
         self.conv = ConverterPage()
 
     data = [
-        ('<page><body><p>Text<note note-class="footnote"><note-body>Note</note-body></note></p></body></page>',
-         # <div><p>Text<sup class="moin-footnote" id="note-0-1-ref">
-         '/div[p[text()="Text"]/sup[@id="note-1-ref"]/a[@href="#note-1"][text()="1"]][p[@id="note-1"][text()="Note"]/sup/a[@href="#note-1-ref"][text()="1"]]'),
+        (
+            '<page><body><p>Text<note note-class="footnote"><note-body>Note</note-body></note></p></body></page>',
+            # <div><p>Text<sup class="moin-footnote" id="note-0-1-ref">
+            '/div[p[text()="Text"]/sup[@id="note-1-ref"]/a[@href="#note-1"][text()="1"]][p[@id="note-1"][text()="Note"]/sup/a[@href="#note-1-ref"][text()="1"]]',
+        )
     ]
 
-    @pytest.mark.parametrize('input,xpath', data)
+    @pytest.mark.parametrize("input,xpath", data)
     def test_note(self, input, xpath):
         pytest.skip("this test requires footnote plugin")  # XXX TODO
         self.do(input, xpath)
diff --git a/src/moin/converters/_tests/test_image.py b/src/moin/converters/_tests/test_image.py
index 82ddc7969..eb8ff2bcc 100644
--- a/src/moin/converters/_tests/test_image.py
+++ b/src/moin/converters/_tests/test_image.py
@@ -21,39 +21,42 @@ def run_test(tree_xml, output):
     assert serialize(tree, method="html") == output
 
 
-@pytest.mark.parametrize('img_type', [
-    'image/jpeg',
-    'image/svg+xml',
-    'image/png',
-    'image/gif',
-])
+@pytest.mark.parametrize("img_type", ["image/jpeg", "image/svg+xml", "image/png", "image/gif"])
 def test_image(img_type):
     """Tests if a set of imagetypes, result inside an img tag"""
-    tree_xml = ('<ns0:page ns0:page-href="wiki:///Home" xmlns:ns0="http://moinmo.in/namespaces/page" '
-                'xmlns:ns1="http://www.w3.org/2001/XInclude" xmlns:ns2="http://www.w3.org/1999/xhtml" '
-                'xmlns:ns3="http://www.w3.org/1999/xlink"><ns0:body><ns0:p ns2:data-lineno="1">'
-                '<ns0:page ns2:class="moin-transclusion" ns0:page-href="wiki:///imagetest" ns2:data-href="/imagetest">'
-                '<ns0:body><ns0:object ns3:href="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" ns0:type="{0}" />'
-                '</ns0:body></ns0:page></ns0:p></ns0:body></ns0:page>')
-
-    output = ('<div xmlns="http://www.w3.org/1999/xhtml"><p data-lineno="1"><span class="moin-transclusion" '
-              'data-href="/imagetest"><img alt="imagetest" src="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest">'
-              '</span></p></div>')
+    tree_xml = (
+        '<ns0:page ns0:page-href="wiki:///Home" xmlns:ns0="http://moinmo.in/namespaces/page" '
+        'xmlns:ns1="http://www.w3.org/2001/XInclude" xmlns:ns2="http://www.w3.org/1999/xhtml" '
+        'xmlns:ns3="http://www.w3.org/1999/xlink"><ns0:body><ns0:p ns2:data-lineno="1">'
+        '<ns0:page ns2:class="moin-transclusion" ns0:page-href="wiki:///imagetest" ns2:data-href="/imagetest">'
+        '<ns0:body><ns0:object ns3:href="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" ns0:type="{0}" />'
+        "</ns0:body></ns0:page></ns0:p></ns0:body></ns0:page>"
+    )
+
+    output = (
+        '<div xmlns="http://www.w3.org/1999/xhtml"><p data-lineno="1"><span class="moin-transclusion" '
+        'data-href="/imagetest"><img alt="imagetest" src="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest">'
+        "</span></p></div>"
+    )
 
     run_test(tree_xml.format(img_type), output)
 
 
 def test_resize():
     """Tests if resize attributes convert to respective html tag resize attributes"""
-    image_resize = ('<ns0:page xmlns:ns0="http://moinmo.in/namespaces/page" '
-                    'xmlns:ns2="http://www.w3.org/1999/xhtml" xmlns:ns3="http://www.w3.org/1999/xlink">'
-                    '<ns0:body><ns0:p><ns0:page>'
-                    '<ns0:body><ns0:object ns3:href="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" '
-                    'ns2:height="10" ns2:width="10" ns0:type="image/jpeg" />'
-                    '</ns0:body></ns0:page></ns0:p></ns0:body></ns0:page>')
-
-    image_resize_out = ('<div xmlns="http://www.w3.org/1999/xhtml"><p><div><img alt="imagetest" height="10" '
-                        'src="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" width="10">'
-                        '</div></p></div>')
+    image_resize = (
+        '<ns0:page xmlns:ns0="http://moinmo.in/namespaces/page" '
+        'xmlns:ns2="http://www.w3.org/1999/xhtml" xmlns:ns3="http://www.w3.org/1999/xlink">'
+        "<ns0:body><ns0:p><ns0:page>"
+        '<ns0:body><ns0:object ns3:href="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" '
+        'ns2:height="10" ns2:width="10" ns0:type="image/jpeg" />'
+        "</ns0:body></ns0:page></ns0:p></ns0:body></ns0:page>"
+    )
+
+    image_resize_out = (
+        '<div xmlns="http://www.w3.org/1999/xhtml"><p><div><img alt="imagetest" height="10" '
+        'src="/+get/+2882c905b2ab409fbf79cd05637a112d/imagetest" width="10">'
+        "</div></p></div>"
+    )
 
     run_test(image_resize, image_resize_out)
diff --git a/src/moin/converters/_tests/test_include.py b/src/moin/converters/_tests/test_include.py
index 8c5adaeb9..ad4fc75c7 100644
--- a/src/moin/converters/_tests/test_include.py
+++ b/src/moin/converters/_tests/test_include.py
@@ -19,230 +19,337 @@ class Config(wikiconfig.Config):
         """
 
     def test_XPointer(self):
-        x = XPointer('a')
+        x = XPointer("a")
         assert len(x) == 1
         e = x[0]
-        assert e.name == 'a'
+        assert e.name == "a"
         assert e.data is None
 
-        x = XPointer('a(b)')
+        x = XPointer("a(b)")
         assert len(x) == 1
         e = x[0]
-        assert e.name == 'a'
-        assert e.data == 'b'
+        assert e.name == "a"
+        assert e.data == "b"
 
-        x = XPointer('a(^(b^)^^)')
+        x = XPointer("a(^(b^)^^)")
         assert len(x) == 1
         e = x[0]
-        assert e.name == 'a'
-        assert e.data == '^(b^)^^'
-        assert e.data_unescape == '(b)^'
+        assert e.name == "a"
+        assert e.data == "^(b^)^^"
+        assert e.data_unescape == "(b)^"
 
-        x = XPointer('a(b)c(d)')
+        x = XPointer("a(b)c(d)")
         assert len(x) == 2
         e = x[0]
-        assert e.name == 'a'
-        assert e.data == 'b'
+        assert e.name == "a"
+        assert e.data == "b"
         e = x[1]
-        assert e.name == 'c'
-        assert e.data == 'd'
+        assert e.name == "c"
+        assert e.data == "d"
 
-        x = XPointer('a(b) c(d)')
+        x = XPointer("a(b) c(d)")
         assert len(x) == 2
         e = x[0]
-        assert e.name == 'a'
-        assert e.data == 'b'
+        assert e.name == "a"
+        assert e.data == "b"
         e = x[1]
-        assert e.name == 'c'
-        assert e.data == 'd'
+        assert e.name == "c"
+        assert e.data == "d"
 
-        x = XPointer('a(a(b))')
+        x = XPointer("a(a(b))")
         assert len(x) == 1
         e = x[0]
-        assert e.name == 'a'
-        assert e.data == 'a(b)'
+        assert e.name == "a"
+        assert e.data == "a(b)"
 
     def test_IncludeHandlesCircularRecursion(self):
         # detect circular recursion and create error message
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{page2}}')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{page3}}')
-        update_item('page3', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{page4}}')
-        update_item('page4', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{page2}}')
-        page1 = Item.create('page1')
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{page2}}")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{page3}}")
+        update_item("page3", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{page4}}")
+        update_item("page4", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{page2}}")
+        page1 = Item.create("page1")
         rendered = page1.content._render_data()
         # an error message will follow strong tag
         assert '<strong class="moin-error">' in rendered
 
     def test_Include_Read_Permission_Denied(self):
         # attempt to include an item that user cannot read
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8', ACL: 'All:write,create,admin,destroy'}, 'no one can read')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'some text{{page1}}more text')
-        page2 = Item.create('page2')
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8", ACL: "All:write,create,admin,destroy"},
+            "no one can read",
+        )
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "some text{{page1}}more text")
+        page2 = Item.create("page2")
         rendered = page2.content._render_data()
         # an error message will follow p tag, similar to: Access Denied, transcluded content suppressed.
         assert '<div class="warning moin-read-denied"><p>' in rendered
 
     def test_ExternalInclude(self):
         # external include
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{http://moinmo.in}}')
-        rendered = Item.create('page1').content._render_data()
-        assert '<object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{http://moinmo.in}}")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object>'
+            in rendered
+        )
         # external include embedded within text (object is an inline tag)
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'before {{http://moinmo.in}} after')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> after</p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "before {{http://moinmo.in}} after")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> after</p>'
+            in rendered
+        )
         # external include embedded within text italic and bold markup (object is an inline tag)
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "before ''italic '''bold {{http://moinmo.in}} bold''' italic'' normal")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before <em>italic <strong>bold <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> bold</strong> italic</em> normal</p>' in rendered
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"},
+            "before ''italic '''bold {{http://moinmo.in}} bold''' italic'' normal",
+        )
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before <em>italic <strong>bold <object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object> bold</strong> italic</em> normal</p>'
+            in rendered
+        )
 
     def test_InlineInclude(self):
 
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'before {{page2}} after')
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "before {{page2}} after")
         # transclude single paragraph as inline
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Single line')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single line</span> after</p>' in rendered
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Single line")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single line</span> after</p>'
+            in rendered
+        )
         # transclude multiple paragraphs as block
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Two\n\nParagraphs')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before </p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Two</p><p>Paragraphs</p></div><p> after</p></div>' in rendered
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Two\n\nParagraphs")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before </p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Two</p><p>Paragraphs</p></div><p> after</p></div>'
+            in rendered
+        )
         # transclude single paragraph with internal markup as inline
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "this text contains ''italic'' string")
-        rendered = Item.create('page1').content._render_data()
-        assert 'before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">this text contains <em>italic</em>' in rendered
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "this text contains ''italic'' string")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            'before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">this text contains <em>italic</em>'
+            in rendered
+        )
         # transclude single paragraph as only content within a paragraph
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Content of page2 is\n\n{{page2}}')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Single Line")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>Content of page2 is</p><p><span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span></p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Content of page2 is\n\n{{page2}}")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Single Line")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>Content of page2 is</p><p><span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span></p>'
+            in rendered
+        )
         # transclude single row table within a paragraph, block element forces paragraph to be split into 2 parts
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'before {{page2}} after')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "|| table || cell ||")
-        rendered = Item.create('page1').content._render_data()
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "before {{page2}} after")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "|| table || cell ||")
+        rendered = Item.create("page1").content._render_data()
         assert '<p>before </p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><table' in rendered
-        assert '</table></div><p> after</p>' in rendered
-        assert rendered.count('<table') == 1
+        assert "</table></div><p> after</p>" in rendered
+        assert rendered.count("<table") == 1
         # transclude two row table within a paragraph, block element forces paragraph to be split into 2 parts
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'before {{page2}} after')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "|| this || has ||\n|| two || rows ||")
-        rendered = Item.create('page1').content._render_data()
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "before {{page2}} after")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "|| this || has ||\n|| two || rows ||")
+        rendered = Item.create("page1").content._render_data()
         # inclusion of block item within a paragraph results in a before and after p
         assert '<p>before </p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><table' in rendered
-        assert '</table></div><p> after</p>' in rendered
-        assert rendered.count('<table') == 1
+        assert "</table></div><p> after</p>" in rendered
+        assert rendered.count("<table") == 1
         # transclude nonexistent item
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'before {{nonexistent}} after')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before <span class="moin-transclusion" data-href="/nonexistent" dir="ltr" lang="en"><a href="/+modify/nonexistent">' in rendered
-        assert '</a></span> after</p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "before {{nonexistent}} after")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before <span class="moin-transclusion" data-href="/nonexistent" dir="ltr" lang="en"><a href="/+modify/nonexistent">'
+            in rendered
+        )
+        assert "</a></span> after</p>" in rendered
         # transclude empty item
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'text {{page2}} text')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"></span> text</p></div>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text {{page2}} text")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"></span> text</p></div>'
+            in rendered
+        )
 
     def test_InlineIncludeCreole(self):
         # transclude single paragraph as inline using creole parser
-        update_item('creole', {CONTENTTYPE: 'text/x.moin.creole;charset=utf-8'}, 'creole item')
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.creole;charset=utf-8'}, 'before {{creole}} after')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>before <span class="moin-transclusion" data-href="/creole" dir="ltr" lang="en">creole item</span> after</p>' in rendered
+        update_item("creole", {CONTENTTYPE: "text/x.moin.creole;charset=utf-8"}, "creole item")
+        update_item("page1", {CONTENTTYPE: "text/x.moin.creole;charset=utf-8"}, "before {{creole}} after")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>before <span class="moin-transclusion" data-href="/creole" dir="ltr" lang="en">creole item</span> after</p>'
+            in rendered
+        )
 
     def test_InlineIncludeWithinMarkup(self):
         # transclude single line item within italic and bold markup
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Normal ''italic '''bold {{page2}} bold''' italic'' normal")
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Single Line")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span> bold</strong> italic</em> normal</p>' in rendered
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"},
+            "Normal ''italic '''bold {{page2}} bold''' italic'' normal",
+        )
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Single Line")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span> bold</strong> italic</em> normal</p>'
+            in rendered
+        )
         # transclude double line item within italic and bold markup
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Normal ''italic '''bold {{page2}} bold''' italic'' normal")
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Double\n\nLine")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>Normal <em>italic <strong>bold </strong></em></p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div><p><em><strong> bold</strong> italic</em> normal</p>' in rendered
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"},
+            "Normal ''italic '''bold {{page2}} bold''' italic'' normal",
+        )
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Double\n\nLine")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>Normal <em>italic <strong>bold </strong></em></p><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div><p><em><strong> bold</strong> italic</em> normal</p>'
+            in rendered
+        )
         # transclude single line item within comment
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "comment /* before {{page2}} after */")
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Single Line")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>comment <span class="comment">before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span> after</span></p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "comment /* before {{page2}} after */")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Single Line")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>comment <span class="comment">before <span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en">Single Line</span> after</span></p>'
+            in rendered
+        )
         # transclude double line item within comment
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "comment /* before {{page2}} after */")
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Double\n\nLine")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>comment <span class="comment">before </span></p><div class="comment moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div><p><span class="comment"> after</span></p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "comment /* before {{page2}} after */")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Double\n\nLine")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>comment <span class="comment">before </span></p><div class="comment moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div><p><span class="comment"> after</span></p>'
+            in rendered
+        )
 
     def test_InlineIncludeImage(self):
         # the 3rd parameter, '',  should be a binary string defining a png image, but it is not needed for this simple test
-        update_item('logo.png', {CONTENTTYPE: 'image/png'}, '')
+        update_item("logo.png", {CONTENTTYPE: "image/png"}, "")
         # simple transclusion
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{logo.png}}')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src=' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{logo.png}}")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src='
+            in rendered
+        )
         assert '/logo.png" /></span></p>' in rendered
         # simple transclusion with alt text and width
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{logo.png|my alt text|width="100"}}')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="my alt text" src=' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, '{{logo.png|my alt text|width="100"}}')
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="my alt text" src='
+            in rendered
+        )
         assert 'logo.png" width="100" /></span></p>' in rendered
         # within paragraph
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'text {{logo.png}} text')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src=' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text {{logo.png}} text")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src='
+            in rendered
+        )
         assert '/logo.png" /></span> text</p>' in rendered
         # within markup
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Normal ''italic '''bold {{logo.png}} bold''' italic'' normal")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src=' in rendered
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"},
+            "Normal ''italic '''bold {{logo.png}} bold''' italic'' normal",
+        )
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>Normal <em>italic <strong>bold <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src='
+            in rendered
+        )
         assert '/logo.png" /></span> bold</strong> italic</em> normal</p>' in rendered
         # multiple transclusions
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, '{{logo.png}}{{logo.png}}')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src=' in rendered
-        assert '/logo.png" /></span><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src=' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "{{logo.png}}{{logo.png}}")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src='
+            in rendered
+        )
+        assert (
+            '/logo.png" /></span><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src='
+            in rendered
+        )
         # check for old bug
-        assert '<p />' not in rendered
-        assert '<p></p>' not in rendered
+        assert "<p />" not in rendered
+        assert "<p></p>" not in rendered
 
     def test_IncludeAsLinkAlternate(self):
         # the 3rd parameter, '',  should be a binary string defining a png image, but it is not needed for this simple test
-        update_item('logo.png', {CONTENTTYPE: 'image/png'}, '')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Single Line")
+        update_item("logo.png", {CONTENTTYPE: "image/png"}, "")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Single Line")
         # image as link alternate
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "text [[page2|{{logo.png}}]] text")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a href="/page2"><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[page2|{{logo.png}}]] text")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a href="/page2"><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="'
+            in rendered
+        )
         assert '/logo.png" /></span></a> text</p>' in rendered
         # link alternate with image embedded in markup
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "text [[page2|plain '''bold {{logo.png}} bold''' plain]] text")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a href="/page2">plain <strong>bold <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="' in rendered
+        update_item(
+            "page1",
+            {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"},
+            "text [[page2|plain '''bold {{logo.png}} bold''' plain]] text",
+        )
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a href="/page2">plain <strong>bold <span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="'
+            in rendered
+        )
         assert '/logo.png" /></span> bold</strong> plain</a> text</p>' in rendered
         # nonexistent image used in link alternate
         # XXX html validation errora: A inside A - the image alternate turns into an A-tag to create the non-existant image.  Error is easily seen.
         # IE9, Firefox, Chrome, Safari, and Opera display this OK;  the only usable hyperlink is to create the missing image.
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "text [[page2|{{logoxxx.png}}]] text")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a href="/page2"><span class="moin-transclusion" data-href="/logoxxx.png" dir="ltr" lang="en"><a href="/+modify/logoxxx.png">' in rendered
-        assert '</a></span></a> text</p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[page2|{{logoxxx.png}}]] text")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a href="/page2"><span class="moin-transclusion" data-href="/logoxxx.png" dir="ltr" lang="en"><a href="/+modify/logoxxx.png">'
+            in rendered
+        )
+        assert "</a></span></a> text</p>" in rendered
         # image used as alternate to nonexistent page
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "text [[page2xxx|{{logo.png}}]] text")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a class="moin-nonexistent" href="/page2xxx"><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[page2xxx|{{logo.png}}]] text")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a class="moin-nonexistent" href="/page2xxx"><span class="moin-transclusion" data-href="/logo.png" dir="ltr" lang="en"><img alt="logo.png" src="'
+            in rendered
+        )
         assert '/logo.png" /></span></a> text</p>' in rendered
         # transclude block elem as link alternate to nonexistent page
         # XXX html validation errors, block element inside A.
         # IE9, Firefox, Chrome, Safari, and Opera display this OK;  the hyperlink is the entire div enclosing the block elem
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'text [[MyPage|{{page2}}]] text')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "Double\n\nLine")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a class="moin-nonexistent" href="/MyPage"><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div></a> text</p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[MyPage|{{page2}}]] text")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Double\n\nLine")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a class="moin-nonexistent" href="/MyPage"><div class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"><p>Double</p><p>Line</p></div></a> text</p>'
+            in rendered
+        )
         # transclude empty item as link alternate to nonexistent page
         # hyperlink will be empty span and invisible
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'text [[MyPage|{{page2}}]] text')
-        update_item('page2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, "")
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a class="moin-nonexistent" href="/MyPage"><span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"></span></a> text</p>' in rendered
+        update_item("page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[MyPage|{{page2}}]] text")
+        update_item("page2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "")
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a class="moin-nonexistent" href="/MyPage"><span class="moin-transclusion" data-href="/page2" dir="ltr" lang="en"></span></a> text</p>'
+            in rendered
+        )
         # transclude external page as link alternate to nonexistent page
-        update_item('page1', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'text [[MyPage|{{http://moinmo.in}}]] text')
-        rendered = Item.create('page1').content._render_data()
-        assert '<p>text <a class="moin-nonexistent" href="/MyPage"><object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object></a> text</p>' in rendered
+        update_item(
+            "page1", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "text [[MyPage|{{http://moinmo.in}}]] text"
+        )
+        rendered = Item.create("page1").content._render_data()
+        assert (
+            '<p>text <a class="moin-nonexistent" href="/MyPage"><object class="moin-transclusion" data="http://moinmo.in" data-href="http://moinmo.in">http://moinmo.in</object></a> text</p>'
+            in rendered
+        )
diff --git a/src/moin/converters/_tests/test_link.py b/src/moin/converters/_tests/test_link.py
index 17dbd553f..3351b75d1 100644
--- a/src/moin/converters/_tests/test_link.py
+++ b/src/moin/converters/_tests/test_link.py
@@ -19,24 +19,18 @@ def conv():
 
 
 @pytest.mark.parametrize(
-    'input_,output',
+    "input_,output",
     (
-        ('wiki:///Test',
-         '/Test'),
-        ('wiki:///Test:colon',
-         '/Test:colon'),
-        ('wiki:///Test?mode=raw',
-         '/Test?mode=raw'),
-        ('wiki:///Test#anchor',
-         '/Test#anchor'),
-        ('wiki:///Test?mode=raw#anchor',
-         '/Test?mode=raw#anchor'),
-        ('wiki://MoinMoin/Test',
-         'http://moinmo.in/Test'),
+        ("wiki:///Test", "/Test"),
+        ("wiki:///Test:colon", "/Test:colon"),
+        ("wiki:///Test?mode=raw", "/Test?mode=raw"),
+        ("wiki:///Test#anchor", "/Test#anchor"),
+        ("wiki:///Test?mode=raw#anchor", "/Test?mode=raw#anchor"),
+        ("wiki://MoinMoin/Test", "http://moinmo.in/Test"),
     ),
 )
 def test_wiki(app, conv, input_, output):
-    assert 'MoinMoin' in app.cfg.interwiki_map
+    assert "MoinMoin" in app.cfg.interwiki_map
 
     elem = ET.Element(None)
     conv.handle_wiki_links(elem, Iri(input_))
@@ -44,44 +38,22 @@ def test_wiki(app, conv, input_, output):
 
 
 @pytest.mark.parametrize(
-    'input_,page,output',
+    "input_,page,output",
     (
         # note: result URLs assume test wiki running at /
-        ('wiki.local:',
-         'wiki:///Root',
-         '/Root'),
-        ('wiki.local:Test',
-         'wiki:///Root',
-         '/Test'),
-        ('wiki.local:Test:colon',
-         'wiki:///Root',
-         '/Test:colon'),
-        ('wiki.local:users/Test:colon',
-         'wiki:///Root',
-         '/users/Test:colon'),
-        ('wiki.local:users:ns/Test:colon',
-         'wiki:///Root',
-         '/users:ns/Test:colon'),
-        ('wiki.local:Test',
-         'wiki:///Root/Sub',
-         '/Test'),
-        ('wiki.local:/Test',
-         'wiki:///Root',
-         '/Root/Test'),
-        ('wiki.local:/Test',
-         'wiki:///Root/Sub',
-         '/Root/Sub/Test'),
-        ('wiki.local:../Test',
-         'wiki:///Root',
-         '/Test'),
-        ('wiki.local:../Test',
-         'wiki:///Root/Sub',
-         '/Root/Test'),
+        ("wiki.local:", "wiki:///Root", "/Root"),
+        ("wiki.local:Test", "wiki:///Root", "/Test"),
+        ("wiki.local:Test:colon", "wiki:///Root", "/Test:colon"),
+        ("wiki.local:users/Test:colon", "wiki:///Root", "/users/Test:colon"),
+        ("wiki.local:users:ns/Test:colon", "wiki:///Root", "/users:ns/Test:colon"),
+        ("wiki.local:Test", "wiki:///Root/Sub", "/Test"),
+        ("wiki.local:/Test", "wiki:///Root", "/Root/Test"),
+        ("wiki.local:/Test", "wiki:///Root/Sub", "/Root/Sub/Test"),
+        ("wiki.local:../Test", "wiki:///Root", "/Test"),
+        ("wiki.local:../Test", "wiki:///Root/Sub", "/Root/Test"),
         # this is a local wiki item with a name happening to have a ":' inside:
-        ('wiki.local:NoInterWiki:Item',
-         'wiki:///Root',
-         '/NoInterWiki:Item'),
-    )
+        ("wiki.local:NoInterWiki:Item", "wiki:///Root", "/NoInterWiki:Item"),
+    ),
 )
 def test_wikilocal(conv, input_, page, output):
     elem = ET.Element(None)
@@ -90,13 +62,8 @@ def test_wikilocal(conv, input_, page, output):
 
 
 @pytest.mark.parametrize(
-    'input_,output',
-    (
-        ('http://moinmo.in/',
-         'http://moinmo.in/'),
-        ('mailto:foo.bar@example.org',
-         'mailto:foo.bar@example.org'),
-    )
+    "input_,output",
+    (("http://moinmo.in/", "http://moinmo.in/"), ("mailto:foo.bar@example.org", "mailto:foo.bar@example.org")),
 )
 def test_wikiexternal(conv, input_, output):
     elem = ET.Element(None)
@@ -106,7 +73,7 @@ def test_wikiexternal(conv, input_, output):
 
 
 @pytest.mark.parametrize(
-    'tree_xml,links_expected,transclusions_expected,external_expected',
+    "tree_xml,links_expected,transclusions_expected,external_expected",
     (
         (
             """
@@ -160,8 +127,8 @@ def test_wikiexternal(conv, input_, output):
             </ns0:p>
             </ns0:body></ns0:page>
             """,
-            ("NoInterWiki:Link", ),
-            ("AlsoNoInterWiki:Transclusion", ),
+            ("NoInterWiki:Link",),
+            ("AlsoNoInterWiki:Transclusion",),
             [],
         ),
     ),
diff --git a/src/moin/converters/_tests/test_markdown_in.py b/src/moin/converters/_tests/test_markdown_in.py
index 9a1217675..92b04c474 100644
--- a/src/moin/converters/_tests/test_markdown_in.py
+++ b/src/moin/converters/_tests/test_markdown_in.py
@@ -16,12 +16,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page: '',
-        xlink: 'xlink',
-        xinclude: 'xinclude',
-        html: 'html',
-    }
+    namespaces = {moin_page: "", xlink: "xlink", xinclude: "xinclude", html: "html"}
 
     output_re = XMLNS_RE
 
@@ -29,154 +24,173 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('Text',
-         '<p>Text</p>'),
-        ('Text\nTest',
-         '<p>Text\nTest</p>'),
-        ('Text\n\nTest',
-         '<p>Text</p><p>Test</p>'),
-        ('<http://moinmo.in/>',
-         '<p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p>'),
-        ('[yo](javascript:alert("xss"))',
-         '<p><a title="xss" html:title="xss" xlink:href="javascript:alert%28">yo</a>)</p>'),
-        ('[MoinMoin](http://moinmo.in/)',
-         '<p><a xlink:href="http://moinmo.in/">MoinMoin</a></p>'),
-        ('----',
-         '<separator class="moin-hr3" />'),
+        ("Text", "<p>Text</p>"),
+        ("Text\nTest", "<p>Text\nTest</p>"),
+        ("Text\n\nTest", "<p>Text</p><p>Test</p>"),
+        ("<http://moinmo.in/>", '<p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p>'),
+        (
+            '[yo](javascript:alert("xss"))',
+            '<p><a title="xss" html:title="xss" xlink:href="javascript:alert%28">yo</a>)</p>',
+        ),
+        ("[MoinMoin](http://moinmo.in/)", '<p><a xlink:href="http://moinmo.in/">MoinMoin</a></p>'),
+        ("----", '<separator class="moin-hr3" />'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('*Emphasis*',
-         '<p><emphasis>Emphasis</emphasis></p>'),
-        ('_Emphasis_',
-         '<p><emphasis>Emphasis</emphasis></p>'),
-        ('**Strong**',
-         '<p><strong>Strong</strong></p>'),
-        ('_**Both**_',
-         '<p><emphasis><strong>Both</strong></emphasis></p>'),
-        ('**_Both_**',
-         '<p><strong><emphasis>Both</emphasis></strong></p>'),
+        ("*Emphasis*", "<p><emphasis>Emphasis</emphasis></p>"),
+        ("_Emphasis_", "<p><emphasis>Emphasis</emphasis></p>"),
+        ("**Strong**", "<p><strong>Strong</strong></p>"),
+        ("_**Both**_", "<p><emphasis><strong>Both</strong></emphasis></p>"),
+        ("**_Both_**", "<p><strong><emphasis>Both</emphasis></strong></p>"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_emphasis(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<em>Emphasis</em>',
-         '<div><p><emphasis>Emphasis</emphasis></p></div>'),
-        ('<i>Italic</i>',
-         '<div><p><emphasis>Italic</emphasis></p></div>'),
-        ('<u>underline</u>',
-         '<div><p><u>underline</u></p></div>'),
-        ('<del>deleted</del>',
-         '<div><p><del>deleted</del></p></div>'),
+        ("<em>Emphasis</em>", "<div><p><emphasis>Emphasis</emphasis></p></div>"),
+        ("<i>Italic</i>", "<div><p><emphasis>Italic</emphasis></p></div>"),
+        ("<u>underline</u>", "<div><p><u>underline</u></p></div>"),
+        ("<del>deleted</del>", "<div><p><del>deleted</del></p></div>"),
         # TODO: markdown 3.3 outputs `/>\n\n\n\n</p>`, prior versions output `/></p>`. Try test again with versions 3.3+
         # Added similar test to test_markdown_in_out
         # ('<hr>',
         #  '<div><p><separator html:class="moin-hr3" />\n\n\n\n</p></div>'),  # works only with markdown 3.3
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_html_extension(self, input, output):
         self.do(input, output)
 
     data = [
-        ('http://moinmo.in/',
-         '<p>http://moinmo.in/</p>'),
-        ('\\[escape](yo)',
-         '<p>[escape](yo)</p>'),
-        ('\\*yo\\*',
-         '<p>*yo*</p>'),
+        ("http://moinmo.in/", "<p>http://moinmo.in/</p>"),
+        ("\\[escape](yo)", "<p>[escape](yo)</p>"),
+        ("\\*yo\\*", "<p>*yo*</p>"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_escape(self, input, output):
         self.do(input, output)
 
     data = [
-        ('* Item',
-         '<list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list>'),
-        ('* Item\nItem',
-         '<list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list>'),
-        ('* Item 1\n* Item 2',
-         '<list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list>'),
-        ('* Item 1\n    * Item 1.2\n* Item 2',
-         '<list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list>'),
-        ('* List 1\n\nyo\n\n\n* List 2',
-         '<list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><p>yo</p><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list>'),
-        ('8. Item',
-         '<list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list>'),
+        (
+            "* Item",
+            '<list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list>',
+        ),
+        (
+            "* Item\nItem",
+            '<list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list>',
+        ),
+        (
+            "* Item 1\n* Item 2",
+            '<list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list>',
+        ),
+        (
+            "* Item 1\n    * Item 1.2\n* Item 2",
+            '<list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list>',
+        ),
+        (
+            "* List 1\n\nyo\n\n\n* List 2",
+            '<list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><p>yo</p><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list>',
+        ),
+        (
+            "8. Item",
+            '<list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('![Alt text](png "Optional title")',
-         '<p><xinclude:include html:alt="Alt text" html:title="Optional title" xinclude:href="wiki.local:png" /></p>'),
-        ('![](png "Optional title")',
-         '<p><xinclude:include html:title="Optional title" xinclude:href="wiki.local:png" /></p>'),
-        ('![remote image](http://static.moinmo.in/logos/moinmoin.png)',
-         '<p><object html:alt="remote image" xlink:href="http://static.moinmo.in/logos/moinmoin.png" /></p>'),
-        ('![Alt text](http://test.moinmo.in/png)',
-         '<p><object html:alt="Alt text" xlink:href="http://test.moinmo.in/png" /></p>'),
-        ('![transclude local wiki item](someitem)',
-         '<p><xinclude:include html:alt="transclude local wiki item" xinclude:href="wiki.local:someitem" /></p>'),
+        (
+            '![Alt text](png "Optional title")',
+            '<p><xinclude:include html:alt="Alt text" html:title="Optional title" xinclude:href="wiki.local:png" /></p>',
+        ),
+        (
+            '![](png "Optional title")',
+            '<p><xinclude:include html:title="Optional title" xinclude:href="wiki.local:png" /></p>',
+        ),
+        (
+            "![remote image](http://static.moinmo.in/logos/moinmoin.png)",
+            '<p><object html:alt="remote image" xlink:href="http://static.moinmo.in/logos/moinmoin.png" /></p>',
+        ),
+        (
+            "![Alt text](http://test.moinmo.in/png)",
+            '<p><object html:alt="Alt text" xlink:href="http://test.moinmo.in/png" /></p>',
+        ),
+        (
+            "![transclude local wiki item](someitem)",
+            '<p><xinclude:include html:alt="transclude local wiki item" xinclude:href="wiki.local:someitem" /></p>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_image(self, input, output):
         self.do(input, output)
 
     data = [
-        ('First Header  | Second Header\n------------- | -------------\nContent Cell  | Content Cell\nContent Cell  | Content Cell',
-         '<table><table-header><table-row><table-cell-head>First Header</table-cell-head><table-cell-head>Second Header</table-cell-head></table-row></table-header><table-body><table-row><table-cell>Content Cell</table-cell><table-cell>Content Cell</table-cell></table-row><table-row><table-cell>Content Cell</table-cell><table-cell>Content Cell</table-cell></table-row></table-body></table>'),
+        (
+            "First Header  | Second Header\n------------- | -------------\nContent Cell  | Content Cell\nContent Cell  | Content Cell",
+            "<table><table-header><table-row><table-cell-head>First Header</table-cell-head><table-cell-head>Second Header</table-cell-head></table-row></table-header><table-body><table-row><table-cell>Content Cell</table-cell><table-cell>Content Cell</table-cell></table-row><table-row><table-cell>Content Cell</table-cell><table-cell>Content Cell</table-cell></table-row></table-body></table>",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
-    data = [('[[Bracketed]]',
-             '<p><a xlink:href="wiki.local:Bracketed">Bracketed</a></p>'),
-            ('[[Main/sub]]',  # check if label is kept lower case, check if slash in link is detected
-             '<p><a xlink:href="wiki.local:Main/sub">sub</a></p>')]
+    data = [
+        ("[[Bracketed]]", '<p><a xlink:href="wiki.local:Bracketed">Bracketed</a></p>'),
+        (
+            "[[Main/sub]]",  # check if label is kept lower case, check if slash in link is detected
+            '<p><a xlink:href="wiki.local:Main/sub">sub</a></p>',
+        ),
+    ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_wikilinks(self, input, output):
-        """ Test the Wikilinks extension: https://python-markdown.github.io/extensions/wikilinks/"""
+        """Test the Wikilinks extension: https://python-markdown.github.io/extensions/wikilinks/"""
         self.do(input, output)
 
     data = [
-        ('!!! note\n    You should note that the title will be automatically capitalized.',
-         '<div class="admonition note"><p class="admonition-title">Note</p><p>You should note that the title will be automatically capitalized.</p></div>'),
-        ('!!! danger "Don\'t try this at home"\n    ...',
-         '<div class="admonition danger"><p class="admonition-title">Don\'t try this at home</p><p>...</p></div>'),
-        ('!!! important ""\n    This is an admonition box without a title.',
-         '<div class="admonition important"><p>This is an admonition box without a title.</p></div>'),
-        ('!!! danger highlight blink "Don\'t try this at home"\n    ...',
-         '<div class="admonition danger highlight blink"><p class="admonition-title">Don\'t try this at home</p><p>...</p></div>'),
+        (
+            "!!! note\n    You should note that the title will be automatically capitalized.",
+            '<div class="admonition note"><p class="admonition-title">Note</p><p>You should note that the title will be automatically capitalized.</p></div>',
+        ),
+        (
+            '!!! danger "Don\'t try this at home"\n    ...',
+            '<div class="admonition danger"><p class="admonition-title">Don\'t try this at home</p><p>...</p></div>',
+        ),
+        (
+            '!!! important ""\n    This is an admonition box without a title.',
+            '<div class="admonition important"><p>This is an admonition box without a title.</p></div>',
+        ),
+        (
+            '!!! danger highlight blink "Don\'t try this at home"\n    ...',
+            '<div class="admonition danger highlight blink"><p class="admonition-title">Don\'t try this at home</p><p>...</p></div>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_admonition(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}):
-        out = self.conv(input, 'text/x-markdown;charset=utf-8', **args)
+        out = self.conv(input, "text/x-markdown;charset=utf-8", **args)
         got_output = self.serialize_strip(out)
         desired_output = "<page><body>%s</body></page>" % output
-        print('------------------------------------')
+        print("------------------------------------")
         print("WANTED:")
         print(desired_output)
         print("GOT:")
diff --git a/src/moin/converters/_tests/test_markdown_in_out.py b/src/moin/converters/_tests/test_markdown_in_out.py
index 160e6363c..36ac80b48 100644
--- a/src/moin/converters/_tests/test_markdown_in_out.py
+++ b/src/moin/converters/_tests/test_markdown_in_out.py
@@ -21,14 +21,15 @@
 class TestConverter:
 
     input_namespaces = 'xmlns="{}" xmlns:page="{}" xmlns:xlink="{}" xmlns:xinclude="{}" xmlns:html="{}"'.format(
-        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace)
+        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace
+    )
 
     namespaces = {
-        moin_page.namespace: 'page',
-        xlink.namespace: 'xlink',
-        xinclude.namespace: 'xinclude',
-        html.namespace: 'html',
-        xml.namespace: 'xml',
+        moin_page.namespace: "page",
+        xlink.namespace: "xlink",
+        xinclude.namespace: "xinclude",
+        html.namespace: "html",
+        xml.namespace: "xml",
     }
 
     input_re = TAGSTART_RE
@@ -39,173 +40,147 @@ def setup_class(self):
         self.conv_out = conv_out()
 
     data = [
-        ('Text',
-         'Text\n'),
-        ('Text\n\nText\n',
-         'Text\n\nText\n'),
-        ('xxx\n\n------\n\n------\n\n------\n',
-         'xxx\n\n----\n\n----\n\n----\n'),
-        ('----\n\n------\n\n--------\n',
-         '----\n\n----\n\n----\n'),
-        ('**strong**\n',
-         '**strong**\n'),
-        ('*emphasis*\n',
-         '*emphasis*\n'),
-        ('    blockcode\n',
-         '    blockcode\n'),
-        ('`monospace`\n',
-         '`monospace`\n'),
-        ('<strike>stroke</strike>\n',
-         '<strike>stroke</strike>\n'),
+        ("Text", "Text\n"),
+        ("Text\n\nText\n", "Text\n\nText\n"),
+        ("xxx\n\n------\n\n------\n\n------\n", "xxx\n\n----\n\n----\n\n----\n"),
+        ("----\n\n------\n\n--------\n", "----\n\n----\n\n----\n"),
+        ("**strong**\n", "**strong**\n"),
+        ("*emphasis*\n", "*emphasis*\n"),
+        ("    blockcode\n", "    blockcode\n"),
+        ("`monospace`\n", "`monospace`\n"),
+        ("<strike>stroke</strike>\n", "<strike>stroke</strike>\n"),
         # <ins> is changed to <u>
-        ('<ins>underline</ins>\n',
-         '<u>underline</u>\n'),
-        ('<big>larger</big>\n',
-         '<big>larger</big>\n'),
-        ('<small>smaller</small>\n',
-         '<small>smaller</small>\n'),
-        ('<sup>super</sup>script\n',
-         '<sup>super</sup>script\n'),
-        ('<sub>sub</sub>script\n',
-         '<sub>sub</sub>script\n'),
-        ('<hr>\n\n<hr>\n\n<hr>\n',
-         '----\n\n----\n\n----\n'),
+        ("<ins>underline</ins>\n", "<u>underline</u>\n"),
+        ("<big>larger</big>\n", "<big>larger</big>\n"),
+        ("<small>smaller</small>\n", "<small>smaller</small>\n"),
+        ("<sup>super</sup>script\n", "<sup>super</sup>script\n"),
+        ("<sub>sub</sub>script\n", "<sub>sub</sub>script\n"),
+        ("<hr>\n\n<hr>\n\n<hr>\n", "----\n\n----\n\n----\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('level 1\n=======\n',
-         '# level 1 #\n'),
-        ('# level 1 #\n',
-         '# level 1 #\n'),
-        ('## level 2 ##\n',
-         '## level 2 ##\n'),
-        ('## level 2\n',
-         '## level 2 ##\n'),
+        ("level 1\n=======\n", "# level 1 #\n"),
+        ("# level 1 #\n", "# level 1 #\n"),
+        ("## level 2 ##\n", "## level 2 ##\n"),
+        ("## level 2\n", "## level 2 ##\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_headings(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[TOC]\n',
-         '[TOC]\n'),
-        ('|Tables|Are|Very|Cool|\n|------|:----:|-----:|:-----|\n|col 2 is|centered|$12|Gloves|\n',
-         '|Tables|Are|Very|Cool|\n|------|:----:|-----:|:-----|\n|col 2 is|centered|$12|Gloves|\n'),
+        ("[TOC]\n", "[TOC]\n"),
+        (
+            "|Tables|Are|Very|Cool|\n|------|:----:|-----:|:-----|\n|col 2 is|centered|$12|Gloves|\n",
+            "|Tables|Are|Very|Cool|\n|------|:----:|-----:|:-----|\n|col 2 is|centered|$12|Gloves|\n",
+        ),
         # TODO: wrong output, creates indented blockcode, loses fenced code language
         # fix probably requires replacing site-packages/markdown/extensions/codehilite.py
-        ('``` javascript\nvar s = "JavaScript syntax highlighting";\nalert(s);\n```\n',
-         '    var s = "JavaScript syntax highlighting";\n    alert(s);\n'),
+        (
+            '``` javascript\nvar s = "JavaScript syntax highlighting";\nalert(s);\n```\n',
+            '    var s = "JavaScript syntax highlighting";\n    alert(s);\n',
+        ),
         # TODO: wrong output, creates indented blockcode, loses fenced code language
-        ('~~~ {python}\ndef hello():\n    print "Hello World!"\n~~~\n',
-         '    def hello():\n        print "Hello World!"\n'),
-        ('~~~\nddd\neee\nfff\n~~~\n',
-         '    ddd\n    eee\n    fff\n'),
-        ('Text with double__underscore__words.\n\n__Strong__ still works.\n\n__this__works__too__.\n',
-         'Text with double__underscore__words.\n\n**Strong** still works.\n\n**this__works__too**.\n'),
-        ('### orange heading ### {: .orange }\n',
-         '### orange heading ### {: class="orange"}\n'),
-        ('A class of LawnGreen is added to this paragraph.\n{: class="LawnGreen"}\n',
-         'A class of LawnGreen is added to this paragraph.\n{: class="LawnGreen"}\n'),
-        ('{: #para3 }\n',
-         '{: #para3 }\n'),
-        ('so [click to see 3rd paragraph](#para3).\n',
-         'so [click to see 3rd paragraph](#para3).\n'),
-        ('Apple\n:   Pomaceous fruit of plants of the genus Malus in\n    the family Rosaceae.\n:   An american computer company.\n',
-         'Apple\n:   Pomaceous fruit of plants of the genus Malus in\n    the family Rosaceae.\n:   An american computer company.\n'),
+        (
+            '~~~ {python}\ndef hello():\n    print "Hello World!"\n~~~\n',
+            '    def hello():\n        print "Hello World!"\n',
+        ),
+        ("~~~\nddd\neee\nfff\n~~~\n", "    ddd\n    eee\n    fff\n"),
+        (
+            "Text with double__underscore__words.\n\n__Strong__ still works.\n\n__this__works__too__.\n",
+            "Text with double__underscore__words.\n\n**Strong** still works.\n\n**this__works__too**.\n",
+        ),
+        ("### orange heading ### {: .orange }\n", '### orange heading ### {: class="orange"}\n'),
+        (
+            'A class of LawnGreen is added to this paragraph.\n{: class="LawnGreen"}\n',
+            'A class of LawnGreen is added to this paragraph.\n{: class="LawnGreen"}\n',
+        ),
+        ("{: #para3 }\n", "{: #para3 }\n"),
+        ("so [click to see 3rd paragraph](#para3).\n", "so [click to see 3rd paragraph](#para3).\n"),
+        (
+            "Apple\n:   Pomaceous fruit of plants of the genus Malus in\n    the family Rosaceae.\n:   An american computer company.\n",
+            "Apple\n:   Pomaceous fruit of plants of the genus Malus in\n    the family Rosaceae.\n:   An american computer company.\n",
+        ),
         # incomplete footnote test, footnotes are positioned but not defined
-        ('Footnotes[^1] have a label[^label] and a definition[^!DEF].\n',
-         'Footnotes[^1] have a label[^label] and a definition[^!DEF].\n'),
+        (
+            "Footnotes[^1] have a label[^label] and a definition[^!DEF].\n",
+            "Footnotes[^1] have a label[^label] and a definition[^!DEF].\n",
+        ),
         # TODO: test footnote placement succeeds but output is wrong, and other tests will fail due to pytest multithreading
         # fix probably requires replacing site-packages/markdown/extensions/footnotes.py
         # ('Footnotes[^a]\n\n[^a]: This is a footnote.\n',
         #  'Footnotes<sup>1</sup>\n\n----\n\n1. This is a footnote.\xa0[\u21a9](#fnref:a){: class="footnote-backref" title="Jump back to footnote 1 in the text"}\n'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_extensions(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[MoinMoin](http://moinmo.in)\n',
-         '[MoinMoin](http://moinmo.in)\n'),
-        ('[PNG](png)\n',
-         '[PNG](png)\n'),
-        ('[MoinMoin][moin]\n[moin]: http://moinmo.in\n',
-         '[MoinMoin](http://moinmo.in)\n'),
-        ('[![Image name](png)](Home "click me")',
-         '[![Image name](png)](Home "click me")'),
-        ('[toc](#table-of-contents)',
-         '[toc](#table-of-contents)'),
-        ('[toc](markdown#table-of-contents)',
-         '[toc](markdown#table-of-contents)'),
-        ('[moinmoin](https://moinmo.in "Go there")',
-         '[moinmoin](https://moinmo.in "Go there")'),
+        ("[MoinMoin](http://moinmo.in)\n", "[MoinMoin](http://moinmo.in)\n"),
+        ("[PNG](png)\n", "[PNG](png)\n"),
+        ("[MoinMoin][moin]\n[moin]: http://moinmo.in\n", "[MoinMoin](http://moinmo.in)\n"),
+        ('[![Image name](png)](Home "click me")', '[![Image name](png)](Home "click me")'),
+        ("[toc](#table-of-contents)", "[toc](#table-of-contents)"),
+        ("[toc](markdown#table-of-contents)", "[toc](markdown#table-of-contents)"),
+        ('[moinmoin](https://moinmo.in "Go there")', '[moinmoin](https://moinmo.in "Go there")'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        ('* A\n* B\n    1. C\n    1. D\n        1. E\n        1. F\n',
-         '* A\n* B\n    1. C\n    1. D\n        1. E\n        1. F\n'),
-        ('  * A\n      1. C\n          - E\n',
-         '  * A\n    1. C\n        * E\n'),
-        (' * A\n     1. C\n     1. D\n',
-         ' * A\n    1. C\n    1. D\n'),
-        ('1. E\n1. F\n',
-         '1. E\n1. F\n'),
-        ('    1. E\n    1. F\n',
-         '    1. E\n    1. F\n'),
-        ('Apple\n:   B\n:   C\n:   D\n',
-         'Apple\n:   B\n:   C\n:   D\n'),
+        (
+            "* A\n* B\n    1. C\n    1. D\n        1. E\n        1. F\n",
+            "* A\n* B\n    1. C\n    1. D\n        1. E\n        1. F\n",
+        ),
+        ("  * A\n      1. C\n          - E\n", "  * A\n    1. C\n        * E\n"),
+        (" * A\n     1. C\n     1. D\n", " * A\n    1. C\n    1. D\n"),
+        ("1. E\n1. F\n", "1. E\n1. F\n"),
+        ("    1. E\n    1. F\n", "    1. E\n    1. F\n"),
+        ("Apple\n:   B\n:   C\n:   D\n", "Apple\n:   B\n:   C\n:   D\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('|A|B|C|\n|-|-|-|\n|1|2|3|\n',
-         '|A|B|C|\n|------|------|------|\n|1|2|3|\n'),
-        ('|A|B|C|\n|:-|:-:|-:|\n|1|2|3|\n',
-         '|A|B|C|\n|:-----|:----:|-----:|\n|1|2|3|\n'),
-        ('A|B|C\n-|-|-\n1|2|3\n',
-         '|A|B|C|\n|------|------|------|\n|1|2|3|\n'),
-        ('`A`|*B*|_C_\n:-|:-:|-:\n1|2|3\n',
-         '|`A`|*B*|*C*|\n|:-----|:----:|-----:|\n|1|2|3|\n'),
+        ("|A|B|C|\n|-|-|-|\n|1|2|3|\n", "|A|B|C|\n|------|------|------|\n|1|2|3|\n"),
+        ("|A|B|C|\n|:-|:-:|-:|\n|1|2|3|\n", "|A|B|C|\n|:-----|:----:|-----:|\n|1|2|3|\n"),
+        ("A|B|C\n-|-|-\n1|2|3\n", "|A|B|C|\n|------|------|------|\n|1|2|3|\n"),
+        ("`A`|*B*|_C_\n:-|:-:|-:\n1|2|3\n", "|`A`|*B*|*C*|\n|:-----|:----:|-----:|\n|1|2|3|\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('\n![Alt text](png "Optional title")',
-         '\n![Alt text](png "Optional title")\n'),
-        ('![Alt text](png)',
-         '![Alt text](png)\n'),
-        ('![Alt text][logo]\n[logo]: png "Optional title attribute"',
-         '![Alt text](png "Optional title attribute")\n'),
+        ('\n![Alt text](png "Optional title")', '\n![Alt text](png "Optional title")\n'),
+        ("![Alt text](png)", "![Alt text](png)\n"),
+        ('![Alt text][logo]\n[logo]: png "Optional title attribute"', '![Alt text](png "Optional title attribute")\n'),
         # alt defined twice
-        ('![remote image](http://static.moinmo.in/logos/moinmoin.png)',
-         '![remote image](http://static.moinmo.in/logos/moinmoin.png){: alt="remote image"}\n'),
+        (
+            "![remote image](http://static.moinmo.in/logos/moinmoin.png)",
+            '![remote image](http://static.moinmo.in/logos/moinmoin.png){: alt="remote image"}\n',
+        ),
         # alt defined twice
-        ('![Alt text](http://test.moinmo.in/png)',
-         '![Alt text](http://test.moinmo.in/png){: alt="Alt text"}\n'),
+        ("![Alt text](http://test.moinmo.in/png)", '![Alt text](http://test.moinmo.in/png){: alt="Alt text"}\n'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_images(self, input, output):
         self.do(input, output)
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
@@ -213,12 +188,14 @@ def handle_output(self, elem, **options):
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv_in(input, 'text/x-markdown;charset=utf-8', **args)
+        out = self.conv_in(input, "text/x-markdown;charset=utf-8", **args)
         out = self.conv_out(self.handle_input(self.serialize_strip(out)), **args)
         # assert self.handle_output(out) == output
-        assert self.handle_output(out).strip() == output.strip()  # TODO: revert to above when number of \n between blocks in moinwiki_out.py is stable
+        assert (
+            self.handle_output(out).strip() == output.strip()
+        )  # TODO: revert to above when number of \n between blocks in moinwiki_out.py is stable
diff --git a/src/moin/converters/_tests/test_mediawiki_in.py b/src/moin/converters/_tests/test_mediawiki_in.py
index 806e6ae44..ce5ede9eb 100644
--- a/src/moin/converters/_tests/test_mediawiki_in.py
+++ b/src/moin/converters/_tests/test_mediawiki_in.py
@@ -15,10 +15,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page.namespace: '',
-        xlink.namespace: 'xlink',
-    }
+    namespaces = {moin_page.namespace: "", xlink.namespace: "xlink"}
 
     output_re = XMLNS_RE
 
@@ -26,61 +23,68 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ("''italic''",
-         '<page><body><p><emphasis>italic</emphasis></p></body></page>'),
-        ("Text\nTest",
-         '<page><body><p>Text\nTest</p></body></page>'),
-        ('Text\n\nTest',
-         '<page><body><p>Text</p><p>Test</p></body></page>'),
-        ("'''bold'''",
-         '<page><body><p><strong>bold</strong></p></body></page>'),
-        ("'''''bold and italic'''''",
-         '<page><body><p><strong><emphasis>bold and italic</emphasis></strong></p></body></page>'),
-        ("<nowiki>no ''markup''</nowiki>\n\n<code>no ''markup''</code>\n\n<tt>no ''markup''</tt>",
-         "<page><body><p><code>no ''markup''</code></p><p><code>no ''markup''</code></p><p><code>no ''markup''</code></p></body></page>"),
-        ("<pre>no ''markup'' block</pre>",
-         "<page><body><p><blockcode>no ''markup'' block</blockcode></p></body></page>"),
-        ('<u>underlined</u>',
-         '<page><body><p><u>underlined</u></p></body></page>'),
-        ('<ins>inserted</ins>',
-         '<page><body><p><ins>inserted</ins></p></body></page>'),
-        ('<del>Strikethrough</del>',
-         '<page><body><p><del>Strikethrough</del></p></body></page>'),
-        ('<s>Strikethrough</s>',
-         '<page><body><p><s>Strikethrough</s></p></body></page>'),
-        ('test <sup>super</sup> or <sub>sub</sub>',
-         '<page><body><p>test <span baseline-shift="super">super</span> or <span baseline-shift="sub">sub</span></p></body></page>'),
-        ('text <blockquote> quote quote quote quote quote quote </blockquote> text',
-         '<page><body><p>text <blockquote> quote quote quote quote quote quote </blockquote> text</p></body></page>'),
-        ('aaa<br />bbb',
-         '<page><body><p>aaa<line-break />bbb</p></body></page>'),
-        ('aaa <ref> sdf </ref> test\n\n asd',
-         '<page><body><p>aaa <note note-class="footnote"><note-body> sdf </note-body></note> test</p><p> asd</p></body></page>'),
-        ("""=level 1=
+        ("''italic''", "<page><body><p><emphasis>italic</emphasis></p></body></page>"),
+        ("Text\nTest", "<page><body><p>Text\nTest</p></body></page>"),
+        ("Text\n\nTest", "<page><body><p>Text</p><p>Test</p></body></page>"),
+        ("'''bold'''", "<page><body><p><strong>bold</strong></p></body></page>"),
+        (
+            "'''''bold and italic'''''",
+            "<page><body><p><strong><emphasis>bold and italic</emphasis></strong></p></body></page>",
+        ),
+        (
+            "<nowiki>no ''markup''</nowiki>\n\n<code>no ''markup''</code>\n\n<tt>no ''markup''</tt>",
+            "<page><body><p><code>no ''markup''</code></p><p><code>no ''markup''</code></p><p><code>no ''markup''</code></p></body></page>",
+        ),
+        (
+            "<pre>no ''markup'' block</pre>",
+            "<page><body><p><blockcode>no ''markup'' block</blockcode></p></body></page>",
+        ),
+        ("<u>underlined</u>", "<page><body><p><u>underlined</u></p></body></page>"),
+        ("<ins>inserted</ins>", "<page><body><p><ins>inserted</ins></p></body></page>"),
+        ("<del>Strikethrough</del>", "<page><body><p><del>Strikethrough</del></p></body></page>"),
+        ("<s>Strikethrough</s>", "<page><body><p><s>Strikethrough</s></p></body></page>"),
+        (
+            "test <sup>super</sup> or <sub>sub</sub>",
+            '<page><body><p>test <span baseline-shift="super">super</span> or <span baseline-shift="sub">sub</span></p></body></page>',
+        ),
+        (
+            "text <blockquote> quote quote quote quote quote quote </blockquote> text",
+            "<page><body><p>text <blockquote> quote quote quote quote quote quote </blockquote> text</p></body></page>",
+        ),
+        ("aaa<br />bbb", "<page><body><p>aaa<line-break />bbb</p></body></page>"),
+        (
+            "aaa <ref> sdf </ref> test\n\n asd",
+            '<page><body><p>aaa <note note-class="footnote"><note-body> sdf </note-body></note> test</p><p> asd</p></body></page>',
+        ),
+        (
+            """=level 1=
 == level 2 ==
 ===level 3===
 ====level 4====
 =====level 5=====
 ======level 6======
 """,
-         '<page><body><h outline-level="1">level 1</h><h outline-level="2">level 2</h><h outline-level="3">level 3</h><h outline-level="4">level 4</h><h outline-level="5">level 5</h><h outline-level="6">level 6</h></body></page>'),
-        ("[javascript:alert('xss')]",
-         "<page><body><p>[javascript:alert('xss')]</p></body></page>"),
+            '<page><body><h outline-level="1">level 1</h><h outline-level="2">level 2</h><h outline-level="3">level 3</h><h outline-level="4">level 4</h><h outline-level="5">level 5</h><h outline-level="6">level 6</h></body></page>',
+        ),
+        ("[javascript:alert('xss')]", "<page><body><p>[javascript:alert('xss')]</p></body></page>"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ("""* one
+        (
+            """* one
 * two
 * three
 ** three point one
 ** three point two
 """,
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two</p></list-item-body></list-item><list-item><list-item-body><p>three</p><list item-label-generate="unordered"><list-item><list-item-body><p>three point one</p></list-item-body></list-item><list-item><list-item-body><p>three point two</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>'),
-        ("""# one
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two</p></list-item-body></list-item><list-item><list-item-body><p>three</p><list item-label-generate="unordered"><list-item><list-item-body><p>three point one</p></list-item-body></list-item><list-item><list-item-body><p>three point two</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>',
+        ),
+        (
+            """# one
 # two<br />spanning more lines<br />doesn't break numbering
 # three
 ## three point one
@@ -88,10 +92,13 @@ def test_base(self, input, output):
 # 4
 no point
 """,
-         '''<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two<line-break />spanning more lines<line-break />doesn't break numbering</p></list-item-body></list-item><list-item><list-item-body><p>three</p><list item-label-generate="ordered"><list-item><list-item-body><p>three point one</p></list-item-body></list-item><list-item><list-item-body><p>three point two</p></list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body><p>4</p></list-item-body></list-item></list><p>no point</p></body></page>'''),
-        (""";item 1:definition 1
+            """<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two<line-break />spanning more lines<line-break />doesn't break numbering</p></list-item-body></list-item><list-item><list-item-body><p>three</p><list item-label-generate="ordered"><list-item><list-item-body><p>three point one</p></list-item-body></list-item><list-item><list-item-body><p>three point two</p></list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body><p>4</p></list-item-body></list-item></list><p>no point</p></body></page>""",
+        ),
+        (
+            """;item 1:definition 1
 ;item 2:definition 2
-""", '''\
+""",
+            """\
 <page><body>\
 <list>\
 <list-item>\
@@ -104,33 +111,41 @@ def test_base(self, input, output):
 </list-item>\
 </list>\
 </body></page>\
-'''),
+""",
+        ),
         # TODO add a test for a definition list with term and definition on separate lines like:
         # ; term
         # : definition
-        (';aaa : bbb',
-         '<page><body><list><list-item><list-item-label>aaa </list-item-label><list-item-body><p> bbb</p></list-item-body></list-item></list></body></page>'),
-        (""": Single indent
+        (
+            ";aaa : bbb",
+            "<page><body><list><list-item><list-item-label>aaa </list-item-label><list-item-body><p> bbb</p></list-item-body></list-item></list></body></page>",
+        ),
+        (
+            """: Single indent
 :: Double indent
 ::::: Multiple indent
 """,
-         '<page><body><list item-label-generate="None"><list-item><list-item-body><p>Single indent</p><list item-label-generate="None"><list-item><list-item-body><p>Double indent</p><list item-label-generate="None"><list-item><list-item-body><p>Multiple indent</p></list-item-body></list-item></list></list-item-body></list-item></list></list-item-body></list-item></list></body></page>'),
-        ("""# one
+            '<page><body><list item-label-generate="None"><list-item><list-item-body><p>Single indent</p><list item-label-generate="None"><list-item><list-item-body><p>Double indent</p><list item-label-generate="None"><list-item><list-item-body><p>Multiple indent</p></list-item-body></list-item></list></list-item-body></list-item></list></list-item-body></list-item></list></body></page>',
+        ),
+        (
+            """# one
 # two
 #* two point one
 #* two point two
 # three
 #; three item one:three def one
 """,
-         '<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two</p><list item-label-generate="unordered"><list-item><list-item-body><p>two point one</p></list-item-body></list-item><list-item><list-item-body><p>two point two</p></list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body><p>three</p><list><list-item><list-item-label>three item one</list-item-label><list-item-body><p>three def one</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>'),
+            '<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>one</p></list-item-body></list-item><list-item><list-item-body><p>two</p><list item-label-generate="unordered"><list-item><list-item-body><p>two point one</p></list-item-body></list-item><list-item><list-item-body><p>two point two</p></list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body><p>three</p><list><list-item><list-item-label>three item one</list-item-label><list-item-body><p>three def one</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ("""{|
+        (
+            """{|
 |Orange
 |Apple
 |-
@@ -141,8 +156,10 @@ def test_list(self, input, output):
 |Ice cream
 |}
 """,
-         '<page><body><table><table-body><table-row><table-cell>Orange</table-cell><table-cell>Apple</table-cell></table-row><table-row><table-cell>Bread</table-cell><table-cell>Pie</table-cell></table-row><table-row><table-cell>Butter</table-cell><table-cell>Ice cream</table-cell></table-row></table-body></table></body></page>'),
-        ("""{|style="border-width: 1px;"
+            "<page><body><table><table-body><table-row><table-cell>Orange</table-cell><table-cell>Apple</table-cell></table-row><table-row><table-cell>Bread</table-cell><table-cell>Pie</table-cell></table-row><table-row><table-cell>Butter</table-cell><table-cell>Ice cream</table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            """{|style="border-width: 1px;"
 |style="border-style: solid; border-width: 1px" colspan="2"| Orange
 Apple
 |-
@@ -152,62 +169,85 @@ def test_list(self, input, output):
 |test
 |}
 """,
-         '<page><body><table style="border-width: 1px;"><table-body><table-row><table-cell number-columns-spanned="2" style="border-style: solid; border-width: 1px">Orange\nApple</table-cell></table-row><table-row><table-cell number-rows-spanned="2">Bread</table-cell><table-cell>Pie</table-cell></table-row><table-row><table-cell>test</table-cell></table-row></table-body></table></body></page>'),
-        ("""{|
+            '<page><body><table style="border-width: 1px;"><table-body><table-row><table-cell number-columns-spanned="2" style="border-style: solid; border-width: 1px">Orange\nApple</table-cell></table-row><table-row><table-cell number-rows-spanned="2">Bread</table-cell><table-cell>Pie</table-cell></table-row><table-row><table-cell>test</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            """{|
 |class="test"|text||style="border:1px"|test
 |}
 """,
-         '<page><body><table><table-body><table-row><table-cell class="test">text</table-cell><table-cell style="border:1px">test</table-cell></table-row></table-body></table></body></page>'),
+            '<page><body><table><table-body><table-row><table-cell class="test">text</table-cell><table-cell style="border:1px">test</table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[[SomeLink]]',
-         '<page><body><p><a xlink:href="wiki.local:SomeLink">SomeLink</a></p></body></page>'),
-        ('[http://external.link]',
-         '<page><body><p><a xlink:href="http://external.link"></a></p></body></page>'),
-        ('[http://external.link alt text]',
-         '<page><body><p><a xlink:href="http://external.link">alt text</a></p></body></page>'),
-        ('[[SomeLink|Some text]]',
-         '<page><body><p><a xlink:href="wiki.local:SomeLink">Some text</a></p></body></page>'),
-        ('[[SomeLink|arg1=value|arg2=otherval|Some text]]',
-         '<page><body><p><a xlink:href="wiki.local:SomeLink?arg1=value&amp;arg2=otherval">Some text</a></p></body></page>'),
-        ('[[File:Test.jpg|test]]',
-         '<page><body><p><object alt="test" xlink:href="wiki.local:Test.jpg?do=get">test</object></p></body></page>'),
-        ('[[File:MyImage.png]]',
-         '<page><body><p><object alt="MyImage.png" xlink:href="wiki.local:MyImage.png?do=get">MyImage.png</object></p></body></page>'),
-        ('[[File:MyImage.png|arg=http://google.com|caption]]',
-         '<page><body><p><object alt="caption" xlink:href="wiki.local:MyImage.png?arg=http%253A%252F%252Fgoogle.com&amp;do=get">caption</object></p></body></page>'),
-        ('[[File:Test.png|do=get|arg1=test|arg2=something else]]',
-         '<page><body><p><object alt="Test.png" xlink:href="wiki.local:Test.png?do=get&amp;arg1=test&amp;arg2=something+else">Test.png</object></p></body></page>'),
+        ("[[SomeLink]]", '<page><body><p><a xlink:href="wiki.local:SomeLink">SomeLink</a></p></body></page>'),
+        ("[http://external.link]", '<page><body><p><a xlink:href="http://external.link"></a></p></body></page>'),
+        (
+            "[http://external.link alt text]",
+            '<page><body><p><a xlink:href="http://external.link">alt text</a></p></body></page>',
+        ),
+        (
+            "[[SomeLink|Some text]]",
+            '<page><body><p><a xlink:href="wiki.local:SomeLink">Some text</a></p></body></page>',
+        ),
+        (
+            "[[SomeLink|arg1=value|arg2=otherval|Some text]]",
+            '<page><body><p><a xlink:href="wiki.local:SomeLink?arg1=value&amp;arg2=otherval">Some text</a></p></body></page>',
+        ),
+        (
+            "[[File:Test.jpg|test]]",
+            '<page><body><p><object alt="test" xlink:href="wiki.local:Test.jpg?do=get">test</object></p></body></page>',
+        ),
+        (
+            "[[File:MyImage.png]]",
+            '<page><body><p><object alt="MyImage.png" xlink:href="wiki.local:MyImage.png?do=get">MyImage.png</object></p></body></page>',
+        ),
+        (
+            "[[File:MyImage.png|arg=http://google.com|caption]]",
+            '<page><body><p><object alt="caption" xlink:href="wiki.local:MyImage.png?arg=http%253A%252F%252Fgoogle.com&amp;do=get">caption</object></p></body></page>',
+        ),
+        (
+            "[[File:Test.png|do=get|arg1=test|arg2=something else]]",
+            '<page><body><p><object alt="Test.png" xlink:href="wiki.local:Test.png?do=get&amp;arg1=test&amp;arg2=something+else">Test.png</object></p></body></page>',
+        ),
         # The do=xxx part is just to test if do in args is being updated correctly, it's invalid otherwise
-        ('[[File:Test2.png|do=xxx|caption|arg1=test]]',
-         '<page><body><p><object alt="caption" xlink:href="wiki.local:Test2.png?do=xxx&amp;arg1=test">caption</object></p></body></page>'),
-        ("[[File:myimg.png|'Graph showing width |= k for 5 < k < 10']]",
-         '<page><body><p><object alt="Graph showing width |= k for 5 &lt; k &lt; 10" xlink:href="wiki.local:myimg.png?do=get">Graph showing width |= k for 5 &lt; k &lt; 10</object></p></body></page>'),
-        ("[[File:myimg.png|arg1='longish caption value with |= to test'|arg2=other|test stuff]]",
-         '<page><body><p><object alt="test stuff" xlink:href="wiki.local:myimg.png?arg1=longish+caption+value+with+%257C%253D+to+test&amp;arg2=other&amp;do=get">test stuff</object></p></body></page>'),
+        (
+            "[[File:Test2.png|do=xxx|caption|arg1=test]]",
+            '<page><body><p><object alt="caption" xlink:href="wiki.local:Test2.png?do=xxx&amp;arg1=test">caption</object></p></body></page>',
+        ),
+        (
+            "[[File:myimg.png|'Graph showing width |= k for 5 < k < 10']]",
+            '<page><body><p><object alt="Graph showing width |= k for 5 &lt; k &lt; 10" xlink:href="wiki.local:myimg.png?do=get">Graph showing width |= k for 5 &lt; k &lt; 10</object></p></body></page>',
+        ),
+        (
+            "[[File:myimg.png|arg1='longish caption value with |= to test'|arg2=other|test stuff]]",
+            '<page><body><p><object alt="test stuff" xlink:href="wiki.local:myimg.png?arg1=longish+caption+value+with+%257C%253D+to+test&amp;arg2=other&amp;do=get">test stuff</object></p></body></page>',
+        ),
         # Unicode test
-        ('[[File:Test.jpg|\xe8]]',
-         '<page><body><p><object alt="\xe8" xlink:href="wiki.local:Test.jpg?do=get">\xe8</object></p></body></page>')
+        (
+            "[[File:Test.jpg|\xe8]]",
+            '<page><body><p><object alt="\xe8" xlink:href="wiki.local:Test.jpg?do=get">\xe8</object></p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_links(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
-        out = self.conv(input, 'text/x-mediawiki;charset=utf-8', **args)
+        out = self.conv(input, "text/x-mediawiki;charset=utf-8", **args)
         result = self.serialize_strip(out)
         print(result)
         assert result == output
 
 
-coverage_modules = ['moin.converters.mediawiki_in']
+coverage_modules = ["moin.converters.mediawiki_in"]
diff --git a/src/moin/converters/_tests/test_moinwiki19_in.py b/src/moin/converters/_tests/test_moinwiki19_in.py
index 6f230b201..4b70e512b 100644
--- a/src/moin/converters/_tests/test_moinwiki19_in.py
+++ b/src/moin/converters/_tests/test_moinwiki19_in.py
@@ -15,12 +15,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page: '',
-        xlink: 'xlink',
-        html: 'xhtml',
-        xinclude: 'xinclude',
-    }
+    namespaces = {moin_page: "", xlink: "xlink", html: "xhtml", xinclude: "xinclude"}
 
     output_re = XMLNS_RE
 
@@ -28,33 +23,32 @@ def setup_class(self):
         self.conv = ConverterFormat19()
 
     data = [
-        ('MoinMoin',
-         '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
-        ('!MoinMoin',
-         '<page><body><p>MoinMoin</p></body></page>'),
-        ('Self:FrontPage',
-         '<page><body><p><a xlink:href="wiki://Self/FrontPage">FrontPage</a></p></body></page>'),
-        ('http://moinmo.in/',
-         '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>'),
+        ("MoinMoin", '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
+        ("!MoinMoin", "<page><body><p>MoinMoin</p></body></page>"),
+        ("Self:FrontPage", '<page><body><p><a xlink:href="wiki://Self/FrontPage">FrontPage</a></p></body></page>'),
+        (
+            "http://moinmo.in/",
+            '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>',
+        ),
         # email tests
-        ('mailto:foo@bar.baz',
-         '<page><body><p><a xlink:href="mailto:foo@bar.baz">mailto:foo@bar.baz</a></p></body></page>'),
-        ('foo@bar.baz',
-         '<page><body><p><a xlink:href="mailto:foo@bar.baz">foo@bar.baz</a></p></body></page>'),
-        ('foo@bar',  # 1.9 requires domain
-         '<page><body><p>foo@bar</p></body></page>'),
+        (
+            "mailto:foo@bar.baz",
+            '<page><body><p><a xlink:href="mailto:foo@bar.baz">mailto:foo@bar.baz</a></p></body></page>',
+        ),
+        ("foo@bar.baz", '<page><body><p><a xlink:href="mailto:foo@bar.baz">foo@bar.baz</a></p></body></page>'),
+        ("foo@bar", "<page><body><p>foo@bar</p></body></page>"),  # 1.9 requires domain
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_freelink(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv(input, 'text/x.moin.wiki;charset=utf-8', **args)
+        out = self.conv(input, "text/x.moin.wiki;charset=utf-8", **args)
         assert self.serialize_strip(out) == output
diff --git a/src/moin/converters/_tests/test_moinwiki19_in_20_out.py b/src/moin/converters/_tests/test_moinwiki19_in_20_out.py
index c6aa41ec3..c3186f9e4 100644
--- a/src/moin/converters/_tests/test_moinwiki19_in_20_out.py
+++ b/src/moin/converters/_tests/test_moinwiki19_in_20_out.py
@@ -13,6 +13,7 @@
 """
 
 import pytest
+
 # TODO: failing tests are commented out and need to be fixed
 
 from emeraldtree import ElementTree as ET
@@ -27,13 +28,14 @@
 class TestConverter:
 
     input_namespaces = 'xmlns="{}" xmlns:page="{}" xmlns:xlink="{}" xmlns:xinclude="{}" xmlns:html="{}"'.format(
-        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace)
+        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace
+    )
 
     namespaces = {
-        moin_page.namespace: 'page',
-        xlink.namespace: 'xlink',
-        xinclude.namespace: 'xinclude',
-        html.namespace: 'html',
+        moin_page.namespace: "page",
+        xlink.namespace: "xlink",
+        xinclude.namespace: "xinclude",
+        html.namespace: "html",
     }
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
@@ -45,18 +47,18 @@ def setup_class(self):
     data = [
         # Note: old style attachments are are supported in moinwiki_in so conversion to moin 2 markup is not necessary
         # TODO: in a perfect world, moinwiki19_in should convert attachments
-        ('[[attachment:filename.txt]]', '[[/filename.txt]]\n'),
+        ("[[attachment:filename.txt]]", "[[/filename.txt]]\n"),
         # moin 1.9 to 2.0 conversion
-        ('TestPage', '[[TestPage]]\n'),
+        ("TestPage", "[[TestPage]]\n"),
         # ('../SisterPage', '[[../SisterPage]]\n'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
@@ -64,11 +66,11 @@ def handle_output(self, elem, **options):
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv_in(input, 'text/x.moin.wiki;format=1.9;charset=utf-8', **args)
+        out = self.conv_in(input, "text/x.moin.wiki;format=1.9;charset=utf-8", **args)
         out = self.conv_out(self.handle_input(self.serialize_strip(out)), **args)
         assert self.handle_output(out) == output
diff --git a/src/moin/converters/_tests/test_moinwiki_in.py b/src/moin/converters/_tests/test_moinwiki_in.py
index 4b49cda6f..511a30399 100644
--- a/src/moin/converters/_tests/test_moinwiki_in.py
+++ b/src/moin/converters/_tests/test_moinwiki_in.py
@@ -17,12 +17,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page: '',
-        xlink: 'xlink',
-        html: 'xhtml',
-        xinclude: 'xinclude',
-    }
+    namespaces = {moin_page: "", xlink: "xlink", html: "xhtml", xinclude: "xinclude"}
 
     output_re = XMLNS_RE
 
@@ -30,410 +25,568 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('Text',
-         '<page><body><p>Text</p></body></page>'),
-        ('Text\nTest',
-         '<page><body><p>Text\nTest</p></body></page>'),
-        ('Text\n\nTest',
-         '<page><body><p>Text</p><p>Test</p></body></page>'),
-        ('[[http://moinmo.in/]]',
-         '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>'),
-        ('[[javascript:alert("xss")]]',
-         '<page><body><p><a xlink:href="wiki.local:javascript:alert%28%22xss%22%29">javascript:alert("xss")</a></p></body></page>'),
-        ('[[http://moinmo.in/|MoinMoin]]',
-         '<page><body><p><a xlink:href="http://moinmo.in/">MoinMoin</a></p></body></page>'),
-        ('[[MoinMoin]]',
-         '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
-        ('[[MoinMoin#Heading]]',
-         '<page><body><p><a xlink:href="wiki.local:MoinMoin#Heading">MoinMoin</a></p></body></page>'),
-        ('[[#Heading]]',
-         '<page><body><p><a xlink:href="wiki.local:#Heading"></a></p></body></page>'),
-        ('[[/inner2.png|{{/inner2.png||width=500}}]]',
-         '<page><body><p><a xlink:href="wiki.local:/inner2.png"><xinclude:include xhtml:width="500" xinclude:href="wiki.local:/inner2.png?" /></a></p></body></page>'),
-        ('{{somelocalimage|my alt text|width=10, height=10}}',
-         '<page><body><p><xinclude:include xhtml:alt="my alt text" xhtml:height="10" xhtml:width="10" xinclude:href="wiki.local:somelocalimage?" /></p></body></page>'),
+        ("Text", "<page><body><p>Text</p></body></page>"),
+        ("Text\nTest", "<page><body><p>Text\nTest</p></body></page>"),
+        ("Text\n\nTest", "<page><body><p>Text</p><p>Test</p></body></page>"),
+        (
+            "[[http://moinmo.in/]]",
+            '<page><body><p><a xlink:href="http://moinmo.in/">http://moinmo.in/</a></p></body></page>',
+        ),
+        (
+            '[[javascript:alert("xss")]]',
+            '<page><body><p><a xlink:href="wiki.local:javascript:alert%28%22xss%22%29">javascript:alert("xss")</a></p></body></page>',
+        ),
+        (
+            "[[http://moinmo.in/|MoinMoin]]",
+            '<page><body><p><a xlink:href="http://moinmo.in/">MoinMoin</a></p></body></page>',
+        ),
+        ("[[MoinMoin]]", '<page><body><p><a xlink:href="wiki.local:MoinMoin">MoinMoin</a></p></body></page>'),
+        (
+            "[[MoinMoin#Heading]]",
+            '<page><body><p><a xlink:href="wiki.local:MoinMoin#Heading">MoinMoin</a></p></body></page>',
+        ),
+        ("[[#Heading]]", '<page><body><p><a xlink:href="wiki.local:#Heading"></a></p></body></page>'),
+        (
+            "[[/inner2.png|{{/inner2.png||width=500}}]]",
+            '<page><body><p><a xlink:href="wiki.local:/inner2.png"><xinclude:include xhtml:width="500" xinclude:href="wiki.local:/inner2.png?" /></a></p></body></page>',
+        ),
+        (
+            "{{somelocalimage|my alt text|width=10, height=10}}",
+            '<page><body><p><xinclude:include xhtml:alt="my alt text" xhtml:height="10" xhtml:width="10" xinclude:href="wiki.local:somelocalimage?" /></p></body></page>',
+        ),
         # html5 requires img tags to have an alt attribute, html_out.py will add any required attributes that are missing
-        ('{{somelocalimage||width=10, height=10}}',
-         '<page><body><p><xinclude:include xhtml:height="10" xhtml:width="10" xinclude:href="wiki.local:somelocalimage?" /></p></body></page>'),
-        ('{{somelocalimage||width=10, &h=10}}',
-         '<page><body><p><xinclude:include xhtml:width="10" xinclude:href="wiki.local:somelocalimage?h=10" /></p></body></page>'),
-        ('before {{somelocalimage}} middle {{somelocalimage}} after',
-         '<page><body><p>before <xinclude:include xinclude:href="wiki.local:somelocalimage?" /> middle <xinclude:include xinclude:href="wiki.local:somelocalimage?" /> after</p></body></page>'),
-        ('before {{http://moinmo.in}} middle {{http://moinmo.in}} after',
-         '<page><body><p>before <object xlink:href="http://moinmo.in" /> middle <object xlink:href="http://moinmo.in" /> after</p></body></page>'),
+        (
+            "{{somelocalimage||width=10, height=10}}",
+            '<page><body><p><xinclude:include xhtml:height="10" xhtml:width="10" xinclude:href="wiki.local:somelocalimage?" /></p></body></page>',
+        ),
+        (
+            "{{somelocalimage||width=10, &h=10}}",
+            '<page><body><p><xinclude:include xhtml:width="10" xinclude:href="wiki.local:somelocalimage?h=10" /></p></body></page>',
+        ),
+        (
+            "before {{somelocalimage}} middle {{somelocalimage}} after",
+            '<page><body><p>before <xinclude:include xinclude:href="wiki.local:somelocalimage?" /> middle <xinclude:include xinclude:href="wiki.local:somelocalimage?" /> after</p></body></page>',
+        ),
+        (
+            "before {{http://moinmo.in}} middle {{http://moinmo.in}} after",
+            '<page><body><p>before <object xlink:href="http://moinmo.in" /> middle <object xlink:href="http://moinmo.in" /> after</p></body></page>',
+        ),
         # in html5, object tags must not have alt attributes, html_out.py will adjust this so alt text is placed before the </object>
-        ('{{http://moinmo.in/|test|width=10, height=10}}',
-         '<page><body><p><object xhtml:alt="test" xhtml:height="10" xhtml:width="10" xlink:href="http://moinmo.in/" /></p></body></page>'),
-        ('{{http://moinmo.in/}}',
-         '<page><body><p><object xlink:href="http://moinmo.in/" /></p></body></page>'),
-        ('{{http://moinmo.in/|MoinMoin}}',
-         '<page><body><p><object xhtml:alt="MoinMoin" xlink:href="http://moinmo.in/" /></p></body></page>'),
-        ('----',
-         '<page><body><separator class="moin-hr1" /></body></page>'),
+        (
+            "{{http://moinmo.in/|test|width=10, height=10}}",
+            '<page><body><p><object xhtml:alt="test" xhtml:height="10" xhtml:width="10" xlink:href="http://moinmo.in/" /></p></body></page>',
+        ),
+        ("{{http://moinmo.in/}}", '<page><body><p><object xlink:href="http://moinmo.in/" /></p></body></page>'),
+        (
+            "{{http://moinmo.in/|MoinMoin}}",
+            '<page><body><p><object xhtml:alt="MoinMoin" xlink:href="http://moinmo.in/" /></p></body></page>',
+        ),
+        ("----", '<page><body><separator class="moin-hr1" /></body></page>'),
     ]
 
-    @pytest.mark.parametrize('args', data)
+    @pytest.mark.parametrize("args", data)
     def test_base(self, args):
         self.do(*args)
 
     data = [
-        ('Text',
-         '<page><body style="background-color: red"><p>Text</p></body></page>',
-         {'arguments': Arguments(keyword={'style': 'background-color: red'})}),
+        (
+            "Text",
+            '<page><body style="background-color: red"><p>Text</p></body></page>',
+            {"arguments": Arguments(keyword={"style": "background-color: red"})},
+        )
     ]
 
-    @pytest.mark.parametrize('input,output,args', data)
+    @pytest.mark.parametrize("input,output,args", data)
     def test_args(self, input, output, args):
         self.do(input, output, args)
 
     data = [
-        ("''Emphasis''",
-         '<page><body><p><emphasis>Emphasis</emphasis></p></body></page>'),
-        ("'''Strong'''",
-         '<page><body><p><strong>Strong</strong></p></body></page>'),
-        ("'''''Both'''''",
-         '<page><body><p><strong><emphasis>Both</emphasis></strong></p></body></page>'),
-        ("'''''Mixed'''Emphasis''",
-         '<page><body><p><emphasis><strong>Mixed</strong>Emphasis</emphasis></p></body></page>'),
-        ("'''''Mixed''Strong'''",
-         '<page><body><p><strong><emphasis>Mixed</emphasis>Strong</strong></p></body></page>'),
-        ("Text ''Emphasis\n''Text",
-         '<page><body><p>Text <emphasis>Emphasis\n</emphasis>Text</p></body></page>'),
-        ("Text ''Emphasis\n\nText",
-         '<page><body><p>Text <emphasis>Emphasis</emphasis></p><p>Text</p></body></page>'),
-        ("Text''''''Text''''",
-         '<page><body><p>TextText</p></body></page>'),
-        ("''italic '''strongitalic ''''' normal",
-         '<page><body><p><emphasis>italic <strong>strongitalic </strong></emphasis> normal</p></body></page>'),
-        ("'''strong '''''italic '''strongitalic''''' normal",
-         '<page><body><p><strong>strong </strong><emphasis>italic <strong>strongitalic</strong></emphasis> normal</p></body></page>'),
+        ("''Emphasis''", "<page><body><p><emphasis>Emphasis</emphasis></p></body></page>"),
+        ("'''Strong'''", "<page><body><p><strong>Strong</strong></p></body></page>"),
+        ("'''''Both'''''", "<page><body><p><strong><emphasis>Both</emphasis></strong></p></body></page>"),
+        (
+            "'''''Mixed'''Emphasis''",
+            "<page><body><p><emphasis><strong>Mixed</strong>Emphasis</emphasis></p></body></page>",
+        ),
+        ("'''''Mixed''Strong'''", "<page><body><p><strong><emphasis>Mixed</emphasis>Strong</strong></p></body></page>"),
+        ("Text ''Emphasis\n''Text", "<page><body><p>Text <emphasis>Emphasis\n</emphasis>Text</p></body></page>"),
+        ("Text ''Emphasis\n\nText", "<page><body><p>Text <emphasis>Emphasis</emphasis></p><p>Text</p></body></page>"),
+        ("Text''''''Text''''", "<page><body><p>TextText</p></body></page>"),
+        (
+            "''italic '''strongitalic ''''' normal",
+            "<page><body><p><emphasis>italic <strong>strongitalic </strong></emphasis> normal</p></body></page>",
+        ),
+        (
+            "'''strong '''''italic '''strongitalic''''' normal",
+            "<page><body><p><strong>strong </strong><emphasis>italic <strong>strongitalic</strong></emphasis> normal</p></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_emphasis(self, input, output):
         self.do(input, output)
 
     data = [
-        ('=Not_a_Heading=',  # this is for better moin 1.x compatibility
-         '<page><body><p>=Not_a_Heading=</p></body></page>'),
-        ('= Heading 1 =',
-         '<page><body><h outline-level="1">Heading 1</h></body></page>'),
-        ('== Heading 2 ==',
-         '<page><body><h outline-level="2">Heading 2</h></body></page>'),
-        ('=== Heading 3 ===',
-         '<page><body><h outline-level="3">Heading 3</h></body></page>'),
-        ('==== Heading 4 ====',
-         '<page><body><h outline-level="4">Heading 4</h></body></page>'),
-        ('===== Heading 5 =====',
-         '<page><body><h outline-level="5">Heading 5</h></body></page>'),
-        ('====== Heading 6 ======',
-         '<page><body><h outline-level="6">Heading 6</h></body></page>'),
+        (
+            "=Not_a_Heading=",  # this is for better moin 1.x compatibility
+            "<page><body><p>=Not_a_Heading=</p></body></page>",
+        ),
+        ("= Heading 1 =", '<page><body><h outline-level="1">Heading 1</h></body></page>'),
+        ("== Heading 2 ==", '<page><body><h outline-level="2">Heading 2</h></body></page>'),
+        ("=== Heading 3 ===", '<page><body><h outline-level="3">Heading 3</h></body></page>'),
+        ("==== Heading 4 ====", '<page><body><h outline-level="4">Heading 4</h></body></page>'),
+        ("===== Heading 5 =====", '<page><body><h outline-level="5">Heading 5</h></body></page>'),
+        ("====== Heading 6 ======", '<page><body><h outline-level="6">Heading 6</h></body></page>'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_heading(self, input, output):
         self.do(input, output)
 
     data = [
-        ('__underline__',
-         '<page><body><p><ins>underline</ins></p></body></page>'),
-        (',,sub,,script',
-         '<page><body><p><span baseline-shift="sub">sub</span>script</p></body></page>'),
-        ('^super^script',
-         '<page><body><p><span baseline-shift="super">super</span>script</p></body></page>'),
-        ('~-smaller-~',
-         '<page><body><p><span font-size="85%">smaller</span></p></body></page>'),
-        ('~+larger+~',
-         '<page><body><p><span font-size="120%">larger</span></p></body></page>'),
-        ('--(strike through)--',
-         '<page><body><p><del>strike through</del></p></body></page>'),
-        ('normal ~+big __underline__ big+~ normal',
-         '<page><body><p>normal <span font-size="120%">big <ins>underline</ins> big</span> normal</p></body></page>'),
-        ('/* normal __underline__ normal */',
-         '<page><body><p><span class="comment">normal <ins>underline</ins> normal</span></p></body></page>'),
-        ('&quot;',
-         '<page><body><p>"</p></body></page>'),
-        ('&#34;',
-         '<page><body><p>"</p></body></page>'),
-        ('&#x22;',
-         '<page><body><p>"</p></body></page>'),
+        ("__underline__", "<page><body><p><ins>underline</ins></p></body></page>"),
+        (",,sub,,script", '<page><body><p><span baseline-shift="sub">sub</span>script</p></body></page>'),
+        ("^super^script", '<page><body><p><span baseline-shift="super">super</span>script</p></body></page>'),
+        ("~-smaller-~", '<page><body><p><span font-size="85%">smaller</span></p></body></page>'),
+        ("~+larger+~", '<page><body><p><span font-size="120%">larger</span></p></body></page>'),
+        ("--(strike through)--", "<page><body><p><del>strike through</del></p></body></page>"),
+        (
+            "normal ~+big __underline__ big+~ normal",
+            '<page><body><p>normal <span font-size="120%">big <ins>underline</ins> big</span> normal</p></body></page>',
+        ),
+        (
+            "/* normal __underline__ normal */",
+            '<page><body><p><span class="comment">normal <ins>underline</ins> normal</span></p></body></page>',
+        ),
+        ("&quot;", '<page><body><p>"</p></body></page>'),
+        ("&#34;", '<page><body><p>"</p></body></page>'),
+        ("&#x22;", '<page><body><p>"</p></body></page>'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_inline(self, input, output):
         self.do(input, output)
 
     data = [
-        (' *Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        (' * Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        (' 1. Item',
-         '<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        (' Key:: Item',
-         '<page><body><list><list-item><list-item-label>Key</list-item-label><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        ('  Item',
-         '<page><body><list item-label-generate="unordered" list-style-type="no-bullet"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>'),
-        (' *Item\nText',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>'),
-        (' *Item\n Item',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list></body></page>'),
-        (' *Item 1\n *Item 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>'),
-        (' *Item 1\n  *Item 1.2\n *Item 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>'),
-        (' *List 1\n\n *List 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>'),
-        (' * List 1\n 1. List 2',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="ordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>'),
+        (
+            " *Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " * Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " 1. Item",
+            '<page><body><list item-label-generate="ordered"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " Key:: Item",
+            "<page><body><list><list-item><list-item-label>Key</list-item-label><list-item-body>Item</list-item-body></list-item></list></body></page>",
+        ),
+        (
+            "  Item",
+            '<page><body><list item-label-generate="unordered" list-style-type="no-bullet"><list-item><list-item-body>Item</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " *Item\nText",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>',
+        ),
+        (
+            " *Item\n Item",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item\nItem</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " *Item 1\n *Item 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1</list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " *Item 1\n  *Item 1.2\n *Item 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>Item 1<list item-label-generate="unordered"><list-item><list-item-body>Item 1.2</list-item-body></list-item></list></list-item-body></list-item><list-item><list-item-body>Item 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " *List 1\n\n *List 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="unordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>',
+        ),
+        (
+            " * List 1\n 1. List 2",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body>List 1</list-item-body></list-item></list><list item-label-generate="ordered"><list-item><list-item-body>List 2</list-item-body></list-item></list></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<<BR>>',
-         '<page><body /></page>'),
-        ('Text<<BR>>Text',
-         '<page><body><p>Text<line-break />Text</p></body></page>'),
-        ('<<Macro>>',
-         '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('<<Macro>><<Macro>>',
-         '<page><body><p><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('<<Macro(arg)>>',
-         '<page><body><part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></part></body></page>'),
+        ("<<BR>>", "<page><body /></page>"),
+        ("Text<<BR>>Text", "<page><body><p>Text<line-break />Text</p></body></page>"),
+        (
+            "<<Macro>>",
+            '<page><body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
+        (
+            "<<Macro>><<Macro>>",
+            '<page><body><p><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /><inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "<<Macro(arg)>>",
+            '<page><body><part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></part></body></page>',
+        ),
         # these macro tests copied from test_creole_in, next test is different because leading space creates unordered list in moin2
-        (' <<Macro>> ',
-         '<page><body><list item-label-generate="unordered" list-style-type="no-bullet"><list-item><list-item-body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></list-item-body></list-item></list></body></page>'),
-        ('Text <<Macro>>',
-         '<page><body><p>Text <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('Text <<Macro(arg)>>',
-         '<page><body><p>Text <inline-part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></p></body></page>'),
-        ('Text\n<<Macro>>',
-         '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('Text\nText <<Macro>>',
-         '<page><body><p>Text\nText <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>'),
-        ('Text\n\n<<Macro>>',
-         '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>'),
+        (
+            " <<Macro>> ",
+            '<page><body><list item-label-generate="unordered" list-style-type="no-bullet"><list-item><list-item-body><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "Text <<Macro>>",
+            '<page><body><p>Text <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "Text <<Macro(arg)>>",
+            '<page><body><p>Text <inline-part alt="&lt;&lt;Macro(arg)&gt;&gt;" content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></p></body></page>',
+        ),
+        (
+            "Text\n<<Macro>>",
+            '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
+        (
+            "Text\nText <<Macro>>",
+            '<page><body><p>Text\nText <inline-part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></p></body></page>',
+        ),
+        (
+            "Text\n\n<<Macro>>",
+            '<page><body><p>Text</p><part alt="&lt;&lt;Macro&gt;&gt;" content-type="x-moin/macro;name=Macro" /></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macro(self, input, output):
         self.do(input, output)
 
     data = [
-        ('||Cell||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||Cell 1||Cell 2||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>'),
-        ('||Row 1||\n||Row 2||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>'),
-        ('||Cell 1.1||Cell 1.2||\n||Cell 2.1||Cell 2.2||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell 1.1</table-cell><table-cell>Cell 1.2</table-cell></table-row><table-row><table-cell>Cell 2.1</table-cell><table-cell>Cell 2.2</table-cell></table-row></table-body></table></body></page>'),
-        ('||Header||\n===\n||Body||\n=====\n||Footer||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Header</table-cell></table-row></table-body><table-body><table-row><table-cell>Body</table-cell></table-row></table-body><table-body><table-row><table-cell>Footer</table-cell></table-row></table-body></table></body></page>'),
-        ('||<<DateTime>>||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><inline-part alt="&lt;&lt;DateTime&gt;&gt;" content-type="x-moin/macro;name=DateTime" /></table-cell></table-row></table-body></table></body></page>'),
+        (
+            "||Cell||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||Cell 1||Cell 2||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell 1</table-cell><table-cell>Cell 2</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||Row 1||\n||Row 2||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Row 1</table-cell></table-row><table-row><table-cell>Row 2</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||Cell 1.1||Cell 1.2||\n||Cell 2.1||Cell 2.2||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Cell 1.1</table-cell><table-cell>Cell 1.2</table-cell></table-row><table-row><table-cell>Cell 2.1</table-cell><table-cell>Cell 2.2</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||Header||\n===\n||Body||\n=====\n||Footer||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell>Header</table-cell></table-row></table-body><table-body><table-row><table-cell>Body</table-cell></table-row></table-body><table-body><table-row><table-cell>Footer</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<<DateTime>>||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><inline-part alt="&lt;&lt;DateTime&gt;&gt;" content-type="x-moin/macro;name=DateTime" /></table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('||{{cat}}||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>'),
-        ('||{{cat|kitty}}||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:alt="kitty" xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>'),
-        ('||{{cat|kitty|width=160}}||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:alt="kitty" xhtml:width="160" xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>'),
-        ('||{{cat||width=160}} text {{cat||width=160}} text [[link]]||',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:width="160" xinclude:href="wiki.local:cat?" /> text <xinclude:include xhtml:width="160" xinclude:href="wiki.local:cat?" /> text <a xlink:href="wiki.local:link">link</a></table-cell></table-row></table-body></table></body></page>'),
+        (
+            "||{{cat}}||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||{{cat|kitty}}||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:alt="kitty" xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||{{cat|kitty|width=160}}||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:alt="kitty" xhtml:width="160" xinclude:href="wiki.local:cat?" /></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||{{cat||width=160}} text {{cat||width=160}} text [[link]]||",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><xinclude:include xhtml:width="160" xinclude:href="wiki.local:cat?" /> text <xinclude:include xhtml:width="160" xinclude:href="wiki.local:cat?" /> text <a xlink:href="wiki.local:link">link</a></table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table_links(self, input, output):
         self.do(input, output)
 
     data = [
         # a class of moin-wiki-table is added to all tables, html_out may create thead and tfoot tags
-        ('||||Span||\n\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Span</table-cell></table-row></table-body></table></body></page>'),
-        ('||<-2>Span||\n\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Span</table-cell></table-row></table-body></table></body></page>'),
-        ('||<|2>Span||\n\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-rows-spanned="2">Span</table-cell></table-row></table-body></table></body></page>'),
-        ('||<tableclass="table" rowclass="row" class="cell">Cell||\n',
-         '<page><body><table class="table moin-wiki-table"><table-body><table-row class="row"><table-cell class="cell">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<tablestyle="table" rowstyle="row" style="cell">Cell||\n',
-         '<page><body><table class="moin-wiki-table" style="table;"><table-body><table-row style="row;"><table-cell style="cell;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<tablestyle="background-color: yellow" rowstyle="background-color: red" #0000FF>Cell||\n',
-         '<page><body><table class="moin-wiki-table" style="background-color: yellow;"><table-body><table-row style="background-color: red;"><table-cell style="background-color: #0000FF;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<width="20em">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="width: 20em;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<tablebgcolor="red">Cell||\n',
-         '<page><body><table class="moin-wiki-table" style="background-color: red;"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<rowbgcolor="red">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row style="background-color: red;"><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<bgcolor="red">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="background-color: red;">Cell</table-cell></table-row></table-body></table></body></page>'),
-
-        ('||<tableid="my-id">Cell||\n',
-         '<page><body><table class="moin-wiki-table" id="my-id"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<rowid="my-id">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row id="my-id"><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<id="my-id">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell id="my-id">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<rowspan="2">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<colspan="2">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<caption="My Table">Cell||\n',
-         '<page><body><table class="moin-wiki-table"><caption>My Table</caption><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>'),
-        ("||'''Cell'''||\n",
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><strong>Cell</strong></table-cell></table-row></table-body></table></body></page>'),
-        ('||<^>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="vertical-align: top;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<v>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="vertical-align: bottom;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<(>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: left;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<:>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: center;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<)>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: right;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<99%>Cell||\n',
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="width: 99%;">Cell</table-cell></table-row></table-body></table></body></page>'),
-        ('||<X>Cell||\n',
-         # '\xa0' below is equal to &nbsp;
-         '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="background-color: pink; color: black;">[ Error: "X" is invalid within &lt;X&gt;' +
-         '\xa0' + ']<line-break />Cell</table-cell></table-row></table-body></table></body></page>'),
+        (
+            "||||Span||\n\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Span</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<-2>Span||\n\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Span</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<|2>Span||\n\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-rows-spanned="2">Span</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<tableclass="table" rowclass="row" class="cell">Cell||\n',
+            '<page><body><table class="table moin-wiki-table"><table-body><table-row class="row"><table-cell class="cell">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<tablestyle="table" rowstyle="row" style="cell">Cell||\n',
+            '<page><body><table class="moin-wiki-table" style="table;"><table-body><table-row style="row;"><table-cell style="cell;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<tablestyle="background-color: yellow" rowstyle="background-color: red" #0000FF>Cell||\n',
+            '<page><body><table class="moin-wiki-table" style="background-color: yellow;"><table-body><table-row style="background-color: red;"><table-cell style="background-color: #0000FF;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<width="20em">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="width: 20em;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<tablebgcolor="red">Cell||\n',
+            '<page><body><table class="moin-wiki-table" style="background-color: red;"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<rowbgcolor="red">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row style="background-color: red;"><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<bgcolor="red">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="background-color: red;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<tableid="my-id">Cell||\n',
+            '<page><body><table class="moin-wiki-table" id="my-id"><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<rowid="my-id">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row id="my-id"><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<id="my-id">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell id="my-id">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<rowspan="2">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-rows-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<colspan="2">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell number-columns-spanned="2">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            '||<caption="My Table">Cell||\n',
+            '<page><body><table class="moin-wiki-table"><caption>My Table</caption><table-body><table-row><table-cell>Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||'''Cell'''||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell><strong>Cell</strong></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<^>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="vertical-align: top;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<v>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="vertical-align: bottom;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<(>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: left;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<:>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: center;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<)>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="text-align: right;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<99%>Cell||\n",
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="width: 99%;">Cell</table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "||<X>Cell||\n",
+            # '\xa0' below is equal to &nbsp;
+            '<page><body><table class="moin-wiki-table"><table-body><table-row><table-cell style="background-color: pink; color: black;">[ Error: "X" is invalid within &lt;X&gt;'
+            + "\xa0"
+            + "]<line-break />Cell</table-cell></table-row></table-body></table></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table_attributes(self, input, output):
         self.do(input, output)
 
     data = [
-        ('{{{nowiki}}}',
-         '<page><body><p><samp>nowiki</samp></p></body></page>'),
-        ('`nowiki`',
-         '<page><body><p><code>nowiki</code></p></body></page>'),
-        ('{{{{nowiki}}}}',
-         '<page><body><p><samp>{nowiki}</samp></p></body></page>'),
-        ('text: {{{nowiki}}}, text',
-         '<page><body><p>text: <samp>nowiki</samp>, text</p></body></page>'),
-        ('{{{\nnowiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args></nowiki-args>nowiki</nowiki></body></page>'),
-        ('{{{\nnowiki\nno\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args></nowiki-args>nowiki\nno\nwiki</nowiki></body></page>'),
-        ('{{{nowiki}}} {{{nowiki}}}',
-         '<page><body><p><samp>nowiki</samp> <samp>nowiki</samp></p></body></page>'),
-        ('{{{}}}',
-         '<page><body><p><samp></samp></p></body></page>'),
-        ('``',
-         '<page><body><p><code></code></p></body></page>'),
+        ("{{{nowiki}}}", "<page><body><p><samp>nowiki</samp></p></body></page>"),
+        ("`nowiki`", "<page><body><p><code>nowiki</code></p></body></page>"),
+        ("{{{{nowiki}}}}", "<page><body><p><samp>{nowiki}</samp></p></body></page>"),
+        ("text: {{{nowiki}}}, text", "<page><body><p>text: <samp>nowiki</samp>, text</p></body></page>"),
+        ("{{{\nnowiki\n}}}", "<page><body><nowiki>3<nowiki-args></nowiki-args>nowiki</nowiki></body></page>"),
+        (
+            "{{{\nnowiki\nno\nwiki\n}}}",
+            "<page><body><nowiki>3<nowiki-args></nowiki-args>nowiki\nno\nwiki</nowiki></body></page>",
+        ),
+        ("{{{nowiki}}} {{{nowiki}}}", "<page><body><p><samp>nowiki</samp> <samp>nowiki</samp></p></body></page>"),
+        ("{{{}}}", "<page><body><p><samp></samp></p></body></page>"),
+        ("``", "<page><body><p><code></code></p></body></page>"),
         # XXX: Is <page> correct?
-        ('{{{#!\ntest\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!</nowiki-args>test</nowiki></body></page>'),
-        ('{{{#!(style="background-color: red")\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!(style="background-color: red")</nowiki-args>wiki</nowiki></body></page>'),
-        ('{{{#!text/plain\ntext\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!text/plain</nowiki-args>text</nowiki></body></page>'),
+        ("{{{#!\ntest\n}}}", "<page><body><nowiki>3<nowiki-args>#!</nowiki-args>test</nowiki></body></page>"),
+        (
+            '{{{#!(style="background-color: red")\nwiki\n}}}',
+            '<page><body><nowiki>3<nowiki-args>#!(style="background-color: red")</nowiki-args>wiki</nowiki></body></page>',
+        ),
+        (
+            "{{{#!text/plain\ntext\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!text/plain</nowiki-args>text</nowiki></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_nowiki(self, input, output):
         self.do(input, output)
 
     data = [
-        ('{{{#!wiki\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!wiki</nowiki-args>wiki</nowiki></body></page>'),
-        ('{{{{{#!wiki\nwiki\n}}}}}',
-         '<page><body><nowiki>5<nowiki-args>#!wiki</nowiki-args>wiki</nowiki></body></page>'),
-        ('{{{#!wiki(style="background-color: red")\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!wiki(style="background-color: red")</nowiki-args>wiki</nowiki></body></page>'),
-        ('{{{#!highlight python\nimport os\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!highlight python</nowiki-args>import os</nowiki></body></page>'),
-        ('{{{#!python\nimport os\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!python</nowiki-args>import os</nowiki></body></page>'),
-        ('{{{#!csv\na;b;c\nd;e;22\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!csv</nowiki-args>a;b;c\nd;e;22</nowiki></body></page>'),
-        ('{{{#!csv ,\na,b,c\nd,e,22\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!csv ,</nowiki-args>a,b,c\nd,e,22</nowiki></body></page>'),
+        ("{{{#!wiki\nwiki\n}}}", "<page><body><nowiki>3<nowiki-args>#!wiki</nowiki-args>wiki</nowiki></body></page>"),
+        (
+            "{{{{{#!wiki\nwiki\n}}}}}",
+            "<page><body><nowiki>5<nowiki-args>#!wiki</nowiki-args>wiki</nowiki></body></page>",
+        ),
+        (
+            '{{{#!wiki(style="background-color: red")\nwiki\n}}}',
+            '<page><body><nowiki>3<nowiki-args>#!wiki(style="background-color: red")</nowiki-args>wiki</nowiki></body></page>',
+        ),
+        (
+            "{{{#!highlight python\nimport os\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!highlight python</nowiki-args>import os</nowiki></body></page>",
+        ),
+        (
+            "{{{#!python\nimport os\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!python</nowiki-args>import os</nowiki></body></page>",
+        ),
+        (
+            "{{{#!csv\na;b;c\nd;e;22\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!csv</nowiki-args>a;b;c\nd;e;22</nowiki></body></page>",
+        ),
+        (
+            "{{{#!csv ,\na,b,c\nd,e,22\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!csv ,</nowiki-args>a,b,c\nd,e,22</nowiki></body></page>",
+        ),
         # TODO: Backward compatibility
-        ('{{{#!wiki red/solid\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!wiki red/solid</nowiki-args>wiki</nowiki></body></page>'),
-        ('{{{#!wiki red/solid\nwiki\n\nwiki\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!wiki red/solid</nowiki-args>wiki\n\nwiki</nowiki></body></page>'),
-        ('{{{#!rst\nHeading\n-------\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!rst</nowiki-args>Heading\n-------</nowiki></body></page>'),
-        ("{{{#!docbook\n<article xmlns='http://docbook.org/ns/docbook' xmlns:xlink='http://www.w3.org/1999/xlink'>\n<section>\n<title>A docbook document</title>\n</section>\n</article>\n}}}",
-         "<page><body><nowiki>3<nowiki-args>#!docbook</nowiki-args>&lt;article xmlns='http://docbook.org/ns/docbook' xmlns:xlink='http://www.w3.org/1999/xlink'&gt;\n&lt;section&gt;\n&lt;title&gt;A docbook document&lt;/title&gt;\n&lt;/section&gt;\n&lt;/article&gt;</nowiki></body></page>"),
-        ('{{{#!creole\n|=A|1\n|=B|2\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!creole</nowiki-args>|=A|1\n|=B|2</nowiki></body></page>'),
-        ('{{{#!text/x.moin.creole\ntext\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!text/x.moin.creole</nowiki-args>text</nowiki></body></page>'),
-        ('{{{#!markdown\n~~~\naaa\nbbb\nccc\n~~~\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!markdown</nowiki-args>~~~\naaa\nbbb\nccc\n~~~</nowiki></body></page>'),
-        ('{{{#!mediawiki\n=== Level 3 ===\n}}}',
-         '<page><body><nowiki>3<nowiki-args>#!mediawiki</nowiki-args>=== Level 3 ===</nowiki></body></page>'),
+        (
+            "{{{#!wiki red/solid\nwiki\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!wiki red/solid</nowiki-args>wiki</nowiki></body></page>",
+        ),
+        (
+            "{{{#!wiki red/solid\nwiki\n\nwiki\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!wiki red/solid</nowiki-args>wiki\n\nwiki</nowiki></body></page>",
+        ),
+        (
+            "{{{#!rst\nHeading\n-------\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!rst</nowiki-args>Heading\n-------</nowiki></body></page>",
+        ),
+        (
+            "{{{#!docbook\n<article xmlns='http://docbook.org/ns/docbook' xmlns:xlink='http://www.w3.org/1999/xlink'>\n<section>\n<title>A docbook document</title>\n</section>\n</article>\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!docbook</nowiki-args>&lt;article xmlns='http://docbook.org/ns/docbook' xmlns:xlink='http://www.w3.org/1999/xlink'&gt;\n&lt;section&gt;\n&lt;title&gt;A docbook document&lt;/title&gt;\n&lt;/section&gt;\n&lt;/article&gt;</nowiki></body></page>",
+        ),
+        (
+            "{{{#!creole\n|=A|1\n|=B|2\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!creole</nowiki-args>|=A|1\n|=B|2</nowiki></body></page>",
+        ),
+        (
+            "{{{#!text/x.moin.creole\ntext\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!text/x.moin.creole</nowiki-args>text</nowiki></body></page>",
+        ),
+        (
+            "{{{#!markdown\n~~~\naaa\nbbb\nccc\n~~~\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!markdown</nowiki-args>~~~\naaa\nbbb\nccc\n~~~</nowiki></body></page>",
+        ),
+        (
+            "{{{#!mediawiki\n=== Level 3 ===\n}}}",
+            "<page><body><nowiki>3<nowiki-args>#!mediawiki</nowiki-args>=== Level 3 ===</nowiki></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_nowiki_parsers(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Text\n * Item\n\nText',
-         '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>'),
-        ('Text\n||Item||\nText',
-         '<page><body><p>Text</p><table class="moin-wiki-table"><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table><p>Text</p></body></page>'),
+        (
+            "Text\n * Item\n\nText",
+            '<page><body><p>Text</p><list item-label-generate="unordered"><list-item><list-item-body>Item</list-item-body></list-item></list><p>Text</p></body></page>',
+        ),
+        (
+            "Text\n||Item||\nText",
+            '<page><body><p>Text</p><table class="moin-wiki-table"><table-body><table-row><table-cell>Item</table-cell></table-row></table-body></table><p>Text</p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_composite(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[[MoinMoin:RecentChanges]]',
-         '<page><body><p><a xlink:href="wiki://MoinMoin/RecentChanges">RecentChanges</a></p></body></page>'),
-        ('[[MoinMoin:RecentChanges|changes]]',
-         '<page><body><p><a xlink:href="wiki://MoinMoin/RecentChanges">changes</a></p></body></page>'),
-        ('[[MoinMoin:Foo/Bar.Baz]]',
-         '<page><body><p><a xlink:href="wiki://MoinMoin/Foo/Bar.Baz">Foo/Bar.Baz</a></p></body></page>'),
-        ('[[MoinMoin:Blank In Page Name|blank in page name]]',
-         '<page><body><p><a xlink:href="wiki://MoinMoin/Blank%20In%20Page%20Name">blank in page name</a></p></body></page>'),
-        ('[[InvalidWikiName:RecentChanges]]',
-         '<page><body><p><a xlink:href="wiki.local:InvalidWikiName:RecentChanges">InvalidWikiName:RecentChanges</a></p></body></page>'),
+        (
+            "[[MoinMoin:RecentChanges]]",
+            '<page><body><p><a xlink:href="wiki://MoinMoin/RecentChanges">RecentChanges</a></p></body></page>',
+        ),
+        (
+            "[[MoinMoin:RecentChanges|changes]]",
+            '<page><body><p><a xlink:href="wiki://MoinMoin/RecentChanges">changes</a></p></body></page>',
+        ),
+        (
+            "[[MoinMoin:Foo/Bar.Baz]]",
+            '<page><body><p><a xlink:href="wiki://MoinMoin/Foo/Bar.Baz">Foo/Bar.Baz</a></p></body></page>',
+        ),
+        (
+            "[[MoinMoin:Blank In Page Name|blank in page name]]",
+            '<page><body><p><a xlink:href="wiki://MoinMoin/Blank%20In%20Page%20Name">blank in page name</a></p></body></page>',
+        ),
+        (
+            "[[InvalidWikiName:RecentChanges]]",
+            '<page><body><p><a xlink:href="wiki.local:InvalidWikiName:RecentChanges">InvalidWikiName:RecentChanges</a></p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_interwiki(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[[mailto:root]]',
-         '<page><body><p><a xlink:href="mailto:root">mailto:root</a></p></body></page>'),
-        ('[[mailto:foo@bar.baz]]',
-         '<page><body><p><a xlink:href="mailto:foo@bar.baz">mailto:foo@bar.baz</a></p></body></page>'),
-        ('[[mailto:foo@bar.baz|write me]]',
-         '<page><body><p><a xlink:href="mailto:foo@bar.baz">write me</a></p></body></page>'),
-        ('[[mailto:foo.bar_baz@bar.baz]]',  # . and _ are special characters commonly allowed by email systems
-         '<page><body><p><a xlink:href="mailto:foo.bar_baz@bar.baz">mailto:foo.bar_baz@bar.baz</a></p></body></page>'),
+        ("[[mailto:root]]", '<page><body><p><a xlink:href="mailto:root">mailto:root</a></p></body></page>'),
+        (
+            "[[mailto:foo@bar.baz]]",
+            '<page><body><p><a xlink:href="mailto:foo@bar.baz">mailto:foo@bar.baz</a></p></body></page>',
+        ),
+        (
+            "[[mailto:foo@bar.baz|write me]]",
+            '<page><body><p><a xlink:href="mailto:foo@bar.baz">write me</a></p></body></page>',
+        ),
+        (
+            "[[mailto:foo.bar_baz@bar.baz]]",  # . and _ are special characters commonly allowed by email systems
+            '<page><body><p><a xlink:href="mailto:foo.bar_baz@bar.baz">mailto:foo.bar_baz@bar.baz</a></p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_email(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv(input, 'text/x.moin.wiki;charset=utf-8', **args)
+        out = self.conv(input, "text/x.moin.wiki;charset=utf-8", **args)
         assert self.serialize_strip(out) == output
diff --git a/src/moin/converters/_tests/test_moinwiki_in_out.py b/src/moin/converters/_tests/test_moinwiki_in_out.py
index a7be41929..3e47dd577 100644
--- a/src/moin/converters/_tests/test_moinwiki_in_out.py
+++ b/src/moin/converters/_tests/test_moinwiki_in_out.py
@@ -25,13 +25,14 @@
 class TestConverter:
 
     input_namespaces = 'xmlns="{}" xmlns:page="{}" xmlns:xlink="{}" xmlns:xinclude="{}" xmlns:html="{}"'.format(
-        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace)
+        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace
+    )
 
     namespaces = {
-        moin_page.namespace: 'page',
-        xlink.namespace: 'xlink',
-        xinclude.namespace: 'xinclude',
-        html.namespace: 'html',
+        moin_page.namespace: "page",
+        xlink.namespace: "xlink",
+        xinclude.namespace: "xinclude",
+        html.namespace: "html",
     }
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
@@ -41,110 +42,96 @@ def setup_class(self):
         self.conv_out = conv_out()
 
     data = [
-        ('Text',
-         'Text\n'),
-        ('Text\n\nText\n',
-         'Text\n\nText\n'),
-        ('----\n-----\n------\n',
-         '----\n-----\n------\n'),
-        ("'''strong or bold'''\n",
-         "'''strong or bold'''\n"),
-        ("''emphasis or italic''\n",
-         "''emphasis or italic''\n"),
+        ("Text", "Text\n"),
+        ("Text\n\nText\n", "Text\n\nText\n"),
+        ("----\n-----\n------\n", "----\n-----\n------\n"),
+        ("'''strong or bold'''\n", "'''strong or bold'''\n"),
+        ("''emphasis or italic''\n", "''emphasis or italic''\n"),
         # extraneous x required below to prevent IndexError, side effect of serializer
-        ('{{{{{x\nblockcode\n}}}}}\n',
-         '{{{{{x\nblockcode\n}}}}}\n'),
-        ('`monospace`\n',
-         '`monospace`\n'),
-        ('--(stroke)--\n',
-         '--(stroke)--\n'),
-        ('__underline__\n',
-         '__underline__\n'),
-        ('~+larger+~\n',
-         '~+larger+~\n'),
-        ('~-smaller-~\n',
-         '~-smaller-~\n'),
-        ('^super^script\n',
-         '^super^script\n'),
-        (',,sub,,script\n',
-         ',,sub,,script\n'),
-        ('#ANY any',
-         '#ANY any\n'),
+        ("{{{{{x\nblockcode\n}}}}}\n", "{{{{{x\nblockcode\n}}}}}\n"),
+        ("`monospace`\n", "`monospace`\n"),
+        ("--(stroke)--\n", "--(stroke)--\n"),
+        ("__underline__\n", "__underline__\n"),
+        ("~+larger+~\n", "~+larger+~\n"),
+        ("~-smaller-~\n", "~-smaller-~\n"),
+        ("^super^script\n", "^super^script\n"),
+        (",,sub,,script\n", ",,sub,,script\n"),
+        ("#ANY any", "#ANY any\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('/* simple inline */',
-         '/* simple inline */'),
-        ("text /* text ''with '''markup''''' */ text",
-         "text /* text ''with '''markup''''' */ text"),
-        ('## block 1\n\n## block 2',
-         '## block 1\n\n## block 2'),
-
+        ("/* simple inline */", "/* simple inline */"),
+        ("text /* text ''with '''markup''''' */ text", "text /* text ''with '''markup''''' */ text"),
+        ("## block 1\n\n## block 2", "## block 1\n\n## block 2"),
         # \n is omitted from output because serialize method (see below) joins adjacent text children
-        ('## block line 1\n## block line 2\n\n',
-         '## block line 1## block line 2\n\n'),
+        ("## block line 1\n## block line 2\n\n", "## block line 1## block line 2\n\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_comments(self, input, output):
         self.do(input, output)
 
     data = [
-        ('{{{\ndef hello():\n    print "Hello World!"\n}}}',
-         '{{{\ndef hello():\n    print "Hello World!"\n}}}'),
-        ('{{{{\ndef hello():\n    print "Hello World!"\n}}}}',
-         '{{{{\ndef hello():\n    print "Hello World!"\n}}}}'),
-        ('{{{#!highlight python\ndef hello():\n    print "Hello World!"\n}}}',
-         '{{{#!highlight python\ndef hello():\n    print "Hello World!"\n}}}'),
-        ('{{{#!python\nimport sys\n}}}',
-         '{{{#!python\nimport sys\n}}}'),
-        ('{{{#!creole\n... **bold** ...\n}}}',
-         '{{{#!creole\n... **bold** ...\n}}}'),
-        ('{{{#!creole\n|=X|1\n|=Y|123\n|=Z|12345\n}}}',
-         '{{{#!creole\n|=X|1\n|=Y|123\n|=Z|12345\n}}}'),
-        ('{{{#!csv ,\nFruit,Color,Quantity\napple,red,5\nbanana,yellow,23\ngrape,purple,126\n}}}',
-         '{{{#!csv ,\nFruit,Color,Quantity\napple,red,5\nbanana,yellow,23\ngrape,purple,126\n}}}'),
+        ('{{{\ndef hello():\n    print "Hello World!"\n}}}', '{{{\ndef hello():\n    print "Hello World!"\n}}}'),
+        ('{{{{\ndef hello():\n    print "Hello World!"\n}}}}', '{{{{\ndef hello():\n    print "Hello World!"\n}}}}'),
+        (
+            '{{{#!highlight python\ndef hello():\n    print "Hello World!"\n}}}',
+            '{{{#!highlight python\ndef hello():\n    print "Hello World!"\n}}}',
+        ),
+        ("{{{#!python\nimport sys\n}}}", "{{{#!python\nimport sys\n}}}"),
+        ("{{{#!creole\n... **bold** ...\n}}}", "{{{#!creole\n... **bold** ...\n}}}"),
+        ("{{{#!creole\n|=X|1\n|=Y|123\n|=Z|12345\n}}}", "{{{#!creole\n|=X|1\n|=Y|123\n|=Z|12345\n}}}"),
+        (
+            "{{{#!csv ,\nFruit,Color,Quantity\napple,red,5\nbanana,yellow,23\ngrape,purple,126\n}}}",
+            "{{{#!csv ,\nFruit,Color,Quantity\napple,red,5\nbanana,yellow,23\ngrape,purple,126\n}}}",
+        ),
         # old style arguments
-        ("{{{#!wiki caution\n '''Don't overuse admonitions'''\n}}}",
-         "{{{#!wiki caution\n '''Don't overuse admonitions'''\n}}}"),
-        ('{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}',
-         '{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}'),
-        ("""{{{#!wiki red/solid\nThis is wiki markup in a '''div''' with __css__ `class="red solid"`.\n}}}""",
-         """{{{#!wiki red/solid\nThis is wiki markup in a '''div''' with __css__ `class="red solid"`.\n}}}"""),
+        (
+            "{{{#!wiki caution\n '''Don't overuse admonitions'''\n}}}",
+            "{{{#!wiki caution\n '''Don't overuse admonitions'''\n}}}",
+        ),
+        (
+            "{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}",
+            "{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}",
+        ),
+        (
+            """{{{#!wiki red/solid\nThis is wiki markup in a '''div''' with __css__ `class="red solid"`.\n}}}""",
+            """{{{#!wiki red/solid\nThis is wiki markup in a '''div''' with __css__ `class="red solid"`.\n}}}""",
+        ),
         # new style arguments
-        ('{{{#!wiki (style="color: green")\nThis is wiki markup in a """div""" with `style="color: green"`.\n}}}',
-         '{{{#!wiki (style="color: green")\nThis is wiki markup in a """div""" with `style="color: green"`.\n}}}'),
-        ('{{{#!wiki (style="color: green")\ngreen\n}}}',
-         '{{{#!wiki (style="color: green")\ngreen\n}}}'),
-        ('{{{#!wiki (style="color: green" class="dotted")\ngreen\n}}}',
-         '{{{#!wiki (style="color: green" class="dotted")\ngreen\n}}}'),
+        (
+            '{{{#!wiki (style="color: green")\nThis is wiki markup in a """div""" with `style="color: green"`.\n}}}',
+            '{{{#!wiki (style="color: green")\nThis is wiki markup in a """div""" with `style="color: green"`.\n}}}',
+        ),
+        ('{{{#!wiki (style="color: green")\ngreen\n}}}', '{{{#!wiki (style="color: green")\ngreen\n}}}'),
+        (
+            '{{{#!wiki (style="color: green" class="dotted")\ngreen\n}}}',
+            '{{{#!wiki (style="color: green" class="dotted")\ngreen\n}}}',
+        ),
         # multi-level
-        ('{{{#!wiki green\ngreen\n{{{{#!wiki orange\norange\n}}}}\ngreen\n}}}',
-         '{{{#!wiki green\ngreen\n{{{{#!wiki orange\norange\n}}}}\ngreen\n}}}'),
+        (
+            "{{{#!wiki green\ngreen\n{{{{#!wiki orange\norange\n}}}}\ngreen\n}}}",
+            "{{{#!wiki green\ngreen\n{{{{#!wiki orange\norange\n}}}}\ngreen\n}}}",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_nowiki(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<<Anchor(anchorname)>>',
-         '<<Anchor(anchorname)>>\n'),
-        ('<<FootNote(test)>>',
-         '<<FootNote(test)>>\n'),
-        ('<<TableOfContents(2)>>',
-         '<<TableOfContents(2)>>\n'),
-        ('<<TeudView()>>',
-         '<<TeudView()>>\n'),
-        ('||<<TeudView()>>||',
-         '||<<TeudView()>>||\n'),
+        ("<<Anchor(anchorname)>>", "<<Anchor(anchorname)>>\n"),
+        ("<<FootNote(test)>>", "<<FootNote(test)>>\n"),
+        ("<<TableOfContents(2)>>", "<<TableOfContents(2)>>\n"),
+        ("<<TeudView()>>", "<<TeudView()>>\n"),
+        ("||<<TeudView()>>||", "||<<TeudView()>>||\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macros(self, input, output):
         self.do(input, output)
 
@@ -153,7 +140,8 @@ def test_macros(self, input, output):
     # This is possibly due to a defect in the serialize_strip method
     data = [
         # moinwiki_in converter changes indented text to no-bullet lists
-        ("""
+        (
+            """
     indented text
         text indented to the 2nd level
     first level
@@ -161,16 +149,18 @@ def test_macros(self, input, output):
         second level again, will be combined with line above
         . second level as no bullet list
         continuation of no bullet list""",
-         """
+            """
  . indented text
    . text indented to the 2nd level
  . first level
    . second level
 second level again, will be combined with line above
    . second level as no bullet list
-continuation of no bullet list"""),
+continuation of no bullet list""",
+        ),
         # output should equal input, but note todo above
-        ("""
+        (
+            """
  . indented text
    . text indented to the 2nd level
  . first level
@@ -178,204 +168,218 @@ def test_macros(self, input, output):
    second level again, will be combined with line above
    . second level as no bullet list
    continuation of no bullet list""",
-         """
+            """
  . indented text
    . text indented to the 2nd level
  . first level
    . second level
 second level again, will be combined with line above
    . second level as no bullet list
-continuation of no bullet list"""),
+continuation of no bullet list""",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_indented_text(self, input, output):
         self.do(input, output)
 
     data = [
-        ('[[Home]]',
-         '[[Home]]'),
-        ('[[Home/subitem]]',
-         '[[Home/subitem]]'),
-        ('[[/Subitem]]',
-         '[[/Subitem]]'),
-        ('[[../Home]]',
-         '[[../Home]]'),
-        ('[[#Heading]]',
-         '[[#Heading]]'),
-        ('[[SomePage#subsection|subsection of Some Page]]',
-         '[[SomePage#subsection|subsection of Some Page]]\n'),
-        ('[[SomePage|{{attachment:samplegraphic.png}}|target=_blank]]',
-         '[[SomePage|{{/samplegraphic.png}}|target="_blank"]]\n'),
-        ('[[../SisterPage|link text]]',
-         '[[../SisterPage|link text]]\n'),
-        ('[[http://static.moinmo.in/logos/moinmoin.png|{{attachment:samplegraphic.png}}|target=_blank]]',
-         '[[http://static.moinmo.in/logos/moinmoin.png|{{/samplegraphic.png}}|target="_blank"]]\n'),
-        ('[[https://moinmo.in/|MoinMoin Wiki|class="green dotted", accesskey=1]]',
-         '[[https://moinmo.in/|MoinMoin Wiki|accesskey="1",class="green dotted"]]\n'),
-        ('[[https://moinmo.in/| |title="go there!"]]',
-         '[[https://moinmo.in/||title="go there!"]]'),
+        ("[[Home]]", "[[Home]]"),
+        ("[[Home/subitem]]", "[[Home/subitem]]"),
+        ("[[/Subitem]]", "[[/Subitem]]"),
+        ("[[../Home]]", "[[../Home]]"),
+        ("[[#Heading]]", "[[#Heading]]"),
+        ("[[SomePage#subsection|subsection of Some Page]]", "[[SomePage#subsection|subsection of Some Page]]\n"),
+        (
+            "[[SomePage|{{attachment:samplegraphic.png}}|target=_blank]]",
+            '[[SomePage|{{/samplegraphic.png}}|target="_blank"]]\n',
+        ),
+        ("[[../SisterPage|link text]]", "[[../SisterPage|link text]]\n"),
+        (
+            "[[http://static.moinmo.in/logos/moinmoin.png|{{attachment:samplegraphic.png}}|target=_blank]]",
+            '[[http://static.moinmo.in/logos/moinmoin.png|{{/samplegraphic.png}}|target="_blank"]]\n',
+        ),
+        (
+            '[[https://moinmo.in/|MoinMoin Wiki|class="green dotted", accesskey=1]]',
+            '[[https://moinmo.in/|MoinMoin Wiki|accesskey="1",class="green dotted"]]\n',
+        ),
+        ('[[https://moinmo.in/| |title="go there!"]]', '[[https://moinmo.in/||title="go there!"]]'),
         # interwiki
         # TODO: should this obsolete (1.9.x) form be made to work?
         # ('[[MoinMoin:MoinMoinWiki|MoinMoin Wiki|&action=diff,&rev1=1,&rev2=2]]', '[[MoinMoin:MoinMoinWiki?action=diff,&rev1=1,&rev2=2|MoinMoin Wiki]]\n'),
-        ('[[MeatBall:InterWiki]]',
-         '[[MeatBall:InterWiki]]'),
-        ('[[MeatBall:InterWiki|InterWiki page on MeatBall]]',
-         '[[MeatBall:InterWiki|InterWiki page on MeatBall]]'),
+        ("[[MeatBall:InterWiki]]", "[[MeatBall:InterWiki]]"),
+        ("[[MeatBall:InterWiki|InterWiki page on MeatBall]]", "[[MeatBall:InterWiki|InterWiki page on MeatBall]]"),
         # TODO: attachments should be converted within import19.py and support removed from moin2
         # Note: old style attachments are converted to new style sub-item syntax; "&do-get" is appended to link and ignored
-        ('[[attachment:HelpOnImages/pineapple.jpg|a pineapple|&do=get]]',
-         '[[/HelpOnImages/pineapple.jpg?do=get|a pineapple]]\n'),
-        ('[[attachment:filename.txt]]',
-         '[[/filename.txt]]\n'),
+        (
+            "[[attachment:HelpOnImages/pineapple.jpg|a pineapple|&do=get]]",
+            "[[/HelpOnImages/pineapple.jpg?do=get|a pineapple]]\n",
+        ),
+        ("[[attachment:filename.txt]]", "[[/filename.txt]]\n"),
         # test parameters
-        ('[[SomePage|Some Page|target=_blank]]',
-         '[[SomePage|Some Page|target="_blank"]]\n'),
-        ('[[SomePage|Some Page|download=MyItem,title=Download]]',
-         '[[SomePage|Some Page|download="MyItem",title="Download"]]\n'),
-        ('[[SomePage|Some Page|download="MyItem",title="Download"]]',
-         '[[SomePage|Some Page|download="MyItem",title="Download"]]\n'),
-        ('[[SomePage|Some Page|class=orange,accesskey=1]]',
-         '[[SomePage|Some Page|accesskey="1",class="orange"]]\n'),
-        ('[[/inner2.png|{{/inner2.png||width=500}}]]',
-         '[[/inner2.png|{{/inner2.png||width="500"}}]]\n'),
-        ('[[file://///server/share/filename%20with%20spaces.txt|link to filename.txt]]',
-         '[[file://///server/share/filename%20with%20spaces.txt|link to filename.txt]]'),
+        ("[[SomePage|Some Page|target=_blank]]", '[[SomePage|Some Page|target="_blank"]]\n'),
+        (
+            "[[SomePage|Some Page|download=MyItem,title=Download]]",
+            '[[SomePage|Some Page|download="MyItem",title="Download"]]\n',
+        ),
+        (
+            '[[SomePage|Some Page|download="MyItem",title="Download"]]',
+            '[[SomePage|Some Page|download="MyItem",title="Download"]]\n',
+        ),
+        ("[[SomePage|Some Page|class=orange,accesskey=1]]", '[[SomePage|Some Page|accesskey="1",class="orange"]]\n'),
+        ("[[/inner2.png|{{/inner2.png||width=500}}]]", '[[/inner2.png|{{/inner2.png||width="500"}}]]\n'),
+        (
+            "[[file://///server/share/filename%20with%20spaces.txt|link to filename.txt]]",
+            "[[file://///server/share/filename%20with%20spaces.txt|link to filename.txt]]",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        (' * A\n * B\n  1. C\n  1. D\n   I. E\n   I. F\n',
-         ' * A\n * B\n   1. C\n   1. D\n      I. E\n      I. F\n'),
-        (' * A\n  1. C\n   I. E\n',
-         ' * A\n   1. C\n      I. E\n'),
-        (' * A\n  1. C\n  1. D\n',
-         ' * A\n   1. C\n   1. D\n'),
-        (' . A\n  . C\n  . D\n',
-         ' . A\n   . C\n   . D\n'),
-        (' i. E\n i. F\n',
-         ' i. E\n i. F\n'),
-        (' i.#11 K\n i. L\n',
-         ' i.#11 K\n i. L\n'),
-        (' 1.#11 eleven\n 1. twelve\n',
-         ' 1.#11 eleven\n 1. twelve\n'),
-        (' A:: B\n :: C\n :: D\n',
-         ' A::\n :: B\n :: C\n :: D\n'),
-        (' A::\n :: B\n :: C\n :: D\n',
-         ' A::\n :: B\n :: C\n :: D\n'),
+        (" * A\n * B\n  1. C\n  1. D\n   I. E\n   I. F\n", " * A\n * B\n   1. C\n   1. D\n      I. E\n      I. F\n"),
+        (" * A\n  1. C\n   I. E\n", " * A\n   1. C\n      I. E\n"),
+        (" * A\n  1. C\n  1. D\n", " * A\n   1. C\n   1. D\n"),
+        (" . A\n  . C\n  . D\n", " . A\n   . C\n   . D\n"),
+        (" i. E\n i. F\n", " i. E\n i. F\n"),
+        (" i.#11 K\n i. L\n", " i.#11 K\n i. L\n"),
+        (" 1.#11 eleven\n 1. twelve\n", " 1.#11 eleven\n 1. twelve\n"),
+        (" A:: B\n :: C\n :: D\n", " A::\n :: B\n :: C\n :: D\n"),
+        (" A::\n :: B\n :: C\n :: D\n", " A::\n :: B\n :: C\n :: D\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('||A||B||<|2>D||\n||||C||\n',
-         '||A||B||<rowspan="2">D||\n||<colspan="2">C||\n'),
-        ("||'''A'''||'''B'''||'''C'''||\n||1      ||2      ||3     ||\n",
-         "||'''A'''||'''B'''||'''C'''||\n||1      ||2      ||3     ||\n"),
-        ('||<|2> cell spanning 2 rows ||cell in the 2nd column ||\n||cell in the 2nd column of the 2nd row ||\n||<-2>test||\n||||test||',
-         '||<rowspan="2"> cell spanning 2 rows ||cell in the 2nd column ||\n||cell in the 2nd column of the 2nd row ||\n||<colspan="2">test||\n||<colspan="2">test||\n'),
-        ('|| narrow ||<99%> wide ||',
-         '|| narrow ||<style="width: 99%;"> wide ||\n'),
-        ('|| narrow ||<:> wide ||',
-         '|| narrow ||<style="text-align: center;"> wide ||\n'),
-        ('||table 1||\n\n||table 2||',
-         '||table 1||\n\n||table 2||'),
-        ('||<#FF8080> red ||<#80FF80> green ||<#8080FF> blue ||',
-         '||<style="background-color: #FF8080;"> red ||<style="background-color: #80FF80;"> green ||<style="background-color: #8080FF;"> blue ||\n'),
-        ('|| normal ||<style="font-weight: bold;"> bold ||<style="color: #FF0000;"> red ||<style="color: #FF0000; font-weight: bold;"> boldred ||',
-         '|| normal ||<style="font-weight: bold;"> bold ||<style="color: #FF0000;"> red ||<style="color: #FF0000; font-weight: bold;"> boldred ||\n'),
-        ('||<style="background-color: red;"> red ||<style="background-color: green;"> green ||<style="background-color: blue;"> blue ||',
-         '||<style="background-color: red;"> red ||<style="background-color: green;"> green ||<style="background-color: blue;"> blue ||\n'),
-        ('||<tableclass="moin-sortable">Fruit||Quantity||\n=====\n||Apple||2||\n||Orange||1||\n||Banana||4||\n=====\n||Total||7||',
-         '||<tableclass="moin-sortable">Fruit||Quantity||\n=====\n||Apple||2||\n||Orange||1||\n||Banana||4||\n=====\n||Total||7||'),
-        ('||<style="vertical-align: top;" rowspan="3"> top||<style="text-align: center; width: 99%;"> center||<style="vertical-align: bottom;" rowspan="3"> bottom||\n||<style="text-align: right;"> right||\n||<style="text-align: left;"> left||',
-         '||<style="vertical-align: top;" rowspan="3"> top||<style="text-align: center; width: 99%;"> center||<style="vertical-align: bottom;" rowspan="3"> bottom||\n||<style="text-align: right;"> right||\n||<style="text-align: left;"> left||'),
-        ('||<^|3> top ||<:99%> center ||<v|3> bottom ||\n||<)> right ||\n||<(> left ||',
-         '||<style="vertical-align: top;" rowspan="3"> top ||<style="text-align: center; width: 99%;"> center ||<style="vertical-align: bottom;" rowspan="3"> bottom ||\n||<style="text-align: right;"> right ||\n||<style="text-align: left;"> left ||'),
-        ('||<caption="My Table" tablewidth="30em">A ||<rowspan="2" > like <|2> ||\n||<bgcolor="#00FF00"> like <#00FF00> ||\n||<colspan="2"> like <-2>||',
-         '||<tablestyle="width: 30em;" caption="My Table">A ||<rowspan="2"> like <|2> ||\n||<style="background-color: #00FF00;"> like <#00FF00> ||\n||<colspan="2"> like <-2>||'),
+        ("||A||B||<|2>D||\n||||C||\n", '||A||B||<rowspan="2">D||\n||<colspan="2">C||\n'),
+        (
+            "||'''A'''||'''B'''||'''C'''||\n||1      ||2      ||3     ||\n",
+            "||'''A'''||'''B'''||'''C'''||\n||1      ||2      ||3     ||\n",
+        ),
+        (
+            "||<|2> cell spanning 2 rows ||cell in the 2nd column ||\n||cell in the 2nd column of the 2nd row ||\n||<-2>test||\n||||test||",
+            '||<rowspan="2"> cell spanning 2 rows ||cell in the 2nd column ||\n||cell in the 2nd column of the 2nd row ||\n||<colspan="2">test||\n||<colspan="2">test||\n',
+        ),
+        ("|| narrow ||<99%> wide ||", '|| narrow ||<style="width: 99%;"> wide ||\n'),
+        ("|| narrow ||<:> wide ||", '|| narrow ||<style="text-align: center;"> wide ||\n'),
+        ("||table 1||\n\n||table 2||", "||table 1||\n\n||table 2||"),
+        (
+            "||<#FF8080> red ||<#80FF80> green ||<#8080FF> blue ||",
+            '||<style="background-color: #FF8080;"> red ||<style="background-color: #80FF80;"> green ||<style="background-color: #8080FF;"> blue ||\n',
+        ),
+        (
+            '|| normal ||<style="font-weight: bold;"> bold ||<style="color: #FF0000;"> red ||<style="color: #FF0000; font-weight: bold;"> boldred ||',
+            '|| normal ||<style="font-weight: bold;"> bold ||<style="color: #FF0000;"> red ||<style="color: #FF0000; font-weight: bold;"> boldred ||\n',
+        ),
+        (
+            '||<style="background-color: red;"> red ||<style="background-color: green;"> green ||<style="background-color: blue;"> blue ||',
+            '||<style="background-color: red;"> red ||<style="background-color: green;"> green ||<style="background-color: blue;"> blue ||\n',
+        ),
+        (
+            '||<tableclass="moin-sortable">Fruit||Quantity||\n=====\n||Apple||2||\n||Orange||1||\n||Banana||4||\n=====\n||Total||7||',
+            '||<tableclass="moin-sortable">Fruit||Quantity||\n=====\n||Apple||2||\n||Orange||1||\n||Banana||4||\n=====\n||Total||7||',
+        ),
+        (
+            '||<style="vertical-align: top;" rowspan="3"> top||<style="text-align: center; width: 99%;"> center||<style="vertical-align: bottom;" rowspan="3"> bottom||\n||<style="text-align: right;"> right||\n||<style="text-align: left;"> left||',
+            '||<style="vertical-align: top;" rowspan="3"> top||<style="text-align: center; width: 99%;"> center||<style="vertical-align: bottom;" rowspan="3"> bottom||\n||<style="text-align: right;"> right||\n||<style="text-align: left;"> left||',
+        ),
+        (
+            "||<^|3> top ||<:99%> center ||<v|3> bottom ||\n||<)> right ||\n||<(> left ||",
+            '||<style="vertical-align: top;" rowspan="3"> top ||<style="text-align: center; width: 99%;"> center ||<style="vertical-align: bottom;" rowspan="3"> bottom ||\n||<style="text-align: right;"> right ||\n||<style="text-align: left;"> left ||',
+        ),
+        (
+            '||<caption="My Table" tablewidth="30em">A ||<rowspan="2" > like <|2> ||\n||<bgcolor="#00FF00"> like <#00FF00> ||\n||<colspan="2"> like <-2>||',
+            '||<tablestyle="width: 30em;" caption="My Table">A ||<rowspan="2"> like <|2> ||\n||<style="background-color: #00FF00;"> like <#00FF00> ||\n||<colspan="2"> like <-2>||',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('{{png}}',
-         '{{png}}\n'),
-        ('{{png|png}}',
-         '{{png|png}}\n'),  # alt text same as default test
-        ('{{png|my png}}',
-         '{{png|my png}}\n'),
-        ('{{{{video.mp4}}}}',
-         '{{{{video.mp4}}}}\n'),
-        ('{{{{audio.mp3}}}}',
-         '{{{{audio.mp3}}}}\n'),
+        ("{{png}}", "{{png}}\n"),
+        ("{{png|png}}", "{{png|png}}\n"),  # alt text same as default test
+        ("{{png|my png}}", "{{png|my png}}\n"),
+        ("{{{{video.mp4}}}}", "{{{{video.mp4}}}}\n"),
+        ("{{{{audio.mp3}}}}", "{{{{audio.mp3}}}}\n"),
         # output attributes will always be quoted, even if input is not quoted
-        ('{{png|my png|width=100}}',
-         '{{png|my png|width="100"}}\n'),
-        ('{{png|my png|&w=100"}}',
-         '{{png|my png|&w=100}}\n'),
-        ('{{png||width="100"}}',
-         '{{png||width="100"}}\n'),
-        ('{{http://static.moinmo.in/logos/moinmoin.png}}\n',
-         '{{http://static.moinmo.in/logos/moinmoin.png}}\n'),
-        ('{{http://static.moinmo.in/logos/moinmoin.png|alt text}}\n',
-         '{{http://static.moinmo.in/logos/moinmoin.png|alt text}}\n'),
+        ("{{png|my png|width=100}}", '{{png|my png|width="100"}}\n'),
+        ('{{png|my png|&w=100"}}', "{{png|my png|&w=100}}\n"),
+        ('{{png||width="100"}}', '{{png||width="100"}}\n'),
+        ("{{http://static.moinmo.in/logos/moinmoin.png}}\n", "{{http://static.moinmo.in/logos/moinmoin.png}}\n"),
+        (
+            "{{http://static.moinmo.in/logos/moinmoin.png|alt text}}\n",
+            "{{http://static.moinmo.in/logos/moinmoin.png|alt text}}\n",
+        ),
         # output sequence of height, width, class may not be the same as input,
         # so here we test only one attribute at a time to avoid random test failures
-        ('{{http://static.moinmo.in/logos/moinmoin.png|alt text|height="150"}}\n',
-         '{{http://static.moinmo.in/logos/moinmoin.png|alt text|height="150"}}\n'),
-        ('{{http://static.moinmo.in/logos/moinmoin.png|alt text|width="100"}}',
-         '{{http://static.moinmo.in/logos/moinmoin.png|alt text|width="100"}}\n'),
-        ('{{http://static.moinmo.in/logos/moinmoin.png|alt text|class="right"}}',
-         '{{http://static.moinmo.in/logos/moinmoin.png|alt text|class="right"}}\n'),
+        (
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|height="150"}}\n',
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|height="150"}}\n',
+        ),
+        (
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|width="100"}}',
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|width="100"}}\n',
+        ),
+        (
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|class="right"}}',
+            '{{http://static.moinmo.in/logos/moinmoin.png|alt text|class="right"}}\n',
+        ),
         # Note: old style attachments are converted to new style sub-item syntax
-        ('{{attachment:image.png}}',
-         '{{/image.png}}\n'),
-        ('{{attachment:image.png|alt text}}',
-         '{{/image.png|alt text}}\n'),
-        ('{{attachment:image.png|alt text|height="150"}}',
-         '{{/image.png|alt text|height="150"}}\n'),
+        ("{{attachment:image.png}}", "{{/image.png}}\n"),
+        ("{{attachment:image.png|alt text}}", "{{/image.png|alt text}}\n"),
+        ('{{attachment:image.png|alt text|height="150"}}', '{{/image.png|alt text|height="150"}}\n'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_object(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Images are aligned to bottom {{png}} of text by default.',
-         'Images are aligned to bottom {{png}} of text by default.'),
-        ('This image is the big logo floated to the right: {{svg|my svg|class="right"}}',
-         'This image is the big logo floated to the right: {{svg|my svg|class="right"}}'),
-        ('Image aligned to top of text. {{jpeg||&w=75 class="top"}}',
-         'Image aligned to top of text. {{jpeg||&w=75 class="top"}}'),
-        ('Image aligned to middle of text. {{http://static.moinmo.in/logos/moinmoin.png||class=middle}}',
-         'Image aligned to middle of text. {{http://static.moinmo.in/logos/moinmoin.png||class="middle"}}'),
-        ('Transclude an HTTPS web page: <<BR>>{{https://moinmo.in||width="800"}}',
-         'Transclude an HTTPS web page: <<BR>>{{https://moinmo.in||width="800"}}'),
+        (
+            "Images are aligned to bottom {{png}} of text by default.",
+            "Images are aligned to bottom {{png}} of text by default.",
+        ),
+        (
+            'This image is the big logo floated to the right: {{svg|my svg|class="right"}}',
+            'This image is the big logo floated to the right: {{svg|my svg|class="right"}}',
+        ),
+        (
+            'Image aligned to top of text. {{jpeg||&w=75 class="top"}}',
+            'Image aligned to top of text. {{jpeg||&w=75 class="top"}}',
+        ),
+        (
+            "Image aligned to middle of text. {{http://static.moinmo.in/logos/moinmoin.png||class=middle}}",
+            'Image aligned to middle of text. {{http://static.moinmo.in/logos/moinmoin.png||class="middle"}}',
+        ),
+        (
+            'Transclude an HTTPS web page: <<BR>>{{https://moinmo.in||width="800"}}',
+            'Transclude an HTTPS web page: <<BR>>{{https://moinmo.in||width="800"}}',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_transclusions(self, input, output):
         self.do(input, output)
 
     data = [
-        (r'smileys: X-( :D >:> <:( :\ :o :-( :( :) B) :)) ;) |) |-) :-? /!\ <!> (./) {X} {i} (!) {1} {2} {3} {*} {o} {OK}',
-         r'smileys: X-( :D >:> <:( :\ :o :-( :( :) B) :)) ;) |) |-) :-? /!\ <!> (./) {X} {i} (!) {1} {2} {3} {*} {o} {OK}'),
+        (
+            r"smileys: X-( :D >:> <:( :\ :o :-( :( :) B) :)) ;) |) |-) :-? /!\ <!> (./) {X} {i} (!) {1} {2} {3} {*} {o} {OK}",
+            r"smileys: X-( :D >:> <:( :\ :o :-( :( :) B) :)) ;) |) |-) :-? /!\ <!> (./) {X} {i} (!) {1} {2} {3} {*} {o} {OK}",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_smileys(self, input, output):
         self.do(input, output)
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
@@ -383,12 +387,14 @@ def handle_output(self, elem, **options):
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv_in(input, 'text/x.moin.wiki;charset=utf-8', **args)
+        out = self.conv_in(input, "text/x.moin.wiki;charset=utf-8", **args)
         out = self.conv_out(self.handle_input(self.serialize_strip(out)), **args)
         # assert self.handle_output(out) == output
-        assert self.handle_output(out).strip() == output.strip()  # TODO: revert to above when number of \n between blocks in moinwiki_out.py is stable
+        assert (
+            self.handle_output(out).strip() == output.strip()
+        )  # TODO: revert to above when number of \n between blocks in moinwiki_out.py is stable
diff --git a/src/moin/converters/_tests/test_moinwiki_out.py b/src/moin/converters/_tests/test_moinwiki_out.py
index f12f89dfc..c79deb754 100644
--- a/src/moin/converters/_tests/test_moinwiki_out.py
+++ b/src/moin/converters/_tests/test_moinwiki_out.py
@@ -18,16 +18,15 @@
 
 class Base:
     input_namespaces = ns_all = 'xmlns="{}" xmlns:page="{}" xmlns:xlink="{}" xmlns:html="{}"'.format(
-        moin_page.namespace, moin_page.namespace, xlink.namespace, html.namespace)
-    output_namespaces = {
-        moin_page.namespace: 'page'
-    }
+        moin_page.namespace, moin_page.namespace, xlink.namespace, html.namespace
+    )
+    output_namespaces = {moin_page.namespace: "page"}
 
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i.encode("utf-8"))
 
     def handle_output(self, elem, **options):
@@ -36,7 +35,9 @@ def handle_output(self, elem, **options):
     def do(self, input, output, args={}):
         out = self.conv(self.handle_input(input), **args)
         # assert self.handle_output(out) == output
-        assert self.handle_output(out).strip() == output.strip()  # TODO: remove .strip() when number of \n between blocks in moinwiki_out.py is stable
+        assert (
+            self.handle_output(out).strip() == output.strip()
+        )  # TODO: remove .strip() when number of \n between blocks in moinwiki_out.py is stable
 
 
 class TestConverter(Base):
@@ -44,171 +45,225 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('<page:p>Текст</page:p>',
-         'Текст\n'),
-        ('<page:p>Text</page:p>',
-         'Text\n'),
-        ('<page:tag><page:p>Text</page:p><page:p>Text</page:p></page:tag>',
-         'Text\n\nText\n'),
-        ('<page:separator />',
-         '----\n'),
-        ('<page:strong>strong</page:strong>',
-         "'''strong'''"),
-        ('<page:emphasis>emphasis</page:emphasis>',
-         "''emphasis''"),
-        ('<page:blockcode>blockcode</page:blockcode>',
-         '{{{\nblockcode\n}}}\n'),
-        ('<page:code>monospace</page:code>',
-         '`monospace`'),
-        ('<page:del>stroke</page:del>',
-         '--(stroke)--'),
-        ('<page:ins>underline</page:ins>',
-         '__underline__'),
-        ('<page:span page:font-size="120%">larger</page:span>',
-         '~+larger+~'),
-        ('<page:span page:font-size="85%">smaller</page:span>',
-         '~-smaller-~'),
-        ('<page:tag><page:span page:baseline-shift="super">super</page:span>script</page:tag>',
-         '^super^script'),
-        ('<page:tag><page:span page:baseline-shift="sub">sub</page:span>script</page:tag>',
-         ',,sub,,script'),
+        ("<page:p>Текст</page:p>", "Текст\n"),
+        ("<page:p>Text</page:p>", "Text\n"),
+        ("<page:tag><page:p>Text</page:p><page:p>Text</page:p></page:tag>", "Text\n\nText\n"),
+        ("<page:separator />", "----\n"),
+        ("<page:strong>strong</page:strong>", "'''strong'''"),
+        ("<page:emphasis>emphasis</page:emphasis>", "''emphasis''"),
+        ("<page:blockcode>blockcode</page:blockcode>", "{{{\nblockcode\n}}}\n"),
+        ("<page:code>monospace</page:code>", "`monospace`"),
+        ("<page:del>stroke</page:del>", "--(stroke)--"),
+        ("<page:ins>underline</page:ins>", "__underline__"),
+        ('<page:span page:font-size="120%">larger</page:span>', "~+larger+~"),
+        ('<page:span page:font-size="85%">smaller</page:span>', "~-smaller-~"),
+        ('<page:tag><page:span page:baseline-shift="super">super</page:span>script</page:tag>', "^super^script"),
+        ('<page:tag><page:span page:baseline-shift="sub">sub</page:span>script</page:tag>', ",,sub,,script"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:a xlink:href="wiki.local:SomePage#subsection">subsection of Some Page</page:a>',
-         '[[SomePage#subsection|subsection of Some Page]]'),
-        ('<page:a html:target="_blank" xlink:href="wiki.local:SomePage">{{attachment:samplegraphic.png}}</page:a>',
-         '[[SomePage|{{attachment:samplegraphic.png}}|target="_blank"]]'),
-        ('<page:a xlink:href="wiki.local:SomePage?target=_blank">{{attachment:samplegraphic.png}}</page:a>',
-         '[[SomePage?target=_blank|{{attachment:samplegraphic.png}}]]'),
-        ('<page:a html:target="_blank" xlink:href="wiki.local:SomePage">{{/samplegraphic.png}}</page:a>',
-         '[[SomePage|{{/samplegraphic.png}}|target="_blank"]]'),
-        ('<page:a xlink:href="../SisterPage">link text</page:a>', '[[../SisterPage|link text]]'),
-        ('<page:a html:target="_blank" html:class="aaa" xlink:href="http://static.moinmo.in/logos/moinmoin.png">{{attachment:samplegraphic.png}}</page:a>',
-         '[[http://static.moinmo.in/logos/moinmoin.png|{{attachment:samplegraphic.png}}|class="aaa",target="_blank"]]'),
-        ('<page:a html:class="green dotted" html:accesskey="1" xlink:href="http://moinmo.in/">MoinMoin Wiki</page:a>',
-         '[[http://moinmo.in/|MoinMoin Wiki|accesskey="1",class="green dotted"]]'),
-        ('<page:a xlink:href="MoinMoin:MoinMoinWiki?action=diff&amp;rev1=1&amp;rev2=2">MoinMoin Wiki</page:a>',
-         '[[MoinMoin:MoinMoinWiki?action=diff&rev1=1&rev2=2|MoinMoin Wiki]]'),
-        ('<page:a xlink:href="attachment:HelpOnImages/pineapple.jpg?do=get">a pineapple</page:a>',
-         '[[attachment:HelpOnImages/pineapple.jpg?do=get|a pineapple]]'),
-        ('<page:a xlink:href="attachment:filename.txt">attachment:filename.txt</page:a>',
-         '[[attachment:filename.txt]]')
+        (
+            '<page:a xlink:href="wiki.local:SomePage#subsection">subsection of Some Page</page:a>',
+            "[[SomePage#subsection|subsection of Some Page]]",
+        ),
+        (
+            '<page:a html:target="_blank" xlink:href="wiki.local:SomePage">{{attachment:samplegraphic.png}}</page:a>',
+            '[[SomePage|{{attachment:samplegraphic.png}}|target="_blank"]]',
+        ),
+        (
+            '<page:a xlink:href="wiki.local:SomePage?target=_blank">{{attachment:samplegraphic.png}}</page:a>',
+            "[[SomePage?target=_blank|{{attachment:samplegraphic.png}}]]",
+        ),
+        (
+            '<page:a html:target="_blank" xlink:href="wiki.local:SomePage">{{/samplegraphic.png}}</page:a>',
+            '[[SomePage|{{/samplegraphic.png}}|target="_blank"]]',
+        ),
+        ('<page:a xlink:href="../SisterPage">link text</page:a>', "[[../SisterPage|link text]]"),
+        (
+            '<page:a html:target="_blank" html:class="aaa" xlink:href="http://static.moinmo.in/logos/moinmoin.png">{{attachment:samplegraphic.png}}</page:a>',
+            '[[http://static.moinmo.in/logos/moinmoin.png|{{attachment:samplegraphic.png}}|class="aaa",target="_blank"]]',
+        ),
+        (
+            '<page:a html:class="green dotted" html:accesskey="1" xlink:href="http://moinmo.in/">MoinMoin Wiki</page:a>',
+            '[[http://moinmo.in/|MoinMoin Wiki|accesskey="1",class="green dotted"]]',
+        ),
+        (
+            '<page:a xlink:href="MoinMoin:MoinMoinWiki?action=diff&amp;rev1=1&amp;rev2=2">MoinMoin Wiki</page:a>',
+            "[[MoinMoin:MoinMoinWiki?action=diff&rev1=1&rev2=2|MoinMoin Wiki]]",
+        ),
+        (
+            '<page:a xlink:href="attachment:HelpOnImages/pineapple.jpg?do=get">a pineapple</page:a>',
+            "[[attachment:HelpOnImages/pineapple.jpg?do=get|a pineapple]]",
+        ),
+        (
+            '<page:a xlink:href="attachment:filename.txt">attachment:filename.txt</page:a>',
+            "[[attachment:filename.txt]]",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:object xlink:href="http://static.moinmo.in/logos/moinmoin.png" />',
-         '{{http://static.moinmo.in/logos/moinmoin.png}}'),
-        ('<page:object page:alt="alt text" xlink:href="http://static.moinmo.in/logos/moinmoin.png">alt text</page:object>',
-         '{{http://static.moinmo.in/logos/moinmoin.png|alt text}}'),
-        ('<page:object xlink:href="attachment:image.png" />', '{{attachment:image.png}}'),
-        ('<page:object page:alt="alt text" xlink:href="attachment:image.png">alt text</page:object>',
-         '{{attachment:image.png|alt text}}'),
-        ('<page:object xlink:href="attachment:image.png" html:width="100" html:height="150" html:class="left">alt text</page:object>',
-         '{{attachment:image.png|alt text|class="left" height="150" width="100"}}'),
+        (
+            '<page:object xlink:href="http://static.moinmo.in/logos/moinmoin.png" />',
+            "{{http://static.moinmo.in/logos/moinmoin.png}}",
+        ),
+        (
+            '<page:object page:alt="alt text" xlink:href="http://static.moinmo.in/logos/moinmoin.png">alt text</page:object>',
+            "{{http://static.moinmo.in/logos/moinmoin.png|alt text}}",
+        ),
+        ('<page:object xlink:href="attachment:image.png" />', "{{attachment:image.png}}"),
+        (
+            '<page:object page:alt="alt text" xlink:href="attachment:image.png">alt text</page:object>',
+            "{{attachment:image.png|alt text}}",
+        ),
+        (
+            '<page:object xlink:href="attachment:image.png" html:width="100" html:height="150" html:class="left">alt text</page:object>',
+            '{{attachment:image.png|alt text|class="left" height="150" width="100"}}',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_object(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         ' * A\n'),
-        ('<page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         ' 1. A\n'),
-        ('<page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         ' I. A\n'),
-        ('<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>B</page:p><page:list page:item-label-generate=\"ordered\"><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p><page:list page:item-label-generate=\"ordered\" page:list-style-type=\"upper-roman\"><page:list-item><page:list-item-body><page:p>E</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>F</page:p></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list>',
-         ' * A\n * B\n   1. C\n   1. D\n      I. E\n      I. F\n'),
-        ('<page:list><page:list-item><page:list-item-label>A</page:list-item-label><page:list-item-body><page:p>B</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p></page:list-item-body></page:list-item></page:list>',
-         ' A::\n :: B\n :: C\n :: D\n'),
+        (
+            '<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            " * A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            " 1. A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            " I. A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>B</page:p><page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p><page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body><page:p>E</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>F</page:p></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list>',
+            " * A\n * B\n   1. C\n   1. D\n      I. E\n      I. F\n",
+        ),
+        (
+            "<page:list><page:list-item><page:list-item-label>A</page:list-item-label><page:list-item-body><page:p>B</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p></page:list-item-body></page:list-item></page:list>",
+            " A::\n :: B\n :: C\n :: D\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:table><page:table-body><page:table-row><page:table-cell>A</page:table-cell><page:table-cell>B</page:table-cell><page:table-cell page:number-rows-spanned="2">D</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">C</page:table-cell></page:table-row></page:table-body></page:table>',
-         '||A||B||<rowspan="2">D||\n||<colspan="2">C||\n'),
-        ('<page:table><page:table-body><page:table-row><page:table-cell><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>B</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>1</page:p></page:table-cell><page:table-cell>2</page:table-cell><page:table-cell>3</page:table-cell></page:table-row></page:table-body></page:table>',
-         "||'''A'''||'''B'''||'''C'''||\n||1||2||3||\n"),
-        ('<page:table><page:table-body><page:table-row><page:table-cell page:number-rows-spanned="2">cell spanning 2 rows</page:table-cell><page:table-cell>cell in the 2nd column</page:table-cell></page:table-row><page:table-row><page:table-cell>cell in the 2nd column of the 2nd row</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">test</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">test</page:table-cell></page:table-row></page:table-body></page:table>',
-         '||<rowspan="2">cell spanning 2 rows||cell in the 2nd column||\n||cell in the 2nd column of the 2nd row||\n||<colspan="2">test||\n||<colspan="2">test||\n'),
+        (
+            '<page:table><page:table-body><page:table-row><page:table-cell>A</page:table-cell><page:table-cell>B</page:table-cell><page:table-cell page:number-rows-spanned="2">D</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">C</page:table-cell></page:table-row></page:table-body></page:table>',
+            '||A||B||<rowspan="2">D||\n||<colspan="2">C||\n',
+        ),
+        (
+            "<page:table><page:table-body><page:table-row><page:table-cell><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>B</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>1</page:p></page:table-cell><page:table-cell>2</page:table-cell><page:table-cell>3</page:table-cell></page:table-row></page:table-body></page:table>",
+            "||'''A'''||'''B'''||'''C'''||\n||1||2||3||\n",
+        ),
+        (
+            '<page:table><page:table-body><page:table-row><page:table-cell page:number-rows-spanned="2">cell spanning 2 rows</page:table-cell><page:table-cell>cell in the 2nd column</page:table-cell></page:table-row><page:table-row><page:table-cell>cell in the 2nd column of the 2nd row</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">test</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-columns-spanned="2">test</page:table-cell></page:table-row></page:table-body></page:table>',
+            '||<rowspan="2">cell spanning 2 rows||cell in the 2nd column||\n||cell in the 2nd column of the 2nd row||\n||<colspan="2">test||\n||<colspan="2">test||\n',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:note page:note-class="footnote"><page:note-body>test</page:note-body></page:note>',
-         '<<FootNote(test)>>'),
-        ('<page:tag><page:table-of-content page:outline-level="2" /></page:tag>',
-         '<<TableOfContents(2)>>\n'),
-        ('<page:part page:alt="&lt;&lt;Anchor(anchorname)&gt;&gt;" page:content-type="x-moin/macro;name=Anchor"><page:arguments>anchorname</page:arguments></page:part>',
-         '<<Anchor(anchorname)>>\n'),
-        ('<page:part page:alt="&lt;&lt;MonthCalendar(,,12)&gt;&gt;" page:content-type="x-moin/macro;name=MonthCalendar"><page:arguments>,,12</page:arguments></page:part>',
-         '<<MonthCalendar(,,12)>>\n'),
+        (
+            '<page:note page:note-class="footnote"><page:note-body>test</page:note-body></page:note>',
+            "<<FootNote(test)>>",
+        ),
+        ('<page:tag><page:table-of-content page:outline-level="2" /></page:tag>', "<<TableOfContents(2)>>\n"),
+        (
+            '<page:part page:alt="&lt;&lt;Anchor(anchorname)&gt;&gt;" page:content-type="x-moin/macro;name=Anchor"><page:arguments>anchorname</page:arguments></page:part>',
+            "<<Anchor(anchorname)>>\n",
+        ),
+        (
+            '<page:part page:alt="&lt;&lt;MonthCalendar(,,12)&gt;&gt;" page:content-type="x-moin/macro;name=MonthCalendar"><page:arguments>,,12</page:arguments></page:part>',
+            "<<MonthCalendar(,,12)>>\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macros(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:page><page:body page:class="comment dotted"><page:p>This is a wiki parser.</page:p><page:p>Its visibility gets toggled the same way.</page:p></page:body></page:page></page:body></page:page>',
-         '{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}\n'),
-        ('<page:page><page:body><page:page><page:body page:class="red solid"><page:p>This is wiki markup in a <page:strong>div</page:strong> with <page:ins>css</page:ins> <page:code>class="red solid"</page:code>.</page:p></page:body></page:page></page:body></page:page>',
-         '{{{#!wiki red/solid\nThis is wiki markup in a \'\'\'div\'\'\' with __css__ `class="red solid"`.\n}}}\n'),
-        ('<page:page><page:body><page:part page:content-type="x-moin/format;name=creole"><page:arguments><page:argument page:name="style">st: er</page:argument><page:argument page:name="class">par: arg para: arga</page:argument></page:arguments><page:body>... **bold** ...</page:body></page:part></page:body></page:page>',
-         '{{{#!creole(style="st: er" class="par: arg para: arga")\n... **bold** ...\n}}}\n'),
+        (
+            '<page:page><page:body><page:page><page:body page:class="comment dotted"><page:p>This is a wiki parser.</page:p><page:p>Its visibility gets toggled the same way.</page:p></page:body></page:page></page:body></page:page>',
+            "{{{#!wiki comment/dotted\nThis is a wiki parser.\n\nIts visibility gets toggled the same way.\n}}}\n",
+        ),
+        (
+            '<page:page><page:body><page:page><page:body page:class="red solid"><page:p>This is wiki markup in a <page:strong>div</page:strong> with <page:ins>css</page:ins> <page:code>class="red solid"</page:code>.</page:p></page:body></page:page></page:body></page:page>',
+            "{{{#!wiki red/solid\nThis is wiki markup in a '''div''' with __css__ `class=\"red solid\"`.\n}}}\n",
+        ),
+        (
+            '<page:page><page:body><page:part page:content-type="x-moin/format;name=creole"><page:arguments><page:argument page:name="style">st: er</page:argument><page:argument page:name="class">par: arg para: arga</page:argument></page:arguments><page:body>... **bold** ...</page:body></page:part></page:body></page:page>',
+            '{{{#!creole(style="st: er" class="par: arg para: arga")\n... **bold** ...\n}}}\n',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_parser(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:body></page:page>',
-         'A\n\nB\n\nC\n\nD\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '||A<<BR>>B<<BR>>C<<BR>>D||\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '||Z||A<<BR>>B<<BR>>C<<BR>>D||\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell></page:table_row><page:table_row><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '||Z||\n||A<<BR>>B<<BR>>C<<BR>>D||\n'),
-        ('<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body>A<page:line-break></page:line-break>A</page:list-item-body></page:list-item><page:list-item><page:list-item-body>A<page:line-break></page:line-break>A<page:line-break></page:line-break>A</page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         ' * A<<BR>>A\n * A<<BR>>A<<BR>>A\n * A\n'),
+        (
+            "<page:page><page:body><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:body></page:page>",
+            "A\n\nB\n\nC\n\nD\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "||A<<BR>>B<<BR>>C<<BR>>D||\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "||Z||A<<BR>>B<<BR>>C<<BR>>D||\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell></page:table_row><page:table_row><page:table_cell>A<page:line-break></page:line-break>B<page:line-break></page:line-break>C<page:line-break></page:line-break>D</page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "||Z||\n||A<<BR>>B<<BR>>C<<BR>>D||\n",
+        ),
+        (
+            '<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body>A<page:line-break></page:line-break>A</page:list-item-body></page:list-item><page:list-item><page:list-item-body>A<page:line-break></page:line-break>A<page:line-break></page:line-break>A</page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            " * A<<BR>>A\n * A<<BR>>A<<BR>>A\n * A\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_br(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:p>A</page:p><page:separator /></page:body></page:page>',
-         'A\n----\n'),
-        ('<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr1"/></page:body></page:page>',
-         'A\n----\n'),
-        ('<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr3"/></page:body></page:page>',
-         'A\n------\n'),
-        ('<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr6"/></page:body></page:page>',
-         'A\n---------\n'),
+        ("<page:page><page:body><page:p>A</page:p><page:separator /></page:body></page:page>", "A\n----\n"),
+        (
+            '<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr1"/></page:body></page:page>',
+            "A\n----\n",
+        ),
+        (
+            '<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr3"/></page:body></page:page>',
+            "A\n------\n",
+        ),
+        (
+            '<page:page><page:body><page:p>A</page:p><page:separator page:class="moin-hr6"/></page:body></page:page>',
+            "A\n---------\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_separator(self, input, output):
         self.do(input, output)
 
 
-coverage_modules = ['moin.converters.moinwiki_out']
+coverage_modules = ["moin.converters.moinwiki_out"]
diff --git a/src/moin/converters/_tests/test_registry.py b/src/moin/converters/_tests/test_registry.py
index 399634c0a..b7be17aee 100644
--- a/src/moin/converters/_tests/test_registry.py
+++ b/src/moin/converters/_tests/test_registry.py
@@ -24,38 +24,44 @@
 from moin.converters.link import ConverterItemRefs as LinkConverterItemRefs
 
 
-@pytest.mark.parametrize('type_input,type_output,expected_class', [
-    # *_in converters
-    (type_moin_wiki, type_moin_document, MoinwikiInConverter),
-    (Type('x-moin/format;name=wiki'), type_moin_document, MoinwikiInConverter),
-    # pygments_in can handle this too but html_in should have more priority
-    (Type('text/html'), type_moin_document, HtmlInConverter),
-    # fall back to pygments_in
-    (Type('text/html+jinja'), type_moin_document, PygmentsInConverter),
-    # fallback for any random text/* input types
-    (Type('text/blahblah'), type_moin_document, TextInConverter),
-    # fallback for anything
-    (Type('mua/haha'), type_moin_document, EverythingConverter),
-    # *_out converters
-    (type_moin_document, Type('application/x-xhtml-moin-page'), HtmlOutConverterPage),
-    (type_moin_document, type_moin_wiki, MoinwikiOutConverter),
-    (type_moin_document, Type('x-moin/format;name=wiki'), MoinwikiOutConverter),
-])
+@pytest.mark.parametrize(
+    "type_input,type_output,expected_class",
+    [
+        # *_in converters
+        (type_moin_wiki, type_moin_document, MoinwikiInConverter),
+        (Type("x-moin/format;name=wiki"), type_moin_document, MoinwikiInConverter),
+        # pygments_in can handle this too but html_in should have more priority
+        (Type("text/html"), type_moin_document, HtmlInConverter),
+        # fall back to pygments_in
+        (Type("text/html+jinja"), type_moin_document, PygmentsInConverter),
+        # fallback for any random text/* input types
+        (Type("text/blahblah"), type_moin_document, TextInConverter),
+        # fallback for anything
+        (Type("mua/haha"), type_moin_document, EverythingConverter),
+        # *_out converters
+        (type_moin_document, Type("application/x-xhtml-moin-page"), HtmlOutConverterPage),
+        (type_moin_document, type_moin_wiki, MoinwikiOutConverter),
+        (type_moin_document, Type("x-moin/format;name=wiki"), MoinwikiOutConverter),
+    ],
+)
 def test_converter_finder(type_input, type_output, expected_class):
     conv = default_registry.get(type_input, type_output)
     assert isinstance(conv, expected_class)
 
 
-@pytest.mark.parametrize('kwargs,expected_class', [
-    # DOM converters, which depend on keyword argument to default_registry.get
-    (dict(macros='expandall'), MacroConverter),
-    (dict(includes='expandall'), IncludeConverter),
-    (dict(links='extern'), LinkConverterExternOutput),
-    (dict(items='refs'), LinkConverterItemRefs),
-])
+@pytest.mark.parametrize(
+    "kwargs,expected_class",
+    [
+        # DOM converters, which depend on keyword argument to default_registry.get
+        (dict(macros="expandall"), MacroConverter),
+        (dict(includes="expandall"), IncludeConverter),
+        (dict(links="extern"), LinkConverterExternOutput),
+        (dict(items="refs"), LinkConverterItemRefs),
+    ],
+)
 def test_converter_args(kwargs, expected_class):
     conv = default_registry.get(type_moin_document, type_moin_document, **kwargs)
     assert isinstance(conv, expected_class)
 
 
-coverage_modules = ['moin.converters']
+coverage_modules = ["moin.converters"]
diff --git a/src/moin/converters/_tests/test_rst_in.py b/src/moin/converters/_tests/test_rst_in.py
index 4ff129ae0..a8752bde5 100644
--- a/src/moin/converters/_tests/test_rst_in.py
+++ b/src/moin/converters/_tests/test_rst_in.py
@@ -15,12 +15,7 @@
 
 
 class TestConverter:
-    namespaces = {
-        moin_page.namespace: '',
-        xlink.namespace: 'xlink',
-        html: 'xhtml',
-        xinclude: 'xinclude',
-    }
+    namespaces = {moin_page.namespace: "", xlink.namespace: "xlink", html: "xhtml", xinclude: "xinclude"}
 
     output_re = XMLNS_RE
 
@@ -28,109 +23,136 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('Text',
-         '<page><body><p>Text</p></body></page>'),
-        ('Text\nTest',
-         '<page><body><p>Text\nTest</p></body></page>'),
-        ('Text\n\nTest',
-         '<page><body><p>Text</p><p>Test</p></body></page>'),
-        ('H\\ :sub:`2`\\ O\n\nE = mc\\ :sup:`2`',
-         '<page><body><p>H<span baseline-shift="sub">2</span>O</p><p>E = mc<span baseline-shift="super">2</span></p></body></page>'),
-        ('| Lend us a couple of bob till Thursday.',
-         '<page><body><line-block><line-blk>Lend us a couple of bob till Thursday.</line-blk></line-block></body></page>'),
-        ('**Text**',
-         '<page><body><p><strong>Text</strong></p></body></page>'),
-        ('*Text*',
-         '<page><body><p><emphasis>Text</emphasis></p></body></page>'),
-        ('``Text``',
-         '<page><body><p><code>Text</code></p></body></page>'),
-        ("`Text <javascript:alert('xss')>`_",
-         '<page><body><p><admonition type="error">Text</admonition></p></body></page>'),
-        ('Text\n\n~~~~~\n\nTest',
-         '<page><body><p>Text</p><separator xhtml:class="moin-hr3" /><p>Test</p></body></page>'),
-        ('.. comment',
-         '<page><body><div class="comment dashed">comment</div></body></page>'),
-        ('..\n comment',
-         '<page><body><div class="comment dashed">comment</div></body></page>'),
+        ("Text", "<page><body><p>Text</p></body></page>"),
+        ("Text\nTest", "<page><body><p>Text\nTest</p></body></page>"),
+        ("Text\n\nTest", "<page><body><p>Text</p><p>Test</p></body></page>"),
+        (
+            "H\\ :sub:`2`\\ O\n\nE = mc\\ :sup:`2`",
+            '<page><body><p>H<span baseline-shift="sub">2</span>O</p><p>E = mc<span baseline-shift="super">2</span></p></body></page>',
+        ),
+        (
+            "| Lend us a couple of bob till Thursday.",
+            "<page><body><line-block><line-blk>Lend us a couple of bob till Thursday.</line-blk></line-block></body></page>",
+        ),
+        ("**Text**", "<page><body><p><strong>Text</strong></p></body></page>"),
+        ("*Text*", "<page><body><p><emphasis>Text</emphasis></p></body></page>"),
+        ("``Text``", "<page><body><p><code>Text</code></p></body></page>"),
+        (
+            "`Text <javascript:alert('xss')>`_",
+            '<page><body><p><admonition type="error">Text</admonition></p></body></page>',
+        ),
+        (
+            "Text\n\n~~~~~\n\nTest",
+            '<page><body><p>Text</p><separator xhtml:class="moin-hr3" /><p>Test</p></body></page>',
+        ),
+        (".. comment", '<page><body><div class="comment dashed">comment</div></body></page>'),
+        ("..\n comment", '<page><body><div class="comment dashed">comment</div></body></page>'),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('1. a\n   b\n   c\n\n2. b\n\n   d', '''<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>a
+        (
+            "1. a\n   b\n   c\n\n2. b\n\n   d",
+            """<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>a
 b
-c</p></list-item-body></list-item><list-item><list-item-body><p>b</p><p>d</p></list-item-body></list-item></list></body></page>'''),
-        ('1. a\n2. b\n\nA. c\n\na. A\n\n   1. B\n\n   2. C\n\n',
-         '<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>a</p></list-item-body></list-item><list-item><list-item-body><p>b</p></list-item-body></list-item></list><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body><p>c</p></list-item-body></list-item></list><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body><p>A</p><list item-label-generate="ordered"><list-item><list-item-body><p>B</p></list-item-body></list-item><list-item><list-item-body><p>C</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>'),
-        ('* A\n\n   - B\n\n      + C\n\n   - D\n\n* E',
-         '<page><body><list item-label-generate="unordered"><list-item><list-item-body><p>A</p><blockquote><list item-label-generate="unordered"><list-item><list-item-body><p>B</p><blockquote><list item-label-generate="unordered"><list-item><list-item-body><p>C</p></list-item-body></list-item></list></blockquote></list-item-body></list-item><list-item><list-item-body><p>D</p></list-item-body></list-item></list></blockquote></list-item-body></list-item><list-item><list-item-body><p>E</p></list-item-body></list-item></list></body></page>'),
-        ('what\n      def\n\nhow\n      to',
-         '<page><body><list><list-item><list-item-label>what</list-item-label><list-item-body><p>def</p></list-item-body></list-item><list-item><list-item-label>how</list-item-label><list-item-body><p>to</p></list-item-body></list-item></list></body></page>'),
+c</p></list-item-body></list-item><list-item><list-item-body><p>b</p><p>d</p></list-item-body></list-item></list></body></page>""",
+        ),
+        (
+            "1. a\n2. b\n\nA. c\n\na. A\n\n   1. B\n\n   2. C\n\n",
+            '<page><body><list item-label-generate="ordered"><list-item><list-item-body><p>a</p></list-item-body></list-item><list-item><list-item-body><p>b</p></list-item-body></list-item></list><list item-label-generate="ordered" list-style-type="upper-alpha"><list-item><list-item-body><p>c</p></list-item-body></list-item></list><list item-label-generate="ordered" list-style-type="lower-alpha"><list-item><list-item-body><p>A</p><list item-label-generate="ordered"><list-item><list-item-body><p>B</p></list-item-body></list-item><list-item><list-item-body><p>C</p></list-item-body></list-item></list></list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "* A\n\n   - B\n\n      + C\n\n   - D\n\n* E",
+            '<page><body><list item-label-generate="unordered"><list-item><list-item-body><p>A</p><blockquote><list item-label-generate="unordered"><list-item><list-item-body><p>B</p><blockquote><list item-label-generate="unordered"><list-item><list-item-body><p>C</p></list-item-body></list-item></list></blockquote></list-item-body></list-item><list-item><list-item-body><p>D</p></list-item-body></list-item></list></blockquote></list-item-body></list-item><list-item><list-item-body><p>E</p></list-item-body></list-item></list></body></page>',
+        ),
+        (
+            "what\n      def\n\nhow\n      to",
+            "<page><body><list><list-item><list-item-label>what</list-item-label><list-item-body><p>def</p></list-item-body></list-item><list-item><list-item-label>how</list-item-label><list-item-body><p>to</p></list-item-body></list-item></list></body></page>",
+        ),
         # starting an ordered list with a value other than 1 generates an error
-        (' 3. A\n #. B',
-         '<page><body><blockquote><list item-label-generate="ordered"><list-item><list-item-body><p>A</p>'
-         '</list-item-body></list-item><list-item><list-item-body><p>B</p></list-item-body></list-item></list>'
-         '<admonition type="error"><p>Enumerated list start value not ordinal-1: "3" (ordinal 3)</p></admonition>'
-         '</blockquote></body></page>'),
+        (
+            " 3. A\n #. B",
+            '<page><body><blockquote><list item-label-generate="ordered"><list-item><list-item-body><p>A</p>'
+            "</list-item-body></list-item><list-item><list-item-body><p>B</p></list-item-body></list-item></list>"
+            '<admonition type="error"><p>Enumerated list start value not ordinal-1: "3" (ordinal 3)</p></admonition>'
+            "</blockquote></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('term 1\n definition 1',
-         '<page><body><list><list-item><list-item-label>term 1</list-item-label><list-item-body><p>definition 1</p></list-item-body></list-item></list></body></page>'),
-        ('term 2 : classifier 1 : classifier 2\n definition 2',
-         '<page><body><list><list-item><list-item-label>term 2<span>:classifier 1</span><span>:classifier 2</span></list-item-label>classifier 1classifier 2<list-item-body><p>definition 2</p></list-item-body></list-item></list></body></page>'),
+        (
+            "term 1\n definition 1",
+            "<page><body><list><list-item><list-item-label>term 1</list-item-label><list-item-body><p>definition 1</p></list-item-body></list-item></list></body></page>",
+        ),
+        (
+            "term 2 : classifier 1 : classifier 2\n definition 2",
+            "<page><body><list><list-item><list-item-label>term 2<span>:classifier 1</span><span>:classifier 2</span></list-item-label>classifier 1classifier 2<list-item-body><p>definition 2</p></list-item-body></list-item></list></body></page>",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_definition_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('.. image:: images/biohazard.png',
-         '<page><body><xinclude:include xinclude:href="wiki.local:images/biohazard.png" /></body></page>'),
-        (""".. image:: images/biohazard.png
+        (
+            ".. image:: images/biohazard.png",
+            '<page><body><xinclude:include xinclude:href="wiki.local:images/biohazard.png" /></body></page>',
+        ),
+        (
+            """.. image:: images/biohazard.png
     :height: 100
     :width: 200
     :scale: 50
     :alt: alternate text""",
-         '<page><body><xinclude:include xhtml:alt="alternate text" xhtml:height="50" xhtml:width="100" xinclude:href="wiki.local:images/biohazard.png" /></body></page>'),
-        ('abc |test| cba\n\n.. |test| image:: test.png',
-         '<page><body><p>abc <xinclude:include xhtml:alt="test" xinclude:href="wiki.local:test.png" /> cba</p></body></page>'),
+            '<page><body><xinclude:include xhtml:alt="alternate text" xhtml:height="50" xhtml:width="100" xinclude:href="wiki.local:images/biohazard.png" /></body></page>',
+        ),
+        (
+            "abc |test| cba\n\n.. |test| image:: test.png",
+            '<page><body><p>abc <xinclude:include xhtml:alt="test" xinclude:href="wiki.local:test.png" /> cba</p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_image(self, input, output):
         self.do(input, output)
 
     data = [
         # from http://docutils.sourceforge.net/docs/user/rst/quickstart.html#sections; note first header is level 2 because same underlining was used for Chapter 2 Title
-        ('Chapter 1 Title\n===============\n\nSection 1.1 Title\n-----------------\n\nSubsection 1.1.1 Title\n~~~~~~~~~~~~~~~~~~~~~~\n\nSection 1.2 Title\n-----------------\n\nChapter 2 Title\n===============\n',
-         '<page><body><h outline-level="2">Chapter 1 Title</h><h outline-level="3">Section 1.1 Title</h><h outline-level="4">Subsection 1.1.1 Title</h><h outline-level="3">Section 1.2 Title</h><h outline-level="2">Chapter 2 Title</h></body></page>'),
-
+        (
+            "Chapter 1 Title\n===============\n\nSection 1.1 Title\n-----------------\n\nSubsection 1.1.1 Title\n~~~~~~~~~~~~~~~~~~~~~~\n\nSection 1.2 Title\n-----------------\n\nChapter 2 Title\n===============\n",
+            '<page><body><h outline-level="2">Chapter 1 Title</h><h outline-level="3">Section 1.1 Title</h><h outline-level="4">Subsection 1.1.1 Title</h><h outline-level="3">Section 1.2 Title</h><h outline-level="2">Chapter 2 Title</h></body></page>',
+        ),
         # from http://docutils.sourceforge.net/docs/user/rst/quickstart.html#document-title-subtitle; note Subtitle and Section Title are level 2
-        ('================\n Document Title\n================\n\n----------\n Subtitle\n----------\n\nSection Title\n=============',
-         '<page><body><h outline-level="1">Document Title</h><h outline-level="2">Subtitle</h><h outline-level="2">Section Title</h></body></page>'),
-
+        (
+            "================\n Document Title\n================\n\n----------\n Subtitle\n----------\n\nSection Title\n=============",
+            '<page><body><h outline-level="1">Document Title</h><h outline-level="2">Subtitle</h><h outline-level="2">Section Title</h></body></page>',
+        ),
         # similar to test above; note that H3 is level 2, H4 is level 3, ...
-        ('==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\n',
-         '<page><body><h outline-level="1">H1</h><h outline-level="2">H2</h><h outline-level="2">H3</h><h outline-level="3">H4</h><h outline-level="4">H5</h><h outline-level="5">H6</h></body></page>'),
-
+        (
+            "==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\n",
+            '<page><body><h outline-level="1">H1</h><h outline-level="2">H2</h><h outline-level="2">H3</h><h outline-level="3">H4</h><h outline-level="4">H5</h><h outline-level="5">H6</h></body></page>',
+        ),
         # adding a H2a heading using the H2 style underlining results in "normal" heading levels: H1 is a title, h2 and all other headings are sections
-        ('==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n\n',
-         '<page><body><h outline-level="1">H1</h><h outline-level="2">H2</h><h outline-level="3">H3</h><h outline-level="4">H4</h><h outline-level="5">H5</h><h outline-level="6">H6</h><h outline-level="2">H2a</h></body></page>'),
-
+        (
+            "==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n\n",
+            '<page><body><h outline-level="1">H1</h><h outline-level="2">H2</h><h outline-level="3">H3</h><h outline-level="4">H4</h><h outline-level="5">H5</h><h outline-level="6">H6</h><h outline-level="2">H2a</h></body></page>',
+        ),
         # when a document starts with a paragraph, then the first heading is rendered as a section level 2 heading
-        ('Paragraph\n\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\n',
-         '<page><body><p>Paragraph</p><h outline-level="2">H1</h><h outline-level="3">H2</h><h outline-level="4">H3</h><h outline-level="5">H4</h><h outline-level="6">H5</h></body></page>'),
+        (
+            "Paragraph\n\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\n",
+            '<page><body><p>Paragraph</p><h outline-level="2">H1</h><h outline-level="3">H2</h><h outline-level="4">H3</h><h outline-level="5">H4</h><h outline-level="6">H5</h></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_headers(self, input, output):
         """
         reST has a unique method of defining heading levels.
@@ -150,78 +172,113 @@ def test_headers(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Abra [1]_\n\n.. [1] arba',
-         '<page><body><p>Abra <note note-class="footnote"><note-body>arba</note-body></note></p></body></page>'),
-        ('Abra [#]_\n\n.. [#] arba',
-         '<page><body><p>Abra <note note-class="footnote"><note-body>arba</note-body></note></p></body></page>'),
+        (
+            "Abra [1]_\n\n.. [1] arba",
+            '<page><body><p>Abra <note note-class="footnote"><note-body>arba</note-body></note></p></body></page>',
+        ),
+        (
+            "Abra [#]_\n\n.. [#] arba",
+            '<page><body><p>Abra <note note-class="footnote"><note-body>arba</note-body></note></p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_footnote(self, input, output):
         self.do(input, output)
 
     data = [
-        (':Date: 2001-08-16\n:Version: 1\n:Authors: Joe Doe',
-         '<page><body><table><table-body>2001-08-16<table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1</table-cell></table-row><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Joe Doe</table-cell></table-row></table-body></table></body></page>'),
+        (
+            ":Date: 2001-08-16\n:Version: 1\n:Authors: Joe Doe",
+            "<page><body><table><table-body>2001-08-16<table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1</table-cell></table-row><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Joe Doe</table-cell></table-row></table-body></table></body></page>",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_field_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Abra test_ arba\n\n.. _test: http://python.org',
-         '<page><body><p>Abra <a xlink:href="http://python.org">test</a> arba</p></body></page>'),
-        ('Abra test__ arba\n\n.. __: http://python.org/fish/',
-         '<page><body><p>Abra <a xlink:href="http://python.org/fish/">test</a> arba</p></body></page>'),
-        ('Abra test__ arba\n\n.. __: http://python.org',
-         '<page><body><p>Abra <a xlink:href="http://python.org">test</a> arba</p></body></page>'),
-        ('Abra\n\n.. _example:\n\nAbra example_ arba\n',
-         '<page><body><p>Abra</p><span id="example" /><p>Abra <a xlink:href="wiki.local:#example">example</a> arba</p></body></page>'),
-        ('Abra example_ arba\n\n.. _example:\n\ntext',
-         '<page><body><p>Abra <a xlink:href="wiki.local:#example">example</a> arba</p><span id="example" /><p>text</p></body></page>'),
-        ('http://www.python.org/',
-         '<page><body><p><a xlink:href="http://www.python.org/">http://www.python.org/</a></p></body></page>'),
-        ('http:Home',
-         '<page><body><p><a xlink:href="wiki.local:Home">http:Home</a></p></body></page>'),
-        ('`Home <http:Home>`_',
-         '<page><body><p><a xlink:href="wiki.local:Home">Home</a></p></body></page>'),
-        ('mailto:me@moin.com',
-         '<page><body><p><a xlink:href="mailto:me@moin.com">mailto:me@moin.com</a></p></body></page>'),
-        ('`email me <mailto:fred@example.com>`_',
-         '<page><body><p><a xlink:href="mailto:fred@example.com">email me</a></p></body></page>'),
-        ('`Write to me`_ with your questions.\n\n.. _Write to me: jdoe@example.com',
-         '<page><body><p><a xlink:href="mailto:jdoe@example.com">Write to me</a> with your questions.</p></body></page>'),
+        (
+            "Abra test_ arba\n\n.. _test: http://python.org",
+            '<page><body><p>Abra <a xlink:href="http://python.org">test</a> arba</p></body></page>',
+        ),
+        (
+            "Abra test__ arba\n\n.. __: http://python.org/fish/",
+            '<page><body><p>Abra <a xlink:href="http://python.org/fish/">test</a> arba</p></body></page>',
+        ),
+        (
+            "Abra test__ arba\n\n.. __: http://python.org",
+            '<page><body><p>Abra <a xlink:href="http://python.org">test</a> arba</p></body></page>',
+        ),
+        (
+            "Abra\n\n.. _example:\n\nAbra example_ arba\n",
+            '<page><body><p>Abra</p><span id="example" /><p>Abra <a xlink:href="wiki.local:#example">example</a> arba</p></body></page>',
+        ),
+        (
+            "Abra example_ arba\n\n.. _example:\n\ntext",
+            '<page><body><p>Abra <a xlink:href="wiki.local:#example">example</a> arba</p><span id="example" /><p>text</p></body></page>',
+        ),
+        (
+            "http://www.python.org/",
+            '<page><body><p><a xlink:href="http://www.python.org/">http://www.python.org/</a></p></body></page>',
+        ),
+        ("http:Home", '<page><body><p><a xlink:href="wiki.local:Home">http:Home</a></p></body></page>'),
+        ("`Home <http:Home>`_", '<page><body><p><a xlink:href="wiki.local:Home">Home</a></p></body></page>'),
+        (
+            "mailto:me@moin.com",
+            '<page><body><p><a xlink:href="mailto:me@moin.com">mailto:me@moin.com</a></p></body></page>',
+        ),
+        (
+            "`email me <mailto:fred@example.com>`_",
+            '<page><body><p><a xlink:href="mailto:fred@example.com">email me</a></p></body></page>',
+        ),
+        (
+            "`Write to me`_ with your questions.\n\n.. _Write to me: jdoe@example.com",
+            '<page><body><p><a xlink:href="mailto:jdoe@example.com">Write to me</a> with your questions.</p></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        ('.. macro:: <<TableOfContents()>>', '<page><body><table-of-content /></body></page>'),
-        ('.. macro:: <<Macro()>>', '<page><body><inline-part content-type="x-moin/macro;name=Macro" /></body></page>'),
-        ('.. macro:: Macro(arg)',
-         '<page><body><inline-part content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></body></page>'),
-        ('test |a| test\n\n.. |a| macro:: <<Macro()>>',
-         '<page><body><p>test <inline-part content-type="x-moin/macro;name=Macro" /> test</p></body></page>'),
-        ('.. contents::\n  :depth: 1\n', '<page><body><table-of-content outline-level="1" /></body></page>'),
-        ('.. parser:: python test=test\n  import test\n  test.s = 11',
-         '<page><body><part content-type="x-moin/format;name=python"><arguments><argument name="test">test</argument></arguments>import test\ntest.s = 11</part></body></page>'),
-        ('.. include:: RecentChanges',
-         '<page><body><xinclude:include alt="&lt;&lt;Include(RecentChanges)&gt;&gt;" content-type="x-moin/macro;name=Include" xinclude:href="wiki.local:RecentChanges" /></body></page>'),
+        (".. macro:: <<TableOfContents()>>", "<page><body><table-of-content /></body></page>"),
+        (".. macro:: <<Macro()>>", '<page><body><inline-part content-type="x-moin/macro;name=Macro" /></body></page>'),
+        (
+            ".. macro:: Macro(arg)",
+            '<page><body><inline-part content-type="x-moin/macro;name=Macro"><arguments>arg</arguments></inline-part></body></page>',
+        ),
+        (
+            "test |a| test\n\n.. |a| macro:: <<Macro()>>",
+            '<page><body><p>test <inline-part content-type="x-moin/macro;name=Macro" /> test</p></body></page>',
+        ),
+        (".. contents::\n  :depth: 1\n", '<page><body><table-of-content outline-level="1" /></body></page>'),
+        (
+            ".. parser:: python test=test\n  import test\n  test.s = 11",
+            '<page><body><part content-type="x-moin/format;name=python"><arguments><argument name="test">test</argument></arguments>import test\ntest.s = 11</part></body></page>',
+        ),
+        (
+            ".. include:: RecentChanges",
+            '<page><body><xinclude:include alt="&lt;&lt;Include(RecentChanges)&gt;&gt;" content-type="x-moin/macro;name=Include" xinclude:href="wiki.local:RecentChanges" /></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_directive(self, input, output):
         self.do(input, output)
 
     data = [
-        ('+-+-+-+\n|A|B|D|\n+-+-+ +\n|C  | |\n+---+-+\n\n',
-         '<page><body><table><table-body><table-row><table-cell><p>A</p></table-cell><table-cell><p>B</p></table-cell><table-cell number-rows-spanned="2"><p>D</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>C</p></table-cell></table-row></table-body></table></body></page>'),
-        ('+-----+-----+-----+\n|**A**|**B**|**C**|\n+-----+-----+-----+\n|1    |2    |3    |\n+-----+-----+-----+\n\n',
-         '<page><body><table><table-body><table-row><table-cell><p><strong>A</strong></p></table-cell><table-cell><p><strong>B</strong></p></table-cell><table-cell><p><strong>C</strong></p></table-cell></table-row><table-row><table-cell><p>1</p></table-cell><table-cell><p>2</p></table-cell><table-cell><p>3</p></table-cell></table-row></table-body></table></body></page>'),
-        ("""+--------------------+-------------------------------------+
+        (
+            "+-+-+-+\n|A|B|D|\n+-+-+ +\n|C  | |\n+---+-+\n\n",
+            '<page><body><table><table-body><table-row><table-cell><p>A</p></table-cell><table-cell><p>B</p></table-cell><table-cell number-rows-spanned="2"><p>D</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>C</p></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            "+-----+-----+-----+\n|**A**|**B**|**C**|\n+-----+-----+-----+\n|1    |2    |3    |\n+-----+-----+-----+\n\n",
+            "<page><body><table><table-body><table-row><table-cell><p><strong>A</strong></p></table-cell><table-cell><p><strong>B</strong></p></table-cell><table-cell><p><strong>C</strong></p></table-cell></table-row><table-row><table-cell><p>1</p></table-cell><table-cell><p>2</p></table-cell><table-cell><p>3</p></table-cell></table-row></table-body></table></body></page>",
+        ),
+        (
+            """+--------------------+-------------------------------------+
 |cell spanning 2 rows|cell in the 2nd column               |
 +                    +-------------------------------------+
 |                    |cell in the 2nd column of the 2nd row|
@@ -232,8 +289,10 @@ def test_directive(self, input, output):
 +----------------------------------------------------------+
 
 """,
-         '<page><body><table><table-body><table-row><table-cell number-rows-spanned="2"><p>cell spanning 2 rows</p></table-cell><table-cell><p>cell in the 2nd column</p></table-cell></table-row><table-row><table-cell><p>cell in the 2nd column of the 2nd row</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row></table-body></table></body></page>'),
-        ("""
+            '<page><body><table><table-body><table-row><table-cell number-rows-spanned="2"><p>cell spanning 2 rows</p></table-cell><table-cell><p>cell in the 2nd column</p></table-cell></table-row><table-row><table-cell><p>cell in the 2nd column of the 2nd row</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row></table-body></table></body></page>',
+        ),
+        (
+            """
 +--------------------+-------------------------------------+
 | AAAAAAAAAAAAAAAAAA | BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB |
 +====================+=====================================+
@@ -247,29 +306,32 @@ def test_directive(self, input, output):
 +----------------------------------------------------------+
 
 """,
-         '<page><body><table><table-header><table-row><table-cell><p>AAAAAAAAAAAAAAAAAA</p></table-cell><table-cell><p>BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB</p></table-cell></table-row></table-header><table-body><table-row><table-cell number-rows-spanned=\"2\"><p>cell spanning 2 rows</p></table-cell><table-cell><p>cell in the 2nd column</p></table-cell></table-row><table-row><table-cell><p>cell in the 2nd column of the 2nd row</p></table-cell></table-row><table-row><table-cell number-columns-spanned=\"2\"><p>test</p></table-cell></table-row><table-row><table-cell number-columns-spanned=\"2\"><p>test</p></table-cell></table-row></table-body></table></body></page>'),
+            '<page><body><table><table-header><table-row><table-cell><p>AAAAAAAAAAAAAAAAAA</p></table-cell><table-cell><p>BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB</p></table-cell></table-row></table-header><table-body><table-row><table-cell number-rows-spanned="2"><p>cell spanning 2 rows</p></table-cell><table-cell><p>cell in the 2nd column</p></table-cell></table-row><table-row><table-cell><p>cell in the 2nd column of the 2nd row</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row><table-row><table-cell number-columns-spanned="2"><p>test</p></table-cell></table-row></table-body></table></body></page>',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        (':Author: Test\n:Version:  $Revision: 1.17 $\n:Copyright: c\n:Test: t',
-         '<page><body><table><table-body><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Test</table-cell></table-row><table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1.17</table-cell></table-row><table-row><table-cell><strong>Copyright:</strong></table-cell><table-cell>c</table-cell></table-row><table-row><table-cell><strong>Test:</strong></table-cell><table-cell><p>t</p></table-cell></table-row></table-body></table></body></page>'),
+        (
+            ":Author: Test\n:Version:  $Revision: 1.17 $\n:Copyright: c\n:Test: t",
+            "<page><body><table><table-body><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Test</table-cell></table-row><table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1.17</table-cell></table-row><table-row><table-cell><strong>Copyright:</strong></table-cell><table-cell>c</table-cell></table-row><table-row><table-cell><strong>Test:</strong></table-cell><table-cell><p>t</p></table-cell></table-row></table-body></table></body></page>",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_docutils_feature(self, input, output):
         self.do(input, output)
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
-        out = self.conv(input, 'text/x-rst;charset=utf-8', **args)
+        out = self.conv(input, "text/x-rst;charset=utf-8", **args)
         assert self.serialize_strip(out) == output
 
 
-coverage_modules = ['moin.converters.rst_in']
+coverage_modules = ["moin.converters.rst_in"]
diff --git a/src/moin/converters/_tests/test_rst_in_out.py b/src/moin/converters/_tests/test_rst_in_out.py
index 377fd95a1..d4000d9a9 100644
--- a/src/moin/converters/_tests/test_rst_in_out.py
+++ b/src/moin/converters/_tests/test_rst_in_out.py
@@ -25,19 +25,20 @@
 from moin.converters.rst_out import Converter as conv_out
 
 # ### TODO: try block (do not crash if we don't have docutils)
-pytest.importorskip('docutils')  # noqa
+pytest.importorskip("docutils")  # noqa
 
 
 class TestConverter:
 
     input_namespaces = 'xmlns="{}" xmlns:page="{}" xmlns:xlink="{}" xmlns:xinclude="{}" xmlns:html="{}"'.format(
-        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace)
+        moin_page.namespace, moin_page.namespace, xlink.namespace, xinclude.namespace, html.namespace
+    )
 
     namespaces = {
-        moin_page.namespace: 'page',
-        xlink.namespace: 'xlink',
-        xinclude.namespace: 'xinclude',
-        html.namespace: 'html',
+        moin_page.namespace: "page",
+        xlink.namespace: "xlink",
+        xinclude.namespace: "xinclude",
+        html.namespace: "html",
     }
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
@@ -48,160 +49,160 @@ def setup_class(self):
 
     data = [
         # output is not identical to input, but HTML out display is the same
-        ('=====\nTitle\n=====\n\nSubTitle\n========\n\nSection\n-------\n',
-         '\n=====\nTitle\n=====\n\nSubTitle\n========\n\nSection\n=======\n'),
-        ('para\n\n=======\nSection\n=======\n\nSubsection\n==========\n\nSubsubection\n------------\n',
-         'para\n\nSection\n=======\n\nSubsection\n----------\n\nSubsubection\n************\n'),
+        (
+            "=====\nTitle\n=====\n\nSubTitle\n========\n\nSection\n-------\n",
+            "\n=====\nTitle\n=====\n\nSubTitle\n========\n\nSection\n=======\n",
+        ),
+        (
+            "para\n\n=======\nSection\n=======\n\nSubsection\n==========\n\nSubsubection\n------------\n",
+            "para\n\nSection\n=======\n\nSubsection\n----------\n\nSubsubection\n************\n",
+        ),
         # output identical to input
-        ('\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n',
-         '\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n'),
+        (
+            "\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n",
+            "\n==\nH1\n==\n\nH2\n==\n\nH3\n--\n\nH4\n**\n\nH5\n::\n\nH6\n++\n\nH2a\n===\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_headers(self, input, output):
         self.do(input, output)
 
     data = [
-        ('Text',
-         'Text\n'),
-        ('Text\n\nText\n',
-         'Text\n\nText\n'),
-        ('**strong**\n',
-         '**strong**\n'),
-        ('*emphasis*\n',
-         '*emphasis*\n'),
+        ("Text", "Text\n"),
+        ("Text\n\nText\n", "Text\n\nText\n"),
+        ("**strong**\n", "**strong**\n"),
+        ("*emphasis*\n", "*emphasis*\n"),
         # extraneous x required below to prevent IndexError, side effect of serializer
-        ('{{{{{x\nblockcode\n}}}}}\n',
-         '{{{{{x\nblockcode\n}}}}}\n'),
-        ('--(stroke)--\n',
-         '--(stroke)--\n'),
-        ('__underline__\n',
-         '__underline__\n'),
-        ('~+larger+~\n',
-         '~+larger+~\n'),
-        ('~-smaller-~\n',
-         '~-smaller-~\n'),
-        ('^super^script\n',
-         '^super^script\n'),
-        (',,sub,,script\n',
-         ',,sub,,script\n'),
-        ('#ANY any',
-         '#ANY any\n'),
+        ("{{{{{x\nblockcode\n}}}}}\n", "{{{{{x\nblockcode\n}}}}}\n"),
+        ("--(stroke)--\n", "--(stroke)--\n"),
+        ("__underline__\n", "__underline__\n"),
+        ("~+larger+~\n", "~+larger+~\n"),
+        ("~-smaller-~\n", "~-smaller-~\n"),
+        ("^super^script\n", "^super^script\n"),
+        (",,sub,,script\n", ",,sub,,script\n"),
+        ("#ANY any", "#ANY any\n"),
         # line blocks
-        ('\n| Lend us a couple of bob till Thursday.\n',
-         '\n| Lend us a couple of bob till Thursday.\n'),
+        ("\n| Lend us a couple of bob till Thursday.\n", "\n| Lend us a couple of bob till Thursday.\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('.. This is a comment',
-         '\n..\n This is a comment\n'),
-        ('..\n This is a comment',
-         '\n..\n This is a comment\n'),
-        ('..\n [and] this!',
-         '\n..\n [and] this!\n'),
-        ('..\n this:: too!',
-         '\n..\n this:: too!\n'),
-        ('..\n |even| this:: !',
-         '\n..\n |even| this:: !\n'),
+        (".. This is a comment", "\n..\n This is a comment\n"),
+        ("..\n This is a comment", "\n..\n This is a comment\n"),
+        ("..\n [and] this!", "\n..\n [and] this!\n"),
+        ("..\n this:: too!", "\n..\n this:: too!\n"),
+        ("..\n |even| this:: !", "\n..\n |even| this:: !\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_comments(self, input, output):
         self.do(input, output)
 
     data = [
-        ('.. macro:: <<TableOfContents()>>',
-         '\n\n.. contents::\n\n'),
-        ('.. contents::',
-         '\n\n.. contents::\n\n'),
-        ('.. macro:: <<Include(MyPage)>>',
-         '\n.. include:: MyPage\n'),
-        ('.. include:: MyPage',
-         '\n.. include:: MyPage\n'),
-        ('.. macro:: <<RandomItem()>>',
-         '\n.. macro:: <<RandomItem()>>\n'),
-        ('.. macro:: <<RandomItem(5)>>',
-         '\n.. macro:: <<RandomItem(5)>>\n'),
-        ('.. macro:: <<Date>>',
-         '\n.. macro:: <<Date()>>\n'),
+        (".. macro:: <<TableOfContents()>>", "\n\n.. contents::\n\n"),
+        (".. contents::", "\n\n.. contents::\n\n"),
+        (".. macro:: <<Include(MyPage)>>", "\n.. include:: MyPage\n"),
+        (".. include:: MyPage", "\n.. include:: MyPage\n"),
+        (".. macro:: <<RandomItem()>>", "\n.. macro:: <<RandomItem()>>\n"),
+        (".. macro:: <<RandomItem(5)>>", "\n.. macro:: <<RandomItem(5)>>\n"),
+        (".. macro:: <<Date>>", "\n.. macro:: <<Date()>>\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macros(self, input, output):
         self.do(input, output)
 
     data = [
         # examples taken from http://docutils.sourceforge.net/docs/user/rst/quickref.html#explicit-markup
         # output is not identical to input, but HTML out display is the same
-        ('External hyperlinks, like Python_.\n\n.. _Python: http://www.python.org/',
-         'External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n'),
-        ('External hyperlinks, like `Python <http://www.python.org/>`_.',
-         'External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n'),
-        ('Internal crossreferences, like example_.\n\n.. _example:\n\nThis is an example crossreference target.',
-         'Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n'),
-        ('Python_ is `my favourite programming language`__.\n\n.. _Python: http://www.python.org/\n\n__ Python_',
-         '`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n'),
-        ('Titles are targets, too \n======================= \nImplict references, like `Titles are targets, too`_.',
-         '\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n'),
+        (
+            "External hyperlinks, like Python_.\n\n.. _Python: http://www.python.org/",
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+        ),
+        (
+            "External hyperlinks, like `Python <http://www.python.org/>`_.",
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+        ),
+        (
+            "Internal crossreferences, like example_.\n\n.. _example:\n\nThis is an example crossreference target.",
+            "Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n",
+        ),
+        (
+            "Python_ is `my favourite programming language`__.\n\n.. _Python: http://www.python.org/\n\n__ Python_",
+            "`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n",
+        ),
+        (
+            "Titles are targets, too \n======================= \nImplict references, like `Titles are targets, too`_.",
+            "\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n",
+        ),
         # output is same as input
-        ('External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n',
-         'External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n'),
-        ('External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n',
-         'External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n'),
-        ('Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n',
-         'Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n'),
-        ('`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n',
-         '`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n'),
-        ('\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n',
-         '\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n'),
+        (
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+        ),
+        (
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+            "External hyperlinks, like `Python`_.\n\n\n.. _Python: http://www.python.org/\n\n",
+        ),
+        (
+            "Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n",
+            "Internal crossreferences, like `example`_.\n\n.. _example:\n\nThis is an example crossreference target.\n",
+        ),
+        (
+            "`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n",
+            "`Python`_ is `my favourite programming language`_.\n\n\n.. _Python: http://www.python.org/\n\n.. _my favourite programming language: http://www.python.org/\n\n",
+        ),
+        (
+            "\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n",
+            "\n=======================\nTitles are targets, too\n=======================\n\nImplict references, like `Titles are targets, too`_.\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        ('- a\n- b\n\n  - aa\n  - ab\n',
-         '\n* a\n* b\n\n  * aa\n  * ab\n'),
-        ('1. a\n#. b\n\n   (A) aa\n   (#) ab\n\n',
-         '\n1. a\n#. b\n\n   A. aa\n   #. ab\n'),
-        ('1. a\n#. b\n\n   (A) aa\n   (#) ab\n',
-         '\n1. a\n#. b\n\n   A. aa\n   #. ab\n'),
+        ("- a\n- b\n\n  - aa\n  - ab\n", "\n* a\n* b\n\n  * aa\n  * ab\n"),
+        ("1. a\n#. b\n\n   (A) aa\n   (#) ab\n\n", "\n1. a\n#. b\n\n   A. aa\n   #. ab\n"),
+        ("1. a\n#. b\n\n   (A) aa\n   (#) ab\n", "\n1. a\n#. b\n\n   A. aa\n   #. ab\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
         # simple tables are converted to grid tables
-        ('== == ==\na  b  c  \n== == ==\n1  2  3\n== == ==',
-         '\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n'),
-        ('\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n',
-         '\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n'),
+        ("== == ==\na  b  c  \n== == ==\n1  2  3\n== == ==", "\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n"),
+        ("\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n", "\n+-+-+-+\n|a|b|c|\n+=+=+=+\n|1|2|3|\n+-+-+-+\n\n"),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('.. image:: png\n   :scale: 50\n   :alt: alternate text png\n   :align: center\n   :height: 100\n   :width: 200\n',
-         '\n.. image:: png\n   :alt: alternate text png\n   :align: center\n   :height: 50\n   :width: 100\n'),
-        ('.. figure:: png\n   :alt: alternate text png\n   :height: 100\n   :width: 200\n   :scale: 50\n\n   Moin Logo\n\n   This logo replaced the "MoinMoin Man"\n   logo long ago.\n',
-         '\n.. figure:: png\n   :alt: alternate text png\n   :height: 50\n   :width: 100\n\n   Moin Logo\n\n   This logo replaced the "MoinMoin Man"\n   logo long ago.\n'),
+        (
+            ".. image:: png\n   :scale: 50\n   :alt: alternate text png\n   :align: center\n   :height: 100\n   :width: 200\n",
+            "\n.. image:: png\n   :alt: alternate text png\n   :align: center\n   :height: 50\n   :width: 100\n",
+        ),
+        (
+            '.. figure:: png\n   :alt: alternate text png\n   :height: 100\n   :width: 200\n   :scale: 50\n\n   Moin Logo\n\n   This logo replaced the "MoinMoin Man"\n   logo long ago.\n',
+            '\n.. figure:: png\n   :alt: alternate text png\n   :height: 50\n   :width: 100\n\n   Moin Logo\n\n   This logo replaced the "MoinMoin Man"\n   logo long ago.\n',
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_object(self, input, output):
         self.do(input, output)
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
@@ -209,12 +210,12 @@ def handle_output(self, elem, **options):
 
     def serialize_strip(self, elem, **options):
         result = serialize(elem, namespaces=self.namespaces, **options)
-        return self.output_re.sub('', result)
+        return self.output_re.sub("", result)
 
     def do(self, input, output, args={}, skip=None):
         if skip:
             pytest.skip(skip)
-        out = self.conv_in(input, 'text/x.moin.wiki;charset=utf-8', **args)
+        out = self.conv_in(input, "text/x.moin.wiki;charset=utf-8", **args)
         out = self.conv_out(self.handle_input(self.serialize_strip(out)), **args)
         assert self.handle_output(out) == output
         # ~ assert self.handle_output(out).strip() == output.strip()  # TODO: revert to above when number of \n between blocks in moinwiki_out.py is stable
diff --git a/src/moin/converters/_tests/test_rst_out.py b/src/moin/converters/_tests/test_rst_out.py
index 2028af8c4..b799da985 100644
--- a/src/moin/converters/_tests/test_rst_out.py
+++ b/src/moin/converters/_tests/test_rst_out.py
@@ -17,16 +17,16 @@
 
 
 class Base:
-    input_namespaces = ns_all = f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:xlink="{xlink.namespace}"'
-    output_namespaces = {
-        moin_page.namespace: 'page'
-    }
+    input_namespaces = ns_all = (
+        f'xmlns="{moin_page.namespace}" xmlns:page="{moin_page.namespace}" xmlns:xlink="{xlink.namespace}"'
+    )
+    output_namespaces = {moin_page.namespace: "page"}
 
     input_re = TAGSTART_RE
     output_re = XMLNS_RE
 
     def handle_input(self, input):
-        i = self.input_re.sub(r'\1 ' + self.input_namespaces, input)
+        i = self.input_re.sub(r"\1 " + self.input_namespaces, input)
         return ET.XML(i)
 
     def handle_output(self, elem, **options):
@@ -42,61 +42,75 @@ def setup_class(self):
         self.conv = Converter()
 
     data = [
-        ('<page:p>Text</page:p>',
-         'Text\n'),
-        ('<page:tag><page:p>Text</page:p><page:p>Text</page:p></page:tag>',
-         'Text\n\nText\n'),
-        ('<page:separator />',
-         '\n\n----\n\n'),
-        ('<page:strong>strong</page:strong>',
-         '**strong**'),
-        ('<page:emphasis>emphasis</page:emphasis>',
-         '*emphasis*'),
-        ('<page:blockcode>blockcode</page:blockcode>',
-         '\n::\n\n  blockcode\n\n'),
-        ('<page:code>monospace</page:code>',
-         '``monospace``'),
-        ("""<page:page><page:body><page:h page:outline-level="1">h1</page:h><page:h page:outline-level="2">h2</page:h><page:h page:outline-level="3">h3</page:h><page:h page:outline-level="4">h4</page:h><page:h page:outline-level="5">h5</page:h><page:h page:outline-level="6">h6</page:h></page:body></page:page>""",
-         """\n==\nh1\n==\n\nh2\n==\n\nh3\n--\n\nh4\n**\n\nh5\n::\n\nh6\n++\n"""),
-        ('<page:page><page:body><page:p>H<page:span page:baseline-shift="sub">2</page:span>O</page:p><page:p>E = mc<page:span page:baseline-shift="super">2</page:span></page:p></page:body></page:page>',
-         'H\\ :sub:`2`\\ O\n\nE = mc\\ :sup:`2`\\ \n'),
-        ('<page:page><page:body><page:p>H<page:span>2</page:span>O</page:p></page:body></page:page>',
-         'H2O\n'),
-        ('<page:page><page:body><page:div page:class="comment dashed">comment</page:div></page:body></page:page>',
-         '\n..\n comment\n'),
-        ('<page><body><line-block><line-blk>Lend us a couple of bob till Thursday.</line-blk></line-block></body></page>',
-         '\n| Lend us a couple of bob till Thursday.\n'),
+        ("<page:p>Text</page:p>", "Text\n"),
+        ("<page:tag><page:p>Text</page:p><page:p>Text</page:p></page:tag>", "Text\n\nText\n"),
+        ("<page:separator />", "\n\n----\n\n"),
+        ("<page:strong>strong</page:strong>", "**strong**"),
+        ("<page:emphasis>emphasis</page:emphasis>", "*emphasis*"),
+        ("<page:blockcode>blockcode</page:blockcode>", "\n::\n\n  blockcode\n\n"),
+        ("<page:code>monospace</page:code>", "``monospace``"),
+        (
+            """<page:page><page:body><page:h page:outline-level="1">h1</page:h><page:h page:outline-level="2">h2</page:h><page:h page:outline-level="3">h3</page:h><page:h page:outline-level="4">h4</page:h><page:h page:outline-level="5">h5</page:h><page:h page:outline-level="6">h6</page:h></page:body></page:page>""",
+            """\n==\nh1\n==\n\nh2\n==\n\nh3\n--\n\nh4\n**\n\nh5\n::\n\nh6\n++\n""",
+        ),
+        (
+            '<page:page><page:body><page:p>H<page:span page:baseline-shift="sub">2</page:span>O</page:p><page:p>E = mc<page:span page:baseline-shift="super">2</page:span></page:p></page:body></page:page>',
+            "H\\ :sub:`2`\\ O\n\nE = mc\\ :sup:`2`\\ \n",
+        ),
+        ("<page:page><page:body><page:p>H<page:span>2</page:span>O</page:p></page:body></page:page>", "H2O\n"),
+        (
+            '<page:page><page:body><page:div page:class="comment dashed">comment</page:div></page:body></page:page>',
+            "\n..\n comment\n",
+        ),
+        (
+            "<page><body><line-block><line-blk>Lend us a couple of bob till Thursday.</line-blk></line-block></body></page>",
+            "\n| Lend us a couple of bob till Thursday.\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_base(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         '\n* A\n'),
-        ('<page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
-         '\n1. A\n'),
-        ('<page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body>A</page:list-item-body></page:list-item></page:list>',
-         '\nI. A\n'),
-        ('<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>B</page:p><page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p><page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body><page:p>E</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>F</page:p></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list>',
-         '\n* A\n* B\n\n  1. C\n  #. D\n\n     I. E\n     #. F\n'),
-        ('<page:list><page:list-item><page:list-item-label>A</page:list-item-label><page:list-item-body><page:p>B</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p></page:list-item-body></page:list-item></page:list>',
-         'A\n  B\n  C\n  D\n'),
+        (
+            '<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            "\n* A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item></page:list>',
+            "\n1. A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body>A</page:list-item-body></page:list-item></page:list>',
+            "\nI. A\n",
+        ),
+        (
+            '<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>B</page:p><page:list page:item-label-generate="ordered"><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p><page:list page:item-label-generate="ordered" page:list-style-type="upper-roman"><page:list-item><page:list-item-body><page:p>E</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>F</page:p></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list></page:list-item-body></page:list-item></page:list>',
+            "\n* A\n* B\n\n  1. C\n  #. D\n\n     I. E\n     #. F\n",
+        ),
+        (
+            "<page:list><page:list-item><page:list-item-label>A</page:list-item-label><page:list-item-body><page:p>B</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>C</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>D</page:p></page:list-item-body></page:list-item></page:list>",
+            "A\n  B\n  C\n  D\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_list(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:table><page:table-body><page:table-row><page:table-cell>A</page:table-cell><page:table-cell>B</page:table-cell><page:table-cell page:number-rows-spanned="2">D</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2">C</page:table-cell></page:table-row></page:table-body></page:table>',
-         '\n+-+-+-+\n|A|B|D|\n+-+-+ +\n|C  | |\n+---+-+\n\n'),
-
-        ('<page:table><page:table-body><page:table-row><page:table-cell><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>B</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>1</page:p></page:table-cell><page:table-cell>2</page:table-cell><page:table-cell>3</page:table-cell></page:table-row></page:table-body></page:table>',
-         '\n+-----+-----+-----+\n|**A**|**B**|**C**|\n+-----+-----+-----+\n|1    |2    |3    |\n+-----+-----+-----+\n\n'),
-
-        ('<page:page><page:body><page:table><page:table-header><page:table-row><page:table-cell><page:p>AAAAAAAAAAAAAAAAAA</page:p></page:table-cell><page:table-cell><page:p>BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB</page:p></page:table-cell></page:table-row></page:table-header><page:table-body><page:table-row><page:table-cell page:number-rows-spanned=\"2\"><page:p>cell spanning 2 rows</page:p></page:table-cell><page:table-cell><page:p>cell in the 2nd column</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>cell in the 2nd column of the 2nd row</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned=\"2\"><page:p>test</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned=\"2\"><page:p>test</page:p></page:table-cell></page:table-row></page:table-body></page:table></page:body></page:page>', """\n+--------------------+-------------------------------------+
+        (
+            '<page:table><page:table-body><page:table-row><page:table-cell>A</page:table-cell><page:table-cell>B</page:table-cell><page:table-cell page:number-rows-spanned="2">D</page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2">C</page:table-cell></page:table-row></page:table-body></page:table>',
+            "\n+-+-+-+\n|A|B|D|\n+-+-+ +\n|C  | |\n+---+-+\n\n",
+        ),
+        (
+            "<page:table><page:table-body><page:table-row><page:table-cell><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>B</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>1</page:p></page:table-cell><page:table-cell>2</page:table-cell><page:table-cell>3</page:table-cell></page:table-row></page:table-body></page:table>",
+            "\n+-----+-----+-----+\n|**A**|**B**|**C**|\n+-----+-----+-----+\n|1    |2    |3    |\n+-----+-----+-----+\n\n",
+        ),
+        (
+            '<page:page><page:body><page:table><page:table-header><page:table-row><page:table-cell><page:p>AAAAAAAAAAAAAAAAAA</page:p></page:table-cell><page:table-cell><page:p>BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB</page:p></page:table-cell></page:table-row></page:table-header><page:table-body><page:table-row><page:table-cell page:number-rows-spanned="2"><page:p>cell spanning 2 rows</page:p></page:table-cell><page:table-cell><page:p>cell in the 2nd column</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell><page:p>cell in the 2nd column of the 2nd row</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2"><page:p>test</page:p></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2"><page:p>test</page:p></page:table-cell></page:table-row></page:table-body></page:table></page:body></page:page>',
+            """\n+--------------------+-------------------------------------+
 |AAAAAAAAAAAAAAAAAA  |BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB  |
 +====================+=====================================+
 |cell spanning 2 rows|cell in the 2nd column               |
@@ -108,35 +122,49 @@ def test_list(self, input, output):
 |test                                                      |
 +----------------------------------------------------------+
 
-"""),
-
-        ('<page:table><page:table-body><page:table-row><page:table-cell page:number-cols-spanned="2"><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2"><page:p>1</page:p></page:table-cell></page:table-row></page:table-body></page:table>',
-         '\n+------+-----+\n|**A** |**C**|\n+------+-----+\n|1     |     |\n+------+-----+\n\n'),
+""",
+        ),
+        (
+            '<page:table><page:table-body><page:table-row><page:table-cell page:number-cols-spanned="2"><page:strong>A</page:strong></page:table-cell><page:table-cell><page:strong>C</page:strong></page:table-cell></page:table-row><page:table-row><page:table-cell page:number-cols-spanned="2"><page:p>1</page:p></page:table-cell></page:table-row></page:table-body></page:table>',
+            "\n+------+-----+\n|**A** |**C**|\n+------+-----+\n|1     |     |\n+------+-----+\n\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_table(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:body></page:page>',
-         'A\n\nB\n\nC\n\nD\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '\n+-+\n|A|\n| |\n|B|\n| |\n|C|\n| |\n|D|\n+-+\n\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '\n+-+-+\n|Z|A|\n| | |\n| |B|\n| | |\n| |C|\n| | |\n| |D|\n+-+-+\n\n'),
-        ('<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell></page:table_row><page:table_row><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>',
-         '\n+-+\n|Z|\n+-+\n|A|\n| |\n|B|\n| |\n|C|\n| |\n|D|\n+-+\n\n'),
-        ('<page:page><page:body>A<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>A</page:p>A<page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body>A</page:list-item-body></page:list-item></page:list>A</page:body></page:page>',
-         'A\n* A\n\n  A\n* A\n\n  A\n\n  A\n* A\nA')
+        (
+            "<page:page><page:body><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:body></page:page>",
+            "A\n\nB\n\nC\n\nD\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "\n+-+\n|A|\n| |\n|B|\n| |\n|C|\n| |\n|D|\n+-+\n\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "\n+-+-+\n|Z|A|\n| | |\n| |B|\n| | |\n| |C|\n| | |\n| |D|\n+-+-+\n\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table_row><page:table_cell>Z</page:table_cell></page:table_row><page:table_row><page:table_cell><page:p>A</page:p><page:p>B</page:p>C<page:p>D</page:p></page:table_cell></page:table_row></page:table></page:body></page:page>",
+            "\n+-+\n|Z|\n+-+\n|A|\n| |\n|B|\n| |\n|C|\n| |\n|D|\n+-+\n\n",
+        ),
+        (
+            '<page:page><page:body>A<page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body><page:p>A</page:p>A<page:p>A</page:p></page:list-item-body></page:list-item><page:list-item><page:list-item-body>A</page:list-item-body></page:list-item></page:list>A</page:body></page:page>',
+            "A\n* A\n\n  A\n* A\n\n  A\n\n  A\n* A\nA",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_p(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page><body><table><table-body><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Test</table-cell></table-row><table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1.17</table-cell></table-row><table-row><table-cell><strong>Copyright:</strong></table-cell><table-cell>c</table-cell></table-row><table-row><table-cell><strong>Test:</strong></table-cell><table-cell><p>t</p></table-cell></table-row></table-body></table></body></page>', """\n+--------------+----+
+        (
+            "<page><body><table><table-body><table-row><table-cell><strong>Author:</strong></table-cell><table-cell>Test</table-cell></table-row><table-row><table-cell><strong>Version:</strong></table-cell><table-cell>1.17</table-cell></table-row><table-row><table-cell><strong>Copyright:</strong></table-cell><table-cell>c</table-cell></table-row><table-row><table-cell><strong>Test:</strong></table-cell><table-cell><p>t</p></table-cell></table-row></table-body></table></body></page>",
+            """\n+--------------+----+
 |**Author:**   |Test|
 +--------------+----+
 |**Version:**  |1.17|
@@ -146,40 +174,52 @@ def test_p(self, input, output):
 |**Test:**     |t   |
 +--------------+----+
 
-"""),
+""",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_docutils_features(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p></page:body></page:page>',
-         'Abra  [#]_ \n\n\n.. [#] arba\n\n'),
-        ('<page:page><page:body><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p><page:p>Abra <page:note page:note-class="footnote">arba</page:note><page:note page:note-class="footnote">arba</page:note></page:p></page:body></page:page>',
-         'Abra  [#]_ \n\nAbra  [#]_ \n\nAbra  [#]_  [#]_ \n\n\n.. [#] arba\n\n.. [#] arba\n\n.. [#] arba\n\n.. [#] arba\n\n'),
+        (
+            '<page:page><page:body><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p></page:body></page:page>',
+            "Abra  [#]_ \n\n\n.. [#] arba\n\n",
+        ),
+        (
+            '<page:page><page:body><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p><page:p>Abra <page:note page:note-class="footnote">arba</page:note></page:p><page:p>Abra <page:note page:note-class="footnote">arba</page:note><page:note page:note-class="footnote">arba</page:note></page:p></page:body></page:page>',
+            "Abra  [#]_ \n\nAbra  [#]_ \n\nAbra  [#]_  [#]_ \n\n\n.. [#] arba\n\n.. [#] arba\n\n.. [#] arba\n\n.. [#] arba\n\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_note(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba</page:p></page:body></page:page>',
-         'Abra `test`_ arba\n\n\n.. _test: http://python.org\n\n'),
-        ('<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba <page:a xlink:href="http://python.ru">test</page:a></page:p></page:body></page:page>',
-         'Abra `test`_ arba `test`_\n\n\n.. _test: http://python.org\n\n.. _test: http://python.ru\n\n'),
-        ('<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba <page:a xlink:href="http://python.ru">test</page:a> rbaa <page:a xlink:href="http://python.su">test</page:a></page:p></page:body></page:page>',
-         'Abra `test`_ arba `test`_ rbaa `test`_\n\n\n.. _test: http://python.org\n\n.. _test: http://python.ru\n\n.. _test: http://python.su\n\n'),
+        (
+            '<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba</page:p></page:body></page:page>',
+            "Abra `test`_ arba\n\n\n.. _test: http://python.org\n\n",
+        ),
+        (
+            '<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba <page:a xlink:href="http://python.ru">test</page:a></page:p></page:body></page:page>',
+            "Abra `test`_ arba `test`_\n\n\n.. _test: http://python.org\n\n.. _test: http://python.ru\n\n",
+        ),
+        (
+            '<page:page><page:body><page:p>Abra <page:a xlink:href="http://python.org">test</page:a> arba <page:a xlink:href="http://python.ru">test</page:a> rbaa <page:a xlink:href="http://python.su">test</page:a></page:p></page:body></page:page>',
+            "Abra `test`_ arba `test`_ rbaa `test`_\n\n\n.. _test: http://python.org\n\n.. _test: http://python.ru\n\n.. _test: http://python.su\n\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_link(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:table><page:table-body><page:table-row><page:table-cell><page:strong>Author:</page:strong></page:table-cell><page:table-cell>Test</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Version:</page:strong></page:table-cell><page:table-cell>1.17</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Copyright:</page:strong></page:table-cell><page:table-cell>c</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Test:</page:strong></page:table-cell><page:table-cell><page:p>t</page:p></page:table-cell></page:table-row></page:table-body></page:table></page:list-item-body></page:list-item></page:list></page:body></page:page>',
-         """\n* A
+        (
+            '<page:page><page:body><page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:table><page:table-body><page:table-row><page:table-cell><page:strong>Author:</page:strong></page:table-cell><page:table-cell>Test</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Version:</page:strong></page:table-cell><page:table-cell>1.17</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Copyright:</page:strong></page:table-cell><page:table-cell>c</page:table-cell></page:table-row><page:table-row><page:table-cell><page:strong>Test:</page:strong></page:table-cell><page:table-cell><page:p>t</page:p></page:table-cell></page:table-row></page:table-body></page:table></page:list-item-body></page:list-item></page:list></page:body></page:page>',
+            """\n* A
 
   +--------------+----+
   |**Author:**   |Test|
@@ -190,55 +230,75 @@ def test_link(self, input, output):
   +--------------+----+
   |**Test:**     |t   |
   +--------------+----+
-"""),
-        ('<page:page><page:body><page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:blockcode> test </page:blockcode></page:list-item-body></page:list-item></page:list></page:body></page:page>',
-         '\n* A\n::\n\n     test \n\n'),
-        ('<page:page><page:body><page:table><page:table-body><page:table-row><page:table-cell><page:p><page:strong>A</page:strong></page:p><page:line_break /><page:p><page:strong>A</page:strong></page:p></page:table-cell><page:table-cell><page:strong>B</page:strong><page:line_break /><page:strong>B</page:strong></page:table-cell></page:table-row></page:table-body></page:table></page:body></page:page>',
-         '\n+-----+-----+\n|**A**|**B**|\n|     |     |\n|**A**|**B**|\n+-----+-----+\n\n'),
+""",
+        ),
+        (
+            '<page:page><page:body><page:list page:item-label-generate="unordered"><page:list-item><page:list-item-body><page:p>A</page:p><page:blockcode> test </page:blockcode></page:list-item-body></page:list-item></page:list></page:body></page:page>',
+            "\n* A\n::\n\n     test \n\n",
+        ),
+        (
+            "<page:page><page:body><page:table><page:table-body><page:table-row><page:table-cell><page:p><page:strong>A</page:strong></page:p><page:line_break /><page:p><page:strong>A</page:strong></page:p></page:table-cell><page:table-cell><page:strong>B</page:strong><page:line_break /><page:strong>B</page:strong></page:table-cell></page:table-row></page:table-body></page:table></page:body></page:page>",
+            "\n+-----+-----+\n|**A**|**B**|\n|     |     |\n|**A**|**B**|\n+-----+-----+\n\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_mixed(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:object xlink:href="http://static.moinmo.in/logos/moinmoin.png" />',
-         '\n\n..  image:: http://static.moinmo.in/logos/moinmoin.png\n\n'),
-        ('<page:object page:alt="alt text" xlink:href="http://static.moinmo.in/logos/moinmoin.png">alt text</page:object>',
-         '|alt text|\n\n.. |alt text| image:: http://static.moinmo.in/logos/moinmoin.png\n\n'),
-        ('<page:object xlink:href="attachment:image.png" />',
-         '\n\n..  image:: attachment:image.png\n\n'),
-        ('<page:object page:alt="alt text" xlink:href="attachment:image.png">alt text</page:object>',
-         '|alt text|\n\n.. |alt text| image:: attachment:image.png\n\n'),
-        ('<page:object page:alt="alt text" xlink:href="attachment:image.png?width=100&amp;height=150&amp;align=left" />',
-         '|alt text|\n\n.. |alt text| image:: attachment:image.png\n  :width: 100\n  :height: 150\n  :align: left\n\n'),
+        (
+            '<page:object xlink:href="http://static.moinmo.in/logos/moinmoin.png" />',
+            "\n\n..  image:: http://static.moinmo.in/logos/moinmoin.png\n\n",
+        ),
+        (
+            '<page:object page:alt="alt text" xlink:href="http://static.moinmo.in/logos/moinmoin.png">alt text</page:object>',
+            "|alt text|\n\n.. |alt text| image:: http://static.moinmo.in/logos/moinmoin.png\n\n",
+        ),
+        ('<page:object xlink:href="attachment:image.png" />', "\n\n..  image:: attachment:image.png\n\n"),
+        (
+            '<page:object page:alt="alt text" xlink:href="attachment:image.png">alt text</page:object>',
+            "|alt text|\n\n.. |alt text| image:: attachment:image.png\n\n",
+        ),
+        (
+            '<page:object page:alt="alt text" xlink:href="attachment:image.png?width=100&amp;height=150&amp;align=left" />',
+            "|alt text|\n\n.. |alt text| image:: attachment:image.png\n  :width: 100\n  :height: 150\n  :align: left\n\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_object(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:tag><page:table-of-content page:outline-level="2" /></page:tag>',
-         '\n\n.. contents::\n   :depth: 2\n\n'),
-        ('<page:part page:alt="&lt;&lt;Anchor(anchorname)&gt;&gt;" page:content-type="x-moin/macro;name=Anchor"><page:arguments>anchorname</page:arguments></page:part>',
-         '\n.. macro:: <<Anchor(anchorname)>>\n'),
-        ('<page:part page:alt="&lt;&lt;MonthCalendar(,,12)&gt;&gt;" page:content-type="x-moin/macro;name=MonthCalendar"><page:arguments>,,12</page:arguments></page:part>',
-         '\n.. macro:: <<MonthCalendar(,,12)>>\n'),
+        (
+            '<page:tag><page:table-of-content page:outline-level="2" /></page:tag>',
+            "\n\n.. contents::\n   :depth: 2\n\n",
+        ),
+        (
+            '<page:part page:alt="&lt;&lt;Anchor(anchorname)&gt;&gt;" page:content-type="x-moin/macro;name=Anchor"><page:arguments>anchorname</page:arguments></page:part>',
+            "\n.. macro:: <<Anchor(anchorname)>>\n",
+        ),
+        (
+            '<page:part page:alt="&lt;&lt;MonthCalendar(,,12)&gt;&gt;" page:content-type="x-moin/macro;name=MonthCalendar"><page:arguments>,,12</page:arguments></page:part>',
+            "\n.. macro:: <<MonthCalendar(,,12)>>\n",
+        ),
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_macros(self, input, output):
         self.do(input, output)
 
     data = [
-        ('<page:page><page:body><page:part page:content-type="x-moin/format;name=creole"><page:arguments><page:argument page:name="style">st: er</page:argument><page:argument page:name="class">par: arg para: arga</page:argument></page:arguments><page:body>... **bold** ...</page:body></page:part></page:body></page:page>',
-         """\n\n.. parser:creole style="st: er" class="par: arg para: arga"\n  ... **bold** ..."""),
+        (
+            '<page:page><page:body><page:part page:content-type="x-moin/format;name=creole"><page:arguments><page:argument page:name="style">st: er</page:argument><page:argument page:name="class">par: arg para: arga</page:argument></page:arguments><page:body>... **bold** ...</page:body></page:part></page:body></page:page>',
+            """\n\n.. parser:creole style="st: er" class="par: arg para: arga"\n  ... **bold** ...""",
+        )
     ]
 
-    @pytest.mark.parametrize('input,output', data)
+    @pytest.mark.parametrize("input,output", data)
     def test_parser(self, input, output):
         self.do(input, output)
 
 
-coverage_modules = ['moin.converters.rst_out']
+coverage_modules = ["moin.converters.rst_out"]
diff --git a/src/moin/converters/_tests/test_smiley.py b/src/moin/converters/_tests/test_smiley.py
index 0113d117a..761e08ab8 100644
--- a/src/moin/converters/_tests/test_smiley.py
+++ b/src/moin/converters/_tests/test_smiley.py
@@ -10,12 +10,10 @@
 from moin.converters.smiley import Converter, moin_page, ET
 from . import serialize, XMLNS_RE3, TAGSTART_RE
 
-etree = pytest.importorskip('lxml.etree')  # noqa
+etree = pytest.importorskip("lxml.etree")  # noqa
 
 
-output_namespaces = {
-    moin_page.namespace: '',
-}
+output_namespaces = {moin_page.namespace: ""}
 
 input_re = TAGSTART_RE
 output_re = XMLNS_RE3
@@ -23,45 +21,52 @@
 
 def serialize_strip(elem, **options):
     result = serialize(elem, namespaces=output_namespaces, **options)
-    return output_re.sub('', result)
+    return output_re.sub("", result)
 
 
-@pytest.mark.parametrize('input,query', [
-    # normal
-    ('<page><body><p>bla bla :-) bla bla</p></body></page>',
-     '/page/body/p/span[@class="moin-text-icon moin-smile"]'),
-    # in code
-    ('<page><body><code>bla bla :-) bla bla</code></body></page>',
-     '/page/body[code="bla bla :-) bla bla"]'),
-    # 2 at once
-    ('<page><body><p>:-) :-(</p></body></page>',
-     '/page/body/p'
-     '[span[1][@class="moin-text-icon moin-smile"]]'
-     '[span[2][@class="moin-text-icon moin-sad"]]'),
-    # strong
-    ('<page><body><p><strong>:-)</strong></p></body></page>',
-     '/page/body/p/strong/span[@class="moin-text-icon moin-smile"]'),
-    # Test to check we do not have bug with newline in the string
-    ('<page><body><p>1\n2\n3\n4</p></body></page>',
-     '/page/body[p="1\n2\n3\n4"]'),
-    # Test with space between the elements
-    ('<page><body><table-of-content />     <p>text</p></body></page>',
-     '/page/body[p="text"]'),
-    # Test the ignored tags
-    ('<page><body><p><code>:-)</code></p></body></page>',
-     '/page/body/p[code=":-)"]'),
-    # Test the ignored tags and subelement
-    ('<page><body><blockcode>:-)<strong>:-(</strong></blockcode></body></page>',
-     '/page/body/blockcode[text()=":-)"][strong=":-("]'),
-])
+@pytest.mark.parametrize(
+    "input,query",
+    [
+        # normal
+        (
+            "<page><body><p>bla bla :-) bla bla</p></body></page>",
+            '/page/body/p/span[@class="moin-text-icon moin-smile"]',
+        ),
+        # in code
+        ("<page><body><code>bla bla :-) bla bla</code></body></page>", '/page/body[code="bla bla :-) bla bla"]'),
+        # 2 at once
+        (
+            "<page><body><p>:-) :-(</p></body></page>",
+            "/page/body/p"
+            '[span[1][@class="moin-text-icon moin-smile"]]'
+            '[span[2][@class="moin-text-icon moin-sad"]]',
+        ),
+        # strong
+        (
+            "<page><body><p><strong>:-)</strong></p></body></page>",
+            '/page/body/p/strong/span[@class="moin-text-icon moin-smile"]',
+        ),
+        # Test to check we do not have bug with newline in the string
+        ("<page><body><p>1\n2\n3\n4</p></body></page>", '/page/body[p="1\n2\n3\n4"]'),
+        # Test with space between the elements
+        ("<page><body><table-of-content />     <p>text</p></body></page>", '/page/body[p="text"]'),
+        # Test the ignored tags
+        ("<page><body><p><code>:-)</code></p></body></page>", '/page/body/p[code=":-)"]'),
+        # Test the ignored tags and subelement
+        (
+            "<page><body><blockcode>:-)<strong>:-(</strong></blockcode></body></page>",
+            '/page/body/blockcode[text()=":-)"][strong=":-("]',
+        ),
+    ],
+)
 def test_smiley_convert(input, query):
     conv = Converter()
-    print('input:', input)
+    print("input:", input)
     out_elem = conv(ET.XML(input))
     after_conversion = serialize_strip(out_elem)
-    print('output:', after_conversion)
-    print('query:', query)
+    print("output:", after_conversion)
+    print("query:", query)
     tree = etree.fromstring(after_conversion)
     result = tree.xpath(query)
-    print('query result:', result)
+    print("query result:", result)
     assert result
diff --git a/src/moin/converters/_util.py b/src/moin/converters/_util.py
index e65c9b870..d66b334f5 100644
--- a/src/moin/converters/_util.py
+++ b/src/moin/converters/_util.py
@@ -39,14 +39,15 @@ def decode_data(data, contenttype=None):
     if not isinstance(data, (bytes, str)):
         data = data.data.read()
     if isinstance(data, bytes):
-        coding = 'utf-8'
+        coding = "utf-8"
         if contenttype is not None:
             ct = Type(contenttype)
-            coding = ct.parameters.get('charset', coding)
+            coding = ct.parameters.get("charset", coding)
         data = data.decode(coding)
     if not isinstance(data, str):
-        raise TypeError("data must be rev or bytes (requires contenttype with charset) or str, "
-                        "but we got {!r}".format(data))
+        raise TypeError(
+            "data must be rev or bytes (requires contenttype with charset) or str, " "but we got {!r}".format(data)
+        )
     return data
 
 
@@ -54,8 +55,8 @@ def normalize_split_text(text):
     """
     normalize line endings, split text into a list of lines
     """
-    text = text.replace('\r\n', '\n')
-    lines = text.split('\n')
+    text = text.replace("\r\n", "\n")
+    lines = text.split("\n")
     return lines
 
 
@@ -121,7 +122,7 @@ def add_lineno(self, elem):
         """
         Add a custom attribute (data-lineno=nn) that will be used by Javascript to scroll edit textarea.
         """
-        if flaskg and getattr(flaskg, 'add_lineno_attr', False):
+        if flaskg and getattr(flaskg, "add_lineno_attr", False):
             if self.last_lineno != self.iter_content.lineno:
                 # avoid adding same lineno to parent and multiple children or grand-children
                 elem.attrib[html.data_lineno] = self.iter_content.lineno
@@ -161,5 +162,5 @@ def top_check(self, *names, **kwargs):
         """
         Check if the top of the stack name and attrib matches the parameters.
         """
-        attrib = kwargs.get('attrib', {})
+        attrib = kwargs.get("attrib", {})
         return self._list[-1].name in names and set(attrib.items()).issubset(set(self._list[-1].elem.attrib.items()))
diff --git a/src/moin/converters/_wiki_macro.py b/src/moin/converters/_wiki_macro.py
index 960bc368c..6132daac6 100644
--- a/src/moin/converters/_wiki_macro.py
+++ b/src/moin/converters/_wiki_macro.py
@@ -17,6 +17,7 @@
 from moin.i18n import _
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -35,7 +36,7 @@ def _FootNote_repl(self, args, text, context_block):
         text = args
         text = self.macro_text(text)  # footnotes may have markup, macro_text is likely overridden
         elem_body = moin_page.note_body(children=text)
-        attrib = {moin_page.note_class: 'footnote'}
+        attrib = {moin_page.note_class: "footnote"}
         elem = moin_page.note(attrib=attrib, children=[elem_body])
 
         if context_block:
@@ -54,10 +55,11 @@ def _Include_repl(self, args, text, context_block):
         macro output will be enclosed in a SPAN-tag. converters/include.py will resolve
         HTML 5 validation issues should the macro output block tags within an inline context.
         """
+
         def error_message(msg):
-            txt = moin_page.p(children=(text, ))
-            msg = moin_page.p(children=(msg, ))
-            msg.set(moin_page.class_, 'moin-error')
+            txt = moin_page.p(children=(text,))
+            msg = moin_page.p(children=(msg,))
+            msg.set(moin_page.class_, "moin-error")
             div = moin_page.div(children=(txt, msg))
             return div
 
@@ -73,57 +75,57 @@ def error_message(msg):
             level = int(args[2])
         except (IndexError, ValueError):
             pass
-        sort = 'sort' in args and args['sort']
-        if sort and sort not in ('ascending', 'descending'):
+        sort = "sort" in args and args["sort"]
+        if sort and sort not in ("ascending", "descending"):
             return error_message(_("Include Macro above has invalid format, expected sort=ascending or descending"))
         # TODO: We need corresponding code in include.py to process items, skipitems, titlesonly, and editlink
-        items = 'items' in args and int(args['items'])
-        skipitems = 'skipitems' in args and int(args['skipitems'])
-        titlesonly = 'titlesonly' in args
-        editlink = 'editlink' in args
+        items = "items" in args and int(args["items"])
+        skipitems = "skipitems" in args and int(args["skipitems"])
+        titlesonly = "titlesonly" in args
+        editlink = "editlink" in args
 
         attrib = {}
         xpointer = []
         xpointer_moin = []
 
         def add_moin_xpointer(function, args):
-            args = str(args).replace('^', '^^').replace('(', '^(').replace(')', '^)')
-            xpointer_moin.append(function + '(' + args + ')')
+            args = str(args).replace("^", "^^").replace("(", "^(").replace(")", "^)")
+            xpointer_moin.append(function + "(" + args + ")")
 
-        if pagename.startswith('^'):
-            add_moin_xpointer('pages', pagename)
+        if pagename.startswith("^"):
+            add_moin_xpointer("pages", pagename)
             if sort:
-                add_moin_xpointer('sort', sort)
+                add_moin_xpointer("sort", sort)
             if items:
-                add_moin_xpointer('items', items)
+                add_moin_xpointer("items", items)
             if skipitems:
-                add_moin_xpointer('skipitems', skipitems)
+                add_moin_xpointer("skipitems", skipitems)
         else:
-            link = iri.Iri(scheme='wiki.local', path=pagename)
+            link = iri.Iri(scheme="wiki.local", path=pagename)
             attrib[xinclude.href] = link
 
         if heading is not None:
-            add_moin_xpointer('heading', heading)
+            add_moin_xpointer("heading", heading)
         if level:
-            add_moin_xpointer('level', str(level))
+            add_moin_xpointer("level", str(level))
         if titlesonly:
-            add_moin_xpointer('titlesonly', '')
+            add_moin_xpointer("titlesonly", "")
         if editlink:
-            add_moin_xpointer('editlink', '')
+            add_moin_xpointer("editlink", "")
 
         if xpointer_moin:
-            xpointer.append('page:include({})'.format(' '.join(xpointer_moin)))
+            xpointer.append("page:include({})".format(" ".join(xpointer_moin)))
 
         if xpointer:
             # TODO: Namespace?
-            ns = f'xmlns(page={moin_page}) '
+            ns = f"xmlns(page={moin_page}) "
 
-            attrib[xinclude.xpointer] = ns + ' '.join(xpointer)
+            attrib[xinclude.xpointer] = ns + " ".join(xpointer)
 
         span_wrap = xinclude.include(attrib=attrib)
         if not context_block:
             return span_wrap
-        attrib = {moin_page.class_: 'moin-p'}
+        attrib = {moin_page.class_: "moin-p"}
         return moin_page.div(attrib=attrib, children=[span_wrap])
 
     def _TableOfContents_repl(self, args, text, context_block):
@@ -143,19 +145,16 @@ def _TableOfContents_repl(self, args, text, context_block):
         return moin_page.table_of_content(attrib=attrib)
 
     def macro(self, name, args, text, context_block=False):
-        func = getattr(self, f'_{name}_repl', None)
+        func = getattr(self, f"_{name}_repl", None)
         if func is not None:
             return func(args, text, context_block)
 
         tag = context_block and moin_page.part or moin_page.inline_part
 
-        elem = tag(attrib={
-            moin_page.alt: text,
-            moin_page.content_type: 'x-moin/macro;name=' + name,
-        })
+        elem = tag(attrib={moin_page.alt: text, moin_page.content_type: "x-moin/macro;name=" + name})
 
         if args:
-            elem_arguments = moin_page.arguments(children=(args, ))
+            elem_arguments = moin_page.arguments(children=(args,))
             elem.append(elem_arguments)
 
         return elem
@@ -170,11 +169,11 @@ def macro_text(self, text):
 
     # TODO: Merge with macro support somehow.
     def parser(self, name, args, content):
-        if '/' in name:
+        if "/" in name:
             type = Type(name)
         else:
-            type = Type(type='x-moin', subtype='format', parameters={'name': name})
-        logging.debug("parser type: %r" % (type, ))
+            type = Type(type="x-moin", subtype="format", parameters={"name": name})
+        logging.debug("parser type: %r" % (type,))
 
         elem = moin_page.part(attrib={moin_page.content_type: type})
 
@@ -186,7 +185,7 @@ def parser(self, name, args, content):
                 attrib = {}
                 if key:
                     attrib[moin_page.name] = key
-                elem_arg = moin_page.argument(attrib=attrib, children=(value, ))
+                elem_arg = moin_page.argument(attrib=attrib, children=(value,))
                 elem_arguments.append(elem_arg)
 
         if content:
diff --git a/src/moin/converters/archive_in.py b/src/moin/converters/archive_in.py
index 226768861..d13c59342 100644
--- a/src/moin/converters/archive_in.py
+++ b/src/moin/converters/archive_in.py
@@ -23,6 +23,7 @@
 from moin.constants.keys import NAME, NAMESPACE, NAME_EXACT
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -37,19 +38,19 @@ class ArchiveConverter(TableMixin):
     Base class for archive converters, convert an archive to a DOM table
     with an archive listing.
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls()
 
     def process_name(self, member_name):
         attrib = {
-            xlink.href: Iri(scheme='wiki', authority='', path='/' + self.fullname,
-                            query=f'do=get&member={member_name}'),
+            xlink.href: Iri(scheme="wiki", authority="", path="/" + self.fullname, query=f"do=get&member={member_name}")
         }
-        return moin_page.a(attrib=attrib, children=[member_name, ])
+        return moin_page.a(attrib=attrib, children=[member_name])
 
     def process_datetime(self, dt):
-        return str(dt.isoformat(' '))
+        return str(dt.isoformat(" "))
 
     def process_size(self, size):
         return str(size)
@@ -59,13 +60,13 @@ def __call__(self, rev, contenttype=None, arguments=None):
         self.fullname = fqname.fullname
         try:
             contents = self.list_contents(rev.data)
-            contents = [(self.process_size(size),
-                         self.process_datetime(dt),
-                         self.process_name(name),
-                         ) for size, dt, name in contents]
-            table = self.build_dom_table(contents, head=[_("Size"), _("Timestamp"), _("Name")], cls='zebra')
-            body = moin_page.body(children=(table, ))
-            return moin_page.page(children=(body, ))
+            contents = [
+                (self.process_size(size), self.process_datetime(dt), self.process_name(name))
+                for size, dt, name in contents
+            ]
+            table = self.build_dom_table(contents, head=[_("Size"), _("Timestamp"), _("Name")], cls="zebra")
+            body = moin_page.body(children=(table,))
+            return moin_page.page(children=(body,))
         except ArchiveException as err:
             logging.exception("An exception within archive file handling occurred:")
             # XXX we also use a table for error reporting, could be
@@ -89,18 +90,15 @@ class TarConverter(ArchiveConverter):
     """
     Support listing tar files.
     """
+
     def list_contents(self, fileobj):
         try:
             rows = []
-            tf = tarfile.open(fileobj=fileobj, mode='r')
+            tf = tarfile.open(fileobj=fileobj, mode="r")
             for tinfo in tf.getmembers():
                 if tinfo.isfile():
                     # display only normal files, not directories
-                    rows.append((
-                        tinfo.size,
-                        datetime.utcfromtimestamp(tinfo.mtime),
-                        tinfo.name,
-                    ))
+                    rows.append((tinfo.size, datetime.utcfromtimestamp(tinfo.mtime), tinfo.name))
             return rows
         except tarfile.TarError as err:
             raise ArchiveException(str(err))
@@ -110,18 +108,15 @@ class ZipConverter(ArchiveConverter):
     """
     Support listing zip files.
     """
+
     def list_contents(self, fileobj):
         try:
             rows = []
-            zf = zipfile.ZipFile(fileobj, mode='r')
+            zf = zipfile.ZipFile(fileobj, mode="r")
             for zinfo in zf.filelist:
-                if not (zinfo.file_size == 0 and zinfo.filename.endswith('/')):
+                if not (zinfo.file_size == 0 and zinfo.filename.endswith("/")):
                     # display only normal files, not directories
-                    rows.append((
-                        zinfo.file_size,
-                        datetime(*zinfo.date_time),  # y,m,d,h,m,s
-                        zinfo.filename,
-                    ))
+                    rows.append((zinfo.file_size, datetime(*zinfo.date_time), zinfo.filename))  # y,m,d,h,m,s
             return rows
         except (RuntimeError, zipfile.BadZipfile) as err:
             # RuntimeError is raised by zipfile stdlib module in case of
@@ -130,6 +125,6 @@ def list_contents(self, fileobj):
             raise ArchiveException(str(err))
 
 
-default_registry.register(TarConverter._factory, Type('application/x-tar'), type_moin_document)
-default_registry.register(TarConverter._factory, Type('application/x-gtar'), type_moin_document)
-default_registry.register(ZipConverter._factory, Type('application/zip'), type_moin_document)
+default_registry.register(TarConverter._factory, Type("application/x-tar"), type_moin_document)
+default_registry.register(TarConverter._factory, Type("application/x-gtar"), type_moin_document)
+default_registry.register(ZipConverter._factory, Type("application/zip"), type_moin_document)
diff --git a/src/moin/converters/audio_video_in.py b/src/moin/converters/audio_video_in.py
index 20f5712fd..31aeb0262 100644
--- a/src/moin/converters/audio_video_in.py
+++ b/src/moin/converters/audio_video_in.py
@@ -19,6 +19,7 @@ class Converter:
     """
     Convert audio/video to the corresponding <object> in the DOM Tree
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls(input_type=input)
@@ -30,23 +31,22 @@ def __call__(self, rev, contenttype=None, arguments=None):
         item_name = rev.item.fqname.fullname
         attrib = {
             moin_page.type_: str(self.input_type),
-            xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name,
-                            query=f'do=get&rev={rev.revid}'),
+            xlink.href: Iri(scheme="wiki", authority="", path="/" + item_name, query=f"do=get&rev={rev.revid}"),
         }
         if arguments and html.alt in arguments:
             attrib[html.alt] = arguments[html.alt]
         elif rev.meta.get(SUMMARY):
             attrib[html.alt] = rev.meta[SUMMARY]
-        obj = moin_page.object_(attrib=attrib, children=['Your Browser does not support HTML5 audio/video element.', ])
-        body = moin_page.body(children=(obj, ))
-        return moin_page.page(children=(body, ))
+        obj = moin_page.object_(attrib=attrib, children=["Your Browser does not support HTML5 audio/video element."])
+        body = moin_page.body(children=(obj,))
+        return moin_page.page(children=(body,))
 
 
-default_registry.register(Converter._factory, Type('video/mp4'), type_moin_document)
-default_registry.register(Converter._factory, Type('video/ogg'), type_moin_document)
-default_registry.register(Converter._factory, Type('video/webm'), type_moin_document)
+default_registry.register(Converter._factory, Type("video/mp4"), type_moin_document)
+default_registry.register(Converter._factory, Type("video/ogg"), type_moin_document)
+default_registry.register(Converter._factory, Type("video/webm"), type_moin_document)
 
-default_registry.register(Converter._factory, Type('audio/mpeg'), type_moin_document)
-default_registry.register(Converter._factory, Type('audio/ogg'), type_moin_document)
-default_registry.register(Converter._factory, Type('audio/webm'), type_moin_document)
-default_registry.register(Converter._factory, Type('audio/x-wav'), type_moin_document)
+default_registry.register(Converter._factory, Type("audio/mpeg"), type_moin_document)
+default_registry.register(Converter._factory, Type("audio/ogg"), type_moin_document)
+default_registry.register(Converter._factory, Type("audio/webm"), type_moin_document)
+default_registry.register(Converter._factory, Type("audio/x-wav"), type_moin_document)
diff --git a/src/moin/converters/creole_in.py b/src/moin/converters/creole_in.py
index 828279044..b0c74d01e 100644
--- a/src/moin/converters/creole_in.py
+++ b/src/moin/converters/creole_in.py
@@ -69,11 +69,11 @@ def block_head_repl(self, _iter_content, stack, head, head_head, head_text):
         stack.clear()
 
         attrib = {moin_page.outline_level: str(len(head_head))}
-        element = moin_page.h(attrib=attrib, children=(head_text, ))
+        element = moin_page.h(attrib=attrib, children=(head_text,))
         stack.top_append(element)
 
     # Matches an empty (only whitespaces) line.
-    block_line = r'(?P<line> ^ \s* $ )'
+    block_line = r"(?P<line> ^ \s* $ )"
 
     def block_line_repl(self, _iter_content, stack, line):
         stack.clear()
@@ -95,9 +95,9 @@ def block_list_repl(self, iter_content, stack, list):
 
         for line in iter_content:
             match = self.list_re.match(line)
-            self._apply(match, 'list', iter_content, stack)
+            self._apply(match, "list", iter_content, stack)
 
-            if match.group('end') is not None:
+            if match.group("end") is not None:
                 # Allow the mainloop to take care of the line after a list.
                 iter_content.push(line)
                 break
@@ -163,9 +163,9 @@ def block_nowiki_lines(self, iter_content):
         for line in iter_content:
             match = self.nowiki_end_re.match(line)
             if match:
-                if not match.group('escape'):
+                if not match.group("escape"):
                     return
-                line = match.group('rest')
+                line = match.group("rest")
             yield line
 
     def block_nowiki_repl(self, iter_content, stack, nowiki):
@@ -181,7 +181,7 @@ def block_nowiki_repl(self, iter_content, stack, nowiki):
 
         # Stop directly if we got an end marker in the first line
         match = self.nowiki_end_re.match(firstline)
-        if match and not match.group('escape'):
+        if match and not match.group("escape"):
             stack.push(moin_page.blockcode())
             return
 
@@ -190,31 +190,31 @@ def block_nowiki_repl(self, iter_content, stack, nowiki):
         match = self.nowiki_interpret_re.match(firstline)
 
         if match:
-            name = match.group('nowiki_name')
-            args = match.group('nowiki_args')
+            name = match.group("nowiki_name")
+            args = match.group("nowiki_args")
             if args:
                 args = parse_arguments(args)
 
             # Parse it directly if the type is ourself
-            if not name or name == 'creole':
+            if not name or name == "creole":
                 body = self.parse_block(lines, args)
-                elem = moin_page.page(children=(body, ))
+                elem = moin_page.page(children=(body,))
                 stack.top_append(elem)
 
             else:
                 stack.top_append(self.parser(name, args, lines))
 
         else:
-            elem = moin_page.blockcode(children=(firstline, ))
+            elem = moin_page.blockcode(children=(firstline,))
             stack.top_append(elem)
 
             for line in lines:
-                elem.append('\n')
+                elem.append("\n")
                 elem.append(line)
 
-    block_separator = r'(?P<separator> ^ \s* ---- \s* $ )'
+    block_separator = r"(?P<separator> ^ \s* ---- \s* $ )"
 
-    def block_separator_repl(self, _iter_content, stack, separator, hr_class='moin-hr3'):
+    def block_separator_repl(self, _iter_content, stack, separator, hr_class="moin-hr3"):
         stack.clear()
         stack.top_append(moin_page.separator(attrib={moin_page.class_: hr_class}))
 
@@ -241,7 +241,7 @@ def block_table_repl(self, iter_content, stack, table):
                 iter_content.push(line)
                 break
 
-            self.block_table_row(match.group('table'), stack)
+            self.block_table_row(match.group("table"), stack)
 
         stack.clear()
 
@@ -250,58 +250,58 @@ def block_table_row(self, content, stack):
         stack.push(element)
 
         for match in self.tablerow_re.finditer(content):
-            self._apply(match, 'tablerow', stack)
+            self._apply(match, "tablerow", stack)
 
         stack.pop()
 
-    block_text = r'(?P<text> .+ )'
+    block_text = r"(?P<text> .+ )"
 
     def block_text_repl(self, _iter_content, stack, text):
-        if stack.top_check('table', 'table-body', 'list'):
+        if stack.top_check("table", "table-body", "list"):
             stack.clear()
 
-        if stack.top_check('body'):
+        if stack.top_check("body"):
             element = moin_page.p()
             stack.push(element)
         # If we are in a paragraph already, don't loose the whitespace
         else:
-            stack.top_append('\n')
+            stack.top_append("\n")
         self.parse_inline(text, stack)
 
-    inline_emph = r'(?P<emph> (?<!:)// )'
+    inline_emph = r"(?P<emph> (?<!:)// )"
     # there must be no : in front of the // avoids italic rendering in urls
     # with unknown protocols
 
     def inline_emph_repl(self, stack, emph):
-        if not stack.top_check('emphasis'):
+        if not stack.top_check("emphasis"):
             stack.push(moin_page.emphasis())
         else:
-            stack.pop_name('emphasis')
+            stack.pop_name("emphasis")
 
-    inline_insert = r'(?P<insert> (?<!:)__ )'
+    inline_insert = r"(?P<insert> (?<!:)__ )"
 
     def inline_insert_repl(self, stack, insert):
         # creole docs suggest u, but ins is consistent with moinwiki and html5 ins/u docs
-        if not stack.top_check('ins'):
+        if not stack.top_check("ins"):
             stack.push(moin_page.ins())
         else:
-            stack.pop_name('ins')
+            stack.pop_name("ins")
 
-    inline_strong = r'(?P<strong> \*\* )'
+    inline_strong = r"(?P<strong> \*\* )"
 
     def inline_strong_repl(self, stack, strong):
-        if not stack.top_check('strong'):
+        if not stack.top_check("strong"):
             stack.push(moin_page.strong())
         else:
-            stack.pop_name('strong')
+            stack.pop_name("strong")
 
-    inline_linebreak = r'(?P<linebreak> \\\\ )'
+    inline_linebreak = r"(?P<linebreak> \\\\ )"
 
     def inline_linebreak_repl(self, stack, linebreak):
         element = moin_page.line_break()
         stack.top_append(element)
 
-    inline_escape = r'(?P<escape> ~ (?P<escaped_char>\S) )'
+    inline_escape = r"(?P<escape> ~ (?P<escaped_char>\S) )"
 
     def inline_escape_repl(self, stack, escape, escaped_char):
         stack.top_append(escaped_char)
@@ -328,16 +328,24 @@ def inline_escape_repl(self, stack, escape, escaped_char):
             ([|] \s* (?P<link_text>.+?) \s*)?
             \]\]
         )
-    """ % dict(uri_schemes='|'.join(URI_SCHEMES))
+    """ % dict(
+        uri_schemes="|".join(URI_SCHEMES)
+    )
 
-    def inline_link_repl(self, stack, link, link_url=None, link_item=None, link_text=None,
-                         link_interwiki_site=None, link_interwiki_item=None):
+    def inline_link_repl(
+        self,
+        stack,
+        link,
+        link_url=None,
+        link_item=None,
+        link_text=None,
+        link_interwiki_site=None,
+        link_interwiki_item=None,
+    ):
         """Handle all kinds of links."""
         if link_interwiki_site:
             if is_known_wiki(link_interwiki_site):
-                link = Iri(scheme='wiki',
-                           authority=link_interwiki_site,
-                           path='/' + link_interwiki_item)
+                link = Iri(scheme="wiki", authority=link_interwiki_site, path="/" + link_interwiki_item)
                 element = moin_page.a(attrib={xlink.href: link})
                 stack.push(element)
                 if link_text:
@@ -348,17 +356,17 @@ def inline_link_repl(self, stack, link, link_url=None, link_item=None, link_text
                 return
             else:
                 # assume local language uses ":" inside of words, set link_item and continue
-                link_item = f'{link_interwiki_site}:{link_interwiki_item}'
+                link_item = f"{link_interwiki_site}:{link_interwiki_item}"
         if link_item is not None:
-            att = 'attachment:'  # moin 1.9 needed this for an attached file
+            att = "attachment:"  # moin 1.9 needed this for an attached file
             if link_item.startswith(att):
-                link_item = '/' + link_item[len(att):]  # now we have a subitem
+                link_item = "/" + link_item[len(att) :]  # now we have a subitem
             # we have Anchor macro, so we support anchor links despite lack of docs in Creole spec
-            if '#' in link_item:
-                path, fragment = link_item.rsplit('#', 1)
+            if "#" in link_item:
+                path, fragment = link_item.rsplit("#", 1)
             else:
                 path, fragment = link_item, None
-            target = Iri(scheme='wiki.local', path=path, fragment=fragment)
+            target = Iri(scheme="wiki.local", path=path, fragment=fragment)
             text = link_item
         else:
             target = Iri(link_url)
@@ -399,7 +407,7 @@ def inline_macro_repl(self, stack, macro, macro_name, macro_args=None):
     """
 
     def inline_nowiki_repl(self, stack, nowiki, nowiki_text):
-        stack.top_append(moin_page.code(children=(nowiki_text, )))
+        stack.top_append(moin_page.code(children=(nowiki_text,)))
 
     inline_object = r"""
         (?P<object>
@@ -426,16 +434,17 @@ def inline_object_repl(self, stack, object, object_page=None, object_url=None, o
         if object_text:
             attrib[html.alt] = object_text
         if object_page is not None:
-            att = 'attachment:'  # moin 1.9 needed this for an attached file
+            att = "attachment:"  # moin 1.9 needed this for an attached file
             if object_page.startswith(att):
-                object_page = '/' + object_page[len(att):]  # now we have a subitem
-            target = Iri(scheme='wiki.local', path=object_page)
+                object_page = "/" + object_page[len(att) :]  # now we have a subitem
+            target = Iri(scheme="wiki.local", path=object_page)
             attrib[xinclude.href] = target
             element = xinclude.include(attrib=attrib)
         else:
             attrib[xlink.href] = object_url
-            element = moin_page.object(attrib=attrib,
-                                       children=('Your Browser does not support HTML5 audio/video element.', ))
+            element = moin_page.object(
+                attrib=attrib, children=("Your Browser does not support HTML5 audio/video element.",)
+            )
         stack.top_append(element)
 
     inline_url = r"""
@@ -449,7 +458,9 @@ def inline_object_repl(self, stack, object, object_page=None, object_url=None, o
             )
             ($ | (?=\s | [,.:;!?()] (\s | $)))
         )
-    """ % dict(uri_schemes='|'.join(URI_SCHEMES))
+    """ % dict(
+        uri_schemes="|".join(URI_SCHEMES)
+    )
 
     def inline_url_repl(self, stack, url, url_target, escaped_url=None):
         """Handle raw urls in text."""
@@ -457,7 +468,7 @@ def inline_url_repl(self, stack, url, url_target, escaped_url=None):
         if not escaped_url:
             # this url is NOT escaped
             attrib = {xlink.href: url_target}
-            element = moin_page.a(attrib=attrib, children=(url_target, ))
+            element = moin_page.a(attrib=attrib, children=(url_target,))
             stack.top_append(element)
         else:
             # this url is escaped, we render it as text
@@ -506,18 +517,18 @@ def list_item_repl(self, _iter_content, stack, item, item_head, item_text):
         # type.
         while True:
             cur = stack.top()
-            if cur.tag.name == 'body':
+            if cur.tag.name == "body":
                 break
-            if cur.tag.name == 'list-item-body':
+            if cur.tag.name == "list-item-body":
                 if list_level > cur.list_level:
                     break
-            if cur.tag.name == 'list':
+            if cur.tag.name == "list":
                 if list_level >= cur.list_level and list_type == cur.list_type:
                     break
             stack.pop()
 
-        if cur.tag.name != 'list':
-            generate = list_type == '#' and 'ordered' or 'unordered'
+        if cur.tag.name != "list":
+            generate = list_type == "#" and "ordered" or "unordered"
             attrib = {moin_page.item_label_generate: generate}
             element = moin_page.list(attrib=attrib)
             element.list_level, element.list_type = list_level, list_type
@@ -557,24 +568,15 @@ def tablerow_cell_repl(self, stack, cell, cell_text, cell_head=None):
         """
         attrib = {}
         if cell_head:
-            attrib[moin_page.class_] = 'moin-thead'
+            attrib[moin_page.class_] = "moin-thead"
         element = moin_page.table_cell(attrib=attrib)
         stack.push(element)
         self.parse_inline(cell_text.strip(), stack)
-        stack.pop_name('table-cell')
+        stack.pop_name("table-cell")
 
     # Block elements
-    block = (
-        block_line,
-        block_head,
-        block_separator,
-        block_macro,
-        block_nowiki,
-        block_list,
-        block_table,
-        block_text,
-    )
-    block_re = re.compile('|'.join(block), re.X | re.U)
+    block = (block_line, block_head, block_separator, block_macro, block_nowiki, block_list, block_table, block_text)
+    block_re = re.compile("|".join(block), re.X | re.U)
 
     # Inline elements
     inline = (
@@ -589,31 +591,18 @@ def tablerow_cell_repl(self, stack, cell, cell_text, cell_head=None):
         inline_insert,
         inline_linebreak,
     )
-    inline_re = re.compile('|'.join(inline), re.X | re.U)
+    inline_re = re.compile("|".join(inline), re.X | re.U)
 
-    inlinedesc = (
-        inline_macro,
-        inline_nowiki,
-        inline_emph,
-        inline_strong,
-        inline_object,
-    )
-    inlinedesc_re = re.compile('|'.join(inlinedesc), re.X | re.U)
+    inlinedesc = (inline_macro, inline_nowiki, inline_emph, inline_strong, inline_object)
+    inlinedesc_re = re.compile("|".join(inlinedesc), re.X | re.U)
 
     # Link description
-    link_desc = (
-        inline_object,
-        inline_linebreak,
-    )
-    link_desc_re = re.compile('|'.join(link_desc), re.X | re.U)
+    link_desc = (inline_object, inline_linebreak)
+    link_desc_re = re.compile("|".join(link_desc), re.X | re.U)
 
     # List items
-    list = (
-        list_end,
-        list_item,
-        list_text,
-    )
-    list_re = re.compile('|'.join(list), re.X | re.U)
+    list = (list_end, list_item, list_text)
+    list_re = re.compile("|".join(list), re.X | re.U)
 
     # Nowiki interpreter
     nowiki_interpret_re = re.compile(nowiki_interpret, re.X)
@@ -632,13 +621,13 @@ def _apply(self, match, prefix, *args):
         Call the _repl method for the last matched group with the given prefix.
         """
         data = {k: v for k, v in match.groupdict().items() if v is not None}
-        getattr(self, f'{prefix}_{match.lastgroup}_repl')(*args, **data)
+        getattr(self, f"{prefix}_{match.lastgroup}_repl")(*args, **data)
 
     def parse_block(self, iter_content, arguments):
         attrib = {}
         if arguments:
             for key, value in arguments.keyword.items():
-                if key in ('style', ):
+                if key in ("style",):
                     attrib[moin_page(key)] = value
 
         body = moin_page.body(attrib=attrib)
@@ -648,7 +637,7 @@ def parse_block(self, iter_content, arguments):
         # Please note that the iterator can be modified by other functions
         for line in iter_content:
             match = self.block_re.match(line)
-            self._apply(match, 'block', iter_content, stack)
+            self._apply(match, "block", iter_content, stack)
 
         return body
 
@@ -658,10 +647,10 @@ def parse_inline(self, text, stack, inline_re=inline_re):
         pos = 0
         for match in inline_re.finditer(text):
             # Handle leading text
-            stack.top_append_ifnotempty(text[pos:match.start()])
+            stack.top_append_ifnotempty(text[pos : match.start()])
             pos = match.end()
 
-            self._apply(match, 'inline', stack)
+            self._apply(match, "inline", stack)
 
         # Handle trailing text
         stack.top_append_ifnotempty(text[pos:])
@@ -678,4 +667,4 @@ def macro_text(self, text):
 
 
 default_registry.register(Converter.factory, type_moin_creole, type_moin_document)
-default_registry.register(Converter.factory, Type('x-moin/format;name=creole'), type_moin_document)
+default_registry.register(Converter.factory, Type("x-moin/format;name=creole"), type_moin_document)
diff --git a/src/moin/converters/docbook_in.py b/src/moin/converters/docbook_in.py
index 369209ddb..d86fb3a7c 100644
--- a/src/moin/converters/docbook_in.py
+++ b/src/moin/converters/docbook_in.py
@@ -17,6 +17,7 @@
 import re
 
 from emeraldtree import ElementTree as ET
+
 try:
     from flask import g as flaskg
 except ImportError:
@@ -31,6 +32,7 @@
 from ._util import allowed_uri_scheme, decode_data, normalize_split_text
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -56,9 +58,10 @@ class XMLParser(ET.XMLParser):
     modified _start_list is only needed for the initial construction of the DOM when
     flaskg.add_lineno_attr may be True.
     """
+
     def _start_list(self, tag, attrib_in):
         elem = super()._start_list(tag, attrib_in)
-        if flaskg and getattr(flaskg, 'add_lineno_attr', False):
+        if flaskg and getattr(flaskg, "add_lineno_attr", False):
             elem.attrib[html.data_lineno] = self._parser.CurrentLineNumber
         return elem
 
@@ -67,172 +70,354 @@ class Converter:
     """
     Converter application/docbook+xml -> x.moin.document
     """
+
     # Namespace of our input data
-    docbook_namespace = {
-        docbook.namespace: 'docbook'
-    }
+    docbook_namespace = {docbook.namespace: "docbook"}
 
     # DocBook elements which are completely ignored by our converter
     # We even do not process children of these elements
     ignored_tags = {
         # Info elements
-        'abstract', 'artpagenums', 'annotation',
-        'artpagenums', 'author', 'authorgroup',
-        'authorinitials', 'bibliocoverage', 'biblioid',
-        'bibliomisc', 'bibliomset', 'bibliorelation',
-        'biblioset', 'bibliosource', 'collab', 'confdates',
-        'confgroup', 'confnum', 'confsponsor', 'conftitle',
-        'contractnum', 'contractsponsor', 'copyright',
-        'contrib', 'cover', 'edition', 'editor',
-        'extendedlink', 'issuenum', 'itermset', 'keyword',
-        'keywordset', 'legalnotice', 'org', 'orgname',
-        'orgdiv', 'otheraddr', 'othercredit', 'pagenums',
-        'personblurb', 'printhistory', 'productname',
-        'productnumber', 'pubdate', 'publisher',
-        'publishername', 'releaseinfo', 'revdescription',
-        'revhistory', 'revision', 'revnumber', 'revremark',
-        'seriesvolnums', 'subjectset', 'volumenum',
+        "abstract",
+        "artpagenums",
+        "annotation",
+        "artpagenums",
+        "author",
+        "authorgroup",
+        "authorinitials",
+        "bibliocoverage",
+        "biblioid",
+        "bibliomisc",
+        "bibliomset",
+        "bibliorelation",
+        "biblioset",
+        "bibliosource",
+        "collab",
+        "confdates",
+        "confgroup",
+        "confnum",
+        "confsponsor",
+        "conftitle",
+        "contractnum",
+        "contractsponsor",
+        "copyright",
+        "contrib",
+        "cover",
+        "edition",
+        "editor",
+        "extendedlink",
+        "issuenum",
+        "itermset",
+        "keyword",
+        "keywordset",
+        "legalnotice",
+        "org",
+        "orgname",
+        "orgdiv",
+        "otheraddr",
+        "othercredit",
+        "pagenums",
+        "personblurb",
+        "printhistory",
+        "productname",
+        "productnumber",
+        "pubdate",
+        "publisher",
+        "publishername",
+        "releaseinfo",
+        "revdescription",
+        "revhistory",
+        "revision",
+        "revnumber",
+        "revremark",
+        "seriesvolnums",
+        "subjectset",
+        "volumenum",
         # Other bibliography elements
-        'bibliodiv', 'biblioentry', 'bibliography',
-        'bibliolist', 'bibliomixed', 'biblioref',
-        'bibliorelation', 'citation', 'citerefentry',
-        'citetitle',
+        "bibliodiv",
+        "biblioentry",
+        "bibliography",
+        "bibliolist",
+        "bibliomixed",
+        "biblioref",
+        "bibliorelation",
+        "citation",
+        "citerefentry",
+        "citetitle",
         # Callout elements
-        'callout', 'calloutlist', 'area', 'areaset',
-        'areaspec', 'co', 'imageobjectco',
+        "callout",
+        "calloutlist",
+        "area",
+        "areaset",
+        "areaspec",
+        "co",
+        "imageobjectco",
         # Class information
-        'classname', 'classsynopsis', 'classsynopsisinfo',
-        'constructorsynopsis', 'destructorsynopsis',
-        'fieldsynopsis', 'funcdef', 'funcparams',
-        'funcprototype', 'funcsynopsis',
-        'funcsynopsisinfo', 'function', 'group',
-        'initializer', 'interfacename',
-        'methodname', 'methodparam', 'methodsynopsis',
-        'ooclass', 'ooexception', 'oointerface', 'varargs',
-        'void',
+        "classname",
+        "classsynopsis",
+        "classsynopsisinfo",
+        "constructorsynopsis",
+        "destructorsynopsis",
+        "fieldsynopsis",
+        "funcdef",
+        "funcparams",
+        "funcprototype",
+        "funcsynopsis",
+        "funcsynopsisinfo",
+        "function",
+        "group",
+        "initializer",
+        "interfacename",
+        "methodname",
+        "methodparam",
+        "methodsynopsis",
+        "ooclass",
+        "ooexception",
+        "oointerface",
+        "varargs",
+        "void",
         # GUI elements
-        'guibutton', 'guiicon', 'guilabel',
-        'guimenu', 'guimenuitem', 'guisubmenu',
+        "guibutton",
+        "guiicon",
+        "guilabel",
+        "guimenu",
+        "guimenuitem",
+        "guisubmenu",
         # EBNF Elements
-        'constraint', 'constraintdef', 'lhs', 'rhs',
-        'nonterminal',
+        "constraint",
+        "constraintdef",
+        "lhs",
+        "rhs",
+        "nonterminal",
         # msg elements
-        'msg', 'msgaud', 'msgentry', 'msgexplan',
-        'msginfo', 'msglevel', 'msgmain', 'msgorig',
-        'msgrel', 'msgset', 'msgsub', 'msgtext',
+        "msg",
+        "msgaud",
+        "msgentry",
+        "msgexplan",
+        "msginfo",
+        "msglevel",
+        "msgmain",
+        "msgorig",
+        "msgrel",
+        "msgset",
+        "msgsub",
+        "msgtext",
         # REF entry
-        'refclass', 'refdescriptor', 'refentry',
-        'refentrytitle', 'reference', 'refmeta',
-        'refmiscinfo', 'refname', 'refnamediv',
-        'refpurpose', 'refsect1', 'refsect2', 'refsect3',
-        'refsection', 'refsynopsisdiv',
+        "refclass",
+        "refdescriptor",
+        "refentry",
+        "refentrytitle",
+        "reference",
+        "refmeta",
+        "refmiscinfo",
+        "refname",
+        "refnamediv",
+        "refpurpose",
+        "refsect1",
+        "refsect2",
+        "refsect3",
+        "refsection",
+        "refsynopsisdiv",
         # TOC
-        'toc', 'tocdiv', 'tocentry',
+        "toc",
+        "tocdiv",
+        "tocentry",
         # Index elements
-        'index', 'indexdiv', 'indexentry', 'indexterm',
-        'primary', 'primaryie', 'secondary',
-        'secondaryie', 'see', 'seealso',
-        'tertiary', 'tertiaryie',
+        "index",
+        "indexdiv",
+        "indexentry",
+        "indexterm",
+        "primary",
+        "primaryie",
+        "secondary",
+        "secondaryie",
+        "see",
+        "seealso",
+        "tertiary",
+        "tertiaryie",
         # Other elements
-        'info', 'bridgehead', 'arc', 'titleabbrev',
-        'spanspec', 'xref',
+        "info",
+        "bridgehead",
+        "arc",
+        "titleabbrev",
+        "spanspec",
+        "xref",
     }
 
     # DocBook inline elements which does not have equivalence in the DOM
     # tree, but we keep the information using <span element='tag.name'>
-    inline_tags = {'abbrev', 'address', 'accel', 'acronym', 'alt',
-                   'affiliation', 'city', 'command', 'constant',
-                   'country', 'database', 'date', 'errorcode',
-                   'errorname', 'errortext', 'errortype',
-                   'exceptionname', 'fax', 'filename', 'firstname',
-                   'firstterm', 'foreignphrase', 'hardware', 'holder',
-                   'honorific', 'jobtitle', 'keycap', 'keycode',
-                   'keycombo', 'keysym', 'lineannotation',
-                   'manvolnum', 'mousebutton', 'option', 'optional',
-                   'package', 'person', 'personname', 'phone', 'pob',
-                   'postcode', 'prompt', 'remark', 'replaceable',
-                   'returnvalue', 'shortaffil', 'shortcut', 'state',
-                   'street', 'surname', 'symbol', 'systemitem',
-                   'termdef', 'type', 'uri', 'userinput',
-                   'wordasword', 'varname', 'anchor',
-                   }
+    inline_tags = {
+        "abbrev",
+        "address",
+        "accel",
+        "acronym",
+        "alt",
+        "affiliation",
+        "city",
+        "command",
+        "constant",
+        "country",
+        "database",
+        "date",
+        "errorcode",
+        "errorname",
+        "errortext",
+        "errortype",
+        "exceptionname",
+        "fax",
+        "filename",
+        "firstname",
+        "firstterm",
+        "foreignphrase",
+        "hardware",
+        "holder",
+        "honorific",
+        "jobtitle",
+        "keycap",
+        "keycode",
+        "keycombo",
+        "keysym",
+        "lineannotation",
+        "manvolnum",
+        "mousebutton",
+        "option",
+        "optional",
+        "package",
+        "person",
+        "personname",
+        "phone",
+        "pob",
+        "postcode",
+        "prompt",
+        "remark",
+        "replaceable",
+        "returnvalue",
+        "shortaffil",
+        "shortcut",
+        "state",
+        "street",
+        "surname",
+        "symbol",
+        "systemitem",
+        "termdef",
+        "type",
+        "uri",
+        "userinput",
+        "wordasword",
+        "varname",
+        "anchor",
+    }
 
     # DocBook block element which does not have equivalence in the DOM
     # tree, but we keep the information using <div html:class='tag.name'>
-    block_tags = {'acknowledgements', 'appendix', 'article', 'book',
-                  'caption', 'chapter', 'cmdsynopsis', 'colophon',
-                  'dedication', 'epigraph', 'example', 'figure',
-                  'equation', 'part', 'partintro',
-                  'screenshoot', 'set', 'setindex', 'sidebar',
-                  'simplesect', 'subtitle', 'synopsis',
-                  'synopfragment', 'task', 'taskprerequisites',
-                  'taskrelated', 'tasksummary', 'title',
-                  }
+    block_tags = {
+        "acknowledgements",
+        "appendix",
+        "article",
+        "book",
+        "caption",
+        "chapter",
+        "cmdsynopsis",
+        "colophon",
+        "dedication",
+        "epigraph",
+        "example",
+        "figure",
+        "equation",
+        "part",
+        "partintro",
+        "screenshoot",
+        "set",
+        "setindex",
+        "sidebar",
+        "simplesect",
+        "subtitle",
+        "synopsis",
+        "synopfragment",
+        "task",
+        "taskprerequisites",
+        "taskrelated",
+        "tasksummary",
+        "title",
+    }
 
     # DocBook has admonition as individual element, but the DOM Tree
     # has only one element for it, so we will convert all the DocBook
     # admonitions in this list, into the admonition element of the DOM Tree.
-    admonition_tags = {'attention', 'caution', 'danger', 'error', 'hint', 'important', 'note', 'tip', 'warning'}
+    admonition_tags = {"attention", "caution", "danger", "error", "hint", "important", "note", "tip", "warning"}
 
     # DocBook can handle three kinds of media: audio, image, video.
     # TODO: a media format attribute is optional, e.g.: <imagedata format="jpeg" fileref="jpeg.jpg"/>
     #     XXX: quality of supported formats list is suspect, see below
     media_tags = {
         # <tagname>: (<formats list>, <child tagname>, <mime type>)
-        'audioobject': (
-            ['x-wav', 'mpeg', 'ogg', 'webm'],  # XXX: none of these are in http://docbook.org/tdg/en/html/audiodata.html
-            'audiodata',
-            'audio/',
+        "audioobject": (
+            ["x-wav", "mpeg", "ogg", "webm"],  # XXX: none of these are in http://docbook.org/tdg/en/html/audiodata.html
+            "audiodata",
+            "audio/",
         ),
-        'imageobject': (
-            ['gif', 'png', 'jpeg', 'jpg', 'svg'],  # selected from http://docbook.org/tdg/en/html/imagedata.html
-            'imagedata',
-            'image/',
+        "imageobject": (
+            ["gif", "png", "jpeg", "jpg", "svg"],  # selected from http://docbook.org/tdg/en/html/imagedata.html
+            "imagedata",
+            "image/",
+        ),
+        "videoobject": (
+            ["ogg", "webm", "mp4"],  # XXX: none of these are in http://docbook.org/tdg/en/html/videodata.html
+            "videodata",
+            "video/",
         ),
-        'videoobject': (
-            ['ogg', 'webm', 'mp4'],  # XXX: none of these are in http://docbook.org/tdg/en/html/videodata.html
-            'videodata',
-            'video/',
-        )
     }
 
     # DocBook tags which can be convert directly to a DOM Tree element
-    simple_tags = {'code': moin_page.code,
-                   'computeroutput': moin_page.code,
-                   'glossdef': moin_page('list-item-body'),
-                   'glossentry': moin_page('list-item'),
-                   'glosslist': moin_page('list'),
-                   'glossterm': moin_page('list-item-label'),
-                   'literal': moin_page.code,
-                   'markup': moin_page.code,
-                   'para': moin_page.p,
-                   'phrase': moin_page.span,
-                   'programlisting': moin_page.blockcode,
-                   'quote': moin_page.quote,
-                   'row': moin_page('table-row'),
-                   'screen': moin_page.blockcode,
-                   'simpara': moin_page.p,
-                   'term': moin_page('list-item-label'),
-                   'listitem': moin_page('list-item-body'),
-                   'thead': moin_page('table-header'),
-                   'tfoot': moin_page('table-footer'),
-                   'tbody': moin_page('table-body'),
-                   'tr': moin_page('table-row'),
-                   'variablelist': moin_page('list'),
-                   'varlistentry': moin_page('list-item'),
-                   }
+    simple_tags = {
+        "code": moin_page.code,
+        "computeroutput": moin_page.code,
+        "glossdef": moin_page("list-item-body"),
+        "glossentry": moin_page("list-item"),
+        "glosslist": moin_page("list"),
+        "glossterm": moin_page("list-item-label"),
+        "literal": moin_page.code,
+        "markup": moin_page.code,
+        "para": moin_page.p,
+        "phrase": moin_page.span,
+        "programlisting": moin_page.blockcode,
+        "quote": moin_page.quote,
+        "row": moin_page("table-row"),
+        "screen": moin_page.blockcode,
+        "simpara": moin_page.p,
+        "term": moin_page("list-item-label"),
+        "listitem": moin_page("list-item-body"),
+        "thead": moin_page("table-header"),
+        "tfoot": moin_page("table-footer"),
+        "tbody": moin_page("table-body"),
+        "tr": moin_page("table-row"),
+        "variablelist": moin_page("list"),
+        "varlistentry": moin_page("list-item"),
+    }
 
     # Other block elements which can be root element.
-    root_tags = {'blockquote', 'formalpara', 'informalequation',
-                 'informalexample', 'informalfigure',
-                 'informalfigure', 'orderedlist', 'sect1', 'sect2',
-                 'sect3', 'sect4', 'sect5', 'section',
-                 'segmentedlist', 'simplelist', 'procedure',
-                 'qandaset',
-                 }
+    root_tags = {
+        "blockquote",
+        "formalpara",
+        "informalequation",
+        "informalexample",
+        "informalfigure",
+        "informalfigure",
+        "orderedlist",
+        "sect1",
+        "sect2",
+        "sect3",
+        "sect4",
+        "sect5",
+        "section",
+        "segmentedlist",
+        "simplelist",
+        "procedure",
+        "qandaset",
+    }
 
     # Regular expression to find section tag.
-    sect_re = re.compile('sect[1-5]')
+    sect_re = re.compile("sect[1-5]")
 
     @classmethod
     def _factory(cls, input, output, **kw):
@@ -241,7 +426,7 @@ def _factory(cls, input, output, **kw):
     def __call__(self, data, contenttype=None, arguments=None):
         text = decode_data(data, contenttype)
         content = normalize_split_text(text)
-        docbook_str = '\n'.join(content)
+        docbook_str = "\n".join(content)
 
         # Initalize our attributes
         self.section_depth = 0
@@ -256,7 +441,7 @@ def __call__(self, data, contenttype=None, arguments=None):
         # We will create an element tree from the DocBook content
         try:
             # XXX: The XML parser need bytestring.
-            tree = XML(docbook_str.encode('utf-8'))  # using local XML override, not ET.XML
+            tree = XML(docbook_str.encode("utf-8"))  # using local XML override, not ET.XML
         except ET.ParseError as detail:
             return self.error(str(detail))
 
@@ -274,10 +459,10 @@ def error(self, message):
         """
         Return a DOM Tree containing an error message.
         """
-        error = self.new(moin_page('error'), attrib={}, children=[message])
-        part = self.new(moin_page('part'), attrib={}, children=[error])
-        body = self.new(moin_page('body'), attrib={}, children=[part])
-        return self.new(moin_page('page'), attrib={}, children=[body])
+        error = self.new(moin_page("error"), attrib={}, children=[message])
+        part = self.new(moin_page("part"), attrib={}, children=[error])
+        body = self.new(moin_page("body"), attrib={}, children=[part])
+        return self.new(moin_page("page"), attrib={}, children=[body])
 
     def do_children(self, element, depth):
         """
@@ -292,7 +477,7 @@ def do_children(self, element, depth):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 new_children.extend(r)
             else:
                 # avoid problems in html_out by ignoring unicode '\n', '\n  ', '\n    '
@@ -326,7 +511,7 @@ def get_standard_attributes(self, element):
         """
         result = {}
         for key, value in element.attrib.items():
-            if key.uri == xml and key.name in ['id', 'base', 'lang'] or key.name == 'data-lineno':
+            if key.uri == xml and key.name in ["id", "base", "lang"] or key.name == "data-lineno":
                 result[key] = value
         if result:
             # We clear standard_attribute, if ancestror attribute
@@ -345,7 +530,7 @@ def visit(self, element, depth):
         uri = element.tag.uri
         name = self.docbook_namespace.get(uri, None)
         if name is not None:
-            method_name = 'visit_' + name
+            method_name = "visit_" + name
             method = getattr(self, method_name, None)
             if method is not None:
                 return method(element, depth)
@@ -393,7 +578,7 @@ def visit_docbook(self, element, depth):
             return self.visit_docbook_admonition(element, depth)
 
         # We will find the correct method to handle our tag
-        method_name = 'visit_docbook_' + element.tag.name
+        method_name = "visit_docbook_" + element.tag.name
         method = getattr(self, method_name, None)
         if method:
             return method(element, depth)
@@ -412,7 +597,7 @@ def visit_data_object(self, element, depth):
         object_data = []
         text_object = []
         caption = []
-        object_element = ''
+        object_element = ""
         for child in element:
             if isinstance(child, ET.Element):
                 if child.tag.name in self.media_tags:  # audioobject, imageobject, videoobject
@@ -422,9 +607,9 @@ def visit_data_object(self, element, depth):
                         if isinstance(grand_child, ET.Element) and grand_child.tag.name == data_tag:
                             # capture audiodata, imagedata, or videodata tags
                             object_data.append(grand_child)
-                if child.tag.name == 'caption':
+                if child.tag.name == "caption":
                     caption = self.do_children(child, depth + 1)[0]
-                if child.tag.name == 'textobject':
+                if child.tag.name == "textobject":
                     text_object = child
                 # we ignore objectinfo tags
         return self.visit_data_element(object_element, depth, object_data, text_object, caption)
@@ -445,7 +630,7 @@ def visit_data_element(self, element, depth, object_data, text_object, caption):
                 return self.new(moin_page.p, attrib={}, children=children)
         # We try to determine the best object to show
         for obj in object_data:
-            format = obj.get('format')  # format is optional: <imagedata format="jpeg" fileref="jpeg.jpg"/>
+            format = obj.get("format")  # format is optional: <imagedata format="jpeg" fileref="jpeg.jpg"/>
             if format:
                 format = format.lower()
                 if format in preferred_format:
@@ -463,30 +648,30 @@ def visit_data_element(self, element, depth, object_data, text_object, caption):
             children = self.do_children(text_object, depth + 1)
             return self.new(moin_page.p, attrib={}, children=children)
 
-        href = object_to_show.get('fileref')
+        href = object_to_show.get("fileref")
         if not href:
             # We could probably try to use entityref,
             # but at this time we won't support it.
             return
         attrib[html.alt] = href
-        if '://' in href:
+        if "://" in href:
             attrib[xlink.href] = Iri(href)
         else:
-            attrib[xinclude.href] = Iri(scheme='wiki.local', path=href)
-        format = object_to_show.get('format')
+            attrib[xinclude.href] = Iri(scheme="wiki.local", path=href)
+        format = object_to_show.get("format")
         if format:
             format = format.lower()
-            attrib[moin_page('type')] = ''.join([mimetype, format])
+            attrib[moin_page("type")] = "".join([mimetype, format])
         else:
-            attrib[moin_page('type')] = mimetype
-        align = object_to_show.get('align')
-        if align and align in {'left', 'center', 'right', 'top', 'middle', 'bottom'}:
+            attrib[moin_page("type")] = mimetype
+        align = object_to_show.get("align")
+        if align and align in {"left", "center", "right", "top", "middle", "bottom"}:
             attrib[html.class_] = align
 
         # return object tag, html_out.py will convert to img, audio, or video based on type attr
         ret = ET.Element(xinclude.include, attrib=attrib)
         if caption:
-            caption = self.new(moin_page.span, attrib={moin_page.class_: 'db-caption'}, children=[caption])
+            caption = self.new(moin_page.span, attrib={moin_page.class_: "db-caption"}, children=[caption])
             return self.new(moin_page.span, attrib={}, children=[ret, caption])
         else:
             return ret
@@ -496,10 +681,9 @@ def visit_docbook_admonition(self, element, depth):
         <tag.name> --> <admonition type='tag.name'>
         """
         attrib = {}
-        key = moin_page('type')
+        key = moin_page("type")
         attrib[key] = element.tag.name
-        return self.new_copy(moin_page.admonition, element,
-                             depth, attrib=attrib)
+        return self.new_copy(moin_page.admonition, element, depth, attrib=attrib)
 
     def visit_docbook_block(self, element, depth):
         """
@@ -510,9 +694,8 @@ def visit_docbook_block(self, element, depth):
         """
         attrib = {}
         key = html.class_
-        attrib[key] = ''.join(['db-', element.tag.name])
-        return self.new_copy(moin_page.div, element,
-                             depth, attrib=attrib)
+        attrib[key] = "".join(["db-", element.tag.name])
+        return self.new_copy(moin_page.div, element, depth, attrib=attrib)
 
     def visit_docbook_blockquote(self, element, depth):
         """
@@ -537,7 +720,7 @@ def visit_docbook_blockquote(self, element, depth):
             else:
                 children.append(child)
         attrib = {}
-        attrib[moin_page('source')] = source[0]
+        attrib[moin_page("source")] = source[0]
         return self.new(moin_page.blockquote, attrib=attrib, children=children)
 
     def visit_docbook_emphasis(self, element, depth):
@@ -550,30 +733,25 @@ def visit_docbook_emphasis(self, element, depth):
         However, it is still semantic, so we call it emphasis and strong.
         """
         for key, value in element.attrib.items():
-            if key.name == 'role' and value == 'bold':
-                return self.new_copy(moin_page.strong, element,
-                                     depth, attrib={})
-        return self.new_copy(moin_page.emphasis, element,
-                             depth, attrib={})
+            if key.name == "role" and value == "bold":
+                return self.new_copy(moin_page.strong, element, depth, attrib={})
+        return self.new_copy(moin_page.emphasis, element, depth, attrib={})
 
     def visit_docbook_entrytbl(self, element, depth):
         """
         Return a table within a table-cell.
         """
-        table_element = self.new_copy(moin_page.table, element,
-                                      depth, attrib={})
-        return self.new(moin_page('table-cell'),
-                        attrib={}, children=[table_element])
+        table_element = self.new_copy(moin_page.table, element, depth, attrib={})
+        return self.new(moin_page("table-cell"), attrib={}, children=[table_element])
 
     def visit_docbook_footnote(self, element, depth):
         """
         <footnote> --> <note note-class="footnote"><note-body>
         """
         attrib = {}
-        key = moin_page('note-class')
+        key = moin_page("note-class")
         attrib[key] = "footnote"
-        children = self.new(moin_page('note-body'), attrib={},
-                            children=self.do_children(element, depth))
+        children = self.new(moin_page("note-body"), attrib={}, children=self.do_children(element, depth))
         if len(children) > 1:
             # must delete lineno because footnote will be placed near end of page and out of sequence
             del children._children[1].attrib[html.data_lineno]
@@ -589,9 +767,9 @@ def visit_docbook_formalpara(self, element, depth):
         """
         for child in element:
             if isinstance(child, ET.Element):
-                if child.tag.name == 'title':
+                if child.tag.name == "title":
                     title_element = child
-                if child.tag.name == 'para':
+                if child.tag.name == "para":
                     para_element = child
 
         if not title_element:
@@ -603,7 +781,7 @@ def visit_docbook_formalpara(self, element, depth):
 
         children = self.do_children(para_element, depth + 1)[0]
         attrib = {}
-        attrib[html('title')] = title_element[0]
+        attrib[html("title")] = title_element[0]
         return self.new(moin_page.p, attrib=attrib, children=children)
 
     def visit_docbook_informalequation(self, element, depth):
@@ -611,27 +789,24 @@ def visit_docbook_informalequation(self, element, depth):
         <informalequation> --> <div html:class="equation">
         """
         attrib = {}
-        attrib[html.class_] = 'db-equation'
-        return self.new_copy(moin_page('div'), element,
-                             depth, attrib=attrib)
+        attrib[html.class_] = "db-equation"
+        return self.new_copy(moin_page("div"), element, depth, attrib=attrib)
 
     def visit_docbook_informalexample(self, element, depth):
         """
         <informalexample> --> <div html:class="example">
         """
         attrib = {}
-        attrib[html.class_] = 'db-example'
-        return self.new_copy(moin_page('div'), element,
-                             depth, attrib=attrib)
+        attrib[html.class_] = "db-example"
+        return self.new_copy(moin_page("div"), element, depth, attrib=attrib)
 
     def visit_docbook_informalfigure(self, element, depth):
         """
         <informalfigure> --> <div html:class="figure">
         """
         attrib = {}
-        attrib[html.class_] = 'db-figure'
-        return self.new_copy(moin_page('div'), element,
-                             depth, attrib=attrib)
+        attrib[html.class_] = "db-figure"
+        return self.new_copy(moin_page("div"), element, depth, attrib=attrib)
 
     def visit_docbook_inline(self, element, depth):
         """
@@ -640,34 +815,30 @@ def visit_docbook_inline(self, element, depth):
         """
         key = html.class_
         attrib = {}
-        attrib[key] = ''.join(['db-', element.tag.name])
-        return self.new_copy(moin_page.span, element,
-                             depth, attrib=attrib)
+        attrib[key] = "".join(["db-", element.tag.name])
+        return self.new_copy(moin_page.span, element, depth, attrib=attrib)
 
     def visit_docbook_inlinequation(self, element, depth):
         """
         <inlinequation> --> <span element="equation">
         """
         attrib = {}
-        attrib[moin_page('element')] = 'equation'
-        return self.new_copy(moin_page.span, element,
-                             depth, attrib=attrib)
+        attrib[moin_page("element")] = "equation"
+        return self.new_copy(moin_page.span, element, depth, attrib=attrib)
 
     def visit_docbook_inlinemediaobject(self, element, depth):
         data_element = self.visit_data_object(element, depth)
-        attrib = {html.class_: 'db-inlinemediaobject'}
-        return self.new(moin_page.span, attrib=attrib,
-                        children=[data_element])
+        attrib = {html.class_: "db-inlinemediaobject"}
+        return self.new(moin_page.span, attrib=attrib, children=[data_element])
 
     def visit_docbook_itemizedlist(self, element, depth):
         """
         <itemizedlist> --> <list item-label-generate="unordered">
         """
         attrib = {}
-        key = moin_page('item-label-generate')
-        attrib[key] = 'unordered'
-        return self.visit_simple_list(moin_page.list, attrib,
-                                      element, depth)
+        key = moin_page("item-label-generate")
+        attrib[key] = "unordered"
+        return self.visit_simple_list(moin_page.list, attrib, element, depth)
 
     def visit_docbook_link(self, element, depth):
         """
@@ -687,12 +858,12 @@ def visit_docbook_link(self, element, depth):
         if element.attrib.get(xlink.title_):
             attrib[html.title_] = element.attrib.get(xlink.title_)
         href = element.attrib.get(xlink.href)
-        linkend = element.get('linkend')
+        linkend = element.get("linkend")
         if linkend:
-            href = ''.join(['#', linkend])
+            href = "".join(["#", linkend])
         iri = Iri(href)
         if iri.scheme is None:
-            iri.scheme = 'wiki.local'
+            iri.scheme = "wiki.local"
         attrib[xlink.href] = iri
         return self.new_copy(moin_page.a, element, depth, attrib)
 
@@ -700,28 +871,25 @@ def visit_docbook_literallayout(self, element, depth):
         """
         <literallayout> --> <blockcode html:class="db-literallayout">
         """
-        attrib = {html.class_: 'db-literallayout'}
-        return self.new_copy(moin_page.blockcode, element,
-                             depth, attrib=attrib)
+        attrib = {html.class_: "db-literallayout"}
+        return self.new_copy(moin_page.blockcode, element, depth, attrib=attrib)
 
     def visit_docbook_mediaobject(self, element, depth):
         data_element = self.visit_data_object(element, depth)
-        attrib = {html.class_: 'db-mediaobject'}
-        return self.new(moin_page.div, attrib=attrib,
-                        children=[data_element])
+        attrib = {html.class_: "db-mediaobject"}
+        return self.new(moin_page.div, attrib=attrib, children=[data_element])
 
     def visit_docbook_olink(self, element, depth):
         """
         <olink targetdoc='URI' targetptr='ptr'>
           --> <a xlink:href='URI#ptr'>
         """
-        targetdoc = element.get('targetdoc')
-        targetptr = element.get('targetptr')
+        targetdoc = element.get("targetdoc")
+        targetptr = element.get("targetptr")
         if targetdoc and targetptr and allowed_uri_scheme(targetdoc):
             attrib = {}
-            attrib[xlink.href] = ''.join([targetdoc, '#', targetptr])
-            return self.new_copy(moin_page.a, element,
-                                 depth, attrib=attrib)
+            attrib[xlink.href] = "".join([targetdoc, "#", targetptr])
+            return self.new_copy(moin_page.a, element, depth, attrib=attrib)
 
     def visit_docbook_orderedlist(self, element, depth):
         """
@@ -729,24 +897,25 @@ def visit_docbook_orderedlist(self, element, depth):
         See attribute_conversion for more details about the attributes.
         """
         attrib = {}
-        key = moin_page('item-label-generate')
-        attrib[key] = 'ordered'
-        attribute_conversion = {"upperalpha": "upper-alpha",
-                                "loweralpha": "lower-alpha",
-                                "upperroman": "upper-roman",
-                                "lowerroman": "lower-roman"}
-        numeration = element.get('numeration')
+        key = moin_page("item-label-generate")
+        attrib[key] = "ordered"
+        attribute_conversion = {
+            "upperalpha": "upper-alpha",
+            "loweralpha": "lower-alpha",
+            "upperroman": "upper-roman",
+            "lowerroman": "lower-roman",
+        }
+        numeration = element.get("numeration")
         if numeration in attribute_conversion:
-            key = moin_page('list-style-type')
+            key = moin_page("list-style-type")
             attrib[key] = attribute_conversion[numeration]
-        return self.visit_simple_list(moin_page.list, attrib,
-                                      element, depth)
+        return self.visit_simple_list(moin_page.list, attrib, element, depth)
 
     def visit_docbook_sbr(self, element, depth):
         """
         <sbr /> --> <line-break />
         """
-        return self.new(moin_page('line-break'), attrib={}, children={})
+        return self.new(moin_page("line-break"), attrib={}, children={})
 
     def visit_docbook_sect(self, element, depth):
         """
@@ -764,17 +933,17 @@ def visit_docbook_sect(self, element, depth):
         TODO: Add div element, with specific id
         """
         self.is_section = True
-        title = ''
+        title = ""
         for child in element:
             if isinstance(child, ET.Element):
                 uri = child.tag.uri
                 name = self.docbook_namespace.get(uri, None)
-                if name == 'docbook' and child.tag.name == 'title':
+                if name == "docbook" and child.tag.name == "title":
                     title = child
                     # Remove the title element to avoid double conversion
                     element.remove(child)
         heading_level = element.tag.name[4]
-        key = moin_page('outline-level')
+        key = moin_page("outline-level")
         attrib = {}
         attrib[key] = heading_level
         return self.new(moin_page.h, attrib=attrib, children=title)
@@ -799,17 +968,17 @@ def visit_docbook_section(self, element, depth):
             self.heading_level = self.heading_level - (self.section_depth - depth)
             self.section_depth = depth
 
-        title = ''
+        title = ""
         result = []
         for child in element:
             if isinstance(child, ET.Element):
                 uri = child.tag.uri
                 name = self.docbook_namespace.get(uri, None)
-                if name == 'docbook' and child.tag.name == 'title':
+                if name == "docbook" and child.tag.name == "title":
                     title = child
                     # Remove the title element to avoid double conversion
                     element.remove(child)
-        key = moin_page('outline-level')
+        key = moin_page("outline-level")
         attrib = {}
         attrib[key] = self.heading_level
         result.append(self.new(moin_page.h, attrib=attrib, children=title))
@@ -829,14 +998,13 @@ def visit_docbook_seglistitem(self, element, labels, depth):
         counter = 0
         for child in element:
             if isinstance(child, ET.Element):
-                if child.tag.name == 'seg':
-                    label_tag = ET.Element(moin_page('list-item-label'),
-                                           attrib={}, children=labels[counter % len(labels)])
-                    body_tag = ET.Element(moin_page('list-item-body'),
-                                          attrib={}, children=self.visit(child, depth))
-                    item_tag = ET.Element(moin_page('list-item'),
-                                          attrib={}, children=[label_tag, body_tag])
-                    item_tag = (item_tag, )
+                if child.tag.name == "seg":
+                    label_tag = ET.Element(
+                        moin_page("list-item-label"), attrib={}, children=labels[counter % len(labels)]
+                    )
+                    body_tag = ET.Element(moin_page("list-item-body"), attrib={}, children=self.visit(child, depth))
+                    item_tag = ET.Element(moin_page("list-item"), attrib={}, children=[label_tag, body_tag])
+                    item_tag = (item_tag,)
                     new.extend(item_tag)
                     counter += 1
                 else:
@@ -844,7 +1012,7 @@ def visit_docbook_seglistitem(self, element, labels, depth):
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     new.extend(r)
             else:
                 new.append(child)
@@ -865,22 +1033,22 @@ def visit_docbook_segmentedlist(self, element, depth):
         for child in element:
             if isinstance(child, ET.Element):
                 r = None
-                if child.tag.name == 'segtitle':
+                if child.tag.name == "segtitle":
                     r = self.visit(child, depth)
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     labels.extend(r)
                 else:
-                    if child.tag.name == 'seglistitem':
+                    if child.tag.name == "seglistitem":
                         r = self.visit_docbook_seglistitem(child, labels, depth)
                     else:
                         r = self.visit(child, depth)
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     new.extend(r)
             else:
                 new.append(child)
@@ -892,8 +1060,8 @@ def visit_docbook_simplelist(self, element, depth):
         """
         # TODO: Add support of the type attribute
         attrib = {}
-        key = moin_page('item-label-generate')
-        attrib[key] = 'unordered'
+        key = moin_page("item-label-generate")
+        attrib[key] = "unordered"
         return self.visit_simple_list(moin_page.list, attrib, element, depth)
 
     def visit_docbook_subscript(self, element, depth):
@@ -901,10 +1069,9 @@ def visit_docbook_subscript(self, element, depth):
         <subscript> --> <span baseline-shift="sub">
         """
         attrib = {}
-        key = moin_page('baseline-shift')
-        attrib[key] = 'sub'
-        return self.new_copy(moin_page.span, element,
-                             depth, attrib=attrib)
+        key = moin_page("baseline-shift")
+        attrib[key] = "sub"
+        return self.new_copy(moin_page.span, element, depth, attrib=attrib)
 
     def visit_docbook_substeps(self, element, depth):
         """
@@ -917,10 +1084,9 @@ def visit_docbook_superscript(self, element, depth):
         <superscript> --> <span baseline-shift="super">
         """
         attrib = {}
-        key = moin_page('baseline-shift')
-        attrib[key] = 'super'
-        return self.new_copy(moin_page.span, element,
-                             depth, attrib=attrib)
+        key = moin_page("baseline-shift")
+        attrib[key] = "super"
+        return self.new_copy(moin_page.span, element, depth, attrib=attrib)
 
     def visit_docbook_procedure(self, element, depth):
         """
@@ -928,19 +1094,18 @@ def visit_docbook_procedure(self, element, depth):
         """
         # TODO: See to add Procedure text (if needed)
         attrib = {}
-        key = moin_page('item-label-generate')
-        attrib[key] = 'ordered'
-        return self.visit_simple_list(moin_page.list, attrib,
-                                      element, depth)
+        key = moin_page("item-label-generate")
+        attrib[key] = "ordered"
+        return self.visit_simple_list(moin_page.list, attrib, element, depth)
 
     def visit_docbook_qandaset(self, element, depth):
         """
         See visit_qandaset_* method.
         """
-        default_label = element.get('defaultlabel')
-        if default_label == 'number':
+        default_label = element.get("defaultlabel")
+        if default_label == "number":
             return self.visit_qandaset_number(element, depth)
-        elif default_label == 'qanda':
+        elif default_label == "qanda":
             return self.visit_qandaset_qanda(element, depth)
         else:
             return self.do_children(element, depth)
@@ -957,7 +1122,7 @@ def visit_docbook_table(self, element, depth):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 list_table_elements.extend(r)
         return ET.Element(moin_page.table, attrib={}, children=list_table_elements)
 
@@ -967,17 +1132,17 @@ def visit_docbook_tag(self, element, depth):
           --> <span class="db-tag-class.name">{ns.address}TAG</tag>
         """
         # We get the attributes
-        class_attribute = element.get('class')
-        namespace_attribute = element.get('namespace')
+        class_attribute = element.get("class")
+        namespace_attribute = element.get("namespace")
         # We create the attribute for our final element
         attrib = {}
         children = []
         if class_attribute:
-            attrib[html.class_] = ''.join(['db-tag-', class_attribute])
+            attrib[html.class_] = "".join(["db-tag-", class_attribute])
         else:
-            attrib[html.class_] = 'db-tag'
+            attrib[html.class_] = "db-tag"
         if namespace_attribute:
-            namespace_str = ''.join(['{', namespace_attribute, '}'])
+            namespace_str = "".join(["{", namespace_attribute, "}"])
             children.append(namespace_str)
         children.extend(self.do_children(element, depth))
         return self.new(moin_page.span, attrib=attrib, children=children)
@@ -989,24 +1154,24 @@ def visit_docbook_trademark(self, element, depth):
         Docbook supports 4 types of trademark: copyright, registered, trade (mark), and service (mark).
         <trademark> --> <span class="db-trademark">
         """
-        trademark_entities = {'copyright': '\xa9 ',  # '&copy; ',
-                              'registered': '\xae',  # '&reg;',
-                              'trade': '\u2122',  # no entity name defined for superscript TM
-                              }
-        trademark_class = element.get('class')
+        trademark_entities = {
+            "copyright": "\xa9 ",  # '&copy; ',
+            "registered": "\xae",  # '&reg;',
+            "trade": "\u2122",  # no entity name defined for superscript TM
+        }
+        trademark_class = element.get("class")
         children = self.do_children(element, depth)
         if trademark_class in trademark_entities:
-            if trademark_class == 'copyright':
+            if trademark_class == "copyright":
                 children.insert(0, trademark_entities[trademark_class])
             else:
                 children.append(trademark_entities[trademark_class])
-        elif trademark_class == 'service':
+        elif trademark_class == "service":
             # no entity name nor entity number defined for superscript SM
-            sup_attrib = {moin_page('baseline-shift'): 'super'}
-            service_mark = self.new(moin_page.span, attrib=sup_attrib,
-                                    children=['SM'])
+            sup_attrib = {moin_page("baseline-shift"): "super"}
+            service_mark = self.new(moin_page.span, attrib=sup_attrib, children=["SM"])
             children.append(service_mark)
-        attrib = {html.class_: 'db-trademark'}
+        attrib = {html.class_: "db-trademark"}
         return self.new(moin_page.span, attrib=attrib, children=children)
 
     def visit_docbook_entry(self, element, depth):
@@ -1014,8 +1179,8 @@ def visit_docbook_entry(self, element, depth):
         <entry> --> <table-cell>
         """
         attrib = {}
-        rowspan = element.get('morerows')
-        colspan = element.get('morecols')
+        rowspan = element.get("morerows")
+        colspan = element.get("morecols")
         try:
             if rowspan:
                 attrib[moin_page.number_rows_spanned] = str(1 + int(rowspan))
@@ -1023,22 +1188,20 @@ def visit_docbook_entry(self, element, depth):
                 attrib[moin_page.number_columns_spanned] = str(1 + int(colspan))
         except ValueError:
             pass
-        return self.new_copy(moin_page.table_cell,
-                             element, depth, attrib=attrib)
+        return self.new_copy(moin_page.table_cell, element, depth, attrib=attrib)
 
     def visit_docbook_td(self, element, depth):
         """
         <td> --> <table-cell>
         """
         attrib = {}
-        rowspan = element.get('rowspan')
-        colspan = element.get('colspan')
+        rowspan = element.get("rowspan")
+        colspan = element.get("colspan")
         if rowspan:
             attrib[moin_page.number_rows_spanned] = rowspan
         if colspan:
             attrib[moin_page.number_columns_spanned] = colspan
-        return self.new_copy(moin_page.table_cell,
-                             element, depth, attrib=attrib)
+        return self.new_copy(moin_page.table_cell, element, depth, attrib=attrib)
 
     def visit_docbook_ulink(self, element, depth):
         """
@@ -1052,7 +1215,7 @@ def visit_docbook_ulink(self, element, depth):
         # The namespace does not always work, so we will try to retrive the attribute whatever
         if not href:
             for key, value in element.attrib.items():
-                if key.name == 'url' and allowed_uri_scheme(value):
+                if key.name == "url" and allowed_uri_scheme(value):
                     href = value
         key = xlink.href
         attrib[key] = href
@@ -1073,18 +1236,18 @@ def visit_qandaentry_number(self, element, depth):
         items = []
         for child in element:
             if isinstance(child, ET.Element):
-                if child.tag.name == 'question' or child.tag.name == 'answer':
+                if child.tag.name == "question" or child.tag.name == "answer":
                     r = self.visit(child, depth)
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     items.extend(r)
             else:
                 items.append(child)
 
-        item_body = ET.Element(moin_page('list-item-body'), attrib={}, children=items)
-        return ET.Element(moin_page('list-item'), attrib={}, children=[item_body])
+        item_body = ET.Element(moin_page("list-item-body"), attrib={}, children=items)
+        return ET.Element(moin_page("list-item"), attrib={}, children=[item_body])
 
     def visit_qandaset_number(self, element, depth):
         """
@@ -1092,23 +1255,23 @@ def visit_qandaset_number(self, element, depth):
           --> <list item-label-generate='ordered'>
         """
         attrib = {}
-        key = moin_page('item-label-generate')
-        attrib[key] = 'ordered'
+        key = moin_page("item-label-generate")
+        attrib[key] = "ordered"
         items = []
         for child in element:
             if isinstance(child, ET.Element):
-                if child.tag.name == 'qandaentry':
+                if child.tag.name == "qandaentry":
                     r = self.visit_qandaentry_number(child, depth)
                 else:
                     r = self.visit(child, depth)
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
-                items.extend(r, )
+                    r = (r,)
+                items.extend(r)
             else:
                 items.append(child)
-        return ET.Element(moin_page('list'), attrib=attrib, children=items)
+        return ET.Element(moin_page("list"), attrib=attrib, children=items)
 
     def visit_qandaentry_qanda(self, element, depth):
         """
@@ -1132,21 +1295,21 @@ def visit_qandaentry_qanda(self, element, depth):
             if isinstance(child, ET.Element):
                 r = ()
                 item_label = None
-                if child.tag.name == 'question':
-                    item_label = ET.Element(moin_page('list-item-label'), attrib={}, children="Q:")
-                elif child.tag.name == 'answer':
-                    item_label = ET.Element(moin_page('list-item-label'), attrib={}, children="A:")
+                if child.tag.name == "question":
+                    item_label = ET.Element(moin_page("list-item-label"), attrib={}, children="Q:")
+                elif child.tag.name == "answer":
+                    item_label = ET.Element(moin_page("list-item-label"), attrib={}, children="A:")
                 else:
                     r = self.visit(child, depth)
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     items.extend(r)
                 if item_label is not None:
-                    item_body = ET.Element(moin_page('list-item-body'), attrib={}, children=self.visit(child, depth))
+                    item_body = ET.Element(moin_page("list-item-body"), attrib={}, children=self.visit(child, depth))
                     r = (item_label, item_body)
-                    list_item = ET.Element(moin_page('list-item'), attrib={}, children=r)
+                    list_item = ET.Element(moin_page("list-item"), attrib={}, children=r)
                     items.append(list_item)
             else:
                 items.append(child)
@@ -1160,18 +1323,18 @@ def visit_qandaset_qanda(self, element, depth):
         for child in element:
             if isinstance(child, ET.Element):
                 r = ()
-                if child.tag.name == 'qandaentry':
+                if child.tag.name == "qandaentry":
                     r = self.visit_qandaentry_qanda(child, depth)
                 else:
                     r = self.visit(child, depth)
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 items.extend(r)
             else:
                 items.append(child)
-        return ET.Element(moin_page('list'), attrib={}, children=items)
+        return ET.Element(moin_page("list"), attrib={}, children=items)
 
     def visit_simple_list(self, moin_page_tag, attrib, element, depth):
         """
@@ -1180,23 +1343,22 @@ def visit_simple_list(self, moin_page_tag, attrib, element, depth):
 
         Here we handle the conversion of such of list.
         """
-        list_item_tags = {'listitem', 'step', 'stepalternatives', 'member'}
+        list_item_tags = {"listitem", "step", "stepalternatives", "member"}
         items = []
         for child in element:
             if isinstance(child, ET.Element):
                 if child.tag.name in list_item_tags:
                     children = self.visit(child, depth)
-                    list_item_body = ET.Element(moin_page('list-item-body'), attrib={}, children=children)
-                    tag = ET.Element(moin_page('list-item'), attrib={},
-                                     children=[list_item_body])
-                    tag = (tag, )
+                    list_item_body = ET.Element(moin_page("list-item-body"), attrib={}, children=children)
+                    tag = ET.Element(moin_page("list-item"), attrib={}, children=[list_item_body])
+                    tag = (tag,)
                     items.extend(tag)
                 else:
                     r = self.visit(child, depth)
                     if r is None:
                         r = ()
                     elif not isinstance(r, (list, tuple)):
-                        r = (r, )
+                        r = (r,)
                     items.extend(r)
             else:
                 items.append(child)
@@ -1225,9 +1387,9 @@ def start_dom_tree(self, element, depth):
         children.append(self.visit(element, depth))
         # We show the table of content only if it is not empty
         if self.is_section:
-            children.insert(0, self.new(moin_page('table-of-content'), attrib={}, children={}))
+            children.insert(0, self.new(moin_page("table-of-content"), attrib={}, children={}))
         body = self.new(moin_page.body, attrib={}, children=children)
         return self.new(moin_page.page, attrib=attrib, children=[body])
 
 
-default_registry.register(Converter._factory, Type('application/docbook+xml'), type_moin_document)
+default_registry.register(Converter._factory, Type("application/docbook+xml"), type_moin_document)
diff --git a/src/moin/converters/docbook_out.py b/src/moin/converters/docbook_out.py
index cd6e0046a..b88d5c816 100644
--- a/src/moin/converters/docbook_out.py
+++ b/src/moin/converters/docbook_out.py
@@ -17,6 +17,7 @@
 from . import default_registry, ElementException
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -24,23 +25,23 @@ class Converter:
     """
     Converter application/x.moin.document -> application/docbook+xml
     """
-    namespaces_visit = {
-        moin_page: 'moinpage'
-    }
 
-    unsupported_tags = {'separator'}
+    namespaces_visit = {moin_page: "moinpage"}
+
+    unsupported_tags = {"separator"}
 
     # Only these admonitions are supported by DocBook 5
-    admonition_tags = {'caution', 'important', 'note', 'tip', 'warning'}
+    admonition_tags = {"caution", "important", "note", "tip", "warning"}
 
     # DOM Tree element which can easily be converted into a DocBook
     # element, without attributes.
-    simple_tags = {'code': docbook.literal,
-                   'emphasis': docbook.emphasis,
-                   'list-item': docbook.varlistentry,
-                   'list-item-label': docbook.term,
-                   'quote': docbook.quote,
-                   }
+    simple_tags = {
+        "code": docbook.literal,
+        "emphasis": docbook.emphasis,
+        "list-item": docbook.varlistentry,
+        "list-item-label": docbook.term,
+        "quote": docbook.quote,
+    }
 
     # We store the standard attributes of an element.
     # Once we have been able to put it into an output element,
@@ -59,10 +60,10 @@ def __call__(self, element, **kw):
         self.root_section = 10
         # We can define the title of the document
         # using the title keyword in the argument
-        if 'title' in kw:
-            self.title = kw['title']
+        if "title" in kw:
+            self.title = kw["title"]
         else:
-            self.title = 'Untitled'
+            self.title = "Untitled"
 
         return self.visit(element)
 
@@ -80,7 +81,7 @@ def do_children(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 new.extend(r)
             else:
                 new.append(child)
@@ -94,8 +95,7 @@ def new(self, tag, attrib, children):
             attrib.update(self.standard_attribute)
             self.standard_attribute = {}
         if self.current_section > 0:
-            self.section_children[self.current_section].append(
-                ET.Element(tag, attrib=attrib, children=children))
+            self.section_children[self.current_section].append(ET.Element(tag, attrib=attrib, children=children))
         else:
             return ET.Element(tag, attrib=attrib, children=children)
 
@@ -135,7 +135,7 @@ def visit(self, element):
         uri = element.tag.uri
         name = self.namespaces_visit.get(uri, None)
         if name is not None:
-            method_name = 'visit_' + name
+            method_name = "visit_" + name
             method = getattr(self, method_name, None)
             if method is not None:
                 return method(element)
@@ -162,7 +162,7 @@ def visit_moinpage(self, element):
             logging.warning(f"Unsupported tag : {element.tag.name}")
             return self.do_children(element)
 
-        method_name = 'visit_moinpage_' + element.tag.name.replace('-', '_')
+        method_name = "visit_moinpage_" + element.tag.name.replace("-", "_")
         method = getattr(self, method_name, None)
         if method:
             return method(element)
@@ -193,7 +193,7 @@ def visit_moinpage_admonition(self, element):
 
         For instance: <caution> --> <admonition type='caution'>
         """
-        tag = element.get(moin_page('type'))
+        tag = element.get(moin_page("type"))
         if tag in self.admonition_tags:
             # Our tag is valid for DocBook 5
             return self.new_copy(docbook(tag), element, attrib={})
@@ -205,8 +205,8 @@ def visit_moinpage_blockcode(self, element):
         """
         <blockcode>text</blockcode> --> <screen><![CDATA[text]]></scren>
         """
-        code_str = ''.join(element)
-        children = ''.join(['<![CDATA[', code_str, ']]>'])
+        code_str = "".join(element)
+        children = "".join(["<![CDATA[", code_str, "]]>"])
         return self.new(docbook.screen, attrib={}, children=children)
 
     def visit_moinpage_blockquote(self, element):
@@ -233,14 +233,14 @@ def visit_moinpage_blockquote(self, element):
                 <simpara>text</text>
             </blockquote>
         """
-        author = element.get(moin_page('source'))
+        author = element.get(moin_page("source"))
         if not author:
             # TODO: Internationalization
             author = "Unknown"
-        attribution = self.new(docbook('attribution'), attrib={}, children=[author])
+        attribution = self.new(docbook("attribution"), attrib={}, children=[author])
         children = self.do_children(element)
-        para = self.new(docbook('simpara'), attrib={}, children=children)
-        return self.new(docbook('blockquote'), attrib={}, children=[attribution, para])
+        para = self.new(docbook("simpara"), attrib={}, children=children)
+        return self.new(docbook("blockquote"), attrib={}, children=[attribution, para])
 
     def visit_moinpage_h(self, element):
         """
@@ -254,11 +254,11 @@ def visit_moinpage_h(self, element):
         A section is closed when we have a new heading with an equal or
         higher level.
         """
-        depth = element.get(moin_page('outline-level'), 1)
+        depth = element.get(moin_page("outline-level"), 1)
         try:
             depth = int(depth)
         except ValueError:
-            raise ElementException('page:outline-level needs to be an integer')
+            raise ElementException("page:outline-level needs to be an integer")
         # We will have a new section
         # under another section
         if depth > self.current_section:
@@ -266,16 +266,17 @@ def visit_moinpage_h(self, element):
             self.current_section = int(depth)
             self.section_children[self.current_section] = []
             # NB : Error with docbook.title
-            title = ET.Element(docbook('title'), attrib={}, children=element[0])
+            title = ET.Element(docbook("title"), attrib={}, children=element[0])
             self.section_children[self.current_section].append(title)
 
         # We will close a section before starting a new one
         # Need more test
         elif depth < self.current_section:
             if self.parent_section != 0:
-                section_tag = f'sect{self.parent_section}'
-                section = ET.Element(docbook(section_tag), attrib={},
-                                     children=self.section_children[self.current_section])
+                section_tag = f"sect{self.parent_section}"
+                section = ET.Element(
+                    docbook(section_tag), attrib={}, children=self.section_children[self.current_section]
+                )
                 self.section_children[self.parent_section].append(section)
                 self.current_section = int(depth)
 
@@ -292,27 +293,25 @@ def visit_moinpage_list(self, element):
 
         Or a specific function to handle definition list.
         """
-        item_label_generate = element.get(moin_page('item-label-generate'))
-        if 'ordered' == item_label_generate:
+        item_label_generate = element.get(moin_page("item-label-generate"))
+        if "ordered" == item_label_generate:
             attrib = {}
             # Get the list-style-type to define correctly numeration
-            list_style_type = element.get(moin_page('list-style-type'))
-            if 'upper-alpha' == list_style_type:
-                attrib[docbook('numeration')] = 'upperalpha'
-            elif 'upper-roman' == list_style_type:
-                attrib[docbook('numeration')] = 'upperroman'
-            elif 'lower-alpha' == list_style_type:
-                attrib[docbook('numeration')] = 'loweralpha'
-            elif 'lower-roman' == list_style_type:
-                attrib[docbook('numeration')] = 'lowerroman'
+            list_style_type = element.get(moin_page("list-style-type"))
+            if "upper-alpha" == list_style_type:
+                attrib[docbook("numeration")] = "upperalpha"
+            elif "upper-roman" == list_style_type:
+                attrib[docbook("numeration")] = "upperroman"
+            elif "lower-alpha" == list_style_type:
+                attrib[docbook("numeration")] = "loweralpha"
+            elif "lower-roman" == list_style_type:
+                attrib[docbook("numeration")] = "lowerroman"
             else:
-                attrib[docbook('numeration')] = 'arabic'
+                attrib[docbook("numeration")] = "arabic"
 
-            return self.handle_simple_list(docbook.orderedlist,
-                                           element, attrib=attrib)
-        elif 'unordered' == item_label_generate:
-            return self.handle_simple_list(docbook.itemizedlist,
-                                           element, attrib={})
+            return self.handle_simple_list(docbook.orderedlist, element, attrib=attrib)
+        elif "unordered" == item_label_generate:
+            return self.handle_simple_list(docbook.itemizedlist, element, attrib={})
         else:
             return self.new_copy(docbook.variablelist, element, attrib={})
 
@@ -324,7 +323,7 @@ def visit_moinpage_list_item_body(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 items.extend(r)
             else:
                 an_item = ET.Element(docbook.simpara, attrib={}, children=child)
@@ -336,9 +335,9 @@ def visit_moinpage_note(self, element):
         <note note-class="footnote"><note-body>text</note-body></note>
           --> <footnote><simpara>text</simpara></footnote>
         """
-        note_class = element.get(moin_page('note-class'))
+        note_class = element.get(moin_page("note-class"))
         # We only convert footnote, we do not convert endnote yet
-        if note_class != 'footnote':
+        if note_class != "footnote":
             return
 
         # We will check the presence of a body
@@ -346,7 +345,7 @@ def visit_moinpage_note(self, element):
         for child in element:
             if isinstance(child, ET.Element):
                 if child.tag.uri == moin_page:
-                    if child.tag.name == 'note-body':
+                    if child.tag.name == "note-body":
                         body = self.do_children(child)
         # We process note only with note-body child
         if not body:
@@ -376,36 +375,29 @@ def visit_moinpage_object(self, element):
         mimetype = Type(_type=element.get(moin_page.type_, CONTENTTYPE_NONEXISTENT))
         if href:
             attrib[docbook.fileref] = href
-            if Type('image/').issupertype(mimetype):
-                object_data = self.new(docbook.imagedata, attrib=attrib,
-                                       children=[])
-                object_element = self.new(docbook.imageobject, attrib={},
-                                          children=[object_data])
-            elif Type('video/').issupertype(mimetype):
-                object_data = self.new(docbook.videodata, attrib=attrib,
-                                       children=[])
-                object_element = self.new(docbook.videoobject, attrib={},
-                                          children=[object_data])
-            elif Type('audio/').issupertype(mimetype):
-                object_data = self.new(docbook.audiodata, attrib=attrib,
-                                       children=[])
-                object_element = self.new(docbook.audioobject, attrib={},
-                                          children=[object_data])
+            if Type("image/").issupertype(mimetype):
+                object_data = self.new(docbook.imagedata, attrib=attrib, children=[])
+                object_element = self.new(docbook.imageobject, attrib={}, children=[object_data])
+            elif Type("video/").issupertype(mimetype):
+                object_data = self.new(docbook.videodata, attrib=attrib, children=[])
+                object_element = self.new(docbook.videoobject, attrib={}, children=[object_data])
+            elif Type("audio/").issupertype(mimetype):
+                object_data = self.new(docbook.audiodata, attrib=attrib, children=[])
+                object_element = self.new(docbook.audioobject, attrib={}, children=[object_data])
             else:
                 return
         else:
             return
-        return self.new(docbook.inlinemediaobject, attrib={},
-                        children=[object_element])
+        return self.new(docbook.inlinemediaobject, attrib={}, children=[object_element])
 
     def visit_moinpage_table(self, element):
         # TODO: Attributes conversion
-        title = element.get(html('title'))
+        title = element.get(html("title"))
         if not title:
             # TODO: Translation
             title = f"Table {self.table_counter}"
         self.table_counter += 1
-        caption = ET.Element(docbook('caption'), attrib={}, children=[title])
+        caption = ET.Element(docbook("caption"), attrib={}, children=[title])
         children = [caption]
         children.extend(self.do_children(element))
         return self.new(docbook.table, attrib={}, children=children)
@@ -416,8 +408,8 @@ def visit_moinpage_table_body(self, element):
 
     def visit_moinpage_table_cell(self, element):
         attrib = {}
-        rowspan = element.get(moin_page('number-rows-spanned'))
-        colspan = element.get(moin_page('number-columns-spanned'))
+        rowspan = element.get(moin_page("number-rows-spanned"))
+        colspan = element.get(moin_page("number-columns-spanned"))
         print(f"rowspan : {rowspan}")
         if rowspan:
             attrib[docbook.rowspan] = rowspan
@@ -442,7 +434,7 @@ def handle_simple_list(self, docbook_tag, element, attrib):
         for child in element:
             if isinstance(child, ET.Element):
                 # We do not care about <list-item>
-                if child.tag.name != 'list-item':
+                if child.tag.name != "list-item":
                     r = self.visit(child)
                 else:
                     r = self.do_children(child)
@@ -450,37 +442,33 @@ def handle_simple_list(self, docbook_tag, element, attrib):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 list_items.extend(r)
         return ET.Element(docbook_tag, attrib=attrib, children=list_items)
 
     def visit_moinpage_page(self, element):
-        title = ET.Element(docbook('title'), attrib={}, children=[self.title])
+        title = ET.Element(docbook("title"), attrib={}, children=[self.title])
         info = ET.Element(docbook.info, attrib={}, children=[title])
         for item in element:
-            if item.tag.uri == moin_page and item.tag.name == 'body':
+            if item.tag.uri == moin_page and item.tag.name == "body":
                 c = self.do_children(item)
                 if not c:
-                    self.section_children = sorted(self.section_children.items(),
-                                                   reverse=True)
+                    self.section_children = sorted(self.section_children.items(), reverse=True)
                     section = None
                     for k, v in self.section_children:
                         if section:
-                            section_tag = f'sect{k}'
+                            section_tag = f"sect{k}"
                             v.append(section)
-                            section = ET.Element(docbook(section_tag),
-                                                 attrib={}, children=v)
+                            section = ET.Element(docbook(section_tag), attrib={}, children=v)
                         else:
-                            section_tag = f'sect{k}'
-                            section = ET.Element(docbook(section_tag),
-                                                 attrib={}, children=v)
-                    return ET.Element(docbook.article,
-                                      attrib={}, children=[info, section])
+                            section_tag = f"sect{k}"
+                            section = ET.Element(docbook(section_tag), attrib={}, children=v)
+                    return ET.Element(docbook.article, attrib={}, children=[info, section])
                 else:
                     c.insert(0, info)
                     return ET.Element(docbook.article, attrib={}, children=c)
 
-        raise RuntimeError(f'page:page need to contain exactly one page body tag, got {element[:]!r}')
+        raise RuntimeError(f"page:page need to contain exactly one page body tag, got {element[:]!r}")
 
     def visit_moinpage_p(self, element):
         """
@@ -488,12 +476,11 @@ def visit_moinpage_p(self, element):
         with a <title> child.
         Otherwise we return a <simpara>.
         """
-        title_attr = element.get(html('title'))
+        title_attr = element.get(html("title"))
         if title_attr:
             print(title_attr)
             children = []
-            title_elem = self.new(docbook('title'), attrib={},
-                                  children=[title_attr])
+            title_elem = self.new(docbook("title"), attrib={}, children=[title_attr])
             children.append(title_elem)
             children.extend(self.do_children(element))
             return self.new(docbook.para, attrib={}, children=children)
@@ -510,11 +497,10 @@ def visit_moinpage_span(self, element):
         """
         # Check for the attributes of span
         for key, value in element.attrib.items():
-            if key.name == 'baseline-shift':
-                if value == 'super':
-                    return self.new_copy(docbook.superscript,
-                                         element, attrib={})
-                if value == 'sub':
+            if key.name == "baseline-shift":
+                if value == "super":
+                    return self.new_copy(docbook.superscript, element, attrib={})
+                if value == "sub":
                     return self.new_copy(docbook.subscript, element, attrib={})
 
         return self.new_copy(docbook.phrase, element, attrib={})
@@ -533,4 +519,4 @@ def visit_simple_tag(self, element):
         return self.new_copy(tag_to_return, element, attrib={})
 
 
-default_registry.register(Converter._factory, type_moin_document, Type('application/docbook+xml'))
+default_registry.register(Converter._factory, type_moin_document, Type("application/docbook+xml"))
diff --git a/src/moin/converters/everything.py b/src/moin/converters/everything.py
index 7514a68b1..cf8e06187 100644
--- a/src/moin/converters/everything.py
+++ b/src/moin/converters/everything.py
@@ -20,29 +20,27 @@ class Converter:
     """
     Convert a unsupported item to DOM Tree.
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls()
 
     def __call__(self, rev, contenttype=None, arguments=None):
         try:
-            item_name = rev.item.name or rev.meta['name'][0]
+            item_name = rev.item.name or rev.meta["name"][0]
         except IndexError:
             # item is deleted
             message = _(
-                'This deleted item must be restored before it can be viewed or downloaded, ItemID = {itemid}'
+                "This deleted item must be restored before it can be viewed or downloaded, ItemID = {itemid}"
             ).format(itemid=rev.item.itemid)
-            admonition = moin_page.div(attrib={moin_page.class_: 'error'}, children=[moin_page.p(children=[message])])
-            body = moin_page.body(children=(admonition, ))
-            return moin_page.page(children=(body, ))
-        attrib = {
-            xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name,
-                            query=f'do=get&rev={rev.revid}'),
-        }
+            admonition = moin_page.div(attrib={moin_page.class_: "error"}, children=[moin_page.p(children=[message])])
+            body = moin_page.body(children=(admonition,))
+            return moin_page.page(children=(body,))
+        attrib = {xlink.href: Iri(scheme="wiki", authority="", path="/" + item_name, query=f"do=get&rev={rev.revid}")}
         a = moin_page.a(attrib=attrib, children=[f"Download {item_name}."])
-        body = moin_page.body(children=(a, ))
-        return moin_page.page(children=(body, ))
+        body = moin_page.body(children=(a,))
+        return moin_page.page(children=(body,))
 
 
-default_registry.register(Converter._factory, Type('application/octet-stream'), type_moin_document)
+default_registry.register(Converter._factory, Type("application/octet-stream"), type_moin_document)
 default_registry.register(Converter._factory, Type(type=None, subtype=None), type_moin_document)
diff --git a/src/moin/converters/highlight.py b/src/moin/converters/highlight.py
index 3574e4f31..e05a0e94b 100644
--- a/src/moin/converters/highlight.py
+++ b/src/moin/converters/highlight.py
@@ -17,9 +17,9 @@
 
 class Converter:
     @classmethod
-    def _factory(cls, input, output, highlight='', regex='', **kw):
-        if highlight == 'highlight':
-            regex = request.args['regex']
+    def _factory(cls, input, output, highlight="", regex="", **kw):
+        if highlight == "highlight":
+            regex = request.args["regex"]
             return cls(regex)
 
     def recurse(self, elem):
@@ -32,11 +32,11 @@ def recurse(self, elem):
                 # Restrict it to our own namespace for now
                 if elem.tag.uri == moin_page.namespace:
                     for match in re.finditer(self.pattern, child):
-                        text = child[pos:match.start()]
+                        text = child[pos : match.start()]
                         new_childs.append(text)
 
-                        text = child[match.start():match.end()]
-                        attrib = {html.class_: 'moin-highlight'}
+                        text = child[match.start() : match.end()]
+                        attrib = {html.class_: "moin-highlight"}
                         e = moin_page.strong(attrib=attrib, children=[text])
                         new_childs.append(e)
 
diff --git a/src/moin/converters/html_in.py b/src/moin/converters/html_in.py
index 228f93f63..a132b7e0e 100644
--- a/src/moin/converters/html_in.py
+++ b/src/moin/converters/html_in.py
@@ -25,6 +25,7 @@
 from ._util import allowed_uri_scheme, decode_data, normalize_split_text
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -32,6 +33,7 @@ class NoDupsFlash:
     """
     Issue flash messages for unsupported HTML tags; but do not create duplicate messages.
     """
+
     def __init__(self):
         self.messages = set()
 
@@ -48,52 +50,80 @@ class Converter:
     """
     Converter html -> .x.moin.document
     """
+
     # Namespace of our input data
-    html_namespace = {
-        html.namespace: 'xhtml',
-    }
+    html_namespace = {html.namespace: "xhtml"}
 
     # HTML tags which can be converted directly to the moin_page namespace
-    symmetric_tags = {'div', 'p', 'strong', 'code', 'quote', 'blockquote', 'span'}
+    symmetric_tags = {"div", "p", "strong", "code", "quote", "blockquote", "span"}
 
     # HTML tags to define a list, except dl which is a little bit different
-    list_tags = {'ul', 'dir', 'ol'}
+    list_tags = {"ul", "dir", "ol"}
 
     # HTML tags which can be convert without attributes in a different DOM tag
     simple_tags = {  # Emphasis
-        'em': moin_page.emphasis, 'i': moin_page.emphasis,
+        "em": moin_page.emphasis,
+        "i": moin_page.emphasis,
         # Strong
-        'b': moin_page.strong, 'strong': moin_page.strong,
+        "b": moin_page.strong,
+        "strong": moin_page.strong,
         # Code and Blockcode
-        'pre': moin_page.blockcode, 'tt': moin_page.code,
-        'samp': moin_page.code,
+        "pre": moin_page.blockcode,
+        "tt": moin_page.code,
+        "samp": moin_page.code,
         # Lists
-        'dt': moin_page.list_item_label, 'dd': moin_page.list_item_body,
+        "dt": moin_page.list_item_label,
+        "dd": moin_page.list_item_body,
         # TODO : Some tags related to tables can be also simplify
     }
 
     # HTML Tag which does not have equivalence in the DOM Tree
     # But we keep the information using <span element>
-    inline_tags = {'abbr', 'acronym', 'address', 'dfn', 'kbd'}
+    inline_tags = {"abbr", "acronym", "address", "dfn", "kbd"}
 
     # HTML tags which are completely ignored by our converter.
     # We even do not process children of these elements.
-    ignored_tags = {'applet', 'area', 'button', 'caption', 'center', 'fieldset',
-                    'form', 'frame', 'frameset', 'head', 'iframe', 'input', 'isindex',
-                    'label', 'legend', 'link', 'map', 'menu', 'noframes', 'noscript',
-                    'optgroup', 'option', 'param', 'script', 'select', 'style',
-                    'textarea', 'title', 'var',
-                    }
+    ignored_tags = {
+        "applet",
+        "area",
+        "button",
+        "caption",
+        "center",
+        "fieldset",
+        "form",
+        "frame",
+        "frameset",
+        "head",
+        "iframe",
+        "input",
+        "isindex",
+        "label",
+        "legend",
+        "link",
+        "map",
+        "menu",
+        "noframes",
+        "noscript",
+        "optgroup",
+        "option",
+        "param",
+        "script",
+        "select",
+        "style",
+        "textarea",
+        "title",
+        "var",
+    }
 
     # standard_attributes are html attributes which are used
     # directly in the DOM tree, without any conversion
-    standard_attributes = {'title', 'class', 'style', 'alt'}
+    standard_attributes = {"title", "class", "style", "alt"}
 
     # Regular expression to detect an html heading tag
-    heading_re = re.compile('h[1-6]')
+    heading_re = re.compile("h[1-6]")
 
     # Store the Base URL for all the URL of the document
-    base_url = ''
+    base_url = ""
 
     @classmethod
     def _factory(cls, input, output, **kw):
@@ -110,39 +140,39 @@ def __call__(self, data, contenttype=None, arguments=None):
 
         text = decode_data(data, contenttype)
         # data cleanup is not needed by html_out, but is needed by moinwiki_out; CKEditor adds unwanted \n\t
-        while '\t\t' in text:
-            text = text.replace('\t\t', '\t')
-        text = text.replace('\r\n\t', '').replace('\n\t', '')
+        while "\t\t" in text:
+            text = text.replace("\t\t", "\t")
+        text = text.replace("\r\n\t", "").replace("\n\t", "")
 
         content = normalize_split_text(text)
         # Be sure we have empty string in the base url
-        self.base_url = ''
+        self.base_url = ""
 
         # We create an element tree from the HTML content
         # The content is a list of string, line per line
         # We can concatenate all in one string
-        html_str = '\n'.join(content)
+        html_str = "\n".join(content)
         try:
             html_tree = HTML(html_str)
         except AssertionError as reason:
             # we suspect user has created or uploaded malformed HTML, try to show input as preformatted code
-            msg = _('Error: malformed HTML: {reason}.').format(reason=reason)
+            msg = _("Error: malformed HTML: {reason}.").format(reason=reason)
             msg = f'<div class="error"><p><strong>{msg}</strong></p></div>'
-            html_str = ''.join(['<html>', msg, '<pre>', html_str, '</pre></html>'])
+            html_str = "".join(["<html>", msg, "<pre>", html_str, "</pre></html>"])
             try:
                 html_tree = HTML(html_str)
             except ValueError:
-                msg = _('Error: malformed HTML. Try viewing source with Highlight or Modify links.')
+                msg = _("Error: malformed HTML. Try viewing source with Highlight or Modify links.")
                 msg = f'<div class="error"><p><strong>{msg}</strong></p></div>'
-                html_str = ''.join(['<html>', msg, '</html>'])
+                html_str = "".join(["<html>", msg, "</html>"])
                 html_tree = HTML(html_str)
 
         # We should have a root element, which will be converted as <page>
         # for the DOM Tree.
         # NB : If <html> used, it will be converted back to <div> after
         # one roundtrip
-        if html_tree.tag.name != 'html':
-            html_str = ''.join(['<div>', html_str, '</div>'])
+        if html_tree.tag.name != "html":
+            html_str = "".join(["<div>", html_str, "</div>"])
             html_tree = HTML(html_str)
 
         # Start the conversion of the first element
@@ -166,7 +196,7 @@ def do_children(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 new.extend(r)
             else:
                 new.append(child)
@@ -203,11 +233,10 @@ def new_copy_symmetric(self, element, attrib):
     def convert_attributes(self, element):
         result = {}
         for key, value in element.attrib.items():
-            if key.uri == html and \
-               key.name in self.standard_attributes:
+            if key.uri == html and key.name in self.standard_attributes:
                 result[key] = value
-            if key.name == 'id':
-                result[xml('id')] = value
+            if key.name == "id":
+                result[xml("id")] = value
         return result
 
     def visit(self, element):
@@ -221,7 +250,7 @@ def visit(self, element):
         uri = element.tag.uri
         name = self.html_namespace.get(uri, None)
         if name is not None:
-            method_name = 'visit_' + name
+            method_name = "visit_" + name
             method = getattr(self, method_name, None)
             if method is not None:
                 return method(element)
@@ -258,7 +287,7 @@ def visit_xhtml(self, element):
             return self.visit_xhtml_heading(element)
 
         # Otherwise we need a specific procedure to handle it
-        method_name = 'visit_xhtml_' + element.tag.name
+        method_name = "visit_xhtml_" + element.tag.name
         method = getattr(self, method_name, None)
         if method:
             return method(element)
@@ -266,15 +295,17 @@ def visit_xhtml(self, element):
         # We should ignore this tag
         if element.tag.name in self.ignored_tags:
             # tell user output from obsolete tags like "center" is suppressed
-            msg = _("Tag '{invalid_tag}' is not supported; all tag contents are discarded."
-                    ).format(invalid_tag=element.tag.name)
+            msg = _("Tag '{invalid_tag}' is not supported; all tag contents are discarded.").format(
+                invalid_tag=element.tag.name
+            )
             self.no_dups_flash.log(msg, "info")
             logging.debug(f"WARNING : Ignored tag : {element.tag.name}")
             return
 
         # Otherwise we process children of the unknown element
-        msg = _("Tag '{invalid_tag}' is not known; tag ignored but children are processed."
-                ).format(invalid_tag=element.tag.name)
+        msg = _("Tag '{invalid_tag}' is not known; tag ignored but children are processed.").format(
+            invalid_tag=element.tag.name
+        )
         self.no_dups_flash.log(msg, "info")
         logging.debug(f"WARNING : Unknown tag : {element.tag.name}")
         return self.do_children(element)
@@ -294,7 +325,7 @@ def visit_xhtml_heading(self, element):
         element in our moin_page namespace
         """
         heading_level = element.tag.name[1]
-        key = moin_page('outline-level')
+        key = moin_page("outline-level")
         attrib = {}
         attrib[key] = heading_level
         ret = self.new_copy(moin_page.h, element, attrib)
@@ -310,36 +341,36 @@ def visit_xhtml_big(self, element):
         """
         <big>Text</big> --> <span font-size=120%>Text</span>
         """
-        key = moin_page('font-size')
+        key = moin_page("font-size")
         attrib = {}
-        attrib[key] = '120%'
+        attrib[key] = "120%"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_xhtml_small(self, element):
         """
         <small>Text</small> --> <span font-size=85%>Text</span>
         """
-        key = moin_page('font-size')
+        key = moin_page("font-size")
         attrib = {}
-        attrib[key] = '85%'
+        attrib[key] = "85%"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_xhtml_sub(self, element):
         """
         <sub>Text</sub> --> <span base-line-shift="sub">Text</span>
         """
-        key = moin_page('baseline-shift')
+        key = moin_page("baseline-shift")
         attrib = {}
-        attrib[key] = 'sub'
+        attrib[key] = "sub"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_xhtml_sup(self, element):
         """
         <sup>Text</sup> --> <span base-line-shift="super">Text</span>
         """
-        key = moin_page('baseline-shift')
+        key = moin_page("baseline-shift")
         attrib = {}
-        attrib[key] = 'super'
+        attrib[key] = "super"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_xhtml_u(self, element):
@@ -372,26 +403,26 @@ def visit_xhtml_strike(self, element):
         """
         return self.new_copy(moin_page.s, element, {})
 
-    def visit_xhtml_hr(self, element, min_class='moin-hr1', max_class='moin-hr6', default_class='moin-hr3'):
+    def visit_xhtml_hr(self, element, min_class="moin-hr1", max_class="moin-hr6", default_class="moin-hr3"):
         """
         <hr /> --> <separator />
         """
-        hr_class = element.attrib.get(html('class'))
+        hr_class = element.attrib.get(html("class"))
         if hr_class is None or not (min_class <= hr_class <= max_class):
-            element.attrib[html('class')] = default_class
+            element.attrib[html("class")] = default_class
         return self.new_copy(moin_page.separator, element, {})
 
     def visit_xhtml_a(self, element):
         """
         <a href="URI">Text</a> --> <a xlink:href="URI">Text</a>
         """
-        key = xlink('href')
+        key = xlink("href")
         attrib = {}
-        if element.attrib.get('title'):
-            attrib[html.title_] = element.attrib.get('title')
+        if element.attrib.get("title"):
+            attrib[html.title_] = element.attrib.get("title")
         href = element.get(html.href)
         if self.base_url:
-            href = ''.join([self.base_url, href])
+            href = "".join([self.base_url, href])
         if allowed_uri_scheme(href):
             iri = Iri(href)
         else:
@@ -399,7 +430,7 @@ def visit_xhtml_a(self, element):
             # <p><a href="javascript:alert('hi')">Test</a></p> are converted to: <p><javascript:alert('hi')"</p>
             return href
         if iri.scheme is None:
-            iri.scheme = 'wiki.local'
+            iri.scheme = "wiki.local"
         attrib[key] = iri
         return self.new_copy(moin_page.a, element, attrib)
 
@@ -407,12 +438,12 @@ def visit_xhtml_img(self, element):
         """
         <img src="URI" /> --> <object xlink:href="URI />
         """
-        key = xlink('href')
+        key = xlink("href")
         attrib = self.convert_attributes(element)
         # adding type_ attrib makes html_out create an image tag rather than an object tag
-        attrib[moin_page.type_] = 'image/'
+        attrib[moin_page.type_] = "image/"
         if self.base_url:
-            attrib[key] = ''.join([self.base_url, element.get(html.src)])
+            attrib[key] = "".join([self.base_url, element.get(html.src)])
         else:
             attrib[key] = element.get(html.src)
         return moin_page.object(attrib)
@@ -421,10 +452,10 @@ def visit_xhtml_object(self, element):
         """
         <object data="href"></object> --> <object xlink="href" />
         """
-        key = xlink('href')
+        key = xlink("href")
         attrib = {}
         if self.base_url:
-            attrib[key] = ''.join([self.base_url, element.get(html.data)])
+            attrib[key] = "".join([self.base_url, element.get(html.data)])
         else:
             attrib[key] = element.get(html.data)
 
@@ -437,16 +468,16 @@ def visit_xhtml_audio(self, element):
         <audio src="URI" /> --> <audio xlink:href="URI />
         """
         attrib = {}
-        key = xlink('href')
+        key = xlink("href")
         if self.base_url:
-            attrib[key] = ''.join([self.base_url, element.get(html.src)])
+            attrib[key] = "".join([self.base_url, element.get(html.src)])
         else:
             attrib[key] = element.get(html.src)
         for key, value in element.attrib.items():
-            if key.uri == html and key.name in ('controls', ):
+            if key.uri == html and key.name in ("controls",):
                 attrib[key] = value
-            if key.name == 'id':
-                attrib[xml('id')] = value
+            if key.name == "id":
+                attrib[xml("id")] = value
         return moin_page.audio(attrib)
 
     def visit_xhtml_video(self, element):
@@ -454,16 +485,16 @@ def visit_xhtml_video(self, element):
         <video src="URI" /> --> <video xlink:href="URI />
         """
         attrib = {}
-        key = xlink('href')
+        key = xlink("href")
         if self.base_url:
-            attrib[key] = ''.join([self.base_url, element.get(html.src)])
+            attrib[key] = "".join([self.base_url, element.get(html.src)])
         else:
             attrib[key] = element.get(html.src)
         for key, value in element.attrib.items():
-            if key.uri == html and key.name in ('controls', 'width', 'height', 'autoplay'):
+            if key.uri == html and key.name in ("controls", "width", "height", "autoplay"):
                 attrib[key] = value
-            if key.name == 'id':
-                attrib[xml('id')] = value
+            if key.name == "id":
+                attrib[xml("id")] = value
         return moin_page.video(attrib)
 
     def visit_xhtml_inline(self, element):
@@ -471,9 +502,9 @@ def visit_xhtml_inline(self, element):
         For some specific inline tags (defined in inline_tags)
         We just return <span element="tag.name">
         """
-        key = html('class')
+        key = html("class")
         attrib = {}
-        attrib[key] = ''.join(['html-', element.tag.name])
+        attrib[key] = "".join(["html-", element.tag.name])
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_xhtml_list(self, element):
@@ -501,20 +532,20 @@ def visit_xhtml_list(self, element):
         # according to the type of the list
         attrib = self.convert_attributes(element)
         if element.tag.name == "ul" or element.tag.name == "dir":
-            attrib[moin_page('item-label-generate')] = 'unordered'
+            attrib[moin_page("item-label-generate")] = "unordered"
         elif element.tag.name == "ol":
-            attrib[moin_page('item-label-generate')] = 'ordered'
+            attrib[moin_page("item-label-generate")] = "ordered"
 
             # We check which kind of style we have
             style = element.get(html.type)
-            if 'A' == style:
-                attrib[moin_page('list-style-type')] = 'upper-alpha'
-            elif 'I' == style:
-                attrib[moin_page('list-style-type')] = 'upper-roman'
-            elif 'a' == style:
-                attrib[moin_page('list-style-type')] = 'lower-alpha'
-            elif 'i' == style:
-                attrib[moin_page('list-style-type')] = 'lower-roman'
+            if "A" == style:
+                attrib[moin_page("list-style-type")] = "upper-alpha"
+            elif "I" == style:
+                attrib[moin_page("list-style-type")] = "upper-roman"
+            elif "a" == style:
+                attrib[moin_page("list-style-type")] = "lower-alpha"
+            elif "i" == style:
+                attrib[moin_page("list-style-type")] = "lower-roman"
 
         # we should not have any strings in the child
         list_items = []
@@ -524,7 +555,7 @@ def visit_xhtml_list(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 list_items.extend(r)
         return ET.Element(moin_page.list, attrib=attrib, children=list_items)
 
@@ -557,7 +588,7 @@ def visit_xhtml_dl(self, element):
         # of <dt><dd>
         for child in element:
             # We need one dt tag, and one dd tag, a have a pair
-            if child.tag.name == 'dt' or child.tag.name == 'dd':
+            if child.tag.name == "dt" or child.tag.name == "dd":
                 number_pair += 1
 
             # The following code is similar to do_children method
@@ -566,7 +597,7 @@ def visit_xhtml_dl(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 pair.extend(r)
             else:
                 pair.append(r)
@@ -574,8 +605,7 @@ def visit_xhtml_dl(self, element):
             if number_pair == 2:
                 # We have two elements of the pair
                 # So we can put it into a <list-item> element
-                list_item_element = ET.Element(moin_page.list_item,
-                                               attrib={}, children=pair)
+                list_item_element = ET.Element(moin_page.list_item, attrib={}, children=pair)
                 list_item.append(list_item_element)
                 pair = []
                 number_pair = 0
@@ -594,8 +624,7 @@ def visit_xhtml_li(self, element):
 
         For <li> element, there is no label
         """
-        list_item_body = ET.Element(moin_page.list_item_body,
-                                    attrib={}, children=self.do_children(element))
+        list_item_body = ET.Element(moin_page.list_item_body, attrib={}, children=self.do_children(element))
         return ET.Element(moin_page.list_item, attrib={}, children=[list_item_body])
 
     def visit_xhtml_table(self, element):
@@ -608,7 +637,7 @@ def visit_xhtml_table(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 list_table_elements.extend(r)
         return ET.Element(moin_page.table, attrib=attrib, children=list_table_elements)
 
@@ -640,10 +669,10 @@ def rowspan_colspan(self, element):
         rowspan = element.get(html.rowspan)
         colspan = element.get(html.colspan)
         if rowspan:
-            attrib[moin_page('number-rows-spanned')] = rowspan
+            attrib[moin_page("number-rows-spanned")] = rowspan
         if colspan:
-            attrib[moin_page('number-columns-spanned')] = colspan
+            attrib[moin_page("number-columns-spanned")] = colspan
         return attrib
 
 
-default_registry.register(Converter._factory, Type('text/html'), type_moin_document)
+default_registry.register(Converter._factory, Type("text/html"), type_moin_document)
diff --git a/src/moin/converters/html_out.py b/src/moin/converters/html_out.py
index 9d95ccea1..29568ae42 100644
--- a/src/moin/converters/html_out.py
+++ b/src/moin/converters/html_out.py
@@ -28,11 +28,12 @@
 from . import default_registry, ElementException
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 # strings not allowed in style attributes
-SUSPECT = {'/*', '/>', '\\', '`', 'script', '&#', 'http', 'expression', 'behavior', }
+SUSPECT = {"/*", "/>", "\\", "`", "script", "&#", "http", "expression", "behavior"}
 
 
 def style_attr_filter(style):
@@ -42,17 +43,17 @@ def style_attr_filter(style):
     if app.cfg.allow_style_attributes:
         s = "".join(style.strip().lower().split())
         if any(x in s for x in SUSPECT):
-            return ' /*style suppressed, failed test for suspect strings*/ '
+            return " /*style suppressed, failed test for suspect strings*/ "
         return style
-    return ''
+    return ""
 
 
 def convert_getlink_to_showlink(href):
     """
     If the incoming transclusion reference is within this domain, then remove "+get/<revision number>/".
     """
-    if href.startswith('/'):
-        return re.sub(r'\+get/\+[0-9a-fA-F]+/', '', href)
+    if href.startswith("/"):
+        return re.sub(r"\+get/\+[0-9a-fA-F]+/", "", href)
     return href
 
 
@@ -65,9 +66,9 @@ def mark_item_as_transclusion(elem, href_or_item):
     in a span or div and 2 overlay siblings will be created.
     """
     if isinstance(href_or_item, Item):
-        query = urlencode({'do': 'show'}, encoding=CHARSET)
-        href = Iri(scheme='wiki', authority='', path='/' + href_or_item.fqname.fullname, query=query)
-        if hasattr(href_or_item, 'meta') and LANGUAGE in href_or_item.meta:
+        query = urlencode({"do": "show"}, encoding=CHARSET)
+        href = Iri(scheme="wiki", authority="", path="/" + href_or_item.fqname.fullname, query=query)
+        if hasattr(href_or_item, "meta") and LANGUAGE in href_or_item.meta:
             elem.attrib[html.lang] = href_or_item.meta[LANGUAGE]
         elif hasattr(flaskg.user, LANGUAGE):
             elem.attrib[html.lang] = flaskg.user.language
@@ -77,15 +78,16 @@ def mark_item_as_transclusion(elem, href_or_item):
     else:  # isinstance(href_or_item, Iri)
         href = href_or_item
     elem.attrib[html.data_href] = href
-    classes = elem.attrib.get(html.class_, '').split()
-    classes.append('moin-transclusion')
-    elem.attrib[html.class_] = ' '.join(classes)
+    classes = elem.attrib.get(html.class_, "").split()
+    classes.append("moin-transclusion")
+    elem.attrib[html.class_] = " ".join(classes)
     return elem
 
 
 class Attribute:
-    """ Adds the attribute with the HTML namespace to the output. """
-    __slots__ = 'key'
+    """Adds the attribute with the HTML namespace to the output."""
+
+    __slots__ = "key"
 
     def __init__(self, key):
         self.key = html(key)
@@ -95,17 +97,15 @@ def __call__(self, value, out):
 
 
 class Attributes:
-    namespaces_valid_output = frozenset([
-        html,
-    ])
-
-    visit_class = Attribute('class')
-    visit_number_columns_spanned = Attribute('colspan')
-    visit_number_rows_spanned = Attribute('rowspan')
-    visit_style = Attribute('style')
-    visit_title = Attribute('title')
-    visit_id = Attribute('id')
-    visit_type = Attribute('type')  # IE8 needs <object... type="image/svg+xml" ...> to display svg images
+    namespaces_valid_output = frozenset([html])
+
+    visit_class = Attribute("class")
+    visit_number_columns_spanned = Attribute("colspan")
+    visit_number_rows_spanned = Attribute("rowspan")
+    visit_style = Attribute("style")
+    visit_title = Attribute("title")
+    visit_id = Attribute("id")
+    visit_type = Attribute("type")  # IE8 needs <object... type="image/svg+xml" ...> to display svg images
 
     def __init__(self, element):
         self.element = element
@@ -135,8 +135,8 @@ def convert(self):
             if key.uri == moin_page:
                 # We never have _ in attribute names, so ignore them instead of
                 # create ambigues matches.
-                if '_' not in key.name:
-                    n = 'visit_' + key.name.replace('-', '_')
+                if "_" not in key.name:
+                    n = "visit_" + key.name.replace("-", "_")
                     f = getattr(self, n, None)
                     if f is not None:
                         f(value, new)
@@ -144,11 +144,11 @@ def convert(self):
                 new[key] = value
             # We convert xml:id
             elif key.uri == xml.namespace:
-                if key.name == 'id' or key.name == 'lang':
+                if key.name == "id" or key.name == "lang":
                     new[ET.QName(key.name, html.namespace)] = value
             elif key.uri is None:
-                if self.default_uri_input and '_' not in key.name:
-                    n = 'visit_' + key.name.replace('-', '_')
+                if self.default_uri_input and "_" not in key.name:
+                    n = "visit_" + key.name.replace("-", "_")
                     f = getattr(self, n, None)
                     if f is not None:
                         f(value, new_default)
@@ -166,12 +166,10 @@ class Converter:
     Converter application/x.moin.document -> application/x.moin.document
     """
 
-    namespaces_visit = {
-        moin_page: 'moinpage',
-    }
+    namespaces_visit = {moin_page: "moinpage"}
 
     # Inline tags which can be directly converted into an HTML element
-    direct_inline_tags = {'abbr', 'address', 'dfn', 'kbd'}
+    direct_inline_tags = {"abbr", "address", "dfn", "kbd"}
 
     def __call__(self, element):
         return self.visit(element)
@@ -184,7 +182,7 @@ def do_children(self, element):
                 if r is None:
                     r = ()
                 elif not isinstance(r, (list, tuple)):
-                    r = (r, )
+                    r = (r,)
                 new.extend(r)
             else:
                 new.append(child)
@@ -200,7 +198,7 @@ def visit(self, elem):
         uri = elem.tag.uri
         name = self.namespaces_visit.get(uri, None)
         if name is not None:
-            n = 'visit_' + name
+            n = "visit_" + name
             f = getattr(self, n, None)
             if f is not None:
                 return f(elem)
@@ -209,7 +207,7 @@ def visit(self, elem):
         return self.new_copy(elem.tag, elem)
 
     def visit_moinpage(self, elem):
-        n = 'visit_moinpage_' + elem.tag.name.replace('-', '_')
+        n = "visit_moinpage_" + elem.tag.name.replace("-", "_")
         f = getattr(self, n, None)
         if f:
             return f(elem)
@@ -222,7 +220,7 @@ def visit_moinpage_a(self, elem):
         href = elem.get(xlink.href)
         if href:
             attrib[html.href] = href
-        if len(elem) == 1 and isinstance(elem[0], str) and elem[0] == '':
+        if len(elem) == 1 and isinstance(elem[0], str) and elem[0] == "":
             # input similar to [[#Heading]] will create an invisible link like <a href="#Heading></a> unless we fix it
             elem[0] = href.path[1:] if href.path else href.fragment
         # html attributes are copied by default (html.target, html.class, html.download...
@@ -298,12 +296,12 @@ def visit_moinpage_h(self, elem):
         try:
             level = int(level)
         except ValueError:
-            raise ElementException('page:outline-level needs to be an integer')
+            raise ElementException("page:outline-level needs to be an integer")
         if level < 1:
             level = 1
         elif level > 6:
             level = 6
-        ret = self.new_copy(html(f'h{level}'), elem)
+        ret = self.new_copy(html(f"h{level}"), elem)
         ret.level = level
         return ret
 
@@ -312,9 +310,9 @@ def visit_moinpage_inline_part(self, elem):
 
         for item in elem:
             if item.tag.uri == moin_page:
-                if item.tag.name == 'inline-body':
+                if item.tag.name == "inline-body":
                     body = item
-                elif item.tag.name == 'error':
+                elif item.tag.name == "error":
                     error = item
 
         if body:
@@ -324,14 +322,14 @@ def visit_moinpage_inline_part(self, elem):
             if len(error):
                 ret = html.span(children=error)
             else:
-                ret = html.span(children=('Error', ))
-            ret.set(html.class_, 'moin-error')
+                ret = html.span(children=("Error",))
+            ret.set(html.class_, "moin-error")
             return ret
 
         # XXX: Move handling of namespace-less attributes into emeraldtree
-        alt = elem.get(moin_page.alt, elem.get('alt'))
+        alt = elem.get(moin_page.alt, elem.get("alt"))
         if alt:
-            return html.span(children=(alt, ))
+            return html.span(children=(alt,))
 
         return html.span()
 
@@ -343,7 +341,7 @@ def visit_moinpage_line_break(self, elem):
         return html.br()
 
     def visit_moinpage_line_blk(self, elem):
-        return self.new_copy(html.div, elem, attrib={html.class_: 'moin-line-blk'})
+        return self.new_copy(html.div, elem, attrib={html.class_: "moin-line-blk"})
 
     def visit_moinpage_line_block(self, elem):
         """
@@ -352,33 +350,33 @@ def visit_moinpage_line_block(self, elem):
         | roses are red,
         | violets are blue,
         """
-        return self.new_copy(html.div, elem, attrib={html.class_: 'moin-line-block'})
+        return self.new_copy(html.div, elem, attrib={html.class_: "moin-line-block"})
 
     def visit_moinpage_list(self, elem):
         attrib = Attributes(elem)
         attrib_new = attrib.convert()
-        generate = attrib.get('item-label-generate')
+        generate = attrib.get("item-label-generate")
 
         if generate:
-            if generate == 'ordered':
-                style = attrib.get('list-style-type')
+            if generate == "ordered":
+                style = attrib.get("list-style-type")
                 if style:
-                    if style == 'upper-alpha':
-                        attrib_new[html('class')] = 'moin-upperalpha-list'
-                    elif style == 'upper-roman':
-                        attrib_new[html('class')] = 'moin-upperroman-list'
-                    elif style == 'lower-roman':
-                        attrib_new[html('class')] = 'moin-lowerroman-list'
-                    elif style == 'lower-alpha':
-                        attrib_new[html('class')] = 'moin-loweralpha-list'
-                start_number = attrib.get('list-start')
+                    if style == "upper-alpha":
+                        attrib_new[html("class")] = "moin-upperalpha-list"
+                    elif style == "upper-roman":
+                        attrib_new[html("class")] = "moin-upperroman-list"
+                    elif style == "lower-roman":
+                        attrib_new[html("class")] = "moin-lowerroman-list"
+                    elif style == "lower-alpha":
+                        attrib_new[html("class")] = "moin-loweralpha-list"
+                start_number = attrib.get("list-start")
                 if start_number:
-                    attrib_new[html('start')] = start_number
+                    attrib_new[html("start")] = start_number
                 ret = html.ol(attrib_new)
-            elif generate == 'unordered':
-                style = attrib.get('list-style-type')
-                if style and style == 'no-bullet':
-                    attrib_new[html('class')] = 'moin-nobullet-list'
+            elif generate == "unordered":
+                style = attrib.get("list-style-type")
+                if style and style == "no-bullet":
+                    attrib_new[html("class")] = "moin-nobullet-list"
                 ret = html.ul(attrib=attrib_new)
             else:
                 raise ElementException(f'page:item-label-generate does not support "{generate}"')
@@ -387,16 +385,16 @@ def visit_moinpage_list(self, elem):
 
         for item in elem:
             if isinstance(item, ET.Element):
-                if item.tag.uri == moin_page and item.tag.name == 'list-item':
+                if item.tag.uri == moin_page and item.tag.name == "list-item":
                     if not generate:
                         for label in item:
                             if isinstance(label, ET.Element):
-                                if label.tag.uri == moin_page and label.tag.name == 'list-item-label':
+                                if label.tag.uri == moin_page and label.tag.name == "list-item-label":
                                     ret_label = self.new_copy(html.dt, label)
                                     ret.append(ret_label)
                     for body in item:
                         if isinstance(body, ET.Element):
-                            if body.tag.uri == moin_page and body.tag.name == 'list-item-body':
+                            if body.tag.uri == moin_page and body.tag.name == "list-item-body":
                                 if generate:
                                     ret_body = self.new_copy(html.li, body)
                                 else:
@@ -418,9 +416,9 @@ def visit_moinpage_list_item(self, elem):
         ret = html.dl(attrib=attrib_new)
         for item in elem:
             if isinstance(item, ET.Element) and item.tag.uri == moin_page:
-                if item.tag.name == 'list-item-label':
+                if item.tag.name == "list-item-label":
                     ret.append(self.new_copy(html.dt, item))
-                elif item.tag.name == 'list-item-body':
+                elif item.tag.name == "list-item-body":
                     ret.append(self.new_copy(html.dd, item))
         return ret
 
@@ -428,11 +426,11 @@ def eval_object_type(self, mimetype, href):
         """
         Returns the type of an object as a str, one of the following: img, video, audio, object
         """
-        if Type('image/').issupertype(mimetype):
+        if Type("image/").issupertype(mimetype):
             return "img"
-        elif Type('video/').issupertype(mimetype):
+        elif Type("video/").issupertype(mimetype):
             return "video"
-        elif Type('audio/').issupertype(mimetype):
+        elif Type("audio/").issupertype(mimetype):
             return "audio"
         else:
             # Nothing else worked...try using <object>
@@ -448,10 +446,10 @@ def visit_moinpage_object(self, elem):
         href = elem.get(xlink.href, None)
         attrib = {}
 
-        whitelist = ['width', 'height', 'alt', 'class', 'data-href', 'style', 'title']
+        whitelist = ["width", "height", "alt", "class", "data-href", "style", "title"]
         for key in elem.attrib:
             if key.name in whitelist:
-                if key.name == 'style':
+                if key.name == "style":
                     attrib[key] = style_attr_filter(elem.attrib[key])
                 else:
                     attrib[key] = elem.attrib[key]
@@ -472,7 +470,7 @@ def visit_moinpage_object(self, elem):
             # Set the attribute of the returned element appropriately
             attrib[attr] = href
         alt = convert_getlink_to_showlink(str(href))
-        alt = re.sub(r'^/', '', alt)
+        alt = re.sub(r"^/", "", alt)
 
         if obj_type == "img":
             # Images must have alt attribute in html5, but if user did not specify then default to url
@@ -483,7 +481,7 @@ def visit_moinpage_object(self, elem):
         else:
             if obj_type != "object":
                 # Non-objects like video and audio have the "controls" attribute
-                attrib[html.controls] = 'controls'
+                attrib[html.controls] = "controls"
                 new_elem = self.new_copy(getattr(html, obj_type), elem, attrib)
             else:
                 # is an object
@@ -492,15 +490,15 @@ def visit_moinpage_object(self, elem):
             # alt text will be transclusion alt field, item meta summary, or item name
             if new_elem.attrib.get(html.alt):
                 if new_elem.text:
-                    new_elem.append(' - ')
+                    new_elem.append(" - ")
                 new_elem.append(new_elem.attrib.get(html.alt))
                 del new_elem.attrib[html.alt]
             else:
                 if new_elem.text:
-                    new_elem.append(' - ')
+                    new_elem.append(" - ")
                 new_elem.append(alt)
 
-        if obj_type == "object" and getattr(href, 'scheme', None):
+        if obj_type == "object" and getattr(href, "scheme", None):
             # items similar to {{http://moinmo.in}} are marked here, other objects are marked in include.py
             return mark_item_as_transclusion(new_elem, href)
         return new_elem
@@ -510,20 +508,20 @@ def visit_moinpage_p(self, elem):
 
     def visit_moinpage_page(self, elem):
         for item in elem:
-            if item.tag.uri == moin_page and item.tag.name == 'body':
+            if item.tag.uri == moin_page and item.tag.name == "body":
                 # if this is a transcluded page, we must pass the class and data-href attribs
                 attribs = elem.attrib.copy()
                 if moin_page.page_href in attribs:
                     del attribs[moin_page.page_href]
                 if attribs and len(item) == 1:
 
-                    if item[0].tag.name in ('object', 'a'):
+                    if item[0].tag.name in ("object", "a"):
                         # png, jpg, gif are objects here, will be changed to img when they are processed
                         # transclusion is a single inline element "My pet {{bird.jpg}} flys." or
                         # "[[SomePage|{{Logo.png}}]]"
                         return self.new_copy(html.span, item, attribs)
 
-                    elif item[0].tag.name == 'p':
+                    elif item[0].tag.name == "p":
                         # transclusion is a single p-tag that can be coerced to inline  "Yes, we have {{no}} bananas."
                         new_span = html.span(children=item[0][:])
                         return self.new_copy(html.span, new_span, attribs)
@@ -531,34 +529,34 @@ def visit_moinpage_page(self, elem):
                 # transclusion is a block element
                 return self.new_copy(html.div, item, attribs)
 
-        raise RuntimeError(f'page:page need to contain exactly one page:body tag, got {elem[:]!r}')
+        raise RuntimeError(f"page:page need to contain exactly one page:body tag, got {elem[:]!r}")
 
     def visit_moinpage_part(self, elem):
         body = error = None
 
         for item in elem:
             if item.tag.uri == moin_page:
-                if item.tag.name == 'body':
+                if item.tag.name == "body":
                     body = item
-                elif item.tag.name == 'error':
+                elif item.tag.name == "error":
                     error = item
 
         if body:
             # returning a Div styled like a P avoids HTML validation errors
-            return self.new_copy(html.div, item, attrib={html.class_: 'moin-p'})
+            return self.new_copy(html.div, item, attrib={html.class_: "moin-p"})
 
         elif error:
             if len(error):
                 ret = html.p(children=error)
             else:
-                ret = html.p(children=('Error', ))
-            ret.set(html.class_, 'moin-error')
+                ret = html.p(children=("Error",))
+            ret.set(html.class_, "moin-error")
             return ret
 
         # XXX: Move handling of namespace-less attributes into emeraldtree
-        alt = elem.get(moin_page.alt, elem.get('alt'))
+        alt = elem.get(moin_page.alt, elem.get("alt"))
         if alt:
-            return html.p(children=(alt, ))
+            return html.p(children=(alt,))
 
         return html.p()
 
@@ -576,31 +574,31 @@ def visit_moinpage_span(self, elem):
         # Check for the attributes of span
         attrib = Attributes(elem)
         # Check for the baseline-shift (subscript or superscript)
-        generate = attrib.get('baseline-shift')
+        generate = attrib.get("baseline-shift")
         if generate:
-            if generate == 'sub':
+            if generate == "sub":
                 return self.new_copy(html.sub, elem)
-            elif generate == 'super':
+            elif generate == "super":
                 return self.new_copy(html.sup, elem)
-        generate = attrib.get('font-size')
+        generate = attrib.get("font-size")
         if generate:
-            if generate == '85%':
+            if generate == "85%":
                 attribute = {}
-                key = html('class')
-                attribute[key] = 'moin-small'
+                key = html("class")
+                attribute[key] = "moin-small"
                 return self.new_copy(html.span, elem, attribute)
-            elif generate == '120%':
+            elif generate == "120%":
                 attribute = {}
-                key = html('class')
-                attribute[key] = 'moin-big'
+                key = html("class")
+                attribute[key] = "moin-big"
                 return self.new_copy(html.span, elem, attribute)
-        generate = attrib.get('element')
+        generate = attrib.get("element")
         if generate:
             if generate in self.direct_inline_tags:
                 return self.new_copy(html(generate), elem)
             else:
                 attribute = {}
-                key = html('class')
+                key = html("class")
                 attribute[key] = f"element-{generate}"
                 return self.new_copy(html.span, elem, attribute)
         # If no attributes are handled by our converter, just return span
@@ -615,11 +613,11 @@ def visit_moinpage_strong(self, elem):
     def visit_moinpage_table(self, elem):
         attrib = Attributes(elem).convert()
         ret = html.table(attrib=attrib)
-        caption = 1 if elem[0].tag.name == 'caption' else 0
+        caption = 1 if elem[0].tag.name == "caption" else 0
         for idx, item in enumerate(elem):
             tag = None
             if item.tag.uri == moin_page:
-                if len(elem) > 1 + caption and html('class') in attrib and 'moin-wiki-table' in attrib[html('class')]:
+                if len(elem) > 1 + caption and html("class") in attrib and "moin-wiki-table" in attrib[html("class")]:
                     # moinwiki tables require special handling because
                     # moinwiki_in converts "||header||\n===\n||body||\n===\n||footer||" into multiple table-body's
                     if idx == 0 + caption:
@@ -630,16 +628,15 @@ def visit_moinpage_table(self, elem):
                         tag = html.tfoot
                     else:
                         tag = html.caption if (caption and idx == 0) else html.tbody
-                elif item.tag.name == 'table-body':
+                elif item.tag.name == "table-body":
                     tag = html.tbody
-                elif item.tag.name == 'table-header':
+                elif item.tag.name == "table-header":
                     tag = html.thead
-                elif item.tag.name == 'table-footer':
+                elif item.tag.name == "table-footer":
                     tag = html.tfoot
-                elif item.tag.name == 'caption':
+                elif item.tag.name == "caption":
                     tag = html.caption
-            elif item.tag.uri == html and \
-                    item.tag.name in ('tbody', 'thead', 'tfoot'):
+            elif item.tag.uri == html and item.tag.name in ("tbody", "thead", "tfoot"):
                 tag = item.tag
             if tag is not None:
                 ret.append(self.new_copy(tag, item))
@@ -677,7 +674,7 @@ def gen_text(self, text):
         nr = self._ids[id] = self._ids.get(id, 0) + 1
         if nr == 1:
             return id
-        return id + f'-{nr}'
+        return id + f"-{nr}"
 
 
 class SpecialPage:
@@ -693,11 +690,9 @@ def remove_footnotes(self):
         self._footnotes = []
 
     def add_heading(self, elem, level, id=None):
-        elem.append(html.a(attrib={
-            html.href: f"#{id}",
-            html.class_: "moin-permalink",
-            html.title_: _("Link to this heading")
-        }))
+        elem.append(
+            html.a(attrib={html.href: f"#{id}", html.class_: "moin-permalink", html.title_: _("Link to this heading")})
+        )
         self._headings.append((elem, level, id))
 
     def add_toc(self, elem, maxlevel):
@@ -756,13 +751,17 @@ def __call__(self, element):
                 headings_list = [h[1] for h in headings]
                 if headings_list:
                     maxlevel = max(headings_list)
-                headtogglelink = html.a(attrib={
-                    html.class_: 'moin-showhide',
-                    html.href_: '#',
-                    html.onclick_: "$('.moin-table-of-contents ol').toggle();return false;",
-                }, children=['[+]', ])
-                elem_h = html.div(attrib={html.class_: 'moin-table-of-contents-heading'},
-                                  children=[_('Contents'), headtogglelink])
+                headtogglelink = html.a(
+                    attrib={
+                        html.class_: "moin-showhide",
+                        html.href_: "#",
+                        html.onclick_: "$('.moin-table-of-contents ol').toggle();return false;",
+                    },
+                    children=["[+]"],
+                )
+                elem_h = html.div(
+                    attrib={html.class_: "moin-table-of-contents-heading"}, children=[_("Contents"), headtogglelink]
+                )
                 elem.append(elem_h)
                 stack = [elem]
 
@@ -777,7 +776,7 @@ def stack_top_append(elem):
                 old_toggle = ""
                 for elem, level, id in headings:
                     need_item = last_level >= level
-                    text = ''.join(elem.itertext())
+                    text = "".join(elem.itertext())
                     while last_level > level:
                         stack.pop()
                         stack.pop()
@@ -786,17 +785,20 @@ def stack_top_append(elem):
                         if maxlevel != 1:
                             stack_top_append(old_toggle)
                         stack_push(html.ol())
-                        stack_push(html.li({html.id_: f'li{id}'}))
+                        stack_push(html.li({html.id_: f"li{id}"}))
                         last_level += 1
                     if need_item:
                         stack.pop()
-                        stack_push(html.li({html.id_: f'li{id}'}))
-                    togglelink = html.a(attrib={
-                        html.href_: "#",
-                        html.onclick_: f"$('#li{id} ol').toggle();return false;",
-                        html.class_: 'moin-showhide',
-                    }, children=["[+]", ])
-                    elem_a = html.a(attrib={html.href: '#' + id}, children=[text, ])
+                        stack_push(html.li({html.id_: f"li{id}"}))
+                    togglelink = html.a(
+                        attrib={
+                            html.href_: "#",
+                            html.onclick_: f"$('#li{id} ol').toggle();return false;",
+                            html.class_: "moin-showhide",
+                        },
+                        children=["[+]"],
+                    )
+                    elem_a = html.a(attrib={html.href: "#" + id}, children=[text])
                     stack_top_append(elem_a)
                     old_toggle = togglelink
         return ret
@@ -821,11 +823,11 @@ def visit_moinpage_h(self, elem, _tag_html_id=html.id):
 
         id = elem.get(_tag_html_id)
         if not id:
-            id = self._id.gen_text(''.join(elem.itertext()))
+            id = self._id.gen_text("".join(elem.itertext()))
             elem.set(_tag_html_id, id)
         try:
             # do not create duplicate anchors to this heading when converting from one markup to another
-            if not elem[-1].attrib[html.class_] == 'moin-permalink':
+            if not elem[-1].attrib[html.class_] == "moin-permalink":
                 self._special_stack[-1].add_heading(elem, elem.level, id)
         except (AttributeError, KeyError):
             self._special_stack[-1].add_heading(elem, elem.level, id)
@@ -848,31 +850,39 @@ def visit_moinpage_note(self, elem):
 
             footnotes_div = self.create_footnotes(top)
             top.remove_footnotes()
-            self._id.zero_id('note')
+            self._id.zero_id("note")
             # bump note-placement counter to insure unique footnote ids
-            self._id.gen_id('note-placement')
+            self._id.gen_id("note-placement")
             return footnotes_div
 
         body = None
         for child in elem:
             if child.tag.uri == moin_page:
-                if child.tag.name == 'note-body':
+                if child.tag.name == "note-body":
                     body = self.do_children(child)
 
-        id = self._id.gen_id('note')
-        prefixed_id = '%s-%s' % (self._id.get_id('note-placement'), id)
+        id = self._id.gen_id("note")
+        prefixed_id = "%s-%s" % (self._id.get_id("note-placement"), id)
 
-        elem_ref = ET.XML("""
+        elem_ref = ET.XML(
+            """
 <html:sup xmlns:html="{}" html:id="note-{}-ref" html:class="moin-footnote">
 <html:a html:href="#note-{}">{}</html:a>
 </html:sup>
-""".format(html, prefixed_id, prefixed_id, id))
+""".format(
+                html, prefixed_id, prefixed_id, id
+            )
+        )
 
-        elem_note = ET.XML("""
+        elem_note = ET.XML(
+            """
 <html:p xmlns:html="{}" html:id="note-{}">
 <html:sup><html:a html:href="#note-{}-ref">{}</html:a></html:sup>
 </html:p>
-""".format(html, prefixed_id, prefixed_id, id))
+""".format(
+                html, prefixed_id, prefixed_id, id
+            )
+        )
 
         elem_note.extend(body)
         top.add_footnote(elem_note)
@@ -887,7 +897,7 @@ def visit_moinpage_table_of_content(self, elem):
             level = 6
 
         attribs = elem.attrib.copy()
-        attribs[html.class_] = 'moin-table-of-contents'
+        attribs[html.class_] = "moin-table-of-contents"
         elem = html.div(attrib=attribs)
 
         self._special_stack[-1].add_toc(elem, level)
@@ -900,4 +910,4 @@ class ConverterDocument(ConverterPage):
     """
 
 
-default_registry.register(ConverterPage._factory, type_moin_document, Type('application/x-xhtml-moin-page'))
+default_registry.register(ConverterPage._factory, type_moin_document, Type("application/x-xhtml-moin-page"))
diff --git a/src/moin/converters/image_in.py b/src/moin/converters/image_in.py
index e28a07702..d8d1a8525 100644
--- a/src/moin/converters/image_in.py
+++ b/src/moin/converters/image_in.py
@@ -23,6 +23,7 @@ class Converter:
     """
     Convert an image to the corresponding <object> in the DOM Tree
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls(input_type=input)
@@ -32,7 +33,7 @@ def __init__(self, input_type):
 
     def __call__(self, rev, contenttype=None, arguments=None):
         item_name = rev.item.name
-        query_keys = {'do': 'get', 'rev': rev.revid}
+        query_keys = {"do": "get", "rev": rev.revid}
         attrib = {}
         if arguments:
             query = arguments.keyword.get(xinclude.href)
@@ -43,19 +44,21 @@ def __call__(self, rev, contenttype=None, arguments=None):
 
         query = urlencode(query_keys, encoding=CHARSET)
 
-        attrib.update({
-            moin_page.type_: str(self.input_type),
-            xlink.href: Iri(scheme='wiki', authority='', path='/' + rev.item.fqname.fullname, query=query),
-        })
+        attrib.update(
+            {
+                moin_page.type_: str(self.input_type),
+                xlink.href: Iri(scheme="wiki", authority="", path="/" + rev.item.fqname.fullname, query=query),
+            }
+        )
         if rev.meta.get(SUMMARY) and html.alt not in attrib:
             attrib[html.alt] = rev.meta[SUMMARY]
 
-        obj = moin_page.object_(attrib=attrib, children=[item_name, ])
-        body = moin_page.body(children=(obj, ))
-        return moin_page.page(children=(body, ))
+        obj = moin_page.object_(attrib=attrib, children=[item_name])
+        body = moin_page.body(children=(obj,))
+        return moin_page.page(children=(body,))
 
 
-default_registry.register(Converter._factory, Type('image/svg+xml'), type_moin_document)
-default_registry.register(Converter._factory, Type('image/png'), type_moin_document)
-default_registry.register(Converter._factory, Type('image/jpeg'), type_moin_document)
-default_registry.register(Converter._factory, Type('image/gif'), type_moin_document)
+default_registry.register(Converter._factory, Type("image/svg+xml"), type_moin_document)
+default_registry.register(Converter._factory, Type("image/png"), type_moin_document)
+default_registry.register(Converter._factory, Type("image/jpeg"), type_moin_document)
+default_registry.register(Converter._factory, Type("image/gif"), type_moin_document)
diff --git a/src/moin/converters/include.py b/src/moin/converters/include.py
index 641c1b829..b65704268 100644
--- a/src/moin/converters/include.py
+++ b/src/moin/converters/include.py
@@ -110,20 +110,21 @@
 from ._args import Arguments
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 # elements generated by moin wiki markup that cannot have block children
 NO_BLOCK_CHILDREN = [
-    'p',
-    'span',  # /*comment*/, ~+big+~, ~-small-~ via classes comment, moin-big, moin-small
-    'emphasis',  # ''italic''
-    'strong',  # '''bold'''
-    'del',  # --(stroke)--
-    'ins',  # __underline__
+    "p",
+    "span",  # /*comment*/, ~+big+~, ~-small-~ via classes comment, moin-big, moin-small
+    "emphasis",  # ''italic''
+    "strong",  # '''bold'''
+    "del",  # --(stroke)--
+    "ins",  # __underline__
     # 'sub',  # ,,subscript,, # no markup allowed within subscripts
     # 'sup',  # ^superscript^ # no markup allowed within superscripts
-    'a',  # [[SomeItem|{{logo.png}}]]
+    "a",  # [[SomeItem|{{logo.png}}]]
 ]
 
 
@@ -150,36 +151,36 @@ class XPointer(list):
     tokenizer_re = re.compile(tokenizer_rules, re.X)
 
     class Entry:
-        __slots__ = 'name', 'data'
+        __slots__ = "name", "data"
 
         def __init__(self, name, data):
             self.name, self.data = name, data
 
         @property
         def data_unescape(self):
-            data = self.data.replace('^(', '(').replace('^)', ')')
-            return data.replace('^^', '^')
+            data = self.data.replace("^(", "(").replace("^)", ")")
+            return data.replace("^^", "^")
 
     def __init__(self, input):
         name = []
         stack = []
 
         for match in self.tokenizer_re.finditer(input):
-            if match.group('bracket_open'):
+            if match.group("bracket_open"):
                 stack.append([])
-            elif match.group('bracket_close'):
+            elif match.group("bracket_close"):
                 top = stack.pop()
                 if stack:
-                    stack[-1].append('(')
+                    stack[-1].append("(")
                     stack[-1].extend(top)
-                    stack[-1].append(')')
+                    stack[-1].append(")")
                 else:
-                    self.append(self.Entry(''.join(name), ''.join(top)))
+                    self.append(self.Entry("".join(name), "".join(top)))
                     name = []
             else:
                 if stack:
                     stack[-1].append(match.group())
-                elif not match.group('whitespace'):
+                elif not match.group("whitespace"):
                     name.append(match.group())
 
         while len(stack) > 1:
@@ -187,14 +188,14 @@ def __init__(self, input):
             stack[-1].extend(top)
 
         if name:
-            self.append(self.Entry(''.join(name), None))
+            self.append(self.Entry("".join(name), None))
 
 
 class Converter:
 
     @classmethod
     def _factory(cls, input, output, includes=None, **kw):
-        if includes == 'expandall':
+        if includes == "expandall":
             return cls()
 
     def recurse(self, elem, page_href):
@@ -235,17 +236,17 @@ def recurse(self, elem, page_href):
                     xp_namespaces = {}
                     for entry in xp:
                         uri = None
-                        name = entry.name.split(':', 1)
+                        name = entry.name.split(":", 1)
                         if len(name) > 1:
                             prefix, name = name
                             uri = xp_namespaces.get(prefix, False)
                         else:
                             name = name[0]
 
-                        if uri is None and name == 'xmlns':
-                            d_prefix, d_uri = entry.data.split('=', 1)
+                        if uri is None and name == "xmlns":
+                            d_prefix, d_uri = entry.data.split("=", 1)
                             xp_namespaces[d_prefix] = d_uri
-                        elif uri == moin_page.namespace and name == 'include':
+                        elif uri == moin_page.namespace and name == "include":
                             xp_include = XPointer(entry.data)
 
                     if xp_include:
@@ -255,38 +256,38 @@ def recurse(self, elem, page_href):
                             # <<Include(pagename, heading, level, from="regex", to="regex", sort=ascending|descending,
                             #           items=n, skipitems=n, titlesonly, editlink)>>
                             # these are currently unsupported in moin 2.0: from, to, titlesonly, editlink
-                            if name == 'pages':  # pages == pagename in moin 1.9
+                            if name == "pages":  # pages == pagename in moin 1.9
                                 xp_include_pages = data
-                            elif name == 'sort':
+                            elif name == "sort":
                                 xp_include_sort = data
-                            elif name == 'items':
+                            elif name == "items":
                                 xp_include_items = int(data)
-                            elif name == 'skipitems':
+                            elif name == "skipitems":
                                 xp_include_skipitems = int(data)
-                            elif name == 'heading':
+                            elif name == "heading":
                                 xp_include_heading = data
-                            elif name == 'level':
+                            elif name == "level":
                                 xp_include_level = data
 
                 included_elements = []
                 if href:
                     # We have a single page to transclude or include
                     href = Iri(href)
-                    link = Iri(scheme='wiki', authority='')
-                    if href.scheme == 'wiki':
+                    link = Iri(scheme="wiki", authority="")
+                    if href.scheme == "wiki":
                         if href.authority:
                             raise ValueError("can't handle xinclude for non-local authority")
                         else:
                             path = href.path[1:]
-                    elif href.scheme == 'wiki.local':
+                    elif href.scheme == "wiki.local":
                         page = page_href
                         path = href.path
-                        if path[0] == '':
+                        if path[0] == "":
                             # /subitem
                             tmp = page.path[1:]
                             tmp.extend(path[1:])
                             path = tmp
-                        elif path[0] == '..':
+                        elif path[0] == "..":
                             # ../sisteritem
                             path = page.path[1:] + path[1:]
                     else:
@@ -296,51 +297,51 @@ def recurse(self, elem, page_href):
 
                     if flaskg.user.may.read(str(path)):
                         page = Item.create(str(path))
-                        pages = ((page, link), )
+                        pages = ((page, link),)
                     else:
                         # ACLs prevent user from viewing a transclusion - show message
-                        message = moin_page.p(children=(_('Access Denied, transcluded content suppressed.')))
-                        attrib = {html.class_: 'warning moin-read-denied'}
-                        div = ET.Element(moin_page.div, attrib, children=(message, ))
-                        container = ET.Element(moin_page.body, children=(div, ))
+                        message = moin_page.p(children=(_("Access Denied, transcluded content suppressed.")))
+                        attrib = {html.class_: "warning moin-read-denied"}
+                        div = ET.Element(moin_page.div, attrib, children=(message,))
+                        container = ET.Element(moin_page.body, children=(div,))
                         return [container, 0]  # replace transclusion with container's child
 
                 elif xp_include_pages:
                     # we have regex of pages to include:  <<Include(^qqq)>>
                     query = And([Term(WIKINAME, app.cfg.interwikiname), Regex(NAME_EXACT, xp_include_pages)])
-                    reverse = xp_include_sort == 'descending'
+                    reverse = xp_include_sort == "descending"
                     results = flaskg.storage.search(query, sortedby=NAME_EXACT, reverse=reverse, limit=None)
                     pagelist = [result.fqname.fullname for result in results]
                     if xp_include_skipitems is not None:
                         pagelist = pagelist[xp_include_skipitems:]
                     if xp_include_items is not None:
-                        pagelist = pagelist[xp_include_items + 1:]
-                    pages = ((Item.create(p), Iri(scheme='wiki', authority='', path='/' + p)) for p in pagelist)
+                        pagelist = pagelist[xp_include_items + 1 :]
+                    pages = ((Item.create(p), Iri(scheme="wiki", authority="", path="/" + p)) for p in pagelist)
                     if not pagelist:
                         msg = _('Error: no items found matching "<<Include({0})>>"').format(xp_include_pages)
-                        attrib = {html.class_: 'moin-error'}
-                        strong = ET.Element(moin_page.strong, attrib, (msg, ))
+                        attrib = {html.class_: "moin-error"}
+                        strong = ET.Element(moin_page.strong, attrib, (msg,))
                         included_elements.append(strong)
 
                 for page, p_href in pages:
-                    if p_href.path[0] != '/':
-                        p_href.path = IriPath('/' + '/'.join(p_href.path))
+                    if p_href.path[0] != "/":
+                        p_href.path = IriPath("/" + "/".join(p_href.path))
                     if p_href in self.stack:
                         # we have a transclusion loop, create an error message showing list of pages forming loop
-                        loop = self.stack[self.stack.index(p_href):]
-                        loop = [f'{ref.path[1:]}' for ref in loop if ref is not None] + [page.name]
-                        msg = 'Error: Transclusion loop via: ' + ', '.join(loop)
-                        attrib = {html.class_: 'moin-error'}
-                        strong = ET.Element(moin_page.strong, attrib, (msg, ))
+                        loop = self.stack[self.stack.index(p_href) :]
+                        loop = [f"{ref.path[1:]}" for ref in loop if ref is not None] + [page.name]
+                        msg = "Error: Transclusion loop via: " + ", ".join(loop)
+                        attrib = {html.class_: "moin-error"}
+                        strong = ET.Element(moin_page.strong, attrib, (msg,))
                         included_elements.append(strong)
                         continue
 
                     if xp_include_heading is not None:
                         attrib = {xlink.href: p_href}
-                        children = (xp_include_heading or page.name, )
+                        children = (xp_include_heading or page.name,)
                         elem_a = ET.Element(moin_page.a, attrib, children=children)
-                        attrib = {moin_page.outline_level: xp_include_level or '1'}
-                        elem_h = ET.Element(moin_page.h, attrib, children=(elem_a, ))
+                        attrib = {moin_page.outline_level: xp_include_level or "1"}
+                        elem_h = ET.Element(moin_page.h, attrib, children=(elem_a,))
                         included_elements.append(elem_h)
 
                     page_doc = page.content.internal_representation(attributes=Arguments(keyword=elem.attrib))
@@ -381,8 +382,9 @@ def recurse(self, elem, page_href):
                                 # the transcluded item is empty, insert an empty span into DOM
                                 attrib = Attributes(ret).convert()
                                 elem[i] = ET.Element(moin_page.span, attrib=attrib)
-                            elif (isinstance(body[0], ET.Node) and
-                                  (len(body) > 1 or body[0].tag.name not in ('p', 'object', 'a'))):
+                            elif isinstance(body[0], ET.Node) and (
+                                len(body) > 1 or body[0].tag.name not in ("p", "object", "a")
+                            ):
                                 # Complex case: "some text {{BlockItem}} more text" or "\n{{BlockItem}}\n" where
                                 # the BlockItem body contains multiple p's, a table, preformatted text, etc.
                                 # These block elements cannot be made a child of the current elem, so we create
@@ -391,7 +393,7 @@ def recurse(self, elem, page_href):
                                 before = copy.deepcopy(elem)
                                 after = copy.deepcopy(elem)
                                 before[:] = elem[0:i]
-                                after[:] = elem[i + 1:]
+                                after[:] = elem[i + 1 :]
                                 if len(before):
                                     # there are siblings before transclude, save them in container
                                     container.append(before)
@@ -407,7 +409,7 @@ def recurse(self, elem, page_href):
                                 container.append(div)  # new_trans_ptr is index to this
                                 if len(after):
                                     container.append(after)
-                                if elem.tag.name == 'a':
+                                if elem.tag.name == "a":
                                     # invalid input [[MyPage|{{BlockItem}}]],
                                     # best option is to retain A-tag and fail html validation
                                     # TODO: error may not be obvious to user - add error message
@@ -419,9 +421,9 @@ def recurse(self, elem, page_href):
                             else:
                                 # default action for inline transclusions or odd things like
                                 # circular transclusion error messages
-                                classes = child.attrib.get(html.class_, '').split()
-                                classes += ret.attrib.get(html.class_, '').split()
-                                ret.attrib[html.class_] = ' '.join(classes)
+                                classes = child.attrib.get(html.class_, "").split()
+                                classes += ret.attrib.get(html.class_, "").split()
+                                ret.attrib[html.class_] = " ".join(classes)
                                 elem[i] = ret
                         elif isinstance(ret, list):
                             # a container has been returned.
@@ -436,15 +438,15 @@ def recurse(self, elem, page_href):
                                 before = copy.deepcopy(elem)
                                 after = copy.deepcopy(elem)
                                 before[:] = elem[0:i] + ret_container[0:trans_ptr]
-                                after[:] = ret_container[trans_ptr + 1:] + elem[i + 1:]
+                                after[:] = ret_container[trans_ptr + 1 :] + elem[i + 1 :]
                                 if len(before):
                                     container.append(before)
                                 new_trans_ptr = len(container)
                                 # child may have classes like "comment" that must be added to transcluded element
-                                classes = child.attrib.get(moin_page.class_, '').split()
+                                classes = child.attrib.get(moin_page.class_, "").split()
                                 # must use moin_page.class_ above, but use html.class below per html_out.py code
-                                classes += ret_container[trans_ptr].attrib.get(html.class_, '').split()
-                                ret_container[trans_ptr].attrib[html.class_] = ' '.join(classes)
+                                classes += ret_container[trans_ptr].attrib.get(html.class_, "").split()
+                                ret_container[trans_ptr].attrib[html.class_] = " ".join(classes)
                                 container.append(ret_container[trans_ptr])  # the transclusion
                                 if len(after):
                                     container.append(after)
@@ -452,13 +454,13 @@ def recurse(self, elem, page_href):
                             else:
                                 # elem is a block element
                                 for grandchild in child:
-                                    if isinstance(grandchild, ET.Node) and grandchild.tag.name == 'include':
+                                    if isinstance(grandchild, ET.Node) and grandchild.tag.name == "include":
                                         # the include may have classes that must be added to transcluded element
-                                        classes = grandchild.attrib.get(html.class_, '').split()
-                                        classes += ret_container[trans_ptr].attrib.get(html.class_, '').split()
-                                        ret_container[trans_ptr].attrib[html.class_] = ' '.join(classes)
+                                        classes = grandchild.attrib.get(html.class_, "").split()
+                                        classes += ret_container[trans_ptr].attrib.get(html.class_, "").split()
+                                        ret_container[trans_ptr].attrib[html.class_] = " ".join(classes)
                                 # replace child element with the container generated in lower recursion
-                                elem[i:i + 1] = ret_container  # elem[i] is the child
+                                elem[i : i + 1] = ret_container  # elem[i] is the child
                         else:
                             # default action for any ret not fitting special cases above,
                             # e.g. tranclusion is within a table cell
diff --git a/src/moin/converters/link.py b/src/moin/converters/link.py
index 062eaf754..919a1b9f8 100644
--- a/src/moin/converters/link.py
+++ b/src/moin/converters/link.py
@@ -47,9 +47,15 @@ def __call__(self, *args, **kw):
         # because it is also called in subclasses
         return self.traverse_tree(*args, **kw)
 
-    def traverse_tree(self, elem, page=None, __tag_page_href=moin_page.page_href,
-                      __tag_link=_tag_xlink_href, __tag_include=_tag_xinclude_href,
-                      __tag_data_href=_tag_html_data_href):
+    def traverse_tree(
+        self,
+        elem,
+        page=None,
+        __tag_page_href=moin_page.page_href,
+        __tag_link=_tag_xlink_href,
+        __tag_include=_tag_xinclude_href,
+        __tag_data_href=_tag_html_data_href,
+    ):
         """
         Traverses the tree and handles each element appropriately
         """
@@ -63,23 +69,23 @@ def traverse_tree(self, elem, page=None, __tag_page_href=moin_page.page_href,
         for href, to_tag in (xlink_href, self._tag_xlink_href), (data_href, self._tag_html_data_href):
             if href:
                 href = Iri(href)
-                if href.scheme == 'wiki.local':
+                if href.scheme == "wiki.local":
                     self.handle_wikilocal_links(elem, href, page, to_tag)
-                elif href.scheme == 'wiki':
+                elif href.scheme == "wiki":
                     self.handle_wiki_links(elem, href, to_tag)
                 elif href.scheme:
                     self.handle_external_links(elem, href, to_tag)
 
         if not xlink_href and xinclude_href:
             xinclude_href = Iri(xinclude_href)
-            if xinclude_href.scheme == 'wiki.local':
+            if xinclude_href.scheme == "wiki.local":
                 self.handle_wikilocal_transclusions(elem, xinclude_href, page)
-            elif xinclude_href.scheme == 'wiki':
+            elif xinclude_href.scheme == "wiki":
                 self.handle_wiki_transclusions(elem, xinclude_href)
 
-        elif xlink_href == '':
+        elif xlink_href == "":
             # reST link to page fragment
-            elem.set(self._tag_xlink_href, '#' + elem.text.replace(' ', '_'))
+            elem.set(self._tag_xlink_href, "#" + elem.text.replace(" ", "_"))
 
         for child in elem.iter_elements():
             self.traverse_tree(child, page)
@@ -102,7 +108,7 @@ def absolute_path(self, path, current_page_path):
         quoted_current_page_path = current_page_path[1:].quoted
 
         abs_path = AbsItemName(quoted_current_page_path, quoted_path)
-        if quoted_path.startswith('/'):
+        if quoted_path.startswith("/"):
             # avoid Iri issue where item name containing a colon is mistaken for scheme:path
             abs_path = Iri(path=abs_path).path
         return abs_path
@@ -111,7 +117,7 @@ def absolute_path(self, path, current_page_path):
 class ConverterExternOutput(ConverterBase):
     @classmethod
     def _factory(cls, input, output, links=None, **kw):
-        if links == 'extern':
+        if links == "extern":
             return cls()
 
     def _get_do_rev(self, query):
@@ -125,48 +131,48 @@ def _get_do_rev(self, query):
         """
         do = None
         rev = None
-        separator = '&'
+        separator = "&"
         result = []
         if query:
             for kv in query.split(separator):
                 if not kv:
                     continue
-                if '=' in kv:
-                    k, v = kv.split('=', 1)
+                if "=" in kv:
+                    k, v = kv.split("=", 1)
                 else:
-                    k, v = kv, ''
-                if k == 'do':
+                    k, v = kv, ""
+                if k == "do":
                     do = v
                     continue  # we remove do=xxx from qs
-                if k == 'rev':
+                if k == "rev":
                     rev = v
                     continue  # we remove rev=n from qs
-                result.append(f'{k}={v}')
+                result.append(f"{k}={v}")
         if result:
             query = separator.join(result)
         else:
             query = None
         do_to_endpoint = dict(
-            show='frontend.show_item',
-            get='frontend.get_item',
-            download='frontend.download_item',
-            modify='frontend.modify_item',
+            show="frontend.show_item",
+            get="frontend.get_item",
+            download="frontend.download_item",
+            modify="frontend.modify_item",
             # TODO: if we just always used same function name as do=name, we did not need this dict
             # ...
         )
-        endpoint = do_to_endpoint[do or 'show']
+        endpoint = do_to_endpoint[do or "show"]
         return endpoint, rev, query
 
     def handle_wiki_links(self, elem, input, to_tag=ConverterBase._tag_xlink_href):
-        wiki_name = 'Self'
+        wiki_name = "Self"
         if input.authority and input.authority.host:
             wn = str(input.authority.host)
             if is_known_wiki(wn):
                 # interwiki link
                 if html.class_ in elem.attrib:
-                    elem.set(moin_page.class_, 'moin-interwiki ' + elem.attrib[html.class_])
+                    elem.set(moin_page.class_, "moin-interwiki " + elem.attrib[html.class_])
                 else:
-                    elem.set(moin_page.class_, 'moin-interwiki')
+                    elem.set(moin_page.class_, "moin-interwiki")
                 wiki_name = wn
                 elem.set(moin_page.title_, wn)
         item_name = str(input.path[1:])
@@ -184,9 +190,9 @@ def handle_wikilocal_links(self, elem, input, page, to_tag=ConverterBase._tag_xl
             item_name = str(path)
             if not flaskg.storage.has_item(item_name):
                 # XXX these index accesses slow down the link converter quite a bit
-                elem.set(moin_page.class_, 'moin-nonexistent')
+                elem.set(moin_page.class_, "moin-nonexistent")
         else:
-            item_name = str(page.path[1:]) if page else ''
+            item_name = str(page.path[1:]) if page else ""
         endpoint, rev, query = self._get_do_rev(input.query)
         url = url_for_item(item_name, rev=rev, endpoint=endpoint)
         if not page:
@@ -199,16 +205,17 @@ def handle_external_links(self, elem, input, to_tag=ConverterBase._tag_xlink_hre
         # rst_in.py may create a link similar to "http:Home", we check input.authority to verify link is external
         if elem.tag == moin_page.a and input.authority:
             # adding this class enables themes to flag external links with an icon
-            elem.set(html.class_, elem.attrib.get(html.class_, '') + ' moin-' + input.scheme)
+            elem.set(html.class_, elem.attrib.get(html.class_, "") + " moin-" + input.scheme)
 
 
 class ConverterItemRefs(ConverterBase):
     """
     determine all links and transclusions to other wiki items in this document
     """
+
     @classmethod
     def _factory(cls, input, output, items=None, **kw):
-        if items == 'refs':
+        if items == "refs":
             return cls()
 
     def __init__(self, **kw):
@@ -237,7 +244,7 @@ def handle_wikilocal_links(self, elem, input, page, to_tag=ConverterBase._tag_xl
         :param page: the iri of the page where the link is
         """
         path = input.path
-        if not path or ':' in path:
+        if not path or ":" in path:
             return
 
         path = self.absolute_path(path, page.path)
@@ -251,7 +258,7 @@ def handle_wikilocal_transclusions(self, elem, input, page):
         :param page: the iri of the page where the transclusion is
         """
         path = input.path
-        if not path or ':' in path:
+        if not path or ":" in path:
             return
 
         path = self.absolute_path(path, page.path)
diff --git a/src/moin/converters/macro.py b/src/moin/converters/macro.py
index 37131d07b..747fa33bd 100644
--- a/src/moin/converters/macro.py
+++ b/src/moin/converters/macro.py
@@ -21,13 +21,14 @@
 from . import default_registry
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class Converter:
     @classmethod
     def _factory(cls, input, output, macros=None, **kw):
-        if macros == 'expandall':
+        if macros == "expandall":
             return cls()
 
     def handle_macro(self, elem, page):
@@ -39,18 +40,18 @@ def handle_macro(self, elem, page):
             return
 
         type = Type(type)
-        if not (type.type == 'x-moin' and type.subtype == 'macro'):
+        if not (type.type == "x-moin" and type.subtype == "macro"):
             logging.debug(f"not a macro, skipping: {type!r}")
             return
 
-        name = type.parameters['name']
+        name = type.parameters["name"]
         context_block = elem.tag == moin_page.part
         args = elem[0] if len(elem) else None
         elem_body = context_block and moin_page.body() or moin_page.inline_body()
         elem_error = moin_page.error()
 
         try:
-            cls = plugins.importPlugin(app.cfg, 'macros', name, function='Macro')
+            cls = plugins.importPlugin(app.cfg, "macros", name, function="Macro")
             macro = cls()
             ret = macro((), args, page, alt, context_block)
             elem_body.append(ret)
@@ -64,8 +65,11 @@ def handle_macro(self, elem, page):
             # thus, in case of exceptions, we just log the problem and return
             # some standard text.
             logging.exception(f"Macro {name} raised an exception:")
-            elem_error.append(_('<<{macro_name}: execution failed [{error_msg}] (see also the log)>>'
-                                ).format(macro_name=name, error_msg=str(e)))
+            elem_error.append(
+                _("<<{macro_name}: execution failed [{error_msg}] (see also the log)>>").format(
+                    macro_name=name, error_msg=str(e)
+                )
+            )
 
         if len(elem_body):
             elem.append(elem_body)
diff --git a/src/moin/converters/markdown_in.py b/src/moin/converters/markdown_in.py
index 9474e9546..7691c7c05 100644
--- a/src/moin/converters/markdown_in.py
+++ b/src/moin/converters/markdown_in.py
@@ -19,6 +19,7 @@
 from moin.converters.html_in import Converter as HTML_IN_Converter
 
 from emeraldtree import ElementTree as ET
+
 try:
     from flask import g as flaskg
 except ImportError:
@@ -34,10 +35,11 @@
 from moin.utils.mime import Type, type_moin_document
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 html_in_converter = HTML_IN_Converter()
-block_elements = 'p h blockcode ol ul pre address blockquote dl div fieldset form hr noscript table'.split()
+block_elements = "p h blockcode ol ul pre address blockquote dl div fieldset form hr noscript table".split()
 BLOCK_ELEMENTS = {moin_page(x) for x in block_elements}
 
 
@@ -54,13 +56,13 @@ def postproc_text(markdown, text):
     if text is None:
         return None
 
-    if text == '[TOC]':
+    if text == "[TOC]":
         return moin_page.table_of_content(attrib={})
 
     for pp in markdown.postprocessors:
         text = pp.run(text)
 
-    if text.startswith('<pre>') or text.startswith('<div class="codehilite"><pre>'):
+    if text.startswith("<pre>") or text.startswith('<div class="codehilite"><pre>'):
         return text
 
     def fixup(m):
@@ -89,52 +91,77 @@ class Converter:
     # {{{ html conversion
 
     # HTML tags which can be converted directly to the moin_page namespace
-    symmetric_tags = {'div', 'p', 'strong', 'code', 'quote', 'blockquote'}
+    symmetric_tags = {"div", "p", "strong", "code", "quote", "blockquote"}
 
     # HTML tags to define a list, except dl which is a little bit different
-    list_tags = {'ul', 'ol'}
+    list_tags = {"ul", "ol"}
 
     # HTML tags which can be convert without attributes in a different DOM tag
     simple_tags = {  # Emphasis
-        'em': moin_page.emphasis,
-        'i': moin_page.emphasis,
+        "em": moin_page.emphasis,
+        "i": moin_page.emphasis,
         # Strong
-        'b': moin_page.strong,
-        'strong': moin_page.strong,
+        "b": moin_page.strong,
+        "strong": moin_page.strong,
         # Code and Blockcode
-        'pre': moin_page.blockcode,
-        'tt': moin_page.code,
-        'samp': moin_page.code,
+        "pre": moin_page.blockcode,
+        "tt": moin_page.code,
+        "samp": moin_page.code,
         # Lists
-        'dl': moin_page.list_item,
-        'dt': moin_page.list_item_label,
-        'dd': moin_page.list_item_body,
+        "dl": moin_page.list_item,
+        "dt": moin_page.list_item_label,
+        "dd": moin_page.list_item_body,
         # Table - th and td require special processing for alignment of cell contents
-        'table': moin_page.table,
-        'thead': moin_page.table_header,
-        'tbody': moin_page.table_body,
-        'tr': moin_page.table_row,
+        "table": moin_page.table,
+        "thead": moin_page.table_header,
+        "tbody": moin_page.table_body,
+        "tr": moin_page.table_row,
     }
 
     # HTML Tag which does not have equivalence in the DOM Tree
     # But we keep the information using <span element>
-    inline_tags = {'abbr', 'acronym', 'address', 'dfn', 'kbd'}
+    inline_tags = {"abbr", "acronym", "address", "dfn", "kbd"}
 
     # HTML tags which are completely ignored by our converter.
     # We even do not process children of these elements.
-    ignored_tags = {'applet', 'area', 'button', 'caption', 'center', 'fieldset',
-                    'form', 'frame', 'frameset', 'head', 'iframe', 'input', 'isindex',
-                    'label', 'legend', 'link', 'map', 'menu', 'noframes', 'noscript',
-                    'optgroup', 'option', 'param', 'script', 'select', 'style',
-                    'textarea', 'title', 'var',
-                    }
+    ignored_tags = {
+        "applet",
+        "area",
+        "button",
+        "caption",
+        "center",
+        "fieldset",
+        "form",
+        "frame",
+        "frameset",
+        "head",
+        "iframe",
+        "input",
+        "isindex",
+        "label",
+        "legend",
+        "link",
+        "map",
+        "menu",
+        "noframes",
+        "noscript",
+        "optgroup",
+        "option",
+        "param",
+        "script",
+        "select",
+        "style",
+        "textarea",
+        "title",
+        "var",
+    }
 
     # standard_attributes are html attributes which are used
     # directly in the DOM tree, without any conversion
-    standard_attributes = {'title', 'class', 'style'}
+    standard_attributes = {"title", "class", "style"}
 
     # Regular expression to detect an html heading tag
-    heading_re = re.compile('h[1-6]')
+    heading_re = re.compile("h[1-6]")
 
     def new(self, tag, attrib, children):
         """
@@ -169,8 +196,8 @@ def convert_attributes(self, element):
         for key, value in element.attrib.items():
             if key in self.standard_attributes:
                 result[moin_page(key)] = value
-            if key == 'id':
-                result[xml('id')] = value
+            if key == "id":
+                result[xml("id")] = value
         return result
 
     def visit_heading(self, element):
@@ -179,7 +206,7 @@ def visit_heading(self, element):
         element in our moin_page namespace
         """
         heading_level = element.tag[1]
-        key = moin_page('outline-level')
+        key = moin_page("outline-level")
         attrib = {}
         attrib[key] = heading_level
         return self.new_copy(moin_page.h, element, attrib)
@@ -188,60 +215,60 @@ def visit_br(self, element):
         return moin_page.line_break()
 
     def visit_big(self, element):
-        key = moin_page('font-size')
+        key = moin_page("font-size")
         attrib = {}
-        attrib[key] = '120%'
+        attrib[key] = "120%"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_small(self, element):
-        key = moin_page('font-size')
+        key = moin_page("font-size")
         attrib = {}
-        attrib[key] = '85%'
+        attrib[key] = "85%"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_sub(self, element):
-        key = moin_page('baseline-shift')
+        key = moin_page("baseline-shift")
         attrib = {}
-        attrib[key] = 'sub'
+        attrib[key] = "sub"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_sup(self, element):
-        key = moin_page('baseline-shift')
+        key = moin_page("baseline-shift")
         attrib = {}
-        attrib[key] = 'super'
+        attrib[key] = "super"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_u(self, element):
-        key = moin_page('text-decoration')
+        key = moin_page("text-decoration")
         attrib = {}
-        attrib[key] = 'underline'
+        attrib[key] = "underline"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_ins(self, element):
-        key = moin_page('text-decoration')
+        key = moin_page("text-decoration")
         attrib = {}
-        attrib[key] = 'underline'
+        attrib[key] = "underline"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_del(self, element):
-        key = moin_page('text-decoration')
+        key = moin_page("text-decoration")
         attrib = {}
-        attrib[key] = 'line-through'
+        attrib[key] = "line-through"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_s(self, element):
-        key = moin_page('text-decoration')
+        key = moin_page("text-decoration")
         attrib = {}
-        attrib[key] = 'line-through'
+        attrib[key] = "line-through"
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_strike(self, element):
-        key = moin_page('text-decoration')
+        key = moin_page("text-decoration")
         attrib = {}
-        attrib[key] = 'line-through'
+        attrib[key] = "line-through"
         return self.new_copy(moin_page.span, element, attrib)
 
-    def visit_hr(self, element, default_class='moin-hr3'):
+    def visit_hr(self, element, default_class="moin-hr3"):
         return self.new_copy(moin_page.separator, element, {moin_page.class_: default_class})
 
     def visit_img(self, element):
@@ -249,14 +276,14 @@ def visit_img(self, element):
         <img src="URI" /> --> <object xlink:href="URI />
         """
         attrib = {}
-        url = Iri(element.attrib.get('src'))
-        if element.attrib.get('alt'):
-            attrib[html.alt] = element.attrib.get('alt')
-        if element.attrib.get('title'):
-            attrib[html.title_] = element.attrib.get('title')
+        url = Iri(element.attrib.get("src"))
+        if element.attrib.get("alt"):
+            attrib[html.alt] = element.attrib.get("alt")
+        if element.attrib.get("title"):
+            attrib[html.title_] = element.attrib.get("title")
         if url.scheme is None:
             # img tag
-            target = Iri(scheme='wiki.local', path=element.attrib.get("src"), fragment=None)
+            target = Iri(scheme="wiki.local", path=element.attrib.get("src"), fragment=None)
             attrib[xinclude.href] = target
             new_node = xinclude.include(attrib=attrib)
         else:
@@ -269,10 +296,10 @@ def visit_object(self, element):
         """
         <object data="href"></object> --> <object xlink="href" />
         """
-        key = xlink('href')
+        key = xlink("href")
         attrib = {}
         if self.base_url:
-            attrib[key] = ''.join([self.base_url, element.get(html.data)])
+            attrib[key] = "".join([self.base_url, element.get(html.data)])
         else:
             attrib[key] = element.get(html.data)
 
@@ -287,7 +314,7 @@ def visit_inline(self, element):
         """
         key = html.class_
         attrib = {}
-        attrib[key] = ''.join(['html-', element.tag.name])
+        attrib[key] = "".join(["html-", element.tag.name])
         return self.new_copy(moin_page.span, element, attrib)
 
     def visit_li(self, element):
@@ -301,8 +328,7 @@ def visit_li(self, element):
 
         For <li> element, there is no label
         """
-        list_item_body = ET.Element(moin_page.list_item_body,
-                                    attrib={}, children=self.do_children(element))
+        list_item_body = ET.Element(moin_page.list_item_body, attrib={}, children=self.do_children(element))
         return ET.Element(moin_page.list_item, attrib={}, children=[list_item_body])
 
     def visit_list(self, element):
@@ -330,30 +356,30 @@ def visit_list(self, element):
         # according to the type of the list
         attrib = {}
         if element.tag == "ul" or element.tag == "dir":
-            attrib[moin_page('item-label-generate')] = 'unordered'
+            attrib[moin_page("item-label-generate")] = "unordered"
         elif element.tag == "ol":
-            attrib[moin_page('item-label-generate')] = 'ordered'
+            attrib[moin_page("item-label-generate")] = "ordered"
 
         return ET.Element(moin_page.list, attrib=attrib, children=self.do_children(element))
 
     def visit_a(self, element):
-        """ element.attrib has href, element.tag is 'a', element.text has title"""
-        key = xlink('href')
+        """element.attrib has href, element.tag is 'a', element.text has title"""
+        key = xlink("href")
         attrib = {}
-        if element.attrib.get('title'):
-            attrib[html.title_] = element.attrib.get('title')
+        if element.attrib.get("title"):
+            attrib[html.title_] = element.attrib.get("title")
         href = postproc_text(self.markdown, element.attrib.get("href"))
         iri = Iri(href)
         # iri has authority, fragment, path, query, scheme = none,none,path,none
         if iri.scheme is None:
-            iri.scheme = 'wiki.local'
+            iri.scheme = "wiki.local"
         attrib[key] = iri
         return self.new_copy(moin_page.a, element, attrib)
 
     def verify_align_style(self, attrib):
-        alignment = attrib.get('style')
-        if alignment and alignment in ('text-align: right;', 'text-align: center;', 'text-align: left;'):
-            attrib = {moin_page.style: attrib.get('style')}
+        alignment = attrib.get("style")
+        if alignment and alignment in ("text-align: right;", "text-align: center;", "text-align: left;"):
+            attrib = {moin_page.style: attrib.get("style")}
             return attrib
         return {}
 
@@ -387,7 +413,7 @@ def visit(self, element):
             return self.visit_heading(element)
 
         # Otherwise we need a specific procedure to handle it
-        method_name = 'visit_' + element.tag
+        method_name = "visit_" + element.tag
         method = getattr(self, method_name, None)
         if method:
             return method(element)
@@ -414,7 +440,7 @@ def do_children(self, element, add_lineno=False):
         """
         new = []
         # copy anything but '\n'
-        if hasattr(element, "text") and element.text is not None and element.text != '\n':
+        if hasattr(element, "text") and element.text is not None and element.text != "\n":
             new.append(postproc_text(self.markdown, element.text))
 
         for child in element:
@@ -425,10 +451,10 @@ def do_children(self, element, add_lineno=False):
                 if add_lineno and self.line_numbers:
                     # the line numbers for the start of each block were counted and saved before preprocessors were run
                     r.attrib[html.data_lineno] = self.line_numbers.popleft()
-                r = (r, )
+                r = (r,)
             new.extend(r)
             # copy anything but '\n'
-            if hasattr(child, "tail") and child.tail is not None and child.tail != '\n' and child.tail:
+            if hasattr(child, "tail") and child.tail is not None and child.tail != "\n" and child.tail:
                 new.append(postproc_text(self.markdown, child.tail))
         return new
 
@@ -454,16 +480,16 @@ def count_lines(self, text):
         line_numbers = deque()
         lineno = 1
         in_blockquote = False
-        blocks = text.split('\n\n')
+        blocks = text.split("\n\n")
         for block in blocks:
             if not block:
                 # bump count because empty blocks will be discarded
                 lineno += 2
                 continue
-            line_count = block.count('\n')
+            line_count = block.count("\n")
 
             # detect and fix the problem of interspersed blank lines within blockquotes
-            if block.startswith('    ') or block.startswith('\n    '):
+            if block.startswith("    ") or block.startswith("\n    "):
                 if in_blockquote:
                     lineno += line_count + 2
                     continue
@@ -471,7 +497,7 @@ def count_lines(self, text):
             else:
                 in_blockquote = False
 
-            if block.startswith('\n'):
+            if block.startswith("\n"):
                 lineno += 1
                 line_numbers.append(lineno)
                 lineno += line_count + 2 - 1  # -1 is already in count
@@ -490,7 +516,7 @@ def embedded_markup(self, text):
         """
         try:
             # we enclose plain text and span tags with P-tags
-            p_text = html_in_converter(f'<p>{text}</p>')
+            p_text = html_in_converter(f"<p>{text}</p>")
             # discard page and body tags
             return p_text[0][0]
         except AssertionError:
@@ -505,7 +531,7 @@ def convert_embedded_markup(self, node):
         """
         for idx, child in enumerate(node):
             if isinstance(child, str):
-                if '<' in child:
+                if "<" in child:
                     node[idx] = self.embedded_markup(child)  # child is immutable string, so must do node[idx]
             else:
                 # do not convert markup within a <pre> tag
@@ -530,17 +556,13 @@ def convert_invalid_p_nodes(self, node):
                 self.convert_invalid_p_nodes(child)
 
     def __init__(self):
-        self.markdown = Markdown(extensions=[
-                ExtraExtension(),
-                CodeHiliteExtension(guess_lang=False),
-                'mdx_wikilink_plus',
-                'admonition',
-            ],
+        self.markdown = Markdown(
+            extensions=[ExtraExtension(), CodeHiliteExtension(guess_lang=False), "mdx_wikilink_plus", "admonition"],
             extension_configs={
-                'mdx_wikilink_plus': {
-                    'html_class': None,
-                    'image_class': None,
-                    'label_case': 'none',  # do not automatically CamelCase the label, keep it untouched
+                "mdx_wikilink_plus": {
+                    "html_class": None,
+                    "image_class": None,
+                    "label_case": "none",  # do not automatically CamelCase the label, keep it untouched
                 }
             },
         )
@@ -577,7 +599,7 @@ def __call__(self, data, contenttype=None, arguments=None):
         text = text.replace(md_util.STX, "").replace(md_util.ETX, "")
         text = text.replace("\r\n", "\n").replace("\r", "\n") + "\n\n"
         text = text.expandtabs(self.markdown.tab_length)
-        text = re.sub(r'(?<=\n) +\n', '\n', text)
+        text = re.sub(r"(?<=\n) +\n", "\n", text)
 
         # save line counts for start of each block, used later for edit autoscroll
         self.count_lines(text)
@@ -600,7 +622,7 @@ def __call__(self, data, contenttype=None, arguments=None):
 
         # }}} end Markdown 3.0.0 core.py convert method
 
-        add_lineno = bool(flaskg and getattr(flaskg, 'add_lineno_attr', False))
+        add_lineno = bool(flaskg and getattr(flaskg, "add_lineno_attr", False))
 
         # run markdown post processors and convert from ElementTree to an EmeraldTree object
         converted = self.do_children(root, add_lineno=add_lineno)
@@ -617,4 +639,4 @@ def __call__(self, data, contenttype=None, arguments=None):
 
 
 default_registry.register(Converter._factory, Type("text/x-markdown"), type_moin_document)
-default_registry.register(Converter._factory, Type('x-moin/format;name=markdown'), type_moin_document)
+default_registry.register(Converter._factory, Type("x-moin/format;name=markdown"), type_moin_document)
diff --git a/src/moin/converters/markdown_out.py b/src/moin/converters/markdown_out.py
index d6d3b0587..bd08e26a6 100644
--- a/src/moin/converters/markdown_out.py
+++ b/src/moin/converters/markdown_out.py
@@ -29,48 +29,49 @@ class Markdown:
     Markdown syntax elements
     It's dummy
     """
-    h = '#'
-    a_open = '<'
-    a_desc_open = '('
-    a_desc_close = ')'
-    a_close = '>'
-    comment_open = '<!-- '
-    comment_close = ' -->'
-    verbatim_open = '    '  # * 3
-    verbatim_close = '    '  # * 3
-    monospace = '`'
+
+    h = "#"
+    a_open = "<"
+    a_desc_open = "("
+    a_desc_close = ")"
+    a_close = ">"
+    comment_open = "<!-- "
+    comment_close = " -->"
+    verbatim_open = "    "  # * 3
+    verbatim_close = "    "  # * 3
+    monospace = "`"
     strong = "**"
     emphasis = "*"
-    underline_open = '<u>'
-    underline_close = '</u>'
-    samp_open = '`'
-    samp_close = '`'
-    stroke_open = '<strike>'
-    stroke_close = '</strike>'
-    table_marker = '|'
-    p = '\n'
-    linebreak = '  '
-    larger_open = '<big>'
-    larger_close = '</big>'
-    smaller_open = '<small>'
-    smaller_close = '</small>'
-    object_open = '{{'
-    object_close = '}}'
-    definition_list_marker = ':  '
-    separator = '----'
-    attribute_open = '{: '
-    attribute_close = '}'
+    underline_open = "<u>"
+    underline_close = "</u>"
+    samp_open = "`"
+    samp_close = "`"
+    stroke_open = "<strike>"
+    stroke_close = "</strike>"
+    table_marker = "|"
+    p = "\n"
+    linebreak = "  "
+    larger_open = "<big>"
+    larger_close = "</big>"
+    smaller_open = "<small>"
+    smaller_close = "</small>"
+    object_open = "{{"
+    object_close = "}}"
+    definition_list_marker = ":  "
+    separator = "----"
+    attribute_open = "{: "
+    attribute_close = "}"
     # TODO: definition list
     list_type = {
-        ('definition', None): '',
-        ('ordered', None): '1.',
-        ('ordered', 'lower-alpha'): '1.',
-        ('ordered', 'upper-alpha'): '1.',
-        ('ordered', 'lower-roman'): '1.',
-        ('ordered', 'upper-roman'): '1.',
-        ('unordered', None): '*',
-        ('unordered', 'no-bullet'): '*',
-        (None, None): '::',
+        ("definition", None): "",
+        ("ordered", None): "1.",
+        ("ordered", "lower-alpha"): "1.",
+        ("ordered", "upper-alpha"): "1.",
+        ("ordered", "lower-roman"): "1.",
+        ("ordered", "upper-roman"): "1.",
+        ("unordered", None): "*",
+        ("unordered", "no-bullet"): "*",
+        (None, None): "::",
     }
 
     def __init__(self):
@@ -81,53 +82,51 @@ class Converter:
     """
     Converter application/x.moin.document -> text/x.moin.wiki
     """
-    namespaces = {
-        moin_page.namespace: 'moinpage',
-        xinclude: 'xinclude',
-    }
+
+    namespaces = {moin_page.namespace: "moinpage", xinclude: "xinclude"}
 
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls()
 
     def __init__(self):
-        self.list_item_labels = ['', ]
-        self.list_item_label = ''
+        self.list_item_labels = [""]
+        self.list_item_label = ""
         self.list_level = 0
         self.footnotes = []  # tuple of (name, text)
         self.footnote_number = 0  # incremented if a footnote name was not passed
 
     def __call__(self, root):
-        self.status = ['text', ]
+        self.status = ["text"]
         self.last_closed = None
         self.list_item_label = []
         content = self.open(root)
-        while '\n\n\n' in content:
-            content = content.replace('\n\n\n', '\n\n')
+        while "\n\n\n" in content:
+            content = content.replace("\n\n\n", "\n\n")
         if self.footnotes:
             # add footnote definitions to end of content
             notes = []
             for name, txt in self.footnotes:
-                notes.append(f'[^{name}]: {txt}')
-            notes = '\n'.join(notes)
-            content += '\n\n' + notes + '\n'
+                notes.append(f"[^{name}]: {txt}")
+            notes = "\n".join(notes)
+            content += "\n\n" + notes + "\n"
         return content
 
-    def open_children(self, elem, join_char=''):
+    def open_children(self, elem, join_char=""):
         childrens_output = []
         for child in elem:
             if isinstance(child, ET.Element):
                 # open function can change self.output
                 childrens_output.append(self.open(child))
             else:
-                ret = ''
+                ret = ""
                 if self.status[-1] == "text":
                     if self.last_closed == "p":
-                        ret = '\n'
-                if child == '\n' and getattr(elem, 'level', 0):
-                    child = child + ' ' * (len(''.join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
-                childrens_output.append(f'{ret}{child}')
-                self.last_closed = 'text'
+                        ret = "\n"
+                if child == "\n" and getattr(elem, "level", 0):
+                    child = child + " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
+                childrens_output.append(f"{ret}{child}")
+                self.last_closed = "text"
         out = join_char.join(childrens_output)
         return out
 
@@ -135,7 +134,7 @@ def open(self, elem):
         uri = elem.tag.uri
         name = self.namespaces.get(uri, None)
         if name is not None:
-            n = 'open_' + name
+            n = "open_" + name
             f = getattr(self, n, None)
             if f is not None:
                 return f(elem)
@@ -148,62 +147,78 @@ def attribute_list(self, elem):
         """
         attr_list = []
         for key, val in elem.attrib.items():
-            if key.name not in ('data-lineno', 'outline-level', 'href', 'item-label-generate', 'baseline-shift'):
+            if key.name not in ("data-lineno", "outline-level", "href", "item-label-generate", "baseline-shift"):
                 attr_list.append(f'{key.name}="{val}"')
         if attr_list:
-            return Markdown.attribute_open + ' '.join(attr_list) + Markdown.attribute_close
-        return ''
+            return Markdown.attribute_open + " ".join(attr_list) + Markdown.attribute_close
+        return ""
 
     def open_moinpage(self, elem):
-        n = 'open_moinpage_' + elem.tag.name.replace('-', '_')
+        n = "open_moinpage_" + elem.tag.name.replace("-", "_")
         f = getattr(self, n, None)
         if f:
             ret = f(elem)
-            if elem.tag.name not in ('separator', 'blockcode', 'code', 'div', 'big', 'small', 'sup', 'sub', 'th',
-                                     'emphasis', 's', 'ins', 'u', 'span', 'table', 'a',):
+            if elem.tag.name not in (
+                "separator",
+                "blockcode",
+                "code",
+                "div",
+                "big",
+                "small",
+                "sup",
+                "sub",
+                "th",
+                "emphasis",
+                "s",
+                "ins",
+                "u",
+                "span",
+                "table",
+                "a",
+            ):
                 attrib = self.attribute_list(elem)
                 if attrib:
-                    if ret.endswith('#\n'):
-                        ret = ret[:-1] + ' ' + attrib + ret[-1:]
-                    elif ret.endswith('\n') and not elem.tag.name == 'p':
+                    if ret.endswith("#\n"):
+                        ret = ret[:-1] + " " + attrib + ret[-1:]
+                    elif ret.endswith("\n") and not elem.tag.name == "p":
                         ret = ret[:-1] + attrib + ret[-1:]
-                    elif ret.endswith('\n') and elem.tag.name == 'p':
-                        ret += attrib + '\n'
+                    elif ret.endswith("\n") and elem.tag.name == "p":
+                        ret += attrib + "\n"
                     else:
                         ret += attrib
-            self.last_closed = elem.tag.name.replace('-', '_')
+            self.last_closed = elem.tag.name.replace("-", "_")
             return ret
         return self.open_children(elem)
 
     def open_moinpage_a(self, elem):
-        """ [link text](url "optional title") """
+        """[link text](url "optional title")"""
         href = elem.get(xlink.href, None)
         title = elem.get(html.title_, None)
         if isinstance(href, Iri):
             href = str(href)
-        href = href.split('wiki.local:')[-1]
+        href = href.split("wiki.local:")[-1]
         text = self.open_children(elem)
         if title:
             href = f'{href} "{title}"'
-        ret = f'[{text}]({href})'
+        ret = f"[{text}]({href})"
         cls = elem.get(moin_page.class_)
         if cls:
             ret = ret + '{:class="' + cls + '"}'
         return ret
 
     def open_moinpage_blockcode(self, elem):
-        text = ''.join(elem.itertext())
+        text = "".join(elem.itertext())
 
-        if elem.attrib.get(html.class_, None) == 'codehilite':
+        if elem.attrib.get(html.class_, None) == "codehilite":
             return text
 
-        lines = text.split('\n')
-        ret = '\n' + Markdown.verbatim_open + ('\n' + Markdown.verbatim_open).join(lines)
-        return '\n' + ret + '\n'
+        lines = text.split("\n")
+        ret = "\n" + Markdown.verbatim_open + ("\n" + Markdown.verbatim_open).join(lines)
+        return "\n" + ret + "\n"
 
     def open_moinpage_block_comment(self, elem):
         # convert moin hidden comment markdown/html comment: ## some block comment
-        return Markdown.comment_open + '\n'.join(elem) + Markdown.comment_close
+        return Markdown.comment_open + "\n".join(elem) + Markdown.comment_close
 
     def open_moinpage_blockquote(self, elem):
         # blockquotes are generated by html_in (and maybe others), not by moinwiki_in
@@ -211,13 +226,13 @@ def open_moinpage_blockquote(self, elem):
         ret = self.open_children(elem)
         ret = ret.strip()
         indented = []
-        for line in ret.split('\n'):
-            indented.append(' > ' + line)
-        return '\n' + '\n'.join(indented) + '\n'
+        for line in ret.split("\n"):
+            indented.append(" > " + line)
+        return "\n" + "\n".join(indented) + "\n"
 
     def open_moinpage_code(self, elem):
         ret = Markdown.monospace
-        ret += ''.join(elem.itertext())
+        ret += "".join(elem.itertext())
         ret += Markdown.monospace
         return ret
 
@@ -225,17 +240,17 @@ def open_moinpage_div(self, elem):
         """
         Find and process div tags with special classes as needed.
         """
-        if elem.attrib.get(html.class_, None) == 'toc':
+        if elem.attrib.get(html.class_, None) == "toc":
             # we do not want expanded toc
-            return '\n\n[TOC]\n\n'
+            return "\n\n[TOC]\n\n"
 
-        if elem.attrib.get(html.class_, None) == 'codehilite' and isinstance(elem[0][1], str):
+        if elem.attrib.get(html.class_, None) == "codehilite" and isinstance(elem[0][1], str):
             # in most cases, codehilite returns plain text blocks; return an indented block
-            text = elem[0][1].split('\n')
-            return '\n' + '\n'.join(['    ' + x for x in text]) + '\n'
+            text = elem[0][1].split("\n")
+            return "\n" + "\n".join(["    " + x for x in text]) + "\n"
 
         childrens_output = self.open_children(elem)
-        return '\n\n' + childrens_output + '\n\n'
+        return "\n\n" + childrens_output + "\n\n"
 
     def open_moinpage_emphasis(self, elem):
         childrens_output = self.open_children(elem)
@@ -246,66 +261,66 @@ def open_moinpage_h(self, elem):
         try:
             level = int(level)
         except ValueError:
-            raise ElementException('page:outline-level needs to be an integer')
+            raise ElementException("page:outline-level needs to be an integer")
         if level < 1:
             level = 1
         elif level > 6:
             level = 6
-        ret = Markdown.h * level + ' '
-        ret += ''.join(elem.itertext())
-        ret += f' {Markdown.h * level}\n'
-        return '\n' + ret
+        ret = Markdown.h * level + " "
+        ret += "".join(elem.itertext())
+        ret += f" {Markdown.h * level}\n"
+        return "\n" + ret
 
     def open_moinpage_line_break(self, elem):
         return Markdown.linebreak
 
     def open_moinpage_list(self, elem):
         label_type = elem.get(moin_page.item_label_generate, None), elem.get(moin_page.list_style_type, None)
-        self.list_item_labels.append(Markdown.list_type.get(label_type, '*'))
+        self.list_item_labels.append(Markdown.list_type.get(label_type, "*"))
         self.list_level += 1
-        ret = ''
-        if self.status[-1] != 'text' or self.last_closed:
-            ret = '\n'
-        self.status.append('list')
+        ret = ""
+        if self.status[-1] != "text" or self.last_closed:
+            ret = "\n"
+        self.status.append("list")
         self.last_closed = None
         childrens_output = self.open_children(elem)
         list_start = elem.attrib.get(moin_page.list_start)
         if list_start:
-            child_out1, child_out2 = childrens_output.split('.', 1)
-            childrens_output = f'{child_out1}.#{list_start}{child_out2}'
+            child_out1, child_out2 = childrens_output.split(".", 1)
+            childrens_output = f"{child_out1}.#{list_start}{child_out2}"
         self.list_item_labels.pop()
         self.list_level -= 1
         self.status.pop()
-        if self.status[-1] == 'list':
-            ret_end = ''
+        if self.status[-1] == "list":
+            ret_end = ""
         else:
-            ret_end = '\n'
+            ret_end = "\n"
         return f"{ret}{childrens_output}{ret_end}"
 
     def open_moinpage_list_item(self, elem):
-        self.list_item_label = self.list_item_labels[-1] + ' '
+        self.list_item_label = self.list_item_labels[-1] + " "
         return self.open_children(elem)
 
     def open_moinpage_list_item_label(self, elem):
         """Used for definition list terms"""
-        ret = ''
-        if self.list_item_labels[-1] == '' or self.list_item_labels[-1] == Markdown.definition_list_marker:
+        ret = ""
+        if self.list_item_labels[-1] == "" or self.list_item_labels[-1] == Markdown.definition_list_marker:
             self.list_item_labels[-1] = Markdown.definition_list_marker
-            self.list_item_label = self.list_item_labels[-1] + ' '
-            ret = '   ' * (len(''.join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
+            self.list_item_label = self.list_item_labels[-1] + " "
+            ret = "   " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
             if self.last_closed:
-                ret = f'\n{ret}'
+                ret = f"\n{ret}"
         childrens_output = self.open_children(elem)
         return f"\n{ret}{childrens_output}"
 
     def open_moinpage_list_item_body(self, elem):
-        ret = ''
+        ret = ""
         if self.last_closed:
-            ret = '\n'
-        ret += '    ' * len(self.list_item_labels[:-2]) + self.list_item_label
+            ret = "\n"
+        ret += "    " * len(self.list_item_labels[:-2]) + self.list_item_label
         child_out = self.open_children(elem)
         if self.list_item_label[0] == Markdown.definition_list_marker[0]:
-            child_out = '\n    '.join(child_out.split('\n'))
+            child_out = "\n    ".join(child_out.split("\n"))
         return ret + child_out
 
     def open_moinpage_note(self, elem):
@@ -315,15 +330,15 @@ def open_moinpage_note(self, elem):
             if class_ == "footnote":
                 self.footnote_number += 1
                 self.footnotes.append((self.footnote_number, self.open_children(elem)))
-                return f'[^{self.footnote_number}]'
+                return f"[^{self.footnote_number}]"
         # moinwiki footnote placement is ignored; markdown cannot place footnotes in middle of document like moinwiki
-        return ''
+        return ""
 
     def open_moinpage_nowiki(self, elem):
         """No support for moin features like highlight or nowiki within nowiki."""
-        if isinstance(elem[0], ET.Element) and elem[0].tag.name == 'blockcode' and isinstance(elem[0][0], str):
-            text = elem[0][0].split('\n')
-            return '\n' + '\n'.join(['    ' + x for x in text]) + '\n'
+        if isinstance(elem[0], ET.Element) and elem[0].tag.name == "blockcode" and isinstance(elem[0][0], str):
+            text = elem[0][0].split("\n")
+            return "\n" + "\n".join(["    " + x for x in text]) + "\n"
         return self.open_children(elem)
 
     def open_moinpage_object(self, elem):
@@ -332,50 +347,51 @@ def open_moinpage_object(self, elem):
 
         Transcluded objects are expanded in output because Markdown does not support transclusions.
         """
-        href = elem.get(xlink.href, elem.get(xinclude.href, ''))
+        href = elem.get(xlink.href, elem.get(xinclude.href, ""))
         if isinstance(href, Iri):
             href = str(href)
             href = urllib.parse.unquote(href)
-            if href.startswith('/+get/+'):
-                href = href.split('/')[-1]
-        href = href.split('wiki.local:')[-1]
+            if href.startswith("/+get/+"):
+                href = href.split("/")[-1]
+        href = href.split("wiki.local:")[-1]
         if len(elem) and isinstance(elem[0], str):
             # alt text for objects is enclosed within <object...>...</object>
             alt = elem[0]
         else:
-            alt = elem.attrib.get(html.alt, '')
-        title = elem.attrib.get(html.title_, '')
+            alt = elem.attrib.get(html.alt, "")
+        title = elem.attrib.get(html.title_, "")
         if title:
             title = f'"{title}"'
-        ret = f'![{alt}]({href} {title})'
-        ret = ret.replace(' )', ')')
+        ret = f"![{alt}]({href} {title})"
+        ret = ret.replace(" )", ")")
         return ret
 
     def open_moinpage_p(self, elem):
-        if moin_page.class_ in elem.attrib and 'moin-error' in elem.attrib[moin_page.class_]:
+        if moin_page.class_ in elem.attrib and "moin-error" in elem.attrib[moin_page.class_]:
             # ignore error messages inserted into DOM
-            return ''
+            return ""
 
         self.status.append("p")
         ret = ""
-        if self.status[-2] == 'text':
-            if self.last_closed == 'text':
+        if self.status[-2] == "text":
+            if self.last_closed == "text":
                 ret = Markdown.p * 2 + self.open_children(elem) + Markdown.p
             elif self.last_closed:
                 ret = Markdown.p + self.open_children(elem) + Markdown.p
             else:
                 ret = self.open_children(elem) + Markdown.p
-        elif self.status[-2] == 'table':
-            if self.last_closed and self.last_closed != 'table_cell' and self.last_closed != 'table_row':
+        elif self.status[-2] == "table":
+            if self.last_closed and self.last_closed != "table_cell" and self.last_closed != "table_row":
                 ret = Markdown.linebreak + self.open_children(elem)
             else:
                 ret = self.open_children(elem)
-        elif self.status[-2] == 'list':  # TODO: still possible? <p> after <li> removed from moinwiki_in
-            if self.last_closed \
-               and (self.last_closed != 'list_item' and
-                    self.last_closed != 'list_item_header' and
-                    self.last_closed != 'list_item_footer' and
-                    self.last_closed != 'list_item_label'):
+        elif self.status[-2] == "list":  # TODO: still possible? <p> after <li> removed from moinwiki_in
+            if self.last_closed and (
+                self.last_closed != "list_item"
+                and self.last_closed != "list_item_header"
+                and self.last_closed != "list_item_footer"
+                and self.last_closed != "list_item_label"
+            ):
                 ret = Markdown.linebreak + self.open_children(elem)
             else:
                 ret = self.open_children(elem)
@@ -387,50 +403,51 @@ def open_moinpage_p(self, elem):
     def open_moinpage_page(self, elem):
         self.last_closed = None
         if len(self.status) > 1:
-            self.status.append('text')
+            self.status.append("text")
             childrens_output = self.open_children(elem)
             self.status.pop()
             return childrens_output
 
-        self.status.append('text')
+        self.status.append("text")
         childrens_output = self.open_children(elem)
         self.status.pop()
         return childrens_output
 
     def open_moinpage_body(self, elem):
-        class_ = elem.get(moin_page.class_, '').replace(' ', '/')
+        class_ = elem.get(moin_page.class_, "").replace(" ", "/")
         if class_:
-            ret = f' {class_}\n'
+            ret = f" {class_}\n"
         elif len(self.status) > 2:
-            ret = '\n'
+            ret = "\n"
         else:
-            ret = ''
+            ret = ""
         childrens_output = self.open_children(elem)
         return f"{ret}{childrens_output}"
 
     def open_moinpage_samp(self, elem):
         # text {{{more text}}} end
         ret = Markdown.samp_open
-        ret += ''.join(elem.itertext())
+        ret += "".join(elem.itertext())
         ret += Markdown.samp_close
         return ret
 
     def open_moinpage_separator(self, elem):
-        return '\n----\n'
+        return "\n----\n"
 
     def open_moinpage_span(self, elem):
-        font_size = elem.get(moin_page.font_size, '')
-        baseline_shift = elem.get(moin_page.baseline_shift, '')
+        font_size = elem.get(moin_page.font_size, "")
+        baseline_shift = elem.get(moin_page.baseline_shift, "")
         if font_size:
             return "{}{}{}".format(
                 Markdown.larger_open if font_size == "120%" else Markdown.smaller_open,
                 self.open_children(elem),
-                Markdown.larger_close if font_size == "120%" else Markdown.smaller_close)
-        if baseline_shift == 'super':
-            return '<sup>{}</sup>'.format(''.join(elem.itertext()))
-        if baseline_shift == 'sub':
-            return '<sub>{}</sub>'.format(''.join(elem.itertext()))
-        return ''.join(self.open_children(elem))
+                Markdown.larger_close if font_size == "120%" else Markdown.smaller_close,
+            )
+        if baseline_shift == "super":
+            return "<sup>{}</sup>".format("".join(elem.itertext()))
+        if baseline_shift == "sub":
+            return "<sub>{}</sub>".format("".join(elem.itertext()))
+        return "".join(self.open_children(elem))
 
     def open_moinpage_del(self, elem):  # stroke or strike-through
         return Markdown.stroke_open + self.open_children(elem) + Markdown.stroke_close
@@ -448,36 +465,36 @@ def open_moinpage_strong(self, elem):
         return f"{Markdown.strong}{self.open_children(elem)}{Markdown.strong}"
 
     def open_moinpage_table(self, elem):
-        self.status.append('table')
+        self.status.append("table")
         self.last_closed = None
         ret = self.open_children(elem)
         self.status.pop()
         # markdown tables must have headings
-        if '----' not in ret:
+        if "----" not in ret:
             # style: text-align gets lost here
-            rows = ret.split('\n')
+            rows = ret.split("\n")
             header = rows[0][1:-1]  # remove leading and trailing |
-            cells = header.split('|')
-            marker = Markdown.table_marker + Markdown.table_marker.join(['----' for x in cells]) + Markdown.table_marker
+            cells = header.split("|")
+            marker = Markdown.table_marker + Markdown.table_marker.join(["----" for x in cells]) + Markdown.table_marker
             rows.insert(1, marker)
-            ret = '\n'.join(rows)
-        return '\n' + ret + '\n'
+            ret = "\n".join(rows)
+        return "\n" + ret + "\n"
 
     def open_moinpage_table_header(self, elem):
         # used for reST to moinwiki conversion, maybe others that generate table head
         separator = []
         for th in elem[0]:
-            if th.attrib.get(moin_page.style, None) == 'text-align: center;':
-                separator.append(':----:')
-            elif th.attrib.get(moin_page.style, None) == 'text-align: left;':
-                separator.append(':-----')
-            elif th.attrib.get(moin_page.style, None) == 'text-align: right;':
-                separator.append('-----:')
+            if th.attrib.get(moin_page.style, None) == "text-align: center;":
+                separator.append(":----:")
+            elif th.attrib.get(moin_page.style, None) == "text-align: left;":
+                separator.append(":-----")
+            elif th.attrib.get(moin_page.style, None) == "text-align: right;":
+                separator.append("-----:")
             else:
-                separator.append('------')
+                separator.append("------")
         separator = Markdown.table_marker.join(separator)
         ret = self.open_children(elem)
-        ret = ret + '{0}{1}{0}\n'.format(Markdown.table_marker, separator)
+        ret = ret + "{0}{1}{0}\n".format(Markdown.table_marker, separator)
         return ret
 
     def open_moinpage_table_body(self, elem):
@@ -486,7 +503,7 @@ def open_moinpage_table_body(self, elem):
 
     def open_moinpage_table_row(self, elem):
         ret = self.open_children(elem, join_char=Markdown.table_marker)
-        return '{0}{1}{0}\n'.format(Markdown.table_marker, ret)
+        return "{0}{1}{0}\n".format(Markdown.table_marker, ret)
 
     def open_moinpage_table_of_content(self, elem):
         return "\n[TOC]\n"
@@ -497,4 +514,4 @@ def open_xinclude(self, elem):
 
 
 default_registry.register(Converter._factory, type_moin_document, Type("text/x-markdown"))
-default_registry.register(Converter._factory, type_moin_document, Type('x-moin/format;name=markdown'))
+default_registry.register(Converter._factory, type_moin_document, Type("x-moin/format;name=markdown"))
diff --git a/src/moin/converters/mediawiki_in.py b/src/moin/converters/mediawiki_in.py
index ace302882..09b75bc34 100644
--- a/src/moin/converters/mediawiki_in.py
+++ b/src/moin/converters/mediawiki_in.py
@@ -26,11 +26,12 @@
 from ._util import decode_data, normalize_split_text, _Iter, _Stack
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class _TableArguments:
-    rules = r'''
+    rules = r"""
     (?:
         (?P<arg>
             (?:
@@ -50,34 +51,31 @@ class _TableArguments:
             )
         )
     )
-    '''
+    """
     _re = re.compile(rules, re.X)
 
-    map_keys = {
-        'colspan': 'number-columns-spanned',
-        'rowspan': 'number-rows-spanned',
-    }
+    map_keys = {"colspan": "number-columns-spanned", "rowspan": "number-rows-spanned"}
 
     def arg_repl(self, args, arg, key=None, value_u=None, value_q1=None, value_q2=None):
         key = self.map_keys.get(key, key)
-        value = (value_u or value_q1 or value_q2).encode('ascii', errors='backslashreplace').decode('unicode-escape')
+        value = (value_u or value_q1 or value_q2).encode("ascii", errors="backslashreplace").decode("unicode-escape")
         if key:
             args.keyword[key] = value
         else:
             args.positional.append(value)
 
     def number_columns_spanned_repl(self, args, number_columns_spanned):
-        args.keyword['number-columns-spanned'] = int(number_columns_spanned)
+        args.keyword["number-columns-spanned"] = int(number_columns_spanned)
 
     def number_rows_spanned_repl(self, args, number_rows_spanned):
-        args.keyword['number-rows-spanned'] = int(number_rows_spanned)
+        args.keyword["number-rows-spanned"] = int(number_rows_spanned)
 
     def __call__(self, input):
         args = Arguments()
 
         for match in self._re.finditer(input):
             data = {str(k): v for k, v in match.groupdict().items() if v is not None}
-            getattr(self, f'{match.lastgroup}_repl')(args, **data)
+            getattr(self, f"{match.lastgroup}_repl")(args, **data)
 
         return args
 
@@ -93,7 +91,7 @@ def __call__(self, data, contenttype=None, arguments=None):
         iter_content = _Iter(content)
         self.preprocessor = self.Mediawiki_preprocessor()
         body = self.parse_block(iter_content, arguments)
-        root = moin_page.page(children=(body, ))
+        root = moin_page.page(children=(body,))
 
         return root
 
@@ -118,13 +116,13 @@ def block_head_repl(self, _iter_content, stack, head, head_head, head_text):
         element = moin_page.h(attrib=attrib, children=[head_text])
         stack.top_append(element)
 
-    block_line = r'(?P<line> ^ \s* $ )'
+    block_line = r"(?P<line> ^ \s* $ )"
     # empty line that separates paragraphs
 
     def block_line_repl(self, _iter_content, stack, line):
         stack.clear()
 
-    block_separator = r'(?P<separator> ^ \s* -{4,} \s* $ )'
+    block_separator = r"(?P<separator> ^ \s* -{4,} \s* $ )"
 
     def block_separator_repl(self, _iter_content, stack, separator):
         stack.clear()
@@ -157,7 +155,7 @@ def block_table_lines(self, iter_content):
                 return
             yield line
 
-    def block_table_repl(self, iter_content, stack, table, table_args=''):
+    def block_table_repl(self, iter_content, stack, table, table_args=""):
         stack.clear()
         # TODO: table attributes
         elem = moin_page.table()
@@ -166,7 +164,7 @@ def block_table_repl(self, iter_content, stack, table, table_args=''):
             table_args = _TableArguments()(table_args)
             for key, value in table_args.keyword.items():
                 attrib = elem.attrib
-                if key in ('class', 'style', 'number-columns-spanned', 'number-rows-spanned'):
+                if key in ("class", "style", "number-columns-spanned", "number-rows-spanned"):
                     attrib[moin_page(key)] = value
 
         element = moin_page.table_body()
@@ -179,24 +177,24 @@ def block_table_repl(self, iter_content, stack, table, table_args=''):
             m = self.tablerow_re.match(line)
             if not m:
                 return
-            if m.group('newrow'):
-                stack.pop_name('table-row')
+            if m.group("newrow"):
+                stack.pop_name("table-row")
                 element = moin_page.table_row()
                 stack.push(element)
-            cells = m.group('cells')
+            cells = m.group("cells")
             if cells:
-                cells = cells.split('||')
+                cells = cells.split("||")
                 for cell in cells:
-                    if stack.top_check('table-cell'):
+                    if stack.top_check("table-cell"):
                         stack.pop()
 
-                    cell = re.split(r'\s*\|\s*', cell)
+                    cell = re.split(r"\s*\|\s*", cell)
                     element = moin_page.table_cell()
                     if len(cell) > 1:
                         cell_args = _TableArguments()(cell[0])
                         for key, value in cell_args.keyword.items():
                             attrib = element.attrib
-                            if key in ('class', 'style', 'number-columns-spanned', 'number-rows-spanned'):
+                            if key in ("class", "style", "number-columns-spanned", "number-rows-spanned"):
                                 attrib[moin_page(key)] = value
                         cell = cell[1]
                     else:
@@ -205,24 +203,24 @@ def block_table_repl(self, iter_content, stack, table, table_args=''):
                     self.preprocessor.push()
                     self.parse_inline(cell, stack, self.inline_re)
                     preprocessor_status = self.preprocessor.pop()
-            elif m.group('text'):
+            elif m.group("text"):
                 self.preprocessor.push(preprocessor_status)
-                self.parse_inline('\n{}'.format(m.group('text')), stack, self.inline_re)
+                self.parse_inline("\n{}".format(m.group("text")), stack, self.inline_re)
                 preprocessor_status = self.preprocessor.pop()
-        stack.pop_name('table')
+        stack.pop_name("table")
 
-    block_text = r'(?P<text> .+ )'
+    block_text = r"(?P<text> .+ )"
 
     def block_text_repl(self, _iter_content, stack, text):
-        if stack.top_check('table', 'table-body', 'list'):
+        if stack.top_check("table", "table-body", "list"):
             stack.clear()
 
-        if stack.top_check('body', 'list-item-body'):
+        if stack.top_check("body", "list-item-body"):
             element = moin_page.p()
             stack.push(element)
         # If we are in a paragraph already, don't loose the whitespace
         else:
-            stack.top_append('\n')
+            stack.top_append("\n")
         self.parse_inline(text, stack, self.inline_re)
 
     indent = r"""
@@ -266,40 +264,49 @@ def indent_iter(self, iter_content, line, level, is_list):
                     yield line
                     break
 
-            if match.group('indent'):
-                new_level = len(match.group('indent'))
+            if match.group("indent"):
+                new_level = len(match.group("indent"))
 
-            if match.group('list_begin') or level != new_level:
+            if match.group("list_begin") or level != new_level:
                 iter_content.push(line)
                 return
 
-            yield match.group('text')
-
-    def indent_repl(self, iter_content, stack, line,
-                    indent, text, list_begin=None, list_definition=None,
-                    list_definition_text=None, list_numbers=None,
-                    list_bullet=None,
-                    list_none=None):
+            yield match.group("text")
+
+    def indent_repl(
+        self,
+        iter_content,
+        stack,
+        line,
+        indent,
+        text,
+        list_begin=None,
+        list_definition=None,
+        list_definition_text=None,
+        list_numbers=None,
+        list_bullet=None,
+        list_none=None,
+    ):
         level = len(indent)
-        list_type = 'unordered', 'none'
+        list_type = "unordered", "none"
         if list_begin:
             if list_definition:
-                list_type = 'definition', None
+                list_type = "definition", None
             elif list_numbers:
-                list_type = 'ordered', None
+                list_type = "ordered", None
             elif list_bullet:
-                list_type = 'unordered', None
+                list_type = "unordered", None
             elif list_none:
                 list_type = None, None
 
         element_use = None
         while len(stack) > 1:
             cur = stack.top()
-            if cur.tag.name == 'list-item-body':
+            if cur.tag.name == "list-item-body":
                 if level > cur.level:
                     element_use = cur
                     break
-            if cur.tag.name == 'list':
+            if cur.tag.name == "list":
                 if level >= cur.level and list_type == cur.list_type:
                     element_use = cur
                     break
@@ -308,7 +315,7 @@ def indent_repl(self, iter_content, stack, line,
         if not element_use:
             element_use = stack.top()
         if list_begin:
-            if element_use.tag.name != 'list':
+            if element_use.tag.name != "list":
                 attrib = {}
                 if not list_definition:
                     attrib[moin_page.item_label_generate] = list_type[0]
@@ -325,9 +332,9 @@ def indent_repl(self, iter_content, stack, line,
                 new_stack = _Stack(element_label, iter_content=iter_content)
                 # TODO: definition list doesn't work,
                 #       if definition of the term on the next line
-                splited_text = text.split(':')
+                splited_text = text.split(":")
                 list_definition_text = splited_text.pop(0)
-                text = ':'.join(splited_text)
+                text = ":".join(splited_text)
 
                 self.parse_inline(list_definition_text, new_stack, self.inline_re)
 
@@ -346,9 +353,9 @@ def indent_repl(self, iter_content, stack, line,
             match = self.block_re.match(line)
             it = iter
             # XXX: Hack to allow nowiki to ignore the list indentation
-            if match.lastgroup == 'table' or match.lastgroup == 'nowiki':
+            if match.lastgroup == "table" or match.lastgroup == "nowiki":
                 it = iter_content
-            self._apply(match, 'block', it, new_stack)
+            self._apply(match, "block", it, new_stack)
 
     inline_comment = r"""
         (?P<comment>
@@ -383,16 +390,16 @@ def inline_comment_repl(self, stack, comment, comment_begin=None, comment_end=No
         )
     """
 
-    def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
+    def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=""):
         if len(emphstrong) == 5:
-            if stack.top_check('emphasis'):
+            if stack.top_check("emphasis"):
                 stack.pop()
-                if stack.top_check('strong'):
+                if stack.top_check("strong"):
                     stack.pop()
                 else:
                     stack.push(moin_page.strong())
-            elif stack.top_check('strong'):
-                if stack.top_check('strong'):
+            elif stack.top_check("strong"):
+                if stack.top_check("strong"):
                     stack.pop()
                 else:
                     stack.push(moin_page.strong())
@@ -404,12 +411,12 @@ def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
                     stack.push(moin_page.strong())
                     stack.push(moin_page.emphasis())
         elif len(emphstrong) == 3:
-            if stack.top_check('strong'):
+            if stack.top_check("strong"):
                 stack.pop()
             else:
                 stack.push(moin_page.strong())
         elif len(emphstrong) == 2:
-            if stack.top_check('emphasis'):
+            if stack.top_check("emphasis"):
                 stack.pop()
             else:
                 stack.push(moin_page.emphasis())
@@ -432,14 +439,14 @@ def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
     """
 
     def inline_entity_repl(self, stack, entity):
-        if entity[1] == '#':
-            if entity[2] == 'x':
+        if entity[1] == "#":
+            if entity[2] == "x":
                 c = int(entity[3:-1], 16)
             else:
                 c = int(entity[2:-1], 10)
             c = chr(c)
         else:
-            c = chr(name2codepoint.get(entity[1:-1], 0xfffe))
+            c = chr(name2codepoint.get(entity[1:-1], 0xFFFE))
         stack.top_append(c)
 
     inline_blockquote = r"""
@@ -472,11 +479,12 @@ def inline_blockquote_repl(self, stack, blockquote, blockquote_begin=None, block
         )
     """
 
-    def inline_footnote_repl(self, stack, footnote,
-                             footnote_begin=None, footnote_text=None, footnote_end=None, footnote_start=None):
+    def inline_footnote_repl(
+        self, stack, footnote, footnote_begin=None, footnote_text=None, footnote_end=None, footnote_start=None
+    ):
         # stack.top_check('emphasis'):
         if footnote_begin is not None:
-            stack.push(moin_page.note(attrib={moin_page.note_class: 'footnote'}))
+            stack.push(moin_page.note(attrib={moin_page.note_class: "footnote"}))
             stack.push(moin_page.note_body())
         elif footnote_end is not None:
             stack.pop()
@@ -491,7 +499,7 @@ def inline_footnote_repl(self, stack, footnote,
     """
 
     def inline_strike_repl(self, stack, strike):
-        if not stack.top_check('s'):
+        if not stack.top_check("s"):
             stack.push(moin_page.s())
         else:
             stack.pop()
@@ -505,7 +513,7 @@ def inline_strike_repl(self, stack, strike):
     """
 
     def inline_delete_repl(self, stack, delete):
-        if not stack.top_check('del'):
+        if not stack.top_check("del"):
             stack.push(moin_page.del_())
         else:
             stack.pop()
@@ -519,7 +527,7 @@ def inline_delete_repl(self, stack, delete):
     """
 
     def inline_subscript_repl(self, stack, subscript, subscript_text):
-        attrib = {moin_page.baseline_shift: 'sub'}
+        attrib = {moin_page.baseline_shift: "sub"}
         elem = moin_page.span(attrib=attrib, children=[subscript_text])
         stack.top_append(elem)
 
@@ -532,7 +540,7 @@ def inline_subscript_repl(self, stack, subscript, subscript_text):
     """
 
     def inline_superscript_repl(self, stack, superscript, superscript_text):
-        attrib = {moin_page.baseline_shift: 'super'}
+        attrib = {moin_page.baseline_shift: "super"}
         elem = moin_page.span(attrib=attrib, children=[superscript_text])
         stack.top_append(elem)
 
@@ -545,7 +553,7 @@ def inline_superscript_repl(self, stack, superscript, superscript_text):
     """
 
     def inline_underline_repl(self, stack, underline):
-        if not stack.top_check('u'):
+        if not stack.top_check("u"):
             stack.push(moin_page.u())
         else:
             stack.pop()
@@ -559,7 +567,7 @@ def inline_underline_repl(self, stack, underline):
     """
 
     def inline_insert_repl(self, stack, insert):
-        if not stack.top_check('ins'):
+        if not stack.top_check("ins"):
             stack.push(moin_page.ins())
         else:
             stack.pop()
@@ -600,7 +608,9 @@ def inline_insert_repl(self, stack, insert):
             \s*
             \]
         )
-    """ % dict(uri_schemes='|'.join(URI_SCHEMES))
+    """ % dict(
+        uri_schemes="|".join(URI_SCHEMES)
+    )
 
     def parse_args(self, input):
         """
@@ -611,7 +621,7 @@ def parse_args(self, input):
         :param input: can be like a|b|c=f|something else caption|g='long caption'|link=http://google.com
         :returns: Arguments instance
         """
-        parse_rules = r'''
+        parse_rules = r"""
         (?:
             (?P<key>[\w-]+)=    # Matches 'key=' part of the string, optional
         )?
@@ -623,22 +633,23 @@ def parse_args(self, input):
             |
             '(?P<squote_val>.*?)(?<!\\)'    # Quoted value with single quotes
         )
-        '''
+        """
         parse_re = re.compile(parse_rules, re.X | re.U)
         ret = Arguments()
         for match in parse_re.finditer(input):
-            key = match.group('key')
-            value = match.group('unquote_val') or match.group('squote_val') or match.group('dquote_val')
+            key = match.group("key")
+            value = match.group("unquote_val") or match.group("squote_val") or match.group("dquote_val")
             if key:
                 ret.keyword[key] = value
             else:
                 ret.positional.append(value)
         return ret
 
-    def inline_link_repl(self, stack, link, link_url=None, link_item=None,
-                         link_args='', external_link_url=None, alt_text=''):
+    def inline_link_repl(
+        self, stack, link, link_url=None, link_item=None, link_args="", external_link_url=None, alt_text=""
+    ):
         """Handle all kinds of links."""
-        link_text = ''
+        link_text = ""
         # Remove the first pipe/space, example of link_args : |arg1|arg2 or " arg1 arg2"
         parsed_args = self.parse_args(link_args[1:])
         query = None
@@ -648,25 +659,25 @@ def inline_link_repl(self, stack, link, link_url=None, link_item=None,
         if parsed_args.positional:
             link_text = parsed_args.positional.pop()
         if link_item is not None:
-            if '#' in link_item:
-                path, fragment = link_item.rsplit('#', 1)
+            if "#" in link_item:
+                path, fragment = link_item.rsplit("#", 1)
             else:
                 path, fragment = link_item, None
-            target = Iri(scheme='wiki.local', path=path, query=query, fragment=fragment)
+            target = Iri(scheme="wiki.local", path=path, query=query, fragment=fragment)
             text = link_item
         else:
-            if link_url and len(link_url.split(':')) > 0 and link_url.split(':')[0] == 'File':
-                object_item = ':'.join(link_url.split(':')[1:])
+            if link_url and len(link_url.split(":")) > 0 and link_url.split(":")[0] == "File":
+                object_item = ":".join(link_url.split(":")[1:])
                 args = parsed_args.keyword
                 if object_item is not None:
-                    if 'do' not in args:
+                    if "do" not in args:
                         # by default, we want the item's get url for transclusion of raw data:
-                        args['do'] = 'get'
+                        args["do"] = "get"
                     query = urlencode(args, encoding=CHARSET)
-                    target = Iri(scheme='wiki.local', path=object_item, query=query, fragment=None)
+                    target = Iri(scheme="wiki.local", path=object_item, query=query, fragment=None)
                     text = object_item
                 else:
-                    target = Iri(scheme='wiki.local', path=link_url)
+                    target = Iri(scheme="wiki.local", path=link_url)
                     text = link_url
 
                 if not link_text:
@@ -684,7 +695,7 @@ def inline_link_repl(self, stack, link, link_url=None, link_item=None,
                     stack.top_append(text)
                 stack.pop()
                 return
-            target = Iri(scheme='wiki.local', path=link_url)
+            target = Iri(scheme="wiki.local", path=link_url)
             text = link_url
         if external_link_url:
             target = Iri(external_link_url)
@@ -728,9 +739,16 @@ def inline_breakline_repl(self, stack, breakline):
         )
     """
 
-    def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None,
-                           nowiki_text_pre=None, pre_args='',
-                           nowiki_text_code=None, nowiki_text_tt=None):
+    def inline_nowiki_repl(
+        self,
+        stack,
+        nowiki,
+        nowiki_text=None,
+        nowiki_text_pre=None,
+        pre_args="",
+        nowiki_text_code=None,
+        nowiki_text_tt=None,
+    ):
         text = None
 
         if nowiki_text is not None:
@@ -776,7 +794,7 @@ def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None,
         # block_nowiki,
         block_text,
     )
-    block_re = re.compile('|'.join(block), re.X | re.U | re.M)
+    block_re = re.compile("|".join(block), re.X | re.U | re.M)
 
     indent_re = re.compile(indent, re.X)
 
@@ -799,7 +817,7 @@ def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None,
         inline_insert,
         inline_entity,
     )
-    inline_re = re.compile('|'.join(inline), re.X | re.U)
+    inline_re = re.compile("|".join(inline), re.X | re.U)
 
     inlinedesc = (
         # inline_macro,
@@ -807,7 +825,7 @@ def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None,
         inline_nowiki,
         inline_emphstrong,
     )
-    inlinedesc_re = re.compile('|'.join(inlinedesc), re.X | re.U)
+    inlinedesc_re = re.compile("|".join(inlinedesc), re.X | re.U)
 
     # Nowiki end
     # nowiki_end_re = re.compile(nowiki_end, re.X)
@@ -822,41 +840,22 @@ def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None,
     class Mediawiki_preprocessor:
 
         class Preprocessor_tag:
-            def __init__(self, name='', text='', tag='', status=True):
+            def __init__(self, name="", text="", tag="", status=True):
                 self.tag_name = name
                 self.tag = tag
                 self.text = [text]
                 self.status = status
 
-        all_tags = [
-            'br',
-            'blockquote'
-            'del',
-            'pre',
-            'code',
-            'tt',
-            'nowiki',
-            'ref',
-            's',
-            'sub',
-            'sup',
-        ]
-
-        nowiki_tags = [
-            'pre',
-            'code',
-            'tt',
-            'nowiki',
-        ]
-
-        block_tags = [
-            'blockquote',
-        ]
+        all_tags = ["br", "blockquote" "del", "pre", "code", "tt", "nowiki", "ref", "s", "sub", "sup"]
+
+        nowiki_tags = ["pre", "code", "tt", "nowiki"]
+
+        block_tags = ["blockquote"]
 
         def __init__(self):
             self.opened_tags = []
             self.nowiki = False
-            self.nowiki_tag = ''
+            self.nowiki_tag = ""
             self._stack = []
 
         def push(self, status=[]):
@@ -868,7 +867,7 @@ def push(self, status=[]):
                     self.nowiki_tag = self.opened_tags[-1].tag_name
                 else:
                     self.nowiki = False
-                    self.nowiki_tag = ''
+                    self.nowiki_tag = ""
 
         def pop(self):
             if len(self._stack):
@@ -881,7 +880,7 @@ def pop(self):
                     self.nowiki_tag = self.opened_tags[-1].tag_name
                 else:
                     self.nowiki = False
-                    self.nowiki_tag = ''
+                    self.nowiki_tag = ""
             return self.opened_tags
 
         def __call__(self, line, tags=[]):
@@ -906,35 +905,40 @@ def __call__(self, line, tags=[]):
                         next_text = match.group(3)
                         text = match.group(2) or match.group(4)
                         if not text:
-                            text = ''
+                            text = ""
                         tag_match = re.match(r"/\s*(.*)", tag)
                         status = not tag_match
                         if tag_match:
-                            tag_name = tag_match.group(1).split(' ')[0]
+                            tag_name = tag_match.group(1).split(" ")[0]
                         else:
-                            tag_name = tag.split(' ')[0]
-                        if tag_name not in self.all_tags or re.match(r'.*/\s*$', tag)\
-                                or self.nowiki and (status or tag_name != self.nowiki_tag):
+                            tag_name = tag.split(" ")[0]
+                        if (
+                            tag_name not in self.all_tags
+                            or re.match(r".*/\s*$", tag)
+                            or self.nowiki
+                            and (status or tag_name != self.nowiki_tag)
+                        ):
                             if not len(tags):
-                                post_line.append(f'<{tag}>')
+                                post_line.append(f"<{tag}>")
                                 post_line.append(text)
                             else:
-                                tags[-1].text.append(f'<{tag}>')
+                                tags[-1].text.append(f"<{tag}>")
                                 tags[-1].text.append(text)
                         else:
                             if not status:
                                 if self.nowiki:
                                     if tag_name == self.nowiki_tag:
-                                        self.nowiki_tag = ''
+                                        self.nowiki_tag = ""
                                         self.nowiki = False
                                 if tag_name in [t.tag_name for t in tags]:
                                     open_tags = []
-                                    tmp_line = ''
+                                    tmp_line = ""
                                     close_tag = self.Preprocessor_tag()
                                     while tag_name != close_tag.tag_name:
                                         close_tag = tags.pop()
-                                        tmp_line = '<{}>{}{}</{}>'.format(
-                                            close_tag.tag, ''.join(close_tag.text), tmp_line, close_tag.tag_name)
+                                        tmp_line = "<{}>{}{}</{}>".format(
+                                            close_tag.tag, "".join(close_tag.text), tmp_line, close_tag.tag_name
+                                        )
                                         if not len(tags):
                                             post_line.append(tmp_line)
                                         else:
@@ -947,7 +951,7 @@ def __call__(self, line, tags=[]):
                                         tags[-1].text.append(text)
                                     if open_tags:
                                         for t in open_tags[:-1].reverse():
-                                            t.text = ''
+                                            t.text = ""
                                             tags.append(t)
                             else:
                                 if tag_name in self.nowiki_tags:
@@ -957,7 +961,7 @@ def __call__(self, line, tags=[]):
                     else:
                         post_line.append(next_text)
                         break
-                return ''.join(post_line)
+                return "".join(post_line)
             self.opened_tags = tags
 
     def _apply(self, match, prefix, *args):
@@ -965,7 +969,7 @@ def _apply(self, match, prefix, *args):
         Call the _repl method for the last matched group with the given prefix.
         """
         data = {str(k): v for k, v in match.groupdict().items() if v is not None}
-        func = f'{prefix}_{match.lastgroup}_repl'
+        func = f"{prefix}_{match.lastgroup}_repl"
         # logging.debug("calling %s(%r, %r)" % (func, args, data))
         getattr(self, func)(*args, **data)
 
@@ -973,10 +977,10 @@ def parse_block(self, iter_content, arguments):
         attrib = {}
         if arguments:
             for key, value in arguments.keyword.items():
-                if key in ('style', ):
+                if key in ("style",):
                     attrib[moin_page(key)] = value
-                elif key == '_old':
-                    attrib[moin_page.class_] = value.replace('/', ' ')
+                elif key == "_old":
+                    attrib[moin_page.class_] = value.replace("/", " ")
 
         body = moin_page.body(attrib=attrib)
 
@@ -988,28 +992,28 @@ def parse_block(self, iter_content, arguments):
                 data = {str(k): v for k, v in match.groupdict().items() if v is not None}
                 self.indent_repl(iter_content, stack, line, **data)
             else:
-                self.indent_repl(iter_content, stack, line, '', line)
+                self.indent_repl(iter_content, stack, line, "", line)
 
         return body
 
     def parse_inline(self, text, stack, inline_re):
         """Recognize inline elements within the given text"""
-        lines = text.split('\n')
+        lines = text.split("\n")
         text = []
         for line in lines:
             text.append(self.preprocessor(line))
-        text = '\n'.join(text)
+        text = "\n".join(text)
         pos = 0
         for match in inline_re.finditer(text):
             # Handle leading text
-            stack.top_append_ifnotempty(text[pos:match.start()])
+            stack.top_append_ifnotempty(text[pos : match.start()])
             pos = match.end()
 
-            self._apply(match, 'inline', stack)
+            self._apply(match, "inline", stack)
 
         # Handle trailing text
         stack.top_append_ifnotempty(text[pos:])
 
 
-default_registry.register(Converter.factory, Type('x-moin/format;name=mediawiki'), type_moin_document)
-default_registry.register(Converter.factory, Type('text/x-mediawiki'), type_moin_document)
+default_registry.register(Converter.factory, Type("x-moin/format;name=mediawiki"), type_moin_document)
+default_registry.register(Converter.factory, Type("text/x-mediawiki"), type_moin_document)
diff --git a/src/moin/converters/moinwiki19_in.py b/src/moin/converters/moinwiki19_in.py
index e73799bb3..292ba787e 100644
--- a/src/moin/converters/moinwiki19_in.py
+++ b/src/moin/converters/moinwiki19_in.py
@@ -22,6 +22,7 @@
 from .moinwiki_in import Converter
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -75,15 +76,22 @@ def factory(cls, input, output, **kw):
           $  # ... or end of line
          )
     """ % {
-        'u': CHARS_UPPER,
-        'l': CHARS_LOWER,
-        'child': re.escape(wikiutil.CHILD_PREFIX),
-        'parent': re.escape(wikiutil.PARENT_PREFIX),
+        "u": CHARS_UPPER,
+        "l": CHARS_LOWER,
+        "child": re.escape(wikiutil.CHILD_PREFIX),
+        "parent": re.escape(wikiutil.PARENT_PREFIX),
     }
 
-    def inline_freelink_repl(self, stack, freelink, freelink_bang=None,
-                             freelink_interwiki_page=None, freelink_interwiki_ref=None,
-                             freelink_page=None, freelink_email=None):
+    def inline_freelink_repl(
+        self,
+        stack,
+        freelink,
+        freelink_bang=None,
+        freelink_interwiki_page=None,
+        freelink_interwiki_ref=None,
+        freelink_page=None,
+        freelink_email=None,
+    ):
         if freelink_bang:
             stack.top_append(freelink)
             return
@@ -91,15 +99,15 @@ def inline_freelink_repl(self, stack, freelink, freelink_bang=None,
         attrib = {}
 
         if freelink_page:
-            if '#' in freelink_page:
-                path, fragment = freelink_page.rsplit('#', 1)
+            if "#" in freelink_page:
+                path, fragment = freelink_page.rsplit("#", 1)
             else:
                 path, fragment = freelink_page, None
-            link = Iri(scheme='wiki.local', path=path, fragment=fragment)
+            link = Iri(scheme="wiki.local", path=path, fragment=fragment)
             text = freelink_page
 
         elif freelink_email:
-            link = 'mailto:' + freelink_email
+            link = "mailto:" + freelink_email
             text = freelink_email
 
         else:
@@ -107,9 +115,7 @@ def inline_freelink_repl(self, stack, freelink, freelink_bang=None,
                 stack.top_append(freelink)
                 return
 
-            link = Iri(scheme='wiki',
-                       authority=freelink_interwiki_ref,
-                       path='/' + freelink_interwiki_page)
+            link = Iri(scheme="wiki", authority=freelink_interwiki_ref, path="/" + freelink_interwiki_page)
             text = freelink_interwiki_page
 
         attrib[xlink.href] = link
@@ -143,7 +149,9 @@ def inline_freelink_repl(self, stack, freelink, freelink_bang=None,
                 )
             )
         )
-    """ % dict(uri_schemes='|'.join(URI_SCHEMES))
+    """ % dict(
+        uri_schemes="|".join(URI_SCHEMES)
+    )
 
     def inline_url_repl(self, stack, url, url_target):
         url = Iri(url_target)
@@ -151,12 +159,9 @@ def inline_url_repl(self, stack, url, url_target):
         element = moin_page.a(attrib=attrib, children=[url_target])
         stack.top_append(element)
 
-    inline = Converter.inline + (
-        inline_freelink,
-        inline_url,
-    )
-    inline_re = re.compile('|'.join(inline), re.X | re.U)
+    inline = Converter.inline + (inline_freelink, inline_url)
+    inline_re = re.compile("|".join(inline), re.X | re.U)
 
 
-default_registry.register(ConverterFormat19.factory, Type('text/x.moin.wiki;format=1.9'), type_moin_document)
-default_registry.register(ConverterFormat19.factory, Type('x-moin/format;name=wiki;format=1.9'), type_moin_document)
+default_registry.register(ConverterFormat19.factory, Type("text/x.moin.wiki;format=1.9"), type_moin_document)
+default_registry.register(ConverterFormat19.factory, Type("x-moin/format;name=wiki;format=1.9"), type_moin_document)
diff --git a/src/moin/converters/moinwiki_in.py b/src/moin/converters/moinwiki_in.py
index 903aedf81..8504b1e88 100644
--- a/src/moin/converters/moinwiki_in.py
+++ b/src/moin/converters/moinwiki_in.py
@@ -28,11 +28,12 @@
 from . import default_registry
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class _TableArguments:
-    rules = r'''
+    rules = r"""
     (?:
         - (?P<number_columns_spanned> \d+)
         |
@@ -72,30 +73,27 @@ class _TableArguments:
         |
         (?P<syntax_error> \S+?)
     )
-    '''
+    """
     _re = re.compile(rules, re.X)
 
-    map_keys = {
-        'colspan': 'number-columns-spanned',
-        'rowspan': 'number-rows-spanned',
-    }
+    map_keys = {"colspan": "number-columns-spanned", "rowspan": "number-rows-spanned"}
 
     def arg_repl(self, args, arg, key=None, value_u=None, value_q1=None, value_q2=None):
         key = self.map_keys.get(key, key)
-        value = (value_u or value_q1 or value_q2).encode('ascii', errors='backslashreplace').decode('unicode-escape')
+        value = (value_u or value_q1 or value_q2).encode("ascii", errors="backslashreplace").decode("unicode-escape")
         if key:
             args.keyword[key] = value
         else:
             args.positional.append(value)
 
     def number_columns_spanned_repl(self, args, number_columns_spanned):
-        args.keyword['number-columns-spanned'] = int(number_columns_spanned)
+        args.keyword["number-columns-spanned"] = int(number_columns_spanned)
 
     def number_rows_spanned_repl(self, args, number_rows_spanned):
-        args.keyword['number-rows-spanned'] = int(number_rows_spanned)
+        args.keyword["number-rows-spanned"] = int(number_rows_spanned)
 
     def add_attr_to_style(self, args, attr):
-        args.keyword['style'] = args.keyword.get('style', "") + attr + " "
+        args.keyword["style"] = args.keyword.get("style", "") + attr + " "
 
     def hex_color_code_repl(self, args, hex_color_code):
         self.add_attr_to_style(args, f"background-color: #{hex_color_code};")
@@ -119,14 +117,14 @@ def width_percent_repl(self, args, width_percent):
         self.add_attr_to_style(args, f"width: {width_percent};")
 
     def syntax_error_repl(self, args, syntax_error):
-        args.keyword['error'] = syntax_error
+        args.keyword["error"] = syntax_error
 
     def __call__(self, input):
         args = Arguments()
 
         for match in self._re.finditer(input):
             data = {str(k): v for k, v in match.groupdict().items() if v is not None}
-            getattr(self, f'{match.lastgroup}_repl')(args, **data)
+            getattr(self, f"{match.lastgroup}_repl")(args, **data)
 
         return args
 
@@ -142,7 +140,7 @@ def __call__(self, data, contenttype=None, arguments=None):
         iter_content = _Iter(lines)
 
         body = self.parse_block(iter_content, arguments)
-        root = moin_page.page(children=(body, ))
+        root = moin_page.page(children=(body,))
 
         return root
 
@@ -154,9 +152,9 @@ def __call__(self, data, contenttype=None, arguments=None):
 
     def block_comment_repl(self, _iter_content, stack, comment):
         # A comment also ends anything
-        if not stack.top_check('block-comment'):
+        if not stack.top_check("block-comment"):
             stack.clear()
-            elem = moin_page.block_comment(children=(comment, ))
+            elem = moin_page.block_comment(children=(comment,))
             stack.push(elem)
         else:
             stack.top_append(comment)
@@ -185,7 +183,7 @@ def block_head_repl(self, _iter_content, stack, head, head_head, head_text):
         self.parse_inline(head_text, stack, self.inline_re)
         stack.pop()
 
-    block_line = r'(?P<line> ^ \s* $ )'
+    block_line = r"(?P<line> ^ \s* $ )"
     # empty line that separates paragraphs
 
     def block_line_repl(self, _iter_content, stack, line):
@@ -210,7 +208,7 @@ def block_line_repl(self, _iter_content, stack, line):
         $
     """
 
-    def block_macro_repl(self, _iter_content, stack, macro, macro_name, macro_args=''):
+    def block_macro_repl(self, _iter_content, stack, macro, macro_name, macro_args=""):
         """Handles macros using the placeholder syntax.
 
         Arguments are passed as a single positional parameter, each macro must parse as required.
@@ -260,32 +258,40 @@ def block_nowiki_lines(self, iter_content, marker_len):
         for line in iter_content:
             match = self.nowiki_end_re.match(line)
             if match:
-                marker = match.group('marker')
+                marker = match.group("marker")
                 if len(marker) == marker_len:
                     return
             yield line
 
-    def block_nowiki_repl(self, iter_content, stack, nowiki, nowiki_marker,
-                          nowiki_interpret='', nowiki_name=None, nowiki_args=None,
-                          optional_args=None):
+    def block_nowiki_repl(
+        self,
+        iter_content,
+        stack,
+        nowiki,
+        nowiki_marker,
+        nowiki_interpret="",
+        nowiki_name=None,
+        nowiki_args=None,
+        optional_args=None,
+    ):
         stack.clear()
         lines = _Iter(self.block_nowiki_lines(iter_content, len(nowiki_marker)), startno=iter_content.lineno)
-        content = '\n'.join(lines)
+        content = "\n".join(lines)
         # the arguments for wiki, csv, and highlight are diverse, one parser does not fit all
         # we push everything after {{{ to DOM; nowiki.py can insert error messages or
         # moinwiki_out can recreate exact input
-        all_nowiki_args = moin_page.nowiki_args(children=(nowiki_interpret, ))
+        all_nowiki_args = moin_page.nowiki_args(children=(nowiki_interpret,))
         # we avoid adjacent text siblings because serializer within tests merges them
-        elem = moin_page.nowiki(children=(str(len(nowiki_marker)), all_nowiki_args, content, ))
+        elem = moin_page.nowiki(children=(str(len(nowiki_marker)), all_nowiki_args, content))
         stack.top_append(elem)
 
-    block_separator = r'(?P<separator> ^ \s* -{4,} \s* $ )'
+    block_separator = r"(?P<separator> ^ \s* -{4,} \s* $ )"
 
-    def block_separator_repl(self, _iter_content, stack, separator, hr_class='moin-hr{0}'):
+    def block_separator_repl(self, _iter_content, stack, separator, hr_class="moin-hr{0}"):
         stack.clear()
         hr_height = min((len(separator) - 3), 6)
         hr_height = max(hr_height, 1)
-        attrib = {moin_page('class'): hr_class.format(hr_height)}
+        attrib = {moin_page("class"): hr_class.format(hr_height)}
         elem = moin_page.separator(attrib=attrib)
         stack.top_append(elem)
 
@@ -314,7 +320,7 @@ def block_separator_repl(self, _iter_content, stack, separator, hr_class='moin-h
     def block_table_repl(self, iter_content, stack, table):
         stack.clear()
 
-        element = moin_page.table(attrib={moin_page('class'): 'moin-wiki-table'})
+        element = moin_page.table(attrib={moin_page("class"): "moin-wiki-table"})
         stack.push(element)
         stack.push(moin_page.table_body())
 
@@ -334,28 +340,28 @@ def block_table_repl(self, iter_content, stack, table):
                     # Allow the mainloop to take care of the line after table end.
                     iter_content.push(line)
                     break
-            self.block_table_row(match.group('table'), stack, element)
+            self.block_table_row(match.group("table"), stack, element)
 
     def block_table_row(self, content, stack, table):
         element = moin_page.table_row()
         stack.push(element)
 
         for match in self.tablerow_re.finditer(content):
-            self._apply(match, 'tablerow', stack, table, element)
+            self._apply(match, "tablerow", stack, table, element)
 
         stack.pop()
 
-    block_text = r'(?P<text> .+ )'
+    block_text = r"(?P<text> .+ )"
 
     def block_text_repl(self, _iter_content, stack, text):
-        if stack.top_check('table', 'table-body', 'list', 'block-comment'):
+        if stack.top_check("table", "table-body", "list", "block-comment"):
             stack.clear()
-        if stack.top_check('body', ):
+        if stack.top_check("body"):
             element = moin_page.p()
             stack.push(element)
-        elif stack.top_check('p', ) or len(stack.top()):
+        elif stack.top_check("p") or len(stack.top()):
             # we are in a paragraph or multi-line list item, don't loose the whitespace
-            stack.top_append('\n')
+            stack.top_append("\n")
         self.parse_inline(text, stack, self.inline_re)
 
     indent = r"""
@@ -399,51 +405,64 @@ def indent_iter(self, iter_content, line, level):
             match = self.indent_re.match(line)
 
             new_level = 0
-            if match.group('indent'):
-                new_level = len(match.group('indent'))
+            if match.group("indent"):
+                new_level = len(match.group("indent"))
 
-            if match.group('list_begin') or level != new_level:
+            if match.group("list_begin") or level != new_level:
                 iter_content.push(line)
                 return
 
-            yield match.group('text')
-
-    def indent_repl(self, iter_content, stack, line,
-                    indent, text, list_begin=None, list_definition=None,
-                    list_definition_text=None, list_numbers=None,
-                    list_alpha=None, list_roman=None, list_bullet=None,
-                    list_start_number=None, list_start_roman=None, list_start_alpha=None,
-                    list_none=None):
+            yield match.group("text")
+
+    def indent_repl(
+        self,
+        iter_content,
+        stack,
+        line,
+        indent,
+        text,
+        list_begin=None,
+        list_definition=None,
+        list_definition_text=None,
+        list_numbers=None,
+        list_alpha=None,
+        list_roman=None,
+        list_bullet=None,
+        list_start_number=None,
+        list_start_roman=None,
+        list_start_alpha=None,
+        list_none=None,
+    ):
 
         level = len(indent)
 
         # default to blockquote / indented text / bulletless list
-        list_type = 'unordered', 'no-bullet'
+        list_type = "unordered", "no-bullet"
 
         if list_begin:
             if list_definition:
-                list_type = 'definition', None
+                list_type = "definition", None
             elif list_numbers:
-                list_type = 'ordered', None
-            elif list_alpha and list_alpha[:2] == 'A.':
-                list_type = 'ordered', 'upper-alpha'
+                list_type = "ordered", None
+            elif list_alpha and list_alpha[:2] == "A.":
+                list_type = "ordered", "upper-alpha"
             elif list_alpha:
-                list_type = 'ordered', 'lower-alpha'
-            elif list_roman and list_roman[:2] == 'I.':
-                list_type = 'ordered', 'upper-roman'
+                list_type = "ordered", "lower-alpha"
+            elif list_roman and list_roman[:2] == "I.":
+                list_type = "ordered", "upper-roman"
             elif list_roman:
-                list_type = 'ordered', 'lower-roman'
-            elif list_bullet == '*':
-                list_type = 'unordered', None
+                list_type = "ordered", "lower-roman"
+            elif list_bullet == "*":
+                list_type = "unordered", None
 
         element_use = None
         while len(stack) > 1:
             cur = stack.top()
-            if cur.tag.name == 'list-item-body':
+            if cur.tag.name == "list-item-body":
                 if level > cur.level:
                     element_use = cur
                     break
-            if cur.tag.name == 'list':
+            if cur.tag.name == "list":
                 if level >= cur.level and list_type == cur.list_type:
                     element_use = cur
                     break
@@ -453,7 +472,7 @@ def indent_repl(self, iter_content, stack, line,
             element_use = stack.top()
 
         if indent:
-            if element_use.tag.name != 'list':
+            if element_use.tag.name != "list":
                 attrib = {}
                 if not list_definition:
                     attrib[moin_page.item_label_generate] = list_type[0]
@@ -488,9 +507,9 @@ def indent_repl(self, iter_content, stack, line,
             match = self.block_re.match(line)
             it = iter
             # XXX: Hack to allow nowiki to ignore the list indentation
-            if match.lastgroup == 'nowiki':
+            if match.lastgroup == "nowiki":
                 it = iter_content
-            self._apply(match, 'block', it, new_stack)
+            self._apply(match, "block", it, new_stack)
 
     inline_comment = r"""
         (?P<comment>
@@ -510,7 +529,7 @@ def indent_repl(self, iter_content, stack, line,
 
     def inline_comment_repl(self, stack, comment, comment_begin=None, comment_end=None):
         if comment_begin:
-            attrib = {moin_page('class'): 'comment'}
+            attrib = {moin_page("class"): "comment"}
             elem = moin_page.span(attrib=attrib)
             stack.push(elem)
         else:
@@ -529,17 +548,17 @@ def inline_comment_repl(self, stack, comment, comment_begin=None, comment_end=No
         )
     """
 
-    def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
+    def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=""):
         if len(emphstrong) == 5:
-            if stack.top_check('emphasis'):
+            if stack.top_check("emphasis"):
                 stack.pop()
-                if stack.top_check('strong'):
+                if stack.top_check("strong"):
                     stack.pop()
                 else:
                     stack.push(moin_page.strong())
-            elif stack.top_check('strong'):
+            elif stack.top_check("strong"):
                 stack.pop()
-                if stack.top_check('emphasis'):
+                if stack.top_check("emphasis"):
                     stack.pop()
                 else:
                     stack.push(moin_page.emphasis())
@@ -551,12 +570,12 @@ def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
                     stack.push(moin_page.strong())
                     stack.push(moin_page.emphasis())
         elif len(emphstrong) == 3:
-            if stack.top_check('strong'):
+            if stack.top_check("strong"):
                 stack.pop()
             else:
                 stack.push(moin_page.strong())
         elif len(emphstrong) == 2:
-            if stack.top_check('emphasis'):
+            if stack.top_check("emphasis"):
                 stack.pop()
             else:
                 stack.push(moin_page.emphasis())
@@ -579,15 +598,16 @@ def inline_emphstrong_repl(self, stack, emphstrong, emphstrong_follow=''):
     """
 
     def inline_entity_repl(self, stack, entity):
-        if entity[1] == '#':
-            if entity[2] == 'x':
+        if entity[1] == "#":
+            if entity[2] == "x":
                 c = int(entity[3:-1], 16)
             else:
                 c = int(entity[2:-1], 10)
             c = chr(c)
         else:
             from html.entities import name2codepoint
-            c = chr(name2codepoint.get(entity[1:-1], 0xfffe))
+
+            c = chr(name2codepoint.get(entity[1:-1], 0xFFFE))
         stack.top_append(c)
 
     inline_size = r"""
@@ -604,7 +624,7 @@ def inline_entity_repl(self, stack, entity):
 
     def inline_size_repl(self, stack, size, size_begin=None, size_end=None):
         if size_begin:
-            size = '120%' if size[1] == '+' else '85%'
+            size = "120%" if size[1] == "+" else "85%"
             attrib = {moin_page.font_size: size}
             elem = moin_page.span(attrib=attrib)
             stack.push(elem)
@@ -635,7 +655,7 @@ def inline_strike_repl(self, stack, strike, strike_begin=None):
     """
 
     def inline_subscript_repl(self, stack, subscript, subscript_text):
-        attrib = {moin_page.baseline_shift: 'sub'}
+        attrib = {moin_page.baseline_shift: "sub"}
         elem = moin_page.span(attrib=attrib, children=[subscript_text])
         stack.top_append(elem)
 
@@ -648,7 +668,7 @@ def inline_subscript_repl(self, stack, subscript, subscript_text):
     """
 
     def inline_superscript_repl(self, stack, superscript, superscript_text):
-        attrib = {moin_page.baseline_shift: 'super'}
+        attrib = {moin_page.baseline_shift: "super"}
         elem = moin_page.span(attrib=attrib, children=[superscript_text])
         stack.top_append(elem)
 
@@ -659,7 +679,7 @@ def inline_superscript_repl(self, stack, superscript, superscript_text):
     """
 
     def inline_underline_repl(self, stack, underline):
-        if not stack.top_check('ins'):
+        if not stack.top_check("ins"):
             stack.push(moin_page.ins())
         else:
             stack.pop()
@@ -697,27 +717,35 @@ def inline_underline_repl(self, stack, underline):
             )?
             \]\]
         )
-    """ % dict(uri_schemes='|'.join(URI_SCHEMES))
+    """ % dict(
+        uri_schemes="|".join(URI_SCHEMES)
+    )
 
-    def inline_link_repl(self, stack, link, link_url=None, link_item=None,
-                         link_text=None, link_args=None,
-                         link_interwiki_site=None, link_interwiki_item=None):
+    def inline_link_repl(
+        self,
+        stack,
+        link,
+        link_url=None,
+        link_item=None,
+        link_text=None,
+        link_args=None,
+        link_interwiki_site=None,
+        link_interwiki_item=None,
+    ):
         """Handle all kinds of links."""
         attribs = {}
         query = []
         if link_args:
             link_args = parse_arguments(link_args)  # XXX needs different parsing
             for key in link_args.keys():
-                if key in ('target', 'title', 'download', 'class', 'accesskey'):
+                if key in ("target", "title", "download", "class", "accesskey"):
                     attribs[html(key)] = link_args[key]
-                if key[0] == '&':
-                    query.append(f'{key[1:]}={link_args[key]}')
+                if key[0] == "&":
+                    query.append(f"{key[1:]}={link_args[key]}")
 
         if link_interwiki_site:
             if is_known_wiki(link_interwiki_site):
-                link = Iri(scheme='wiki',
-                           authority=link_interwiki_site,
-                           path='/' + link_interwiki_item)
+                link = Iri(scheme="wiki", authority=link_interwiki_site, path="/" + link_interwiki_item)
                 attribs[xlink.href] = link
                 element = moin_page.a(attrib=attribs)
                 stack.push(element)
@@ -729,32 +757,32 @@ def inline_link_repl(self, stack, link, link_url=None, link_item=None,
                 return
             else:
                 # assume local language uses ":" inside of words, set link_item and continue
-                link_item = f'{link_interwiki_site}:{link_interwiki_item}'
+                link_item = f"{link_interwiki_site}:{link_interwiki_item}"
 
         if link_item is not None:
-            att = 'attachment:'  # moin 1.9 needed this for an attached file
+            att = "attachment:"  # moin 1.9 needed this for an attached file
             if link_item.startswith(att):
-                link_item = '/' + link_item[len(att):]  # now we have a subitem
-            if '#' in link_item:
+                link_item = "/" + link_item[len(att) :]  # now we have a subitem
+            if "#" in link_item:
                 try:
-                    if link_item.startswith('#') and '/+convert/' in request.url:
+                    if link_item.startswith("#") and "/+convert/" in request.url:
                         # avoid traceback in link.py when converting moinwiki item to reST | HTML | Docbook
-                        link_item = request.url.split('+convert/')[-1] + link_item
+                        link_item = request.url.split("+convert/")[-1] + link_item
                 except RuntimeError:  # CLI call has no valid request context
                     pass
-                link_item, fragment = link_item.rsplit('#', 1)
+                link_item, fragment = link_item.rsplit("#", 1)
             else:
                 link_item, fragment = link_item, None
-            if '?' in link_item:
-                path, link_query = link_item.rsplit('?', 1)
+            if "?" in link_item:
+                path, link_query = link_item.rsplit("?", 1)
                 query.insert(0, link_query)
             else:
                 path, link_query = link_item, None
             if query:
-                query = '&' + '&'.join(query)
+                query = "&" + "&".join(query)
             else:
                 query = None
-            target = Iri(scheme='wiki.local', path=path, query=query, fragment=fragment)
+            target = Iri(scheme="wiki.local", path=path, query=query, fragment=fragment)
             text = link_item
         else:
             target = Iri(link_url)
@@ -782,7 +810,7 @@ def inline_link_repl(self, stack, link, link_url=None, link_item=None,
         )
     """
 
-    def inline_macro_repl(self, stack, macro, macro_name, macro_args=''):
+    def inline_macro_repl(self, stack, macro, macro_name, macro_args=""):
         """Handles macros using the placeholder syntax."""
         elem = self.macro(macro_name, macro_args, macro)
         stack.top_append(elem)
@@ -836,8 +864,7 @@ def inline_nowiki_repl(self, stack, nowiki, nowiki_text=None, nowiki_text_backti
         )
     """
 
-    def inline_object_repl(self, stack, object, object_url=None, object_item=None,
-                           object_text=None, object_args=None):
+    def inline_object_repl(self, stack, object, object_url=None, object_item=None, object_text=None, object_args=None):
         """Handles objects transcluded within the page."""
         if object_args:
             args = parse_arguments(object_args, parse_re=object_re).keyword
@@ -845,9 +872,9 @@ def inline_object_repl(self, stack, object, object_url=None, object_item=None,
             args = {}
         query_keys = {}
         attrib = {}
-        whitelist = ['width', 'height', 'class']
+        whitelist = ["width", "height", "class"]
         for attr, value in args.items():
-            if attr.startswith('&'):
+            if attr.startswith("&"):
                 query_keys[attr[1:]] = value
             elif attr in whitelist:
                 attrib[html(attr)] = value
@@ -857,10 +884,10 @@ def inline_object_repl(self, stack, object, object_url=None, object_item=None,
             # img tag
             query = urlencode(query_keys, encoding=CHARSET)
             # TODO: moin 1.9 needed this for an attached file; move functionality to scripts/migration/moin/import19.py
-            att = 'attachment:'
+            att = "attachment:"
             if object_item.startswith(att):
-                object_item = '/' + object_item[len(att):]  # now we have a subitem
-            target = Iri(scheme='wiki.local', path=object_item, query=query, fragment=None)
+                object_item = "/" + object_item[len(att) :]  # now we have a subitem
+            target = Iri(scheme="wiki.local", path=object_item, query=query, fragment=None)
             attrib[xinclude.href] = target
             element = xinclude.include(attrib=attrib)
             stack.top_append(element)
@@ -909,13 +936,13 @@ def inline_object_repl(self, stack, object, object_url=None, object_item=None,
     def tablerow_cell_repl(self, stack, table, row, cell, cell_marker, cell_text, cell_args=None):
 
         def add_attr_to_style(attrib, attr):
-            attr = attr.strip().encode('ascii', errors='backslashreplace').decode('unicode-escape')
-            if not attr.endswith(';'):
-                attr += ';'
-            if attrib.get(moin_page('style'), ""):
-                attrib[moin_page('style')] = attrib.get(moin_page('style'), "") + " " + attr
+            attr = attr.strip().encode("ascii", errors="backslashreplace").decode("unicode-escape")
+            if not attr.endswith(";"):
+                attr += ";"
+            if attrib.get(moin_page("style"), ""):
+                attrib[moin_page("style")] = attrib.get(moin_page("style"), "") + " " + attr
             else:
-                attrib[moin_page('style')] = attr
+                attrib[moin_page("style")] = attr
 
         element = moin_page.table_cell()
         stack.push(element)
@@ -929,76 +956,66 @@ def add_attr_to_style(attrib, attr):
 
             # any positional parameters will be errors;  retrieved as (key=None, value="some-positional-param");
             for key, value in cell_args.items():
-                if key == 'bgcolor':
+                if key == "bgcolor":
                     if no_errors:
                         # avoid overriding error highlighting
-                        add_attr_to_style(element.attrib, f'background-color: {value};')
-                elif key == 'rowbgcolor':
-                    add_attr_to_style(row.attrib, f'background-color: {value};')
-                elif key == 'tablebgcolor':
-                    add_attr_to_style(table.attrib, f'background-color: {value};')
-                elif key == 'width':
-                    add_attr_to_style(element.attrib, f'width: {value};')
-                elif key == 'tablewidth':
-                    add_attr_to_style(table.attrib, f'width: {value};')
-                elif key == 'caption':
-                    table.insert(0, moin_page.caption(children=[value, ]))
-                elif key == 'tableclass':
-                    table.attrib[moin_page('class')] = value + ' moin-wiki-table'
-                elif key == 'rowclass':
-                    row.attrib[moin_page('class')] = value
-                elif key == 'class':
-                    element.attrib[moin_page('class')] = value
-                elif key == 'tablestyle':
+                        add_attr_to_style(element.attrib, f"background-color: {value};")
+                elif key == "rowbgcolor":
+                    add_attr_to_style(row.attrib, f"background-color: {value};")
+                elif key == "tablebgcolor":
+                    add_attr_to_style(table.attrib, f"background-color: {value};")
+                elif key == "width":
+                    add_attr_to_style(element.attrib, f"width: {value};")
+                elif key == "tablewidth":
+                    add_attr_to_style(table.attrib, f"width: {value};")
+                elif key == "caption":
+                    table.insert(0, moin_page.caption(children=[value]))
+                elif key == "tableclass":
+                    table.attrib[moin_page("class")] = value + " moin-wiki-table"
+                elif key == "rowclass":
+                    row.attrib[moin_page("class")] = value
+                elif key == "class":
+                    element.attrib[moin_page("class")] = value
+                elif key == "tablestyle":
                     add_attr_to_style(table.attrib, value)
-                elif key == 'rowstyle':
+                elif key == "rowstyle":
                     add_attr_to_style(row.attrib, value)
-                elif key == 'style':
+                elif key == "style":
                     if no_errors:
                         add_attr_to_style(element.attrib, value)
-                elif key == 'tableid':
-                    table.attrib[moin_page('id')] = value
-                elif key == 'rowid':
-                    row.attrib[moin_page('id')] = value
-                elif key == 'id':
-                    element.attrib[moin_page('id')] = value
-                elif key == 'number-columns-spanned':
+                elif key == "tableid":
+                    table.attrib[moin_page("id")] = value
+                elif key == "rowid":
+                    row.attrib[moin_page("id")] = value
+                elif key == "id":
+                    element.attrib[moin_page("id")] = value
+                elif key == "number-columns-spanned":
                     element.attrib[moin_page(key)] = value
-                elif key == 'number-rows-spanned':
+                elif key == "number-rows-spanned":
                     element.attrib[moin_page(key)] = value
                 else:
-                    if key == 'error' or key is None:
+                    if key == "error" or key is None:
                         error = value
                     else:
                         error = key
-                    cell_markup = cell.split('>')[0]
-                    cell_markup = cell_markup.split('<')[1]
-                    msg1 = _('Error:')
-                    msg2 = _('is invalid within')
-                    cell_text = '[ {} "{}" {} <{}>&nbsp;]<<BR>>{}'.format(
-                        msg1, error, msg2, cell_markup, cell_text)
+                    cell_markup = cell.split(">")[0]
+                    cell_markup = cell_markup.split("<")[1]
+                    msg1 = _("Error:")
+                    msg2 = _("is invalid within")
+                    cell_text = '[ {} "{}" {} <{}>&nbsp;]<<BR>>{}'.format(msg1, error, msg2, cell_markup, cell_text)
                     if no_errors:
-                        add_attr_to_style(element.attrib, 'background-color: pink; color: black;')
+                        add_attr_to_style(element.attrib, "background-color: pink; color: black;")
                     no_errors = False
 
         self.parse_inline(cell_text, stack, self.inline_re)
 
-        stack.pop_name('table-cell')
+        stack.pop_name("table-cell")
 
     header_footer_re = re.compile(header_footer_separator, re.X)
 
     # Block elements
-    block = (
-        block_line,
-        block_comment,
-        block_head,
-        block_separator,
-        block_macro,
-        block_nowiki,
-        block_table,
-        block_text,
-    )
-    block_re = re.compile('|'.join(block), re.X | re.U | re.M)
+    block = (block_line, block_comment, block_head, block_separator, block_macro, block_nowiki, block_table, block_text)
+    block_re = re.compile("|".join(block), re.X | re.U | re.M)
 
     indent_re = re.compile(indent, re.X)
 
@@ -1016,7 +1033,7 @@ def add_attr_to_style(attrib, attr):
         inline_underline,
         inline_entity,
     )
-    inline_re = re.compile('|'.join(inline), re.X | re.U)
+    inline_re = re.compile("|".join(inline), re.X | re.U)
 
     # link text may have markup, excluding links
     inlinedesc = (
@@ -1032,7 +1049,7 @@ def add_attr_to_style(attrib, attr):
         inline_underline,
         inline_entity,
     )
-    inlinedesc_re = re.compile('|'.join(inlinedesc), re.X | re.U)
+    inlinedesc_re = re.compile("|".join(inlinedesc), re.X | re.U)
 
     # Nowiki end
     nowiki_end_re = re.compile(nowiki_end, re.X)
@@ -1048,7 +1065,7 @@ def _apply(self, match, prefix, *args):
         Call the _repl method for the last matched group with the given prefix.
         """
         data = {str(k): v for k, v in match.groupdict().items() if v is not None}
-        func = f'{prefix}_{match.lastgroup}_repl'
+        func = f"{prefix}_{match.lastgroup}_repl"
         # logging.debug("calling %s(%r, %r)" % (func, args, data))
         getattr(self, func)(*args, **data)
 
@@ -1056,7 +1073,7 @@ def parse_block(self, iter_content, arguments):
         attrib = {}
         if arguments:
             for key, value in arguments.keyword.items():
-                if key in ('style', 'class', ):
+                if key in ("style", "class"):
                     attrib[moin_page(key)] = value
 
         body = moin_page.body(attrib=attrib)
@@ -1074,10 +1091,10 @@ def parse_inline(self, text, stack, inline_re):
         pos = 0
         for match in inline_re.finditer(text):
             # Handle leading text
-            stack.top_append_ifnotempty(text[pos:match.start()])
+            stack.top_append_ifnotempty(text[pos : match.start()])
             pos = match.end()
 
-            self._apply(match, 'inline', stack)
+            self._apply(match, "inline", stack)
 
         # Handle trailing text
         stack.top_append_ifnotempty(text[pos:])
@@ -1094,4 +1111,4 @@ def macro_text(self, text):
 
 
 default_registry.register(Converter.factory, type_moin_wiki, type_moin_document)
-default_registry.register(Converter.factory, Type('x-moin/format;name=wiki'), type_moin_document)
+default_registry.register(Converter.factory, Type("x-moin/format;name=wiki"), type_moin_document)
diff --git a/src/moin/converters/moinwiki_out.py b/src/moin/converters/moinwiki_out.py
index 188a2efdd..86d32e5d6 100644
--- a/src/moin/converters/moinwiki_out.py
+++ b/src/moin/converters/moinwiki_out.py
@@ -26,6 +26,7 @@
 from . import default_registry
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -34,42 +35,43 @@ class Moinwiki:
     Moinwiki syntax elements
     It's dummy
     """
-    h = '='
-    a_open = '[['
-    a_separator = '|'
-    a_close = ']]'
-    verbatim_open = '{'  # * 3
-    verbatim_close = '}'  # * 3
-    monospace = '`'
+
+    h = "="
+    a_open = "[["
+    a_separator = "|"
+    a_close = "]]"
+    verbatim_open = "{"  # * 3
+    verbatim_close = "}"  # * 3
+    monospace = "`"
     strong = "'''"
     emphasis = "''"
-    underline = '__'
-    samp_open = '{{{'  # 3 brackets is only option for inline
-    samp_close = '}}}'
-    stroke_open = '--('
-    stroke_close = ')--'
-    table_marker = '||'
-    p = '\n'
-    linebreak = '<<BR>>'
-    larger_open = '~+'
-    larger_close = '+~'
-    smaller_open = '~-'
-    smaller_close = '-~'
-    object_open = '{{'
-    object_close = '}}'
-    definition_list_marker = '::'
-    separator = '----'
+    underline = "__"
+    samp_open = "{{{"  # 3 brackets is only option for inline
+    samp_close = "}}}"
+    stroke_open = "--("
+    stroke_close = ")--"
+    table_marker = "||"
+    p = "\n"
+    linebreak = "<<BR>>"
+    larger_open = "~+"
+    larger_close = "+~"
+    smaller_open = "~-"
+    smaller_close = "-~"
+    object_open = "{{"
+    object_close = "}}"
+    definition_list_marker = "::"
+    separator = "----"
     # TODO: definition list
     list_type = {
-        ('definition', None): '',
-        ('ordered', None): '1.',
-        ('ordered', 'lower-alpha'): 'a.',
-        ('ordered', 'upper-alpha'): 'A.',
-        ('ordered', 'lower-roman'): 'i.',
-        ('ordered', 'upper-roman'): 'I.',
-        ('unordered', None): '*',
-        ('unordered', 'no-bullet'): '.',
-        (None, None): '::',
+        ("definition", None): "",
+        ("ordered", None): "1.",
+        ("ordered", "lower-alpha"): "a.",
+        ("ordered", "upper-alpha"): "A.",
+        ("ordered", "lower-roman"): "i.",
+        ("ordered", "upper-roman"): "I.",
+        ("unordered", None): "*",
+        ("unordered", "no-bullet"): ".",
+        (None, None): "::",
     }
 
     def __init__(self):
@@ -80,41 +82,37 @@ class Converter:
     """
     Converter application/x.moin.document -> text/x.moin.wiki
     """
-    namespaces = {
-        moin_page.namespace: 'moinpage',
-        xinclude: 'xinclude',
-    }
+
+    namespaces = {moin_page.namespace: "moinpage", xinclude: "xinclude"}
 
     supported_tag = {
-        'moinpage': (
-            'a',
-            'blockcode',
-            'break_line',
-            'code',
-            'div',
-            'emphasis',
-            'h',
-            'list',
-            'list_item',
-            'list_item_label',
-            'list_item_body',
-            'nowiki',
-            'p',
-            'page',
-            'separator',
-            'span',
-            'strong',
-            'object',
-            'table',
-            'table_header',
-            'table_footer',
-            'table_body',
-            'table_row',
-            'table_cell',
-        ),
-        'xinclude': (
-            'include',
+        "moinpage": (
+            "a",
+            "blockcode",
+            "break_line",
+            "code",
+            "div",
+            "emphasis",
+            "h",
+            "list",
+            "list_item",
+            "list_item_label",
+            "list_item_body",
+            "nowiki",
+            "p",
+            "page",
+            "separator",
+            "span",
+            "strong",
+            "object",
+            "table",
+            "table_header",
+            "table_footer",
+            "table_body",
+            "table_row",
+            "table_cell",
         ),
+        "xinclude": ("include",),
     }
 
     @classmethod
@@ -124,15 +122,15 @@ def factory(cls, input, output, **kw):
     def __init__(self):
 
         # TODO: create class containing all table attributes
-        self.table_tableclass = ''
-        self.table_tablestyle = ''
-        self.table_rowsclass = ''
-        self.table_rowsstyle = ''
-        self.table_rowstyle = ''
-        self.table_rowclass = ''
-
-        self.list_item_labels = ['', ]
-        self.list_item_label = ''
+        self.table_tableclass = ""
+        self.table_tablestyle = ""
+        self.table_rowsclass = ""
+        self.table_rowsstyle = ""
+        self.table_rowstyle = ""
+        self.table_rowclass = ""
+
+        self.list_item_labels = [""]
+        self.list_item_label = ""
         self.list_level = 0
         self.unknown_macro_list = []
 
@@ -140,14 +138,15 @@ def __init__(self):
         # 'table' - text inside table - <p> = '<<BR>>' and </p> = ''
         # 'list' - text inside list - <p> if after </p> = '<<BR>>' and </p> = ''
         # status added because of differences in interpretation of <p> in different places
+
     def __call__(self, root):
-        self.status = ['text', ]
+        self.status = ["text"]
         self.last_closed = None
         self.list_item_label = []
         content = self.open(root)
-        while '\n\n\n' in content:
-            content = content.replace('\n\n\n', '\n\n')
-        content = content[1:] if content.startswith('\n') else content
+        while "\n\n\n" in content:
+            content = content.replace("\n\n\n", "\n\n")
+        content = content[1:] if content.startswith("\n") else content
         return content
 
     def open_children(self, elem):
@@ -157,22 +156,22 @@ def open_children(self, elem):
                 # open function can change self.output
                 childrens_output.append(self.open(child))
             else:
-                ret = ''
+                ret = ""
                 if self.status[-1] == "text":
                     if self.last_closed == "p":
-                        ret = '\n'
-                if child == '\n' and getattr(elem, 'level', 0):
-                    child = child + ' ' * (len(''.join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
-                childrens_output.append(f'{ret}{child}')
-                self.last_closed = 'text'
-        out = ''.join(childrens_output)
+                        ret = "\n"
+                if child == "\n" and getattr(elem, "level", 0):
+                    child = child + " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
+                childrens_output.append(f"{ret}{child}")
+                self.last_closed = "text"
+        out = "".join(childrens_output)
         return out
 
     def open(self, elem):
         uri = elem.tag.uri
         name = self.namespaces.get(uri, None)
         if name is not None:
-            n = 'open_' + name
+            n = "open_" + name
             f = getattr(self, n, None)
             if f is not None:
                 return f(elem)
@@ -180,89 +179,89 @@ def open(self, elem):
         return self.open_children(elem)
 
     def open_moinpage(self, elem):
-        n = 'open_moinpage_' + elem.tag.name.replace('-', '_')
+        n = "open_moinpage_" + elem.tag.name.replace("-", "_")
         f = getattr(self, n, None)
         if f:
             ret = f(elem)
-            self.last_closed = elem.tag.name.replace('-', '_')
+            self.last_closed = elem.tag.name.replace("-", "_")
             return ret
         return self.open_children(elem)
 
     def open_moinpage_a(self, elem):
         href = elem.get(xlink.href, None)
         params = {}
-        params['target'] = elem.get(html.target, None)
-        params['title'] = elem.get(html.title_, None)
-        params['download'] = elem.get(html.download, None)
-        params['class'] = elem.get(html.class_, None)
-        params['accesskey'] = elem.get(html.accesskey, None)
+        params["target"] = elem.get(html.target, None)
+        params["title"] = elem.get(html.title_, None)
+        params["download"] = elem.get(html.download, None)
+        params["class"] = elem.get(html.class_, None)
+        params["accesskey"] = elem.get(html.accesskey, None)
         # we sort so output order is predictable for tests
-        params = ','.join([f'{p}="{params[p]}"' for p in sorted(params) if params[p]])
+        params = ",".join([f'{p}="{params[p]}"' for p in sorted(params) if params[p]])
 
         # XXX: We don't have Iri support for now
         if isinstance(href, Iri):
             href = str(href)
         # TODO: this can be done using one regex, can it?
-        href = href.split('#')
+        href = href.split("#")
         if len(href) > 1:
             href, fragment = href
         else:
-            href, fragment = href[0], ''
-        href = href.split('?')
-        args = ''
+            href, fragment = href[0], ""
+        href = href.split("?")
+        args = ""
         if len(href) > 1:
             # With normal
-            args = ''.join(['&' + s for s in findall(r'(?:^|;|,|&|)(\w+=\w+)(?:,|&|$|)', href[1])])
-        href = href[0].split('wiki.local:')[-1]
+            args = "".join(["&" + s for s in findall(r"(?:^|;|,|&|)(\w+=\w+)(?:,|&|$|)", href[1])])
+        href = href[0].split("wiki.local:")[-1]
         if args:
-            args = '?' + args[1:]
+            args = "?" + args[1:]
         if fragment:
-            args += '#' + fragment
+            args += "#" + fragment
         text = self.open_children(elem)
         if text == href:
-            text = ''
-        ret = f'{href}{args}|{text}|{params}'
-        ret = ret.rstrip('|')
-        if ret.startswith('wiki://'):
+            text = ""
+        ret = f"{href}{args}|{text}|{params}"
+        ret = ret.rstrip("|")
+        if ret.startswith("wiki://"):
             # interwiki fixup
             ret = ret[7:]
-            ret = ret.replace('/', ':', 1)
+            ret = ret.replace("/", ":", 1)
         return Moinwiki.a_open + ret + Moinwiki.a_close
 
     def open_moinpage_blockcode(self, elem):
-        text = ''.join(elem.itertext())
+        text = "".join(elem.itertext())
         max_subpage_lvl = 3
-        for s in findall(r'}+', text):
+        for s in findall(r"}+", text):
             if max_subpage_lvl <= len(s):
                 max_subpage_lvl = len(s) + 1
-        ret = f'{Moinwiki.verbatim_open * max_subpage_lvl}\n{text}\n{Moinwiki.verbatim_close * max_subpage_lvl}\n'
-        return '\n' + ret + '\n'
+        ret = f"{Moinwiki.verbatim_open * max_subpage_lvl}\n{text}\n{Moinwiki.verbatim_close * max_subpage_lvl}\n"
+        return "\n" + ret + "\n"
 
     def open_moinpage_block_comment(self, elem):
         # text child similar to: ## some block comment
-        return '\n\n' + '\n'.join(elem) + '\n\n'
+        return "\n\n" + "\n".join(elem) + "\n\n"
 
     def open_moinpage_blockquote(self, elem):
         # blockquotes are generated by html_in (and maybe others), not by moinwiki_in
         # to achieve same look, we convert to bulletless unordered list
         ret = self.open_children(elem)
         ret = ret.strip()
-        ret = ret.replace('\n\n', '\n\n    . ')
-        ret = ret.split('<<BR>>')
+        ret = ret.replace("\n\n", "\n\n    . ")
+        ret = ret.split("<<BR>>")
         indented = []
         for line in ret:
-            indented.append('    . ' + line)
-        return '\n\n' + '\n'.join(indented) + '\n\n'
+            indented.append("    . " + line)
+        return "\n\n" + "\n".join(indented) + "\n\n"
 
     def open_moinpage_code(self, elem):
         ret = Moinwiki.monospace
-        ret += ''.join(elem.itertext())
+        ret += "".join(elem.itertext())
         ret += Moinwiki.monospace
         return ret
 
     def open_moinpage_div(self, elem):
         childrens_output = self.open_children(elem)
-        return '\n\n' + childrens_output + '\n\n'
+        return "\n\n" + childrens_output + "\n\n"
 
     def open_moinpage_emphasis(self, elem):
         childrens_output = self.open_children(elem)
@@ -273,73 +272,70 @@ def open_moinpage_h(self, elem):
         try:
             level = int(level)
         except ValueError:
-            raise ElementException('page:outline-level needs to be an integer')
+            raise ElementException("page:outline-level needs to be an integer")
         if level < 1:
             level = 1
         elif level > 6:
             level = 6
-        ret = Moinwiki.h * level + ' '
-        ret += ''.join(elem.itertext())
-        ret += f' {Moinwiki.h * level}\n'
-        return '\n' + ret
+        ret = Moinwiki.h * level + " "
+        ret += "".join(elem.itertext())
+        ret += f" {Moinwiki.h * level}\n"
+        return "\n" + ret
 
     def open_moinpage_line_break(self, elem):
         return Moinwiki.linebreak
 
     def open_moinpage_list(self, elem):
         label_type = elem.get(moin_page.item_label_generate, None), elem.get(moin_page.list_style_type, None)
-        self.list_item_labels.append(
-            Moinwiki.list_type.get(label_type, ''))
+        self.list_item_labels.append(Moinwiki.list_type.get(label_type, ""))
         self.list_level += 1
-        ret = ''
-        if self.status[-1] != 'text' or self.last_closed:
-            ret = '\n'
-        self.status.append('list')
+        ret = ""
+        if self.status[-1] != "text" or self.last_closed:
+            ret = "\n"
+        self.status.append("list")
         self.last_closed = None
         childrens_output = self.open_children(elem)
         list_start = elem.attrib.get(moin_page.list_start)
         if list_start:
-            child_out1, child_out2 = childrens_output.split('.', 1)
-            childrens_output = f'{child_out1}.#{list_start}{child_out2}'
+            child_out1, child_out2 = childrens_output.split(".", 1)
+            childrens_output = f"{child_out1}.#{list_start}{child_out2}"
         self.list_item_labels.pop()
         self.list_level -= 1
         self.status.pop()
-        if self.status[-1] == 'list':
-            ret_end = ''
+        if self.status[-1] == "list":
+            ret_end = ""
         else:
-            ret_end = '\n'
+            ret_end = "\n"
         return f"{ret}{childrens_output}{ret_end}"
 
     def open_moinpage_list_item(self, elem):
-        self.list_item_label = self.list_item_labels[-1] + ' '
+        self.list_item_label = self.list_item_labels[-1] + " "
         return self.open_children(elem)
 
     def open_moinpage_list_item_label(self, elem):
-        ret = ''
-        if self.list_item_labels[-1] == '' or self.list_item_labels[-1] == Moinwiki.definition_list_marker:
+        ret = ""
+        if self.list_item_labels[-1] == "" or self.list_item_labels[-1] == Moinwiki.definition_list_marker:
             self.list_item_labels[-1] = Moinwiki.definition_list_marker
-            self.list_item_label = self.list_item_labels[-1] + ' '
-            ret = ' ' * (len(''.join(self.list_item_labels[:-1])) +
-                         len(self.list_item_labels[:-1]))  # self.list_level
+            self.list_item_label = self.list_item_labels[-1] + " "
+            ret = " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))  # self.list_level
             if self.last_closed:
-                ret = f'\n{ret}'
+                ret = f"\n{ret}"
         childrens_output = self.open_children(elem)
         return f"{ret}{childrens_output}{Moinwiki.definition_list_marker}"
 
     def open_moinpage_list_item_body(self, elem):
-        ret = ''
+        ret = ""
         if self.last_closed:
-            ret = '\n'
-        ret += ' ' * (len(''.join(self.list_item_labels[:-1])) +
-                      len(self.list_item_labels[:-1])) + self.list_item_label
+            ret = "\n"
+        ret += " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1])) + self.list_item_label
         return ret + self.open_children(elem)
 
     def open_moinpage_note(self, elem):
         class_ = elem.get(moin_page.note_class, "")
         if class_:
             if class_ == "footnote":
-                return f'<<FootNote({self.open_children(elem)})>>'
-        return '\n<<FootNote()>>\n'
+                return f"<<FootNote({self.open_children(elem)})>>"
+        return "\n<<FootNote()>>\n"
 
     def open_moinpage_nowiki(self, elem):
         """{{{#!wiki ... or {{{#!highlight ... etc."""
@@ -348,10 +344,15 @@ def open_moinpage_nowiki(self, elem):
             nowiki_args = all_nowiki_args[0]
         except IndexError:
             # this happens only with pytest, why wasn't open_moinpage_blockcode called?
-            nowiki_args = ''
+            nowiki_args = ""
         nowiki_marker_len = int(nowiki_marker_len)
-        return '\n' + Moinwiki.verbatim_open * nowiki_marker_len + f'{nowiki_args}\n{content}\n' + \
-               Moinwiki.verbatim_close * nowiki_marker_len + '\n'
+        return (
+            "\n"
+            + Moinwiki.verbatim_open * nowiki_marker_len
+            + f"{nowiki_args}\n{content}\n"
+            + Moinwiki.verbatim_close * nowiki_marker_len
+            + "\n"
+        )
 
     def include_object(self, xpointer, href):
         """
@@ -367,22 +368,22 @@ def include_object(self, xpointer, href):
         TODO: some 1.9 features have been dropped.
         """
         arguments = {}
-        href = href.split(':')[-1]
-        args = xpointer.split('page:include(')[1][:-1]
-        args = args[:-1].split(') ')
+        href = href.split(":")[-1]
+        args = xpointer.split("page:include(")[1][:-1]
+        args = args[:-1].split(") ")
         for arg in args:
-            key, val = arg.split('(')
+            key, val = arg.split("(")
             arguments[key] = val
         parms = f",{arguments.get('heading', '')},{arguments.get('level', '')}"
-        for key in ('sort', 'items', 'skipitems'):
+        for key in ("sort", "items", "skipitems"):
             if key in arguments:
                 parms += f',{key}="{arguments[key]}"'
-        while parms.endswith(','):
+        while parms.endswith(","):
             parms = parms[:-1]
-        if not href and 'pages' in arguments:
+        if not href and "pages" in arguments:
             # xpointer needs unescaping, see comments above
-            href = arguments['pages'].replace('^(', '(').replace('^)', ')').replace('^^', '^')
-        return f'<<Include({href}{parms})>>'
+            href = arguments["pages"].replace("^(", "(").replace("^)", ")").replace("^^", "^")
+        return f"<<Include({href}{parms})>>"
 
     def open_moinpage_object(self, elem):
         """
@@ -390,7 +391,7 @@ def open_moinpage_object(self, elem):
 
         Other macros are processes by open_moinpage_part.
         """
-        href = elem.get(xlink.href, elem.get(xinclude.href, ''))
+        href = elem.get(xlink.href, elem.get(xinclude.href, ""))
         if isinstance(href, Iri):
             href = str(href)
             href = urllib.parse.unquote(href)
@@ -400,60 +401,61 @@ def open_moinpage_object(self, elem):
         except KeyError:
             pass
 
-        href = href.split('?')
-        args = ''
+        href = href.split("?")
+        args = ""
         if len(href) > 1:
-            args = ' '.join([s for s in findall(r'(?:^|;|,|&|)(\w+=\w+)(?:,|&|$)', href[1]) if s[:3] != 'do='])
-        href = href[0].split('wiki.local:')[-1]
+            args = " ".join([s for s in findall(r"(?:^|;|,|&|)(\w+=\w+)(?:,|&|$)", href[1]) if s[:3] != "do="])
+        href = href[0].split("wiki.local:")[-1]
 
         if len(elem) and isinstance(elem[0], str):
             # alt text for objects is enclosed within <object...>...</object>
             alt = elem[0]
         else:
-            alt = elem.attrib.get(html.alt, '')
+            alt = elem.attrib.get(html.alt, "")
 
-        whitelist = {html.width: 'width', html.height: 'height', html.class_: 'class'}
+        whitelist = {html.width: "width", html.height: "height", html.class_: "class"}
         options = []
         for attr, value in sorted(elem.attrib.items()):
             if attr in whitelist.keys():
                 options.append(f'{whitelist[attr]}="{value}"')
 
         if args:
-            args = '&' + args
+            args = "&" + args
         if options:
             if args:
-                args += ' '
-            args += ' '.join(options)
+                args += " "
+            args += " ".join(options)
 
-        ret = f'{Moinwiki.object_open}{href}|{alt}|{args}{Moinwiki.object_close}'
+        ret = f"{Moinwiki.object_open}{href}|{alt}|{args}{Moinwiki.object_close}"
         ret = sub(r"\|+}}", "}}", ret)
         return ret
 
     def open_moinpage_p(self, elem):
-        if moin_page.class_ in elem.attrib and 'moin-error' in elem.attrib[moin_page.class_]:
+        if moin_page.class_ in elem.attrib and "moin-error" in elem.attrib[moin_page.class_]:
             # ignore error messages inserted into DOM
-            return ''
+            return ""
 
         self.status.append("p")
         ret = ""
-        if self.status[-2] == 'text':
-            if self.last_closed == 'text':
+        if self.status[-2] == "text":
+            if self.last_closed == "text":
                 ret = Moinwiki.p * 2 + self.open_children(elem) + Moinwiki.p
             elif self.last_closed:
                 ret = Moinwiki.p + self.open_children(elem) + Moinwiki.p
             else:
                 ret = self.open_children(elem) + Moinwiki.p
-        elif self.status[-2] == 'table':
-            if self.last_closed and self.last_closed != 'table_cell' and self.last_closed != 'table_row':
+        elif self.status[-2] == "table":
+            if self.last_closed and self.last_closed != "table_cell" and self.last_closed != "table_row":
                 ret = Moinwiki.linebreak + self.open_children(elem)
             else:
                 ret = self.open_children(elem)
-        elif self.status[-2] == 'list':  # TODO: still possible? <p> after <li> removed from moinwiki_in
-            if self.last_closed \
-               and (self.last_closed != 'list_item' and
-                    self.last_closed != 'list_item_header' and
-                    self.last_closed != 'list_item_footer' and
-                    self.last_closed != 'list_item_label'):
+        elif self.status[-2] == "list":  # TODO: still possible? <p> after <li> removed from moinwiki_in
+            if self.last_closed and (
+                self.last_closed != "list_item"
+                and self.last_closed != "list_item_header"
+                and self.last_closed != "list_item_footer"
+                and self.last_closed != "list_item_label"
+            ):
                 ret = Moinwiki.linebreak + self.open_children(elem)
             else:
                 ret = self.open_children(elem)
@@ -464,50 +466,51 @@ def open_moinpage_p(self, elem):
 
     def open_moinpage_page(self, elem):
         self.last_closed = None
-        ret = ''
+        ret = ""
         if len(self.status) > 1:
             ret = "#!wiki"
             max_subpage_lvl = 3
-            self.status.append('text')
+            self.status.append("text")
             childrens_output = self.open_children(elem)
             self.status.pop()
-            for s in findall(r'}+', childrens_output):
+            for s in findall(r"}+", childrens_output):
                 if max_subpage_lvl <= len(s):
                     max_subpage_lvl = len(s) + 1
-            return '{}{}{}{}\n'.format(
+            return "{}{}{}{}\n".format(
                 Moinwiki.verbatim_open * max_subpage_lvl,
-                ret, childrens_output,
-                Moinwiki.verbatim_close * max_subpage_lvl)
+                ret,
+                childrens_output,
+                Moinwiki.verbatim_close * max_subpage_lvl,
+            )
 
-        self.status.append('text')
+        self.status.append("text")
         childrens_output = self.open_children(elem)
         self.status.pop()
         return childrens_output
 
     def open_moinpage_body(self, elem):
-        class_ = elem.get(moin_page.class_, '').replace(' ', '/')
+        class_ = elem.get(moin_page.class_, "").replace(" ", "/")
         if class_:
-            ret = f' {class_}\n'
+            ret = f" {class_}\n"
         elif len(self.status) > 2:
-            ret = '\n'
+            ret = "\n"
         else:
-            ret = ''
+            ret = ""
         childrens_output = self.open_children(elem)
         return f"{ret}{childrens_output}"
 
     def open_moinpage_part(self, elem):
-        type = elem.get(moin_page.content_type, "").split(';')
+        type = elem.get(moin_page.content_type, "").split(";")
         if len(type) == 2:
             if type[0] == "x-moin/macro":
-                name = type[1].split('=')[1]
+                name = type[1].split("=")[1]
                 if name not in macro_modules:
                     logging.debug(f"Unknown macro {name} found.")
                     if name not in self.unknown_macro_list:
                         self.unknown_macro_list.append(name)
-                eol = '\n\n' if elem.tag.name == 'part' else ''
+                eol = "\n\n" if elem.tag.name == "part" else ""
                 if len(elem) and elem[0].tag.name == "arguments":
-                    return "{0}<<{1}({2})>>{0}".format(
-                        eol, name, elem[0][0])
+                    return "{0}<<{1}({2})>>{0}".format(eol, name, elem[0][0])
                 else:
                     return "{0}<<{1}()>>{0}".format(eol, name)
             elif type[0] == "x-moin/format":
@@ -522,53 +525,54 @@ def open_moinpage_part(self, elem):
                     elem = next(elem_it)
                 ret = f"{ret}\n{' '.join(elem.itertext())}\n}}}}}}\n"
                 return ret
-        return Markup.unescape(elem.get(moin_page.alt, '')) + "\n"
+        return Markup.unescape(elem.get(moin_page.alt, "")) + "\n"
 
     def open_moinpage_inline_part(self, elem):
         ret = self.open_moinpage_part(elem)
-        if ret[-1] == '\n':
+        if ret[-1] == "\n":
             ret = ret[:-1]
         return ret
 
     def open_moinpage_samp(self, elem):
         # text {{{more text}}} end
         ret = Moinwiki.samp_open
-        ret += ''.join(elem.itertext())
+        ret += "".join(elem.itertext())
         ret += Moinwiki.samp_close
         return ret
 
-    def open_moinpage_separator(self, elem, hr_class_prefix='moin-hr'):
-        hr_ending = '\n'
-        hr_class = elem.attrib.get(moin_page('class'))
+    def open_moinpage_separator(self, elem, hr_class_prefix="moin-hr"):
+        hr_ending = "\n"
+        hr_class = elem.attrib.get(moin_page("class"))
         if hr_class:
             try:
                 height = int(hr_class.split(hr_class_prefix)[1]) - 1
             except (ValueError, IndexError, TypeError):
-                raise ElementException(f'page:separator has invalid class {hr_class}')
+                raise ElementException(f"page:separator has invalid class {hr_class}")
             else:
                 if 0 <= height <= 5:
-                    hr_ending = ('-' * height) + hr_ending
+                    hr_ending = ("-" * height) + hr_ending
         return Moinwiki.separator + hr_ending
 
     def open_moinpage_span(self, elem):
         # moin syntax does not support style attributes within span tags.
         # Colored text or backgrounds supported by html, markdown extensions, etc
         # are ignored and not converted.
-        font_size = elem.get(moin_page.font_size, '')
-        baseline_shift = elem.get(moin_page.baseline_shift, '')
-        class_ = elem.get(moin_page.class_, '')
-        if class_ == 'comment':
-            return f'/* {self.open_children(elem)} */'
+        font_size = elem.get(moin_page.font_size, "")
+        baseline_shift = elem.get(moin_page.baseline_shift, "")
+        class_ = elem.get(moin_page.class_, "")
+        if class_ == "comment":
+            return f"/* {self.open_children(elem)} */"
         if font_size:
             return "{}{}{}".format(
                 Moinwiki.larger_open if font_size == "120%" else Moinwiki.smaller_open,
                 self.open_children(elem),
-                Moinwiki.larger_close if font_size == "120%" else Moinwiki.smaller_close)
-        if baseline_shift == 'super':
+                Moinwiki.larger_close if font_size == "120%" else Moinwiki.smaller_close,
+            )
+        if baseline_shift == "super":
             return f"^{''.join(elem.itertext())}^"
-        if baseline_shift == 'sub':
+        if baseline_shift == "sub":
             return f",,{''.join(elem.itertext())},,"
-        return ''.join(self.open_children(elem))
+        return "".join(self.open_children(elem))
 
     def open_moinpage_del(self, elem):  # stroke or strike-through
         return Moinwiki.stroke_open + self.open_children(elem) + Moinwiki.stroke_close
@@ -586,53 +590,53 @@ def open_moinpage_strong(self, elem):
         return f"{Moinwiki.strong}{self.open_children(elem)}{Moinwiki.strong}"
 
     def open_moinpage_table(self, elem):
-        self.table_tableclass = elem.attrib.get(moin_page.class_, '')
+        self.table_tableclass = elem.attrib.get(moin_page.class_, "")
         # moin-wiki-table class was added by moinwiki_in so html_out can convert multiple body's into head, foot
-        self.table_tableclass = self.table_tableclass.replace('moin-wiki-table', '').strip()
-        self.table_tablestyle = elem.attrib.get(moin_page.style, '')
+        self.table_tableclass = self.table_tableclass.replace("moin-wiki-table", "").strip()
+        self.table_tablestyle = elem.attrib.get(moin_page.style, "")
         if elem[0].tag == moin_page.caption:
             self.table_caption = elem[0][0]
         else:
-            self.table_caption = ''
-        self.table_rowsstyle = ''
-        self.table_rowsclass = ''
-        self.table_multi_body = ''
-        self.status.append('table')
+            self.table_caption = ""
+        self.table_rowsstyle = ""
+        self.table_rowsclass = ""
+        self.table_multi_body = ""
+        self.status.append("table")
         self.last_closed = None
         ret = self.open_children(elem)
         self.status.pop()
-        return '\n' + ret + '\n'
+        return "\n" + ret + "\n"
 
     def open_moinpage_caption(self, elem):
         # return empty string, text has already been processed in open_moinpage_table above
-        return ''
+        return ""
 
     def open_moinpage_table_header(self, elem):
         # used for reST to moinwiki conversion, maybe others that generate table head
         ret = self.open_children(elem)
-        return ret + '=====\n'
+        return ret + "=====\n"
 
     def open_moinpage_table_footer(self, elem):
         # no known use, need some markup that generates table foot
         ret = self.open_children(elem)
-        return '=====\n' + ret
+        return "=====\n" + ret
 
     def open_moinpage_table_body(self, elem):
-        self.table_rowsclass = ''
+        self.table_rowsclass = ""
         ret = self.table_multi_body + self.open_children(elem)
         # multible body elements separate header/body/footer within DOM created by moinwiki_in
-        self.table_multi_body = '=====\n'
+        self.table_multi_body = "=====\n"
         return ret
 
     def open_moinpage_table_row(self, elem):
-        self.table_rowclass = elem.attrib.get(moin_page.class_, '')
-        self.table_rowclass = ' '.join([s for s in [self.table_rowsclass, self.table_rowclass] if s])
-        self.table_rowstyle = elem.attrib.get(moin_page.style, '')
-        self.table_rowstyle = ' '.join([s for s in [self.table_rowsstyle, self.table_rowstyle] if s])
+        self.table_rowclass = elem.attrib.get(moin_page.class_, "")
+        self.table_rowclass = " ".join([s for s in [self.table_rowsclass, self.table_rowclass] if s])
+        self.table_rowstyle = elem.attrib.get(moin_page.style, "")
+        self.table_rowstyle = " ".join([s for s in [self.table_rowsstyle, self.table_rowstyle] if s])
         ret = self.open_children(elem)
-        self.table_rowstyle = ''
-        self.table_rowclass = ''
-        return ret + Moinwiki.table_marker + '\n'
+        self.table_rowstyle = ""
+        self.table_rowclass = ""
+        return ret + Moinwiki.table_marker + "\n"
 
     def open_moinpage_th(self, elem):
         return self.open_moinpage_table_cell_head(self, elem)
@@ -644,8 +648,8 @@ def open_moinpage_td(self, elem):
         return self.open_moinpage_table_cell(self, elem)
 
     def open_moinpage_table_cell(self, elem):
-        table_cellclass = elem.attrib.get(moin_page.class_, '')
-        table_cellstyle = elem.attrib.get(moin_page.style, '')
+        table_cellclass = elem.attrib.get(moin_page.class_, "")
+        table_cellstyle = elem.attrib.get(moin_page.style, "")
         number_columns_spanned = int(elem.get(moin_page.number_columns_spanned, 1))
         number_rows_spanned = elem.get(moin_page.number_rows_spanned, None)
         ret = Moinwiki.table_marker
@@ -654,19 +658,19 @@ def open_moinpage_table_cell(self, elem):
         # TODO: maybe this can be written shorter
         if self.table_tableclass:
             attrib.append(f'tableclass="{self.table_tableclass}"')
-            self.table_tableclass = ''
+            self.table_tableclass = ""
         if self.table_tablestyle:
             attrib.append(f'tablestyle="{self.table_tablestyle}"')
-            self.table_tablestyle = ''
+            self.table_tablestyle = ""
         if self.table_caption:
             attrib.append(f'caption="{self.table_caption}"')
-            self.table_caption = ''
+            self.table_caption = ""
         if self.table_rowclass:
             attrib.append(f'rowclass="{self.table_rowclass}"')
-            self.table_rowclass = ''
+            self.table_rowclass = ""
         if self.table_rowstyle:
             attrib.append(f'rowstyle="{self.table_rowstyle}"')
-            self.table_rowstyle = ''
+            self.table_rowstyle = ""
         if table_cellclass:
             attrib.append(f'class="{table_cellclass}"')
         if table_cellstyle:
@@ -676,10 +680,10 @@ def open_moinpage_table_cell(self, elem):
         if number_columns_spanned > 1:
             attrib.append(f'colspan="{number_columns_spanned}"')
 
-        attrib = ' '.join(attrib)
+        attrib = " ".join(attrib)
 
         if attrib:
-            ret += f'<{attrib}>'
+            ret += f"<{attrib}>"
         childrens_output = self.open_children(elem)
         return ret + childrens_output
 
@@ -692,4 +696,4 @@ def open_xinclude(self, elem):
 
 
 default_registry.register(Converter.factory, type_moin_document, type_moin_wiki)
-default_registry.register(Converter.factory, type_moin_document, Type('x-moin/format;name=wiki'))
+default_registry.register(Converter.factory, type_moin_document, Type("x-moin/format;name=wiki"))
diff --git a/src/moin/converters/nonexistent_in.py b/src/moin/converters/nonexistent_in.py
index dbedc1ced..145ba55ea 100644
--- a/src/moin/converters/nonexistent_in.py
+++ b/src/moin/converters/nonexistent_in.py
@@ -21,19 +21,19 @@ class Converter:
     """
     Convert a non-existing item to DOM Tree.
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls()
 
     def __call__(self, rev, contenttype=None, arguments=None):
         item_name = rev.item.fqname.fullname
-        attrib = {
-            xlink.href: Iri(scheme='wiki', authority='', path='/' + item_name, query='do=modify'),
-        }
-        a = moin_page.a(attrib=attrib, children=[_("{item_name} does not exist. Create it? "
-                                                   ).format(item_name=item_name)])
-        body = moin_page.body(children=(a, ))
-        return moin_page.page(children=(body, ))
+        attrib = {xlink.href: Iri(scheme="wiki", authority="", path="/" + item_name, query="do=modify")}
+        a = moin_page.a(
+            attrib=attrib, children=[_("{item_name} does not exist. Create it? ").format(item_name=item_name)]
+        )
+        body = moin_page.body(children=(a,))
+        return moin_page.page(children=(body,))
 
 
 default_registry.register(Converter._factory, Type(CONTENTTYPE_NONEXISTENT), type_moin_document)
diff --git a/src/moin/converters/nowiki.py b/src/moin/converters/nowiki.py
index cd835d094..3bcf0bda4 100644
--- a/src/moin/converters/nowiki.py
+++ b/src/moin/converters/nowiki.py
@@ -12,7 +12,7 @@
 from emeraldtree import ElementTree as ET
 
 import pygments
-from . pygments_in import TreeFormatter
+from .pygments_in import TreeFormatter
 from pygments.util import ClassNotFound
 
 from moin.i18n import _
@@ -25,21 +25,22 @@
 from ._util import normalize_split_text, _Iter
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 class Converter:
     @classmethod
     def _factory(cls, input, output, nowiki=None, **kw):
-        if nowiki == 'expandall':
+        if nowiki == "expandall":
             return cls()
 
     def invalid_args(self, elem, all_nowiki_args):
         """Insert an error message into output."""
-        message = _(
-            'Defaulting to plain text due to invalid arguments: "{arguments}"'
-        ).format(arguments=all_nowiki_args[0])
-        admonition = moin_page.div(attrib={moin_page.class_: 'error'}, children=[moin_page.p(children=[message])])
+        message = _('Defaulting to plain text due to invalid arguments: "{arguments}"').format(
+            arguments=all_nowiki_args[0]
+        )
+        admonition = moin_page.div(attrib={moin_page.class_: "error"}, children=[moin_page.p(children=[message])])
         elem.append(admonition)
 
     def handle_nowiki(self, elem, page):
@@ -53,24 +54,24 @@ def handle_nowiki(self, elem, page):
 
         if not nowiki_args:
             # input similar to: {{{\ntext\n}}}\n
-            blockcode = moin_page.blockcode(children=(content, ))
+            blockcode = moin_page.blockcode(children=(content,))
             elem.append(blockcode)
             return
 
-        if nowiki_args.startswith('#!') and len(nowiki_args) > 2:
-            arguments = nowiki_args[2:].split(' ', 1)  # skip leading #!
+        if nowiki_args.startswith("#!") and len(nowiki_args) > 2:
+            arguments = nowiki_args[2:].split(" ", 1)  # skip leading #!
             nowiki_name = arguments[0]
             optional_args = arguments[1] if len(arguments) > 1 else None
         else:
             nowiki_name = optional_args = None
 
         lexer = None
-        if nowiki_name in {'diff', 'cplusplus', 'python', 'java', 'pascal', 'irc'}:
+        if nowiki_name in {"diff", "cplusplus", "python", "java", "pascal", "irc"}:
             # make old style markup similar to {{{#!python like new style {{{#!highlight python
-            optional_args = nowiki_name if not optional_args else nowiki_name + ' ' + optional_args
-            nowiki_name = 'highlight'
+            optional_args = nowiki_name if not optional_args else nowiki_name + " " + optional_args
+            nowiki_name = "highlight"
 
-        if nowiki_name == 'highlight':
+        if nowiki_name == "highlight":
             # TODO: support moin 1.9 options like numbers=on start=222 step=10
             optional_args = optional_args.split()[0]  # ignore all parameters except lexer name
             try:
@@ -80,102 +81,109 @@ def handle_nowiki(self, elem, page):
                     lexer = pygments.lexers.get_lexer_for_mimetype(optional_args)
                 except ClassNotFound:
                     self.invalid_args(elem, all_nowiki_args)
-                    lexer = pygments.lexers.get_lexer_by_name('text')
+                    lexer = pygments.lexers.get_lexer_by_name("text")
         if lexer:
-            blockcode = moin_page.blockcode(attrib={moin_page.class_: 'highlight'})
+            blockcode = moin_page.blockcode(attrib={moin_page.class_: "highlight"})
             pygments.highlight(content, lexer, TreeFormatter(), blockcode)
             elem.append(blockcode)
             return
 
-        if nowiki_name in ('csv', 'text/csv'):
+        if nowiki_name in ("csv", "text/csv"):
             # TODO: support moin 1.9 options: quotechar, show, hide, autofilter, name, link, static_cols, etc
             delim = None
             if optional_args:
-                m = re.search('delimiter=(.?)', optional_args)
+                m = re.search("delimiter=(.?)", optional_args)
                 if m and m.group(1):
                     delim = m.group(1)
                 if not delim:
                     delim = optional_args.split()[0]  # ignore all parameters except a delimiter in first position
                     if len(delim) > 1:
                         delim = None
-            sep = delim or ';'
-            content = content.split('\n')
+            sep = delim or ";"
+            content = content.split("\n")
             head = content[0].split(sep)
             rows = [x.split(sep) for x in content[1:]]
             csv_builder = TableMixin()
-            table = csv_builder.build_dom_table(rows, head=head, cls='moin-csv-table moin-sortable')
+            table = csv_builder.build_dom_table(rows, head=head, cls="moin-csv-table moin-sortable")
             elem.append(table)
             return
 
-        if nowiki_name in ('wiki', 'text/x.moin.wiki',):
+        if nowiki_name in ("wiki", "text/x.moin.wiki"):
             from .moinwiki_in import Converter as moinwiki_converter
+
             moinwiki = moinwiki_converter()
             lines = normalize_split_text(content)
             lines = _Iter(lines)
             # reparse arguments from original: {{{#!wiki solid/orange (style="color: red;")
             wiki_args = parse_arguments(all_nowiki_args[0][2:])
             if len(wiki_args.positional) > 1:
-                wiki_args.keyword['class'] = ' '.join(wiki_args.positional[1:])
+                wiki_args.keyword["class"] = " ".join(wiki_args.positional[1:])
             del wiki_args.positional[:]
             body = moinwiki.parse_block(lines, wiki_args)
-            page = moin_page.page(children=(body, ))
+            page = moin_page.page(children=(body,))
             elem.append(page)
             return
 
-        if nowiki_name in ('creole', 'text/x.moin.creole'):
+        if nowiki_name in ("creole", "text/x.moin.creole"):
             from .creole_in import Converter as creole_converter
+
             creole = creole_converter()
             lines = normalize_split_text(content)
             lines = _Iter(lines)
             body = creole.parse_block(lines, optional_args)
-            page = moin_page.page(children=(body, ))
+            page = moin_page.page(children=(body,))
             elem.append(page)
             return
 
-        if nowiki_name in ('rst', 'text/x-rst'):
+        if nowiki_name in ("rst", "text/x-rst"):
             from .rst_in import Converter as rst_converter
+
             rst = rst_converter()
-            page = rst(content, contenttype='text/x-rst;charset=utf-8')
+            page = rst(content, contenttype="text/x-rst;charset=utf-8")
             elem.append(page)
             return
 
-        if nowiki_name in ('docbook', 'application/docbook+xml'):
+        if nowiki_name in ("docbook", "application/docbook+xml"):
             from .docbook_in import Converter as docbook_converter
+
             docbook = docbook_converter()
-            page = docbook(content, contenttype='application/docbook+xml;charset=utf-8')
+            page = docbook(content, contenttype="application/docbook+xml;charset=utf-8")
             elem.append(page)
             return
 
-        if nowiki_name in ('markdown', 'text/x-markdown'):
+        if nowiki_name in ("markdown", "text/x-markdown"):
             from .markdown_in import Converter as markdown_converter
+
             markdown = markdown_converter()
-            page = markdown(content, contenttype='text/x-markdown;charset=utf-8')
+            page = markdown(content, contenttype="text/x-markdown;charset=utf-8")
             elem.append(page)
             return
 
-        if nowiki_name in ('mediawiki', 'text/x-mediawiki'):
+        if nowiki_name in ("mediawiki", "text/x-mediawiki"):
             from .mediawiki_in import Converter as mediawiki_converter
+
             mediawiki = mediawiki_converter()
             page = mediawiki(content, optional_args)
             elem.append(page)
             return
 
-        if nowiki_name in ('html', 'HTML', 'text/html'):
+        if nowiki_name in ("html", "HTML", "text/html"):
             from .html_in import Converter as html_converter
+
             html = html_converter()
             page = html(content, optional_args)
             elem.append(page)
             return
 
         self.invalid_args(elem, all_nowiki_args)
-        lexer = pygments.lexers.get_lexer_by_name('text')
-        blockcode = moin_page.blockcode(attrib={moin_page.class_: 'highlight'})
+        lexer = pygments.lexers.get_lexer_by_name("text")
+        blockcode = moin_page.blockcode(attrib={moin_page.class_: "highlight"})
         pygments.highlight(content, lexer, TreeFormatter(), blockcode)
         elem.append(blockcode)
         return
 
     def recurse(self, elem, page):
-        if elem.tag in (moin_page.nowiki, ):
+        if elem.tag in (moin_page.nowiki,):
             yield elem, page
 
         for child in elem:
diff --git a/src/moin/converters/opendocument_in.py b/src/moin/converters/opendocument_in.py
index 8c9844c67..80321b793 100644
--- a/src/moin/converters/opendocument_in.py
+++ b/src/moin/converters/opendocument_in.py
@@ -16,6 +16,7 @@
 from .xml_in import strip_xml
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -28,7 +29,7 @@ def __call__(self, rev, contenttype=None, arguments=None):
         zf = zipfile.ZipFile(rev, "r")  # rev is file-like
         try:
             data = zf.read("content.xml")
-            text = data.decode('utf-8')
+            text = data.decode("utf-8")
             text = strip_xml(text)
             return text
         except AttributeError as e:
diff --git a/src/moin/converters/pdf_in.py b/src/moin/converters/pdf_in.py
index d5dc72ece..30601d569 100644
--- a/src/moin/converters/pdf_in.py
+++ b/src/moin/converters/pdf_in.py
@@ -19,6 +19,7 @@
 from moin.utils.mime import Type, type_text_plain
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -50,4 +51,4 @@ def __call__(self, rev, contenttype=None, arguments=None):
             return f.getvalue()
 
 
-default_registry.register(PDFIndexingConverter._factory, Type('application/pdf'), type_text_plain)
+default_registry.register(PDFIndexingConverter._factory, Type("application/pdf"), type_text_plain)
diff --git a/src/moin/converters/pygments_in.py b/src/moin/converters/pygments_in.py
index b2e0c36bc..6f9f9df82 100644
--- a/src/moin/converters/pygments_in.py
+++ b/src/moin/converters/pygments_in.py
@@ -18,19 +18,21 @@
 from ._util import decode_data, normalize_split_text
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 if pygments:
+
     class TreeFormatter(pygments.formatter.Formatter):
         def _append(self, type, value, element):
             class_ = STANDARD_TYPES.get(type)
             if class_:
-                value = moin_page.span(attrib={moin_page.class_: class_}, children=(value, ))
+                value = moin_page.span(attrib={moin_page.class_: class_}, children=(value,))
             element.append(value)
 
         def format(self, tokensource, element):
-            lastval = ''
+            lastval = ""
             lasttype = None
 
             for ttype, value in tokensource:
@@ -64,16 +66,16 @@ def _factory(cls, type_input, type_output, **kw):
             # that were supported by special parsers in moin 1.x:
             if pygments_name is None:
                 moin_pygments = [
-                    ('python', 'Python'),
-                    ('diff', 'Diff'),
-                    ('irssi', 'IRC logs'),
-                    ('irc', 'IRC logs'),
-                    ('java', 'Java'),
-                    ('cplusplus', 'C++'),
-                    ('pascal', 'Delphi'),
+                    ("python", "Python"),
+                    ("diff", "Diff"),
+                    ("irssi", "IRC logs"),
+                    ("irc", "IRC logs"),
+                    ("java", "Java"),
+                    ("cplusplus", "C++"),
+                    ("pascal", "Delphi"),
                 ]
                 for moin_format, pygments_name in moin_pygments:
-                    if Type(f'x-moin/format;name={moin_format}').issupertype(type_input):
+                    if Type(f"x-moin/format;name={moin_format}").issupertype(type_input):
                         break
                 else:
                     pygments_name = None
@@ -93,33 +95,36 @@ def __init__(self, lexer=None, contenttype=None):
             if lexer is None and contenttype is not None:
                 ct = Type(contenttype)
                 # pygments can't process parameters (like e.g. ...;charset=utf-8):
-                mimetype = f'{ct.type}/{ct.subtype}'
+                mimetype = f"{ct.type}/{ct.subtype}"
 
                 # TODO: fix pygments and remove this workaround for missing mimetypes; see issue #16
-                alias_mimetypes = {'text/x.moin.wiki': 'text/x-trac-wiki',
-                                   'text/x.moin.creole': 'text/x-trac-wiki',
-                                   'application/docbook+xml': 'application/xml'}
+                alias_mimetypes = {
+                    "text/x.moin.wiki": "text/x-trac-wiki",
+                    "text/x.moin.creole": "text/x-trac-wiki",
+                    "application/docbook+xml": "application/xml",
+                }
                 mimetype = alias_mimetypes[mimetype] if mimetype in alias_mimetypes else mimetype
 
                 try:
                     lexer = pygments.lexers.get_lexer_for_mimetype(mimetype)
                 except pygments.util.ClassNotFound:
-                    lexer = pygments.lexers.get_lexer_for_mimetype('text/plain')
+                    lexer = pygments.lexers.get_lexer_for_mimetype("text/plain")
             self.lexer = lexer
 
         def __call__(self, data, contenttype=None, arguments=None):
             text = decode_data(data, contenttype)
             content = normalize_split_text(text)
-            content = '\n'.join(content)
-            blockcode = moin_page.blockcode(attrib={moin_page.class_: 'highlight'})
+            content = "\n".join(content)
+            blockcode = moin_page.blockcode(attrib={moin_page.class_: "highlight"})
             pygments.highlight(content, self.lexer, TreeFormatter(), blockcode)
-            body = moin_page.body(children=(blockcode, ))
-            return moin_page.page(children=(body, ))
+            body = moin_page.body(children=(blockcode,))
+            return moin_page.page(children=(body,))
 
     from . import default_registry
     from moin.utils.mime import Type, type_moin_document
-    default_registry.register(Converter._factory, Type(type='text'), type_moin_document)
-    default_registry.register(Converter._factory, Type('x-moin/format'), type_moin_document)
+
+    default_registry.register(Converter._factory, Type(type="text"), type_moin_document)
+    default_registry.register(Converter._factory, Type("x-moin/format"), type_moin_document)
 
 else:
     # we have no Pygments, minimal Converter replacement, so highlight view does not crash
@@ -132,7 +137,7 @@ def __call__(self, content, arguments=None):
             blockcode = moin_page.blockcode()
             for line in content:
                 if len(blockcode):
-                    blockcode.append('\n')
+                    blockcode.append("\n")
                 blockcode.append(line.expandtabs())
-            body = moin_page.body(children=(blockcode, ))
-            return moin_page.page(children=(body, ))
+            body = moin_page.body(children=(blockcode,))
+            return moin_page.page(children=(body,))
diff --git a/src/moin/converters/rst_in.py b/src/moin/converters/rst_in.py
index 270bd1a8d..bfcd1ec5d 100644
--- a/src/moin/converters/rst_in.py
+++ b/src/moin/converters/rst_in.py
@@ -36,6 +36,7 @@
 from ._util import allowed_uri_scheme, decode_data, normalize_split_text
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -46,10 +47,10 @@ class NodeVisitor:
 
     def __init__(self):
         self.current_node = moin_page.body()
-        self.root = moin_page.page(children=(self.current_node, ))
+        self.root = moin_page.page(children=(self.current_node,))
         self.path = [self.root, self.current_node]
         self.header_size = 1
-        self.status = ['document']
+        self.status = ["document"]
         self.footnotes = dict()
         self.last_lineno = 0
         self.current_lineno = 0
@@ -61,7 +62,7 @@ def dispatch_visit(self, node):
         self.unknown_visit.
         """
         node_name = node.__class__.__name__
-        method = getattr(self, 'visit_' + node_name, self.unknown_visit)
+        method = getattr(self, "visit_" + node_name, self.unknown_visit)
         if isinstance(node.line, int):
             self.current_lineno = node.line
         return method(node)
@@ -73,7 +74,7 @@ def dispatch_departure(self, node):
         self.unknown_departure.
         """
         node_name = node.__class__.__name__
-        method = getattr(self, 'depart_' + node_name, self.unknown_departure)
+        method = getattr(self, "depart_" + node_name, self.unknown_departure)
         return method(node)
 
     def unknown_visit(self, node):
@@ -93,7 +94,7 @@ def unknown_departure(self, node):
         pass
 
     def open_moin_page_node(self, mointree_element):
-        if flaskg and getattr(flaskg, 'add_lineno_attr', False):
+        if flaskg and getattr(flaskg, "add_lineno_attr", False):
             # add data-lineno attribute for auto-scrolling edit textarea
             if self.last_lineno < self.current_lineno:
                 mointree_element.attrib[html.data_lineno] = self.current_lineno
@@ -126,48 +127,48 @@ def depart_admonition(self, node=None):
 
     # see http://docutils.sourceforge.net/docs/ref/rst/directives.html#specific-admonitions
     def visit_attention(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'attention'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "attention"}))
 
     depart_attention = depart_admonition
 
     def visit_caution(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'caution'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "caution"}))
 
     depart_caution = depart_admonition
 
     def visit_danger(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'danger'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "danger"}))
 
     depart_danger = depart_admonition
 
     def visit_error(self, node):
         # this is used to process parsing errors as well as user error admonitions
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'error'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "error"}))
 
     depart_error = depart_admonition
 
     def visit_hint(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'hint'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "hint"}))
 
     depart_hint = depart_admonition
 
     def visit_important(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'important'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "important"}))
 
     depart_important = depart_admonition
 
     def visit_note(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'note'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "note"}))
 
     depart_note = depart_admonition
 
     def visit_tip(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'tip'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "tip"}))
 
     depart_tip = depart_admonition
 
     def visit_warning(self, node):
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'warning'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "warning"}))
 
     depart_warning = depart_admonition
 
@@ -178,15 +179,14 @@ def depart_block_quote(self, node):
         self.close_moin_page_node()
 
     def visit_attribution(self, node):
-        attrib = {html.class_: 'moin-rst-attribution'}
+        attrib = {html.class_: "moin-rst-attribution"}
         self.open_moin_page_node(moin_page.p(attrib=attrib))
 
     def depart_attribution(self, node):
         self.close_moin_page_node()
 
     def visit_bullet_list(self, node):
-        self.open_moin_page_node(moin_page.list(
-            attrib={moin_page.item_label_generate: 'unordered'}))
+        self.open_moin_page_node(moin_page.list(attrib={moin_page.item_label_generate: "unordered"}))
 
     def depart_bullet_list(self, node):
         self.close_moin_page_node()
@@ -272,7 +272,7 @@ def visit_comment(self, node):
         """
         Create moinwiki style hidden comment rather than html style: <!-- a comment -->
         """
-        attrib = {moin_page.class_: 'comment dashed'}
+        attrib = {moin_page.class_: "comment dashed"}
         self.open_moin_page_node(moin_page.div(attrib=attrib))
 
     def depart_comment(self, node):
@@ -287,12 +287,10 @@ def depart_emphasis(self, node):
     def visit_entry(self, node):
         # process a table cell <td> tag
         new_element = moin_page.table_cell()
-        if 'morerows' in node.attributes:
-            new_element.set(moin_page.number_rows_spanned,
-                            repr(int(node['morerows']) + 1))
-        if 'morecols' in node.attributes:
-            new_element.set(moin_page.number_columns_spanned,
-                            repr(int(node['morecols']) + 1))
+        if "morerows" in node.attributes:
+            new_element.set(moin_page.number_rows_spanned, repr(int(node["morerows"]) + 1))
+        if "morecols" in node.attributes:
+            new_element.set(moin_page.number_columns_spanned, repr(int(node["morecols"]) + 1))
         self.open_moin_page_node(new_element)
 
     def depart_entry(self, node):
@@ -300,15 +298,14 @@ def depart_entry(self, node):
 
     def visit_enumerated_list(self, node):
         enum_style = {
-            'arabic': None,
-            'loweralpha': 'lower-alpha',
-            'upperalpha': 'upper-alpha',
-            'lowerroman': 'lower-roman',
-            'upperroman': 'upper-roman',
+            "arabic": None,
+            "loweralpha": "lower-alpha",
+            "upperalpha": "upper-alpha",
+            "lowerroman": "lower-roman",
+            "upperroman": "upper-roman",
         }
-        new_node = moin_page.list(
-            attrib={moin_page.item_label_generate: 'ordered'})
-        type = enum_style.get(node['enumtype'], None)
+        new_node = moin_page.list(attrib={moin_page.item_label_generate: "ordered"})
+        type = enum_style.get(node["enumtype"], None)
         if type:
             new_node.set(moin_page.list_style_type, type)
         self.open_moin_page_node(new_node)
@@ -329,7 +326,7 @@ def depart_field_body(self, node):
         self.close_moin_page_node()
 
     def visit_field_list(self, node):
-        attrib = {html.class_: 'moin-rst-fieldlist'}
+        attrib = {html.class_: "moin-rst-fieldlist"}
         self.open_moin_page_node(moin_page.table(attrib=attrib))
         self.open_moin_page_node(moin_page.table_body())
 
@@ -340,7 +337,7 @@ def depart_field_list(self, node):
     def visit_field_name(self, node):
         self.open_moin_page_node(moin_page.table_cell())
         self.open_moin_page_node(moin_page.strong())
-        self.open_moin_page_node(f'{node.astext()}:')
+        self.open_moin_page_node(f"{node.astext()}:")
         node.children = []
         self.close_moin_page_node()
 
@@ -361,14 +358,13 @@ def depart_footer(self, node):
         pass
 
     def visit_footnote(self, node):
-        self.status.append('footnote')
+        self.status.append("footnote")
 
     def depart_footnote(self, node):
         self.status.pop()
 
     def visit_footnote_reference(self, node):
-        self.open_moin_page_node(moin_page.note(
-            attrib={moin_page.note_class: 'footnote'}))
+        self.open_moin_page_node(moin_page.note(attrib={moin_page.note_class: "footnote"}))
         new_footnote = moin_page.note_body()
         self.open_moin_page_node(new_footnote)
         self.footnotes[node.children[-1]] = new_footnote
@@ -388,36 +384,36 @@ def visit_image(self, node):
         """
         Processes images and other transcluded objects.
         """
-        whitelist = ['width', 'height', 'alt', ]
+        whitelist = ["width", "height", "alt"]
         attrib = {}
         for key in whitelist:
             if node.get(key):
                 attrib[html(key)] = node.get(key)
 
         # there is no 'scale' attribute, hence absent from whitelist, handled separately
-        if node.get('scale'):
-            scaling_factor = int(node.get('scale')) / 100.0
-            for key in ('width', 'height'):
+        if node.get("scale"):
+            scaling_factor = int(node.get("scale")) / 100.0
+            for key in ("width", "height"):
                 if html(key) in attrib:
                     attrib[html(key)] = int(int(attrib[html(key)]) * scaling_factor)
 
         # "align" parameter is invalid in HTML5. Convert it to a class defined in userstyles.css.
         userstyles = {
-            'left': 'left',
-            'center': 'center',
-            'right': 'right',
-            'top': 'top',  # rst parser creates error messages for top, bottom, and middle
-            'bottom': 'bottom',
-            'middle': 'middle',
+            "left": "left",
+            "center": "center",
+            "right": "right",
+            "top": "top",  # rst parser creates error messages for top, bottom, and middle
+            "bottom": "bottom",
+            "middle": "middle",
         }
-        alignment = userstyles.get(node.get('align'))
+        alignment = userstyles.get(node.get("align"))
         if alignment:
             attrib[html.class_] = alignment
 
-        url = Iri(node['uri'])
+        url = Iri(node["uri"])
         if url.scheme is None:
             # img
-            target = Iri(scheme='wiki.local', path=node['uri'], fragment=None)
+            target = Iri(scheme="wiki.local", path=node["uri"], fragment=None)
             attrib[xinclude.href] = target
             new_node = xinclude.include(attrib=attrib)
         else:
@@ -437,7 +433,7 @@ def depart_inline(self, node):
         pass
 
     def visit_label(self, node):
-        if self.status[-1] == 'footnote':
+        if self.status[-1] == "footnote":
             self.footnote_lable = node.astext()
         node.children = []
 
@@ -474,7 +470,7 @@ def visit_literal(self, node):
         self.close_moin_page_node()
 
     def visit_literal_block(self, node):
-        parser = node.get('parser', '')
+        parser = node.get("parser", "")
         if parser:
             named_args = re.findall(r"(\w+)=(\w+)", parser)
             simple_args = re.findall(r"(?:\s)\w+(?:\s|$)", parser)
@@ -484,9 +480,12 @@ def visit_literal_block(self, node):
             for name, value in named_args:
                 args.append(moin_page.argument(attrib={moin_page.name: name}, children=[value]))
             arguments = moin_page.arguments(children=args)
-            self.open_moin_page_node(moin_page.part(
-                children=[arguments],
-                attrib={moin_page.content_type: "x-moin/format;name={}".format(parser.split(' ')[0])}))
+            self.open_moin_page_node(
+                moin_page.part(
+                    children=[arguments],
+                    attrib={moin_page.content_type: "x-moin/format;name={}".format(parser.split(" ")[0])},
+                )
+            )
         else:
             self.open_moin_page_node(moin_page.blockcode())
 
@@ -494,7 +493,7 @@ def depart_literal_block(self, node):
         self.close_moin_page_node()
 
     def visit_option_list(self, node):
-        attrib = {html.class_: 'moin-rst-optionlist'}
+        attrib = {html.class_: "moin-rst-optionlist"}
         self.open_moin_page_node(moin_page.table(attrib=attrib))
         self.open_moin_page_node(moin_page.table_body())
 
@@ -518,7 +517,7 @@ def depart_option(self, node):
     depart_description = depart_option
 
     def visit_paragraph(self, node):
-        if self.status[-1] == 'footnote':
+        if self.status[-1] == "footnote":
             footnote_node = self.footnotes.get(self.footnote_lable, None)
             if footnote_node:
                 footnote_node.append(node.astext())
@@ -527,7 +526,7 @@ def visit_paragraph(self, node):
             self.open_moin_page_node(moin_page.p())
 
     def depart_paragraph(self, node):
-        if self.status[-1] == 'footnote':
+        if self.status[-1] == "footnote":
             pass
         else:
             self.close_moin_page_node()
@@ -539,11 +538,11 @@ def depart_problematic(self, node):
         pass
 
     def visit_reference(self, node):
-        refuri = node.get('refuri', '')
-        if refuri.startswith('<<') and refuri.endswith('>>'):  # moin macro
-            macro_name = refuri[2:-2].split('(')[0]
+        refuri = node.get("refuri", "")
+        if refuri.startswith("<<") and refuri.endswith(">>"):  # moin macro
+            macro_name = refuri[2:-2].split("(")[0]
             if macro_name == "TableOfContents":
-                arguments = refuri[2:-2].split('(')[1][:-1].split(',')
+                arguments = refuri[2:-2].split("(")[1][:-1].split(",")
                 node = moin_page.table_of_content()
                 self.open_moin_page_node(node)
                 if arguments and arguments[0]:
@@ -552,23 +551,25 @@ def visit_reference(self, node):
             if macro_name == "Include":
                 # include macros are expanded by include.py similar to transclusions
                 # rst include handles only wiki pages and does not support additional arguments like moinwiki
-                arguments = refuri[2:-2].split('(')[1][:-1].split(',')
-                link = Iri(scheme='wiki.local', path=arguments)
-                node = xinclude.include(attrib={
-                    xinclude.href: link,
-                    moin_page.alt: refuri,
-                    moin_page.content_type: 'x-moin/macro;name=' + macro_name,
-                })
+                arguments = refuri[2:-2].split("(")[1][:-1].split(",")
+                link = Iri(scheme="wiki.local", path=arguments)
+                node = xinclude.include(
+                    attrib={
+                        xinclude.href: link,
+                        moin_page.alt: refuri,
+                        moin_page.content_type: "x-moin/macro;name=" + macro_name,
+                    }
+                )
                 self.open_moin_page_node(node)
                 return
             try:
-                arguments = refuri[2:-2].split('(')[1][:-1]
+                arguments = refuri[2:-2].split("(")[1][:-1]
             except IndexError:
-                arguments = ''  # <<DateTime>>
+                arguments = ""  # <<DateTime>>
 
             self.open_moin_page_node(
-                moin_page.inline_part(
-                    attrib={moin_page.content_type: f"x-moin/macro;name={macro_name}"}))
+                moin_page.inline_part(attrib={moin_page.content_type: f"x-moin/macro;name={macro_name}"})
+            )
             if arguments:
                 self.open_moin_page_node(moin_page.arguments())
                 self.open_moin_page_node(arguments)
@@ -579,15 +580,15 @@ def visit_reference(self, node):
         if not allowed_uri_scheme(refuri):
             self.visit_error(node)
             return
-        if refuri == '':
+        if refuri == "":
             # build a link to a heading or an explicitly defined anchor
-            refuri = Iri(scheme='wiki.local', fragment=node.attributes['name'].replace(' ', '_'))
-        if isinstance(refuri, str) and refuri.startswith('http'):
-            if '://' not in refuri:
-                refuri = refuri.split(':')[1]
+            refuri = Iri(scheme="wiki.local", fragment=node.attributes["name"].replace(" ", "_"))
+        if isinstance(refuri, str) and refuri.startswith("http"):
+            if "://" not in refuri:
+                refuri = refuri.split(":")[1]
         iri = Iri(refuri)
         if iri.scheme is None:
-            iri.scheme = 'wiki.local'
+            iri.scheme = "wiki.local"
             refuri = iri
         self.open_moin_page_node(moin_page.a(attrib={xlink.href: refuri}))
 
@@ -637,34 +638,28 @@ def depart_strong(self, node):
         self.close_moin_page_node()
 
     def visit_subscript(self, node):
-        self.open_moin_page_node(
-            moin_page.span(
-                attrib={moin_page.baseline_shift: 'sub'}))
+        self.open_moin_page_node(moin_page.span(attrib={moin_page.baseline_shift: "sub"}))
 
     def depart_subscript(self, node):
         self.close_moin_page_node()
 
     def visit_subtitle(self, node):
         self.header_size += 1
-        self.open_moin_page_node(
-            moin_page.h(
-                attrib={moin_page.outline_level: repr(self.header_size)}))
+        self.open_moin_page_node(moin_page.h(attrib={moin_page.outline_level: repr(self.header_size)}))
 
     def depart_subtitle(self, node):
         self.header_size -= 1
         self.close_moin_page_node()
 
     def visit_superscript(self, node):
-        self.open_moin_page_node(
-            moin_page.span(
-                attrib={moin_page.baseline_shift: 'super'}))
+        self.open_moin_page_node(moin_page.span(attrib={moin_page.baseline_shift: "super"}))
 
     def depart_superscript(self, node):
         self.close_moin_page_node()
 
     def visit_system_message(self, node):
         # we have encountered a parsing error, insert an error message
-        self.open_moin_page_node(moin_page.admonition({moin_page.type: 'error'}))
+        self.open_moin_page_node(moin_page.admonition({moin_page.type: "error"}))
 
     def depart_system_message(self, node):
         self.close_moin_page_node()
@@ -687,7 +682,7 @@ def visit_target(self, node):
 
         .. _example:
         """
-        anchor = node.get('refid')
+        anchor = node.get("refid")
         if anchor:
             self.open_moin_page_node(moin_page.span(attrib={moin_page.id: anchor}))
             self.close_moin_page_node()
@@ -727,9 +722,7 @@ def depart_thead(self, node):
         self.close_moin_page_node()
 
     def visit_title(self, node):
-        self.open_moin_page_node(
-            moin_page.h(
-                attrib={moin_page.outline_level: repr(self.header_size)}))
+        self.open_moin_page_node(moin_page.h(attrib={moin_page.outline_level: repr(self.header_size)}))
 
     def depart_title(self, node):
         self.close_moin_page_node()
@@ -746,7 +739,7 @@ def visit_title_reference(self, node):
     def depart_title_reference(self, node):
         pass
 
-    def visit_transition(self, node, default_class='moin-hr3'):
+    def visit_transition(self, node, default_class="moin-hr3"):
         # TODO: add to rst_out
         attrib = {html.class_: default_class}
         self.open_moin_page_node(moin_page.separator(attrib=attrib))
@@ -790,9 +783,9 @@ def walkabout(node, visitor):
 
 class Writer(writers.Writer):
 
-    supported = ('moin-x-document', )
-    config_section = 'MoinMoin writer'
-    config_section_dependencies = ('writers', )
+    supported = ("moin-x-document",)
+    config_section = "MoinMoin writer"
+    config_section_dependencies = ("writers",)
     output = None
     visitor_attributes = []
 
@@ -811,24 +804,24 @@ class MoinDirectives:
     def __init__(self):
 
         # include MoinMoin pages
-        directives.register_directive('include', self.include)
+        directives.register_directive("include", self.include)
 
         # used for MoinMoin macros
-        directives.register_directive('macro', self.macro)
+        directives.register_directive("macro", self.macro)
 
         # used for MoinMoin tables of content
-        directives.register_directive('contents', self.table_of_content)
+        directives.register_directive("contents", self.table_of_content)
 
         # used for MoinMoin parsers
-        directives.register_directive('parser', self.parser)
+        directives.register_directive("parser", self.parser)
 
         # disallow a few directives in order to prevent XSS
         # for directive in ('meta', 'include', 'raw'):
-        for directive in ('meta', 'raw'):
+        for directive in ("meta", "raw"):
             directives.register_directive(directive, None)
 
         # disable the raw role
-        roles._roles['raw'] = None
+        roles._roles["raw"] = None
 
         # As a quick fix for infinite includes we only allow a fixed number of
         # includes per page
@@ -838,8 +831,7 @@ def __init__(self):
     # Handle the include directive rather than letting the default docutils
     # parser handle it. This allows the inclusion of MoinMoin pages instead of
     # something from the filesystem.
-    def include(self, name, arguments, options, content, lineno,
-                content_offset, block_text, state, state_machine):
+    def include(self, name, arguments, options, content, lineno, content_offset, block_text, state, state_machine):
         # content contains the included file name
 
         # TODO: i18n for errors
@@ -849,13 +841,13 @@ def include(self, name, arguments, options, content, lineno,
             self.num_includes += 1
         else:
             lines = ["**Maximum number of allowed includes exceeded**"]
-            state_machine.insert_input(lines, 'MoinDirectives')
+            state_machine.insert_input(lines, "MoinDirectives")
             return []
 
         if content:
-            macro = f'<<Include({content[0]})>>'
+            macro = f"<<Include({content[0]})>>"
         else:
-            macro = '<<Include()>>'
+            macro = "<<Include()>>"
         ref = reference(macro, refuri=macro)
         return [ref]
 
@@ -875,12 +867,12 @@ def macro(self, name, arguments, options, content, lineno, content_offset, block
         # content contains macro to be called
         if len(content):
             # Allow either with or without brackets
-            if content[0].startswith('<<'):
+            if content[0].startswith("<<"):
                 macro = content[0]
             else:
-                macro = f'<<{content[0]}>>'
+                macro = f"<<{content[0]}>>"
             ref = reference(macro, refuri=macro)
-            ref['name'] = macro
+            ref["name"] = macro
             return [ref]
         return
 
@@ -889,17 +881,18 @@ def macro(self, name, arguments, options, content, lineno, content_offset, block
     macro.required_arguments = 1
     macro.optional_arguments = 0
 
-    def table_of_content(self, name, arguments, options, content, lineno, content_offset,
-                         block_text, state, state_machine):
-        text = ''
+    def table_of_content(
+        self, name, arguments, options, content, lineno, content_offset, block_text, state, state_machine
+    ):
+        text = ""
         for i in content:
-            m = re.search(r':(\w+): (\w+)', i)
+            m = re.search(r":(\w+): (\w+)", i)
             if m and len(m.groups()) == 2:
-                if m.groups()[0] == 'depth':
+                if m.groups()[0] == "depth":
                     text = m.groups()[1]
-        macro = f'<<TableOfContents({text})>>'
+        macro = f"<<TableOfContents({text})>>"
         ref = reference(macro, refuri=macro)
-        ref['name'] = macro
+        ref["name"] = macro
         return [ref]
 
     table_of_content.has_content = table_of_content.content = True
@@ -909,7 +902,7 @@ def table_of_content(self, name, arguments, options, content, lineno, content_of
 
     def parser(self, name, arguments, options, content, lineo, content_offset, block_text, state, state_machine):
         block = literal_block()
-        block['parser'] = content[0]
+        block["parser"] = content[0]
         block.children = [nodes.Text("\n".join(content[1:]))]
         return [block]
 
@@ -929,28 +922,33 @@ def __call__(self, data, contenttype=None, arguments=None):
         input = normalize_split_text(text)
         MoinDirectives()
         while True:
-            input = '\n'.join(input)
+            input = "\n".join(input)
             try:
                 docutils_tree = core.publish_doctree(source=input)
             except utils.SystemMessage as inst:
-                string_numb = re.match(re.compile(r'<string>:([0-9]*):\s*\(.*?\)\s*(.*)',
-                                                  re.X | re.U | re.M | re.S), str(inst))
+                string_numb = re.match(
+                    re.compile(r"<string>:([0-9]*):\s*\(.*?\)\s*(.*)", re.X | re.U | re.M | re.S), str(inst)
+                )
                 if string_numb:
                     str_num = string_numb.group(1)
-                    input = input.split('\n')
+                    input = input.split("\n")
                     if str_num:
-                        input = [('.. error::\n'
-                                  ' ::\n'
-                                  '\n'
-                                  '  Parse error on line number {}:\n'
-                                  '\n'
-                                  '  {}\n'
-                                  '\n'
-                                  '  Go back and try to fix that.\n'
-                                  '\n').format(str_num, string_numb.group(2).replace('\n', '\n  '))]
+                        input = [
+                            (
+                                ".. error::\n"
+                                " ::\n"
+                                "\n"
+                                "  Parse error on line number {}:\n"
+                                "\n"
+                                "  {}\n"
+                                "\n"
+                                "  Go back and try to fix that.\n"
+                                "\n"
+                            ).format(str_num, string_numb.group(2).replace("\n", "\n  "))
+                        ]
                         continue
                 else:
-                    input = ['.. error::\n ::\n\n  {}\n\n'.format(str(inst).replace('\n', '\n  '))]
+                    input = [".. error::\n ::\n\n  {}\n\n".format(str(inst).replace("\n", "\n  "))]
                 raise inst
             break
         visitor = NodeVisitor()
@@ -959,7 +957,5 @@ def __call__(self, data, contenttype=None, arguments=None):
         return ret
 
 
-default_registry.register(Converter.factory,
-                          Type('text/x-rst'), type_moin_document)
-default_registry.register(Converter.factory,
-                          Type('x-moin/format;name=rst'), type_moin_document)
+default_registry.register(Converter.factory, Type("text/x-rst"), type_moin_document)
+default_registry.register(Converter.factory, Type("x-moin/format;name=rst"), type_moin_document)
diff --git a/src/moin/converters/rst_out.py b/src/moin/converters/rst_out.py
index c2c178446..c2c81e0cc 100644
--- a/src/moin/converters/rst_out.py
+++ b/src/moin/converters/rst_out.py
@@ -32,11 +32,11 @@ def __call__(self):
         return self.text
 
     def height(self):
-        return len(self.text.split('\n'))
+        return len(self.text.split("\n"))
 
     def width(self):
         max = 0
-        for i in self.text.split('\n'):
+        for i in self.text.split("\n"):
             if len(i) > max:
                 max = len(i)
         return max
@@ -53,13 +53,13 @@ def __init__(self):
         self.j = -1
         self.table = []
         self.header_count = 0
-        self.rowclass = ''
+        self.rowclass = ""
 
     def add_row(self):
         """
         Add new row to the table.
         """
-        if self.rowclass == 'table-header':
+        if self.rowclass == "table-header":
             self.header_count += 1
         row = []
         self.i += 1
@@ -67,7 +67,7 @@ def add_row(self):
         self.table.append(row)
         if self.i > 0:
             if len(self.table[-2]) > self.j:
-                self.add_cell(self.table[-2][self.j][0], self.table[-2][self.j][1] - 1, Cell(''))
+                self.add_cell(self.table[-2][self.j][0], self.table[-2][self.j][1] - 1, Cell(""))
         return row
 
     def end_row(self):
@@ -78,9 +78,9 @@ def end_row(self):
         """
         if len(self.table) > 1:
             if len(self.table[-2]) > len(self.table[-1]):
-                self.add_cell(1, 1, Cell(''))
+                self.add_cell(1, 1, Cell(""))
                 self.end_row()
-            if self.rowclass == 'table-header':
+            if self.rowclass == "table-header":
                 self.table.insert(self.header_count - 1, self.table.pop())
 
     def add_cell(self, cs, rs, cell):
@@ -93,11 +93,11 @@ def add_cell(self, cs, rs, cell):
             return
         self.table[-1].append((cs, rs, cell))
         for i in range(cs - 1):
-            self.table[-1].append((cs - i - 1, rs, Cell('')))
+            self.table[-1].append((cs - i - 1, rs, Cell("")))
         self.j += cs
         if self.i > 0:
             if len(self.table[-2]) > self.j:
-                self.add_cell(self.table[-2][self.j][0], self.table[-2][self.j][1] - 1, Cell(''))
+                self.add_cell(self.table[-2][self.j][0], self.table[-2][self.j][1] - 1, Cell(""))
         return
 
     def height(self):
@@ -162,80 +162,77 @@ def __repr__(self):
             for row in range(self.height()):
                 rows.append(self.row_height(row))
             ret = []
-            line = ['+']
+            line = ["+"]
             row = self.table[0]
             for col in range(len(cols)):
-                line.append('-' * cols[col])
+                line.append("-" * cols[col])
                 if self.table[0][col][0] > 1:
-                    line.append('-')
+                    line.append("-")
                 else:
-                    line.append('+')
-            ret.append(''.join(line))
+                    line.append("+")
+            ret.append("".join(line))
             for row in range(len(rows)):
                 for i in range(rows[row]):
                     line = []
-                    line.append('|')
+                    line.append("|")
                     for col in range(len(cols)):
                         if self.table[row][col][2].height() <= i:
-                            line.append(''.ljust(cols[col])[:cols[col]])
+                            line.append("".ljust(cols[col])[: cols[col]])
                         else:
-                            line.append(
-                                self.table[row][col][2]().split(
-                                    '\n')[i].ljust(cols[col])[:cols[col]])
+                            line.append(self.table[row][col][2]().split("\n")[i].ljust(cols[col])[: cols[col]])
                         if self.table[row][col][0] > 1:
-                            line.append(' ')
+                            line.append(" ")
                         else:
-                            line.append('|')
+                            line.append("|")
 
-                    ret.append(''.join(line))
-                line = ['+']
+                    ret.append("".join(line))
+                line = ["+"]
                 for col in range(len(cols)):
                     if self.table[row][col][1] > 1:
-                        line.append(' ' * cols[col])
+                        line.append(" " * cols[col])
                     elif row == self.header_count - 1:
-                        line.append('=' * cols[col])
+                        line.append("=" * cols[col])
                     else:
-                        line.append('-' * cols[col])
+                        line.append("-" * cols[col])
                     if self.table[row][col][0] > 1:
-                        if row + 1 < len(rows)\
-                                and self.table[row + 1][col][0] > 1\
-                                or row + 1 >= len(rows):
-                            line.append('-')
+                        if row + 1 < len(rows) and self.table[row + 1][col][0] > 1 or row + 1 >= len(rows):
+                            line.append("-")
                         else:
-                            line.append('+')
+                            line.append("+")
                     else:
-                        line.append('+')
-                ret.append(''.join(line))
-        return '\n'.join(ret)
+                        line.append("+")
+                ret.append("".join(line))
+        return "\n".join(ret)
 
 
 class ReST:
     """
     reST syntax elements
     """
+
     # moin2 reST standard headings, uses = above and below h1, = below h2, - below h3... + below h6
     # these heading styles are used in all .rst files under /docs/
     # does not agree with: http://documentation-style-guide-sphinx.readthedocs.io/en/latest/style-guide.html#headings
     h_top = " =     "
     h_bottom = " ==-*:+"
 
-    a_separator = '|'
-    verbatim = '::'
-    monospace = '``'
+    a_separator = "|"
+    verbatim = "::"
+    monospace = "``"
     strong = "**"
     emphasis = "*"
-    p = '\n'
-    linebreak = '\n\n'
-    separator = '----'
+    p = "\n"
+    linebreak = "\n\n"
+    separator = "----"
     list_type = {
-        ('definition', None): '',
-        ('ordered', None): '1.',
-        ('ordered', 'lower-alpha'): 'a.',
-        ('ordered', 'upper-alpha'): 'A.',
-        ('ordered', 'lower-roman'): 'i.',
-        ('ordered', 'upper-roman'): 'I.',
-        ('unordered', None): '*',
-        (None, None): ' ',
+        ("definition", None): "",
+        ("ordered", None): "1.",
+        ("ordered", "lower-alpha"): "a.",
+        ("ordered", "upper-alpha"): "A.",
+        ("ordered", "lower-roman"): "i.",
+        ("ordered", "upper-roman"): "I.",
+        ("unordered", None): "*",
+        (None, None): " ",
     }
 
 
@@ -243,35 +240,34 @@ class Converter:
     """
     Converter application/x.moin.document -> text/x.moin.rst
     """
-    namespaces = {
-        moin_page.namespace: 'moinpage',
-        xinclude: 'xinclude', }
+
+    namespaces = {moin_page.namespace: "moinpage", xinclude: "xinclude"}
 
     supported_tag = {
-        'moinpage': (
-            'a',
-            'blockcode',
-            'break_line',
-            'code',
-            'div',
-            'emphasis',
-            'h',
-            'list',
-            'list_item',
-            'list_item_label',
-            'list_item_body',
-            'p',
-            'page',
-            'separator',
-            'span',
-            'strong',
-            'object',
-            'table',
-            'table_header',
-            'teble_footer',
-            'table_body',
-            'table_row',
-            'table_cell',
+        "moinpage": (
+            "a",
+            "blockcode",
+            "break_line",
+            "code",
+            "div",
+            "emphasis",
+            "h",
+            "list",
+            "list_item",
+            "list_item_label",
+            "list_item_body",
+            "p",
+            "page",
+            "separator",
+            "span",
+            "strong",
+            "object",
+            "table",
+            "table_header",
+            "teble_footer",
+            "table_body",
+            "table_row",
+            "table_cell",
         )
     }
 
@@ -281,15 +277,15 @@ def factory(cls, input, output, **kw):
 
     def __init__(self):
         # TODO: create class containing all table attributes
-        self.table_tableclass = ''
-        self.table_tablestyle = ''
-        self.table_rowsclass = ''
-        self.table_rowsstyle = ''
-        self.table_rowstyle = ''
-        self.table_rowclass = ''
+        self.table_tableclass = ""
+        self.table_tablestyle = ""
+        self.table_rowsclass = ""
+        self.table_rowsstyle = ""
+        self.table_rowstyle = ""
+        self.table_rowclass = ""
 
         self.list_item_labels = []
-        self.list_item_label = ''
+        self.list_item_label = ""
         self.list_level = -1
 
         # 'text' - default status - <p> = '/n' and </p> = '/n'
@@ -298,8 +294,9 @@ def __init__(self):
         #       <p> if after </p> = '<<BR>>' and </p> = ''
         # status added because of
         #  differences in interpretation of <p> in different places
+
     def __call__(self, root):
-        self.status = ['text', ]
+        self.status = ["text"]
         self.last_closed = None
         self.list_item_label = []
         self.footnotes = []
@@ -325,10 +322,10 @@ def open_children(self, elem):
             if isinstance(child, ET.Element):
                 childs_output = self.open(child)
                 if self.delete_newlines:
-                    while childrens_output and re.match(r'(\n*)\Z', childrens_output[-1]):
+                    while childrens_output and re.match(r"(\n*)\Z", childrens_output[-1]):
                         childrens_output.pop()
                     if childrens_output:
-                        last_newlines = r'(\n*)\Z'
+                        last_newlines = r"(\n*)\Z"
                         i = -len(re.search(last_newlines, childrens_output[-1]).groups(1)[0])
                         if i:
                             childrens_output[-1] = childrens_output[-1][:i]
@@ -339,58 +336,67 @@ def open_children(self, elem):
             else:
                 if self.status[-1] == "table":
                     if self.last_closed == "p":
-                        childrens_output.append('\n\n')
+                        childrens_output.append("\n\n")
                 elif self.status[-1] == "list":
-                    child = re.sub(r"\n(.)", lambda m: "\n{}{}".format(' ' * (
-                        len(''.join(self.list_item_labels)) + len(self.list_item_labels)
-                    ), m.group(1)), child)
+                    child = re.sub(
+                        r"\n(.)",
+                        lambda m: "\n{}{}".format(
+                            " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)), m.group(1)
+                        ),
+                        child,
+                    )
                     if self.last_closed == "p":
                         childrens_output.append(
-                            '\n' + ' ' * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)))
+                            "\n" + " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels))
+                        )
                 elif self.status[-1] == "text":
                     if self.last_closed == "p":
                         childrens_output.append(self.define_references())
-                        childrens_output.append('\n')
+                        childrens_output.append("\n")
                 elif self.status[-2] == "list":
-                    child = re.sub(r"\n(.)", lambda m: "\n{}{}".format(' ' * (
-                        len(''.join(self.list_item_labels)) + len(self.list_item_labels)
-                    ), m.group(1)), child)
+                    child = re.sub(
+                        r"\n(.)",
+                        lambda m: "\n{}{}".format(
+                            " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)), m.group(1)
+                        ),
+                        child,
+                    )
                 childrens_output.append(child)
-                self.last_closed = 'text'
+                self.last_closed = "text"
         self.delete_newlines = delete_newlines
-        return ''.join(childrens_output)
+        return "".join(childrens_output)
 
     def open(self, elem):
         uri = elem.tag.uri
         name = self.namespaces.get(uri, None)
         if name is not None:
-            n = 'open_' + name
+            n = "open_" + name
             f = getattr(self, n, None)
             if f is not None:
                 return f(elem)
         return self.open_children(elem)
 
     def open_moinpage(self, elem):
-        n = 'open_moinpage_' + elem.tag.name.replace('-', '_')
+        n = "open_moinpage_" + elem.tag.name.replace("-", "_")
         f = getattr(self, n, None)
         if f:
             ret = f(elem)
-            self.last_closed = elem.tag.name.replace('-', '_')
+            self.last_closed = elem.tag.name.replace("-", "_")
             return ret
         return self.open_children(elem)
 
     def open_xinclude(self, elem):
-        n = 'open_xinclude_' + elem.tag.name.replace('-', '_')
+        n = "open_xinclude_" + elem.tag.name.replace("-", "_")
         f = getattr(self, n, None)
         if f:
             ret = f(elem)
-            self.last_closed = elem.tag.name.replace('-', '_')
+            self.last_closed = elem.tag.name.replace("-", "_")
             return ret
         return self.open_children(elem)
 
     def open_moinpage_a(self, elem):
         href = elem.get(xlink.href, None)
-        text = ''.join(elem.itertext()).replace('\n', ' ')
+        text = "".join(elem.itertext()).replace("\n", " ")
         # TODO: check that links have different alt texts
         if text in [t for (t, h) in self.all_used_references]:
             if (text, href) in self.all_used_references:
@@ -406,16 +412,16 @@ def open_moinpage_a(self, elem):
         return f"`{text}`_"
 
     def open_moinpage_blockcode(self, elem):
-        text = ''.join(elem.itertext())
-        text = text.replace('\n', '\n  ' +
-                            ' ' * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)))
+        text = "".join(elem.itertext())
+        text = text.replace("\n", "\n  " + " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)))
         if self.list_level >= 0:
             self.delete_newlines = True
         return "\n::\n\n  {}{}\n\n".format(
-            ' ' * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)), text)
+            " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)), text
+        )
 
     def open_moinpage_code(self, elem):
-        ret = "{}{}{}".format(ReST.monospace, ''.join(elem.itertext()), ReST.monospace)
+        ret = "{}{}{}".format(ReST.monospace, "".join(elem.itertext()), ReST.monospace)
         return ret
 
     def open_moinpage_div(self, elem):
@@ -426,12 +432,12 @@ def open_moinpage_div(self, elem):
         """
         if moin_page.class_ in elem.attrib:
             classes = elem.attrib[moin_page.class_].split()
-            if 'comment' in classes:
+            if "comment" in classes:
                 comment = self.open_children(elem)
-                if comment.startswith('\n'):
+                if comment.startswith("\n"):
                     comment = comment[1:]
-                comment = comment.replace('\n', '\n ')
-                return f'\n..\n {comment}\n'
+                comment = comment.replace("\n", "\n ")
+                return f"\n..\n {comment}\n"
         # in case div has another use
         return self.open_children(elem)
 
@@ -442,18 +448,18 @@ def open_moinpage_figure(self, elem):
             * a caption, figures have captions, images do not
             * optional text (may be several)
         """
-        ret = self.open_children(elem).replace('image', 'figure')
-        ret = ret.split('\n')
+        ret = self.open_children(elem).replace("image", "figure")
+        ret = ret.split("\n")
         lines = []
         for r in ret:
-            if r.startswith(('   ', '..')) or not r:
+            if r.startswith(("   ", "..")) or not r:
                 lines.append(r)
             else:
-                lines.append('   ' + r)
-        return '\n'.join(lines)
+                lines.append("   " + r)
+        return "\n".join(lines)
 
     def open_moinpage_figcaption(self, elem):
-        return f'\n   {self.open_children(elem)}\n'
+        return f"\n   {self.open_children(elem)}\n"
 
     def open_moinpage_emphasis(self, elem):
         childrens_output = self.open_children(elem)
@@ -461,17 +467,17 @@ def open_moinpage_emphasis(self, elem):
 
     def open_moinpage_h(self, elem):
         level = elem.get(moin_page.outline_level, 1)
-        text = ''.join(elem.itertext())
+        text = "".join(elem.itertext())
         try:
             level = int(level)
         except ValueError:
-            raise ElementException('page:outline-level needs to be an integer')
+            raise ElementException("page:outline-level needs to be an integer")
         if level < 1:
             level = 1
         elif level > 6:
             level = 6
         self.headings.append(text)
-        if ReST.h_top[level] == ' ':
+        if ReST.h_top[level] == " ":
             ret = f"\n{text}\n{ReST.h_bottom[level] * len(text)}\n"
         else:
             ret = f"\n{ReST.h_top[level] * len(text)}\n{text}\n{ReST.h_bottom[level] * len(text)}\n"
@@ -487,51 +493,50 @@ def open_xinclude_include(self, elem):
            :alt: alternate text png
            :align: center
         """
-        whitelist = {html.width: 'width', html.height: 'height', html.class_: 'align', html.alt: 'alt'}
+        whitelist = {html.width: "width", html.height: "height", html.class_: "align", html.alt: "alt"}
         href = elem.attrib[xinclude.href]
         try:
             href = href.path
         except Exception:
-            href = href.split('wiki.local:')[-1]
-        ret = [f'\n.. image:: {href}', ]
+            href = href.split("wiki.local:")[-1]
+        ret = [f"\n.. image:: {href}"]
         for key, val in sorted(whitelist.items()):
             if key in elem.attrib:
-                ret.append(f'   :{val}: {elem.attrib[key]}')
+                ret.append(f"   :{val}: {elem.attrib[key]}")
         if len(ret) == 1:
             # if there are no attributes, then (for now) we assume it is an include
-            ret[0] = ret[0].replace('image', 'include')
-        return '\n'.join(ret) + '\n'
+            ret[0] = ret[0].replace("image", "include")
+        return "\n".join(ret) + "\n"
 
     def open_moinpage_line_blk(self, elem):
         out = self.open_children(elem)
-        if out.startswith('\n'):
+        if out.startswith("\n"):
             out = out[1:]
-        return '| {}{}\n'.format(' ' * self.line_block_indent, out)
+        return "| {}{}\n".format(" " * self.line_block_indent, out)
 
     def open_moinpage_line_block(self, elem):
         ret = []
         if self.line_block_indent < 0:
-            ret.append('\n')
+            ret.append("\n")
         self.line_block_indent += 4
         for child in elem:
             ret.append(self.open(child))
         self.line_block_indent -= 4
-        return ''.join(ret)
+        return "".join(ret)
 
     def open_moinpage_line_break(self, elem):
         if self.status[-1] == "list":
-            return (ReST.linebreak + ' ' * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)))
-        if self.last_closed == 'p':
-            return '\n\n'
+            return ReST.linebreak + " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels))
+        if self.last_closed == "p":
+            return "\n\n"
         return ReST.linebreak
 
     def open_moinpage_list(self, elem):
         label_type = elem.get(moin_page.item_label_generate, None), elem.get(moin_page.list_style_type, None)
-        self.list_item_labels.append(
-            ReST.list_type.get(label_type, ' '))
+        self.list_item_labels.append(ReST.list_type.get(label_type, " "))
         self.list_level += 1
-        ret = ''
-        self.status.append('list')
+        ret = ""
+        self.status.append("list")
         self.last_closed = None
         ret += self.open_children(elem)
         self.list_item_labels.pop()
@@ -540,110 +545,122 @@ def open_moinpage_list(self, elem):
         return ret
 
     def open_moinpage_list_item(self, elem):
-        self.list_item_label = self.list_item_labels[-1] + ' '
+        self.list_item_label = self.list_item_labels[-1] + " "
         return self.open_children(elem)
 
     def open_moinpage_list_item_label(self, elem):
-        ret = ''
-        if self.list_item_labels[-1] == '' or self.list_item_labels[-1] == ' ':
-            self.list_item_labels[-1] = ' '
-            self.list_item_label = self.list_item_labels[-1] + ' '
-            ret = (' ' * (len(''.join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1])))
-            if self.last_closed and self.last_closed != 'list':
-                ret = f'\n{ret}'
+        ret = ""
+        if self.list_item_labels[-1] == "" or self.list_item_labels[-1] == " ":
+            self.list_item_labels[-1] = " "
+            self.list_item_label = self.list_item_labels[-1] + " "
+            ret = " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1]))
+            if self.last_closed and self.last_closed != "list":
+                ret = f"\n{ret}"
             return ret + self.open_children(elem)
         return self.open_children(elem)
 
     def open_moinpage_list_item_body(self, elem):
-        ret = ''
-        if not self.last_closed == 'list_item':
-            ret = '\n'
-        ret += (' ' * (len(''.join(self.list_item_labels[:-1])) +
-                       len(self.list_item_labels[:-1])) + self.list_item_label)
-        if self.list_item_labels[-1] in ['1.', 'i.', 'I.', 'a.', 'A.']:
-            self.list_item_labels[-1] = '#.'
+        ret = ""
+        if not self.last_closed == "list_item":
+            ret = "\n"
+        ret += " " * (len("".join(self.list_item_labels[:-1])) + len(self.list_item_labels[:-1])) + self.list_item_label
+        if self.list_item_labels[-1] in ["1.", "i.", "I.", "a.", "A."]:
+            self.list_item_labels[-1] = "#."
 
         ret = self.define_references() + ret + self.open_children(elem)
         if self.last_closed == "text":
-            return ret + '\n'
+            return ret + "\n"
         return ret
 
     def open_moinpage_note(self, elem):
         class_ = elem.get(moin_page.note_class, "")
         if class_:
-            self.status.append('list')
+            self.status.append("list")
             if class_ == "footnote":
                 self.footnotes.append(self.open_children(elem))
             self.status.pop()
-        return ' [#]_ '
+        return " [#]_ "
 
     def open_moinpage_object(self, elem):
         # TODO: object parameters support
-        href = elem.get(xlink.href, elem.get(xinclude.href, ''))
+        href = elem.get(xlink.href, elem.get(xinclude.href, ""))
         if isinstance(href, Iri):
             href = str(href)
-        href = href.split('?')
-        args = ''
+        href = href.split("?")
+        args = ""
         if len(href) > 1:
-            args = [s for s in re.findall(r'(?:^|;|,|&|)(\w+=\w+)(?:,|&|$)', href[1]) if s[:3] != 'do=']
+            args = [s for s in re.findall(r"(?:^|;|,|&|)(\w+=\w+)(?:,|&|$)", href[1]) if s[:3] != "do="]
         href = href[0]
-        alt = elem.get(moin_page.alt, '')
+        alt = elem.get(moin_page.alt, "")
         if not alt:
-            ret = ''
+            ret = ""
         else:
-            ret = f'|{alt}|'
-        args_text = ''
+            ret = f"|{alt}|"
+        args_text = ""
         if args:
-            args_text = "\n  {}".format('\n  '.join(':{}: {}'.format(
-                arg.split('=')[0], arg.split('=')[1]) for arg in args))
+            args_text = "\n  {}".format(
+                "\n  ".join(":{}: {}".format(arg.split("=")[0], arg.split("=")[1]) for arg in args)
+            )
         self.objects.append(f".. {ret} image:: {href}{args_text}")
         return ret
 
     def open_moinpage_p(self, elem):
-        ret = ''
-        if self.status[-1] == 'text':
-            self.status.append('p')
+        ret = ""
+        if self.status[-1] == "text":
+            self.status.append("p")
             set = self.define_references()
-            if self.last_closed == 'text':
+            if self.last_closed == "text":
                 ret = ReST.p * 2 + self.open_children(elem) + ReST.p + set
             elif self.last_closed:
                 ret = ReST.p + self.open_children(elem) + ReST.p + set
             else:
                 ret = self.open_children(elem) + ReST.p + set
-        elif self.status[-1] == 'table':
-            self.status.append('p')
-            if self.last_closed and self.last_closed != 'table_cell' \
-               and self.last_closed != 'table_row' \
-               and self.last_closed != 'table_header' \
-               and self.last_closed != 'table_footer' \
-               and self.last_closed != 'table_body' \
-               and self.last_closed != 'line_break':
+        elif self.status[-1] == "table":
+            self.status.append("p")
+            if (
+                self.last_closed
+                and self.last_closed != "table_cell"
+                and self.last_closed != "table_row"
+                and self.last_closed != "table_header"
+                and self.last_closed != "table_footer"
+                and self.last_closed != "table_body"
+                and self.last_closed != "line_break"
+            ):
                 # and self.last_closed != 'p':
                 ret = ReST.linebreak + self.open_children(elem)
-            elif self.last_closed == 'p' or self.last_closed == 'line_break':
+            elif self.last_closed == "p" or self.last_closed == "line_break":
                 ret = self.open_children(elem)
             else:
                 ret = self.open_children(elem)
-        elif self.status[-1] == 'list':
-            self.status.append('p')
-            if self.last_closed and self.last_closed == 'list_item_label':
+        elif self.status[-1] == "list":
+            self.status.append("p")
+            if self.last_closed and self.last_closed == "list_item_label":
                 ret = self.open_children(elem)
-            elif self.last_closed and self.last_closed != 'list_item' \
-                    and self.last_closed != 'list_item_header' \
-                    and self.last_closed != 'list_item_footer' \
-                    and self.last_closed != 'p':
-                ret = (ReST.linebreak + ' ' * (len(''.join(self.list_item_labels)) +
-                                               len(self.list_item_labels)) + self.open_children(elem))
-            elif self.last_closed and self.last_closed == 'p':
+            elif (
+                self.last_closed
+                and self.last_closed != "list_item"
+                and self.last_closed != "list_item_header"
+                and self.last_closed != "list_item_footer"
+                and self.last_closed != "p"
+            ):
+                ret = (
+                    ReST.linebreak
+                    + " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels))
+                    + self.open_children(elem)
+                )
+            elif self.last_closed and self.last_closed == "p":
                 # return ReST.p +\
-                ret = ("\n" + ' ' * (len(''.join(self.list_item_labels)) +
-                                     len(self.list_item_labels)) + self.open_children(elem))
+                ret = (
+                    "\n"
+                    + " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels))
+                    + self.open_children(elem)
+                )
             else:
                 ret = self.open_children(elem)
             if not self.delete_newlines:
                 ret += "\n"
         else:
-            self.status.append('p')
+            self.status.append("p")
             ret = self.open_children(elem)
         self.status.pop()
         return ret
@@ -655,56 +672,56 @@ def open_moinpage_page(self, elem):
     def open_moinpage_body(self, elem):
         return self.open_children(elem)
 
-    def open_moinpage_part(self, elem, sep='\n'):
-        type = elem.get(moin_page.content_type, "").split(';')
+    def open_moinpage_part(self, elem, sep="\n"):
+        type = elem.get(moin_page.content_type, "").split(";")
         if len(type) == 2:
             if type[0] == "x-moin/macro":
                 if len(elem) and next(iter(elem)).tag.name == "arguments":
-                    alt = "<<{}({})>>".format(type[1].split('=')[1], elem[0][0])
+                    alt = "<<{}({})>>".format(type[1].split("=")[1], elem[0][0])
                 else:
-                    alt = "<<{}()>>".format(type[1].split('=')[1])
+                    alt = "<<{}()>>".format(type[1].split("=")[1])
                 return sep + f".. macro:: {alt}" + sep
             elif type[0] == "x-moin/format":
                 elem_it = iter(elem)
-                ret = "\n\n.. parser:{}".format(type[1].split('=')[1])
+                ret = "\n\n.. parser:{}".format(type[1].split("=")[1])
                 if len(elem) and next(elem_it).tag.name == "arguments":
                     args = []
                     for arg in next(iter(elem)):
                         if arg.tag.name == "argument":
-                            args.append("{}=\"{}\"".format(arg.get(moin_page.name, ""), ' '.join(arg.itertext())))
-                    ret = '{} {}'.format(ret, ' '.join(args))
+                            args.append('{}="{}"'.format(arg.get(moin_page.name, ""), " ".join(arg.itertext())))
+                    ret = "{} {}".format(ret, " ".join(args))
                     elem = next(elem_it)
-                ret = "{}\n  {}".format(ret, ' '.join(elem.itertext()))
+                ret = "{}\n  {}".format(ret, " ".join(elem.itertext()))
                 return ret
-        return elem.get(moin_page.alt, '') + "\n"
+        return elem.get(moin_page.alt, "") + "\n"
 
-    def open_moinpage_inline_part(self, elem, sep=''):
+    def open_moinpage_inline_part(self, elem, sep=""):
         return self.open_moinpage_part(elem)
 
     def open_moinpage_separator(self, elem):
-        return '\n\n' + ReST.separator + '\n\n'
+        return "\n\n" + ReST.separator + "\n\n"
 
     def open_moinpage_span(self, elem):
-        baseline_shift = elem.get(moin_page.baseline_shift, '')
-        if baseline_shift == 'super':
-            return "\\ :sup:`{}`\\ ".format(''.join(elem.itertext()))
-        if baseline_shift == 'sub':
-            return "\\ :sub:`{}`\\ ".format(''.join(elem.itertext()))
-        id = elem.get(moin_page.id, '')
+        baseline_shift = elem.get(moin_page.baseline_shift, "")
+        if baseline_shift == "super":
+            return "\\ :sup:`{}`\\ ".format("".join(elem.itertext()))
+        if baseline_shift == "sub":
+            return "\\ :sub:`{}`\\ ".format("".join(elem.itertext()))
+        id = elem.get(moin_page.id, "")
         if id:
             self.headings.append(id)
-            return f'\n.. _{id}:\n'
+            return f"\n.. _{id}:\n"
         return self.open_children(elem)
 
     def open_moinpage_strong(self, elem):
         return ReST.strong + self.open_children(elem) + ReST.strong
 
     def open_moinpage_table(self, elem):
-        self.table_tableclass = elem.attrib.get('class', '')
-        self.table_tablestyle = elem.attrib.get('style', '')
-        self.table_rowsstyle = ''
-        self.table_rowsclass = ''
-        self.status.append('table')
+        self.table_tableclass = elem.attrib.get("class", "")
+        self.table_tablestyle = elem.attrib.get("style", "")
+        self.table_rowsstyle = ""
+        self.table_rowsclass = ""
+        self.status.append("table")
         self.last_closed = None
         self.table = []
         self.tablec = Table()
@@ -712,31 +729,35 @@ def open_moinpage_table(self, elem):
         self.status.pop()
         table = repr(self.tablec)
         if self.status[-1] == "list":
-            table = re.sub(r"\n(.)", lambda m: "\n{}{}".format(' ' * (
-                len(''.join(self.list_item_labels)) + len(self.list_item_labels)
-            ), m.group(1)), "\n" + table)
+            table = re.sub(
+                r"\n(.)",
+                lambda m: "\n{}{}".format(
+                    " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)), m.group(1)
+                ),
+                "\n" + table,
+            )
             return table + ReST.p
-        return '\n' + table + ReST.linebreak
+        return "\n" + table + ReST.linebreak
 
     def open_moinpage_table_header(self, elem):
         # is this correct rowclass?
-        self.tablec.rowclass = 'table-header'
+        self.tablec.rowclass = "table-header"
         return self.open_children(elem)
 
     def open_moinpage_table_body(self, elem):
-        self.tablec.rowclass = 'table-body'
+        self.tablec.rowclass = "table-body"
         return self.open_children(elem)
 
     def open_moinpage_table_row(self, elem):
-        self.table_rowclass = elem.attrib.get('class', '')
-        self.table_rowclass = ' '.join([s for s in [self.table_rowsclass, self.table_rowclass] if s])
-        self.table_rowstyle = elem.attrib.get('style', '')
-        self.table_rowstyle = ' '.join([s for s in [self.table_rowsstyle, self.table_rowstyle] if s])
+        self.table_rowclass = elem.attrib.get("class", "")
+        self.table_rowclass = " ".join([s for s in [self.table_rowsclass, self.table_rowclass] if s])
+        self.table_rowstyle = elem.attrib.get("style", "")
+        self.table_rowstyle = " ".join([s for s in [self.table_rowsstyle, self.table_rowstyle] if s])
         self.table.append([])
         self.tablec.add_row()
         ret = self.open_children(elem)
-        self.table_rowstyle = ''
-        self.table_rowclass = ''
+        self.table_rowstyle = ""
+        self.table_rowclass = ""
         self.tablec.end_row()
         return ret
 
@@ -745,8 +766,8 @@ def open_moinpage_table_cell(self, elem):
         number_rows_spanned = int(elem.get(moin_page.number_rows_spanned, 1))
         self.table[-1].append((number_cols_spanned, number_rows_spanned, [self.open_children(elem)]))
         cell = self.table[-1][-1]
-        self.tablec.add_cell(cell[0], cell[1], Cell(''.join(cell[2])))
-        return ''
+        self.tablec.add_cell(cell[0], cell[1], Cell("".join(cell[2])))
+        return ""
 
     def open_moinpage_table_of_content(self, elem):
         depth = elem.get(moin_page.outline_level, "")
@@ -759,18 +780,22 @@ def define_references(self):
         """
         Adds definitions of found links and objects to the converter output.
         """
-        ret = ''
+        ret = ""
         self.all_used_references.extend(self.used_references)
-        definitions = [" " * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)) +
-                       f".. _{t}: {h}" for t, h in self.used_references if t not in self.headings]
-        definitions.extend(" " * (len(''.join(self.list_item_labels)) + len(self.list_item_labels)) +
-                           link for link in self.objects)
+        definitions = [
+            " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)) + f".. _{t}: {h}"
+            for t, h in self.used_references
+            if t not in self.headings
+        ]
+        definitions.extend(
+            " " * (len("".join(self.list_item_labels)) + len(self.list_item_labels)) + link for link in self.objects
+        )
         # convert ".. _example: wiki.local:#example" to ".. _example:"
-        definitions = [x.split(' wiki.local')[0] for x in definitions]
+        definitions = [x.split(" wiki.local")[0] for x in definitions]
         definition_block = "\n\n".join(definitions)
 
         if definitions:
-            if self.last_closed == 'list_item_label':
+            if self.last_closed == "list_item_label":
                 ret += f"\n{definition_block}\n\n"
             else:
                 ret += f"\n\n{definition_block}\n\n"
@@ -781,9 +806,5 @@ def define_references(self):
         return ret
 
 
-default_registry.register(Converter.factory,
-                          type_moin_document,
-                          Type('text/x-rst'))
-default_registry.register(Converter.factory,
-                          type_moin_document,
-                          Type('x-moin/format;name=rst'))
+default_registry.register(Converter.factory, type_moin_document, Type("text/x-rst"))
+default_registry.register(Converter.factory, type_moin_document, Type("x-moin/format;name=rst"))
diff --git a/src/moin/converters/smiley.py b/src/moin/converters/smiley.py
index abc4bf6f5..950a2a30a 100644
--- a/src/moin/converters/smiley.py
+++ b/src/moin/converters/smiley.py
@@ -23,55 +23,58 @@ class Converter:
     """
     Replace each smiley by the corresponding element in the DOM Tree
     """
+
     smileys = {
         # markup: smiley name
-        'X-(': 'angry',
-        ':D': 'biggrin',
-        '<:(': 'frown',
-        ':o': 'redface',
-        ':(': 'sad',
-        ':)': 'smile',
-        'B)': 'smile2',
-        ':))': 'smile3',
-        ';)': 'smile4',
-        '/!\\': 'alert',
-        '<!>': 'attention',
-        '(!)': 'idea',
-        ':-?': 'tongue',
-        ':\\': 'ohwell',
-        '>:>': 'devil',
-        '|)': 'tired',
-        ':-(': 'sad',
-        ':-)': 'smile',
-        'B-)': 'smile2',
-        ':-))': 'smile3',
-        ';-)': 'smile4',
-        '|-)': 'tired',
-        '(./)': 'checkmark',
-        '{OK}': 'thumbs-up',
-        '{X}': 'icon-error',
-        '{i}': 'icon-info',
-        '{1}': 'prio1',
-        '{2}': 'prio2',
-        '{3}': 'prio3',
-        '{*}': 'star_on',
-        '{o}': 'star_off',
+        "X-(": "angry",
+        ":D": "biggrin",
+        "<:(": "frown",
+        ":o": "redface",
+        ":(": "sad",
+        ":)": "smile",
+        "B)": "smile2",
+        ":))": "smile3",
+        ";)": "smile4",
+        "/!\\": "alert",
+        "<!>": "attention",
+        "(!)": "idea",
+        ":-?": "tongue",
+        ":\\": "ohwell",
+        ">:>": "devil",
+        "|)": "tired",
+        ":-(": "sad",
+        ":-)": "smile",
+        "B-)": "smile2",
+        ":-))": "smile3",
+        ";-)": "smile4",
+        "|-)": "tired",
+        "(./)": "checkmark",
+        "{OK}": "thumbs-up",
+        "{X}": "icon-error",
+        "{i}": "icon-info",
+        "{1}": "prio1",
+        "{2}": "prio2",
+        "{3}": "prio3",
+        "{*}": "star_on",
+        "{o}": "star_off",
     }
 
     smiley_rule = r"""
     (^|(?<=\s))  # we require either beginning of line or some space before a smiley
     (%(smiley)s)  # one of the smileys
     ($|(?=\s))  # we require either ending of line or some space after a smiley
-""" % {'smiley': '|'.join([re.escape(s) for s in smileys])}
+""" % {
+        "smiley": "|".join([re.escape(s) for s in smileys])
+    }
 
     smiley_re = re.compile(smiley_rule, re.UNICODE | re.VERBOSE)
 
     # We do not process any smiley conversion within these elements.
-    tags_to_ignore = {'code', 'blockcode', 'nowiki', }
+    tags_to_ignore = {"code", "blockcode", "nowiki"}
 
     @classmethod
     def _factory(cls, input, output, icon=None, **kw):
-        if icon == 'smiley':
+        if icon == "smiley":
             return cls()
 
     def __call__(self, content):
@@ -93,7 +96,7 @@ def do_children(self, element):
                 if children is None:
                     children = ()
                 elif not isinstance(children, (list, tuple)):
-                    children = (children, )
+                    children = (children,)
                 new_children.extend(children)
             else:
                 # Otherwise, we have a text node, so we convert the smileys
@@ -130,7 +133,7 @@ def replace_smiley(self, text):
 
         if smiley_markup in self.smileys:
             smiley_name = self.smileys[smiley_markup]
-            attrib = {moin_page('class'): 'moin-text-icon moin-' + smiley_name}
+            attrib = {moin_page("class"): "moin-text-icon moin-" + smiley_name}
             return ET.Element(moin_page.span, attrib=attrib, children=[smiley_markup])
         else:
             # if the text was not a smiley, just return the markup without any transformations
diff --git a/src/moin/converters/text_csv_in.py b/src/moin/converters/text_csv_in.py
index 7cde47303..b627b4a02 100644
--- a/src/moin/converters/text_csv_in.py
+++ b/src/moin/converters/text_csv_in.py
@@ -21,6 +21,7 @@ class Converter(TableMixin):
     Parse the raw text and create a document object
     that can be converted into output using Emitter.
     """
+
     @classmethod
     def _factory(cls, type_input, type_output, **kw):
         return cls()
@@ -37,15 +38,15 @@ def __call__(self, data, contenttype=None, arguments=None):
         cls = None
         try:
             # fragile function, throws errors when csv file is incorrectly formatted
-            if csv.Sniffer().has_header('\n'.join(content)):
+            if csv.Sniffer().has_header("\n".join(content)):
                 head = rows[0]
                 rows = rows[1:]
-                cls = 'moin-sortable'
+                cls = "moin-sortable"
         except csv.Error as e:
-            head = [_('Error parsing CSV file:'), str(e)]
+            head = [_("Error parsing CSV file:"), str(e)]
         table = self.build_dom_table(rows, head=head, cls=cls)
-        body = moin_page.body(children=(table, ))
-        return moin_page.page(children=(body, ))
+        body = moin_page.body(children=(table,))
+        return moin_page.page(children=(body,))
 
 
-default_registry.register(Converter._factory, Type('text/csv'), type_moin_document)
+default_registry.register(Converter._factory, Type("text/csv"), type_moin_document)
diff --git a/src/moin/converters/text_in.py b/src/moin/converters/text_in.py
index e131d0ca2..13bfb6315 100644
--- a/src/moin/converters/text_in.py
+++ b/src/moin/converters/text_in.py
@@ -24,6 +24,7 @@ class Converter:
     Parse the raw text and create a document object
     that can be converted into output using Emitter.
     """
+
     @classmethod
     def _factory(cls, type_input, type_output, **kw):
         return cls()
@@ -34,12 +35,13 @@ def __call__(self, data, contenttype=None, arguments=None):
         blockcode = moin_page.blockcode()
         for line in content:
             if len(blockcode):
-                blockcode.append('\n')
+                blockcode.append("\n")
             blockcode.append(line.expandtabs())
-        body = moin_page.body(children=(blockcode, ))
-        return moin_page.page(children=(body, ))
+        body = moin_page.body(children=(blockcode,))
+        return moin_page.page(children=(body,))
 
 
 # Assign a lower priority (= bigger number) so that it is tried after pygments_in
-default_registry.register(Converter._factory, Type(type='text'), type_moin_document,
-                          default_registry.PRIORITY_MIDDLE + 1)
+default_registry.register(
+    Converter._factory, Type(type="text"), type_moin_document, default_registry.PRIORITY_MIDDLE + 1
+)
diff --git a/src/moin/converters/text_out.py b/src/moin/converters/text_out.py
index e0a472a4c..58279a337 100644
--- a/src/moin/converters/text_out.py
+++ b/src/moin/converters/text_out.py
@@ -19,12 +19,13 @@ class Converter:
     """
     Converter application/x.moin.document -> text/plain
     """
+
     @classmethod
     def factory(cls, input, output, **kw):
         return cls()
 
     def __call__(self, root):
-        return '\n'.join(root.itertext())
+        return "\n".join(root.itertext())
 
 
 default_registry.register(Converter.factory, type_moin_document, type_text_plain)
diff --git a/src/moin/converters/xml_in.py b/src/moin/converters/xml_in.py
index 0ebb7eecb..ce95ad1f3 100644
--- a/src/moin/converters/xml_in.py
+++ b/src/moin/converters/xml_in.py
@@ -13,6 +13,7 @@
 from moin.utils.mime import Type, type_text_plain
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -21,7 +22,7 @@
 
 def strip_xml(text):
     text = RX_STRIPXML.sub(" ", text)
-    text = ' '.join(text.split())
+    text = " ".join(text.split())
     return text
 
 
@@ -30,6 +31,7 @@ class XMLIndexingConverter:
     We try to generically extract contents from XML documents by just throwing
     away all XML tags. This is for indexing, so this might be good enough.
     """
+
     @classmethod
     def _factory(cls, input, output, **kw):
         return cls()
@@ -40,4 +42,4 @@ def __call__(self, rev, contenttype=None, arguments=None):
         return text
 
 
-default_registry.register(XMLIndexingConverter._factory, Type('text/xml'), type_text_plain)
+default_registry.register(XMLIndexingConverter._factory, Type("text/xml"), type_text_plain)
diff --git a/src/moin/datastructures/backends/__init__.py b/src/moin/datastructures/backends/__init__.py
index 573f1749c..7aef1781a 100644
--- a/src/moin/datastructures/backends/__init__.py
+++ b/src/moin/datastructures/backends/__init__.py
@@ -208,8 +208,11 @@ def __contains__(self, member, processed_groups=None):
         else:
             groups = flaskg.groups
             for group_name in self.member_groups:
-                if (group_name not in processed_groups and group_name in groups and
-                        groups[group_name].__contains__(member, processed_groups)):
+                if (
+                    group_name not in processed_groups
+                    and group_name in groups
+                    and groups[group_name].__contains__(member, processed_groups)
+                ):
                     return True
 
         return False
@@ -251,7 +254,8 @@ def __iter__(self, yielded_members=None, processed_groups=None):
 
     def __repr__(self):
         return "<{!r} name={!r} members={!r} member_groups={!r}>".format(
-            self.__class__, self.name, self.members, self.member_groups)
+            self.__class__, self.name, self.members, self.member_groups
+        )
 
 
 class BaseDict(UserDict):
diff --git a/src/moin/datastructures/backends/_tests/__init__.py b/src/moin/datastructures/backends/_tests/__init__.py
index b53d9e8e7..a390124d7 100644
--- a/src/moin/datastructures/backends/_tests/__init__.py
+++ b/src/moin/datastructures/backends/_tests/__init__.py
@@ -20,24 +20,27 @@
 
 class GroupsBackendTest:
 
-    test_groups = {'EditorGroup': ['AdminGroup', 'John', 'JoeDoe', 'Editor1', 'John'],
-                   'AdminGroup': ['Admin1', 'Admin2', 'John'],
-                   'OtherGroup': ['SomethingOther'],
-                   'RecursiveGroup': ['Something', 'OtherRecursiveGroup'],
-                   'OtherRecursiveGroup': ['RecursiveGroup', 'Anything', 'NotExistingGroup'],
-                   'ThirdRecursiveGroup': ['ThirdRecursiveGroup', 'Banana'],
-                   'EmptyGroup': [],
-                   'CheckNotExistingGroup': ['NotExistingGroup']}
-
-    expanded_groups = {'EditorGroup': ['Admin1', 'Admin2', 'John',
-                                       'JoeDoe', 'Editor1'],
-                       'AdminGroup': ['Admin1', 'Admin2', 'John'],
-                       'OtherGroup': ['SomethingOther'],
-                       'RecursiveGroup': ['Anything', 'Something', 'NotExistingGroup'],
-                       'OtherRecursiveGroup': ['Anything', 'Something', 'NotExistingGroup'],
-                       'ThirdRecursiveGroup': ['Banana'],
-                       'EmptyGroup': [],
-                       'CheckNotExistingGroup': ['NotExistingGroup']}
+    test_groups = {
+        "EditorGroup": ["AdminGroup", "John", "JoeDoe", "Editor1", "John"],
+        "AdminGroup": ["Admin1", "Admin2", "John"],
+        "OtherGroup": ["SomethingOther"],
+        "RecursiveGroup": ["Something", "OtherRecursiveGroup"],
+        "OtherRecursiveGroup": ["RecursiveGroup", "Anything", "NotExistingGroup"],
+        "ThirdRecursiveGroup": ["ThirdRecursiveGroup", "Banana"],
+        "EmptyGroup": [],
+        "CheckNotExistingGroup": ["NotExistingGroup"],
+    }
+
+    expanded_groups = {
+        "EditorGroup": ["Admin1", "Admin2", "John", "JoeDoe", "Editor1"],
+        "AdminGroup": ["Admin1", "Admin2", "John"],
+        "OtherGroup": ["SomethingOther"],
+        "RecursiveGroup": ["Anything", "Something", "NotExistingGroup"],
+        "OtherRecursiveGroup": ["Anything", "Something", "NotExistingGroup"],
+        "ThirdRecursiveGroup": ["Banana"],
+        "EmptyGroup": [],
+        "CheckNotExistingGroup": ["NotExistingGroup"],
+    }
 
     def test_contains(self):
         """
@@ -50,13 +53,13 @@ def test_contains(self):
             for member in members:
                 assert member in groups[group]
 
-        raises(GroupDoesNotExistError, lambda: groups['NotExistingGroup'])
+        raises(GroupDoesNotExistError, lambda: groups["NotExistingGroup"])
 
     def test_contains_group(self):
         groups = flaskg.groups
 
-        assert 'AdminGroup' in groups['EditorGroup']
-        assert 'EditorGroup' not in groups['AdminGroup']
+        assert "AdminGroup" in groups["EditorGroup"]
+        assert "EditorGroup" not in groups["AdminGroup"]
 
     def test_iter(self):
         groups = flaskg.groups
@@ -70,19 +73,19 @@ def test_iter(self):
     def test_get(self):
         groups = flaskg.groups
 
-        assert groups.get('AdminGroup')
-        assert 'NotExistingGroup' not in groups
-        assert groups.get('NotExistingGroup') is None
-        assert groups.get('NotExistingGroup', []) == []
+        assert groups.get("AdminGroup")
+        assert "NotExistingGroup" not in groups
+        assert groups.get("NotExistingGroup") is None
+        assert groups.get("NotExistingGroup", []) == []
 
     def test_groups_with_member(self):
         groups = flaskg.groups
 
-        john_groups = list(groups.groups_with_member('John'))
+        john_groups = list(groups.groups_with_member("John"))
         assert 2 == len(john_groups)
-        assert 'EditorGroup' in john_groups
-        assert 'AdminGroup' in john_groups
-        assert 'ThirdGroup' not in john_groups
+        assert "EditorGroup" in john_groups
+        assert "AdminGroup" in john_groups
+        assert "ThirdGroup" not in john_groups
 
     def test_backend_acl_allow(self):
         """
@@ -92,11 +95,11 @@ def test_backend_acl_allow(self):
         acl_rights = ["AdminGroup:admin,read,write"]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
 
-        for user in self.expanded_groups['AdminGroup']:
+        for user in self.expanded_groups["AdminGroup"]:
             for permission in ["read", "write", "admin"]:
                 assert acl.may(
                     "Admin1", permission
-                ), f'{user} must have {permission} permission because he is member of the AdminGroup'
+                ), f"{user} must have {permission} permission because he is member of the AdminGroup"
 
     def test_backend_acl_deny(self):
         """
@@ -106,20 +109,20 @@ def test_backend_acl_deny(self):
         acl_rights = ["AdminGroup:read,write"]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
 
-        assert "SomeUser" not in flaskg.groups['AdminGroup']
+        assert "SomeUser" not in flaskg.groups["AdminGroup"]
         for permission in ["read", "write"]:
             assert not acl.may(
                 "SomeUser", permission
-            ), f'SomeUser must not have {permission} permission because he is not listed in the AdminGroup'
+            ), f"SomeUser must not have {permission} permission because he is not listed in the AdminGroup"
 
-        assert 'Admin1' in flaskg.groups['AdminGroup']
+        assert "Admin1" in flaskg.groups["AdminGroup"]
         assert not acl.may("Admin1", "admin")
 
     def test_backend_acl_with_all(self):
         acl_rights = ["EditorGroup:read,write,admin All:read"]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
 
-        for member in self.expanded_groups['EditorGroup']:
+        for member in self.expanded_groups["EditorGroup"]:
             for permission in ["read", "write", "admin"]:
                 assert acl.may(member, permission)
 
@@ -128,7 +131,7 @@ def test_backend_acl_with_all(self):
             assert not acl.may("Someone", permission)
 
     def test_backend_acl_not_existing_group(self):
-        assert 'NotExistingGroup' not in flaskg.groups
+        assert "NotExistingGroup" not in flaskg.groups
 
         acl_rights = ["NotExistingGroup:read,write,admin All:read"]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
@@ -138,12 +141,15 @@ def test_backend_acl_not_existing_group(self):
 
 class DictsBackendTest:
 
-    dicts = {'SomeTestDict': {'First': 'first item',
-                              'text with spaces': 'second item',
-                              'Empty string': '',
-                              'Last': 'last item'},
-             'SomeOtherTestDict': {'One': '1',
-                                   'Two': '2'}}
+    dicts = {
+        "SomeTestDict": {
+            "First": "first item",
+            "text with spaces": "second item",
+            "Empty string": "",
+            "Last": "last item",
+        },
+        "SomeOtherTestDict": {"One": "1", "Two": "2"},
+    }
 
     def test_getitem(self):
         expected_dicts = self.dicts
@@ -161,15 +167,15 @@ def test_contains(self):
         for key in self.dicts:
             assert key in dicts
 
-        assert 'SomeNotExistingDict' not in dicts
+        assert "SomeNotExistingDict" not in dicts
 
     def test_update(self):
         dicts = flaskg.dicts
 
         d = {}
-        d.update(dicts['SomeTestDict'])
+        d.update(dicts["SomeTestDict"])
 
-        assert 'First' in d
+        assert "First" in d
 
     def test_get(self):
         dicts = flaskg.dicts
@@ -177,13 +183,13 @@ def test_get(self):
         for dict_name in self.dicts:
             assert dicts.get(dict_name)
 
-        assert 'SomeNotExistingDict' not in dicts
-        assert dicts.get('SomeNotExistingDict') is None
-        assert dicts.get('SomeNotExistingDict', {}) == {}
+        assert "SomeNotExistingDict" not in dicts
+        assert dicts.get("SomeNotExistingDict") is None
+        assert dicts.get("SomeNotExistingDict", {}) == {}
 
         for dict_name, expected_dict in self.dicts.items():
             test_dict = dicts[dict_name]
             for key, value in expected_dict.items():
-                assert 'SomeNotExistingKey' not in test_dict
-                assert test_dict.get('SomeNotExistingKey') is None
-                assert test_dict.get('SomeNotExistingKey', {}) == {}
+                assert "SomeNotExistingKey" not in test_dict
+                assert test_dict.get("SomeNotExistingKey") is None
+                assert test_dict.get("SomeNotExistingKey", {}) == {}
diff --git a/src/moin/datastructures/backends/_tests/test_composite_dicts.py b/src/moin/datastructures/backends/_tests/test_composite_dicts.py
index 62093029d..c4f63d386 100644
--- a/src/moin/datastructures/backends/_tests/test_composite_dicts.py
+++ b/src/moin/datastructures/backends/_tests/test_composite_dicts.py
@@ -20,19 +20,21 @@ class TestCompositeDict(DictsBackendTest):
     def cfg(self):
         class Config(wikiconfig.Config):
 
-            one_dict = {'SomeTestDict': {'First': 'first item',
-                                         'text with spaces': 'second item',
-                                         'Empty string': '',
-                                         'Last': 'last item'}}
+            one_dict = {
+                "SomeTestDict": {
+                    "First": "first item",
+                    "text with spaces": "second item",
+                    "Empty string": "",
+                    "Last": "last item",
+                }
+            }
 
-            other_dict = {'SomeOtherTestDict': {'One': '1',
-                                                'Two': '2'}}
+            other_dict = {"SomeOtherTestDict": {"One": "1", "Two": "2"}}
 
             def dicts(self):
-                return CompositeDicts(ConfigDicts(self.one_dict),
-                                      ConfigDicts(self.other_dict))
+                return CompositeDicts(ConfigDicts(self.one_dict), ConfigDicts(self.other_dict))
 
         return Config
 
 
-coverage_modules = ['moin.datastructures.backends.composite_dicts']
+coverage_modules = ["moin.datastructures.backends.composite_dicts"]
diff --git a/src/moin/datastructures/backends/_tests/test_composite_groups.py b/src/moin/datastructures/backends/_tests/test_composite_groups.py
index 253484d8e..005109556 100644
--- a/src/moin/datastructures/backends/_tests/test_composite_groups.py
+++ b/src/moin/datastructures/backends/_tests/test_composite_groups.py
@@ -38,35 +38,36 @@ def cfg(self):
 
         class Config(wikiconfig.Config):
 
-            admin_group = frozenset(['Admin', 'JohnDoe'])
-            editor_group = frozenset(['MainEditor', 'JohnDoe'])
-            fruit_group = frozenset(['Apple', 'Banana', 'Cherry'])
+            admin_group = frozenset(["Admin", "JohnDoe"])
+            editor_group = frozenset(["MainEditor", "JohnDoe"])
+            fruit_group = frozenset(["Apple", "Banana", "Cherry"])
 
-            first_backend_groups = {'AdminGroup': admin_group,
-                                    'EditorGroup': editor_group,
-                                    'FruitGroup': fruit_group}
+            first_backend_groups = {"AdminGroup": admin_group, "EditorGroup": editor_group, "FruitGroup": fruit_group}
 
-            user_group = frozenset(['JohnDoe', 'Bob', 'Joe'])
-            city_group = frozenset(['Bolzano', 'Riga', 'London'])
+            user_group = frozenset(["JohnDoe", "Bob", "Joe"])
+            city_group = frozenset(["Bolzano", "Riga", "London"])
 
             # Suppose, someone hacked second backend and added himself to AdminGroup
-            second_admin_group = frozenset(['TheHacker'])
+            second_admin_group = frozenset(["TheHacker"])
 
-            second_backend_groups = {'UserGroup': user_group,
-                                     'CityGroup': city_group,
-                                     # Here group name clash occurs.
-                                     # AdminGroup is defined in both
-                                     # first_backend and second_backend.
-                                     'AdminGroup': second_admin_group}
+            second_backend_groups = {
+                "UserGroup": user_group,
+                "CityGroup": city_group,
+                # Here group name clash occurs.
+                # AdminGroup is defined in both
+                # first_backend and second_backend.
+                "AdminGroup": second_admin_group,
+            }
 
             def groups(self):
-                return CompositeGroups(ConfigGroups(self.first_backend_groups),
-                                       ConfigGroups(self.second_backend_groups))
+                return CompositeGroups(
+                    ConfigGroups(self.first_backend_groups), ConfigGroups(self.second_backend_groups)
+                )
 
         return Config
 
     def test_getitem(self):
-        raises(GroupDoesNotExistError, lambda: flaskg.groups['NotExistingGroup'])
+        raises(GroupDoesNotExistError, lambda: flaskg.groups["NotExistingGroup"])
 
     def test_clashed_getitem(self):
         """
@@ -74,12 +75,12 @@ def test_clashed_getitem(self):
         backends. __getitem__ should return the first match (backends are
         considered in the order they are given in the backends list).
         """
-        admin_group = flaskg.groups['AdminGroup']
+        admin_group = flaskg.groups["AdminGroup"]
 
         # TheHacker added himself to the second backend, but that must not be
         # taken into consideration, because AdminGroup is defined in first
         # backend and we only use the first match.
-        assert 'TheHacker' not in admin_group
+        assert "TheHacker" not in admin_group
 
     def test_iter(self):
         all_group_names = list(flaskg.groups)
@@ -89,8 +90,8 @@ def test_iter(self):
         assert len(set(all_group_names)) == len(all_group_names)
 
     def test_contains(self):
-        assert 'UserGroup' in flaskg.groups
-        assert 'not existing group' not in flaskg.groups
+        assert "UserGroup" in flaskg.groups
+        assert "not existing group" not in flaskg.groups
 
 
-coverage_modules = ['moin.datastructures.backends.composite_groups']
+coverage_modules = ["moin.datastructures.backends.composite_groups"]
diff --git a/src/moin/datastructures/backends/_tests/test_config_dicts.py b/src/moin/datastructures/backends/_tests/test_config_dicts.py
index b1be80495..524415293 100644
--- a/src/moin/datastructures/backends/_tests/test_config_dicts.py
+++ b/src/moin/datastructures/backends/_tests/test_config_dicts.py
@@ -29,9 +29,9 @@ def dicts(self):
     def test__iter__(self):
         ConfigDicts_obj = ConfigDicts(DictsBackendTest.dicts)
         test_keyiterator = ConfigDicts.__iter__(ConfigDicts_obj)
-        expected = ['SomeTestDict', 'SomeOtherTestDict']
+        expected = ["SomeTestDict", "SomeOtherTestDict"]
         for result in test_keyiterator:
             assert result in expected
 
 
-coverage_modules = ['moin.datastructures.backends.config_dicts']
+coverage_modules = ["moin.datastructures.backends.config_dicts"]
diff --git a/src/moin/datastructures/backends/_tests/test_config_groups.py b/src/moin/datastructures/backends/_tests/test_config_groups.py
index dae102d73..160ee0014 100644
--- a/src/moin/datastructures/backends/_tests/test_config_groups.py
+++ b/src/moin/datastructures/backends/_tests/test_config_groups.py
@@ -25,4 +25,4 @@ def groups(self):
         return Config
 
 
-coverage_modules = ['moin.datastructures.backends.config_groups']
+coverage_modules = ["moin.datastructures.backends.config_groups"]
diff --git a/src/moin/datastructures/backends/_tests/test_lazy_config_groups.py b/src/moin/datastructures/backends/_tests/test_lazy_config_groups.py
index 313517655..fb575a3f0 100644
--- a/src/moin/datastructures/backends/_tests/test_lazy_config_groups.py
+++ b/src/moin/datastructures/backends/_tests/test_lazy_config_groups.py
@@ -16,10 +16,12 @@
 
 class TestLazyConfigGroups(GroupsBackendTest):
 
-    test_groups = {'EditorGroup': ['John', 'JoeDoe', 'Editor1'],
-                   'AdminGroup': ['Admin1', 'Admin2', 'John'],
-                   'OtherGroup': ['SomethingOther'],
-                   'EmptyGroup': []}
+    test_groups = {
+        "EditorGroup": ["John", "JoeDoe", "Editor1"],
+        "AdminGroup": ["Admin1", "Admin2", "John"],
+        "OtherGroup": ["SomethingOther"],
+        "EmptyGroup": [],
+    }
 
     expanded_groups = test_groups
 
@@ -47,20 +49,23 @@ def cfg(self):
         class Config(wikiconfig.Config):
 
             def groups(self):
-                config_groups = {'EditorGroup': ['AdminGroup', 'John', 'JoeDoe', 'Editor1', 'John'],
-                                 'RecursiveGroup': ['Something', 'OtherRecursiveGroup'],
-                                 'OtherRecursiveGroup': ['RecursiveGroup', 'Anything', 'NotExistingGroup'],
-                                 'ThirdRecursiveGroup': ['ThirdRecursiveGroup', 'Banana'],
-                                 'CheckNotExistingGroup': ['NotExistingGroup']}
-
-                lazy_groups = {'AdminGroup': ['Admin1', 'Admin2', 'John'],
-                               'OtherGroup': ['SomethingOther'],
-                               'EmptyGroup': []}
-
-                return CompositeGroups(ConfigGroups(config_groups),
-                                       ConfigLazyGroups(lazy_groups))
+                config_groups = {
+                    "EditorGroup": ["AdminGroup", "John", "JoeDoe", "Editor1", "John"],
+                    "RecursiveGroup": ["Something", "OtherRecursiveGroup"],
+                    "OtherRecursiveGroup": ["RecursiveGroup", "Anything", "NotExistingGroup"],
+                    "ThirdRecursiveGroup": ["ThirdRecursiveGroup", "Banana"],
+                    "CheckNotExistingGroup": ["NotExistingGroup"],
+                }
+
+                lazy_groups = {
+                    "AdminGroup": ["Admin1", "Admin2", "John"],
+                    "OtherGroup": ["SomethingOther"],
+                    "EmptyGroup": [],
+                }
+
+                return CompositeGroups(ConfigGroups(config_groups), ConfigLazyGroups(lazy_groups))
 
         return Config
 
 
-coverage_modules = ['moin.datastructures.backends.config_lazy_groups']
+coverage_modules = ["moin.datastructures.backends.config_lazy_groups"]
diff --git a/src/moin/datastructures/backends/_tests/test_wiki_dicts.py b/src/moin/datastructures/backends/_tests/test_wiki_dicts.py
index caebc62de..265b083f1 100644
--- a/src/moin/datastructures/backends/_tests/test_wiki_dicts.py
+++ b/src/moin/datastructures/backends/_tests/test_wiki_dicts.py
@@ -29,21 +29,17 @@ class TestWikiDictsBackend(DictsBackendTest):
     def custom_setup(self):
         become_trusted()
 
-        wikidict = {"First": "first item",
-                    "text with spaces": "second item",
-                    'Empty string': '',
-                    "Last": "last item"}
-        update_item('SomeTestDict', {WIKIDICT: wikidict}, DATA)
+        wikidict = {"First": "first item", "text with spaces": "second item", "Empty string": "", "Last": "last item"}
+        update_item("SomeTestDict", {WIKIDICT: wikidict}, DATA)
 
-        wikidict = {"One": "1",
-                    "Two": "2"}
-        update_item('SomeOtherTestDict', {WIKIDICT: wikidict}, DATA)
+        wikidict = {"One": "1", "Two": "2"}
+        update_item("SomeOtherTestDict", {WIKIDICT: wikidict}, DATA)
 
     def test__retrieve_items(self):
         wikidict_obj = wiki_dicts.WikiDicts()
-        result = wiki_dicts.WikiDicts._retrieve_items(wikidict_obj, 'SomeOtherTestDict')
-        expected = {'Two': '2', 'One': '1'}
+        result = wiki_dicts.WikiDicts._retrieve_items(wikidict_obj, "SomeOtherTestDict")
+        expected = {"Two": "2", "One": "1"}
         assert result == expected
 
 
-coverage_modules = ['moin.datastructures.backends.wiki_dicts']
+coverage_modules = ["moin.datastructures.backends.wiki_dicts"]
diff --git a/src/moin/datastructures/backends/_tests/test_wiki_groups.py b/src/moin/datastructures/backends/_tests/test_wiki_groups.py
index b434c0659..907ad4d4c 100644
--- a/src/moin/datastructures/backends/_tests/test_wiki_groups.py
+++ b/src/moin/datastructures/backends/_tests/test_wiki_groups.py
@@ -41,13 +41,13 @@ def test_rename_group_item(self):
         Tests renaming of a group item.
         """
         become_trusted()
-        update_item('SomeGroup', {USERGROUP: ["ExampleUser"]}, DATA)
-        assert 'ExampleUser' in flaskg.groups['SomeGroup']
-        pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups['AnotherGroup'])
+        update_item("SomeGroup", {USERGROUP: ["ExampleUser"]}, DATA)
+        assert "ExampleUser" in flaskg.groups["SomeGroup"]
+        pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups["AnotherGroup"])
 
-        update_item('SomeGroup', {NAME: ['AnotherGroup', ], USERGROUP: ["ExampleUser"]}, DATA)
-        assert 'ExampleUser' in flaskg.groups['AnotherGroup']
-        pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups['SomeGroup'])
+        update_item("SomeGroup", {NAME: ["AnotherGroup"], USERGROUP: ["ExampleUser"]}, DATA)
+        assert "ExampleUser" in flaskg.groups["AnotherGroup"]
+        pytest.raises(GroupDoesNotExistError, lambda: flaskg.groups["SomeGroup"])
 
     def test_appending_group_item(self):
         """
@@ -57,9 +57,9 @@ def test_appending_group_item(self):
         # long list of users
         members = create_random_string_list(length=15, count=1234)
         test_user = create_random_string_list(length=15, count=1)[0]
-        update_item('UserGroup', {USERGROUP: members}, DATA)
-        update_item('UserGroup', {USERGROUP: members + [test_user]}, '')
-        result = test_user in flaskg.groups['UserGroup']
+        update_item("UserGroup", {USERGROUP: members}, DATA)
+        update_item("UserGroup", {USERGROUP: members + [test_user]}, "")
+        result = test_user in flaskg.groups["UserGroup"]
 
         assert result
 
@@ -72,17 +72,17 @@ def test_member_removed_from_group_item(self):
 
         # long list of users
         members = create_random_string_list()
-        update_item('UserGroup', {USERGROUP: members}, DATA)
+        update_item("UserGroup", {USERGROUP: members}, DATA)
 
         # updates the text with the text_user
         test_user = create_random_string_list(length=15, count=1)[0]
-        update_item('UserGroup', {USERGROUP: [test_user]}, DATA)
-        result = test_user in flaskg.groups['UserGroup']
+        update_item("UserGroup", {USERGROUP: [test_user]}, DATA)
+        result = test_user in flaskg.groups["UserGroup"]
         assert result
 
         # updates the text without test_user
-        update_item('UserGroup', {}, DATA)
-        result = test_user in flaskg.groups['UserGroup']
+        update_item("UserGroup", {}, DATA)
+        result = test_user in flaskg.groups["UserGroup"]
         assert not result
 
     def test_wiki_backend_item_acl_usergroupmember_item(self):
@@ -92,7 +92,7 @@ def test_wiki_backend_item_acl_usergroupmember_item(self):
         then add user member to an item group and check acl rights
         """
         become_trusted()
-        update_item('NewGroup', {USERGROUP: ["ExampleUser"]}, DATA)
+        update_item("NewGroup", {USERGROUP: ["ExampleUser"]}, DATA)
 
         acl_rights = ["NewGroup:read,write"]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
@@ -100,12 +100,14 @@ def test_wiki_backend_item_acl_usergroupmember_item(self):
         has_rights_before = acl.may("AnotherUser", "read")
 
         # update item - add AnotherUser to a item group NewGroup
-        update_item('NewGroup', {USERGROUP: ["AnotherUser"]}, '')
+        update_item("NewGroup", {USERGROUP: ["AnotherUser"]}, "")
 
         has_rights_after = acl.may("AnotherUser", "read")
 
-        assert not has_rights_before, 'AnotherUser has no read rights because in the beginning he is not a member of a group item NewGroup'
-        assert has_rights_after, 'AnotherUser must have read rights because after appenditem he is member of NewGroup'
+        assert (
+            not has_rights_before
+        ), "AnotherUser has no read rights because in the beginning he is not a member of a group item NewGroup"
+        assert has_rights_after, "AnotherUser must have read rights because after appenditem he is member of NewGroup"
 
 
-coverage_modules = ['moin.datastructures.backends.wiki_groups']
+coverage_modules = ["moin.datastructures.backends.wiki_groups"]
diff --git a/src/moin/datastructures/backends/wiki_groups.py b/src/moin/datastructures/backends/wiki_groups.py
index a4d5eb5be..80bbc2c33 100644
--- a/src/moin/datastructures/backends/wiki_groups.py
+++ b/src/moin/datastructures/backends/wiki_groups.py
@@ -41,8 +41,11 @@ def __iter__(self):
         To find group pages, app.cfg.cache.item_group_regexact pattern is used.
         """
         # TODO: use whoosh to search for group_regex matching items
-        item_list = [rev.fqname.value for rev in flaskg.unprotected_storage.documents()
-                     if self.item_group_regex.search(rev.fqname.value)]
+        item_list = [
+            rev.fqname.value
+            for rev in flaskg.unprotected_storage.documents()
+            if self.item_group_regex.search(rev.fqname.value)
+        ]
         return iter(item_list)
 
     def __getitem__(self, group_name):
diff --git a/src/moin/error.py b/src/moin/error.py
index 944f1bf75..3ad4fac6e 100644
--- a/src/moin/error.py
+++ b/src/moin/error.py
@@ -9,7 +9,7 @@
 
 
 class Error(Exception):
-    """ Base class for moin moin errors
+    """Base class for moin moin errors
 
     Use this class when you raise errors or create sub classes that
     may be used to display non ASCII error message.
@@ -26,7 +26,7 @@ class Error(Exception):
     """
 
     def __init__(self, message):
-        """ Initialize an error, decode if needed
+        """Initialize an error, decode if needed
 
         :param message: str, bytes or object that supports __str__.
         """
@@ -37,16 +37,16 @@ def __init__(self, message):
         self.message = message
 
     def __str__(self):
-        """ Return str error message """
+        """Return str error message"""
         return self.message
 
     def __getitem__(self, item):
-        """ Make it possible to access attributes like a dict """
+        """Make it possible to access attributes like a dict"""
         return getattr(self, item)
 
 
 class CompositeError(Error):
-    """ Base class for exceptions containing an exception
+    """Base class for exceptions containing an exception
 
     Do not use this class but its more specific sub classes.
 
@@ -68,12 +68,12 @@ class InternalError(CompositeError):
     """
 
     def __init__(self, message):
-        """ Save system exception info before this exception is raised """
+        """Save system exception info before this exception is raised"""
         Error.__init__(self, message)
         self.innerException = sys.exc_info()
 
     def exceptions(self):
-        """ Return a list of all inner exceptions """
+        """Return a list of all inner exceptions"""
         all = [self.innerException]
         while True:
             lastException = all[-1][1]
@@ -85,15 +85,15 @@ def exceptions(self):
 
 
 class FatalError(CompositeError):
-    """ Base class for fatal error we can't handle
+    """Base class for fatal error we can't handle
 
     Do not use this class but its more specific sub classes.
     """
 
 
 class ConfigurationError(FatalError):
-    """ Raise when fatal misconfiguration is found """
+    """Raise when fatal misconfiguration is found"""
 
 
 class InternalError(FatalError):
-    """ Raise when internal fatal error is found """
+    """Raise when internal fatal error is found"""
diff --git a/src/moin/forms.py b/src/moin/forms.py
index 571add27d..9b3be2c41 100644
--- a/src/moin/forms.py
+++ b/src/moin/forms.py
@@ -15,8 +15,17 @@
 import json
 from operator import itemgetter
 
-from flatland import (Form, String, Integer, Boolean, Enum as BaseEnum, JoinedString,  # noqa
-                      List, Array, DateTime as _DateTime)
+from flatland import (
+    Form,
+    String,
+    Integer,
+    Boolean,
+    Enum as BaseEnum,
+    JoinedString,  # noqa
+    List,
+    Array,
+    DateTime as _DateTime,
+)
 from flatland.util import class_cloner, Unspecified
 from flatland.validation import Validator, Present, IsEmail, URLValidator, Converted, ValueAtLeast
 from flatland.exc import AdaptationError
@@ -28,10 +37,24 @@
 from flask import flash
 
 from moin.constants.forms import (
-    WIDGET_ANY_INTEGER, WIDGET_CHECKBOX, WIDGET_DATETIME, WIDGET_EMAIL, WIDGET_FILE, WIDGET_HIDDEN,
-    WIDGET_INLINE_CHECKBOX, WIDGET_MULTILINE_TEXT, WIDGET_MULTI_SELECT, WIDGET_PASSWORD, WIDGET_RADIO_CHOICE,
-    WIDGET_READONLY_ITEM_LINK_LIST, WIDGET_READONLY_STRING_LIST, WIDGET_SEARCH, WIDGET_SELECT,
-    WIDGET_SELECT_SUBMIT, WIDGET_SMALL_NATURAL, WIDGET_TEXT
+    WIDGET_ANY_INTEGER,
+    WIDGET_CHECKBOX,
+    WIDGET_DATETIME,
+    WIDGET_EMAIL,
+    WIDGET_FILE,
+    WIDGET_HIDDEN,
+    WIDGET_INLINE_CHECKBOX,
+    WIDGET_MULTILINE_TEXT,
+    WIDGET_MULTI_SELECT,
+    WIDGET_PASSWORD,
+    WIDGET_RADIO_CHOICE,
+    WIDGET_READONLY_ITEM_LINK_LIST,
+    WIDGET_READONLY_STRING_LIST,
+    WIDGET_SEARCH,
+    WIDGET_SELECT,
+    WIDGET_SELECT_SUBMIT,
+    WIDGET_SMALL_NATURAL,
+    WIDGET_TEXT,
 )
 
 from moin.constants.keys import ITEMID, NAME, LATEST_REVS, NAMESPACE, FQNAME
@@ -48,6 +71,7 @@ class Enum(BaseEnum):
     """
     An Enum with a convenience class method out_of.
     """
+
     @classmethod
     def out_of(cls, choice_specs, sort_by=None):
         """
@@ -99,7 +123,7 @@ def validate_name(meta, itemid):
     current_namespace = meta.get(NAMESPACE)
     if current_namespace is None:
         raise NameNotValidError(L_("No namespace field in the meta."))
-    namespaces = [namespace.rstrip('/') for namespace, _ in app.cfg.namespace_mapping]
+    namespaces = [namespace.rstrip("/") for namespace, _ in app.cfg.namespace_mapping]
 
     if len(names) != len(set(names)):
         msg = L_("The names in the name list must be unique.")
@@ -107,28 +131,31 @@ def validate_name(meta, itemid):
         raise NameNotValidError(msg)
 
     # Item names must not start with '@' or '+', '@something' denotes a field where as '+something' denotes a view.
-    invalid_names = [name for name in names if name.startswith(('@', '+'))]
+    invalid_names = [name for name in names if name.startswith(("@", "+"))]
     if invalid_names:
-        msg = L_("Item names ({invalid_names}) must not start with '@' or '+'"
-                ).format(invalid_names=", ".join(invalid_names))
+        msg = L_("Item names ({invalid_names}) must not start with '@' or '+'").format(
+            invalid_names=", ".join(invalid_names)
+        )
         flash(msg, "error")
         raise NameNotValidError(msg)
 
     # Item names must not contain commas
-    invalid_names = [name for name in names if ',' in name]
+    invalid_names = [name for name in names if "," in name]
     if invalid_names:
-        msg = L_("Item name ({invalid_names}) must not contain ',' characters. "
-                 "Create item with 1 name, use rename to create multiple names."
-                ).format(invalid_names=", ".join(invalid_names))
+        msg = L_(
+            "Item name ({invalid_names}) must not contain ',' characters. "
+            "Create item with 1 name, use rename to create multiple names."
+        ).format(invalid_names=", ".join(invalid_names))
         flash(msg, "error")
         raise NameNotValidError(msg)
 
     namespaces = namespaces + NAMESPACES_IDENTIFIER  # Also dont allow item names to match with identifier namespaces.
     # Item names must not match with existing namespaces.
-    invalid_names = [name for name in names if name.split('/', 1)[0] in namespaces]
+    invalid_names = [name for name in names if name.split("/", 1)[0] in namespaces]
     if invalid_names:
-        msg = L_("Item names ({invalid_names}) must not match with existing namespaces."
-                ).format(invalid_names=", ".join(invalid_names))
+        msg = L_("Item names ({invalid_names}) must not match with existing namespaces.").format(
+            invalid_names=", ".join(invalid_names)
+        )
         flash(msg, "error")  # duplicate message at top of form
         raise NameNotValidError(msg)
     query = And([Or([Term(NAME, name) for name in names]), Term(NAMESPACE, current_namespace)])
@@ -139,14 +166,16 @@ def validate_name(meta, itemid):
         results = searcher.search(query)
         duplicate_names = {name for result in results for name in result[NAME] if name in names}
         if duplicate_names:
-            msg = L_("Item(s) named {duplicate_names} already exist.").format(duplicate_names=", ".join(duplicate_names))
+            msg = L_("Item(s) named {duplicate_names} already exist.").format(
+                duplicate_names=", ".join(duplicate_names)
+            )
             flash(msg, "error")  # duplicate message at top of form
             raise NameNotValidError(msg)
 
 
 class ValidName(Validator):
-    """Validator for Name
-    """
+    """Validator for Name"""
+
     invalid_name_msg = ""
 
     def validate(self, element, state):
@@ -155,19 +184,19 @@ def validate(self, element, state):
             # apps/frontend/views.py will validate changes to user names
             return True
         try:
-            validate_name(state['meta'], state[ITEMID])
+            validate_name(state["meta"], state[ITEMID])
         except NameNotValidError as e:
             self.invalid_name_msg = _(str(e))
-            return self.note_error(element, state, 'invalid_name_msg')
+            return self.note_error(element, state, "invalid_name_msg")
         return True
 
 
 class ValidJSON(Validator):
-    """Validator for JSON
-    """
-    invalid_json_msg = L_('Invalid JSON.')
-    invalid_itemid_msg = L_('Itemid not a proper UUID')
-    invalid_namespace_msg = ''
+    """Validator for JSON"""
+
+    invalid_json_msg = L_("Invalid JSON.")
+    invalid_itemid_msg = L_("Itemid not a proper UUID")
+    invalid_namespace_msg = ""
 
     def validitemid(self, itemid):
         if not itemid:
@@ -179,9 +208,11 @@ def validnamespace(self, current_namespace):
         if current_namespace is None:
             self.invalid_namespace_msg = L_("No namespace field in the meta.")
             return False
-        namespaces = [namespace.rstrip('/') for namespace, _ in app.cfg.namespace_mapping]
+        namespaces = [namespace.rstrip("/") for namespace, _ in app.cfg.namespace_mapping]
         if current_namespace not in namespaces:  # current_namespace must be an existing namespace.
-            self.invalid_namespace_msg = L_("{_namespace} is not a valid namespace.").format(_namespace=current_namespace)
+            self.invalid_namespace_msg = L_("{_namespace} is not a valid namespace.").format(
+                _namespace=current_namespace
+            )
             return False
         return True
 
@@ -189,25 +220,28 @@ def validate(self, element, state):
         try:
             meta = json.loads(element.value)
         except:  # noqa - catch ANY exception that happens due to unserializing
-            return self.note_error(element, state, 'invalid_json_msg')
+            return self.note_error(element, state, "invalid_json_msg")
         if not self.validnamespace(meta.get(NAMESPACE)):
-            return self.note_error(element, state, 'invalid_namespace_msg')
+            return self.note_error(element, state, "invalid_namespace_msg")
         if state[FQNAME].field == ITEMID:
             if not self.validitemid(meta.get(ITEMID, state[FQNAME].value)):
-                return self.note_error(element, state, 'invalid_itemid_msg')
+                return self.note_error(element, state, "invalid_itemid_msg")
         return True
 
 
-JSON = OptionalMultilineText.with_properties(lang='en', dir='ltr').validated_by(ValidJSON())
+JSON = OptionalMultilineText.with_properties(lang="en", dir="ltr").validated_by(ValidJSON())
 
 URL = String.with_properties(widget=WIDGET_TEXT).validated_by(URLValidator())
 
-Email = String.using(label=L_('E-Mail')).with_properties(widget=WIDGET_EMAIL,
-                                                         placeholder=L_("E-Mail address")).validated_by(IsEmail())
+Email = (
+    String.using(label=L_("E-Mail"))
+    .with_properties(widget=WIDGET_EMAIL, placeholder=L_("E-Mail address"))
+    .validated_by(IsEmail())
+)
 
 YourEmail = Email.with_properties(placeholder=L_("Your E-Mail address"))
 
-Password = Text.with_properties(widget=WIDGET_PASSWORD).using(label=L_('Password'))
+Password = Text.with_properties(widget=WIDGET_PASSWORD).using(label=L_("Password"))
 
 RequiredPassword = Password.validated_by(Present())
 
@@ -233,6 +267,7 @@ class MyJoinedString(JoinedString):
     A JoinedString that offers the list of children (not the joined string) as
     value property.
     """
+
     @property
     def value(self):
         return [child.value for child in self]
@@ -243,9 +278,10 @@ def u(self):
 
 
 class SubscriptionsJoinedString(JoinedString):
-    """ A JoinedString that offers the list of children as value property and also
+    """A JoinedString that offers the list of children as value property and also
     appends the name of the item to the end of ITEMID subscriptions.
     """
+
     @property
     def value(self):
         subscriptions = []
@@ -266,7 +302,7 @@ def u(self):
                 value = child.u.split(" ", 1)[0]
                 item = flaskg.storage.document(**{ITEMID: value.split(":")[1]})
                 try:
-                    name_ = item.meta['name'][0]
+                    name_ = item.meta["name"][0]
                 except IndexError:
                     name_ = _("This item doesn't exist.")
                 except AttributeError:
@@ -279,21 +315,32 @@ def u(self):
         return self.separator.join(subscriptions)
 
 
-Tags = MyJoinedString.of(String).with_properties(widget=WIDGET_TEXT).using(
-    label=L_('Tags'), optional=True, separator=', ', separator_regex=re.compile(r'\s*,\s*'))
+Tags = (
+    MyJoinedString.of(String)
+    .with_properties(widget=WIDGET_TEXT)
+    .using(label=L_("Tags"), optional=True, separator=", ", separator_regex=re.compile(r"\s*,\s*"))
+)
 
-Names = MyJoinedString.of(String).with_properties(widget=WIDGET_TEXT).using(
-    label=L_('Names'), optional=True, separator=', ', separator_regex=re.compile(r'\s*,\s*')).validated_by(ValidName())
+Names = (
+    MyJoinedString.of(String)
+    .with_properties(widget=WIDGET_TEXT)
+    .using(label=L_("Names"), optional=True, separator=", ", separator_regex=re.compile(r"\s*,\s*"))
+    .validated_by(ValidName())
+)
 
-Subscriptions = SubscriptionsJoinedString.of(String).with_properties(
-    widget=WIDGET_MULTILINE_TEXT, rows=ROWS, cols=COLS).using(
-    label=L_('Subscriptions'), optional=True, separator='\n',
-    separator_regex=re.compile(r'[\r\n]+'))
+Subscriptions = (
+    SubscriptionsJoinedString.of(String)
+    .with_properties(widget=WIDGET_MULTILINE_TEXT, rows=ROWS, cols=COLS)
+    .using(label=L_("Subscriptions"), optional=True, separator="\n", separator_regex=re.compile(r"[\r\n]+"))
+)
 
-Quicklinks = MyJoinedString.of(String).with_properties(widget=WIDGET_MULTILINE_TEXT, rows=ROWS, cols=COLS).using(
-    label=L_('Quick Links'), optional=True, separator='\n', separator_regex=re.compile(r'[\r\n]+'))
+Quicklinks = (
+    MyJoinedString.of(String)
+    .with_properties(widget=WIDGET_MULTILINE_TEXT, rows=ROWS, cols=COLS)
+    .using(label=L_("Quick Links"), optional=True, separator="\n", separator_regex=re.compile(r"[\r\n]+"))
+)
 
-Search = Text.using(default='', optional=True).with_properties(widget=WIDGET_SEARCH, placeholder=L_("Search Query"))
+Search = Text.using(default="", optional=True).with_properties(widget=WIDGET_SEARCH, placeholder=L_("Search Query"))
 
 _Integer = Integer.validated_by(Converted())
 
@@ -311,6 +358,7 @@ class DateTimeUNIX(_DateTime):
     A DateTime that uses a UNIX timestamp instead of datetime as internal
     representation of DateTime.
     """
+
     def serialize(self, value):
         """Serializes value to string."""
         if isinstance(value, int):
@@ -337,14 +385,15 @@ def adapt(self, value):
         if isinstance(dt, datetime.datetime):
             # XXX forces circular dependency when it is in the head import block
             from moin.themes import utctimestamp
+
             # TODO: Add support for timezones
             dt = utctimestamp(dt)
         return dt
 
 
-DateTime = (DateTimeUNIX.with_properties(widget=WIDGET_DATETIME,
-                                         placeholder=_("YYYY-MM-DD HH:MM:SS (example: 2013-12-31 23:59:59)"))
-            .validated_by(Converted(incorrect=L_("Please use the following format: YYYY-MM-DD HH:MM:SS"))))
+DateTime = DateTimeUNIX.with_properties(
+    widget=WIDGET_DATETIME, placeholder=_("YYYY-MM-DD HH:MM:SS (example: 2013-12-31 23:59:59)")
+).validated_by(Converted(incorrect=L_("Please use the following format: YYYY-MM-DD HH:MM:SS")))
 
 File = FileStorage.with_properties(widget=WIDGET_FILE)
 
@@ -362,19 +411,21 @@ class ValidReference(Validator):
     """
     Validator for Reference
     """
-    invalid_reference_msg = L_('Invalid Reference.')
+
+    invalid_reference_msg = L_("Invalid Reference.")
 
     def validate(self, element, state):
         if element.value not in element.valid_values:
-            return self.note_error(element, state, 'invalid_reference_msg')
+            return self.note_error(element, state, "invalid_reference_msg")
         return True
 
 
-class Reference(Select.with_properties(empty_label=L_('(None)')).validated_by(ValidReference())):
+class Reference(Select.with_properties(empty_label=L_("(None)")).validated_by(ValidReference())):
     """
     A metadata property that points to another item selected out of the
     Results of a search query.
     """
+
     @class_cloner
     def to(cls, query, query_args={}):
         cls._query = query
@@ -384,10 +435,10 @@ def to(cls, query, query_args={}):
     @classmethod
     def _get_choice_specs(cls):
         revs = flaskg.storage.search(cls._query, **cls._query_args)
-        label_getter = cls.properties['label_getter']
+        label_getter = cls.properties["label_getter"]
         choices = [(rev.meta[ITEMID], label_getter(rev)) for rev in revs]
         if cls.optional:
-            choices.append(('', cls.properties['empty_label']))
+            choices.append(("", cls.properties["empty_label"]))
         return choices
 
     def __init__(self, value=Unspecified, **kw):
@@ -396,7 +447,7 @@ def __init__(self, value=Unspecified, **kw):
         # subclass having different set of choices when the storage changes
         # between their initialization.
         choice_specs = self._get_choice_specs()
-        self.properties['choice_specs'] = choice_specs
+        self.properties["choice_specs"] = choice_specs
         self.valid_values = [id_ for id_, name in choice_specs]
 
 
@@ -404,6 +455,7 @@ class BackReference(ReadonlyItemLinkList):
     """
     Back references built from Whoosh query.
     """
+
     def set(self, query, **query_args):
         revs = flaskg.storage.search(query, **query_args)
         super().set([rev.meta[NAME] for rev in revs])
diff --git a/src/moin/i18n/__init__.py b/src/moin/i18n/__init__.py
index 0e4e12d4e..379ca6e27 100644
--- a/src/moin/i18n/__init__.py
+++ b/src/moin/i18n/__init__.py
@@ -24,6 +24,7 @@
 from flask.globals import request_ctx
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -33,15 +34,15 @@
 
 
 def i18n_init(app):
-    """ initialize Flask-Babel """
+    """initialize Flask-Babel"""
     Babel(app, locale_selector=get_locale, timezone_selector=get_timezone)
 
 
 def get_locale():
-    """ return the locale for the current user """
+    """return the locale for the current user"""
     locale = None
     # this might be called at a time when flaskg.user is not setup yet:
-    u = getattr(flaskg, 'user', None)
+    u = getattr(flaskg, "user", None)
     if u and u.locale is not None:
         # locale is given in user profile, use it
         locale = u.locale
@@ -55,12 +56,12 @@ def get_locale():
         except RuntimeError:  # CLI call has no valid request context
             cli_no_request_ctx = True
 
-        supported_locales = [Locale('en')] + current_app.extensions['babel'].instance.list_translations()
+        supported_locales = [Locale("en")] + current_app.extensions["babel"].instance.list_translations()
         logging.debug(f"supported_locales = {supported_locales!r}")
         supported_languages = [str(locale) for locale in supported_locales]
         logging.debug(f"supported_languages = {supported_languages!r}")
         if not cli_no_request_ctx:
-            locale = request.accept_languages.best_match(supported_languages, 'en')
+            locale = request.accept_languages.best_match(supported_languages, "en")
             logging.debug(f"best match locale = {locale!r}")
     if not locale:
         locale = current_app.cfg.locale_default
@@ -69,9 +70,9 @@ def get_locale():
 
 
 def get_timezone():
-    """ return the timezone for the current user """
+    """return the timezone for the current user"""
     # this might be called at a time when flaskg.user is not setup yet:
-    u = getattr(flaskg, 'user', None)
+    u = getattr(flaskg, "user", None)
     if u and u.timezone is not None:
         return u.timezone
 
@@ -94,10 +95,10 @@ def force_locale(locale):
     if ctx is None:
         yield
         return
-    babel = ctx.app.extensions['babel']
+    babel = ctx.app.extensions["babel"]
     orig_locale_selector = babel.locale_selector
     orig_attrs = {}
-    for key in ('babel_translations', 'babel_locale'):
+    for key in ("babel_translations", "babel_locale"):
         orig_attrs[key] = getattr(ctx, key, None)
     try:
         babel.locale_selector = lambda: locale
diff --git a/src/moin/i18n/_tests/test_i18n.py b/src/moin/i18n/_tests/test_i18n.py
index 8a1b9d334..c3baf5a63 100644
--- a/src/moin/i18n/_tests/test_i18n.py
+++ b/src/moin/i18n/_tests/test_i18n.py
@@ -17,26 +17,26 @@
 
 def test_user_attributes():
     test_locale = get_locale()
-    assert test_locale == 'en'
+    assert test_locale == "en"
 
     test_timezone = get_timezone()
-    assert test_timezone == 'UTC'
+    assert test_timezone == "UTC"
 
 
 def test_text():
     # test for gettext
-    result = _('test_text')
-    assert result == 'test_text'
+    result = _("test_text")
+    assert result == "test_text"
 
     # test for lazy_gettext
-    result = L_('test_lazy_text')
-    assert result == 'test_lazy_text'
+    result = L_("test_lazy_text")
+    assert result == "test_lazy_text"
 
     # test for ngettext
-    result1 = N_('text1', 'text2', 1)
-    assert result1 == 'text1'
-    result2 = N_('text1', 'text2', 2)
-    assert result2 == 'text2'
+    result1 = N_("text1", "text2", 1)
+    assert result1 == "text1"
+    result2 = N_("text1", "text2", 2)
+    assert result2 == "text2"
 
 
 def test_force_locale():
@@ -44,12 +44,12 @@ def test_force_locale():
     app = Flask(__name__)
 
     def select_locale():
-        return 'de_DE'
+        return "de_DE"
 
     babel.Babel(app, locale_selector=select_locale)
 
     with app.test_request_context():
-        assert str(babel.get_locale()) == 'de_DE'
-        with force_locale('en_US'):
-            assert str(babel.get_locale()) == 'en_US'
-        assert str(babel.get_locale()) == 'de_DE'
+        assert str(babel.get_locale()) == "de_DE"
+        with force_locale("en_US"):
+            assert str(babel.get_locale()) == "en_US"
+        assert str(babel.get_locale()) == "de_DE"
diff --git a/src/moin/items/__init__.py b/src/moin/items/__init__.py
index 1f56ebf4e..5dbfbdeeb 100644
--- a/src/moin/items/__init__.py
+++ b/src/moin/items/__init__.py
@@ -49,24 +49,51 @@
 from moin.utils.registry import RegistryBase
 from moin.utils.diff_html import diff as html_diff
 from moin.utils import diff3
-from moin.forms import (
-    RequiredText, OptionalText, Tags, Names, validate_name,
-    NameNotValidError, OptionalMultilineText
-)
+from moin.forms import RequiredText, OptionalText, Tags, Names, validate_name, NameNotValidError, OptionalMultilineText
 from moin.constants.keys import (
-    NAME, NAMES, NAMENGRAM, NAME_OLD, NAME_EXACT, WIKINAME, MTIME, ITEMTYPE,
-    CONTENTTYPE, SIZE, ACTION, ADDRESS, HOSTNAME, USERID, COMMENT,
-    HASH_ALGORITHM, ITEMID, REVID, DATAID, CURRENT, PARENTID, NAMESPACE,
-    UFIELDS_TYPELIST, UFIELDS, TRASH, REV_NUMBER,
-    ACTION_SAVE, ACTION_REVERT, ACTION_TRASH, ACTION_RENAME, TAGS, TEMPLATE,
-    LATEST_REVS, EDIT_ROWS, FQNAMES, USERGROUP, WIKIDICT, LANGUAGE
+    NAME,
+    NAMES,
+    NAMENGRAM,
+    NAME_OLD,
+    NAME_EXACT,
+    WIKINAME,
+    MTIME,
+    ITEMTYPE,
+    CONTENTTYPE,
+    SIZE,
+    ACTION,
+    ADDRESS,
+    HOSTNAME,
+    USERID,
+    COMMENT,
+    HASH_ALGORITHM,
+    ITEMID,
+    REVID,
+    DATAID,
+    CURRENT,
+    PARENTID,
+    NAMESPACE,
+    UFIELDS_TYPELIST,
+    UFIELDS,
+    TRASH,
+    REV_NUMBER,
+    ACTION_SAVE,
+    ACTION_REVERT,
+    ACTION_TRASH,
+    ACTION_RENAME,
+    TAGS,
+    TEMPLATE,
+    LATEST_REVS,
+    EDIT_ROWS,
+    FQNAMES,
+    USERGROUP,
+    WIKIDICT,
+    LANGUAGE,
 )
 from moin.constants.chartypes import CHARS_UPPER, CHARS_LOWER
 from moin.constants.namespaces import NAMESPACE_ALL, NAMESPACE_USERPROFILES
 from moin.constants.contenttypes import CONTENTTYPE_NONEXISTENT, CONTENTTYPE_VARIABLES
-from moin.constants.itemtypes import (
-    ITEMTYPE_NONEXISTENT, ITEMTYPE_USERPROFILE, ITEMTYPE_DEFAULT, ITEMTYPE_TICKET
-)
+from moin.constants.itemtypes import ITEMTYPE_NONEXISTENT, ITEMTYPE_USERPROFILE, ITEMTYPE_DEFAULT, ITEMTYPE_TICKET
 from moin.utils.notifications import DESTROY_REV, DESTROY_ALL
 from moin.mail.sendmail import encodeSpamSafeEmail
 
@@ -74,6 +101,7 @@
 from ..utils.pysupport import load_package_modules
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -82,7 +110,7 @@
 
 
 def find_matches(fq_name, s_re=None, e_re=None):
-    """ Find similar item names.
+    """Find similar item names.
 
     :param fq_name: fqname to match
     :param s_re: start re for wiki matching
@@ -133,9 +161,9 @@ def wiki_matches(fq_name, fq_names, start_re=None, end_re=None):
     :returns: start, end, matches dict
     """
     if start_re is None:
-        start_re = re.compile(f'([{CHARS_UPPER}][{CHARS_LOWER}]+)')
+        start_re = re.compile(f"([{CHARS_UPPER}][{CHARS_LOWER}]+)")
     if end_re is None:
-        end_re = re.compile(f'([{CHARS_UPPER}][{CHARS_LOWER}]+)$')
+        end_re = re.compile(f"([{CHARS_UPPER}][{CHARS_LOWER}]+)$")
 
     # If we don't get results with wiki words matching, fall back to
     # simple first word and last word, using spaces.
@@ -154,7 +182,7 @@ def wiki_matches(fq_name, fq_names, start_re=None, end_re=None):
         end = words[-1]
 
     matches = {}
-    subitem = item_name + '/'
+    subitem = item_name + "/"
 
     # Find any matching item names and rank by type of match
     for fqname in fq_names:
@@ -171,7 +199,7 @@ def wiki_matches(fq_name, fq_names, start_re=None, end_re=None):
 
 
 def close_match(fq_name, fq_names):
-    """ Get close matches.
+    """Get close matches.
 
     Return all matching fqnames with rank above cutoff value.
 
@@ -194,8 +222,7 @@ def close_match(fq_name, fq_names):
             lower[key] = [fqname]
     # Get all close matches
     item_name = fq_name.value
-    all_matches = difflib.get_close_matches(item_name.lower(), list(lower.keys()),
-                                            n=len(lower), cutoff=0.6)
+    all_matches = difflib.get_close_matches(item_name.lower(), list(lower.keys()), n=len(lower), cutoff=0.6)
 
     # Replace lower names with original names
     matches = []
@@ -205,19 +232,20 @@ def close_match(fq_name, fq_names):
     return matches
 
 
-def _verify_parents(self, new_name, namespace, old_name=''):
+def _verify_parents(self, new_name, namespace, old_name=""):
     """
     If this is a subitem, verify all parent items exist. Return None if OK, raise error if not OK.
     """
-    name_segments = new_name.split('/')
+    name_segments = new_name.split("/")
     for idx in range(len(name_segments) - 1):
-        root_name = '/'.join(name_segments[:idx + 1])
+        root_name = "/".join(name_segments[: idx + 1])
         fqname = CompositeName(namespace, NAME_EXACT, root_name)
         parent_item = flaskg.unprotected_storage.get_item(**fqname.query)
         if parent_item.itemid is None:
-            raise MissingParentError(_(
-                "Cannot create or rename item '{new_name}' because parent '{parent_name}' is missing."
-            ).format(new_name=new_name, parent_name=name_segments[idx])
+            raise MissingParentError(
+                _("Cannot create or rename item '{new_name}' because parent '{parent_name}' is missing.").format(
+                    new_name=new_name, parent_name=name_segments[idx]
+                )
             )
 
 
@@ -242,24 +270,32 @@ def str_to_dict(data):
     lines = data.splitlines()
     for key_val in lines:
         if not key_val == key_val.strip():
-            flash(L_("Removed leading or trailing blanks from WikiDict line: '{key_val}'.").format(key_val=key_val), "info")
+            flash(
+                L_("Removed leading or trailing blanks from WikiDict line: '{key_val}'.").format(key_val=key_val),
+                "info",
+            )
             key_val = key_val.strip()
         if not key_val:
             flash(L_("Empty line in Wiki Dict discarded."), "info")
             continue  #
-        kv = key_val.split('=')
+        kv = key_val.split("=")
         if not len(kv) == 2:
-            new_dict[' ' + key_val] = key_val
+            new_dict[" " + key_val] = key_val
             continue
         k, v = kv
         if not k == k.strip():
-            flash(L_("Removed leading or trailing blanks from WikiDict key: '{key_val}'.").format(key_val=key_val), "info")
+            flash(
+                L_("Removed leading or trailing blanks from WikiDict key: '{key_val}'.").format(key_val=key_val), "info"
+            )
             k = k.strip()
         if not v == v.strip():
-            flash(L_("Removed leading or trailing blanks from WikiDict value: '{key_val}'.").format(key_val=key_val), "info")
+            flash(
+                L_("Removed leading or trailing blanks from WikiDict value: '{key_val}'.").format(key_val=key_val),
+                "info",
+            )
             v = v.strip()
         if k in new_dict:
-            new_dict[' ' + key_val] = key_val
+            new_dict[" " + key_val] = key_val
         else:
             new_dict[k] = v
     return new_dict
@@ -274,13 +310,13 @@ def dict_to_str(dic):
     """
     new_str = []
     for k, v in dic.items():
-        new_str.append(k + '=' + v)
-    new_str = '\r\n'.join(new_str)
+        new_str.append(k + "=" + v)
+    new_str = "\r\n".join(new_str)
     return new_str
 
 
 class RegistryItem(RegistryBase):
-    class Entry(namedtuple('Entry', 'factory itemtype display_name description order')):
+    class Entry(namedtuple("Entry", "factory itemtype display_name description order")):
         def __call__(self, itemtype, *args, **kw):
             if self.itemtype == itemtype:
                 return self.factory(*args, **kw)
@@ -302,7 +338,7 @@ def register(self, e, shown):
         """
         if shown:
             self.shown_entries.append(e)
-            self.shown_entries.sort(key=attrgetter('order'))
+            self.shown_entries.sort(key=attrgetter("order"))
         return self._register(e)
 
 
@@ -310,21 +346,20 @@ def register(self, e, shown):
 
 
 def register(cls):
-    item_registry.register(RegistryItem.Entry(cls._factory, cls.itemtype, cls.display_name,
-                                              cls.description, cls.order), cls.shown)
+    item_registry.register(
+        RegistryItem.Entry(cls._factory, cls.itemtype, cls.display_name, cls.description, cls.order), cls.shown
+    )
     return cls
 
 
 class DummyRev(dict):
-    """ if we have no stored Revision, we use this dummy """
+    """if we have no stored Revision, we use this dummy"""
+
     def __init__(self, item, itemtype=None, contenttype=None):
         self.item = item
         fqname = item.fqname
-        self.meta = {
-            ITEMTYPE: itemtype or ITEMTYPE_NONEXISTENT,
-            CONTENTTYPE: contenttype or CONTENTTYPE_NONEXISTENT
-        }
-        self.data = BytesIO(b'')
+        self.meta = {ITEMTYPE: itemtype or ITEMTYPE_NONEXISTENT, CONTENTTYPE: contenttype or CONTENTTYPE_NONEXISTENT}
+        self.data = BytesIO(b"")
         self.revid = None
         if item:
             self.meta[NAMESPACE] = fqname.namespace
@@ -338,7 +373,8 @@ def __init__(self, item, itemtype=None, contenttype=None):
 
 
 class DummyItem:
-    """ if we have no stored Item, we use this dummy """
+    """if we have no stored Item, we use this dummy"""
+
     def __init__(self, fqname):
         self.fqname = fqname
 
@@ -399,16 +435,16 @@ def get_storage_revision(fqname, itemtype=None, contenttype=None, rev_id=CURRENT
 
 class BaseChangeForm(Form):
     # autofocus=True causes javascript autoscroll in textarea to fail when using Chrome, Opera, or Maxthon browsers
-    comment = OptionalText.using(label=L_('Comment')).with_properties(
+    comment = OptionalText.using(label=L_("Comment")).with_properties(
         placeholder=L_("Comment about your change"), autofocus=False
     )
-    submit_label = L_('OK')
-    preview_label = L_('Preview')
-    cancel_label = L_('Cancel')
+    submit_label = L_("OK")
+    preview_label = L_("Preview")
+    cancel_label = L_("Cancel")
 
 
 class CreateItemForm(BaseChangeForm):
-    target = RequiredText.using(label=L_('Target')).with_properties(autofocus=True)
+    target = RequiredText.using(label=L_("Target")).with_properties(autofocus=True)
 
 
 def acl_validate(acl_string):
@@ -418,17 +454,17 @@ def acl_validate(acl_string):
     In later processes, None means no item ACLs, so the configured default ACLs will be used.
     Empty is same as "". If there are no configured 'after' ACLs, then Empty and "" are equivalent to "All:".
     """
-    all_rights = {'read', 'write', 'create', 'destroy', 'admin'}
+    all_rights = {"read", "write", "create", "destroy", "admin"}
     acls = str(acl_string)
-    if acls in ('None', 'Empty', ''):  # '' is not possible if field is required on form
+    if acls in ("None", "Empty", ""):  # '' is not possible if field is required on form
         return True
     acls = acls.split()
     for acl in acls:
-        acl_rules = acl.split(':')
+        acl_rules = acl.split(":")
         if len(acl_rules) == 2:
             who, rights = acl_rules
             if rights:
-                rights = rights.split(',')
+                rights = rights.split(",")
                 for right in rights:
                     if right not in all_rights:
                         return False
@@ -441,30 +477,32 @@ class ACLValidator(Validator):
     """
     Meta Validator - currently used for validating ACLs only
     """
+
     acl_fail_msg = L_("The ACL string is invalid.")
 
     def validate(self, element, state):
         if acl_validate(element) is True:
             return True
         flash(L_("The ACL string is invalid."), "error")
-        return element, state, 'acl_fail_msg'
+        return element, state, "acl_fail_msg"
 
 
 class DictValidator(Validator):
     """
     validate wiki dicts
     """
+
     msg = L_("The Wiki Dict is invalid. The format is 'key=value', one per line, no commas.")
 
     def validate(self, element, state):
-        meta = state['meta']
+        meta = state["meta"]
         if WIKIDICT in meta:
             for key, val in meta[WIKIDICT].items():
-                if key[0] == ' ' and key[1:] == val:
+                if key[0] == " " and key[1:] == val:
                     # the data is malformed, val has original line in form
                     msg = L_("Invalid key=value pair: '{invalid}'. Nothing saved.").format(invalid=val)
                     flash(msg, "error")
-                    return self.note_error(element, state, 'msg')
+                    return self.note_error(element, state, "msg")
         return True
 
 
@@ -472,31 +510,35 @@ class GroupValidator(Validator):
     """
     validate user groups
     """
+
     group_fail_msg = L_("The User Group list is invalid.")
 
     def validate(self, element, state):
         no_dups = set()
-        meta = state['meta']
+        meta = state["meta"]
         if USERGROUP in meta:
             names = meta[USERGROUP]
             for name in names:
                 if not name == name.strip():
-                    msg = L_("Invalid user name, leading or trailing blanks not allowed: '{invalid}'. Nothing saved."
-                            ).format(invalid=name)
+                    msg = L_(
+                        "Invalid user name, leading or trailing blanks not allowed: '{invalid}'. Nothing saved."
+                    ).format(invalid=name)
                     flash(msg, "error")
-                    return self.note_error(element, state, 'group_fail_msg')
+                    return self.note_error(element, state, "group_fail_msg")
                 if not name:
-                    msg = L_("Invalid user name, null string not allowed: '{invalid}'. Nothing saved.").format(invalid=name)
+                    msg = L_("Invalid user name, null string not allowed: '{invalid}'. Nothing saved.").format(
+                        invalid=name
+                    )
                     flash(msg, "error")
-                    return self.note_error(element, state, 'group_fail_msg')
-                if ',' in name:
+                    return self.note_error(element, state, "group_fail_msg")
+                if "," in name:
                     msg = L_("Invalid user name, ',' not allowed: '{invalid}'. Nothing saved.").format(invalid=name)
                     flash(msg, "error")
-                    return self.note_error(element, state, 'group_fail_msg')
+                    return self.note_error(element, state, "group_fail_msg")
                 if name in no_dups:
                     msg = L_("Duplicate user name: '{invalid}'. Nothing saved.").format(invalid=name)
                     flash(msg, "error")
-                    return self.note_error(element, state, 'group_fail_msg')
+                    return self.note_error(element, state, "group_fail_msg")
                 no_dups.add(name)
         return True
 
@@ -519,6 +561,7 @@ class BaseModifyForm(BaseChangeForm):
     This class is abstract and only defines two factory methods; see
     Item._ModifyForm for the implementation.
     """
+
     @classmethod
     def from_item(cls, item):
         """
@@ -556,13 +599,13 @@ def _build_contenttype_query(groups):
         for e in content_registry.groups[g]:
             ct_unicode = str(e.content_type)
             queries.append(Term(CONTENTTYPE, ct_unicode))
-            queries.append(Prefix(CONTENTTYPE, ct_unicode + ';'))
+            queries.append(Prefix(CONTENTTYPE, ct_unicode + ";"))
     return Or(queries)
 
 
-IndexEntry = namedtuple('IndexEntry', 'relname fullname meta')
+IndexEntry = namedtuple("IndexEntry", "relname fullname meta")
 
-MixedIndexEntry = namedtuple('MixedIndexEntry', 'relname fullname meta hassubitems')
+MixedIndexEntry = namedtuple("MixedIndexEntry", "relname fullname meta hassubitems")
 
 
 def get_itemtype_specific_tags(itemtype):
@@ -597,11 +640,12 @@ class FieldNotUniqueError(ValueError):
 
 
 class Item:
-    """ Highlevel (not storage) Item, wraps around a storage Revision"""
+    """Highlevel (not storage) Item, wraps around a storage Revision"""
+
     # placeholder values for registry entry properties
-    itemtype = ''
-    display_name = ''
-    description = ''
+    itemtype = ""
+    display_name = ""
+    description = ""
     shown = True
     order = 0
 
@@ -610,7 +654,7 @@ def _factory(cls, *args, **kw):
         return cls(*args, **kw)
 
     @classmethod
-    def create(cls, name='', itemtype=None, contenttype=None, rev_id=CURRENT, item=None):
+    def create(cls, name="", itemtype=None, contenttype=None, rev_id=CURRENT, item=None):
         """
         Create a highlevel Item by looking up :name or directly wrapping
         :item and extract the Revision designated by :rev_id revision.
@@ -657,6 +701,7 @@ def __init__(self, fqname, rev=None, content=None):
 
     def get_meta(self):
         return self.rev.meta
+
     meta = property(fget=get_meta)
 
     @property
@@ -667,7 +712,7 @@ def name(self):
         try:
             return self.names[0]
         except IndexError:
-            return ''
+            return ""
 
     @property
     def names(self):
@@ -696,37 +741,41 @@ def _meta_info(self):
         return self.meta_to_dict(self.meta, use_filter=False)
 
     def meta_filter(self, meta):
-        """ kill metadata entries that we set automatically when saving """
+        """kill metadata entries that we set automatically when saving"""
         kill_keys = [  # shall not get copied from old rev to new rev
             # As we have a special field for NAME we don't want NAME to appear in JSON meta.
-            NAME, NAME_OLD,
+            NAME,
+            NAME_OLD,
             # are automatically implanted when saving
-            REVID, DATAID,
+            REVID,
+            DATAID,
             HASH_ALGORITHM,
             SIZE,
             COMMENT,
             MTIME,
             ACTION,
-            ADDRESS, HOSTNAME, USERID,
+            ADDRESS,
+            HOSTNAME,
+            USERID,
         ]
         for key in kill_keys:
             meta.pop(key, None)
         return meta
 
     def meta_to_dict(self, meta, use_filter=True):
-        """ convert meta data from storage object to python dict """
+        """convert meta data from storage object to python dict"""
         meta = dict(meta)
         if use_filter:
             meta = self.meta_filter(meta)
         return meta
 
     def meta_text_to_dict(self, text):
-        """ convert meta data from a text fragment to a dict """
+        """convert meta data from a text fragment to a dict"""
         meta = json.loads(text)
         return self.meta_filter(meta)
 
     def meta_dict_to_text(self, meta, use_filter=True):
-        """ convert meta data from a dict to a text fragment """
+        """convert meta data from a dict to a text fragment"""
         meta = self.meta_to_dict(meta, use_filter)
         return json.dumps(meta, sort_keys=True, indent=2, ensure_ascii=False)
 
@@ -757,19 +806,22 @@ def _rename(self, names, comment, action, delete=False, do_subitems=True, ajax=F
             if ajax:
                 messages.append(L_('The item "{name}" was deleted.').format(name=old_name))
             else:
-                flash(L_('The item "{name}" was deleted.').format(name=old_name), 'info')
+                flash(L_('The item "{name}" was deleted.').format(name=old_name), "info")
         else:
             # rename
             if ajax:
-                messages.append(L_('The item "{name}" was renamed to "{new_name}".'
-                                  ).format(name=old_name, new_name=new_name))
+                messages.append(
+                    L_('The item "{name}" was renamed to "{new_name}".').format(name=old_name, new_name=new_name)
+                )
             else:
-                flash(L_('The item "{name}" was renamed to "{new_name}".'
-                        ).format(name=old_name, new_name=new_name), 'info')
+                flash(
+                    L_('The item "{name}" was renamed to "{new_name}".').format(name=old_name, new_name=new_name),
+                    "info",
+                )
         removed_names = set(self.meta[NAME]) - set(names)
-        removed_names = tuple(x + '/' for x in removed_names)
+        removed_names = tuple(x + "/" for x in removed_names)
         if removed_names or delete:
-            new_parent = names[0] + '/'  # new prefix that will adopt any orphaned subitems
+            new_parent = names[0] + "/"  # new prefix that will adopt any orphaned subitems
             subitems = list(self.get_subitem_revs())
             for child in subitems:
                 old_name = child.meta[NAME] if len(child.meta[NAME]) > 1 else child.meta[NAME][0]
@@ -777,12 +829,13 @@ def _rename(self, names, comment, action, delete=False, do_subitems=True, ajax=F
                     child_newname = None
                     old_fqname = CompositeName(self.fqname.namespace, NAME_EXACT, child.meta[NAME][0])
                     item = Item.create(old_fqname.fullname)
-                    item._save(item.meta, item.content.data, names=child_newname, action=action,
-                               comment=comment, delete=delete)
+                    item._save(
+                        item.meta, item.content.data, names=child_newname, action=action, comment=comment, delete=delete
+                    )
                     if ajax:
                         messages.append(L_('The subitem "{name}" was deleted.').format(name=old_name))
                     else:
-                        flash(L_('The item "{name}" was deleted.').format(name=old_name), 'info')
+                        flash(L_('The item "{name}" was deleted.').format(name=old_name), "info")
                     close_file(item.rev.data)
                     subitem_names += [x.fullname for x in child.meta.revision.fqnames]
                 else:  # rename
@@ -795,15 +848,25 @@ def _rename(self, names, comment, action, delete=False, do_subitems=True, ajax=F
                                 working_name = [child_newname if x == child_oldname else x for x in working_name]
                                 old_fqname = CompositeName(self.fqname.namespace, NAME_EXACT, child_oldname)
                                 item = Item.create(old_fqname.fullname)
-                                item._save(item.meta, item.content.data, names=working_name, action=action,
-                                           comment=comment, delete=delete)
+                                item._save(
+                                    item.meta,
+                                    item.content.data,
+                                    names=working_name,
+                                    action=action,
+                                    comment=comment,
+                                    delete=delete,
+                                )
                                 new_name = working_name if len(working_name) > 1 else working_name[0]
-                                flash(L_('The item "{name}" was renamed to "{new_name}".'
-                                        ).format(name=old_name, new_name=new_name), 'info')
+                                flash(
+                                    L_('The item "{name}" was renamed to "{new_name}".').format(
+                                        name=old_name, new_name=new_name
+                                    ),
+                                    "info",
+                                )
                                 close_file(item.rev.data)
         return messages, subitem_names
 
-    def rename(self, names, comment=''):
+    def rename(self, names, comment=""):
         """
         rename this item to item <names> (replace current names by names in the NAME list)
         """
@@ -816,13 +879,15 @@ def rename(self, names, comment=''):
                 if flaskg.storage.get_item(**fqname.query):
                     raise NameNotUniqueError(
                         L_("An item named {name} already exists in the namespace {namespace}.").format(
-                            name=name, namespace=fqname.namespace))
-            if '/' in name:
+                            name=name, namespace=fqname.namespace
+                        )
+                    )
+            if "/" in name:
                 # if this is a subitem, verify all parent items exist
                 _verify_parents(self, name, self.fqname.namespace, old_name=self.fqname.value)
         self._rename(names, comment, action=ACTION_RENAME)
 
-    def delete(self, comment='', do_subitems=True, ajax=False):
+    def delete(self, comment="", do_subitems=True, ajax=False):
         """
         delete this item
         """
@@ -830,14 +895,14 @@ def delete(self, comment='', do_subitems=True, ajax=False):
         ret = self._rename(self.names, comment, action=ACTION_TRASH, delete=True, do_subitems=do_subitems, ajax=ajax)
         return ret
 
-    def revert(self, comment=''):
+    def revert(self, comment=""):
         meta = dict(self.meta)
         meta[TRASH] = False
         if not self.meta[NAME]:
             meta[NAME] = meta[NAME_OLD]
         return self._save(meta, self.content.data, names=meta[NAME], action=ACTION_REVERT, comment=comment)
 
-    def destroy(self, comment='', destroy_item=False, subitem_names=[], ajax=False):
+    def destroy(self, comment="", destroy_item=False, subitem_names=[], ajax=False):
         """
         If destroy_item is false destroy current revision; else destroy current item and
         any items passed in subitem_names.
@@ -858,7 +923,7 @@ def destroy(self, comment='', destroy_item=False, subitem_names=[], ajax=False):
             if ajax:
                 messages.append(L_('The item "{name}" was destroyed.').format(name=old_name))
             else:
-                flash(L_('The item "{name}" was destroyed.').format(name=old_name), 'info')
+                flash(L_('The item "{name}" was destroyed.').format(name=old_name), "info")
             # destroy all subitems
             for subitem_name in subitem_names:
                 first_name = subitem_name[0] if isinstance(subitem_name, list) else subitem_name
@@ -870,23 +935,34 @@ def destroy(self, comment='', destroy_item=False, subitem_names=[], ajax=False):
                     if ajax:
                         messages.append(L_('The subitem "{name}" was destroyed.').format(name=old_name))
                     else:
-                        flash(L_('The item "{name}" was destroyed.').format(name=old_name), 'info')
+                        flash(L_('The item "{name}" was destroyed.').format(name=old_name), "info")
                     destroyed_names += item.names
                 else:
                     if ajax:
-                        messages.append(L_('Error: The subitem "{name}" was not destroyed, permission denied.'
-                                           ).format(name=old_name))
+                        messages.append(
+                            L_('Error: The subitem "{name}" was not destroyed, permission denied.').format(
+                                name=old_name
+                            )
+                        )
                     else:
-                        flash(L_('Error: The subitem "{name}" was not destroyed, permission denied.'
-                                 ).format(name=old_name), 'info')
+                        flash(
+                            L_('Error: The subitem "{name}" was not destroyed, permission denied.').format(
+                                name=old_name
+                            ),
+                            "info",
+                        )
         else:
             # just destroy this revision
             self.rev.item.destroy_revision(self.rev.revid)
-            flash(L_('Rev Number {rev_number} of the item "{name}" was destroyed.'
-                     ).format(rev_number=self.meta['rev_number'], name=old_name), 'info')
+            flash(
+                L_('Rev Number {rev_number} of the item "{name}" was destroyed.').format(
+                    rev_number=self.meta["rev_number"], name=old_name
+                ),
+                "info",
+            )
         return messages, destroyed_names
 
-    def modify(self, meta, data, comment='', contenttype_guessed=None, **update_meta):
+    def modify(self, meta, data, comment="", contenttype_guessed=None, **update_meta):
         meta = dict(meta)  # we may get a read-only dict-like, copy it
         # get rid of None values
         update_meta = {key: value for key, value in update_meta.items() if value is not None}
@@ -902,14 +978,19 @@ class _ModifyForm(BaseModifyForm):
         Subclasses of Contentful should generally override this instead of
         ModifyForm.
         """
+
         meta_form = BaseMetaForm
-        wikidict = (OptionalMultilineText.using(label=L_("Wiki Dict")).with_properties(rows=ROWS_META, cols=COLS)
-                    .validated_by(DictValidator())
-                    )
-        usergroup = (OptionalMultilineText.using(label=L_("User Group")).with_properties(rows=ROWS_META, cols=COLS)
-                     .validated_by(GroupValidator())
-                     )
-        meta_template = 'modify_meta.html'
+        wikidict = (
+            OptionalMultilineText.using(label=L_("Wiki Dict"))
+            .with_properties(rows=ROWS_META, cols=COLS)
+            .validated_by(DictValidator())
+        )
+        usergroup = (
+            OptionalMultilineText.using(label=L_("User Group"))
+            .with_properties(rows=ROWS_META, cols=COLS)
+            .validated_by(GroupValidator())
+        )
+        meta_template = "modify_meta.html"
 
         def _load(self, item):
             """
@@ -921,22 +1002,22 @@ def _load(self, item):
             # 'strict', which causes KeyError to be thrown when meta contains
             # meta keys that are not present in self['meta_form']. Setting
             # policy to 'duck' suppresses this behavior.
-            if 'acl' not in meta:
-                meta['acl'] = "None"
-            self['meta_form'].set(meta, policy='duck')
-            if meta[NAME][0].endswith('Dict'):
+            if "acl" not in meta:
+                meta["acl"] = "None"
+            self["meta_form"].set(meta, policy="duck")
+            if meta[NAME][0].endswith("Dict"):
                 try:
                     self[WIKIDICT].set(dict_to_str(item.meta[WIKIDICT]))
                 except KeyError:
                     pass
-            if meta[NAME][0].endswith('Group'):
+            if meta[NAME][0].endswith("Group"):
                 try:
-                    user_group = '\r\n'.join(item.meta[USERGROUP])
+                    user_group = "\r\n".join(item.meta[USERGROUP])
                     self[USERGROUP].set(user_group)
                 except KeyError:
                     pass
 
-            self['content_form']._load(item.content)
+            self["content_form"]._load(item.content)
 
         def _dump(self, item):
             """
@@ -952,13 +1033,13 @@ def _dump(self, item):
             # original meta and update it with those from the metadata editor
             # e.g. we get PARENTID in here
             meta = item.meta_filter(item.prepare_meta_for_modify(item.meta))
-            meta.update(self['meta_form'].value)
-            if item.name.endswith('Dict'):
+            meta.update(self["meta_form"].value)
+            if item.name.endswith("Dict"):
                 meta.update({WIKIDICT: str_to_dict(self[WIKIDICT].value)})
-            if item.name.endswith('Group'):
+            if item.name.endswith("Group"):
                 meta.update({USERGROUP: self[USERGROUP].value.splitlines()})
-            data, contenttype_guessed = self['content_form']._dump(item.content)
-            comment = self['comment'].value
+            data, contenttype_guessed = self["content_form"]._dump(item.content)
+            comment = self["comment"].value
             return meta, data, contenttype_guessed, comment
 
     def do_modify(self):
@@ -970,8 +1051,17 @@ def do_modify(self):
         """
         raise NotImplementedError
 
-    def _save(self, meta, data=None, names=None, action=ACTION_SAVE, contenttype_guessed=None, comment=None,
-              overwrite=False, delete=False):
+    def _save(
+        self,
+        meta,
+        data=None,
+        names=None,
+        action=ACTION_SAVE,
+        contenttype_guessed=None,
+        comment=None,
+        overwrite=False,
+        delete=False,
+    ):
         """
         Called by rename (delete calls rename), revert, modify (including first save), admin acl changes.
 
@@ -995,13 +1085,13 @@ def _save(self, meta, data=None, names=None, action=ACTION_SAVE, contenttype_gue
         else:
             meta[LANGUAGE] = app.cfg.language_default
 
-        if 'acl' in meta:
+        if "acl" in meta:
             # we treat this as nothing specified, so fallback to default
-            if meta['acl'] == 'None':
-                meta.pop('acl')
+            if meta["acl"] == "None":
+                meta.pop("acl")
             # this is treated as a rule which matches nothing
-            elif meta['acl'] == 'Empty':
-                meta['acl'] = ''
+            elif meta["acl"] == "Empty":
+                meta["acl"] = ""
         # we store the previous (if different) and current item names into revision metadata
         # this is useful for deletes, rename history and backends that use item uids internally
         if self.fqname.field == NAME_EXACT:
@@ -1047,28 +1137,37 @@ def _save(self, meta, data=None, names=None, action=ACTION_SAVE, contenttype_gue
                 # a valid usecase of this is to just edit metadata.
                 data = currentrev.data
             else:
-                data = b''
+                data = b""
 
         if isinstance(data, str):
             data = self.handle_variables(data, meta)
-            charset = meta['contenttype'].split('charset=')[1]
+            charset = meta["contenttype"].split("charset=")[1]
             data = data.encode(charset)
 
         if isinstance(data, bytes):
             data = BytesIO(data)
-        fqname, new_meta = storage_item.store_revision(meta, data,
-                                                       overwrite=overwrite,
-                                                       action=str(action),
-                                                       contenttype_current=contenttype_current,
-                                                       contenttype_guessed=contenttype_guessed,
-                                                       return_meta=True,
-                                                       return_rev=True,
-                                                       )
+        fqname, new_meta = storage_item.store_revision(
+            meta,
+            data,
+            overwrite=overwrite,
+            action=str(action),
+            contenttype_current=contenttype_current,
+            contenttype_guessed=contenttype_guessed,
+            return_meta=True,
+            return_rev=True,
+        )
         if currentrev is None:
             item_modified.send(app, fqname=fqname, action=action, new_data=data, new_meta=new_meta)
         else:
-            item_modified.send(app, fqname=fqname, action=action, new_data=data, new_meta=new_meta,
-                               data=currentrev.data, meta=currentrev.meta)
+            item_modified.send(
+                app,
+                fqname=fqname,
+                action=action,
+                new_data=data,
+                new_meta=new_meta,
+                data=currentrev.data,
+                meta=currentrev.meta,
+            )
         if currentrev is not None:
             close_file(currentrev.data)
         close_file(data)
@@ -1076,7 +1175,7 @@ def _save(self, meta, data=None, names=None, action=ACTION_SAVE, contenttype_gue
         return new_meta[REVID], new_meta[SIZE]
 
     def handle_variables(self, data, meta):
-        """ Expand @VARIABLE@ in data, where variable is SIG, DATE, etc
+        """Expand @VARIABLE@ in data, where variable is SIG, DATE, etc
 
         TODO: add a means for wiki admins and users to add custom variables.
 
@@ -1088,42 +1187,42 @@ def handle_variables(self, data, meta):
         logging.debug(f"handle_variable data: {data!r}")
         if self.contenttype not in CONTENTTYPE_VARIABLES:
             return data
-        if '@' not in data:
+        if "@" not in data:
             return data
-        if not request.path.startswith('/+modify'):
+        if not request.path.startswith("/+modify"):
             return data
-        if TEMPLATE in meta['tags']:
+        if TEMPLATE in meta["tags"]:
             return data
 
-        item_name = request.path.split('/', 2)[-1]
+        item_name = request.path.split("/", 2)[-1]
         signature = flaskg.user.name0 if flaskg.user.valid else request.remote_addr
 
         variables = {
-            'PAGE': item_name,
-            'ITEM': item_name,
-            'TIMESTAMP': strftime("%Y-%m-%d %H:%M:%S %Z"),
-            'TIME': f"<<DateTime({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
-            'DATE': f"<<Date({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
-            'ME': flaskg.user.name0,
-            'USERNAME': signature,
-            'USER': f"-- {signature}",
-            'SIG': f"-- {signature} <<DateTime({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
+            "PAGE": item_name,
+            "ITEM": item_name,
+            "TIMESTAMP": strftime("%Y-%m-%d %H:%M:%S %Z"),
+            "TIME": f"<<DateTime({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
+            "DATE": f"<<Date({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
+            "ME": flaskg.user.name0,
+            "USERNAME": signature,
+            "USER": f"-- {signature}",
+            "SIG": f"-- {signature} <<DateTime({strftime('%Y-%m-%dT%H:%M:%SZ')})>>",
         }
 
-        email = flaskg.user.profile._meta.get('email', None)
+        email = flaskg.user.profile._meta.get("email", None)
         if email:
             obfuscated_email_address = encodeSpamSafeEmail(email)
-            variables['MAILTO'] = f"<<MailTo({obfuscated_email_address})>>"
-            variables['EMAIL'] = f"<<MailTo({email})>>"
+            variables["MAILTO"] = f"<<MailTo({obfuscated_email_address})>>"
+            variables["EMAIL"] = f"<<MailTo({email})>>"
         else:
             # penalty for not being logged in is a mangled variable,
             # else next user to save item may accidentally reveal his email address
-            variables['MAILTO'] = "@ EMAIl@"
-            variables['EMAIL'] = "@ MAILTO@"
+            variables["MAILTO"] = "@ EMAIl@"
+            variables["EMAIL"] = "@ MAILTO@"
 
         for name in variables:
             try:
-                data = data.replace(f'@{name}@', variables[name])
+                data = data.replace(f"@{name}@", variables[name])
             except UnicodeError:
                 logging.warning(f"handle_variables: UnicodeError! name: {name!r} value: {variables[name]!r}")
         return data
@@ -1134,7 +1233,7 @@ def subitem_prefixes(self):
         Return the possible prefixes for subitems.
         """
         names = self.names
-        return [name + '/' if name else '' for name in names]
+        return [name + "/" if name else "" for name in names]
 
     @property
     def name_old_subitem_prefixes(self):
@@ -1142,7 +1241,7 @@ def name_old_subitem_prefixes(self):
         Return the possible prefixes for subitems using name_old value for deleted items.
         """
         names = self.meta[NAME_OLD]
-        return [name + '/' for name in names]
+        return [name + "/" for name in names]
 
     def get_prefix_match(self, name, prefixes):
         """
@@ -1190,7 +1289,7 @@ def make_flat_index(self, subitems, isglobalindex=False):
 
         :param isglobalindex: True if the query is for global indexes.
         """
-        prefixes = [''] if isglobalindex else self.subitem_prefixes
+        prefixes = [""] if isglobalindex else self.subitem_prefixes
         # IndexEntry instances of "file" subitems
         files = []
         # IndexEntry instances of "directory" subitems
@@ -1204,13 +1303,13 @@ def make_flat_index(self, subitems, isglobalindex=False):
                 prefix = self.get_prefix_match(fullname, prefixes)
                 if prefix is not None:
                     fullname_fqname = CompositeName(rev[NAMESPACE], NAME_EXACT, fullname)
-                    relname = fullname[len(prefix):]
-                    if '/' in relname:
+                    relname = fullname[len(prefix) :]
+                    if "/" in relname:
                         # Find the *direct* subitem that is the ancestor of current
                         # (indirect) subitem. e.g. suppose when the index root is
                         # 'foo', and current item (`rev`) is 'foo/bar/lorem/ipsum',
                         # 'foo/bar' will be found.
-                        direct_relname = relname.partition('/')[0]
+                        direct_relname = relname.partition("/")[0]
                         direct_relname_fqname = CompositeName(rev[NAMESPACE], NAME_EXACT, direct_relname)
                         if direct_relname_fqname not in added_dir_relnames:
                             added_dir_relnames.add(direct_relname_fqname)
@@ -1220,8 +1319,8 @@ def make_flat_index(self, subitems, isglobalindex=False):
                 mini_meta = {key: rev[key] for key in (CONTENTTYPE, ITEMTYPE, SIZE, MTIME, REV_NUMBER, NAMESPACE)}
                 if TAGS in rev and rev[TAGS]:
                     mini_meta[TAGS] = rev[TAGS]
-                mini_meta[USERID] = rev.get(USERID, '')
-                mini_meta[ADDRESS] = rev.get(ADDRESS, '') if app.cfg.show_hosts else ''
+                mini_meta[USERID] = rev.get(USERID, "")
+                mini_meta[ADDRESS] = rev.get(ADDRESS, "") if app.cfg.show_hosts else ""
                 files.append(IndexEntry(relname, fullname_fqname, mini_meta))
         files = sorted(files, key=lambda x: x[1])  # default namespace items are on top
         return dirs, files
@@ -1239,7 +1338,7 @@ def build_index_query(self, startswith=None, selected_groups=None, isglobalindex
         Output:
           Returns a whoosh.query.Prefix object for the input parameters
         """
-        prefix = '' if isglobalindex else self.subitem_prefixes[0]
+        prefix = "" if isglobalindex else self.subitem_prefixes[0]
         if startswith:
             query = Prefix(NAME_EXACT, prefix + startswith) | Prefix(NAME_EXACT, prefix + startswith.swapcase())
         else:
@@ -1276,7 +1375,7 @@ def get_index(self, startswith=None, selected_groups=None):
         query = Term(WIKINAME, app.cfg.interwikiname) & self.build_index_query(
             startswith, selected_groups, isglobalindex
         )
-        if not fqname.value.startswith(NAMESPACE_ALL + '/') and fqname.value != NAMESPACE_ALL:
+        if not fqname.value.startswith(NAMESPACE_ALL + "/") and fqname.value != NAMESPACE_ALL:
             query = Term(NAMESPACE, fqname.namespace) & query
         revs = flaskg.storage.search_meta(query, idx_name=LATEST_REVS, sortedby=NAME_EXACT, limit=None)
         return self.make_flat_index(revs, isglobalindex)
@@ -1286,11 +1385,13 @@ class Contentful(Item):
     """
     Base class for Item subclasses that have content.
     """
+
     @property
     def ModifyForm(self):
         class C(self._ModifyForm):
             content_form = self.content.ModifyForm
-        C.__name__ = 'ModifyForm'
+
+        C.__name__ = "ModifyForm"
         return C
 
 
@@ -1299,9 +1400,10 @@ class Default(Contentful):
     """
     A "conventional" wiki item.
     """
+
     itemtype = ITEMTYPE_DEFAULT
-    display_name = L_('Default')
-    description = L_('Wiki item')
+    display_name = L_("Default")
+    description = L_("Wiki item")
     order = -10
 
     def _do_modify_show_templates(self):
@@ -1309,21 +1411,29 @@ def _do_modify_show_templates(self):
         rev_ids = []
         item_templates = self.content.get_templates(self.contenttype)
         if not item_templates:
-            return redirect(url_for('frontend.modify_item', item_name=self.fqname, itemtype=self.itemtype,
-                                    contenttype=self.contenttype, template=''))
-        return render_template('modify_select_template.html',
-                               item=self,
-                               item_name=self.name,
-                               fqname=self.fqname,
-                               itemtype=self.itemtype,
-                               rev=self.rev,
-                               contenttype=self.contenttype,
-                               templates=item_templates,
-                               first_rev_id=rev_ids and rev_ids[0],
-                               last_rev_id=rev_ids and rev_ids[-1],
-                               meta_rendered='',
-                               data_rendered='',
-                               )
+            return redirect(
+                url_for(
+                    "frontend.modify_item",
+                    item_name=self.fqname,
+                    itemtype=self.itemtype,
+                    contenttype=self.contenttype,
+                    template="",
+                )
+            )
+        return render_template(
+            "modify_select_template.html",
+            item=self,
+            item_name=self.name,
+            fqname=self.fqname,
+            itemtype=self.itemtype,
+            rev=self.rev,
+            contenttype=self.contenttype,
+            templates=item_templates,
+            first_rev_id=rev_ids and rev_ids[0],
+            last_rev_id=rev_ids and rev_ids[-1],
+            meta_rendered="",
+            data_rendered="",
+        )
 
     def do_show(self, revid, item_is_deleted=False):
         """
@@ -1333,21 +1443,22 @@ def do_show(self, revid, item_is_deleted=False):
         rev_navigation_ids_dates = rev_navigation.prior_next_revs(revid, self.fqname)
         # create extra meta tags for use by web crawlers
         html_head_meta = {}
-        if 'tags' in self.meta and self.meta['tags']:
-            html_head_meta['keywords'] = ', '.join(self.meta['tags'])
-        if 'summary' in self.meta and self.meta['summary']:
-            html_head_meta['description'] = self.meta['summary']
-        return render_template('show.html',
-                               item=self,
-                               item_name=self.name,
-                               fqname=self.fqname,
-                               rev=self.rev,
-                               contenttype=self.contenttype,
-                               rev_navigation_ids_dates=rev_navigation_ids_dates,
-                               data_rendered=Markup(self.content._render_data()),
-                               html_head_meta=html_head_meta,
-                               item_is_deleted=item_is_deleted,
-                               )
+        if "tags" in self.meta and self.meta["tags"]:
+            html_head_meta["keywords"] = ", ".join(self.meta["tags"])
+        if "summary" in self.meta and self.meta["summary"]:
+            html_head_meta["description"] = self.meta["summary"]
+        return render_template(
+            "show.html",
+            item=self,
+            item_name=self.name,
+            fqname=self.fqname,
+            rev=self.rev,
+            contenttype=self.contenttype,
+            rev_navigation_ids_dates=rev_navigation_ids_dates,
+            data_rendered=Markup(self.content._render_data()),
+            html_head_meta=html_head_meta,
+            item_is_deleted=item_is_deleted,
+        )
 
     def doc_link(self, content_name, link_text):
         """
@@ -1357,8 +1468,13 @@ def doc_link(self, content_name, link_text):
         :param link_text: unchanged or replaced by alert message
         :return: path to help, link text
         """
-        query = And([Term(NAMESPACE, "help-" + flaskg.user.language), Term(NAME_EXACT, content_name),
-                     Term(WIKINAME, app.cfg.interwikiname)])
+        query = And(
+            [
+                Term(NAMESPACE, "help-" + flaskg.user.language),
+                Term(NAME_EXACT, content_name),
+                Term(WIKINAME, app.cfg.interwikiname),
+            ]
+        )
         results = list(flaskg.storage.search_meta(query, idx_name=LATEST_REVS, limit=None))
         if results:
             return "/help-" + flaskg.user.language + "/" + content_name, link_text
@@ -1371,11 +1487,11 @@ def meta_changed(self, meta):
         """
         if request.values.get(COMMENT):
             return True
-        if request.values.get('meta_form_acl') != meta.get('acl', 'None'):
+        if request.values.get("meta_form_acl") != meta.get("acl", "None"):
             return True
-        if request.values.get('meta_form_summary') != meta.get('summary', None):
+        if request.values.get("meta_form_summary") != meta.get("summary", None):
             return True
-        if meta[NAME][0].endswith('Group'):
+        if meta[NAME][0].endswith("Group"):
             try:
                 new = request.values.get(USERGROUP).splitlines()
             except KeyError:
@@ -1383,46 +1499,50 @@ def meta_changed(self, meta):
             old = meta.get(USERGROUP, None)
             if new != old:
                 return True
-        if meta[NAME][0].endswith('Dict'):
+        if meta[NAME][0].endswith("Dict"):
             new = request.values.get(WIKIDICT)
             new = str_to_dict(new)
             old = meta.get(WIKIDICT, None)
             if new != old:
                 return True
-        new_tags = request.values.get('meta_form_tags').replace(" ", "").split(',')
+        new_tags = request.values.get("meta_form_tags").replace(" ", "").split(",")
         if new_tags == [""]:
             new_tags = []
-        if new_tags != meta.get('tags', None):
+        if new_tags != meta.get("tags", None):
             return True
         return False
 
     def do_modify(self):
         if isinstance(self.content, NonExistentContent) and not flaskg.user.may.create(self.name):
-            abort(403, description=' '
-                  + _('You do not have permission to create the item named "{name}".').format(name=self.name))
+            abort(
+                403,
+                description=" "
+                + _('You do not have permission to create the item named "{name}".').format(name=self.name),
+            )
 
         method = request.method
-        if method in ['GET', 'HEAD']:
+        if method in ["GET", "HEAD"]:
             if isinstance(self.content, NonExistentContent):
                 start, end, matches = find_matches(self.fqname)
                 similar_names = sorted(matches.keys())
-                return render_template('modify_select_contenttype.html',
-                                       fqname=self.fqname,
-                                       item_name=self.name,
-                                       itemtype=self.itemtype,
-                                       group_names=content_registry.group_names,
-                                       groups=content_registry.groups,
-                                       similar_names=similar_names,
-                                       )
+                return render_template(
+                    "modify_select_contenttype.html",
+                    fqname=self.fqname,
+                    item_name=self.name,
+                    itemtype=self.itemtype,
+                    group_names=content_registry.group_names,
+                    groups=content_registry.groups,
+                    similar_names=similar_names,
+                )
 
         item = self
         flaskg.edit_utils = edit_utils = Edit_Utils(self)
 
         # these will be updated if user has clicked Preview
-        preview_diffs = ''
-        preview_rendered = ''
+        preview_diffs = ""
+        preview_rendered = ""
 
-        if request.values.get('cancel'):
+        if request.values.get("cancel"):
             edit_utils.delete_draft()
             if app.cfg.edit_locking_policy == LOCK:
                 edit_utils.unlock_item(cancel=True)
@@ -1437,7 +1557,7 @@ def do_modify(self):
                 # edit locking policy is True and someone else has file locked
                 edit_utils.cursor_close()
                 return redirect(url_for_item(self.name))
-        elif method in ['GET', 'HEAD']:
+        elif method in ["GET", "HEAD"]:
             # if there is not a draft row, create one to aid in conflict detection
             edit_utils.put_draft(None, overwrite=False)
 
@@ -1451,14 +1571,14 @@ def do_modify(self):
                 item = Item.create(template_name)
                 form = self.ModifyForm.from_item(item)
                 # replace template name with new item name and remove TEMPLATE tag
-                form['meta_form']['name'] = self.names[0]
-                form['meta_form']['tags'].remove(TEMPLATE)
+                form["meta_form"]["name"] = self.names[0]
+                form["meta_form"]["tags"].remove(TEMPLATE)
             else:
                 form = self.ModifyForm.from_item(item)
         else:
             form = self.ModifyForm.from_item(item)
 
-        if method == 'POST':
+        if method == "POST":
             # XXX workaround for *Draw items
             if isinstance(self.content, Draw):
                 try:
@@ -1475,12 +1595,12 @@ def do_modify(self):
             form = self.ModifyForm.from_request(request)
             meta, data, contenttype_guessed, comment = form._dump(self)
             if contenttype_guessed:
-                m = re.search('charset=(.+?)($|;)', contenttype_guessed)
+                m = re.search("charset=(.+?)($|;)", contenttype_guessed)
                 if m:
                     data = str(data, m.group(1))
             state = dict(fqname=self.fqname, itemid=meta.get(ITEMID), meta=meta)
             if form.validate(state):
-                if request.values.get('preview'):
+                if request.values.get("preview"):
                     # user has clicked Preview button, create diff and rendered item
                     edit_utils.put_draft(data)
                     old_item = Item.create(self.fqname.fullname, rev_id=CURRENT, contenttype=self.contenttype)
@@ -1490,23 +1610,23 @@ def do_modify(self):
                         preview_diffs = [(d[0], Markup(d[1]), d[2], Markup(d[3])) for d in html_diff(old_text, data)]
                         preview_rendered = item.content._render_data(preview=data)
                     else:  # TODO: make preview button inactive for empty items, see #1539
-                        flash(_("No preview available for empty items."), 'error')
+                        flash(_("No preview available for empty items."), "error")
                     close_file(old_item.rev.data)
                 else:
                     # user clicked OK/Save button, check for conflicts,
-                    if 'charset' in self.contenttype:
+                    if "charset" in self.contenttype:
                         draft, draft_data = edit_utils.get_draft()
                         if draft:
                             # will always be a draft for normal users,
                             # but bot (as in load testing) may post without prior get
                             u_name, i_id, i_name, rev_number, save_time, rev_id = draft
-                            if not rev_id == 'new-item':
+                            if not rev_id == "new-item":
                                 original_item = Item.create(self.name, rev_id=rev_id, contenttype=self.contenttype)
-                                charset = original_item.contenttype.split('charset=')[1]
+                                charset = original_item.contenttype.split("charset=")[1]
                                 original_text = original_item.rev.data.read().decode(charset)
                                 close_file(original_item.rev.data)
                             else:
-                                original_text = ''
+                                original_text = ""
                             if original_text == data and not self.meta_changed(item.meta):
                                 flash(_("Nothing changed, nothing saved."), "info")
                                 edit_utils.delete_draft()
@@ -1515,20 +1635,22 @@ def do_modify(self):
                                 edit_utils.cursor_close()
                                 return redirect(url_for_item(**self.fqname.split))
 
-                            if rev_number < self.meta.get('rev_number', 0):
+                            if rev_number < self.meta.get("rev_number", 0):
                                 # we have conflict - someone else has saved item, create and save 3-way diff,
                                 # give user error message to fix it
                                 saved_item = Item.create(self.name, rev_id=CURRENT, contenttype=self.contenttype)
-                                charset = saved_item.contenttype.split('charset=')[1]
+                                charset = saved_item.contenttype.split("charset=")[1]
                                 saved_text = saved_item.content.data.decode(charset)
                                 data3 = diff3.text_merge(original_text, saved_text, data)
                                 data = data3
-                                comment = _("CONFLICT ") + comment or ''
-                                flash(_("An edit conflict has occurred, edit this item again to resolve conflicts."),
-                                      "error")
+                                comment = _("CONFLICT ") + comment or ""
+                                flash(
+                                    _("An edit conflict has occurred, edit this item again to resolve conflicts."),
+                                    "error",
+                                )
 
                     # save the new revision, unlock, delete draft
-                    contenttype_qs = request.values.get('contenttype')
+                    contenttype_qs = request.values.get("contenttype")
                     try:
                         self.modify(meta, data, comment, contenttype_guessed, **{CONTENTTYPE: contenttype_qs})
                     except AccessDenied:
@@ -1556,7 +1678,7 @@ def do_modify(self):
             edit_rows = str(flaskg.user.profile._defaults[EDIT_ROWS])
         close_file(self.rev.data)
         draft_data = None
-        if not request.values.get('preview'):
+        if not request.values.get("preview"):
             # request is +Modify GET, check for abandoned draft
             draft, draft_data = edit_utils.get_draft()
             if draft:
@@ -1567,13 +1689,21 @@ def do_modify(self):
                     # that  must be merged manually
                     interval, number = show_time.duration(time() - save_time)
                     if self.rev.meta.get(REV_NUMBER, 0) == rev_number:
-                        flash(L_("You may recover your draft saved {number} {interval} "
-                                 "ago by clicking the 'Load Draft' button."
-                                 ).format(number=number, interval=interval, ), 'info')
+                        flash(
+                            L_(
+                                "You may recover your draft saved {number} {interval} "
+                                "ago by clicking the 'Load Draft' button."
+                            ).format(number=number, interval=interval),
+                            "info",
+                        )
                     else:
-                        flash(L_("Your draft saved {number} {interval} ago is outdated, click 'Cancel' to discard "
-                                 "or 'Load Draft', then 'Save' to merge conflicting updates."
-                                 ).format(number=number, interval=interval, ), 'error')
+                        flash(
+                            L_(
+                                "Your draft saved {number} {interval} ago is outdated, click 'Cancel' to discard "
+                                "or 'Load Draft', then 'Save' to merge conflicting updates."
+                            ).format(number=number, interval=interval),
+                            "error",
+                        )
 
         if app.cfg.edit_locking_policy == LOCK:
             # we pass lock_duration so javascript can show alert before timer expires
@@ -1582,26 +1712,27 @@ def do_modify(self):
             lock_duration = None
         edit_utils.cursor_close()
         # enable sidebar themes to show OK, Preview, Cancel buttons that do not scroll off display
-        is_modify_text = True if 'text' in self.contenttype else False
+        is_modify_text = True if "text" in self.contenttype else False
         # if request is +modify GET we show modify form, else if POST Preview
         # we show modify form + diff + rendered item
-        return render_template('modify.html',
-                               fqname=self.fqname,
-                               item_name=self.name,
-                               item=self,
-                               rows_meta=str(ROWS_META),
-                               cols=str(COLS),
-                               form=form,
-                               search_form=None,
-                               help=help,
-                               preview_diffs=preview_diffs,
-                               preview_rendered=preview_rendered,
-                               edit_rows=edit_rows,
-                               is_modify_text=is_modify_text,
-                               draft_data=draft_data,
-                               lock_duration=lock_duration,
-                               tuple=tuple,
-                               )
+        return render_template(
+            "modify.html",
+            fqname=self.fqname,
+            item_name=self.name,
+            item=self,
+            rows_meta=str(ROWS_META),
+            cols=str(COLS),
+            form=form,
+            search_form=None,
+            help=help,
+            preview_diffs=preview_diffs,
+            preview_rendered=preview_rendered,
+            edit_rows=edit_rows,
+            is_modify_text=is_modify_text,
+            draft_data=draft_data,
+            lock_duration=lock_duration,
+            tuple=tuple,
+        )
 
 
 @register
@@ -1610,9 +1741,10 @@ class Userprofile(Item):
     Currently userprofile is implemented as a contenttype. This is a stub of an
     itemtype implementation of userprofile.
     """
+
     itemtype = ITEMTYPE_USERPROFILE
-    display_name = L_('User profile')
-    description = L_('User profile item (not implemented yet!)')
+    display_name = L_("User profile")
+    description = L_("User profile item (not implemented yet!)")
 
 
 @register
@@ -1621,6 +1753,7 @@ class NonExistent(Item):
     A dummy Item for nonexistent items (when modifying, a nonexistent item with
     undetermined itemtype)
     """
+
     itemtype = ITEMTYPE_NONEXISTENT
     shown = False
 
@@ -1632,10 +1765,7 @@ def do_show(self, revid, **kwargs):
         if flaskg.user.may.create(self.name):
             content = self._select_itemtype()
         else:
-            content = render_template('show_nonexistent.html',
-                                      item_name=self.name,
-                                      fqname=self.fqname,
-                                      )
+            content = render_template("show_nonexistent.html", item_name=self.name, fqname=self.fqname)
         return Response(content, 404)
 
     def do_modify(self):
@@ -1667,11 +1797,8 @@ def _select_itemtype(self):
         except MissingParentError as e:
             flash(str(e), "error")
             form = CreateItemForm().from_defaults()
-            form['target'] = self.fqname.fullname
-            return render_template('create_new_item.html',
-                                   fqname=self.fqname,
-                                   form=form,
-                                   )
+            form["target"] = self.fqname.fullname
+            return render_template("create_new_item.html", fqname=self.fqname, form=form)
 
         # verify name meets standards
         try:
@@ -1679,44 +1806,43 @@ def _select_itemtype(self):
         except NameNotValidError:
             # a flash message has already been created
             form = CreateItemForm().from_defaults()
-            form['target'] = self.fqname.fullname
-            return render_template('create_new_item.html',
-                                   fqname=self.fqname,
-                                   form=form,
-                                   )
+            form["target"] = self.fqname.fullname
+            return render_template("create_new_item.html", fqname=self.fqname, form=form)
 
         start, end, matches = find_matches(self.fqname)
         similar_names = sorted(matches.keys())
-        return render_template('modify_select_contenttype.html',
-                               fqname=self.fqname,
-                               item_name=self.name,
-                               itemtype='default',  # create a normal wiki item
-                               group_names=content_registry.group_names,
-                               groups=content_registry.groups,
-                               similar_names=similar_names,
-                               )
+        return render_template(
+            "modify_select_contenttype.html",
+            fqname=self.fqname,
+            item_name=self.name,
+            itemtype="default",  # create a normal wiki item
+            group_names=content_registry.group_names,
+            groups=content_registry.groups,
+            similar_names=similar_names,
+        )
 
         # dead code, see above
-        return render_template('modify_select_itemtype.html',
-                               item=self,
-                               item_name=self.name,
-                               fqname=self.fqname,
-                               itemtypes=item_registry.shown_entries,
-                               )
-
-    def rename(self, name, comment=''):
+        return render_template(
+            "modify_select_itemtype.html",
+            item=self,
+            item_name=self.name,
+            fqname=self.fqname,
+            itemtypes=item_registry.shown_entries,
+        )
+
+    def rename(self, name, comment=""):
         # pointless for non-existing items
         pass
 
-    def delete(self, comment=''):
+    def delete(self, comment=""):
         # pointless for non-existing items
         pass
 
-    def revert(self, comment=''):
+    def revert(self, comment=""):
         # pointless for non-existing items
         pass
 
-    def destroy(self, comment='', destroy_item=False):
+    def destroy(self, comment="", destroy_item=False):
         # pointless for non-existing items
         pass
 
diff --git a/src/moin/items/_tests/test_Blog.py b/src/moin/items/_tests/test_Blog.py
index d720cfec9..0b8a1304a 100644
--- a/src/moin/items/_tests/test_Blog.py
+++ b/src/moin/items/_tests/test_Blog.py
@@ -28,7 +28,7 @@ def set_self_app(self, app):
 
     def _test_view(self, item_name, req_args={}, data_tokens=[], exclude_data_tokens=[], regex=None):
         with self.app.test_client() as c:
-            rv = c.get(url_for('frontend.show_item', item_name=item_name, **req_args))
+            rv = c.get(url_for("frontend.show_item", item_name=item_name, **req_args))
             rv_data = rv.data.decode()
             for data in data_tokens:
                 assert data in rv_data
@@ -41,15 +41,17 @@ def _test_view(self, item_name, req_args={}, data_tokens=[], exclude_data_tokens
 class TestBlog(TestView):
     NO_ENTRIES_MSG = "There are no entries"
 
-    name = 'NewBlogItem'
-    contenttype = 'text/x.moin.wiki;charset=utf-8'
+    name = "NewBlogItem"
+    contenttype = "text/x.moin.wiki;charset=utf-8"
     data = "This is the header item of this blog"
     meta = {CONTENTTYPE: contenttype, ITEMTYPE: ITEMTYPE_BLOG}
-    comment = 'saved it'
-    entries = [{'name': name + '/NewBlogEntryItem1', 'data': "First blog entry"},
-               {'name': name + '/NewBlogEntryItem2', 'data': "Second blog entry"},
-               {'name': name + '/NewBlogEntryItem3', 'data': "Third blog entry"},
-               {'name': name + '/NewBlogEntryItem4', 'data': "Fourth blog entry"}, ]
+    comment = "saved it"
+    entries = [
+        {"name": name + "/NewBlogEntryItem1", "data": "First blog entry"},
+        {"name": name + "/NewBlogEntryItem2", "data": "Second blog entry"},
+        {"name": name + "/NewBlogEntryItem3", "data": "Third blog entry"},
+        {"name": name + "/NewBlogEntryItem4", "data": "Fourth blog entry"},
+    ]
     entry_meta = {CONTENTTYPE: contenttype, ITEMTYPE: ITEMTYPE_BLOG_ENTRY}
 
     def _publish_entry(self, entry, ptime, acl=None):
@@ -57,7 +59,7 @@ def _publish_entry(self, entry, ptime, acl=None):
         meta[PTIME] = ptime
         if acl is not None:
             meta[ACL] = acl
-        update_item(entry['name'], meta, entry['data'])
+        update_item(entry["name"], meta, entry["data"])
 
     def test_create(self):
         item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
@@ -72,7 +74,7 @@ def test_do_show_empty(self):
         item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
         item._save(self.meta, self.data, comment=self.comment)
         # empty blog page without any entries
-        data_tokens = [self.data, self.NO_ENTRIES_MSG, ]
+        data_tokens = [self.data, self.NO_ENTRIES_MSG]
         self._test_view(self.name, data_tokens=data_tokens)
 
     def test_do_show_entries(self):
@@ -80,12 +82,12 @@ def test_do_show_entries(self):
         item._save(self.meta, self.data, comment=self.comment)
         # store entries without PTIME
         for entry in self.entries:
-            item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
-            item._save(self.entry_meta, entry['data'], comment=self.comment)
+            item = Item.create(entry["name"], itemtype=ITEMTYPE_BLOG_ENTRY)
+            item._save(self.entry_meta, entry["data"], comment=self.comment)
         # the blog is not empty
-        exclude_data_tokens = [self.NO_ENTRIES_MSG, ]
+        exclude_data_tokens = [self.NO_ENTRIES_MSG]
         # all stored blog entries are listed on the blog index page
-        data_tokens = [self.data, ] + [entry['data'] for entry in self.entries]
+        data_tokens = [self.data] + [entry["data"] for entry in self.entries]
         self._test_view(self.name, data_tokens=data_tokens, exclude_data_tokens=exclude_data_tokens)
 
     def test_do_show_sorted_entries(self):
@@ -93,8 +95,8 @@ def test_do_show_sorted_entries(self):
         item._save(self.meta, self.data, comment=self.comment)
         # store entries
         for entry in self.entries:
-            item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
-            item._save(self.entry_meta, entry['data'], comment=self.comment)
+            item = Item.create(entry["name"], itemtype=ITEMTYPE_BLOG_ENTRY)
+            item._save(self.entry_meta, entry["data"], comment=self.comment)
         # Add PTIME to some of the entries, ptime value is a UNIX timestamp. If PTIME
         # is not defined, we use MTIME as publication time (which is usually in the past).
         self._publish_entry(self.entries[0], ptime=2000)
@@ -102,15 +104,17 @@ def test_do_show_sorted_entries(self):
         time_in_future = utctimestamp(datetime(2029, 1, 1))
         self._publish_entry(self.entries[2], ptime=time_in_future)
         # the blog is not empty
-        exclude_data_tokens = [self.NO_ENTRIES_MSG, ]
+        exclude_data_tokens = [self.NO_ENTRIES_MSG]
         # blog entries are listed in reverse order relative to their PTIME/MTIMEs,
         # entries published in the future are also listed here
-        ordered_data = [self.data,
-                        self.entries[2]['data'],
-                        self.entries[3]['data'],
-                        self.entries[0]['data'],
-                        self.entries[1]['data'], ]
-        regex = re.compile(r'{}.*{}.*{}.*{}.*{}'.format(*ordered_data), re.DOTALL)
+        ordered_data = [
+            self.data,
+            self.entries[2]["data"],
+            self.entries[3]["data"],
+            self.entries[0]["data"],
+            self.entries[1]["data"],
+        ]
+        regex = re.compile(r"{}.*{}.*{}.*{}.*{}".format(*ordered_data), re.DOTALL)
         self._test_view(self.name, exclude_data_tokens=exclude_data_tokens, regex=regex)
 
     def test_filter_by_tag(self):
@@ -118,33 +122,36 @@ def test_filter_by_tag(self):
         item._save(self.meta, self.data, comment=self.comment)
         # publish some entries with tags
         entries_meta = [
-            {PTIME: 1000, TAGS: ['foo', 'bar', 'moin']},
-            {PTIME: 3000, TAGS: ['foo', 'bar', 'baz']},
-            {PTIME: 2000, TAGS: ['baz', 'moin']},
+            {PTIME: 1000, TAGS: ["foo", "bar", "moin"]},
+            {PTIME: 3000, TAGS: ["foo", "bar", "baz"]},
+            {PTIME: 2000, TAGS: ["baz", "moin"]},
         ]
         for entry, entry_meta in zip(self.entries, entries_meta):
             entry_meta.update(self.entry_meta)
-            item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
-            item._save(entry_meta, entry['data'], comment=self.comment)
+            item = Item.create(entry["name"], itemtype=ITEMTYPE_BLOG_ENTRY)
+            item._save(entry_meta, entry["data"], comment=self.comment)
         # filter by non-existent tag 'non-existent'
-        data_tokens = [self.data, self.NO_ENTRIES_MSG, ]
-        exclude_data_tokens = [self.entries[0]['data'], self.entries[1]['data'], self.entries[2]['data'], ]
-        self._test_view(self.name, req_args={'tag': 'non-existent'}, data_tokens=data_tokens, exclude_data_tokens=exclude_data_tokens)
+        data_tokens = [self.data, self.NO_ENTRIES_MSG]
+        exclude_data_tokens = [self.entries[0]["data"], self.entries[1]["data"], self.entries[2]["data"]]
+        self._test_view(
+            self.name,
+            req_args={"tag": "non-existent"},
+            data_tokens=data_tokens,
+            exclude_data_tokens=exclude_data_tokens,
+        )
         # filter by tag 'moin'
-        exclude_data_tokens = [self.NO_ENTRIES_MSG, self.entries[1]['data'], ]
-        ordered_data = [self.data,
-                        self.entries[2]['data'],
-                        self.entries[0]['data'], ]
-        regex = re.compile(r'{}.*{}.*{}'.format(*ordered_data), re.DOTALL)
-        self._test_view(self.name, req_args={'tag': 'moin'}, exclude_data_tokens=exclude_data_tokens, regex=regex)
+        exclude_data_tokens = [self.NO_ENTRIES_MSG, self.entries[1]["data"]]
+        ordered_data = [self.data, self.entries[2]["data"], self.entries[0]["data"]]
+        regex = re.compile(r"{}.*{}.*{}".format(*ordered_data), re.DOTALL)
+        self._test_view(self.name, req_args={"tag": "moin"}, exclude_data_tokens=exclude_data_tokens, regex=regex)
 
     def test_filter_by_acls(self):
         item = Item.create(self.name, itemtype=ITEMTYPE_BLOG)
         item._save(self.meta, self.data, comment=self.comment)
         # store some unpublished entries
         for entry in self.entries:
-            item = Item.create(entry['name'], itemtype=ITEMTYPE_BLOG_ENTRY)
-            item._save(self.entry_meta, entry['data'], comment=self.comment)
+            item = Item.create(entry["name"], itemtype=ITEMTYPE_BLOG_ENTRY)
+            item._save(self.entry_meta, entry["data"], comment=self.comment)
         # publish the first three entries with specific ACLs
         # we are an "anonymous" user
         self._publish_entry(self.entries[0], ptime=1000, acl="%s:read" % ANON)
@@ -152,21 +159,19 @@ def test_filter_by_acls(self):
         # specify no rights on the 3rd entry
         self._publish_entry(self.entries[2], ptime=2000, acl="%s:" % ANON)
         # the blog is not empty and the 3rd entry is not displayed
-        exclude_data_tokens = [self.NO_ENTRIES_MSG, self.entries[2]['data'], ]
-        ordered_data = [self.data,
-                        self.entries[1]['data'],
-                        self.entries[0]['data'], ]
-        regex = re.compile(r'{}.*{}.*{}'.format(*ordered_data), re.DOTALL)
+        exclude_data_tokens = [self.NO_ENTRIES_MSG, self.entries[2]["data"]]
+        ordered_data = [self.data, self.entries[1]["data"], self.entries[0]["data"]]
+        regex = re.compile(r"{}.*{}.*{}".format(*ordered_data), re.DOTALL)
         self._test_view(self.name, exclude_data_tokens=exclude_data_tokens, regex=regex)
 
 
 class TestBlogEntry(TestView):
-    blog_name = 'NewBlogItem'
-    contenttype = 'text/x.moin.wiki;charset=utf-8'
+    blog_name = "NewBlogItem"
+    contenttype = "text/x.moin.wiki;charset=utf-8"
     blog_data = "This is the header item of this blog"
     blog_meta = {CONTENTTYPE: contenttype, ITEMTYPE: ITEMTYPE_BLOG}
-    comment = 'saved it'
-    entry_name = blog_name + '/NewBlogEntryItem'
+    comment = "saved it"
+    entry_name = blog_name + "/NewBlogEntryItem"
     entry_data = "Blog entry data"
     entry_meta = {CONTENTTYPE: contenttype, ITEMTYPE: ITEMTYPE_BLOG_ENTRY}
 
@@ -191,5 +196,5 @@ def test_do_show(self):
         item = Item.create(self.entry_name, itemtype=ITEMTYPE_BLOG_ENTRY)
         item._save(self.entry_meta, self.entry_data, comment=self.comment)
 
-        data_tokens = [self.blog_data, self.entry_data, ]
+        data_tokens = [self.blog_data, self.entry_data]
         self._test_view(self.entry_name, data_tokens=data_tokens)
diff --git a/src/moin/items/_tests/test_Content.py b/src/moin/items/_tests/test_Content.py
index 8e5a3e6c6..6eb30e9ba 100644
--- a/src/moin/items/_tests/test_Content.py
+++ b/src/moin/items/_tests/test_Content.py
@@ -24,37 +24,37 @@
 
 
 class TestContent:
-    """ Test for arbitrary content """
+    """Test for arbitrary content"""
 
     def testClassFinder(self):
         for contenttype, ExpectedClass in [
-                ('application/x-foobar', Binary),
-                ('text/plain', Text),
-                ('text/plain;charset=utf-8', Text),
-                ('image/tiff', Image),
-                ('image/png', TransformableBitmapImage),
+            ("application/x-foobar", Binary),
+            ("text/plain", Text),
+            ("text/plain;charset=utf-8", Text),
+            ("image/tiff", Image),
+            ("image/png", TransformableBitmapImage),
         ]:
             content = Content.create(contenttype)
             assert isinstance(content, ExpectedClass)
 
     def test_get_templates(self):
-        item_name1 = 'Template_Item1'
+        item_name1 = "Template_Item1"
         item1 = Item.create(item_name1)
-        contenttype1 = 'text/plain;charset=utf-8'
+        contenttype1 = "text/plain;charset=utf-8"
         meta = {CONTENTTYPE: contenttype1, TAGS: [TEMPLATE]}
         item1._save(meta)
         item1 = Item.create(item_name1)
 
-        item_name2 = 'Template_Item2'
+        item_name2 = "Template_Item2"
         item2 = Item.create(item_name2)
-        contenttype1 = 'text/plain;charset=utf-8'
+        contenttype1 = "text/plain;charset=utf-8"
         meta = {CONTENTTYPE: contenttype1, TAGS: [TEMPLATE]}
         item2._save(meta)
         item2 = Item.create(item_name2)
 
-        item_name3 = 'Template_Item3'
+        item_name3 = "Template_Item3"
         item3 = Item.create(item_name3)
-        contenttype2 = 'image/png'
+        contenttype2 = "image/png"
         meta = {CONTENTTYPE: contenttype2, TAGS: [TEMPLATE]}
         item3._save(meta)
         item3 = Item.create(item_name3)
@@ -75,102 +75,106 @@ def testCreateContainerRevision(self):
         """
         creates a container and tests the content saved to the container
         """
-        item_name = 'ContainerItem1'
-        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/x-tar')
-        filecontent = b'abcdefghij'
+        item_name = "ContainerItem1"
+        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype="application/x-tar")
+        filecontent = b"abcdefghij"
         content_length = len(filecontent)
-        members = {'example1.txt', 'example2.txt'}
-        item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
-        item.content.put_member('example2.txt', filecontent, content_length, expected_members=members)
+        members = {"example1.txt", "example2.txt"}
+        item.content.put_member("example1.txt", filecontent, content_length, expected_members=members)
+        item.content.put_member("example2.txt", filecontent, content_length, expected_members=members)
 
-        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/x-tar')
+        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype="application/x-tar")
         tf_names = set(item.content.list_members())
         assert tf_names == members
-        assert item.content.get_member('example1.txt').read() == filecontent
+        assert item.content.get_member("example1.txt").read() == filecontent
 
     def testRevisionUpdate(self):
         """
         creates two revisions of a container item
         """
-        item_name = 'ContainerItem2'
-        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/x-tar')
-        filecontent = b'abcdefghij'
+        item_name = "ContainerItem2"
+        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype="application/x-tar")
+        filecontent = b"abcdefghij"
         content_length = len(filecontent)
-        members = {'example1.txt'}
-        item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
-        filecontent = b'AAAABBBB'
+        members = {"example1.txt"}
+        item.content.put_member("example1.txt", filecontent, content_length, expected_members=members)
+        filecontent = b"AAAABBBB"
         content_length = len(filecontent)
-        item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
+        item.content.put_member("example1.txt", filecontent, content_length, expected_members=members)
 
-        item = Item.create(item_name, contenttype='application/x-tar')
-        assert item.content.get_member('example1.txt').read() == filecontent
+        item = Item.create(item_name, contenttype="application/x-tar")
+        assert item.content.get_member("example1.txt").read() == filecontent
 
 
 class TestZipMixin:
-    """ Test for zip-like items """
+    """Test for zip-like items"""
 
     def test_put_member(self):
-        item_name = 'Zip_file'
-        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype='application/zip')
-        filecontent = 'test_contents'
+        item_name = "Zip_file"
+        item = Item.create(item_name, itemtype=ITEMTYPE_DEFAULT, contenttype="application/zip")
+        filecontent = "test_contents"
         content_length = len(filecontent)
-        members = {'example1.txt', 'example2.txt'}
+        members = {"example1.txt", "example2.txt"}
         with pytest.raises(NotImplementedError):
-            item.content.put_member('example1.txt', filecontent, content_length, expected_members=members)
+            item.content.put_member("example1.txt", filecontent, content_length, expected_members=members)
 
 
 class TestTransformableBitmapImage:
 
     def test__transform(self):
-        item_name = 'image_Item'
+        item_name = "image_Item"
         item = Item.create(item_name)
-        contenttype = 'image/jpeg'
+        contenttype = "image/jpeg"
         meta = {CONTENTTYPE: contenttype}
         item._save(meta)
         item = Item.create(item_name)
         try:
             from PIL import Image as PILImage  # noqa
+
             with pytest.raises(ValueError):
-                result = TransformableBitmapImage._transform(item.content, 'text/plain')
+                result = TransformableBitmapImage._transform(item.content, "text/plain")
         except ImportError:
             result = TransformableBitmapImage._transform(item.content, contenttype)
-            assert result == ('image/jpeg', b'')
+            assert result == ("image/jpeg", b"")
 
     def test__render_data_diff(self):
-        item_name = 'image_Item'
+        item_name = "image_Item"
         item = Item.create(item_name)
-        contenttype = 'image/jpeg'
+        contenttype = "image/jpeg"
         meta = {CONTENTTYPE: contenttype}
         item._save(meta)
         item1 = Item.create(item_name)
         try:
             from PIL import Image as PILImage  # noqa
+
             result = Markup(TransformableBitmapImage._render_data_diff(item1.content, item.rev, item1.rev))
             # On Werkzeug 0.8.2+, urls with '+' are automatically encoded to '%2B'
             # The assert statement works with both older and newer versions of Werkzeug
             # Probably not an intentional change on the werkzeug side, see issue:
             # https://github.com/mitsuhiko/werkzeug/issues/146
-            assert (str(result).startswith('<img src="/+diffraw/image_Item?rev') or
-                    str(result).startswith('<img src="/%2Bdiffraw/image_Item?rev'))
+            assert str(result).startswith('<img src="/+diffraw/image_Item?rev') or str(result).startswith(
+                '<img src="/%2Bdiffraw/image_Item?rev'
+            )
         except ImportError:
             # no PIL
             pass
 
     def test__render_data_diff_text(self):
-        item_name = 'image_Item'
+        item_name = "image_Item"
         item = Item.create(item_name)
-        contenttype = 'image/jpeg'
+        contenttype = "image/jpeg"
         meta = {CONTENTTYPE: contenttype}
         item._save(meta)
         item1 = Item.create(item_name)
-        data = b'test_data'
-        comment = 'next revision'
+        data = b"test_data"
+        comment = "next revision"
         item1._save(meta, data, comment=comment)
         item2 = Item.create(item_name)
         try:
             from PIL import Image as PILImage  # noqa
+
             result = TransformableBitmapImage._render_data_diff_text(item1.content, item1.rev, item2.rev)
-            expected = 'The items have different data.'
+            expected = "The items have different data."
             assert result == expected
         except ImportError:
             pass
@@ -179,97 +183,102 @@ def test__render_data_diff_text(self):
 class TestText:
 
     def test_data_conversion(self):
-        item_name = 'Text_Item'
-        item = Item.create(item_name, ITEMTYPE_DEFAULT, 'text/plain;charset=utf-8')
-        test_text = 'This \n is \n a \n Test'
+        item_name = "Text_Item"
+        item = Item.create(item_name, ITEMTYPE_DEFAULT, "text/plain;charset=utf-8")
+        test_text = "This \n is \n a \n Test"
         # test for data_internal_to_form
         result = Text.data_internal_to_form(item.content, test_text)
-        expected = 'This \r\n is \r\n a \r\n Test'
+        expected = "This \r\n is \r\n a \r\n Test"
         assert result == expected
         # test for data_form_to_internal
-        test_form = 'This \r\n is \r\n a \r\n Test'
+        test_form = "This \r\n is \r\n a \r\n Test"
         result = Text.data_form_to_internal(item.content, test_form)
         expected = test_text
         assert result == expected
         # test for data_internal_to_storage
         result = Text.data_internal_to_storage(item.content, test_text)
-        expected = b'This \r\n is \r\n a \r\n Test'
+        expected = b"This \r\n is \r\n a \r\n Test"
         assert result == expected
         # test for data_storage_to_internal
-        data_storage = b'This \r\n is \r\n a \r\n Test'
+        data_storage = b"This \r\n is \r\n a \r\n Test"
         result = Text.data_storage_to_internal(item.content, data_storage)
         expected = test_text
         assert result == expected
 
     def test__render_data_diff(self):
-        item_name = 'Html_Item'
+        item_name = "Html_Item"
         fqname = split_fqname(item_name)
-        empty_html = '<span></span>'
-        html = '<span>\ud55c</span>'
-        meta = {CONTENTTYPE: 'text/html;charset=utf-8'}
+        empty_html = "<span></span>"
+        html = "<span>\ud55c</span>"
+        meta = {CONTENTTYPE: "text/html;charset=utf-8"}
         item = Item.create(item_name)
         item._save(meta, empty_html)
         item = Item.create(item_name)
         # Unicode test, html escaping
         rev1 = update_item(item_name, meta, html)
-        rev2 = update_item(item_name, {}, '     ')
+        rev2 = update_item(item_name, {}, "     ")
         result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
         assert escape(html) in result
         # Unicode test, whitespace
-        rev1 = update_item(item_name, {}, '\n\n')
-        rev2 = update_item(item_name, {}, '\n     \n')
+        rev1 = update_item(item_name, {}, "\n\n")
+        rev2 = update_item(item_name, {}, "\n     \n")
         result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
-        assert '<span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>' in result
+        assert "<span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>" in result
         # If fairly similar diffs are correctly spanned or not, also check indent
-        rev1 = update_item(item_name, {}, 'One Two Three Four\nSix\n\ud55c')
-        rev2 = update_item(item_name, {}, 'Two Three Seven Four\nSix\n\ud55c')
+        rev1 = update_item(item_name, {}, "One Two Three Four\nSix\n\ud55c")
+        rev2 = update_item(item_name, {}, "Two Three Seven Four\nSix\n\ud55c")
         result = Text._render_data_diff(item.content, rev1, rev2, fqname=fqname)
-        assert '<span>One </span>Two Three Four' in result
-        assert 'Two Three <span>Seven </span>Four' in result
+        assert "<span>One </span>Two Three Four" in result
+        assert "Two Three <span>Seven </span>Four" in result
         # Check for diff_html.diff return types
-        assert reduce(lambda x, y: x and y, [isinstance(i[1], str) and isinstance(i[3], str) for i in diff_html.diff('One Two Three Four\nSix\n', 'Two Three Seven Four\nSix Seven\n')], True)
+        assert reduce(
+            lambda x, y: x and y,
+            [
+                isinstance(i[1], str) and isinstance(i[3], str)
+                for i in diff_html.diff("One Two Three Four\nSix\n", "Two Three Seven Four\nSix Seven\n")
+            ],
+            True,
+        )
 
     def test__render_data_diff_text(self):
-        item_name = 'Text_Item'
+        item_name = "Text_Item"
         item = Item.create(item_name)
-        contenttype = 'text/plain;charset=utf-8'
+        contenttype = "text/plain;charset=utf-8"
         meta = {CONTENTTYPE: contenttype}
         data1 = b"old_data"
         item._save(meta, data1)
         item1 = Item.create(item_name)
-        data2 = b'new_data'
-        comment = 'next revision'
+        data2 = b"new_data"
+        comment = "next revision"
         item1._save(meta, data2, comment=comment)
         item2 = Item.create(item_name)
         result = Text._render_data_diff_text(item1.content, item1.rev, item2.rev)
-        expected = '- old_data\n+ new_data'
+        expected = "- old_data\n+ new_data"
         assert result == expected
-        assert item2.content.data == b''
+        assert item2.content.data == b""
 
     def test__render_data_highlight(self):
-        item_name = 'Text_Item'
+        item_name = "Text_Item"
         item = Item.create(item_name)
-        contenttype = 'text/plain;charset=utf-8'
+        contenttype = "text/plain;charset=utf-8"
         meta = {CONTENTTYPE: contenttype}
         item._save(meta)
         item1 = Item.create(item_name)
-        data = 'test_data\nnext line'
-        comment = 'next revision'
+        data = "test_data\nnext line"
+        comment = "next revision"
         item1._save(meta, data, comment=comment)
         item2 = Item.create(item_name)
         result = Text._render_data_highlight(item2.content)
         assert '<pre class="highlight">test_data\n' in result
-        assert item2.content.data == b''
+        assert item2.content.data == b""
 
     def test__get_data_diff_text(self):
-        item_name = 'Text_Item'
+        item_name = "Text_Item"
         item = Item.create(item_name)
-        contenttypes = dict(texttypes=['text/plain;charset=utf-8',
-                                       'text/x-markdown;charset=utf-8', ],
-                            othertypes=['image/png', 'audio/wave',
-                                        'video/ogg',
-                                        'application/x-svgdraw',
-                                        'application/octet-stream', ])
+        contenttypes = dict(
+            texttypes=["text/plain;charset=utf-8", "text/x-markdown;charset=utf-8"],
+            othertypes=["image/png", "audio/wave", "video/ogg", "application/x-svgdraw", "application/octet-stream"],
+        )
         for key in contenttypes:
             for contenttype in contenttypes[key]:
                 meta = {CONTENTTYPE: contenttype}
@@ -278,22 +287,22 @@ def test__get_data_diff_text(self):
                 oldfile = BytesIO(b"x")
                 newfile = BytesIO(b"xx")
                 difflines = item_.content._get_data_diff_text(oldfile, newfile)
-                if key == 'texttypes':
-                    assert difflines == ['- x', '+ xx']
+                if key == "texttypes":
+                    assert difflines == ["- x", "+ xx"]
                 else:
                     assert difflines == []
 
     def test__get_data_diff_html(self):
         item_name = "Test_Item"
         item = Item.create(item_name)
-        contenttype = 'text/plain;charset=utf-8'
+        contenttype = "text/plain;charset=utf-8"
         meta = {CONTENTTYPE: contenttype}
         item._save(meta)
         item_ = Item.create(item_name)
         oldfile = BytesIO(b"")
         newfile = BytesIO(b"x")
         difflines = item_.content._get_data_diff_html(oldfile, newfile)
-        assert difflines == [(1, Markup(''), 1, Markup('<span>x</span>'))]
+        assert difflines == [(1, Markup(""), 1, Markup("<span>x</span>"))]
 
 
-coverage_modules = ['moin.items.content']
+coverage_modules = ["moin.items.content"]
diff --git a/src/moin/items/_tests/test_Item.py b/src/moin/items/_tests/test_Item.py
index 1a19f7b8f..bdcaa5000 100644
--- a/src/moin/items/_tests/test_Item.py
+++ b/src/moin/items/_tests/test_Item.py
@@ -11,9 +11,23 @@
 from moin._tests import become_trusted, update_item
 from moin.items import Item, NonExistent, IndexEntry, MixedIndexEntry
 from moin.utils.interwiki import CompositeName
-from moin.constants.keys import (ITEMTYPE, CONTENTTYPE, NAME, NAME_OLD, COMMENT,
-                                 ADDRESS, TRASH, ITEMID, NAME_EXACT, SIZE, MTIME,
-                                 REV_NUMBER, NAMESPACE, ACTION, ACTION_REVERT)
+from moin.constants.keys import (
+    ITEMTYPE,
+    CONTENTTYPE,
+    NAME,
+    NAME_OLD,
+    COMMENT,
+    ADDRESS,
+    TRASH,
+    ITEMID,
+    NAME_EXACT,
+    SIZE,
+    MTIME,
+    REV_NUMBER,
+    NAMESPACE,
+    ACTION,
+    ACTION_REVERT,
+)
 from moin.constants.namespaces import NAMESPACE_DEFAULT
 from moin.constants.contenttypes import CONTENTTYPE_NONEXISTENT
 from moin.constants.itemtypes import ITEMTYPE_NONEXISTENT
@@ -24,8 +38,10 @@ def build_dirs_index(basename, relnames):
     Build a list of IndexEntry by hand, useful as a test helper for index testing.
     Dirs are files with subitems and have meta == {}.
     """
-    return [(IndexEntry(relname, CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, '/'.join((basename, relname))), {}))
-            for relname in relnames]
+    return [
+        (IndexEntry(relname, CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, "/".join((basename, relname))), {}))
+        for relname in relnames
+    ]
 
 
 def build_index(basename, relnames):
@@ -33,10 +49,26 @@ def build_index(basename, relnames):
     Build a list of IndexEntry by hand, useful as a test helper for index testing.
     Files have no subitems, meta content is reduced to required keys.
     """
-    files = [(IndexEntry(relname, CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, '/'.join((basename, relname))), Item.create('/'.join((basename, relname))).meta))
-             for relname in relnames]
-    return [(IndexEntry(f.relname, f.fullname, {key: f.meta[key] for key in (CONTENTTYPE, ITEMTYPE, SIZE, MTIME, REV_NUMBER, NAMESPACE, ADDRESS)}))
-            for f in files]
+    files = [
+        (
+            IndexEntry(
+                relname,
+                CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, "/".join((basename, relname))),
+                Item.create("/".join((basename, relname))).meta,
+            )
+        )
+        for relname in relnames
+    ]
+    return [
+        (
+            IndexEntry(
+                f.relname,
+                f.fullname,
+                {key: f.meta[key] for key in (CONTENTTYPE, ITEMTYPE, SIZE, MTIME, REV_NUMBER, NAMESPACE, ADDRESS)},
+            )
+        )
+        for f in files
+    ]
 
 
 def build_mixed_index(basename, spec):
@@ -47,10 +79,28 @@ def build_mixed_index(basename, spec):
 
     :spec is a list of (relname, hassubitem) tuples.
     """
-    files = [(MixedIndexEntry(relname, CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, '/'.join((basename, relname))), Item.create('/'.join((basename, relname))).meta, hassubitem))
-             for relname, hassubitem in spec]
-    return [(MixedIndexEntry(f.relname, f.fullname, {} if f.hassubitems else {key: f.meta[key] for key in (CONTENTTYPE, ITEMTYPE)}, f.hassubitems))
-            for f in files]
+    files = [
+        (
+            MixedIndexEntry(
+                relname,
+                CompositeName(NAMESPACE_DEFAULT, NAME_EXACT, "/".join((basename, relname))),
+                Item.create("/".join((basename, relname))).meta,
+                hassubitem,
+            )
+        )
+        for relname, hassubitem in spec
+    ]
+    return [
+        (
+            MixedIndexEntry(
+                f.relname,
+                f.fullname,
+                {} if f.hassubitems else {key: f.meta[key] for key in (CONTENTTYPE, ITEMTYPE)},
+                f.hassubitems,
+            )
+        )
+        for f in files
+    ]
 
 
 def fix_meta(files, builds):
@@ -62,13 +112,13 @@ def fix_meta(files, builds):
     fix_builds = []
     for idx in range(len(files)):
         fix_file = files[idx]
-        fix_file.meta.pop('mtime', None)
-        fix_file.meta.pop('userid', None)
+        fix_file.meta.pop("mtime", None)
+        fix_file.meta.pop("userid", None)
         fix_files.append(fix_file)
     for idx in range(len(builds)):
         fix_build = builds[idx]
-        fix_build.meta.pop('mtime', None)
-        fix_build.meta.pop('userid', None)
+        fix_build.meta.pop("mtime", None)
+        fix_build.meta.pop("userid", None)
         fix_builds.append(fix_build)
     return fix_files, fix_builds
 
@@ -76,23 +126,23 @@ def fix_meta(files, builds):
 class TestItem:
 
     def testNonExistent(self):
-        item = Item.create('DoesNotExist')
+        item = Item.create("DoesNotExist")
         assert isinstance(item, NonExistent)
         meta, data = item.meta, item.content.data
         assert meta == {
             ITEMTYPE: ITEMTYPE_NONEXISTENT,
             CONTENTTYPE: CONTENTTYPE_NONEXISTENT,
-            NAME: ['DoesNotExist'],
-            NAMESPACE: '',
+            NAME: ["DoesNotExist"],
+            NAMESPACE: "",
         }
-        assert data == ''
+        assert data == ""
 
     def testCRUD(self):
-        name = 'NewItem'
-        contenttype = 'text/plain;charset=utf-8'
-        data = b'foobar'
-        meta = {'foo': 'bar', CONTENTTYPE: contenttype}
-        comment = 'saved it'
+        name = "NewItem"
+        contenttype = "text/plain;charset=utf-8"
+        data = b"foobar"
+        meta = {"foo": "bar", CONTENTTYPE: contenttype}
+        comment = "saved it"
         become_trusted()
         item = Item.create(name)
         # save rev 0
@@ -105,7 +155,7 @@ def testCRUD(self):
         assert saved_data == data
 
         data *= 10000
-        comment += ' again'
+        comment += " again"
         # save rev 1
         item._save(meta, data, comment=comment)
         # check save result
@@ -115,8 +165,8 @@ def testCRUD(self):
         assert saved_meta[COMMENT] == comment
         assert saved_data == data
 
-        data = ''
-        comment = 'saved empty data'
+        data = ""
+        comment = "saved empty data"
         # save rev 2 (auto delete)
         item._save(meta, data, comment=comment)
         # check save result
@@ -124,239 +174,233 @@ def testCRUD(self):
         saved_meta, saved_data = dict(item.meta), item.content.data
         assert saved_meta[CONTENTTYPE] == contenttype
         assert saved_meta[COMMENT] == comment
-        assert saved_data == b''
+        assert saved_data == b""
 
     def testIndex(self):
         # create a toplevel and some sub-items
-        basename = 'Foo'
-        for name in ['', '/ab', '/cd/ef', '/gh', '/ij', '/ij/kl', ]:
+        basename = "Foo"
+        for name in ["", "/ab", "/cd/ef", "/gh", "/ij", "/ij/kl"]:
             item = Item.create(basename + name)
-            item._save({CONTENTTYPE: 'text/plain;charset=utf-8', ITEMTYPE: 'default'}, "foo")
-        item = Item.create(basename + '/mn')
-        item._save({CONTENTTYPE: 'image/jpeg', ITEMTYPE: 'default'}, b"JPG")
+            item._save({CONTENTTYPE: "text/plain;charset=utf-8", ITEMTYPE: "default"}, "foo")
+        item = Item.create(basename + "/mn")
+        item._save({CONTENTTYPE: "image/jpeg", ITEMTYPE: "default"}, b"JPG")
 
         baseitem = Item.create(basename)
 
         # test Item.make_flat_index
         # TODO: test Item.get_subitem_revs
         dirs, files = baseitem.get_index()
-        assert dirs == build_dirs_index(basename, ['cd', 'ij'])
+        assert dirs == build_dirs_index(basename, ["cd", "ij"])
 
         # after +index converted to table output it shows subitems
-        builds = build_index(basename, ['ab', 'cd/ef', 'gh', 'ij', 'ij/kl', 'mn'])
+        builds = build_index(basename, ["ab", "cd/ef", "gh", "ij", "ij/kl", "mn"])
         # fix potential problem of datetime and userid being different
         fix_files, fix_builds = fix_meta(files, builds)
         assert fix_files == fix_builds
 
         # check filtered index when startswith param is passed
-        dirs, files = baseitem.get_index(startswith='a')
+        dirs, files = baseitem.get_index(startswith="a")
         assert dirs == []
-        builds = build_index(basename, ['ab'])
+        builds = build_index(basename, ["ab"])
         fix_files, fix_builds = fix_meta(files, builds)
         assert fix_files == fix_builds
 
         # check filtered index when contenttype_groups is passed
         ctgroups = ["Other Text Items"]
         dirs, files = baseitem.get_index(selected_groups=ctgroups)
-        assert dirs == build_dirs_index(basename, ['cd', 'ij'])
+        assert dirs == build_dirs_index(basename, ["cd", "ij"])
         # mn missing from results because it is image/jpeg, cd was never created
-        builds = build_index(basename, ['ab', 'cd/ef', 'gh', 'ij', 'ij/kl'])
+        builds = build_index(basename, ["ab", "cd/ef", "gh", "ij", "ij/kl"])
         fix_files, fix_builds = fix_meta(files, builds)
         assert fix_files == fix_builds
 
     def test_meta_filter(self):
-        name = 'Test_item'
-        contenttype = 'text/plain;charset=utf-8'
-        meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: ['test_name'], ADDRESS: '1.2.3.4'}
+        name = "Test_item"
+        contenttype = "text/plain;charset=utf-8"
+        meta = {"test_key": "test_val", CONTENTTYPE: contenttype, NAME: ["test_name"], ADDRESS: "1.2.3.4"}
         item = Item.create(name)
         result = Item.meta_filter(item, meta)
         # keys like NAME, ITEMID, REVID, DATAID are filtered
-        expected = {'test_key': 'test_val', CONTENTTYPE: contenttype}
+        expected = {"test_key": "test_val", CONTENTTYPE: contenttype}
         assert result == expected
 
     def test_meta_dict_to_text(self):
-        name = 'Test_item'
-        contenttype = 'text/plain;charset=utf-8'
-        meta = {'test_key': 'test_val', CONTENTTYPE: contenttype, NAME: ['test_name']}
+        name = "Test_item"
+        contenttype = "text/plain;charset=utf-8"
+        meta = {"test_key": "test_val", CONTENTTYPE: contenttype, NAME: ["test_name"]}
         item = Item.create(name)
         result = Item.meta_dict_to_text(item, meta)
         expected = '{\n  "contenttype": "text/plain;charset=utf-8",\n  "test_key": "test_val"\n}'
         assert result == expected
 
     def test_meta_text_to_dict(self):
-        name = 'Test_item'
-        contenttype = 'text/plain;charset=utf-8'
-        text = '{\n  "contenttype": "text/plain;charset=utf-8", \n  "test_key": "test_val", \n "name": ["test_name"] \n}'
+        name = "Test_item"
+        contenttype = "text/plain;charset=utf-8"
+        text = (
+            '{\n  "contenttype": "text/plain;charset=utf-8", \n  "test_key": "test_val", \n "name": ["test_name"] \n}'
+        )
         item = Item.create(name)
         result = Item.meta_text_to_dict(item, text)
-        expected = {'test_key': 'test_val', CONTENTTYPE: contenttype}
+        expected = {"test_key": "test_val", CONTENTTYPE: contenttype}
         assert result == expected
 
     def test_item_can_have_several_names(self):
         content = b"This is page content"
 
-        update_item('Page',
-                    {NAME: ['Page',
-                            'Another name',
-                            ],
-                     CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, content)
+        update_item("Page", {NAME: ["Page", "Another name"], CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, content)
 
-        item1 = Item.create('Page')
-        assert item1.name == 'Page'
-        assert item1.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
+        item1 = Item.create("Page")
+        assert item1.name == "Page"
+        assert item1.meta[CONTENTTYPE] == "text/x.moin.wiki;charset=utf-8"
         assert item1.content.data == content
 
-        item2 = Item.create('Another name')
-        assert item2.name == 'Another name'
-        assert item2.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
+        item2 = Item.create("Another name")
+        assert item2.name == "Another name"
+        assert item2.meta[CONTENTTYPE] == "text/x.moin.wiki;charset=utf-8"
         assert item2.content.data == content
         assert item1.rev.revid == item2.rev.revid
 
     def test_rename(self):
-        name = 'Test_Item'
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
-        meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
-        comment = 'saved it'
+        name = "Test_Item"
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
+        meta = {"test_key": "test_value", CONTENTTYPE: contenttype}
+        comment = "saved it"
         item = Item.create(name)
         item._save(meta, data, comment=comment)
         # item and its contents before renaming
         item = Item.create(name)
-        assert item.name == 'Test_Item'
-        assert item.meta[COMMENT] == 'saved it'
-        new_name = 'Test_new_Item'
-        item.rename(new_name, comment='renamed')
+        assert item.name == "Test_Item"
+        assert item.meta[COMMENT] == "saved it"
+        new_name = "Test_new_Item"
+        item.rename(new_name, comment="renamed")
         # item at original name and its contents after renaming
         item = Item.create(name)
-        assert item.name == 'Test_Item'
+        assert item.name == "Test_Item"
         # this should be a fresh, new item, NOT the stuff we renamed:
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
         # item at new name and its contents after renaming
         item = Item.create(new_name)
-        assert item.name == 'Test_new_Item'
-        assert item.meta[NAME_OLD] == ['Test_Item']
-        assert item.meta[COMMENT] == 'renamed'
-        assert item.content.data == b'test_data'
+        assert item.name == "Test_new_Item"
+        assert item.meta[NAME_OLD] == ["Test_Item"]
+        assert item.meta[COMMENT] == "renamed"
+        assert item.content.data == b"test_data"
 
     def test_rename_works_with_multiple_names(self):
         content = "This is page content"
-        meta = {NAME: ['First', 'Second', 'Third', ], CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}
-        update_item('Page', meta, content)
-
-        item = Item.create('Second')
-        item.rename(['New name', 'First', 'Third'], comment='renamed')
-
-        item1 = Item.create('First')
-        assert item1.name == 'First'
-        assert 'First' in item1.meta[NAME]
-        assert 'Third' in item1.meta[NAME]
-        assert 'New name' in item1.meta[NAME]
-        assert item1.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
+        meta = {NAME: ["First", "Second", "Third"], CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}
+        update_item("Page", meta, content)
+
+        item = Item.create("Second")
+        item.rename(["New name", "First", "Third"], comment="renamed")
+
+        item1 = Item.create("First")
+        assert item1.name == "First"
+        assert "First" in item1.meta[NAME]
+        assert "Third" in item1.meta[NAME]
+        assert "New name" in item1.meta[NAME]
+        assert item1.meta[CONTENTTYPE] == "text/x.moin.wiki;charset=utf-8"
         assert item1.content.data == content.encode()
 
-        item2 = Item.create('New name')
-        assert item2.name == 'New name'
-        assert 'First' in item2.meta[NAME]
-        assert 'Third' in item2.meta[NAME]
-        assert 'New name' in item2.meta[NAME]
-        assert item2.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
+        item2 = Item.create("New name")
+        assert item2.name == "New name"
+        assert "First" in item2.meta[NAME]
+        assert "Third" in item2.meta[NAME]
+        assert "New name" in item2.meta[NAME]
+        assert item2.meta[CONTENTTYPE] == "text/x.moin.wiki;charset=utf-8"
         assert item2.content.data == content.encode()
 
-        item3 = Item.create('Third')
-        assert item3.name == 'Third'
-        assert 'First' in item3.meta[NAME]
-        assert 'Third' in item3.meta[NAME]
-        assert 'New name' in item3.meta[NAME]
-        assert item3.meta[CONTENTTYPE] == 'text/x.moin.wiki;charset=utf-8'
+        item3 = Item.create("Third")
+        assert item3.name == "Third"
+        assert "First" in item3.meta[NAME]
+        assert "Third" in item3.meta[NAME]
+        assert "New name" in item3.meta[NAME]
+        assert item3.meta[CONTENTTYPE] == "text/x.moin.wiki;charset=utf-8"
         assert item3.content.data == content.encode()
 
         assert item1.rev.revid == item2.rev.revid == item3.rev.revid
 
-        item4 = Item.create('Second')
+        item4 = Item.create("Second")
         assert item4.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
     def test_rename_recursion(self):
-        update_item('Page', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Page 1')
-        update_item('Page/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'this is child')
-        update_item('Page/Child/Another', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'another child')
+        update_item("Page", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Page 1")
+        update_item("Page/Child", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "this is child")
+        update_item("Page/Child/Another", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "another child")
 
-        item = Item.create('Page')
-        item.rename('Renamed_Page', comment='renamed')
+        item = Item.create("Page")
+        item.rename("Renamed_Page", comment="renamed")
 
         # items at original name and its contents after renaming
-        item = Item.create('Page')
-        assert item.name == 'Page'
+        item = Item.create("Page")
+        assert item.name == "Page"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
-        item = Item.create('Page/Child')
-        assert item.name == 'Page/Child'
+        item = Item.create("Page/Child")
+        assert item.name == "Page/Child"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
-        item = Item.create('Page/Child/Another')
-        assert item.name == 'Page/Child/Another'
+        item = Item.create("Page/Child/Another")
+        assert item.name == "Page/Child/Another"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
         # item at new name and its contents after renaming
-        item = Item.create('Renamed_Page')
-        assert item.name == 'Renamed_Page'
-        assert item.meta[NAME_OLD] == ['Page']
-        assert item.meta[COMMENT] == 'renamed'
-        assert item.content.data == b'Page 1'
-
-        item = Item.create('Renamed_Page/Child')
-        assert item.name == 'Renamed_Page/Child'
-        assert item.meta[NAME_OLD] == ['Page/Child']
-        assert item.meta[COMMENT] == 'renamed'
-        assert item.content.data == b'this is child'
-
-        item = Item.create('Renamed_Page/Child/Another')
-        assert item.name == 'Renamed_Page/Child/Another'
-        assert item.meta[NAME_OLD] == ['Page/Child/Another']
-        assert item.meta[COMMENT] == 'renamed'
-        assert item.content.data == b'another child'
+        item = Item.create("Renamed_Page")
+        assert item.name == "Renamed_Page"
+        assert item.meta[NAME_OLD] == ["Page"]
+        assert item.meta[COMMENT] == "renamed"
+        assert item.content.data == b"Page 1"
+
+        item = Item.create("Renamed_Page/Child")
+        assert item.name == "Renamed_Page/Child"
+        assert item.meta[NAME_OLD] == ["Page/Child"]
+        assert item.meta[COMMENT] == "renamed"
+        assert item.content.data == b"this is child"
+
+        item = Item.create("Renamed_Page/Child/Another")
+        assert item.name == "Renamed_Page/Child/Another"
+        assert item.meta[NAME_OLD] == ["Page/Child/Another"]
+        assert item.meta[COMMENT] == "renamed"
+        assert item.content.data == b"another child"
 
     def test_rename_recursion_with_multiple_names_and_children(self):
-        update_item('Foo', {
-            CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8',
-            NAME: ['Other', 'Page', 'Foo'],
-        }, 'Parent')
-        update_item('Page/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Page')
-        update_item('Other/Child2', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Other')
-        update_item('Another', {
-            CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8',
-            NAME: ['Another', 'Page/Second'],
-        }, 'Both')
-        update_item('Page/Second/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Second')
-        update_item('Another/Child', {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8'}, 'Child of Another')
-
-        item = Item.create('Page')
-
-        item.rename(['Renamed', 'Other'], comment='renamed')
-
-        assert Item.create('Page/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
-        assert Item.create('Renamed/Child').content.data == b'Child of Page'
-        assert Item.create('Page/Second').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
-        assert Item.create('Renamed/Second').content.data == b'Both'
-        assert Item.create('Another').content.data == b'Both'
-        assert Item.create('Page/Second/Child').meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
-        assert Item.create('Renamed/Second/Child').content.data == b'Child of Second'
-        assert Item.create('Other/Child2').content.data == b'Child of Other'
-        assert Item.create('Another/Child').content.data == b'Child of Another'
+        update_item("Foo", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8", NAME: ["Other", "Page", "Foo"]}, "Parent")
+        update_item("Page/Child", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Child of Page")
+        update_item("Other/Child2", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Child of Other")
+        update_item(
+            "Another", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8", NAME: ["Another", "Page/Second"]}, "Both"
+        )
+        update_item("Page/Second/Child", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Child of Second")
+        update_item("Another/Child", {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8"}, "Child of Another")
+
+        item = Item.create("Page")
+
+        item.rename(["Renamed", "Other"], comment="renamed")
+
+        assert Item.create("Page/Child").meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
+        assert Item.create("Renamed/Child").content.data == b"Child of Page"
+        assert Item.create("Page/Second").meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
+        assert Item.create("Renamed/Second").content.data == b"Both"
+        assert Item.create("Another").content.data == b"Both"
+        assert Item.create("Page/Second/Child").meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
+        assert Item.create("Renamed/Second/Child").content.data == b"Child of Second"
+        assert Item.create("Other/Child2").content.data == b"Child of Other"
+        assert Item.create("Another/Child").content.data == b"Child of Another"
 
     def test_delete(self):
-        name = 'Test_Item2'
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
-        meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
-        comment = 'saved it'
+        name = "Test_Item2"
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
+        meta = {"test_key": "test_value", CONTENTTYPE: contenttype}
+        comment = "saved it"
         item = Item.create(name)
         item._save(meta, data, comment=comment)
         # item and its contents before deleting
         item = Item.create(name)
-        assert item.name == 'Test_Item2'
-        assert item.meta[COMMENT] == 'saved it'
-        item.delete('deleted')
+        assert item.name == "Test_Item2"
+        assert item.meta[COMMENT] == "saved it"
+        item.delete("deleted")
         # item and its contents after deletion
         item = Item.create(name)
-        assert item.name == 'Test_Item2'
+        assert item.name == "Test_Item2"
         # this should be a fresh, new item, NOT the stuff we deleted:
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
@@ -364,110 +408,106 @@ def test_delete_multi_name_multi_subs(self):
         """
         Parent name is [aaa,bbbb,ccccc], subs are aaa/aaa, bbbb/bbbb. Deleting ccccc deletes all.
         """
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
-        meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
-        comment = 'saved it'
-        item = Item.create('aaa')
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
+        meta = {"test_key": "test_value", CONTENTTYPE: contenttype}
+        comment = "saved it"
+        item = Item.create("aaa")
         item._save(meta, data, comment=comment)
 
         # rename
-        item = Item.create('aaa')
-        item.rename(['aaa', 'bbbb', 'ccccc'], comment='renamed')
+        item = Item.create("aaa")
+        item.rename(["aaa", "bbbb", "ccccc"], comment="renamed")
 
         # create subs aaa/aaa and bbbb/bbbb
-        asub = Item.create('aaa/aaa')
-        asub._save(meta, data, comment='aaa/aaa created')
-        bsub = Item.create('bbbb/bbbb')
-        bsub._save(meta, data, comment='bbbb/bbbb created')
+        asub = Item.create("aaa/aaa")
+        asub._save(meta, data, comment="aaa/aaa created")
+        bsub = Item.create("bbbb/bbbb")
+        bsub._save(meta, data, comment="bbbb/bbbb created")
 
         # item and its contents before deleting
-        item = Item.create('ccccc')
-        assert item.name == 'ccccc'
-        assert item.meta[COMMENT] == 'renamed'
-        item.delete('deleted ccccc')
+        item = Item.create("ccccc")
+        assert item.name == "ccccc"
+        assert item.meta[COMMENT] == "renamed"
+        item.delete("deleted ccccc")
 
         # all three alias names and both subitems are deleted
-        item = Item.create('aaa')
-        assert item.name == 'aaa'
+        item = Item.create("aaa")
+        assert item.name == "aaa"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
-        item = Item.create('bbbb')
-        assert item.name == 'bbbb'
+        item = Item.create("bbbb")
+        assert item.name == "bbbb"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
-        item = Item.create('ccccc')
-        assert item.name == 'ccccc'
+        item = Item.create("ccccc")
+        assert item.name == "ccccc"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
-        item = Item.create('aaa/aaa')
-        assert item.name == 'aaa/aaa'
+        item = Item.create("aaa/aaa")
+        assert item.name == "aaa/aaa"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
-        item = Item.create('bbbb/bbbb')
-        assert item.name == 'bbbb/bbbb'
+        item = Item.create("bbbb/bbbb")
+        assert item.name == "bbbb/bbbb"
         assert item.meta[CONTENTTYPE] == CONTENTTYPE_NONEXISTENT
 
     def test_revert(self):
-        name = 'Test_Item'
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
-        meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
-        comment = 'saved it'
+        name = "Test_Item"
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
+        meta = {"test_key": "test_value", CONTENTTYPE: contenttype}
+        comment = "saved it"
         item = Item.create(name)
         item._save(meta, data, comment=comment)
         item = Item.create(name)
-        item.revert('revert')
+        item.revert("revert")
         item = Item.create(name)
         assert item.meta[ACTION] == ACTION_REVERT
 
     def test_modify(self):
-        name = 'Test_Item'
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
-        meta = {'test_key': 'test_value', CONTENTTYPE: contenttype}
-        comment = 'saved it'
+        name = "Test_Item"
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
+        meta = {"test_key": "test_value", CONTENTTYPE: contenttype}
+        comment = "saved it"
         item = Item.create(name)
         item._save(meta, data, comment=comment)
         item = Item.create(name)
-        assert item.name == 'Test_Item'
-        assert item.meta['test_key'] == 'test_value'
+        assert item.name == "Test_Item"
+        assert item.meta["test_key"] == "test_value"
         # modify
-        another_data = 'another_test_data'
-        another_meta = {'another_test_key': 'another_test_value', CONTENTTYPE: contenttype, }
+        another_data = "another_test_data"
+        another_meta = {"another_test_key": "another_test_value", CONTENTTYPE: contenttype}
         item.modify(another_meta, another_data)
         item = Item.create(name)
-        assert item.name == 'Test_Item'
+        assert item.name == "Test_Item"
         with pytest.raises(KeyError):
-            item.meta['test_key']
-        assert item.meta['another_test_key'] == another_meta['another_test_key']
+            item.meta["test_key"]
+        assert item.meta["another_test_key"] == another_meta["another_test_key"]
         assert item.content.data == another_data.encode()
         # add/update meta
-        another_meta = {
-            'test_key': 'test_value',
-            'another_test_key': 'another_test_value',
-            CONTENTTYPE: contenttype,
-        }
+        another_meta = {"test_key": "test_value", "another_test_key": "another_test_value", CONTENTTYPE: contenttype}
         item.modify(another_meta, another_data)
         item = Item.create(name)
         update_meta = {
-            'another_test_key': 'updated_test_value',
-            'new_test_key': 'new_test_value',
-            'none_test_key': None,
+            "another_test_key": "updated_test_value",
+            "new_test_key": "new_test_value",
+            "none_test_key": None,
             CONTENTTYPE: contenttype,
         }
         item.modify(another_meta, another_data, **update_meta)
         item = Item.create(name)
-        assert item.name == 'Test_Item'
-        assert item.meta['test_key'] == another_meta['test_key']
-        assert item.meta['another_test_key'] == update_meta['another_test_key']
-        assert item.meta['new_test_key'] == update_meta['new_test_key']
-        assert 'none_test_key' not in item.meta
+        assert item.name == "Test_Item"
+        assert item.meta["test_key"] == another_meta["test_key"]
+        assert item.meta["another_test_key"] == update_meta["another_test_key"]
+        assert item.meta["new_test_key"] == update_meta["new_test_key"]
+        assert "none_test_key" not in item.meta
 
     def test_trash(self):
-        name = 'trash_item_test'
-        contenttype = 'text/plain;charset=utf-8'
-        data = 'test_data'
+        name = "trash_item_test"
+        contenttype = "text/plain;charset=utf-8"
+        data = "test_data"
         meta = {CONTENTTYPE: contenttype}
         item = Item.create(name)
         # save rev 0
@@ -479,22 +519,22 @@ def test_trash(self):
         meta[NAME] = []
         # save new rev with no names.
         item._save(meta, data, delete=True)
-        new_name = '@itemid/' + item.meta[ITEMID]
+        new_name = "@itemid/" + item.meta[ITEMID]
         item = Item.create(new_name)
         assert item.meta[TRASH]
 
-        new_meta = {NAME: ['foobar', 'buz'], CONTENTTYPE: contenttype}
+        new_meta = {NAME: ["foobar", "buz"], CONTENTTYPE: contenttype}
         item._save(new_meta, data)
-        item = Item.create('foobar')
+        item = Item.create("foobar")
 
-        item.delete('Deleting foobar.')
-        item = Item.create('buz')
+        item.delete("Deleting foobar.")
+        item = Item.create("buz")
         assert not item.meta.get(TRASH)
 
         # Also delete the only name left.
-        item.delete('Moving item to trash.')
+        item.delete("Moving item to trash.")
         item = Item.create(new_name)
         assert item.meta[TRASH]
 
 
-coverage_modules = ['moin.items']
+coverage_modules = ["moin.items"]
diff --git a/src/moin/items/blog.py b/src/moin/items/blog.py
index 5b46f6025..500c478cb 100644
--- a/src/moin/items/blog.py
+++ b/src/moin/items/blog.py
@@ -24,31 +24,33 @@
 from moin.utils.interwiki import split_fqname
 
 
-ITEMTYPE_BLOG = 'blog'
-ITEMTYPE_BLOG_ENTRY = 'blogentry'
+ITEMTYPE_BLOG = "blog"
+ITEMTYPE_BLOG_ENTRY = "blogentry"
 
 
 class BlogMetaForm(BaseMetaForm):
-    supertags = (Tags.using(label=L_('Supertags (Categories)'))
-                 .with_properties(placeholder=L_("Ordered comma separated list of tags")))
+    supertags = Tags.using(label=L_("Supertags (Categories)")).with_properties(
+        placeholder=L_("Ordered comma separated list of tags")
+    )
 
 
 class BlogEntryMetaForm(BaseMetaForm):
-    summary = (Text.using(label=L_("Title (required)", optional=False))
-               .with_properties(placeholder=L_("One-line title of the blog entry")))
-    ptime = DateTime.using(label=L_('Publication time (UTC)'), optional=True)
+    summary = Text.using(label=L_("Title (required)", optional=False)).with_properties(
+        placeholder=L_("One-line title of the blog entry")
+    )
+    ptime = DateTime.using(label=L_("Publication time (UTC)"), optional=True)
 
 
 @register
 class Blog(Default):
     itemtype = ITEMTYPE_BLOG
-    display_name = L_('Blog')
-    description = L_('Blog item')
+    display_name = L_("Blog")
+    description = L_("Blog item")
     order = 0
 
     class _ModifyForm(Default._ModifyForm):
         meta_form = BlogMetaForm
-        meta_template = 'blog/modify_main_meta.html'
+        meta_template = "blog/modify_main_meta.html"
 
     def do_show(self, revid, **kwargs):
         """
@@ -58,14 +60,15 @@ def do_show(self, revid, **kwargs):
         of those entries that contain the tag value in their lists of tags.
         """
         # for now it is just one tag=value, later it could be tag=value1&tag=value2&...
-        tag = request.values.get('tag')
-        prefix = self.name + '/'
-        terms = [Term(WIKINAME, app.cfg.interwikiname),
-                 # Only blog entry itemtypes
-                 Term(ITEMTYPE, ITEMTYPE_BLOG_ENTRY),
-                 # Only sub items of this item
-                 Prefix(NAME_EXACT, prefix),
-                 ]
+        tag = request.values.get("tag")
+        prefix = self.name + "/"
+        terms = [
+            Term(WIKINAME, app.cfg.interwikiname),
+            # Only blog entry itemtypes
+            Term(ITEMTYPE, ITEMTYPE_BLOG_ENTRY),
+            # Only sub items of this item
+            Prefix(NAME_EXACT, prefix),
+        ]
         if tag:
             terms.append(Term(TAGS, tag))
         query = And(terms)
@@ -79,41 +82,43 @@ def ptime_sort_key(searcher, docnum):
             fields = searcher.stored_fields(docnum)
             ptime = fields.get(PTIME, fields[MTIME])
             return ptime
+
         ptime_sort_facet = FunctionFacet(ptime_sort_key)
 
         revs = flaskg.storage.search(query, sortedby=ptime_sort_facet, reverse=True, limit=None)
         blog_entry_items = [Item.create(rev.name, rev_id=rev.revid) for rev in revs]
-        return render_template('blog/main.html',
-                               item_name=self.name,
-                               fqname=split_fqname(self.name),
-                               blog_item=self,
-                               blog_entry_items=blog_entry_items,
-                               tag=tag,
-                               item=self,
-                               )
+        return render_template(
+            "blog/main.html",
+            item_name=self.name,
+            fqname=split_fqname(self.name),
+            blog_item=self,
+            blog_entry_items=blog_entry_items,
+            tag=tag,
+            item=self,
+        )
 
 
 @register
 class BlogEntry(Default):
     itemtype = ITEMTYPE_BLOG_ENTRY
-    display_name = L_('Blog entry')
-    description = L_('Blog entry item')
+    display_name = L_("Blog entry")
+    description = L_("Blog entry item")
     order = 0
 
     class _ModifyForm(Default._ModifyForm):
         meta_form = BlogEntryMetaForm
-        meta_template = 'blog/modify_entry_meta.html'
+        meta_template = "blog/modify_entry_meta.html"
 
         @classmethod
         def from_item(cls, item):
             form = super().from_item(item)
             # preload PTIME with the current datetime
-            if not form['meta_form']['ptime']:
-                form['meta_form']['ptime'].set(datetime.utcnow())
+            if not form["meta_form"]["ptime"]:
+                form["meta_form"]["ptime"].set(datetime.utcnow())
             return form
 
     def do_show(self, revid, **kwargs):
-        blog_item_name = self.name.rsplit('/', 1)[0]
+        blog_item_name = self.name.rsplit("/", 1)[0]
         try:
             blog_item = Item.create(blog_item_name)
         except AccessDenied:
@@ -121,10 +126,11 @@ def do_show(self, revid, **kwargs):
         if not isinstance(blog_item, Blog):
             # The parent item of this blog entry item is not a Blog item.
             abort(403)
-        return render_template('blog/entry.html',
-                               item_name=self.name,
-                               fqname=blog_item.fqname,
-                               blog_item=blog_item,
-                               blog_entry_item=self,
-                               item=self,
-                               )
+        return render_template(
+            "blog/entry.html",
+            item_name=self.name,
+            fqname=blog_item.fqname,
+            blog_item=blog_item,
+            blog_entry_item=self,
+            item=self,
+        )
diff --git a/src/moin/items/content.py b/src/moin/items/content.py
index 399ab2ac3..f8add72ab 100644
--- a/src/moin/items/content.py
+++ b/src/moin/items/content.py
@@ -66,13 +66,29 @@
 from moin.utils.interwiki import get_download_file_name
 from moin.forms import File
 from moin.constants.contenttypes import (
-    GROUP_MARKUP_TEXT, GROUP_OTHER_TEXT, GROUP_IMAGE, GROUP_AUDIO, GROUP_VIDEO,
-    GROUP_DRAWING, GROUP_OTHER, CONTENTTYPE_NONEXISTENT, CHARSET
+    GROUP_MARKUP_TEXT,
+    GROUP_OTHER_TEXT,
+    GROUP_IMAGE,
+    GROUP_AUDIO,
+    GROUP_VIDEO,
+    GROUP_DRAWING,
+    GROUP_OTHER,
+    CONTENTTYPE_NONEXISTENT,
+    CHARSET,
+)
+from moin.constants.keys import (
+    NAME_EXACT,
+    WIKINAME,
+    CONTENTTYPE,
+    TAGS,
+    TEMPLATE,
+    HASH_ALGORITHM,
+    ACTION_SAVE,
+    NAMESPACE,
 )
-from moin.constants.keys import (NAME_EXACT, WIKINAME, CONTENTTYPE, TAGS, TEMPLATE,
-                                 HASH_ALGORITHM, ACTION_SAVE, NAMESPACE)
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -81,8 +97,9 @@
 
 
 class RegistryContent(RegistryBase):
-    class Entry(namedtuple('Entry',
-                           'factory content_type default_contenttype_params display_name ingroup_order priority')):
+    class Entry(
+        namedtuple("Entry", "factory content_type default_contenttype_params display_name ingroup_order priority")
+    ):
         def __call__(self, content_type, *args, **kw):
             if self.content_type.issupertype(Type(content_type)):
                 return self.factory(content_type, *args, **kw)
@@ -107,33 +124,34 @@ def register(self, e, group):
         # If group is specified and contenttype is not a wildcard one
         if group and e.content_type.type and e.content_type.subtype:
             if group not in self.groups:
-                raise ValueError(f'Unknown group name: {group}')
+                raise ValueError(f"Unknown group name: {group}")
             self.groups[group].append(e)
-            self.groups[group].sort(key=attrgetter('ingroup_order'))
+            self.groups[group].sort(key=attrgetter("ingroup_order"))
         return self._register(e)
 
 
-content_registry = RegistryContent([
-    GROUP_MARKUP_TEXT,
-    GROUP_OTHER_TEXT,
-    GROUP_IMAGE,
-    GROUP_AUDIO,
-    GROUP_VIDEO,
-    GROUP_DRAWING,
-    GROUP_OTHER
-])
+content_registry = RegistryContent(
+    [GROUP_MARKUP_TEXT, GROUP_OTHER_TEXT, GROUP_IMAGE, GROUP_AUDIO, GROUP_VIDEO, GROUP_DRAWING, GROUP_OTHER]
+)
 
 
 def register(cls):
-    content_registry.register(RegistryContent.Entry(cls._factory, Type(cls.contenttype),
-                                                    cls.default_contenttype_params, cls.display_name,
-                                                    cls.ingroup_order, RegistryContent.PRIORITY_MIDDLE), cls.group)
+    content_registry.register(
+        RegistryContent.Entry(
+            cls._factory,
+            Type(cls.contenttype),
+            cls.default_contenttype_params,
+            cls.display_name,
+            cls.ingroup_order,
+            RegistryContent.PRIORITY_MIDDLE,
+        ),
+        cls.group,
+    )
     return cls
 
 
 def content_registry_enable(contenttype_enabled):
-    """ Remove content types from the registry that are not explicitly enabled
-    """
+    """Remove content types from the registry that are not explicitly enabled"""
     groups_enabled = {g: [] for g in content_registry.group_names}
     for group in content_registry.group_names:
         for e in content_registry.groups[group]:
@@ -144,8 +162,7 @@ def content_registry_enable(contenttype_enabled):
 
 
 def content_registry_disable(contenttype_disabled):
-    """ Remove disabled content types from registry
-    """
+    """Remove disabled content types from registry"""
     groups_enabled = {g: [] for g in content_registry.group_names}
     for group in content_registry.group_names:
         for e in content_registry.groups[group]:
@@ -156,8 +173,8 @@ def content_registry_disable(contenttype_disabled):
     content_registry.groups = groups_enabled
 
 
-def conv_serialize(doc, namespaces, method='polyglot'):
-    out = array('u')
+def conv_serialize(doc, namespaces, method="polyglot"):
+    out = array("u")
     doc.write(out.fromunicode, namespaces=namespaces, method=method)
     out = out.tounicode()
     return out
@@ -168,6 +185,7 @@ class Content:
     Base for content classes defining some helpers, agnostic about content
     data.
     """
+
     # placeholder values for registry entry properties
     contenttype = None
     default_contenttype_params = {}
@@ -204,10 +222,11 @@ def name(self):
         return self.item.name
 
     def get_data(self):
-        return ''  # TODO create a better method for binary stuff
+        return ""  # TODO create a better method for binary stuff
+
     data = property(fget=get_data)
 
-    @timed('conv_in_dom')
+    @timed("conv_in_dom")
     def internal_representation(self, attributes=None, preview=None):
         """
         Return the internal representation of a document using a DOM Tree
@@ -217,31 +236,34 @@ def internal_representation(self, attributes=None, preview=None):
             hash_name = HASH_ALGORITHM
             hash_hexdigest = self.rev.meta.get(hash_name)
             if hash_hexdigest:
-                cid = cache_key(usage="internal_representation",
-                                hash_name=hash_name,
-                                hash_hexdigest=hash_hexdigest,
-                                attrs=repr(attributes))
+                cid = cache_key(
+                    usage="internal_representation",
+                    hash_name=hash_name,
+                    hash_hexdigest=hash_hexdigest,
+                    attrs=repr(attributes),
+                )
                 doc = app.cache.get(cid)
         if doc is None:
             # We will see if we can perform the conversion:
             # FROM_mimetype --> DOM
             # if so we perform the transformation, otherwise we don't
             from moin.converters import default_registry as reg
+
             input_conv = reg.get(Type(self.contenttype), type_moin_document)
             if not input_conv:
                 raise TypeError(f"We cannot handle the conversion from {self.contenttype} to the DOM tree")
-            smiley_conv = reg.get(type_moin_document, type_moin_document, icon='smiley')
+            smiley_conv = reg.get(type_moin_document, type_moin_document, icon="smiley")
 
             # We can process the conversion
             name = self.rev.fqname.fullname if self.rev else self.name
-            links = Iri(scheme='wiki', authority='', path='/' + name)
+            links = Iri(scheme="wiki", authority="", path="/" + name)
             doc = input_conv(preview or self.rev, self.contenttype, arguments=attributes)
             # XXX is the following assuming that the top element of the doc tree
             # is a moin_page.page element? if yes, this is the wrong place to do that
             # as not every doc will have that element (e.g. for images, we just get
             # moin_page.object, for a tar item, we get a moin_page.table):
             doc.set(moin_page.page_href, str(links))
-            if self.contenttype.startswith(('text/x.moin.wiki', 'text/x-mediawiki', 'text/x.moin.creole', )):
+            if self.contenttype.startswith(("text/x.moin.wiki", "text/x-mediawiki", "text/x.moin.creole")):
                 doc = smiley_conv(doc)
             if cid:
                 app.cache.set(cid, doc)
@@ -249,67 +271,64 @@ def internal_representation(self, attributes=None, preview=None):
 
     def _expand_document(self, doc):
         from moin.converters import default_registry as reg
+
         flaskg.add_lineno_attr = False  # do not add data-lineno attr for transclusions, footnotes, etc.
-        include_conv = reg.get(type_moin_document, type_moin_document, includes='expandall')
-        macro_conv = reg.get(type_moin_document, type_moin_document, macros='expandall')
-        nowiki_conv = reg.get(type_moin_document, type_moin_document, nowiki='expandall')
-        link_conv = reg.get(type_moin_document, type_moin_document, links='extern')
-        flaskg.clock.start('nowiki')
+        include_conv = reg.get(type_moin_document, type_moin_document, includes="expandall")
+        macro_conv = reg.get(type_moin_document, type_moin_document, macros="expandall")
+        nowiki_conv = reg.get(type_moin_document, type_moin_document, nowiki="expandall")
+        link_conv = reg.get(type_moin_document, type_moin_document, links="extern")
+        flaskg.clock.start("nowiki")
         doc = nowiki_conv(doc)
-        flaskg.clock.stop('nowiki')
-        flaskg.clock.start('conv_include')
+        flaskg.clock.stop("nowiki")
+        flaskg.clock.start("conv_include")
         doc = include_conv(doc)
-        flaskg.clock.stop('conv_include')
-        flaskg.clock.start('conv_macro')
+        flaskg.clock.stop("conv_include")
+        flaskg.clock.start("conv_macro")
         doc = macro_conv(doc)
-        flaskg.clock.stop('conv_macro')
-        flaskg.clock.start('conv_link')
+        flaskg.clock.stop("conv_macro")
+        flaskg.clock.start("conv_link")
         doc = link_conv(doc)
-        flaskg.clock.stop('conv_link')
-        if 'regex' in request.args:
-            highlight_conv = reg.get(type_moin_document, type_moin_document, highlight='highlight')
-            flaskg.clock.start('highlight')
+        flaskg.clock.stop("conv_link")
+        if "regex" in request.args:
+            highlight_conv = reg.get(type_moin_document, type_moin_document, highlight="highlight")
+            flaskg.clock.start("highlight")
             doc = highlight_conv(doc)
-            flaskg.clock.stop('highlight')
+            flaskg.clock.stop("highlight")
         return doc
 
     def _render_data(self, preview=None):
         try:
             from moin.converters import default_registry as reg
+
             # TODO: Real output format
             doc = self.internal_representation(preview=preview)
             doc = self._expand_document(doc)
-            flaskg.clock.start('conv_dom_html')
-            html_conv = reg.get(type_moin_document, Type('application/x-xhtml-moin-page'))
+            flaskg.clock.start("conv_dom_html")
+            html_conv = reg.get(type_moin_document, Type("application/x-xhtml-moin-page"))
             doc = html_conv(doc)
-            flaskg.clock.stop('conv_dom_html')
-            rendered_data = conv_serialize(doc, {html.namespace: ''})
+            flaskg.clock.stop("conv_dom_html")
+            rendered_data = conv_serialize(doc, {html.namespace: ""})
         except Exception:
             # we really want to make sure that invalid data or a malfunctioning
             # converter does not crash the item view (otherwise a user might
             # not be able to fix it from the UI).
             error_id = uuid.uuid4()
             logging.exception(f"An exception happened in _render_data (error_id = {error_id} ):")
-            rendered_data = render_template('crash.html',
-                                            server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"),
-                                            url=request.url,
-                                            error_id=error_id)
+            rendered_data = render_template(
+                "crash.html", server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"), url=request.url, error_id=error_id
+            )
         return rendered_data
 
     def _render_data_xml(self):
         doc = self.internal_representation()
-        return conv_serialize(doc,
-                              {moin_page.namespace: '',
-                               xlink.namespace: 'xlink',
-                               html.namespace: 'html',
-                               }, 'xml')
+        return conv_serialize(doc, {moin_page.namespace: "", xlink.namespace: "xlink", html.namespace: "html"}, "xml")
 
     def _render_data_highlight(self):
         # override this in child classes
-        return ''
+        return ""
 
     def _get_data_diff_text(self, oldfile, newfile):
-        """ Get the text diff of 2 versions of file contents
+        """Get the text diff of 2 versions of file contents
 
         :param oldfile: file that contains old content data (bytes)
         :param newfile: file that contains new content data (bytes)
@@ -318,9 +337,12 @@ def _get_data_diff_text(self, oldfile, newfile):
         return []
 
     def get_templates(self, contenttype=None):
-        """ create a list of templates (for some specific contenttype) """
-        terms = [Term(WIKINAME, app.cfg.interwikiname), Term(TAGS, TEMPLATE),
-                 Term(NAMESPACE, self.item.fqname.namespace)]
+        """create a list of templates (for some specific contenttype)"""
+        terms = [
+            Term(WIKINAME, app.cfg.interwikiname),
+            Term(TAGS, TEMPLATE),
+            Term(NAMESPACE, self.item.fqname.namespace),
+        ]
         if contenttype is not None:
             terms.append(Term(CONTENTTYPE, contenttype))
         query = And(terms)
@@ -331,6 +353,7 @@ def get_templates(self, contenttype=None):
 @register
 class NonExistentContent(Content):
     """Dummy Content to use with NonExistent."""
+
     contenttype = CONTENTTYPE_NONEXISTENT
     group = None
 
@@ -343,15 +366,17 @@ def _convert(self, doc):
 
 @register
 class Binary(Content):
-    """ An arbitrary binary item, fallback class for every item mimetype. """
-    contenttype = '*/*'
+    """An arbitrary binary item, fallback class for every item mimetype."""
+
+    contenttype = "*/*"
 
     # XXX reads item rev data into memory!
     def get_data(self):
         if self.rev is not None:
             return self.rev.data.read()
         else:
-            return ''
+            return ""
+
     data = property(fget=get_data)
 
     class ModifyForm(Form):
@@ -359,14 +384,15 @@ class ModifyForm(Form):
         The content part of the ModifyForm of an Item subclass. See also the
         doc of Item._ModifyForm.
         """
-        template = 'modify_binary.html'
-        data_file = File.using(optional=True, label=L_('Replace content with uploaded file:'))
+
+        template = "modify_binary.html"
+        data_file = File.using(optional=True, label=L_("Replace content with uploaded file:"))
 
         def _load(self, item):
             pass
 
         def _dump(self, item):
-            data_file = self['data_file'].value
+            data_file = self["data_file"].value
             if data_file:
                 data = data_file.stream
                 # this is likely a guess by the browser, based on the filename
@@ -386,13 +412,14 @@ def _render_data_diff(self, oldrev, newrev, rev_links={}, fqname=None):
     _render_data_diff_raw = _render_data_diff
 
     def _render_data_diff_atom(self, oldrev, newrev):
-        return render_template('atom.html',
-                               oldrev=oldrev, newrev=newrev, get='binary',
-                               content=Markup(self._render_data()))
+        return render_template(
+            "atom.html", oldrev=oldrev, newrev=newrev, get="binary", content=Markup(self._render_data())
+        )
 
     def _convert(self, doc):
-        return _("Impossible to convert the data to the contenttype: {contenttype}"
-                ).format(contenttype=request.values.get('contenttype'))
+        return _("Impossible to convert the data to the contenttype: {contenttype}").format(
+            contenttype=request.values.get("contenttype")
+        )
 
     def do_get(self, force_attachment=False, mimetype=None):
         hash = self.rev.meta.get(HASH_ALGORITHM)
@@ -402,7 +429,7 @@ def do_get(self, force_attachment=False, mimetype=None):
             return Response(status=304)
 
     def _do_get_modified(self, hash, force_attachment=False, mimetype=None):
-        member = request.values.get('member')
+        member = request.values.get("member")
         return self._do_get(hash, member, force_attachment=force_attachment, mimetype=mimetype)
 
     def _do_get(self, hash, member=None, force_attachment=False, mimetype=None):
@@ -428,11 +455,16 @@ def _do_get(self, hash, member=None, force_attachment=False, mimetype=None):
         else:
             content_type = mt.content_type()
         as_attachment = force_attachment or mt.as_attachment(app.cfg)
-        return send_file(file=file_to_send,
-                         mimetype=content_type,
-                         as_attachment=as_attachment, attachment_filename=filename,
-                         cache_timeout=10,  # wiki data can change rapidly
-                         add_etags=True, etag=hash, conditional=True)
+        return send_file(
+            file=file_to_send,
+            mimetype=content_type,
+            as_attachment=as_attachment,
+            attachment_filename=filename,
+            cache_timeout=10,  # wiki data can change rapidly
+            add_etags=True,
+            etag=hash,
+            conditional=True,
+        )
 
 
 @register
@@ -440,16 +472,17 @@ class OctetStream(Binary):
     """
     Fallback Content for uploaded file of unknown contenttype.
     """
-    contenttype = 'application/octet-stream'
-    display_name = 'Binary File'
+
+    contenttype = "application/octet-stream"
+    display_name = "Binary File"
 
 
 class RenderableBinary(Binary):
-    """ Base class for some binary stuff that renders with a object tag. """
+    """Base class for some binary stuff that renders with a object tag."""
 
 
 class Application(Binary):
-    """ Base class for application/* """
+    """Base class for application/*"""
 
 
 class TarMixin:
@@ -457,12 +490,13 @@ class TarMixin:
     TarMixin offers additional functionality for tar-like items to list and
     access member files and to create new revisions by multiple posts.
     """
+
     def list_members(self):
         """
         list tar file contents (member file names)
         """
         self.rev.data.seek(0)
-        tf = tarfile.open(fileobj=self.rev.data, mode='r')
+        tf = tarfile.open(fileobj=self.rev.data, mode="r")
         return tf.getnames()
 
     def get_member(self, name):
@@ -472,7 +506,7 @@ def get_member(self, name):
         :param name: name of the data in the container file
         """
         self.rev.data.seek(0)
-        tf = tarfile.open(fileobj=self.rev.data, mode='r')
+        tf = tarfile.open(fileobj=self.rev.data, mode="r")
         return tf.extractfile(name)
 
     def put_member(self, name, content, content_length, expected_members):
@@ -489,15 +523,16 @@ def put_member(self, name, content, content_length, expected_members):
         if name not in expected_members:
             raise StorageError(f"tried to add unexpected member {name!r} to container item {self.name!r}")
         assert isinstance(name, str)
-        temp_fname = os.path.join(tempfile.gettempdir(), 'TarContainer_' +
-                                  cache_key(usage='TarContainer', name=self.name))
-        with tarfile.open(temp_fname, mode='a') as tf:
+        temp_fname = os.path.join(
+            tempfile.gettempdir(), "TarContainer_" + cache_key(usage="TarContainer", name=self.name)
+        )
+        with tarfile.open(temp_fname, mode="a") as tf:
             ti = tarfile.TarInfo(name)
             if isinstance(content, bytes):
                 if content_length is None:
                     content_length = len(content)
                 content = BytesIO(content)  # we need a file obj
-            elif not hasattr(content, 'read'):
+            elif not hasattr(content, "read"):
                 logging.error(f"unsupported content object: {content!r}")
                 raise StorageError(f"unsupported content object: {content!r}")
             else:
@@ -514,8 +549,8 @@ def put_member(self, name, content, content_length, expected_members):
         if tf_members == expected_members:
             # everything we expected has been added to the tar file, save the container as revision
             meta = {CONTENTTYPE: self.contenttype}
-            with open(temp_fname, 'rb') as data:
-                self.item._save(meta, data, names=self.name, action=ACTION_SAVE, comment='')
+            with open(temp_fname, "rb") as data:
+                self.item._save(meta, data, names=self.name, action=ACTION_SAVE, comment="")
             os.remove(temp_fname)
 
 
@@ -524,8 +559,9 @@ class ApplicationXTar(TarMixin, Application):
     """
     Tar items
     """
-    contenttype = 'application/x-tar'
-    display_name = 'TAR'
+
+    contenttype = "application/x-tar"
+    display_name = "TAR"
 
 
 @register
@@ -533,8 +569,9 @@ class ApplicationXGTar(ApplicationXTar):
     """
     Compressed tar items
     """
-    contenttype = 'application/x-gtar'
-    display_name = 'TGZ'
+
+    contenttype = "application/x-gtar"
+    display_name = "TGZ"
 
 
 class ZipMixin:
@@ -542,12 +579,13 @@ class ZipMixin:
     ZipMixin offers additional functionality for zip-like items to list and
     access member files.
     """
+
     def list_members(self):
         """
         list zip file contents (member file names)
         """
         self.rev.data.seek(0)
-        zf = zipfile.ZipFile(self.rev.data, mode='r')
+        zf = zipfile.ZipFile(self.rev.data, mode="r")
         return zf.namelist()
 
     def get_member(self, name):
@@ -557,8 +595,8 @@ def get_member(self, name):
         :param name: name of the data in the zip file
         """
         self.rev.data.seek(0)
-        zf = zipfile.ZipFile(self.rev.data, mode='r')
-        return zf.open(name, mode='r')
+        zf = zipfile.ZipFile(self.rev.data, mode="r")
+        return zf.open(name, mode="r")
 
     def put_member(self, name, content, content_length, expected_members):
         raise NotImplementedError
@@ -569,101 +607,110 @@ class ApplicationZip(ZipMixin, Application):
     """
     Zip items
     """
-    contenttype = 'application/zip'
-    display_name = 'ZIP'
+
+    contenttype = "application/zip"
+    display_name = "ZIP"
 
 
 @register
 class PDF(Application):
-    """ PDF """
-    contenttype = 'application/pdf'
-    display_name = 'PDF'
+    """PDF"""
+
+    contenttype = "application/pdf"
+    display_name = "PDF"
 
 
 @register
 class Video(Binary):
-    """ Base class for video/* """
-    contenttype = 'video/*'
+    """Base class for video/*"""
+
+    contenttype = "video/*"
     group = GROUP_VIDEO
 
 
 @register
 class OGGVideo(Video):
-    contenttype = 'video/ogg'
-    display_name = 'OGG'
+    contenttype = "video/ogg"
+    display_name = "OGG"
 
 
 @register
 class WebMVideo(Video):
-    contenttype = 'video/webm'
-    display_name = 'WebM'
+    contenttype = "video/webm"
+    display_name = "WebM"
 
 
 @register
 class MP4(Video):
-    contenttype = 'video/mp4'
-    display_name = 'MP4'
+    contenttype = "video/mp4"
+    display_name = "MP4"
 
 
 @register
 class Audio(Binary):
-    """ Base class for audio/* """
-    contenttype = 'audio/*'
+    """Base class for audio/*"""
+
+    contenttype = "audio/*"
     group = GROUP_AUDIO
 
 
 @register
 class WAV(Audio):
-    contenttype = 'audio/x-wav'
-    display_name = 'WAV'
+    contenttype = "audio/x-wav"
+    display_name = "WAV"
 
 
 @register
 class OGGAudio(Audio):
-    contenttype = 'audio/ogg'
-    display_name = 'OGG'
+    contenttype = "audio/ogg"
+    display_name = "OGG"
 
 
 @register
 class MP3(Audio):
-    contenttype = 'audio/mpeg'
-    display_name = 'MP3'
+    contenttype = "audio/mpeg"
+    display_name = "MP3"
 
 
 @register
 class WebMAudio(Audio):
-    contenttype = 'audio/webm'
-    display_name = 'WebM'
+    contenttype = "audio/webm"
+    display_name = "WebM"
 
 
 @register
 class Image(Binary):
-    """ Base class for image/* """
-    contenttype = 'image/*'
+    """Base class for image/*"""
+
+    contenttype = "image/*"
 
 
 class RenderableImage(RenderableBinary):
-    """ Base class for renderable Image mimetypes """
+    """Base class for renderable Image mimetypes"""
+
     group = GROUP_IMAGE
 
 
 @register
 class SvgImage(RenderableImage):
-    """ SVG images use <object> tag mechanism from RenderableBinary base class """
-    contenttype = 'image/svg+xml'
-    display_name = 'SVG'
+    """SVG images use <object> tag mechanism from RenderableBinary base class"""
+
+    contenttype = "image/svg+xml"
+    display_name = "SVG"
 
 
 class RenderableBitmapImage(RenderableImage):
-    """ PNG/JPEG/GIF images use <img> tag (better browser support than <object>) """
+    """PNG/JPEG/GIF images use <img> tag (better browser support than <object>)"""
+
     # if mimetype is also transformable, please register in TransformableImage ONLY!
 
 
 class TransformableBitmapImage(RenderableBitmapImage):
-    """ We can transform (resize, rotate, mirror) some image types """
+    """We can transform (resize, rotate, mirror) some image types"""
+
     def _transform(self, content_type, size=None, transpose_op=None):
-        """ resize to new size (optional), transpose according to exif infos,
-            result data should be content_type.
+        """resize to new size (optional), transpose according to exif infos,
+        result data should be content_type.
         """
         try:
             from PIL import Image as PILImage
@@ -671,12 +718,12 @@ def _transform(self, content_type, size=None, transpose_op=None):
             # no PIL, we can't do anything, we just output the revision data as is
             return content_type, self.rev.data.read()
 
-        if content_type == 'image/jpeg':
-            output_type = 'JPEG'
-        elif content_type == 'image/png':
-            output_type = 'PNG'
-        elif content_type == 'image/gif':
-            output_type = 'GIF'
+        if content_type == "image/jpeg":
+            output_type = "JPEG"
+        elif content_type == "image/png":
+            output_type = "PNG"
+        elif content_type == "image/gif":
+            output_type = "GIF"
         else:
             raise ValueError(f"content_type {content_type!r} not supported")
 
@@ -715,15 +762,15 @@ def _transform(self, content_type, size=None, transpose_op=None):
 
     def _do_get_modified(self, hash, force_attachment=False, mimetype=None):
         try:
-            width = int(request.values.get('w'))
+            width = int(request.values.get("w"))
         except (TypeError, ValueError):
             width = None
         try:
-            height = int(request.values.get('h'))
+            height = int(request.values.get("h"))
         except (TypeError, ValueError):
             height = None
         try:
-            transpose = int(request.values.get('t'))
+            transpose = int(request.values.get("t"))
             assert 1 <= transpose <= 8
         except (TypeError, ValueError, AssertionError):
             transpose = 1
@@ -731,10 +778,14 @@ def _do_get_modified(self, hash, force_attachment=False, mimetype=None):
             # resize requested, XXX check ACL behaviour! XXX
             hash_name = HASH_ALGORITHM
             hash_hexdigest = self.rev.meta[hash_name]
-            cid = cache_key(usage="ImageTransform",
-                            hash_name=hash_name,
-                            hash_hexdigest=hash_hexdigest,
-                            width=width, height=height, transpose=transpose)
+            cid = cache_key(
+                usage="ImageTransform",
+                hash_name=hash_name,
+                hash_hexdigest=hash_hexdigest,
+                width=width,
+                height=height,
+                transpose=transpose,
+            )
             c = app.cache.get(cid)
             if c is None:
                 if mimetype:
@@ -756,36 +807,35 @@ def _render_data_diff_atom(self, oldrev, newrev):
         if PIL is None:
             # no PIL, we can't do anything, we just call the base class method
             return super()._render_data_diff_atom(oldrev, newrev)
-        url = url_for('frontend.diffraw', _external=True, item_name=self.name, rev1=oldrev.revid, rev2=newrev.revid)
-        return render_template('atom.html',
-                               oldrev=oldrev, newrev=newrev, get='binary',
-                               content=Markup(f'<img src="{escape(url)}" />'))
+        url = url_for("frontend.diffraw", _external=True, item_name=self.name, rev1=oldrev.revid, rev2=newrev.revid)
+        return render_template(
+            "atom.html", oldrev=oldrev, newrev=newrev, get="binary", content=Markup(f'<img src="{escape(url)}" />')
+        )
 
     def _render_data_diff(self, oldrev, newrev, rev_links={}, fqname=None):
         if PIL is None:
             # no PIL, we can't do anything, we just call the base class method
             return super()._render_data_diff(oldrev, newrev)
-        url = url_for('frontend.diffraw', item_name=self.name, rev1=oldrev.revid, rev2=newrev.revid)
+        url = url_for("frontend.diffraw", item_name=self.name, rev1=oldrev.revid, rev2=newrev.revid)
         return Markup(f'<img src="{escape(url)}" />')
 
     def _render_data_diff_raw(self, oldrev, newrev):
         hash_name = HASH_ALGORITHM
-        cid = cache_key(usage="ImageDiff",
-                        hash_name=hash_name,
-                        hash_old=oldrev.meta[hash_name],
-                        hash_new=newrev.meta[hash_name])
+        cid = cache_key(
+            usage="ImageDiff", hash_name=hash_name, hash_old=oldrev.meta[hash_name], hash_new=newrev.meta[hash_name]
+        )
         c = app.cache.get(cid)
         if c is None:
             if PIL is None:
                 abort(404)  # TODO render user friendly error image
 
             content_type = newrev.meta[CONTENTTYPE]
-            if content_type == 'image/jpeg':
-                output_type = 'JPEG'
-            elif content_type == 'image/png':
-                output_type = 'PNG'
-            elif content_type == 'image/gif':
-                output_type = 'GIF'
+            if content_type == "image/jpeg":
+                output_type = "JPEG"
+            elif content_type == "image/png":
+                output_type = "PNG"
+            elif content_type == "image/gif":
+                output_type = "GIF"
             else:
                 raise ValueError(f"content_type {content_type!r} not supported")
 
@@ -815,34 +865,38 @@ def _render_data_diff_text(self, oldrev, newrev):
 
 @register
 class PNG(TransformableBitmapImage):
-    """ PNG image. """
-    contenttype = 'image/png'
-    display_name = 'PNG'
+    """PNG image."""
+
+    contenttype = "image/png"
+    display_name = "PNG"
 
 
 @register
 class JPEG(TransformableBitmapImage):
-    """ JPEG image. """
-    contenttype = 'image/jpeg'
-    display_name = 'JPEG'
+    """JPEG image."""
+
+    contenttype = "image/jpeg"
+    display_name = "JPEG"
 
 
 @register
 class GIF(TransformableBitmapImage):
-    """ GIF image. """
-    contenttype = 'image/gif'
-    display_name = 'GIF'
+    """GIF image."""
+
+    contenttype = "image/gif"
+    display_name = "GIF"
 
 
 @register
 class Text(Binary):
-    """ Base class for text/* """
-    contenttype = 'text/*'
-    default_contenttype_params = dict(charset='utf-8')
+    """Base class for text/*"""
+
+    contenttype = "text/*"
+    default_contenttype_params = dict(charset="utf-8")
     group = GROUP_OTHER_TEXT
 
     class ModifyForm(Binary.ModifyForm):
-        template = 'modify_text.html'
+        template = "modify_text.html"
         data_text = String.using(strip=False, optional=True).with_properties(placeholder=L_("Type your text here"))
         rows = ROWS_DATA
         cols = COLS
@@ -852,37 +906,37 @@ def _load(self, item):
             data = item.data
             data = item.data_storage_to_internal(data)
             data = item.data_internal_to_form(data)
-            self['data_text'] = data
+            self["data_text"] = data
 
         def _dump(self, item):
             data, contenttype_guessed = super()._dump(item)
             if data is None:
-                data = self['data_text'].value
+                data = self["data_text"].value
                 data = item.data_form_to_internal(data)
                 data = item.data_internal_to_storage(data)
                 # we know it is text and utf-8 - XXX is there a way to get the charset of the form?
-                contenttype_guessed = 'text/plain;charset=utf-8'
+                contenttype_guessed = "text/plain;charset=utf-8"
             return data, contenttype_guessed
 
     # text/plain mandates crlf - but in memory, we want lf only
     def data_internal_to_form(self, text):
-        """ convert data from memory format to form format """
-        return text.replace('\n', '\r\n')
+        """convert data from memory format to form format"""
+        return text.replace("\n", "\r\n")
 
     def data_form_to_internal(self, data):
-        """ convert data from form format to memory format """
-        return data.replace('\r\n', '\n')
+        """convert data from form format to memory format"""
+        return data.replace("\r\n", "\n")
 
     def data_internal_to_storage(self, text):
-        """ convert data from memory format to storage format """
-        return text.replace('\n', '\r\n').encode(CHARSET)
+        """convert data from memory format to storage format"""
+        return text.replace("\n", "\r\n").encode(CHARSET)
 
     def data_storage_to_internal(self, data):
-        """ convert data from storage format to memory format """
-        return data.decode(CHARSET).replace('\r\n', '\n')
+        """convert data from storage format to memory format"""
+        return data.decode(CHARSET).replace("\r\n", "\n")
 
     def _render_data_diff_html(self, oldrev, newrev, template, rev_links={}, fqname=None):
-        """ Render HTML formatted meta and content diff of 2 revisions
+        """Render HTML formatted meta and content diff of 2 revisions
 
         :param oldrev: old revision object
         :param newrev: new revision object
@@ -890,20 +944,22 @@ def _render_data_diff_html(self, oldrev, newrev, template, rev_links={}, fqname=
         :return: HTML data with meta and content diff
         """
         from moin.items import Item  # XXX causes import error if placed near top
+
         diffs = self._get_data_diff_html(oldrev.data, newrev.data)
-        item = Item.create(fqname.fullname, rev_id=newrev.meta['revid'])
+        item = Item.create(fqname.fullname, rev_id=newrev.meta["revid"])
         rendered = Markup(item.content._render_data())
-        return render_template(template,
-                               item_name=fqname.fullname,
-                               oldrev=oldrev,
-                               newrev=newrev,
-                               diffs=diffs,
-                               rendered=rendered,
-                               rev_links=rev_links,
-                               )
+        return render_template(
+            template,
+            item_name=fqname.fullname,
+            oldrev=oldrev,
+            newrev=newrev,
+            diffs=diffs,
+            rendered=rendered,
+            rev_links=rev_links,
+        )
 
     def _get_data_diff_html(self, oldfile, newfile):
-        """ Get the HTML diff of 2 versions of file contents
+        """Get the HTML diff of 2 versions of file contents
 
         :param oldfile: file that contains old content data (bytes)
         :param newfile: file that contains new content data (bytes)
@@ -915,7 +971,7 @@ def _get_data_diff_html(self, oldfile, newfile):
         return [(d[0], Markup(d[1]), d[2], Markup(d[3])) for d in html_diff(old_text, new_text)]
 
     def _get_data_diff_text(self, oldfile, newfile):
-        """ Get the text diff of 2 versions of file contents
+        """Get the text diff of 2 versions of file contents
 
         :param oldfile: file that contains old content data (bytes)
         :param newfile: file that contains new content data (bytes)
@@ -926,35 +982,37 @@ def _get_data_diff_text(self, oldfile, newfile):
         return text_diff(old_text.splitlines(), new_text.splitlines())
 
     def _render_data_diff_atom(self, oldrev, newrev, fqname=None):
-        """ renders diff in HTML for atom feed """
-        return self._render_data_diff_html(oldrev, newrev, 'diff_text_atom.html', fqname=fqname)
+        """renders diff in HTML for atom feed"""
+        return self._render_data_diff_html(oldrev, newrev, "diff_text_atom.html", fqname=fqname)
 
     def _render_data_diff(self, oldrev, newrev, rev_links={}, fqname=None):
-        return self._render_data_diff_html(oldrev, newrev, 'diff_text.html', rev_links=rev_links, fqname=fqname)
+        return self._render_data_diff_html(oldrev, newrev, "diff_text.html", rev_links=rev_links, fqname=fqname)
 
     def _render_data_diff_text(self, oldrev, newrev):
-        """ Render text diff of 2 revisions' contents
+        """Render text diff of 2 revisions' contents
 
         :param oldrev: old revision object
         :param newrev: new revision object
         :return: text data of a content diff
         """
         difflines = self._get_data_diff_text(oldrev.data, newrev.data)
-        return '\n'.join(difflines)
+        return "\n".join(difflines)
 
     _render_data_diff_raw = _render_data_diff
 
     def _render_data_highlight(self):
         from moin.converters import default_registry as reg
+
         data_text = self.data_storage_to_internal(self.data)
         # TODO: use registry as soon as it is in there
         from moin.converters.pygments_in import Converter as PygmentsConverter
+
         pygments_conv = PygmentsConverter(contenttype=self.contenttype)
         doc = pygments_conv(data_text)
         # TODO: Real output format
-        html_conv = reg.get(type_moin_document, Type('application/x-xhtml-moin-page'))
+        html_conv = reg.get(type_moin_document, Type("application/x-xhtml-moin-page"))
         doc = html_conv(doc)
-        return conv_serialize(doc, {html.namespace: ''})
+        return conv_serialize(doc, {html.namespace: ""})
 
 
 class MarkupItem(Text):
@@ -962,42 +1020,48 @@ class MarkupItem(Text):
     some kind of item with markup
     (internal links and transcluded items)
     """
+
     group = GROUP_MARKUP_TEXT
 
 
 @register
 class MoinWiki(MarkupItem):
-    """ MoinMoin wiki markup """
-    contenttype = 'text/x.moin.wiki'
-    display_name = 'MoinMoin'
+    """MoinMoin wiki markup"""
+
+    contenttype = "text/x.moin.wiki"
+    display_name = "MoinMoin"
 
 
 @register
 class CreoleWiki(MarkupItem):
-    """ Creole wiki markup """
-    contenttype = 'text/x.moin.creole'
-    display_name = 'Creole'
+    """Creole wiki markup"""
+
+    contenttype = "text/x.moin.creole"
+    display_name = "Creole"
 
 
 @register
 class MediaWiki(MarkupItem):
-    """ MediaWiki markup """
-    contenttype = 'text/x-mediawiki'
-    display_name = 'MediaWiki'
+    """MediaWiki markup"""
+
+    contenttype = "text/x-mediawiki"
+    display_name = "MediaWiki"
 
 
 @register
 class ReST(MarkupItem):
-    """ ReStructured Text markup """
-    contenttype = 'text/x-rst'
-    display_name = 'ReST'
+    """ReStructured Text markup"""
+
+    contenttype = "text/x-rst"
+    display_name = "ReST"
 
 
 @register
 class Markdown(MarkupItem):
-    """ Markdown markup """
-    contenttype = 'text/x-markdown'
-    display_name = 'Markdown'
+    """Markdown markup"""
+
+    contenttype = "text/x-markdown"
+    display_name = "Markdown"
 
 
 @register
@@ -1011,8 +1075,9 @@ class HTML(MarkupItem):
 
     Note: If raw revision data is accessed, unsafe stuff might be present!
     """
-    contenttype = 'text/html'
-    display_name = 'HTML'
+
+    contenttype = "text/html"
+    display_name = "HTML"
 
     class ModifyForm(Text.ModifyForm):
         template = "modify_text_html.html"
@@ -1020,9 +1085,10 @@ class ModifyForm(Text.ModifyForm):
 
 @register
 class DocBook(MarkupItem):
-    """ DocBook Document """
-    contenttype = 'application/docbook+xml'
-    display_name = 'DocBook'
+    """DocBook Document"""
+
+    contenttype = "application/docbook+xml"
+    display_name = "DocBook"
 
     def _convert(self, doc):
         from emeraldtree import ElementTree as ET
@@ -1032,15 +1098,12 @@ def _convert(self, doc):
 
         # We convert the internal representation of the document
         # into a DocBook document
-        conv = reg.get(type_moin_document, Type('application/docbook+xml'))
+        conv = reg.get(type_moin_document, Type("application/docbook+xml"))
 
         doc = conv(doc)
 
         # We determine the different namespaces of the output form
-        output_namespaces = {
-            docbook.namespace: '',
-            xlink.namespace: 'xlink',
-        }
+        output_namespaces = {docbook.namespace: "", xlink.namespace: "xlink"}
 
         # We convert the result into a BytesIO object
         # With the appropriate namespace
@@ -1051,7 +1114,7 @@ def _convert(self, doc):
         tree.write(file_to_send, namespaces=output_namespaces)
 
         # We determine the different parameters for the reply
-        mt = MimeType(mimestr='application/docbook+xml;charset=utf-8')
+        mt = MimeType(mimestr="application/docbook+xml;charset=utf-8")
         content_type = mt.content_type()
         as_attachment = mt.as_attachment(app.cfg)
         # After creation of the BytesIO, we are at the end of the file
@@ -1060,47 +1123,53 @@ def _convert(self, doc):
         file_to_send.seek(0)
         # Important: empty filename keeps flask from trying to autodetect filename,
         # as this would not work for us, because our file's are not necessarily fs files.
-        return send_file(file=file_to_send,
-                         mimetype=content_type,
-                         as_attachment=as_attachment, attachment_filename=None,
-                         cache_timeout=10,  # wiki data can change rapidly
-                         add_etags=False, etag=None, conditional=True)
+        return send_file(
+            file=file_to_send,
+            mimetype=content_type,
+            as_attachment=as_attachment,
+            attachment_filename=None,
+            cache_timeout=10,  # wiki data can change rapidly
+            add_etags=False,
+            etag=None,
+            conditional=True,
+        )
 
 
 @register
 class PlainText(Text):
-    contenttype = 'text/plain'
-    display_name = 'Plain Text'
+    contenttype = "text/plain"
+    display_name = "Plain Text"
 
 
 @register
 class Diff(Text):
-    contenttype = 'text/x-diff'
-    display_name = 'Diff/Patch'
+    contenttype = "text/x-diff"
+    display_name = "Diff/Patch"
 
 
 @register
 class PythonCode(Text):
-    contenttype = 'text/x-python'
-    display_name = 'Python Code'
+    contenttype = "text/x-python"
+    display_name = "Python Code"
 
 
 @register
 class CSV(Text):
-    contenttype = 'text/csv'
-    display_name = 'CSV'
+    contenttype = "text/csv"
+    display_name = "CSV"
 
 
 @register
 class IRCLog(Text):
-    contenttype = 'text/x-irclog'
-    display_name = 'IRC Log'
+    contenttype = "text/x-irclog"
+    display_name = "IRC Log"
 
 
 class Draw(TarMixin, Image):
     """
     Base class for drawing apps that use special Java/Javascript applets to modify and store data in a tar file.
     """
+
     group = GROUP_DRAWING
 
     class ModifyForm(Binary.ModifyForm):
@@ -1115,13 +1184,14 @@ class DrawPNGMap(Draw):
     """
     Base class for drawings that have a png with click map
     """
+
     def _read_map(self):
-        mapfile = self.get_member('drawing.map')
+        mapfile = self.get_member("drawing.map")
         try:
             image_map = mapfile.read()
             mapfile.close()
         except OSError:
-            image_map = ''
+            image_map = ""
         return image_map
 
     def _transform_map(self, image_map, title):
@@ -1130,12 +1200,12 @@ def _transform_map(self, image_map, title):
     def _render_data(self):
         # TODO: this could be a converter -> dom, then transcluding this kind
         # of items and also rendering them with the code in base class could work
-        png_url = url_for('frontend.get_item', item_name=self.name, member='drawing.png', rev=self.rev.revid)
-        title = _('Edit drawing {filename} (opens in new window)').format(filename=self.name)
+        png_url = url_for("frontend.get_item", item_name=self.name, member="drawing.png", rev=self.rev.revid)
+        title = _("Edit drawing {filename} (opens in new window)").format(filename=self.name)
         image_map = self._read_map()
         if image_map:
             mapid, image_map = self._transform_map(image_map, title)
-            title = _('Clickable drawing: {filename}').format(filename=self.name)
+            title = _("Clickable drawing: {filename}").format(filename=self.name)
             return Markup(image_map + f'<img src="{png_url}" alt="{title}" usemap="#{mapid}" />')
         else:
             return Markup(f'<img src="{png_url}" alt="{title}" />')
@@ -1143,29 +1213,28 @@ def _render_data(self):
 
 @register
 class SvgDraw(Draw):
-    """ drawings by svg-edit. It creates two files (svg, png) which are stored as tar file. """
-    contenttype = 'application/x-svgdraw'
-    display_name = 'SVGDRAW'
+    """drawings by svg-edit. It creates two files (svg, png) which are stored as tar file."""
+
+    contenttype = "application/x-svgdraw"
+    display_name = "SVGDRAW"
 
     class ModifyForm(Draw.ModifyForm):
         template = "modify_svg-edit.html"
 
     def handle_post(self):
         # called from modify UI/POST
-        png_upload = request.values.get('png_data')
-        svg_upload = request.values.get('filepath')
-        png_content = png_upload.decode('base_64')
-        png_content = base64.urlsafe_b64decode(png_content.split(',')[1])
-        svg_content = svg_upload.decode('base_64')
+        png_upload = request.values.get("png_data")
+        svg_upload = request.values.get("filepath")
+        png_content = png_upload.decode("base_64")
+        png_content = base64.urlsafe_b64decode(png_content.split(",")[1])
+        svg_content = svg_upload.decode("base_64")
         content_length = None
-        self.put_member("drawing.svg", svg_content, content_length,
-                        expected_members={'drawing.svg', 'drawing.png'})
-        self.put_member("drawing.png", png_content, content_length,
-                        expected_members={'drawing.svg', 'drawing.png'})
+        self.put_member("drawing.svg", svg_content, content_length, expected_members={"drawing.svg", "drawing.png"})
+        self.put_member("drawing.png", png_content, content_length, expected_members={"drawing.svg", "drawing.png"})
 
     def _render_data(self):
         # TODO: this could be a converter -> dom, then transcluding this kind
         # of items and also rendering them with the code in base class could work
-        drawing_url = url_for('frontend.get_item', item_name=self.name, member='drawing.svg', rev=self.rev.revid)
-        png_url = url_for('frontend.get_item', item_name=self.name, member='drawing.png', rev=self.rev.revid)
+        drawing_url = url_for("frontend.get_item", item_name=self.name, member="drawing.svg", rev=self.rev.revid)
+        png_url = url_for("frontend.get_item", item_name=self.name, member="drawing.png", rev=self.rev.revid)
         return Markup(f'<img src="{png_url}" alt="{drawing_url}" />')
diff --git a/src/moin/items/ticket.py b/src/moin/items/ticket.py
index 0a67d2e3c..d286dc253 100644
--- a/src/moin/items/ticket.py
+++ b/src/moin/items/ticket.py
@@ -48,12 +48,38 @@
 
 from moin.i18n import L_
 from moin.themes import render_template
-from moin.forms import (Form, OptionalMultilineText, SmallNatural, Tags,
-                        Reference, BackReference, SelectSubmit, Text, Search, File)
+from moin.forms import (
+    Form,
+    OptionalMultilineText,
+    SmallNatural,
+    Tags,
+    Reference,
+    BackReference,
+    SelectSubmit,
+    Text,
+    Search,
+    File,
+)
 from moin.storage.middleware.protecting import AccessDenied
-from moin.constants.keys import (ITEMTYPE, CONTENTTYPE, ITEMID, CURRENT,
-                                 SUPERSEDED_BY, SUBSCRIPTIONS, DEPENDS_ON, MTIME, TAGS,
-                                 NAME, SUMMARY, ELEMENT, NAMESPACE, WIKINAME, REFERS_TO, CONTENT, ACTION_TRASH)
+from moin.constants.keys import (
+    ITEMTYPE,
+    CONTENTTYPE,
+    ITEMID,
+    CURRENT,
+    SUPERSEDED_BY,
+    SUBSCRIPTIONS,
+    DEPENDS_ON,
+    MTIME,
+    TAGS,
+    NAME,
+    SUMMARY,
+    ELEMENT,
+    NAMESPACE,
+    WIKINAME,
+    REFERS_TO,
+    CONTENT,
+    ACTION_TRASH,
+)
 from moin.constants.contenttypes import CONTENTTYPE_USER
 from moin.constants.itemtypes import ITEMTYPE_TICKET
 from moin.items import Item, Contentful, register, BaseModifyForm, get_itemtype_specific_tags, IndexEntry
@@ -68,34 +94,26 @@
 
 
 def get_itemid_short_summary(rev):
-    return f'{rev.meta[ITEMID][:4]} ({rev.meta[SUMMARY][:50]})'
+    return f"{rev.meta[ITEMID][:4]} ({rev.meta[SUMMARY][:50]})"
 
 
 def get_name(rev):
     return rev.meta[NAME][0]
 
 
-OptionalTicketReference = Reference.to(
-    TICKET_QUERY,
-).using(
-    optional=True,
-).with_properties(
-    label_getter=get_itemid_short_summary,
+OptionalTicketReference = (
+    Reference.to(TICKET_QUERY).using(optional=True).with_properties(label_getter=get_itemid_short_summary)
 )
-OptionalUserReference = Reference.to(
-    USER_QUERY,
-).using(
-    optional=True,
-).with_properties(
-    empty_label='(Nobody)',
-    label_getter=get_name,
+OptionalUserReference = (
+    Reference.to(USER_QUERY).using(optional=True).with_properties(empty_label="(Nobody)", label_getter=get_name)
 )
 
 
 class AdvancedSearchForm(Form):
     q = Search
-    summary = Text.using(label=L_("Summary"),
-                         optional=False).with_properties(widget=WIDGET_SEARCH, placeholder=L_("Find Tickets"))
+    summary = Text.using(label=L_("Summary"), optional=False).with_properties(
+        widget=WIDGET_SEARCH, placeholder=L_("Find Tickets")
+    )
     effort = Rating.using(label=L_("Effort"))
     difficulty = Rating.using(label=L_("Difficulty"))
     severity = Rating.using(label=L_("Severity"))
@@ -106,8 +124,9 @@ class AdvancedSearchForm(Form):
 
 
 class TicketMetaForm(Form):
-    summary = Text.using(label=L_("Summary"),
-                         optional=False).with_properties(widget=WIDGET_SEARCH, placeholder=L_("One-line summary"))
+    summary = Text.using(label=L_("Summary"), optional=False).with_properties(
+        widget=WIDGET_SEARCH, placeholder=L_("One-line summary")
+    )
     effort = Rating.using(label=L_("Effort"))
     difficulty = Rating.using(label=L_("Difficulty"))
     severity = Rating.using(label=L_("Severity"))
@@ -125,23 +144,23 @@ class TicketBackRefForm(Form):
 
     def _load(self, item):
         id_ = item.meta[ITEMID]
-        self['supersedes'].set(Term(SUPERSEDED_BY, id_))
-        self['required_by'].set(Term(DEPENDS_ON, id_))
-        self['subscribers'].set(Term(SUBSCRIPTIONS, id_))
+        self["supersedes"].set(Term(SUPERSEDED_BY, id_))
+        self["required_by"].set(Term(DEPENDS_ON, id_))
+        self["subscribers"].set(Term(SUBSCRIPTIONS, id_))
 
 
 class TicketForm(BaseModifyForm):
     meta = TicketMetaForm
     backrefs = TicketBackRefForm
     message = OptionalMultilineText.using(label=L_("Message")).with_properties(rows=8, cols=80)
-    data_file = File.using(optional=True, label=L_('Replace content with uploaded file:'))
+    data_file = File.using(optional=True, label=L_("Replace content with uploaded file:"))
 
     def _load(self, item):
         meta = item.prepare_meta_for_modify(item.meta)
-        self['meta'].set(meta, 'duck')
+        self["meta"].set(meta, "duck")
         # XXX need a more explicit way to test for item creation/modification
         if ITEMID in item.meta:
-            self['backrefs']._load(item)
+            self["backrefs"]._load(item)
 
 
 class TicketSubmitForm(TicketForm):
@@ -152,22 +171,23 @@ def _dump(self, item):
         meta = {
             ITEMTYPE: item.itemtype,
             # XXX support other markups
-            CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8',
-            'closed': False,
+            CONTENTTYPE: "text/x.moin.wiki;charset=utf-8",
+            "closed": False,
         }
-        meta.update(self['meta'].value)
-        return meta, message_markup(self['message'].value), None, self['data_file'].value
+        meta.update(self["meta"].value)
+        return meta, message_markup(self["message"].value), None, self["data_file"].value
 
 
 class TicketUpdateForm(TicketForm):
-    submit = SelectSubmit.valued('update', 'update_negate_status')
+    submit = SelectSubmit.valued("update", "update_negate_status")
 
     def _load(self, item):
         super()._load(item)
-        self['submit'].properties['labels'] = {
-            'update': L_('Update ticket'),
-            'update_negate_status': (L_('Update & reopen ticket') if item.meta.get('closed')
-                                     else L_('Update & close ticket'))
+        self["submit"].properties["labels"] = {
+            "update": L_("Update ticket"),
+            "update_negate_status": (
+                L_("Update & reopen ticket") if item.meta.get("closed") else L_("Update & close ticket")
+            ),
         }
 
     def _dump(self, item):
@@ -177,35 +197,35 @@ def _dump(self, item):
 
         # create an "Update" comment if metadata changes
         meta_changes = []
-        for key, value in self['meta'].value.items():
+        for key, value in self["meta"].value.items():
             if not meta.get(key) == value:
                 if key == TAGS:
-                    original = ', '.join(meta.get(key))
-                    new = ', '.join(value)
+                    original = ", ".join(meta.get(key))
+                    new = ", ".join(value)
                 elif key == DEPENDS_ON or key == SUPERSEDED_BY:
                     original = meta.get(key)[:4]
                     new = value[:4]
                 else:
                     original = meta.get(key)
                     new = value
-                msg = L_('{key} changed from {original} to {new}').format(key=key, original=original, new=new)
-                meta_changes.append(' * ' + msg)
+                msg = L_("{key} changed from {original} to {new}").format(key=key, original=original, new=new)
+                meta_changes.append(" * " + msg)
         if meta_changes:
-            meta_changes = 'Meta updates:\n' + '\n'.join(meta_changes)
+            meta_changes = "Meta updates:\n" + "\n".join(meta_changes)
             create_comment(meta, meta_changes)
-        meta.update(self['meta'].value)
+        meta.update(self["meta"].value)
 
-        if self['submit'].value == 'update_negate_status':
-            meta['closed'] = not meta.get('closed')
+        if self["submit"].value == "update_negate_status":
+            meta["closed"] = not meta.get("closed")
 
         data = item.content.data_storage_to_internal(item.content.data)
-        message = self['message'].value
+        message = self["message"].value
 
         if meta_changes:
             # user changed meta, create new revision of ticket
             item.modify(meta, data)
 
-        return meta, data, message, self['data_file'].value
+        return meta, data, message, self["data_file"].value
 
 
 def message_markup(message):
@@ -213,11 +233,13 @@ def message_markup(message):
     Add a heading with author and timestamp to message (aka ticket description).
     """
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    heading = L_('{author} wrote on {timestamp}:').format(author=flaskg.user.name[0], timestamp=timestamp)
-    message = f'{heading}\n\n{message}'
+    heading = L_("{author} wrote on {timestamp}:").format(author=flaskg.user.name[0], timestamp=timestamp)
+    message = f"{heading}\n\n{message}"
     return """{{{{{{#!wiki moin-ticket
 %(message)s
-}}}}}}""" % dict(message=message)
+}}}}}}""" % dict(
+        message=message
+    )
 
 
 def check_itemid(self):
@@ -225,15 +247,15 @@ def check_itemid(self):
     if self.meta.get(ITEMID) and self.meta.get(NAME):
         query = And([Term(WIKINAME, app.cfg.interwikiname), Term(REFERS_TO, self.meta[NAME])])
         revs = flaskg.storage.search(query, limit=None)
-        prefix = self.meta[NAME][0] + '/'
+        prefix = self.meta[NAME][0] + "/"
         for rev in revs:  # TODO: if this is not dead code add a comment how to get here
             old_names = rev.meta[NAME]
             for old_name in old_names:
-                file_name = old_name[len(prefix):]
+                file_name = old_name[len(prefix) :]
                 try:
-                    new_name = self.meta[ITEMID] + '/' + file_name
+                    new_name = self.meta[ITEMID] + "/" + file_name
                     item = Item.create(new_name)
-                    item.modify({}, rev.meta[CONTENT], refers_to=self.meta[ITEMID], element='file')
+                    item.modify({}, rev.meta[CONTENT], refers_to=self.meta[ITEMID], element="file")
                     item = Item.create(old_name)
                     item._save(item.meta, name=old_name, action=ACTION_TRASH)  # delete
                 except AccessDenied:
@@ -245,14 +267,14 @@ def file_upload(self, data_file):
     data = data_file.stream
     check_itemid(self)
     if self.meta.get(ITEMID) and self.meta.get(NAME):
-        item_name = self.meta[ITEMID] + '/' + data_file.filename
+        item_name = self.meta[ITEMID] + "/" + data_file.filename
         refers_to = self.meta[ITEMID]
     else:
-        item_name = self.fqname.value + '/' + data_file.filename
+        item_name = self.fqname.value + "/" + data_file.filename
         refers_to = self.fqname.value
     try:
         item = Item.create(item_name)
-        item.modify({}, data, contenttype_guessed=contenttype, refers_to=refers_to, element='file')
+        item.modify({}, data, contenttype_guessed=contenttype, refers_to=refers_to, element="file")
     except AccessDenied:
         abort(403)
 
@@ -261,17 +283,17 @@ def get_files(self):
     check_itemid(self)
     if self.meta.get(ITEMID) and self.meta.get(NAME):
         refers_to = self.meta[ITEMID]
-        prefix = self.meta[ITEMID] + '/'
+        prefix = self.meta[ITEMID] + "/"
     else:
         refers_to = self.fqname.value
-        prefix = self.fqname.value + '/'
-    query = And([Term(WIKINAME, app.cfg.interwikiname), Term(REFERS_TO, refers_to), Term(ELEMENT, 'file')])
+        prefix = self.fqname.value + "/"
+    query = And([Term(WIKINAME, app.cfg.interwikiname), Term(REFERS_TO, refers_to), Term(ELEMENT, "file")])
     revs = flaskg.storage.search(query, limit=None)
     files = []
     for rev in revs:
         names = rev.meta[NAME]
         for name in names:
-            relname = name[len(prefix):]
+            relname = name[len(prefix) :]
             file_fqname = CompositeName(rev.meta[NAMESPACE], ITEMID, rev.meta[ITEMID])
             files.append(IndexEntry(relname, file_fqname, rev.meta))
     return files
@@ -282,7 +304,7 @@ def get_comments(self):
     Return a list of roots (comments to original ticket) and a dict of comments (comments to comments).
     """
     refers_to = self.meta[ITEMID]
-    query = And([Term(WIKINAME, app.cfg.interwikiname), Term(REFERS_TO, refers_to), Term(ELEMENT, 'comment')])
+    query = And([Term(WIKINAME, app.cfg.interwikiname), Term(REFERS_TO, refers_to), Term(ELEMENT, "comment")])
     revs = flaskg.storage.search(query, sortedby=[MTIME], limit=None)
     comments = dict()  # {rev: [],...} comments to a comment
     lookup = dict()  # {itemid: rev,...}
@@ -292,10 +314,10 @@ def get_comments(self):
         lookup[rev.meta[ITEMID]] = rev
         comments[rev] = []
     for rev in revs:
-        if not rev.meta['reply_to']:
+        if not rev.meta["reply_to"]:
             roots.append(rev)
         else:
-            parent = lookup[rev.meta['reply_to']]
+            parent = lookup[rev.meta["reply_to"]]
             comments[parent] = comments.get(parent, []) + [rev]
     return comments, roots
 
@@ -334,19 +356,27 @@ def create_comment(meta, message):
     Create a new item comment against original description, refers_to links to original.
     """
     current_timestamp = datetime.datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
-    item_name = meta[ITEMID] + '/' + 'comment_' + str(current_timestamp)
+    item_name = meta[ITEMID] + "/" + "comment_" + str(current_timestamp)
     item = Item.create(item_name)
-    item.modify({}, data=message, element='comment', contenttype_guessed='text/x.moin.wiki;charset=utf-8',
-                refers_to=meta[ITEMID], reply_to='', author=flaskg.user.name[0], timestamp=time.ctime())
+    item.modify(
+        {},
+        data=message,
+        element="comment",
+        contenttype_guessed="text/x.moin.wiki;charset=utf-8",
+        refers_to=meta[ITEMID],
+        reply_to="",
+        author=flaskg.user.name[0],
+        timestamp=time.ctime(),
+    )
 
 
 @register
 class Ticket(Contentful):
     itemtype = ITEMTYPE_TICKET
-    display_name = L_('Ticket')
-    description = L_('Ticket item')
-    submit_template = 'ticket/submit.html'
-    modify_template = 'ticket/modify.html'
+    display_name = L_("Ticket")
+    description = L_("Ticket item")
+    submit_template = "ticket/submit.html"
+    modify_template = "ticket/modify.html"
 
     def do_show(self, revid, **kwargs):
         if revid != CURRENT:
@@ -363,13 +393,13 @@ def do_modify(self):
         add a comment to a prior comment it is not processed here - see /+comment in views.py.
         """
         is_new = isinstance(self.content, NonExistentContent)
-        closed = self.meta.get('closed')
+        closed = self.meta.get("closed")
 
         Form = TicketSubmitForm if is_new else TicketUpdateForm
 
-        if request.method in ['GET', 'HEAD']:
+        if request.method in ["GET", "HEAD"]:
             form = Form.from_item(self)
-        elif request.method == 'POST':
+        elif request.method == "POST":
             form = Form.from_request(request)
             if form.validate():
                 # save new ticket revision if ticket meta has changed
@@ -389,7 +419,7 @@ def do_modify(self):
                         fqname = CompositeName(self.meta[NAMESPACE], ITEMID, self.meta[ITEMID])
                     except KeyError:
                         fqname = self.fqname
-                    return redirect(url_for('.show_item', item_name=fqname))
+                    return redirect(url_for(".show_item", item_name=fqname))
         if is_new:
             data_rendered = None
             files = {}
@@ -402,17 +432,18 @@ def do_modify(self):
         suggested_tags = get_itemtype_specific_tags(ITEMTYPE_TICKET)
         ordered_comments = []  # list of tuples [(comment, indent),,, ]
         for root in roots:
-            ordered_comments += [(root, 0), ] + build_tree(comments, root, [], 0)
-        return render_template(self.submit_template if is_new else self.modify_template,
-                               is_new=is_new,
-                               closed=closed,
-                               item_name=self.name,
-                               data_rendered=data_rendered,
-                               form=form,
-                               suggested_tags=suggested_tags,
-                               item=self,
-                               files=files,
-                               datetime=datetime.datetime,
-                               ordered_comments=ordered_comments,
-                               render_comment_data=render_comment_data,
-                               )
+            ordered_comments += [(root, 0)] + build_tree(comments, root, [], 0)
+        return render_template(
+            self.submit_template if is_new else self.modify_template,
+            is_new=is_new,
+            closed=closed,
+            item_name=self.name,
+            data_rendered=data_rendered,
+            form=form,
+            suggested_tags=suggested_tags,
+            item=self,
+            files=files,
+            datetime=datetime.datetime,
+            ordered_comments=ordered_comments,
+            render_comment_data=render_comment_data,
+        )
diff --git a/src/moin/log.py b/src/moin/log.py
index 489e88c17..bc341a275 100644
--- a/src/moin/log.py
+++ b/src/moin/log.py
@@ -117,10 +117,10 @@ def _log_warning(message, category, filename, lineno, file=None, line=None):
 
 
 def load_config(conf_fname=None):
-    """ load logging config from conffile """
+    """load logging config from conffile"""
     global configured
     err_msg = None
-    conf_fname = os.environ.get('MOINLOGGINGCONF', conf_fname)
+    conf_fname = os.environ.get("MOINLOGGINGCONF", conf_fname)
     if conf_fname:
         try:
             conf_fname = os.path.abspath(conf_fname)
@@ -147,20 +147,21 @@ def load_config(conf_fname=None):
         logger = getLogger(__name__)
         if err_msg:
             logger.warning(f'load_config for "{conf_fname}" failed with "{err_msg}".')
-        logger.debug('using logging configuration read from built-in fallback in moin.log module!')
+        logger.debug("using logging configuration read from built-in fallback in moin.log module!")
         warnings.showwarning = _log_warning
 
     import moin
+
     code_path = os.path.dirname(moin.__file__)
-    logger.debug(f'Running {moin.project} {moin.version} code from {code_path}')
+    logger.debug(f"Running {moin.project} {moin.version} code from {code_path}")
 
 
 def getLogger(name):
-    """ wrapper around logging.getLogger, so we can do some more stuff:
+    """wrapper around logging.getLogger, so we can do some more stuff:
 
-        - preprocess logger name
-        - patch loglevel constants into logger object, so it can be used
-          instead of the logging module
+    - preprocess logger name
+    - patch loglevel constants into logger object, so it can be used
+      instead of the logging module
     """
     if not configured:
         load_config()
@@ -171,11 +172,12 @@ def getLogger(name):
 
 
 class EmailHandler(logging.Handler):
-    """ A custom handler class which sends email for each logging event using
+    """A custom handler class which sends email for each logging event using
     wiki mail configuration
     """
-    def __init__(self, toaddrs=[], subject=''):
-        """ Initialize the handler
+
+    def __init__(self, toaddrs=[], subject=""):
+        """Initialize the handler
 
         :param toaddrs: address or a list of email addresses whom to send email
         :param subject: unicode email's subject
@@ -188,13 +190,14 @@ def __init__(self, toaddrs=[], subject=''):
         self.in_email_handler = False
 
     def emit(self, record):
-        """ Emit a record.
+        """Emit a record.
 
         Send the record to the specified addresses
         """
         # the app config is accessible after logging is initialized, so set the
         # arguments and make the decision to send mail or not here
         from flask import current_app as app
+
         try:
             email_tracebacks = app.cfg.email_tracebacks
         except RuntimeError:
@@ -211,9 +214,10 @@ def emit(self, record):
         try:
             toaddrs = self.toaddrs if self.toaddrs else app.cfg.admin_emails
             log_level = logging.getLevelName(self.level)
-            subject = self.subject if self.subject else f'[{app.cfg.sitename}][{log_level}] Log message'
+            subject = self.subject if self.subject else f"[{app.cfg.sitename}][{log_level}] Log message"
             msg = self.format(record)
             from moin.mail.sendmail import sendmail
+
             sendmail(subject, msg, to=toaddrs)
         finally:
             self.in_email_handler = False
diff --git a/src/moin/macros/Date.py b/src/moin/macros/Date.py
index 74e02815b..34a1bd6aa 100644
--- a/src/moin/macros/Date.py
+++ b/src/moin/macros/Date.py
@@ -24,8 +24,14 @@ def parse_time(self, args):
                      YYYY-MM-DD HH:MM:SS (same as above but replacing T separator with " ")
         :returns: UNIX timestamp (UTC)
         """
-        if (len(args) >= 19 and args[4] == '-' and args[7] == '-' and
-                args[10] in 'T ' and args[13] == ':' and args[16] == ':'):
+        if (
+            len(args) >= 19
+            and args[4] == "-"
+            and args[7] == "-"
+            and args[10] in "T "
+            and args[13] == ":"
+            and args[16] == ":"
+        ):
             try:
                 year, month, day = int(args[0:4]), int(args[5:7]), int(args[8:10])
                 hour, minute, second = int(args[11:13]), int(args[14:16]), int(args[17:19])
@@ -33,10 +39,10 @@ def parse_time(self, args):
                 tzoffset = 0  # we assume UTC no matter if there is a Z
                 if tz:
                     sign = tz[0]
-                    if sign in '+-\u2212':  # ascii plus, ascii hyphen-minus, unicode minus
+                    if sign in "+-\u2212":  # ascii plus, ascii hyphen-minus, unicode minus
                         tzh, tzm = int(tz[1:3]), int(tz[3:])
                         tzoffset = (tzh * 60 + tzm) * 60
-                        if sign in '-\u2212':  # ascii hyphen-minus, unicode minus
+                        if sign in "-\u2212":  # ascii hyphen-minus, unicode minus
                             tzoffset = -tzoffset
                 tm = year, month, day, hour, minute, second, 0, 0, 0
             except ValueError as err:
diff --git a/src/moin/macros/FontAwesome.py b/src/moin/macros/FontAwesome.py
index cb2a3172b..5d7d63e77 100644
--- a/src/moin/macros/FontAwesome.py
+++ b/src/moin/macros/FontAwesome.py
@@ -28,40 +28,40 @@ def macro(self, content, arguments, page_url, alternative):
         args = arguments[0] if arguments else ""
         if not args:
             raise ValueError("Missing font name")
-        args = args.split(',')
+        args = args.split(",")
         fonts = args[0].split()
         color = args[1].strip() if len(args) > 1 else ""
         size = args[2].strip() if len(args) > 2 else ""
 
-        if color.startswith('#'):
+        if color.startswith("#"):
             try:
                 int(color[1:], 16)
                 assert len(color) in (4, 7)
-                color = f'color: {color}; '
+                color = f"color: {color}; "
             except (ValueError, AssertionError):
                 color = ""
         else:
-            color = f'color: {color}; ' if color.isalpha() else ""
+            color = f"color: {color}; " if color.isalpha() else ""
 
         if size:
             try:
                 s = float(size)
                 assert s > 0.1
                 assert s < 99
-                size = f'font-size: {size}em;'
+                size = f"font-size: {size}em;"
             except (ValueError, AssertionError):
                 size = ""
 
         style = color + size
         classes = []
         for font in fonts:
-            f = font if font.startswith('fa-') else 'fa-' + font
+            f = font if font.startswith("fa-") else "fa-" + font
             classes.append(f)
-        if 'fa-solid' not in classes and 'fa-regular' not in classes and 'fa-brands' not in classes:
-            classes.insert(0, 'fa-solid')
-        if 'fa-spin-reverse' in classes and 'fa-spin' not in classes:
-            classes.insert(0, 'fa-spin')
-        classes = ' '.join(classes)
+        if "fa-solid" not in classes and "fa-regular" not in classes and "fa-brands" not in classes:
+            classes.insert(0, "fa-solid")
+        if "fa-spin-reverse" in classes and "fa-spin" not in classes:
+            classes.insert(0, "fa-spin")
+        classes = " ".join(classes)
 
         attrib = {moin_page.class_: classes}
         if style:
diff --git a/src/moin/macros/GetText.py b/src/moin/macros/GetText.py
index 710c900a4..da9e7da98 100644
--- a/src/moin/macros/GetText.py
+++ b/src/moin/macros/GetText.py
@@ -17,7 +17,8 @@
 
 
 class Macro(MacroInlineBase):
-    """ Return a translation of args, or args as is """
+    """Return a translation of args, or args as is"""
+
     def macro(self, content, arguments, page_url, alternative):
         translation = _(arguments[0])
         return translation
diff --git a/src/moin/macros/GetVal.py b/src/moin/macros/GetVal.py
index 669225844..86563ec5f 100644
--- a/src/moin/macros/GetVal.py
+++ b/src/moin/macros/GetVal.py
@@ -16,7 +16,7 @@
 class Macro(MacroInlineBase):
     def macro(self, content, arguments, page_url, alternative):
         try:
-            args = arguments[0].split(',')
+            args = arguments[0].split(",")
             assert len(args) == 2
             item_name = args[0].strip()
             key = args[1].strip()
@@ -28,8 +28,11 @@ def macro(self, content, arguments, page_url, alternative):
             d = flaskg.dicts[item_name]
         except DictDoesNotExistError:
             raise ValueError(_("GetVal: dict not found: ") + item_name)
-        result = d.get(key, '')
+        result = d.get(key, "")
         if not result:
-            raise ValueError(_('GetVal macro is invalid, {item_name} missing key: {key_name}'
-                               ).format(item_name=item_name, key_name=key))
+            raise ValueError(
+                _("GetVal macro is invalid, {item_name} missing key: {key_name}").format(
+                    item_name=item_name, key_name=key
+                )
+            )
         return result
diff --git a/src/moin/macros/HighlighterList.py b/src/moin/macros/HighlighterList.py
index 744db8e55..f3487c158 100644
--- a/src/moin/macros/HighlighterList.py
+++ b/src/moin/macros/HighlighterList.py
@@ -16,11 +16,7 @@
 
 class Macro(MacroBlockBase):
     def macro(self, content, arguments, page_url, alternative):
-        headings = (_('Lexer Name'),
-                    _('Lexer Aliases'),
-                    _('File Patterns'),
-                    _('Mimetypes'),
-                    )
+        headings = (_("Lexer Name"), _("Lexer Aliases"), _("File Patterns"), _("Mimetypes"))
         rows = list(pygments.lexers.get_all_lexers())
         rows.sort(key=lambda t: tuple(t[0].lower()))
         # Prevent traceback in converters/highlight.py when
@@ -28,5 +24,5 @@ def macro(self, content, arguments, page_url, alternative):
         # A row above consists of [str, tuple, tuple, tuple] where singular tuples contain strings
         pretty_rows = [[str(col) for col in row] for row in rows]
         table = TableMixin()
-        ret = table.build_dom_table(pretty_rows, head=headings, cls='moin-sortable')
+        ret = table.build_dom_table(pretty_rows, head=headings, cls="moin-sortable")
         return ret
diff --git a/src/moin/macros/Icon.py b/src/moin/macros/Icon.py
index 1026e6683..d77dedc0d 100644
--- a/src/moin/macros/Icon.py
+++ b/src/moin/macros/Icon.py
@@ -20,10 +20,10 @@
 
 class Macro(MacroInlineBase):
     def macro(self, content, arguments, page_url, alternative):
-        icon = arguments[0] if arguments else ''
+        icon = arguments[0] if arguments else ""
         if not icon:
             raise ValueError("Missing icon name")
-        src = url_for('static', filename='img/icons/' + icon)
-        reason = _('Icon not rendered, verify name is valid')
-        alt = f'<<Icon({icon})>> - {reason}'
-        return html.img(attrib={html.src: src, html.alt: alt, html.class_: 'moin-icon-macro'})
+        src = url_for("static", filename="img/icons/" + icon)
+        reason = _("Icon not rendered, verify name is valid")
+        alt = f"<<Icon({icon})>> - {reason}"
+        return html.img(attrib={html.src: src, html.alt: alt, html.class_: "moin-icon-macro"})
diff --git a/src/moin/macros/ItemList.py b/src/moin/macros/ItemList.py
index 26e3d9561..9809483b5 100644
--- a/src/moin/macros/ItemList.py
+++ b/src/moin/macros/ItemList.py
@@ -84,13 +84,17 @@ def macro(self, content, arguments, page_url, alternative):
         # process input
         args = []
         if arguments:
-            args = arguments[0].split(',')
+            args = arguments[0].split(",")
         for arg in args:
             try:
-                key, val = (x.strip() for x in arg.split('='))
+                key, val = (x.strip() for x in arg.split("="))
             except ValueError:
-                raise ValueError(_('ItemList macro: Argument "{arg}" does not follow <key>=<val> format '
-                                   '(arguments, if more than one, must be comma-separated).').format(arg=arg))
+                raise ValueError(
+                    _(
+                        'ItemList macro: Argument "{arg}" does not follow <key>=<val> format '
+                        "(arguments, if more than one, must be comma-separated)."
+                    ).format(arg=arg)
+                )
 
             if len(val) < 2 or (val[0] != "'" and val[0] != '"') and val[-1] != val[0]:
                 raise ValueError(_("ItemList macro: The key's value must be bracketed by matching quotes."))
@@ -108,7 +112,9 @@ def macro(self, content, arguments, page_url, alternative):
                 elif val == "True":
                     ordered = True
                 else:
-                    raise ValueError(_('ItemList macro: The value must be "True" or "False". (got "{val}")').format(val=val))
+                    raise ValueError(
+                        _('ItemList macro: The value must be "True" or "False". (got "{val}")').format(val=val)
+                    )
             elif key == "display":
                 display = val  # let 'create_pagelink_list' throw an exception if needed
             elif key == "skiptag":
@@ -119,15 +125,16 @@ def macro(self, content, arguments, page_url, alternative):
         # use curr item if not specified
         if item is None:
             item = request.path[1:]
-            if item.startswith('+modify/'):
-                item = item.split('/', 1)[1]
+            if item.startswith("+modify/"):
+                item = item.split("/", 1)[1]
 
         # verify item exists and current user has read permission
         if item != "":
             if not flaskg.storage.get_item(**(split_fqname(item).query)):
-                message = _('Item does not exist or read access blocked by ACLs: {0}').format(item)
-                admonition = moin_page.div(attrib={moin_page.class_: 'important'},
-                                           children=[moin_page.p(children=[message])])
+                message = _("Item does not exist or read access blocked by ACLs: {0}").format(item)
+                admonition = moin_page.div(
+                    attrib={moin_page.class_: "important"}, children=[moin_page.p(children=[message])]
+                )
                 return admonition
 
         # process subitems
@@ -143,7 +150,7 @@ def macro(self, content, arguments, page_url, alternative):
                     newlist.append(child)
             children = newlist
         if not children:
-            empty_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and 'ordered' or 'unordered'})
+            empty_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and "ordered" or "unordered"})
             item_body = moin_page.list_item_body(children=[_("<ItemList macro: No matching items were found.>")])
             item = moin_page.list_item(children=[item_body])
             empty_list.append(item)
diff --git a/src/moin/macros/MailTo.py b/src/moin/macros/MailTo.py
index 2c25656e5..fa5960019 100644
--- a/src/moin/macros/MailTo.py
+++ b/src/moin/macros/MailTo.py
@@ -22,7 +22,7 @@ def macro(self, content, arguments, page_url, alternative):
         where 2nd parameter is optional.
         """
         if arguments:
-            arguments = arguments[0].split(',')
+            arguments = arguments[0].split(",")
         try:
             assert len(arguments) > 0 and len(arguments) < 3
             email = arguments[0]
@@ -33,12 +33,12 @@ def macro(self, content, arguments, page_url, alternative):
         try:
             text = arguments[1]
         except IndexError:
-            text = ''
+            text = ""
 
         if flaskg.user.valid:
             # decode address and generate mailto: link
             email = decodeSpamSafeEmail(email)
-            result = moin_page.a(attrib={xlink.href: f'mailto:{email}'}, children=[text or email])
+            result = moin_page.a(attrib={xlink.href: f"mailto:{email}"}, children=[text or email])
         else:
             # unknown user, maybe even a spambot, so just return text as given in macro args
             if text:
diff --git a/src/moin/macros/MonthCalendar.py b/src/moin/macros/MonthCalendar.py
index d07039b00..72141bd41 100644
--- a/src/moin/macros/MonthCalendar.py
+++ b/src/moin/macros/MonthCalendar.py
@@ -99,7 +99,7 @@ def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
     """
     table = moin_page.table()
     if cls is not None:
-        table.attrib[moin_page('class')] = cls
+        table.attrib[moin_page("class")] = cls
 
     if caption is not None:
         table_caption = moin_page.caption()
@@ -112,7 +112,7 @@ def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
         for _idx, cell_tuple in enumerate(head):
             (cell, cell_class) = cell_tuple
             table_cell = moin_page.table_cell(children=[cell])
-            table_cell.attrib[moin_page('class')] = cell_class
+            table_cell.attrib[moin_page("class")] = cell_class
             table_row.append(table_cell)
         table_head.append(table_row)
         table.append(table_head)
@@ -130,14 +130,14 @@ def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
             # empty cell
             if not cell_addr:
                 table_cell = moin_page.table_cell(children=[cell])
-                table_cell.attrib[moin_page('class')] = cell_class
+                table_cell.attrib[moin_page("class")] = cell_class
 
             # cell with link to calendar
             else:
-                iri = Iri(scheme='wiki', path='/' + cell_addr)
+                iri = Iri(scheme="wiki", path="/" + cell_addr)
                 table_a = moin_page.a(attrib={xlink.href: iri}, children=[cell])
                 table_cell = moin_page.table_cell(children=[table_a])
-                table_cell.attrib[moin_page('class')] = cell_class
+                table_cell.attrib[moin_page("class")] = cell_class
             table_row.append(table_cell)
         table_body.append(table_row)
     table.append(table_body)
@@ -145,7 +145,7 @@ def build_dom_calendar_table(rows, head=None, caption=None, cls=None):
 
 
 def yearmonthplusoffset(year, month, offset):
-    """ calculate new year/month from year/month and offset """
+    """calculate new year/month from year/month and offset"""
     month += offset
     # handle offset and under/overflows - quick and dirty, yes!
     while month < 1:
@@ -158,31 +158,32 @@ def yearmonthplusoffset(year, month, offset):
 
 
 def parseargs(args, defpagename, defyear, defmonth, defoffset, defheight6, defanniversary):
-    """ parse macro arguments """
+    """parse macro arguments"""
     _, args, _ = paramparser.parse_quoted_separated(args)
-    parmpagename = paramparser.get_str(args.get('item'), 'item', defpagename)
-    parmyear = paramparser.get_int(args.get('year'), 'year', defyear)
-    parmmonth = paramparser.get_int(args.get('month'), 'month', defmonth)
-    parmoffset = paramparser.get_int(args.get('month_offset'), 'month_offset', defoffset)
-    parmheight6 = paramparser.get_bool(args.get('fixed_height'), 'fixed_height', defheight6)
-    parmanniversary = paramparser.get_bool(args.get('anniversary'), 'anniversary', defanniversary)
+    parmpagename = paramparser.get_str(args.get("item"), "item", defpagename)
+    parmyear = paramparser.get_int(args.get("year"), "year", defyear)
+    parmmonth = paramparser.get_int(args.get("month"), "month", defmonth)
+    parmoffset = paramparser.get_int(args.get("month_offset"), "month_offset", defoffset)
+    parmheight6 = paramparser.get_bool(args.get("fixed_height"), "fixed_height", defheight6)
+    parmanniversary = paramparser.get_bool(args.get("anniversary"), "anniversary", defanniversary)
 
     # multiple pagenames separated by "*" - split into list of pagenames
-    parmpagename = re.split(r'\*', parmpagename)
+    parmpagename = re.split(r"\*", parmpagename)
 
     return parmpagename, parmyear, parmmonth, parmoffset, parmheight6, parmanniversary
 
 
 class Macro(MacroInlineBase):
-    ''' return a table with a month calendar '''
+    """return a table with a month calendar"""
+
     def macro(self, content, arguments, page_url, alternative):
 
         # find page name of current page
         # to be able to use it as a default page name
         this_page = request.path[1:]
 
-        if this_page.startswith('+modify/'):
-            this_page = this_page.split('/', 1)[1]
+        if this_page.startswith("+modify/"):
+            this_page = this_page.split("/", 1)[1]
 
         # get arguments from the macro if available,
         # arguments will be None for <<MonthCalendar>>
@@ -197,8 +198,9 @@ def macro(self, content, arguments, page_url, alternative):
 
         # parse and check arguments,
         # set default values if necessary
-        parmpagename, parmyear, parmmonth, parmoffset, parmheight6, anniversary = \
-            parseargs(args, this_page, currentyear, currentmonth, 0, False, False)
+        parmpagename, parmyear, parmmonth, parmoffset, parmheight6, anniversary = parseargs(
+            args, this_page, currentyear, currentmonth, 0, False, False
+        )
 
         year, month = yearmonthplusoffset(parmyear, parmmonth, parmoffset)
 
@@ -206,16 +208,27 @@ def macro(self, content, arguments, page_url, alternative):
         monthcal = calendar.monthcalendar(year, month)
 
         # european / US differences
-        months = (_('January'), _('February'), _('March'), _('April'),
-                  _('May'), _('June'), _('July'), _('August'),
-                  _('September'), _('October'), _('November'), _('December'))
+        months = (
+            _("January"),
+            _("February"),
+            _("March"),
+            _("April"),
+            _("May"),
+            _("June"),
+            _("July"),
+            _("August"),
+            _("September"),
+            _("October"),
+            _("November"),
+            _("December"),
+        )
         # Set things up for Monday or Sunday as the first day of the week
         if calendar.firstweekday() == calendar.MONDAY:
             wkend = (5, 6)
-            wkdays = (_('Mon'), _('Tue'), _('Wed'), _('Thu'), _('Fri'), _('Sat'), _('Sun'))
+            wkdays = (_("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun"))
         if calendar.firstweekday() == calendar.SUNDAY:
             wkend = (0, 6)
-            wkdays = (_('Sun'), _('Mon'), _('Tue'), _('Wed'), _('Thu'), _('Fri'), _('Sat'))
+            wkdays = (_("Sun"), _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"))
 
         calcaption = f"{months[month - 1]} {year}"
         calhead = []
@@ -244,13 +257,13 @@ def macro(self, content, arguments, page_url, alternative):
             calweek = []
             for wkday in r7:
                 day = week[wkday]
-                day_addr = ''
-                day_class = 'cal-emptyday'
+                day_addr = ""
+                day_class = "cal-emptyday"
                 if not day:
                     # '\xa0' is a non-breaking space (just like &nbsp;
                     # in html) to make sure empty cells have the same
                     # height as rows with content
-                    calweek.append(('\xa0', None, 'cal-invalidday'))
+                    calweek.append(("\xa0", None, "cal-invalidday"))
                 else:
                     # we only process the first calendar (or item name)
                     # mentioned in the macro parameters (in case separate
@@ -272,5 +285,5 @@ def macro(self, content, arguments, page_url, alternative):
                     calweek.append((str(day), day_addr, day_class))
             calrows.append(calweek)
 
-        ret = build_dom_calendar_table(rows=calrows, head=calhead, caption=calcaption, cls='calendar')
+        ret = build_dom_calendar_table(rows=calrows, head=calhead, caption=calcaption, cls="calendar")
         return ret
diff --git a/src/moin/macros/RandomItem.py b/src/moin/macros/RandomItem.py
index b560c87ca..b6c18196f 100644
--- a/src/moin/macros/RandomItem.py
+++ b/src/moin/macros/RandomItem.py
@@ -53,7 +53,7 @@ def macro(self, content, arguments, page_url, alternative):
 
         result = moin_page.span()
         for name in random_item_names:
-            link = str(Iri(scheme='wiki', authority='', path='/' + name))
+            link = str(Iri(scheme="wiki", authority="", path="/" + name))
             result.append(moin_page.a(attrib={xlink.href: link}, children=[name]))
             result.append(", ")
 
diff --git a/src/moin/macros/ShowIcons.py b/src/moin/macros/ShowIcons.py
index f7b0c42d0..6e55f4b73 100644
--- a/src/moin/macros/ShowIcons.py
+++ b/src/moin/macros/ShowIcons.py
@@ -24,14 +24,14 @@
 class Macro(MacroBlockBase):
     def macro(self, content, arguments, page_url, alternative):
         my_dir = os.path.abspath(os.path.dirname(__file__))
-        icon_dir = os.path.join(os.path.split(my_dir)[0], 'static', 'img', 'icons')
+        icon_dir = os.path.join(os.path.split(my_dir)[0], "static", "img", "icons")
 
-        headings = (_('Markup'), _('Result'))
+        headings = (_("Markup"), _("Result"))
         files = [f for f in listdir(icon_dir) if isfile(join(icon_dir, f))]
         rows = []
         for filename in files:
-            markup = f'<<Icon({filename})>>'
-            src = url_for('static', filename='img/icons/' + filename)
+            markup = f"<<Icon({filename})>>"
+            src = url_for("static", filename="img/icons/" + filename)
             # TODO: add alt attribute for img and add a macro test module
             # reason = _('Icon not rendered, verify name is valid')
             # alt = '<<Icon({0})>> - {1}'.format(filename, reason)
diff --git a/src/moin/macros/ShowSmileys.py b/src/moin/macros/ShowSmileys.py
index fe4fed40e..429fd3cf3 100644
--- a/src/moin/macros/ShowSmileys.py
+++ b/src/moin/macros/ShowSmileys.py
@@ -17,11 +17,11 @@
 class Macro(MacroBlockBase):
     def macro(self, content, arguments, page_url, alternative):
         smileys = Converter.smileys
-        headings = (_('Markup'), _('Result'), _('Name'))
+        headings = (_("Markup"), _("Result"), _("Name"))
         rows = []
         for key in smileys.keys():
             icon_name = smileys[key]
-            src = url_for('static', filename='img/icons/' + icon_name + ".png")
+            src = url_for("static", filename="img/icons/" + icon_name + ".png")
             rows.append((key, html.img(attrib={html.src: src, html.alt: icon_name}), icon_name))
         table = TableMixin()
         ret = table.build_dom_table(rows, head=headings)
diff --git a/src/moin/macros/TitleIndex.py b/src/moin/macros/TitleIndex.py
index 343a8b45b..380819bba 100644
--- a/src/moin/macros/TitleIndex.py
+++ b/src/moin/macros/TitleIndex.py
@@ -27,7 +27,7 @@ def macro(self, content, arguments, page_url, alternative):
 
         children = get_item_names(namespace)
         if not children:
-            empty_list = moin_page.list(attrib={moin_page.item_label_generate: 'unordered'})
+            empty_list = moin_page.list(attrib={moin_page.item_label_generate: "unordered"})
             item_body = moin_page.list_item_body(children=[_("<TitleList macro: No matching items were found.>")])
             empty_list.append(moin_page.list_item(children=[item_body]))
             return empty_list
diff --git a/src/moin/macros/_base.py b/src/moin/macros/_base.py
index e7bcbba5a..94984cb77 100644
--- a/src/moin/macros/_base.py
+++ b/src/moin/macros/_base.py
@@ -19,7 +19,7 @@
 from moin.constants.keys import TAGS
 
 
-def get_item_names(name='', startswith='', kind='files', skiptag=''):
+def get_item_names(name="", startswith="", kind="files", skiptag=""):
     """
     For the specified item, return the fullname of matching descendents.
 
@@ -70,8 +70,8 @@ def extract_h1(item_name):
     """
     item = Item.create(item_name, rev_id=CURRENT)
     contenttype = item.meta[CONTENTTYPE]
-    if 'x.moin.wiki' not in contenttype and 'x.moin.creole' not in contenttype:
-        return _('{item_name} content type is not moinwiki or creole').format(item_name=item_name)
+    if "x.moin.wiki" not in contenttype and "x.moin.creole" not in contenttype:
+        return _("{item_name} content type is not moinwiki or creole").format(item_name=item_name)
     item.rev.data.seek(0)
     content = item.rev.data.read()
     content = content.decode("utf-8")
@@ -79,19 +79,19 @@ def extract_h1(item_name):
     for line in lines:
         line = line.rstrip()
         if line:
-            if line.startswith('=') and line.endswith('='):
-                title = line.replace('=', '').strip()
+            if line.startswith("=") and line.endswith("="):
+                title = line.replace("=", "").strip()
                 return title
-    return _('No heading found in item: {item_name}').format(item_name=item_name)
+    return _("No heading found in item: {item_name}").format(item_name=item_name)
 
 
-def fail_message(msg, severity='error'):
+def fail_message(msg, severity="error"):
     """
     Return an error message in admonition-like format.
 
     Severity may be: attention, caution, danger, error, hint, important, note, or tip.
     """
-    return html.div(attrib={html.class_: f'{severity} moin-nowiki'}, children=msg)
+    return html.div(attrib={html.class_: f"{severity} moin-nowiki"}, children=msg)
 
 
 class MacroBase:
@@ -115,6 +115,7 @@ class MacroBlockBase(MacroBase):
 
     The macro gets only expanded in block context.
     """
+
     def __call__(self, content, arguments, page_url, alternative, context_block):
         if context_block:
             return self.macro(content, arguments, page_url, alternative)
@@ -130,10 +131,11 @@ class MacroInlineBase(MacroBase):
 
     The macro is wrapped into a div in block context.
     """
+
     def __call__(self, content, arguments, page_url, alternative, context_block):
         ret = self.macro(content, arguments, page_url, alternative)
         if context_block:
-            return moin_page.div(children=(ret, ))
+            return moin_page.div(children=(ret,))
         return ret
 
 
@@ -144,6 +146,7 @@ class MacroInlineOnlyBase(MacroBase):
     The macro is only expanded in inline context. In block context it expands
     to nothing.
     """
+
     def __call__(self, content, arguments, page_url, alternative, context_block):
         if not context_block:
             return self.macro(content, arguments, page_url, alternative)
@@ -151,53 +154,53 @@ def __call__(self, content, arguments, page_url, alternative, context_block):
 
 class MacroPageLinkListBase(MacroBlockBase):
     def create_pagelink_list(self, pagenames, ordered=False, display="FullPath"):
-        """ Creates an ET with a list of pagelinks from a list of pagenames.
+        """Creates an ET with a list of pagelinks from a list of pagenames.
 
-            Parameters:
+        Parameters:
 
-              pagenames: a list of pages, each being like a flask request.path[1:]
+          pagenames: a list of pages, each being like a flask request.path[1:]
 
-              ordered: Should the list be ordered or unordered list (<ol> or <ul>)?
+          ordered: Should the list be ordered or unordered list (<ol> or <ul>)?
 
-                  Options:
-                      False : Display list as an unordered list.  (default)
-                      True  : Display list as an ordered list.
+              Options:
+                  False : Display list as an unordered list.  (default)
+                  True  : Display list as an ordered list.
 
-              display: How should the link be displayed?
+          display: How should the link be displayed?
 
-                  Options:
-                      FullPath  : The full page path (default)
-                      ChildPath : The last component of the FullPath, including the '/'
-                      ChildName : ChildPath, but minus the leading '/'
-                      UnCameled : ChildName, but with a space ' ' character between
-                                  blocks of lowercase characters or numbers and an
-                                  uppercase character.
-                      skiptag   : skip items with this tag
-                      ItemTitle : Use the title from the first header in the linked page
+              Options:
+                  FullPath  : The full page path (default)
+                  ChildPath : The last component of the FullPath, including the '/'
+                  ChildName : ChildPath, but minus the leading '/'
+                  UnCameled : ChildName, but with a space ' ' character between
+                              blocks of lowercase characters or numbers and an
+                              uppercase character.
+                  skiptag   : skip items with this tag
+                  ItemTitle : Use the title from the first header in the linked page
         """
 
-        page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and 'ordered' or 'unordered'})
+        page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and "ordered" or "unordered"})
 
         for pagename in pagenames:
 
             fqname = pagename.fullname
             # This link can never reach pagelinks
-            url = str(iri.Iri(scheme='wiki', authority='', path='/' + fqname))
+            url = str(iri.Iri(scheme="wiki", authority="", path="/" + fqname))
 
             if display == "FullPath":
                 linkname = pagename
             elif display == "ChildPath":
-                index = fqname.rfind('/')
+                index = fqname.rfind("/")
                 if index == -1:
                     linkname = fqname
                 else:
                     linkname = fqname[index:]
             elif display == "ChildName":
-                index = fqname.rfind('/')
-                linkname = fqname[(index + 1):]
+                index = fqname.rfind("/")
+                linkname = fqname[(index + 1) :]
             elif display == "UnCameled":
-                index = fqname.rfind('/')
-                tempname = re.sub("([a-z0-9])([A-Z])", r"\g<1> \g<2>", fqname[(index + 1):])  # space before a cap char
+                index = fqname.rfind("/")
+                tempname = re.sub("([a-z0-9])([A-Z])", r"\g<1> \g<2>", fqname[(index + 1) :])  # space before a cap char
                 linkname = re.sub("([a-zA-Z])([0-9])", r"\g<1> \g<2>", tempname)
             elif display == "ItemTitle":
                 linkname = extract_h1(pagename.fullname)
@@ -214,49 +217,53 @@ def create_pagelink_list(self, pagenames, ordered=False, display="FullPath"):
 
 class MacroMultiLinkListBase(MacroBlockBase):
     def create_multi_pagelink_list(self, itemnames, namespace):
-        """ Creates an ET with a list of itemlinks from a list of itemnames
-            grouped by initials.
+        """Creates an ET with a list of itemlinks from a list of itemnames
+        grouped by initials.
 
-            Parameters:
+        Parameters:
 
-              itemnames: a list of items, each being like a flask request.path[1:]
+          itemnames: a list of items, each being like a flask request.path[1:]
 
-              namespace: Namespace of items
+          namespace: Namespace of items
         """
         result_body = []
         initials_linklist = []
-        initial_letter = ' '
+        initial_letter = " "
 
-        if namespace == '':
-            namespace_name = _("Namespace '{name}' ").format(name='default')
+        if namespace == "":
+            namespace_name = _("Namespace '{name}' ").format(name="default")
             pos_namespace_cut = 0
         else:
             namespace_name = _("Namespace '{name}' ").format(name=namespace)
             pos_namespace_cut = len(namespace) + 1
 
-        item_list = moin_page.list(attrib={moin_page.item_label_generate: 'unordered'})
-        initials_link = moin_page.a(attrib={xlink.href: '#idx-top'}, children=['top', ])
-        initials_linklist.extend([initials_link, moin_page.strong(children=[' | ', ])])
+        item_list = moin_page.list(attrib={moin_page.item_label_generate: "unordered"})
+        initials_link = moin_page.a(attrib={xlink.href: "#idx-top"}, children=["top"])
+        initials_linklist.extend([initials_link, moin_page.strong(children=[" | "])])
 
         for itemname in itemnames:
             if not itemname.value.startswith(initial_letter):
                 # generate header line with initial
                 initial_letter = itemname.value[0]
                 result_body.append(item_list)  # finish item_list for last initial and initialize new item_list
-                item_list = moin_page.list(attrib={moin_page.item_label_generate: 'unordered'})
+                item_list = moin_page.list(attrib={moin_page.item_label_generate: "unordered"})
 
                 header_with_anchor = moin_page.span(
-                    attrib={moin_page.class_: "moin-big", moin_page.id: 'idx-' + initial_letter},
-                    children=[initial_letter,
-                              moin_page.a(attrib={moin_page.class_: "moin-align-right", xlink.href: '#idx-top'},
-                                          children=['^', ])])
+                    attrib={moin_page.class_: "moin-big", moin_page.id: "idx-" + initial_letter},
+                    children=[
+                        initial_letter,
+                        moin_page.a(
+                            attrib={moin_page.class_: "moin-align-right", xlink.href: "#idx-top"}, children=["^"]
+                        ),
+                    ],
+                )
                 result_body.append(header_with_anchor)
-                initials_link = moin_page.a(attrib={xlink.href: '#idx-' + initial_letter}, children=[initial_letter])
-                initials_linklist.extend([initials_link, moin_page.strong(children=[' | ',])])
+                initials_link = moin_page.a(attrib={xlink.href: "#idx-" + initial_letter}, children=[initial_letter])
+                initials_linklist.extend([initials_link, moin_page.strong(children=[" | "])])
 
             # build and add itemname link
             fqname = itemname.fullname
-            url = str(iri.Iri(scheme='wiki', authority='', path='/' + fqname))
+            url = str(iri.Iri(scheme="wiki", authority="", path="/" + fqname))
             linkname = fqname[pos_namespace_cut:]
             pagelink = moin_page.a(attrib={xlink.href: url}, children=[linkname])
             item_body = moin_page.list_item_body(children=[pagelink])
@@ -266,26 +273,29 @@ def create_multi_pagelink_list(self, itemnames, namespace):
         result_body.append(item_list)  # finish item_list for last initial
 
         # Add a list of links for each used initial at top and bottom of the index
-        initials_begin = moin_page.span(attrib={moin_page.id: "idx-top", moin_page.class_: "moin-align-left"},
-                                        children=[_("Index of {what}").format(what=namespace_name), ])
-        initials_link_end = moin_page.a(attrib={xlink.href: '#idx-bottom'}, children=['bottom', ])
+        initials_begin = moin_page.span(
+            attrib={moin_page.id: "idx-top", moin_page.class_: "moin-align-left"},
+            children=[_("Index of {what}").format(what=namespace_name)],
+        )
+        initials_link_end = moin_page.a(attrib={xlink.href: "#idx-bottom"}, children=["bottom"])
         initials_linklist.append(initials_link_end)
         initials_links_span = moin_page.span(attrib={moin_page.class_: "moin-align-right"}, children=initials_linklist)
         result_body.insert(0, moin_page.p(children=[initials_begin, initials_links_span]))
         initials_end = moin_page.span(
-            attrib={moin_page.id: "idx-bottom", moin_page.class_: "moin-align-left"}, children=".")
+            attrib={moin_page.id: "idx-bottom", moin_page.class_: "moin-align-left"}, children="."
+        )
         result_body.append(moin_page.p(children=[initials_end, initials_links_span]))
         return moin_page.body(children=result_body)
 
 
 class MacroNumberPageLinkListBase(MacroBlockBase):
     def create_number_pagelink_list(self, num_pagenames, ordered=False):
-        """ creates an ET with a list of pagelinks from a list of pagenames """
-        num_page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and 'ordered' or 'unordered'})
+        """creates an ET with a list of pagelinks from a list of pagenames"""
+        num_page_list = moin_page.list(attrib={moin_page.item_label_generate: ordered and "ordered" or "unordered"})
         for num, pagename in num_pagenames:
             num_code = moin_page.code(children=[f"{num:6d} "])
             # This link can never reach pagelinks
-            url = str(iri.Iri(scheme='wiki', authority='', path='/' + pagename))
+            url = str(iri.Iri(scheme="wiki", authority="", path="/" + pagename))
             pagelink = moin_page.a(attrib={xlink.href: url}, children=[pagename])
             item_body = moin_page.list_item_body(children=[num_code, pagelink])
             item = moin_page.list_item(children=[item_body])
@@ -295,7 +305,7 @@ def create_number_pagelink_list(self, num_pagenames, ordered=False):
 
 class MacroDefinitionListBase(MacroBlockBase):
     def create_definition_list(self, items):
-        """ creates an ET with a definition list made from items """
+        """creates an ET with a definition list made from items"""
         def_list = moin_page.list()
         for label, body in items:
             item_label = moin_page.list_item_label(children=[label])
diff --git a/src/moin/macros/_tests/test_Anchor.py b/src/moin/macros/_tests/test_Anchor.py
index 4ff22cb59..4dded9ac2 100644
--- a/src/moin/macros/_tests/test_Anchor.py
+++ b/src/moin/macros/_tests/test_Anchor.py
@@ -13,10 +13,10 @@
 def test_Macro():
     macro_obj = Macro()
     with pytest.raises(ValueError):
-        macro_obj.macro('content', None, 'page_url', 'alternative')
+        macro_obj.macro("content", None, "page_url", "alternative")
 
-    arguments = [('test_argument1', 'test_argument2'), 'test_argument3']
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
+    arguments = [("test_argument1", "test_argument2"), "test_argument3"]
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
     test_anchor = list(result.attrib.values())
     # test_anchor[0] since it returns a list
     assert test_anchor[0] == arguments[0]
diff --git a/src/moin/macros/_tests/test_Date.py b/src/moin/macros/_tests/test_Date.py
index 83055e93e..926f271e8 100644
--- a/src/moin/macros/_tests/test_Date.py
+++ b/src/moin/macros/_tests/test_Date.py
@@ -19,51 +19,51 @@
 class TestMacroDateTimeBase:
     def test_parse_time(self):
         MacroDateTimeBase_obj = MacroDateTimeBase()
-        test_time_args = '2023-08-07T11:11:11+0533'
+        test_time_args = "2023-08-07T11:11:11+0533"
         ts = MacroDateTimeBase_obj.parse_time(test_time_args)
         expected = 1691386691.0
         assert ts == expected
 
         result = format_date_time(datetime.utcfromtimestamp(ts))
-        expected = '2023-08-07 05:38:11z'
+        expected = "2023-08-07 05:38:11z"
         assert result == expected
 
         flaskg.user.valid = True  # show_time creates ISO 8601 dates if user is not logged in
         result = format_date_time(datetime.utcfromtimestamp(ts))
-        expected = ['Aug 7, 2023, 5:38:11\u202fAM', 'Aug 7, 2023, 5:38:11 AM', ]  # TODO: remove 2nd entry later
+        expected = ["Aug 7, 2023, 5:38:11\u202fAM", "Aug 7, 2023, 5:38:11 AM"]  # TODO: remove 2nd entry later
         assert result in expected
 
         with pytest.raises(ValueError):
             # things after next 10,000 years can't be predicted
-            MacroDateTimeBase_obj.parse_time('12011-08-07T11:11:11')
+            MacroDateTimeBase_obj.parse_time("12011-08-07T11:11:11")
 
 
 class TestMacro:
     def test_macro(self):
         flaskg.user.valid = True  # show_time creates ISO 8601 dates if user is not logged in
-        flaskg.user.timezone = 'GMT'
-        flaskg.user.locale = 'en'
+        flaskg.user.timezone = "GMT"
+        flaskg.user.locale = "en"
         flaskg.user.iso_8601 = False
 
         macro_obj = Macro()
         # when arguments is None
-        result = macro_obj.macro('content', None, 'page_url', 'alternative')
+        result = macro_obj.macro("content", None, "page_url", "alternative")
         test_time = time.time()
         test_time = format_date(datetime.utcfromtimestamp(test_time))
         assert result == test_time
 
-        arguments = ['2023-08-07T11:11:11+0533', 'argument2']
-        result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-        expected = 'Aug 7, 2023'
+        arguments = ["2023-08-07T11:11:11+0533", "argument2"]
+        result = macro_obj.macro("content", arguments, "page_url", "alternative")
+        expected = "Aug 7, 2023"
         assert result == expected
 
-        flaskg.user.timezone = 'UTC'
+        flaskg.user.timezone = "UTC"
         flaskg.user.iso_8601 = True
-        result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-        expected = '2023-08-07z'
+        result = macro_obj.macro("content", arguments, "page_url", "alternative")
+        expected = "2023-08-07z"
         assert result == expected
 
-        flaskg.user.timezone = 'America/Phoenix'
-        result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-        expected = '2023-08-07'
+        flaskg.user.timezone = "America/Phoenix"
+        result = macro_obj.macro("content", arguments, "page_url", "alternative")
+        expected = "2023-08-07"
         assert result == expected
diff --git a/src/moin/macros/_tests/test_DateTime.py b/src/moin/macros/_tests/test_DateTime.py
index 513869289..9c2c59026 100644
--- a/src/moin/macros/_tests/test_DateTime.py
+++ b/src/moin/macros/_tests/test_DateTime.py
@@ -18,39 +18,40 @@
 
 
 def test_Macro():
-    """Test: DateTime.Macro """
+    """Test: DateTime.Macro"""
     flaskg.user.valid = True  # show_time creates ISO 8601 dates if user is not logged in
     macro_obj = Macro()
     # when arguments is None
-    result = macro_obj.macro('content', None, 'page_url', 'alternative')
+    result = macro_obj.macro("content", None, "page_url", "alternative")
     # get the current time
     test_time = time.time()
     test_times = [test_time, test_time - 1]  # in case our call to time.time happened just after the second rolled over
     test_times = [format_date_time(datetime.utcfromtimestamp(t)) for t in test_times]
     assert result in test_times
 
-    arguments = ['2023-08-07T11:11:11', 'argument2']
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-    expected = ['Aug 7, 2023, 11:11:11\u202fAM', 'Aug 7, 2023, 11:11:11 AM', ]  # TODO: remove 2nd entry later
+    arguments = ["2023-08-07T11:11:11", "argument2"]
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
+    expected = ["Aug 7, 2023, 11:11:11\u202fAM", "Aug 7, 2023, 11:11:11 AM"]  # TODO: remove 2nd entry later
     assert result in expected
 
     flaskg.user.valid = False
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-    expected = '2023-08-07 11:11:11z'
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
+    expected = "2023-08-07 11:11:11z"
     assert result == expected
 
-    arguments = ['incorrect_argument']
+    arguments = ["incorrect_argument"]
     with pytest.raises(ValueError):
-        macro_obj.macro('content', arguments, 'page_url', 'alternative')
+        macro_obj.macro("content", arguments, "page_url", "alternative")
 
     # the following are different ways to specify the same moment
-    expected = '2019-10-07 18:30:00z'
-    arguments = ['2019-10-07T18:30:00Z'
-                 '2019-10-07T22:30:00+0400',
-                 '2019-10-07 11:30:00-0700',  # ascii hyphen-minus
-                 '2019-10-07T15:00:00-0330',
-                 '2019-10-07 11:30:00\u22120700',  # unicode minus \u2212
-                 '2019-10-07T15:00:00\u22120330', ]
+    expected = "2019-10-07 18:30:00z"
+    arguments = [
+        "2019-10-07T18:30:00Z" "2019-10-07T22:30:00+0400",
+        "2019-10-07 11:30:00-0700",  # ascii hyphen-minus
+        "2019-10-07T15:00:00-0330",
+        "2019-10-07 11:30:00\u22120700",  # unicode minus \u2212
+        "2019-10-07T15:00:00\u22120330",
+    ]
     for arg in arguments:
-        result = macro_obj.macro('content', (arg, ), 'page_url', 'alternative')
+        result = macro_obj.macro("content", (arg,), "page_url", "alternative")
         assert result == expected
diff --git a/src/moin/macros/_tests/test_GetText.py b/src/moin/macros/_tests/test_GetText.py
index 960c3babb..6e451c017 100644
--- a/src/moin/macros/_tests/test_GetText.py
+++ b/src/moin/macros/_tests/test_GetText.py
@@ -10,9 +10,9 @@
 
 
 def test_Macro():
-    """ test for Macro.macros """
+    """test for Macro.macros"""
     macro_obj = Macro()
-    arguments = Arguments(['test_argument1 test_argument2'])
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-    expected = 'test_argument1 test_argument2'
+    arguments = Arguments(["test_argument1 test_argument2"])
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
+    expected = "test_argument1 test_argument2"
     assert result == expected
diff --git a/src/moin/macros/_tests/test_GetVal.py b/src/moin/macros/_tests/test_GetVal.py
index 5c84a6309..3c4f5f7c9 100644
--- a/src/moin/macros/_tests/test_GetVal.py
+++ b/src/moin/macros/_tests/test_GetVal.py
@@ -17,9 +17,8 @@ class TestMacro:
     @pytest.fixture
     def test_dict(self):
         become_trusted()
-        wikidict = {"One": "1",
-                    "Two": "2"}
-        update_item('TestDict', {WIKIDICT: wikidict}, "This is a dict item.")
+        wikidict = {"One": "1", "Two": "2"}
+        update_item("TestDict", {WIKIDICT: wikidict}, "This is a dict item.")
 
         return "TestDict"
 
@@ -27,17 +26,17 @@ def test_Macro(self, test_dict):
         macro_obj = Macro()
         arguments = [test_dict]
         with pytest.raises(ValueError):
-            macro_obj.macro('content', arguments, 'page_url', 'alternative')
+            macro_obj.macro("content", arguments, "page_url", "alternative")
 
         if not flaskg.user.may.read(arguments[0]):
             with pytest.raises(ValueError):
-                macro_obj.macro('content', arguments, 'page_url', 'alternative')
+                macro_obj.macro("content", arguments, "page_url", "alternative")
 
-        arguments = ['TestDict, One']
-        result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-        assert result == '1'
+        arguments = ["TestDict, One"]
+        result = macro_obj.macro("content", arguments, "page_url", "alternative")
+        assert result == "1"
 
         # change the value of second element
-        arguments = ['TestDict, Two']
-        result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-        assert result == '2'
+        arguments = ["TestDict, Two"]
+        result = macro_obj.macro("content", arguments, "page_url", "alternative")
+        assert result == "2"
diff --git a/src/moin/macros/_tests/test_ItemList.py b/src/moin/macros/_tests/test_ItemList.py
index 2e40fc40c..2d94f33c0 100644
--- a/src/moin/macros/_tests/test_ItemList.py
+++ b/src/moin/macros/_tests/test_ItemList.py
@@ -9,13 +9,13 @@
 from moin.constants.keys import CONTENTTYPE, ITEMTYPE, REV_NUMBER
 from moin._tests import wikiconfig, update_item
 
-meta = {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8', ITEMTYPE: 'default', REV_NUMBER: 1}
+meta = {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8", ITEMTYPE: "default", REV_NUMBER: 1}
 
 
 class TestItemListMacro:
-    '''
+    """
     call ItemList macro and test ...
-    '''
+    """
 
     class Config(wikiconfig.Config):
         """
@@ -23,68 +23,68 @@ class Config(wikiconfig.Config):
         """
 
     def test_ItemListFullPath(self):
-        update_item('item01', meta, 'some-content')
-        update_item('item02', meta, 'some-content')
-        update_item('other', meta, 'some-content')
+        update_item("item01", meta, "some-content")
+        update_item("item02", meta, "some-content")
+        update_item("other", meta, "some-content")
 
-        update_item('TestItemList', meta, '<<ItemList(item="",startswith="item",display="FullPath")>>')
+        update_item("TestItemList", meta, '<<ItemList(item="",startswith="item",display="FullPath")>>')
 
-        rendered = Item.create('TestItemList').content._render_data()
+        rendered = Item.create("TestItemList").content._render_data()
         assert 'a href="/item01">item01' in rendered
         assert 'a href="/item02">item02' in rendered
-        assert 'other' not in rendered
+        assert "other" not in rendered
 
     def test_ItemListChildPath(self):
-        update_item('item01', meta, 'some-content')
-        update_item('item02', meta, 'some-content')
-        update_item('other', meta, 'some-content')
+        update_item("item01", meta, "some-content")
+        update_item("item02", meta, "some-content")
+        update_item("other", meta, "some-content")
 
-        update_item('TestItemList', meta, '<<ItemList(item="",startswith="item",display="ChildPath")>>')
+        update_item("TestItemList", meta, '<<ItemList(item="",startswith="item",display="ChildPath")>>')
 
-        rendered = Item.create('TestItemList').content._render_data()
+        rendered = Item.create("TestItemList").content._render_data()
         assert 'a href="/item01">item01' in rendered
         assert 'a href="/item02">item02' in rendered
-        assert 'other' not in rendered
+        assert "other" not in rendered
 
     def test_ItemListParent(self):
-        update_item('parent', meta, 'some-content')
-        update_item('parent/item01', meta, 'some-content')
-        update_item('parent/item02', meta, 'some-content')
-        update_item('parent/other01', meta, 'some-content')
-        update_item('item03', meta, 'some-content')
-        update_item('other02', meta, 'some-content')
+        update_item("parent", meta, "some-content")
+        update_item("parent/item01", meta, "some-content")
+        update_item("parent/item02", meta, "some-content")
+        update_item("parent/other01", meta, "some-content")
+        update_item("item03", meta, "some-content")
+        update_item("other02", meta, "some-content")
 
-        update_item('TestItemList01', meta, '<<ItemList(item="",startswith="parent/item")>>')
+        update_item("TestItemList01", meta, '<<ItemList(item="",startswith="parent/item")>>')
 
-        rendered = Item.create('TestItemList01').content._render_data()
+        rendered = Item.create("TestItemList01").content._render_data()
         assert 'a href="/parent/item01">parent/item01' in rendered
         assert 'a href="/parent/item02">parent/item02' in rendered
-        assert 'other' not in rendered
+        assert "other" not in rendered
 
-        update_item('TestItemList02', meta, '<<ItemList(item="parent",startswith="item")>>')
+        update_item("TestItemList02", meta, '<<ItemList(item="parent",startswith="item")>>')
 
-        rendered = Item.create('TestItemList02').content._render_data()
-        assert 'other02' not in rendered
-        assert 'item03' not in rendered
+        rendered = Item.create("TestItemList02").content._render_data()
+        assert "other02" not in rendered
+        assert "item03" not in rendered
 
     def test_ItemListRegex(self):
-        update_item('parent', meta, 'some-content')
-        update_item('parent/item01', meta, 'some-content')
-        update_item('parent/otheritem', meta, 'some-content')
-        update_item('item02', meta, 'some-content')
-        update_item('other02', meta, 'some-content')
+        update_item("parent", meta, "some-content")
+        update_item("parent/item01", meta, "some-content")
+        update_item("parent/otheritem", meta, "some-content")
+        update_item("item02", meta, "some-content")
+        update_item("other02", meta, "some-content")
 
-        update_item('TestItemList03', meta, '<<ItemList(item="",regex="item")>>')
+        update_item("TestItemList03", meta, '<<ItemList(item="",regex="item")>>')
 
-        rendered = Item.create('TestItemList03').content._render_data()
+        rendered = Item.create("TestItemList03").content._render_data()
         assert 'a href="/parent/item01">parent/item01' in rendered
         assert 'a href="/parent/otheritem">parent/otheritem' in rendered
         assert 'a href="/item02">item02' in rendered
-        assert 'other02' not in rendered
+        assert "other02" not in rendered
 
-        update_item('TestItemList04', meta, '<<ItemList(item="parent",regex="^parent/item")>>')
+        update_item("TestItemList04", meta, '<<ItemList(item="parent",regex="^parent/item")>>')
 
-        rendered = Item.create('TestItemList04').content._render_data()
+        rendered = Item.create("TestItemList04").content._render_data()
         assert 'a href="/parent/item01">parent/item01' in rendered
-        assert 'item02' not in rendered
-        assert 'other' not in rendered
+        assert "item02" not in rendered
+        assert "other" not in rendered
diff --git a/src/moin/macros/_tests/test_MonthCalendar.py b/src/moin/macros/_tests/test_MonthCalendar.py
index 19d8e017b..0270f5f53 100644
--- a/src/moin/macros/_tests/test_MonthCalendar.py
+++ b/src/moin/macros/_tests/test_MonthCalendar.py
@@ -12,56 +12,68 @@
 
 
 def test_parseargs_one():
-    '''
+    """
     checking the handling of explicit and default parameters in parseargs
-    '''
-    args = parseargs('item="TEST-CALENDAR",month_offset=-1,fixed_height=true',  # macro arguments
-                     'TEST-CALENDAR', 1990, 4, 0, False, False)  # default values
-    assert args == (['TEST-CALENDAR'], 1990, 4, -1, True, False)
+    """
+    args = parseargs(
+        'item="TEST-CALENDAR",month_offset=-1,fixed_height=true',  # macro arguments
+        "TEST-CALENDAR",
+        1990,
+        4,
+        0,
+        False,
+        False,
+    )  # default values
+    assert args == (["TEST-CALENDAR"], 1990, 4, -1, True, False)
 
 
 def test_parseargs_two():
     args = parseargs(
         'item="WikiWorkingGroup*WikiMacrosSpecialInterestGroup",'
-        'year=2020,month=3,month_offset=-4,fixed_height=true,anniversary=false',
-        'DefaultPageName', 1990, 4, -1, False, True,
-    )
-    assert args == (
-        ["WikiWorkingGroup", "WikiMacrosSpecialInterestGroup"],
-        2020, 3, -4, True, False,
+        "year=2020,month=3,month_offset=-4,fixed_height=true,anniversary=false",
+        "DefaultPageName",
+        1990,
+        4,
+        -1,
+        False,
+        True,
     )
+    assert args == (["WikiWorkingGroup", "WikiMacrosSpecialInterestGroup"], 2020, 3, -4, True, False)
 
 
 def test_Macro():
-    '''
+    """
     call MonthCalendar macro and test some attributes of resulting table
-    '''
+    """
     macro_obj = Macro()
-    arguments = Element('arguments')
+    arguments = Element("arguments")
     arguments.append('item="TEST-CALENDAR",month_offset=-1,fixed_height=true')
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
 
     # the result should be a table with calendar class attribute
-    assert result.tag.name == 'table'
-    assert 'calendar' in result.attrib.values()
+    assert result.tag.name == "table"
+    assert "calendar" in result.attrib.values()
 
     result_tags = list(result)
     # the table should have a caption, header and body
-    assert result_tags[0].tag.name == 'caption'
-    assert result_tags[1].tag.name == 'table-header'
-    assert result_tags[2].tag.name == 'table-body'
+    assert result_tags[0].tag.name == "caption"
+    assert result_tags[1].tag.name == "table-header"
+    assert result_tags[2].tag.name == "table-body"
 
     # the last macro parameter forces six rows in the calendar output
     # even though some month will only need five week rows
     assert len(result_tags[2]) == 6  # number table rows
 
 
-@pytest.mark.parametrize('year, month, month_offset, expected_year, expected_month', [
-    (2000, 1, 3, 2000, 4),
-    (1999, 11, 2, 2000, 1),
-    (2004, 3, 14, 2005, 5),
-    (2006, 2, -4, 2005, 10),
-    (2003, 2, -17, 2001, 9),
-])
+@pytest.mark.parametrize(
+    "year, month, month_offset, expected_year, expected_month",
+    [
+        (2000, 1, 3, 2000, 4),
+        (1999, 11, 2, 2000, 1),
+        (2004, 3, 14, 2005, 5),
+        (2006, 2, -4, 2005, 10),
+        (2003, 2, -17, 2001, 9),
+    ],
+)
 def test_yearmonthplusoffset(year, month, month_offset, expected_year, expected_month):
     assert yearmonthplusoffset(year, month, month_offset) == (expected_year, expected_month)
diff --git a/src/moin/macros/_tests/test_ShowSmileys.py b/src/moin/macros/_tests/test_ShowSmileys.py
index e14b0c764..450c0f98a 100644
--- a/src/moin/macros/_tests/test_ShowSmileys.py
+++ b/src/moin/macros/_tests/test_ShowSmileys.py
@@ -9,17 +9,17 @@
 
 
 def test_Macro():
-    """ test for Macro.macro """
-    expected_text = ['X-(', 'angry', ':D', 'biggrin', '<:(', 'frown', '{o}', 'star_off', ]
-    expected_tag = '{http://moinmo.in/namespaces/page}table-row'
+    """test for Macro.macro"""
+    expected_text = ["X-(", "angry", ":D", "biggrin", "<:(", "frown", "{o}", "star_off"]
+    expected_tag = "{http://moinmo.in/namespaces/page}table-row"
     macro_obj = Macro()
-    macro_out = macro_obj.macro('content', None, 'page_url', 'alternative')
+    macro_out = macro_obj.macro("content", None, "page_url", "alternative")
     result_text = []
     result_tags = []
     for node in macro_out.iter_elements_tree():
-        if getattr(node, 'text'):
-            result_text.append(getattr(node, 'text'))
-        if getattr(node, 'tag'):
-            result_tags.append(str(getattr(node, 'tag')))
+        if getattr(node, "text"):
+            result_text.append(getattr(node, "text"))
+        if getattr(node, "tag"):
+            result_tags.append(str(getattr(node, "tag")))
     assert set(expected_text).issubset(result_text)
     assert expected_tag in result_tags
diff --git a/src/moin/macros/_tests/test_Verbatim.py b/src/moin/macros/_tests/test_Verbatim.py
index 5c5c9d3f5..53f8039a1 100644
--- a/src/moin/macros/_tests/test_Verbatim.py
+++ b/src/moin/macros/_tests/test_Verbatim.py
@@ -9,7 +9,7 @@
 
 
 def test_Macro():
-    arguments = ['test text']
+    arguments = ["test text"]
     macro_obj = Macro()
-    result = macro_obj.macro('content', arguments, 'page_url', 'alternative')
-    assert result == 'test text'
+    result = macro_obj.macro("content", arguments, "page_url", "alternative")
+    assert result == "test text"
diff --git a/src/moin/macros/_tests/test__base.py b/src/moin/macros/_tests/test__base.py
index 80c74183a..7421d2709 100644
--- a/src/moin/macros/_tests/test__base.py
+++ b/src/moin/macros/_tests/test__base.py
@@ -11,61 +11,68 @@
 
 
 class TestMacroBase:
-    """ Test for Macro base and related classes """
+    """Test for Macro base and related classes"""
 
     def test_MacroBase(self):
-        """ test for MacroBase class """
+        """test for MacroBase class"""
         macrobase_obj = MacroBase()
         assert not macrobase_obj.immutable
         with pytest.raises(NotImplementedError):
-            macrobase_obj.__call__('content', 'arguments', 'page_url', 'alternative', 'context_block')
+            macrobase_obj.__call__("content", "arguments", "page_url", "alternative", "context_block")
 
     def test_MacroBlockBase(self):
-        """ test for MacroBlockBase class """
+        """test for MacroBlockBase class"""
+
         class Test_MacroBlockBase(MacroBlockBase):
-            """ inherited class from MacroBlockBase """
+            """inherited class from MacroBlockBase"""
 
         macroblockbase_obj = Test_MacroBlockBase()
         with pytest.raises(ValueError):
-            macroblockbase_obj.__call__('content', 'arguments', 'page_url', 'alternative', context_block=False)
+            macroblockbase_obj.__call__("content", "arguments", "page_url", "alternative", context_block=False)
         with pytest.raises(NotImplementedError):
-            macroblockbase_obj.__call__('content', 'arguments', 'page_url', 'alternative', 'context_block')
+            macroblockbase_obj.__call__("content", "arguments", "page_url", "alternative", "context_block")
 
     def test_MacroInlineBase(self):
-        """ test for MacroInlineBase class """
+        """test for MacroInlineBase class"""
+
         class Test_MacroInlineBase(MacroInlineBase):
-            """ inherited class from MacroInlineBase """
+            """inherited class from MacroInlineBase"""
+
             def macro(self, content, arguments, page_url, alternative):
-                return 'test_macro'
+                return "test_macro"
 
         macroinlinebase_obj = Test_MacroInlineBase()
-        result = macroinlinebase_obj.__call__('content', 'arguments', 'page_url', 'alternative', context_block=False)
-        assert result == 'test_macro'
-        result = macroinlinebase_obj.__call__('content', 'arguments', 'page_url', 'alternative', 'context_block')
-        assert result.text == 'test_macro'
-        result.remove('test_macro')
+        result = macroinlinebase_obj.__call__("content", "arguments", "page_url", "alternative", context_block=False)
+        assert result == "test_macro"
+        result = macroinlinebase_obj.__call__("content", "arguments", "page_url", "alternative", "context_block")
+        assert result.text == "test_macro"
+        result.remove("test_macro")
         assert not result.text
 
     def test_MacroInlineOnlyBase(self):
-        """ test for MacroInlineOnlyBase class """
+        """test for MacroInlineOnlyBase class"""
+
         class Test_MacroInlineOnlyBase(MacroInlineOnlyBase):
-            """ inherited class from MacroInlineOnlyBase """
+            """inherited class from MacroInlineOnlyBase"""
+
             def macro(self, content, arguments, page_url, alternative):
-                return 'test_macro'
+                return "test_macro"
 
         macroinlineonlybase_obj = Test_MacroInlineOnlyBase()
         result = macroinlineonlybase_obj.__call__(
-            'content', 'arguments', 'page_url', 'alternative', context_block=False
+            "content", "arguments", "page_url", "alternative", context_block=False
         )
-        assert result == 'test_macro'
+        assert result == "test_macro"
 
     def test_MacroPageLinkListBase(self):
-        """ test for MacroPageLinkListBase class """
+        """test for MacroPageLinkListBase class"""
+
         class Test_MacroPageLinkListBase(MacroPageLinkListBase):
-            """ inherited class from MacroPageLinkListBase """
+            """inherited class from MacroPageLinkListBase"""
+
             def macro(self, content, arguments, page_url, alternative):
-                return 'test_macro'
+                return "test_macro"
 
         macropagelinklistbase_obj = Test_MacroPageLinkListBase()
-        result = macropagelinklistbase_obj.__call__('content', 'arguments', 'page_url', 'alternative', 'context_block')
-        assert result == 'test_macro'
+        result = macropagelinklistbase_obj.__call__("content", "arguments", "page_url", "alternative", "context_block")
+        assert result == "test_macro"
diff --git a/src/moin/mail/_tests/test_sendmail.py b/src/moin/mail/_tests/test_sendmail.py
index e2b385b37..0671bfea5 100644
--- a/src/moin/mail/_tests/test_sendmail.py
+++ b/src/moin/mail/_tests/test_sendmail.py
@@ -13,23 +13,19 @@ class TestdecodeSpamSafeEmail:
     """mail.sendmail: testing mail"""
 
     _tests = (
-        ('', ''),
-        ('AT', '@'),
-        ('DOT', '.'),
-        ('DASH', '-'),
-        ('CAPS', ''),
-        ('Mixed', 'Mixed'),
-        ('lower', 'lower'),
-        ('Firstname DOT Lastname AT example DOT net',
-         'Firstname.Lastname@example.net'),
-        ('Firstname . Lastname AT exa mp le DOT n e t',
-         'Firstname.Lastname@example.net'),
-        ('Firstname I DONT WANT SPAM . Lastname@example DOT net',
-         'Firstname.Lastname@example.net'),
-        ('First name I Lastname DONT AT WANT SPAM example DOT n e t',
-         'FirstnameLastname@example.net'),
-        ('first.last@example.com', 'first.last@example.com'),
-        ('first . last @ example . com', 'first.last@example.com'),
+        ("", ""),
+        ("AT", "@"),
+        ("DOT", "."),
+        ("DASH", "-"),
+        ("CAPS", ""),
+        ("Mixed", "Mixed"),
+        ("lower", "lower"),
+        ("Firstname DOT Lastname AT example DOT net", "Firstname.Lastname@example.net"),
+        ("Firstname . Lastname AT exa mp le DOT n e t", "Firstname.Lastname@example.net"),
+        ("Firstname I DONT WANT SPAM . Lastname@example DOT net", "Firstname.Lastname@example.net"),
+        ("First name I Lastname DONT AT WANT SPAM example DOT n e t", "FirstnameLastname@example.net"),
+        ("first.last@example.com", "first.last@example.com"),
+        ("first . last @ example . com", "first.last@example.com"),
     )
 
     def testDecodeSpamSafeMail(self):
@@ -42,15 +38,13 @@ class TestencodeSpamSafeEmail:
     """mail.sendmail: testing spam safe mail"""
 
     _tests = (
-        ('', ''),
-        ('@', ' AT '),
-        ('.', ' DOT '),
-        ('-', ' DASH '),
-        ('lower', 'lower'),
-        ('Firstname.Lastname@example.net',
-         'firstname DOT lastname AT example DOT net'),
-        ('F.Lastname@example.net',
-         'f DOT lastname AT example DOT net'),
+        ("", ""),
+        ("@", " AT "),
+        (".", " DOT "),
+        ("-", " DASH "),
+        ("lower", "lower"),
+        ("Firstname.Lastname@example.net", "firstname DOT lastname AT example DOT net"),
+        ("F.Lastname@example.net", "f DOT lastname AT example DOT net"),
     )
 
     def testEncodeSpamSafeMail(self):
@@ -59,10 +53,10 @@ def testEncodeSpamSafeMail(self):
             assert sendmail.encodeSpamSafeEmail(coded) == expected
 
     def testEncodeSpamSafeMailAndObfuscate(self):
-        """mail.sendmail: encoding mail address by an obfuscate string to spam safe mail """
+        """mail.sendmail: encoding mail address by an obfuscate string to spam safe mail"""
         for coded, expected in self._tests:
-            expected = expected.replace(' AT ', ' AT SYCTE ')
-            assert sendmail.encodeSpamSafeEmail(coded, 'SYCTE') == expected
+            expected = expected.replace(" AT ", " AT SYCTE ")
+            assert sendmail.encodeSpamSafeEmail(coded, "SYCTE") == expected
 
 
-coverage_modules = ['moin.mail.sendmail']
+coverage_modules = ["moin.mail.sendmail"]
diff --git a/src/moin/mail/sendmail.py b/src/moin/mail/sendmail.py
index 394d4936c..af7210be4 100644
--- a/src/moin/mail/sendmail.py
+++ b/src/moin/mail/sendmail.py
@@ -17,6 +17,7 @@
 from moin.i18n import _
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -24,7 +25,7 @@
 
 
 def sendmail(subject, text, to=None, cc=None, bcc=None, mail_from=None, html=None):
-    """ Create and send a text/plain message
+    """Create and send a text/plain message
 
     Return a tuple of success or error indicator and message.
 
@@ -48,8 +49,13 @@ def sendmail(subject, text, to=None, cc=None, bcc=None, mail_from=None, html=Non
     """
     cfg = app.cfg
     if not cfg.mail_enabled:
-        return (0, _("Contact administrator: cannot send password recovery e-mail "
-                     "because mail configuration is incomplete."))
+        return (
+            0,
+            _(
+                "Contact administrator: cannot send password recovery e-mail "
+                "because mail configuration is incomplete."
+            ),
+        )
     mail_from = mail_from or cfg.mail_from
 
     logging.debug(f"send mail, from: {mail_from!r}, subj: {subject!r}")
@@ -62,35 +68,35 @@ def sendmail(subject, text, to=None, cc=None, bcc=None, mail_from=None, html=Non
 
     msg.set_content(text)
     if html:
-        msg.add_alternative(html, subtype='html')
+        msg.add_alternative(html, subtype="html")
 
-    msg['From'] = mail_from
+    msg["From"] = mail_from
     if to:
-        msg['To'] = to
+        msg["To"] = to
     if cc:
-        msg['CC'] = cc
-    msg['Subject'] = subject
-    msg['Date'] = formatdate()
-    msg['Message-ID'] = make_msgid()
-    msg['Auto-Submitted'] = 'auto-generated'  # RFC 3834 section 5
+        msg["CC"] = cc
+    msg["Subject"] = subject
+    msg["Date"] = formatdate()
+    msg["Message-ID"] = make_msgid()
+    msg["Auto-Submitted"] = "auto-generated"  # RFC 3834 section 5
 
     if cfg.mail_sendmail:
         if bcc:
             # Set the BCC.  This will be stripped later by sendmail.
-            msg['BCC'] = bcc
+            msg["BCC"] = bcc
         # Set Return-Path so that it isn't set (generally incorrectly) for us.
-        msg['Return-Path'] = mail_from
+        msg["Return-Path"] = mail_from
 
     # Send the message
     if not cfg.mail_sendmail:
         try:
             logging.debug(f"trying to send mail (smtp) via smtp server '{cfg.mail_smarthost}'")
-            host, port = (cfg.mail_smarthost + ':25').split(':')[:2]
+            host, port = (cfg.mail_smarthost + ":25").split(":")[:2]
             server = smtplib.SMTP(host, int(port))
             try:
                 server.ehlo()
                 try:  # try to do TLS
-                    if server.has_extn('starttls'):
+                    if server.has_extn("starttls"):
                         server.starttls()
                         server.ehlo()
                         logging.debug("tls connection to smtp server established")
@@ -112,9 +118,12 @@ def sendmail(subject, text, to=None, cc=None, bcc=None, mail_from=None, html=Non
             return 0, str(e)
         except OSError as e:
             logging.exception("smtp mail failed with an exception.")
-            return (0, _("Connection to mailserver '{server}' failed: {reason}"
-                        ).format(server=cfg.mail_smarthost, reason=str(e))
-                   )
+            return (
+                0,
+                _("Connection to mailserver '{server}' failed: {reason}").format(
+                    server=cfg.mail_smarthost, reason=str(e)
+                ),
+            )
     else:
         raise NotImplementedError  # TODO cli sendmail support
 
@@ -122,7 +131,7 @@ def sendmail(subject, text, to=None, cc=None, bcc=None, mail_from=None, html=Non
     return 1, _("Mail sent successfully")
 
 
-def encodeSpamSafeEmail(email_address, obfuscation_text=''):
+def encodeSpamSafeEmail(email_address, obfuscation_text=""):
     """
     Encodes a standard email address to an obfuscated address
 
@@ -139,16 +148,16 @@ def encodeSpamSafeEmail(email_address, obfuscation_text=''):
     address = email_address.lower()
     # uppercase letters will be stripped by decodeSpamSafeEmail
     for word, sign in _transdict.items():
-        address = address.replace(sign, f' {word} ')
+        address = address.replace(sign, f" {word} ")
     if obfuscation_text.isalpha():
         # is the obfuscation_text alphabetic
-        address = address.replace(' AT ', f' AT {obfuscation_text.upper()} ')
+        address = address.replace(" AT ", f" AT {obfuscation_text.upper()} ")
 
     return address
 
 
 def decodeSpamSafeEmail(address):
-    """ Decode obfuscated email address to standard email address
+    """Decode obfuscated email address to standard email address
 
     Decode a spam-safe email address in `address` by applying the
     following rules:
@@ -174,8 +183,8 @@ def decodeSpamSafeEmail(address):
         # is it all-uppercase?
         if word.isalpha() and word == word.upper():
             # strip unknown CAPS words
-            word = _transdict.get(word, '')
+            word = _transdict.get(word, "")
         email.append(word)
 
     # return concatenated parts
-    return ''.join(email)
+    return "".join(email)
diff --git a/src/moin/search/__init__.py b/src/moin/search/__init__.py
index 5b3d4bd97..6cd1aec86 100644
--- a/src/moin/search/__init__.py
+++ b/src/moin/search/__init__.py
@@ -13,21 +13,21 @@
 
 
 class ValidSearch(Validator):
-    """Validator for a valid search form
-    """
-    too_short_query_msg = L_('Search query too short.')
+    """Validator for a valid search form"""
+
+    too_short_query_msg = L_("Search query too short.")
 
     def validate(self, element, state):
-        if element['q'].value is None:
+        if element["q"].value is None:
             # no query, nothing to search for
             return False
-        if len(element['q'].value) < 2:
-            return self.note_error(element, state, 'too_short_query_msg')
+        if len(element["q"].value) < 2:
+            return self.note_error(element, state, "too_short_query_msg")
         return True
 
 
 class SearchForm(Form):
     q = Search
-    submit_label = L_('Search')
+    submit_label = L_("Search")
 
     validators = [ValidSearch()]
diff --git a/src/moin/search/_tests/test_analyzers.py b/src/moin/search/_tests/test_analyzers.py
index 1742746de..8e1ea160f 100644
--- a/src/moin/search/_tests/test_analyzers.py
+++ b/src/moin/search/_tests/test_analyzers.py
@@ -14,7 +14,7 @@
 class TokenizerTestBase:
 
     def testTokenizer(self):
-        """ analyzers: check what obtained tokens matched given """
+        """analyzers: check what obtained tokens matched given"""
         tokenizer = self.make_tokenizer()
         for value, expected_tokens in self.test_cases_query:
             tokens = [token.text for token in tokenizer(value)]
@@ -22,86 +22,76 @@ def testTokenizer(self):
 
 
 class TestAclTokenizer(TokenizerTestBase):
-    """ analyzers: test ACL tokenizer """
+    """analyzers: test ACL tokenizer"""
 
     test_cases_query = [
         # (query, tokens)
-        ('-MinusGuy:read', ['MinusGuy:-read']),
-        ('+PlusGuy:read', ['PlusGuy:+read']),
-        ('Admin3:read,write,admin', [
-            'Admin3:+read',
-            'Admin3:-pubread',
-            'Admin3:+write',
-            'Admin3:-create',
-            'Admin3:+admin',
-            'Admin3:-destroy',
-        ]),
-        ('Admin1,Admin2:read,write,admin', [
-            'Admin1:+read',
-            'Admin1:-pubread',
-            'Admin1:+write',
-            'Admin1:-create',
-            'Admin1:+admin',
-            'Admin1:-destroy',
-            'Admin2:+read',
-            'Admin2:-pubread',
-            'Admin2:+write',
-            'Admin2:-create',
-            'Admin2:+admin',
-            'Admin2:-destroy',
-        ]),
-        ('JoeDoe:pubread,write', [
-            'JoeDoe:-read',
-            'JoeDoe:+pubread',
-            'JoeDoe:+write',
-            'JoeDoe:-create',
-            'JoeDoe:-admin',
-            'JoeDoe:-destroy',
-        ]),
-        ('name with spaces,another one:read,write', [
-            'name with spaces:+read',
-            'name with spaces:-pubread',
-            'name with spaces:+write',
-            'name with spaces:-create',
-            'name with spaces:-admin',
-            'name with spaces:-destroy',
-            'another one:+read',
-            'another one:-pubread',
-            'another one:+write',
-            'another one:-create',
-            'another one:-admin',
-            'another one:-destroy',
-        ]),
-        ('CamelCase,extended name:read,write', [
-            'CamelCase:+read',
-            'CamelCase:-pubread',
-            'CamelCase:+write',
-            'CamelCase:-create',
-            'CamelCase:-admin',
-            'CamelCase:-destroy',
-            'extended name:+read',
-            'extended name:-pubread',
-            'extended name:+write',
-            'extended name:-create',
-            'extended name:-admin',
-            'extended name:-destroy',
-        ]),
-        ('BadGuy:', [
-            'BadGuy:-read',
-            'BadGuy:-pubread',
-            'BadGuy:-write',
-            'BadGuy:-create',
-            'BadGuy:-admin',
-            'BadGuy:-destroy',
-        ]),
-        ('All:read', [
-            'All:+read',
-            'All:-pubread',
-            'All:-write',
-            'All:-create',
-            'All:-admin',
-            'All:-destroy',
-        ])
+        ("-MinusGuy:read", ["MinusGuy:-read"]),
+        ("+PlusGuy:read", ["PlusGuy:+read"]),
+        (
+            "Admin3:read,write,admin",
+            ["Admin3:+read", "Admin3:-pubread", "Admin3:+write", "Admin3:-create", "Admin3:+admin", "Admin3:-destroy"],
+        ),
+        (
+            "Admin1,Admin2:read,write,admin",
+            [
+                "Admin1:+read",
+                "Admin1:-pubread",
+                "Admin1:+write",
+                "Admin1:-create",
+                "Admin1:+admin",
+                "Admin1:-destroy",
+                "Admin2:+read",
+                "Admin2:-pubread",
+                "Admin2:+write",
+                "Admin2:-create",
+                "Admin2:+admin",
+                "Admin2:-destroy",
+            ],
+        ),
+        (
+            "JoeDoe:pubread,write",
+            ["JoeDoe:-read", "JoeDoe:+pubread", "JoeDoe:+write", "JoeDoe:-create", "JoeDoe:-admin", "JoeDoe:-destroy"],
+        ),
+        (
+            "name with spaces,another one:read,write",
+            [
+                "name with spaces:+read",
+                "name with spaces:-pubread",
+                "name with spaces:+write",
+                "name with spaces:-create",
+                "name with spaces:-admin",
+                "name with spaces:-destroy",
+                "another one:+read",
+                "another one:-pubread",
+                "another one:+write",
+                "another one:-create",
+                "another one:-admin",
+                "another one:-destroy",
+            ],
+        ),
+        (
+            "CamelCase,extended name:read,write",
+            [
+                "CamelCase:+read",
+                "CamelCase:-pubread",
+                "CamelCase:+write",
+                "CamelCase:-create",
+                "CamelCase:-admin",
+                "CamelCase:-destroy",
+                "extended name:+read",
+                "extended name:-pubread",
+                "extended name:+write",
+                "extended name:-create",
+                "extended name:-admin",
+                "extended name:-destroy",
+            ],
+        ),
+        (
+            "BadGuy:",
+            ["BadGuy:-read", "BadGuy:-pubread", "BadGuy:-write", "BadGuy:-create", "BadGuy:-admin", "BadGuy:-destroy"],
+        ),
+        ("All:read", ["All:+read", "All:-pubread", "All:-write", "All:-create", "All:-admin", "All:-destroy"]),
     ]
 
     def make_tokenizer(self):
@@ -109,21 +99,59 @@ def make_tokenizer(self):
 
 
 class TestMimeTokenizer(TokenizerTestBase):
-    """ analyzers: test content type analyzer """
+    """analyzers: test content type analyzer"""
 
     test_cases_query = [
         # (query, tokens)
-        ('text/x.moin.wiki;charset=utf-8',
-         ['text/x.moin.wiki;charset=utf-8', 'text', 'moinwiki', 'x.moin.wiki', 'x', 'moin', 'wiki', 'charset=utf-8', 'charset', 'utf-8']),
-        ('text/plain',
-         ['text/plain', 'text', 'plain']),
-        ('text/plain;charset=utf-8',
-         ['text/plain;charset=utf-8', 'text', 'plain', 'charset=utf-8', 'charset', 'utf-8']),
-        ('text/html;value1=foo;value2=bar',
-         ['text/html;value1=foo;value2=bar', 'text', 'html', 'value1=foo', 'value1', 'foo', 'value2=bar', 'value2', 'bar']),
+        (
+            "text/x.moin.wiki;charset=utf-8",
+            [
+                "text/x.moin.wiki;charset=utf-8",
+                "text",
+                "moinwiki",
+                "x.moin.wiki",
+                "x",
+                "moin",
+                "wiki",
+                "charset=utf-8",
+                "charset",
+                "utf-8",
+            ],
+        ),
+        ("text/plain", ["text/plain", "text", "plain"]),
+        (
+            "text/plain;charset=utf-8",
+            ["text/plain;charset=utf-8", "text", "plain", "charset=utf-8", "charset", "utf-8"],
+        ),
+        (
+            "text/html;value1=foo;value2=bar",
+            [
+                "text/html;value1=foo;value2=bar",
+                "text",
+                "html",
+                "value1=foo",
+                "value1",
+                "foo",
+                "value2=bar",
+                "value2",
+                "bar",
+            ],
+        ),
         # we normalize, sort the params:
-        ('text/html;value2=bar;value1=foo',
-         ['text/html;value2=bar;value1=foo', 'text', 'html', 'value2=bar', 'value2', 'bar', 'value1=foo', 'value1', 'foo']),
+        (
+            "text/html;value2=bar;value1=foo",
+            [
+                "text/html;value2=bar;value1=foo",
+                "text",
+                "html",
+                "value2=bar",
+                "value2",
+                "bar",
+                "value1=foo",
+                "value1",
+                "foo",
+            ],
+        ),
     ]
 
     def make_tokenizer(self):
@@ -131,29 +159,29 @@ def make_tokenizer(self):
 
 
 class TestItemNameAnalyzer(TokenizerTestBase):
-    """ analyzers: test item_name analyzer """
+    """analyzers: test item_name analyzer"""
 
     test_cases_query = [
         # (query, tokens)
-        ('wifi', ['wifi']),
-        ('WiFi', ['wi', 'fi']),
-        ('Wi-Fi', ['wi', 'fi']),
-        ('some item name', ['some', 'item', 'name']),
-        ('SomeItem/SubItem', ['some', 'item', 'sub', 'item']),
-        ('GSOC2011', ['gsoc', '2011'])
+        ("wifi", ["wifi"]),
+        ("WiFi", ["wi", "fi"]),
+        ("Wi-Fi", ["wi", "fi"]),
+        ("some item name", ["some", "item", "name"]),
+        ("SomeItem/SubItem", ["some", "item", "sub", "item"]),
+        ("GSOC2011", ["gsoc", "2011"]),
     ]
 
     test_cases_index = [
-        ('some item name', ['some', 'item', 'name']),
-        ('SomeItem/SubItem', ['some', 'item', 'sub', 'item', 'someitemsubitem']),
-        ('GSOC2011', ['gsoc', '2011'])
+        ("some item name", ["some", "item", "name"]),
+        ("SomeItem/SubItem", ["some", "item", "sub", "item", "someitemsubitem"]),
+        ("GSOC2011", ["gsoc", "2011"]),
     ]
 
     def make_tokenizer(self):
         return item_name_analyzer()
 
     def testTokenizer(self):
-        """ analyzers: test item name analyzer with "query" and "index" mode """
+        """analyzers: test item name analyzer with "query" and "index" mode"""
         tokenizer = self.make_tokenizer()
         for value, expected_tokens in self.test_cases_query:
             tokens = [token.text for token in tokenizer(value, mode="query")]
diff --git a/src/moin/search/analyzers.py b/src/moin/search/analyzers.py
index 9c786908e..0dedee5a2 100644
--- a/src/moin/search/analyzers.py
+++ b/src/moin/search/analyzers.py
@@ -12,9 +12,9 @@
 
 
 class MimeTokenizer(Tokenizer):
-    """ Content type tokenizer """
+    """Content type tokenizer"""
 
-    def __call__(self, value, start_pos=0, positions=False, mode='', **kwargs):
+    def __call__(self, value, start_pos=0, positions=False, mode="", **kwargs):
         """
         This tokenizer is used for both indexing and queries. Queries are simple, usually return the input value as is.
 
@@ -38,7 +38,7 @@ def __call__(self, value, start_pos=0, positions=False, mode='', **kwargs):
         """
         tk = Token()
         tk.pos = 0
-        if mode == 'query':
+        if mode == "query":
             # 1 term expected, but contenttype:'moin utf-8' is valid
             val = value.split()
             for v in val:
@@ -49,22 +49,22 @@ def __call__(self, value, start_pos=0, positions=False, mode='', **kwargs):
             tk.text = value
             # text/x.moin.wiki;charset=utf-8
             yield tk
-            if '/' not in value:
+            if "/" not in value:
                 # unsupported contenttype
                 return
-            major, minor = value.split('/')
+            major, minor = value.split("/")
             # text, x.moin.wiki;charset=utf-8
             tk.text = major
             # text
             yield tk
-            if ';' in minor:
-                parameters = minor.split(';')
+            if ";" in minor:
+                parameters = minor.split(";")
                 # x.moin.wiki, charset=utf-8
                 for par in parameters[1:]:
                     tk.text = par
                     # charset=utf-8
                     yield tk
-                    key, val = par.split('=')
+                    key, val = par.split("=")
                     # charset, utf-8
                     tk.text = key
                     # charset
@@ -73,43 +73,43 @@ def __call__(self, value, start_pos=0, positions=False, mode='', **kwargs):
                     # utf-8
                     yield tk
                 minor = parameters[0]  # x.moin.wiki
-            if minor == 'mpeg':
+            if minor == "mpeg":
                 # 'audio/mpeg' most people expect mp3
-                tk.text = 'mp3'
+                tk.text = "mp3"
                 yield tk
-            if minor == 'jpeg':
+            if minor == "jpeg":
                 # 'image/jpeg' most people expect jpg
-                tk.text = 'jpg'
+                tk.text = "jpg"
                 yield tk
-            if minor == 'x.moin.wiki':
+            if minor == "x.moin.wiki":
                 # moin is valid for moin and creole, use this to get just moin
-                tk.text = 'moinwiki'
+                tk.text = "moinwiki"
                 yield tk
             tk.text = minor
             # x.moin.wiki
             yield tk
-            if '.' in minor:
-                min = minor.split('.')
+            if "." in minor:
+                min = minor.split(".")
                 # x, moin, wiki
                 for m in min:
                     tk.text = m
                     yield tk
-            if '-' in minor:
+            if "-" in minor:
                 # x-markdown
-                min = minor.split('-')
+                min = minor.split("-")
                 for m in min:
                     tk.text = m
                     yield tk
-            if '+' in minor:
+            if "+" in minor:
                 # svg+xml
-                min = minor.split('+')
+                min = minor.split("+")
                 for m in min:
                     tk.text = m
                     yield tk
 
 
 class AclTokenizer(Tokenizer):
-    """ Access control list tokenizer """
+    """Access control list tokenizer"""
 
     def __init__(self, acl_rights_contents):
         """
@@ -117,7 +117,7 @@ def __init__(self, acl_rights_contents):
         """
         self._acl_rights_contents = acl_rights_contents
 
-    def __call__(self, value, start_pos=0, positions=False, mode='', **kwargs):
+    def __call__(self, value, start_pos=0, positions=False, mode="", **kwargs):
         """
         Calls AccessControlList for tokenization
 
@@ -171,8 +171,8 @@ def item_name_analyzer():
 
     Output: "some", "item", "name"; "Some", "Item", "Sub", "Item"; "GSOC", "2011"
     """
-    iwf = MultiFilter(index=IntraWordFilter(mergewords=True, mergenums=True),
-                      query=IntraWordFilter(mergewords=False, mergenums=False)
-                      )
+    iwf = MultiFilter(
+        index=IntraWordFilter(mergewords=True, mergenums=True), query=IntraWordFilter(mergewords=False, mergenums=False)
+    )
     analyzer = RegexTokenizer(r"\S+") | iwf | LowercaseFilter()
     return analyzer
diff --git a/src/moin/security/__init__.py b/src/moin/security/__init__.py
index 845ebdb1a..6390af714 100644
--- a/src/moin/security/__init__.py
+++ b/src/moin/security/__init__.py
@@ -28,6 +28,7 @@ def require_permission(permission):
 
     if the permission is not granted, abort with 403
     """
+
     def wrap(f):
         @wraps(f)
         def wrapped_f(*args, **kw):
@@ -35,7 +36,9 @@ def wrapped_f(*args, **kw):
             if not has_permission():
                 abort(403)
             return f(*args, **kw)
+
         return wrapped_f
+
     return wrap
 
 
@@ -64,20 +67,22 @@ def read(self, itemname):
                 # This call will return correct permissions by checking ACLs:
                 return super(MySecPol, self).read(itemname)
     """
+
     def __init__(self, user):
         self.names = user.name
 
     def read(self, itemname):
         """read permission is special as we have 2 kinds of read capabilities:
 
-           * READ - gives permission to read, unconditionally
-           * PUBREAD - gives permission to read, when published
+        * READ - gives permission to read, unconditionally
+        * PUBREAD - gives permission to read, when published
         """
-        return (flaskg.storage.may(itemname, rights.READ, usernames=self.names) or
-                flaskg.storage.may(itemname, rights.PUBREAD, usernames=self.names))
+        return flaskg.storage.may(itemname, rights.READ, usernames=self.names) or flaskg.storage.may(
+            itemname, rights.PUBREAD, usernames=self.names
+        )
 
     def __getattr__(self, attr):
-        """ Shortcut to handle all known ACL rights.
+        """Shortcut to handle all known ACL rights.
 
         if attr is a valid acl right, return a checking function for it.
         Else raise an AttributeError.
@@ -89,6 +94,7 @@ def __getattr__(self, attr):
         if attr in app.cfg.acl_rights_contents:
             return lambda itemname: flaskg.storage.may(itemname, attr, usernames=self.names)
         if attr in app.cfg.acl_rights_functions:
+
             def multiuser_may():
                 # TODO: if "may" would accept multiple names, we could get rid of this
                 may = app.cfg.cache.acl_functions.may
@@ -96,6 +102,7 @@ def multiuser_may():
                     if may(name, attr):
                         return True
                 return False
+
             return multiuser_may
         raise AttributeError(attr)
 
@@ -176,9 +183,8 @@ class AccessControlList(AutoNe):
 
     special_users = ["All", "Known", "Trusted"]  # order is important
 
-    def __init__(self, lines=[], default='', valid=None):
-        """ Initialize an ACL, starting from <nothing>.
-        """
+    def __init__(self, lines=[], default="", valid=None):
+        """Initialize an ACL, starting from <nothing>."""
         assert valid is not None
         self.acl_rights_valid = valid
         self.default = default
@@ -193,13 +199,13 @@ def __init__(self, lines=[], default='', valid=None):
             self.acl_lines = None
 
     def has_acl(self):
-        """ Checks whether we have a real acl here. """
+        """Checks whether we have a real acl here."""
         # self.acl == None means that there is NO acl.
         # self.acl == [] means that there is a empty acl.
         return self.acl is not None
 
     def _addLine(self, aclstring, remember=1):
-        """ Add another ACL line
+        """Add another ACL line
 
         This can be used in multiple subsequent calls to process longer lists.
 
@@ -213,7 +219,7 @@ def _addLine(self, aclstring, remember=1):
         # Iterate over entries and rights, parsed by acl string iterator
         acliter = ACLStringIterator(self.acl_rights_valid, aclstring)
         for modifier, entries, _rights in acliter:
-            if entries == ['Default']:
+            if entries == ["Default"]:
                 self._addLine(self.default, remember=0)
             else:
                 for entry in entries:
@@ -223,20 +229,20 @@ def _addLine(self, aclstring, remember=1):
                         # + add right with value of 1
                         # - add right with value of 0
                         for right in _rights:
-                            rightsdict[right] = (modifier == '+')
+                            rightsdict[right] = modifier == "+"
                     else:
                         # All rights from acl_rights_valid are added to the
                         # dict, user rights with value of 1, and other with
                         # value of 0
                         for right in self.acl_rights_valid:
-                            rightsdict[right] = (right in _rights)
+                            rightsdict[right] = right in _rights
                     self.acl.append((entry, rightsdict))
 
     def may(self, name, dowhat):
-        """ May <name> <dowhat>? Returns boolean answer.
+        """May <name> <dowhat>? Returns boolean answer.
 
-            Note: this just checks THIS ACL, the before/default/after ACL must
-                  be handled elsewhere, if needed.
+        Note: this just checks THIS ACL, the before/default/after ACL must
+              be handled elsewhere, if needed.
         """
         groups = flaskg.groups
         allowed = None
@@ -266,19 +272,19 @@ def _special_All(self, name, dowhat, rightsdict):
         return rightsdict.get(dowhat)
 
     def _special_Known(self, name, dowhat, rightsdict):
-        """ check if user <name> is known to us,
-            that means that there is a valid user account present.
-            works for subscription emails.
+        """check if user <name> is known to us,
+        that means that there is a valid user account present.
+        works for subscription emails.
         """
         if user.search_users(**{NAME_EXACT: name}):  # is a user with this name known?
             return rightsdict.get(dowhat)
         return None
 
     def _special_Trusted(self, name, dowhat, rightsdict):
-        """ check if user <name> is the current user AND is has logged in using
-            an authentication method that set the trusted attribute.
-            Does not work for subsription emails that should be sent to <user>,
-            as the user is not logged in in that case.
+        """check if user <name> is the current user AND is has logged in using
+        an authentication method that set the trusted attribute.
+        Does not work for subsription emails that should be sent to <user>,
+        as the user is not logged in in that case.
         """
         if flaskg.user.name == name and flaskg.user.trusted:
             return rightsdict.get(dowhat)
@@ -289,7 +295,7 @@ def __eq__(self, other):
 
 
 class ACLStringIterator:
-    """ Iterator for acl string
+    """Iterator for acl string
 
     Parse acl string and return the next entry on each call to next.
     Implements the Iterator protocol.
@@ -302,7 +308,7 @@ class ACLStringIterator:
     """
 
     def __init__(self, rights, aclstring):
-        """ Initialize acl iterator
+        """Initialize acl iterator
 
         :param rights: the acl rights to consider when parsing
         :param aclstring: string to parse
@@ -312,11 +318,11 @@ def __init__(self, rights, aclstring):
         self.finished = 0
 
     def __iter__(self):
-        """ Required by the Iterator protocol """
+        """Required by the Iterator protocol"""
         return self
 
     def __next__(self):
-        """ Return the next values from the acl string
+        """Return the next values from the acl string
 
         When the iterator is finished and you try to call next, it
         raises a StopIteration. The iterator finishes as soon as the
@@ -326,43 +332,43 @@ def __next__(self):
         :returns: values for one item in an acl string
         """
         # Handle finished state, required by iterator protocol
-        if self.rest == '':
+        if self.rest == "":
             self.finished = 1
         if self.finished:
             raise StopIteration
 
         # Get optional modifier [+|-]entries:rights
-        modifier = ''
-        if self.rest[0] in ('+', '-'):
+        modifier = ""
+        if self.rest[0] in ("+", "-"):
             modifier, self.rest = self.rest[0], self.rest[1:]
 
         # Handle the Default meta acl
-        if self.rest.startswith('Default ') or self.rest == 'Default':
+        if self.rest.startswith("Default ") or self.rest == "Default":
             self.rest = self.rest[8:]
-            entries, rights = ['Default'], []
+            entries, rights = ["Default"], []
 
         # Handle entries:rights pairs
         else:
             # Get entries
             try:
-                entries, self.rest = self.rest.split(':', 1)
+                entries, self.rest = self.rest.split(":", 1)
             except ValueError:
                 self.finished = 1
                 raise StopIteration("Can't parse rest of string")
-            if entries == '':
+            if entries == "":
                 entries = []
             else:
                 # TODO strip each entry from blanks?
-                entries = entries.split(',')
+                entries = entries.split(",")
 
             # Get rights
             try:
-                rights, self.rest = self.rest.split(' ', 1)
+                rights, self.rest = self.rest.split(" ", 1)
                 # Remove extra white space after rights fragment,
                 # allowing using multiple spaces between items.
                 self.rest = self.rest.lstrip()
             except ValueError:
-                rights, self.rest = self.rest, ''
-            rights = [r for r in rights.split(',') if r in self.rights]
+                rights, self.rest = self.rest, ""
+            rights = [r for r in rights.split(",") if r in self.rights]
 
         return modifier, entries, rights
diff --git a/src/moin/security/_tests/test_security.py b/src/moin/security/_tests/test_security.py
index e3fb2a827..4f2cabc9e 100644
--- a/src/moin/security/_tests/test_security.py
+++ b/src/moin/security/_tests/test_security.py
@@ -31,185 +31,186 @@ def acliter(acl):
 class TestACLStringIterator:
 
     def testEmpty(self):
-        """ security: empty acl string raise StopIteration """
-        acl_iter = acliter('')
+        """security: empty acl string raise StopIteration"""
+        acl_iter = acliter("")
         pytest.raises(StopIteration, acl_iter.__next__)
 
     def testWhiteSpace(self):
-        """ security: white space acl string raise StopIteration """
-        acl_iter = acliter('       ')
+        """security: white space acl string raise StopIteration"""
+        acl_iter = acliter("       ")
         pytest.raises(StopIteration, acl_iter.__next__)
 
     def testDefault(self):
-        """ security: default meta acl """
-        acl_iter = acliter('Default Default')
+        """security: default meta acl"""
+        acl_iter = acliter("Default Default")
         for mod, entries, rights in acl_iter:
-            assert entries == ['Default']
+            assert entries == ["Default"]
             assert rights == []
 
     def testEmptyRights(self):
-        """ security: empty rights """
-        acl_iter = acliter('WikiName:')
+        """security: empty rights"""
+        acl_iter = acliter("WikiName:")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['WikiName']
+        assert entries == ["WikiName"]
         assert rights == []
 
     def testSingleWikiNameSingleRight(self):
-        """ security: single wiki name, single right """
-        acl_iter = acliter('WikiName:read')
+        """security: single wiki name, single right"""
+        acl_iter = acliter("WikiName:read")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['WikiName']
-        assert rights == ['read']
+        assert entries == ["WikiName"]
+        assert rights == ["read"]
 
     def testMultipleWikiNameAndRights(self):
-        """ security: multiple wiki names and rights """
-        acl_iter = acliter('UserOne,UserTwo:read,write')
+        """security: multiple wiki names and rights"""
+        acl_iter = acliter("UserOne,UserTwo:read,write")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne', 'UserTwo']
-        assert rights == ['read', 'write']
+        assert entries == ["UserOne", "UserTwo"]
+        assert rights == ["read", "write"]
 
     def testMultipleWikiNameAndRightsSpaces(self):
-        """ security: multiple names with spaces """
-        acl_iter = acliter('user one,user two:read')
+        """security: multiple names with spaces"""
+        acl_iter = acliter("user one,user two:read")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user one', 'user two']
-        assert rights == ['read']
+        assert entries == ["user one", "user two"]
+        assert rights == ["read"]
 
     def testMultipleEntries(self):
-        """ security: multiple entries """
-        acl_iter = acliter('UserOne:read,write UserTwo:read All:')
+        """security: multiple entries"""
+        acl_iter = acliter("UserOne:read,write UserTwo:read All:")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne']
-        assert rights == ['read', 'write']
+        assert entries == ["UserOne"]
+        assert rights == ["read", "write"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserTwo']
-        assert rights == ['read']
+        assert entries == ["UserTwo"]
+        assert rights == ["read"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['All']
+        assert entries == ["All"]
         assert rights == []
 
     def testNameWithSpaces(self):
-        """ security: single name with spaces """
-        acl_iter = acliter('user one:read')
+        """security: single name with spaces"""
+        acl_iter = acliter("user one:read")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user one']
-        assert rights == ['read']
+        assert entries == ["user one"]
+        assert rights == ["read"]
 
     def testMultipleEntriesWithSpaces(self):
-        """ security: multiple entries with spaces """
-        acl_iter = acliter('user one:read,write user two:read')
+        """security: multiple entries with spaces"""
+        acl_iter = acliter("user one:read,write user two:read")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user one']
-        assert rights == ['read', 'write']
+        assert entries == ["user one"]
+        assert rights == ["read", "write"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user two']
-        assert rights == ['read']
+        assert entries == ["user two"]
+        assert rights == ["read"]
 
     def testMixedNames(self):
-        """ security: mixed wiki names and names with spaces """
-        acl_iter = acliter('UserOne,user two:read,write user three,UserFour:read')
+        """security: mixed wiki names and names with spaces"""
+        acl_iter = acliter("UserOne,user two:read,write user three,UserFour:read")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne', 'user two']
-        assert rights == ['read', 'write']
+        assert entries == ["UserOne", "user two"]
+        assert rights == ["read", "write"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user three', 'UserFour']
-        assert rights == ['read']
+        assert entries == ["user three", "UserFour"]
+        assert rights == ["read"]
 
     def testModifier(self):
-        """ security: acl modifiers """
-        acl_iter = acliter('+UserOne:read -UserTwo:')
+        """security: acl modifiers"""
+        acl_iter = acliter("+UserOne:read -UserTwo:")
         mod, entries, rights = next(acl_iter)
-        assert mod == '+'
-        assert entries == ['UserOne']
-        assert rights == ['read']
+        assert mod == "+"
+        assert entries == ["UserOne"]
+        assert rights == ["read"]
         mod, entries, rights = next(acl_iter)
-        assert mod == '-'
-        assert entries == ['UserTwo']
+        assert mod == "-"
+        assert entries == ["UserTwo"]
         assert rights == []
 
     def testIgnoreInvalidACL(self):
-        """ security: ignore invalid acl
+        """security: ignore invalid acl
 
         The last part of this acl can not be parsed. If it ends with :
         then it will be parsed as one name with spaces.
         """
-        acl_iter = acliter('UserOne:read user two is ignored')
+        acl_iter = acliter("UserOne:read user two is ignored")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne']
-        assert rights == ['read']
+        assert entries == ["UserOne"]
+        assert rights == ["read"]
         pytest.raises(StopIteration, acl_iter.__next__)
 
     def testEmptyNamesWithRight(self):
-        """ security: empty names with rights
+        """security: empty names with rights
 
         The documents does not talk about this case, may() should ignore
         the rights because there is no entry.
         """
-        acl_iter = acliter('UserOne:read :read All:')
+        acl_iter = acliter("UserOne:read :read All:")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne']
-        assert rights == ['read']
+        assert entries == ["UserOne"]
+        assert rights == ["read"]
         mod, entries, rights = next(acl_iter)
         assert entries == []
-        assert rights == ['read']
+        assert rights == ["read"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['All']
+        assert entries == ["All"]
         assert rights == []
 
     def testIgnoreInvalidRights(self):
-        """ security: ignore rights not in acl_rights_contents
+        """security: ignore rights not in acl_rights_contents
 
         Note: this is also important for ACL regeneration (see also acl
               regeneration test for storage.backends.fs19).
         """
-        acl_iter = acliter('UserOne:read,sing,write,drink,sleep')
+        acl_iter = acliter("UserOne:read,sing,write,drink,sleep")
         mod, entries, rights = next(acl_iter)
-        assert rights == ['read', 'write']
+        assert rights == ["read", "write"]
 
         # we use strange usernames that include invalid rights as substrings
         acls = list(acliter("JimAdelete,JoeArevert:admin,read,delete,write,revert"))
         # now check that we have lost the invalid rights 'delete' and 'revert',
         # but the usernames should be still intact.
-        assert acls == [('', ['JimAdelete', 'JoeArevert'], ['admin', 'read', 'write', ])]
+        assert acls == [("", ["JimAdelete", "JoeArevert"], ["admin", "read", "write"])]
 
     def testBadGuy(self):
-        """ security: bad guy may not allowed anything
+        """security: bad guy may not allowed anything
 
         This test was failing on the apply acl rights test.
         """
-        acl_iter = acliter('UserOne:read,write BadGuy: All:read')
+        acl_iter = acliter("UserOne:read,write BadGuy: All:read")
         mod, entries, rights = next(acl_iter)
         mod, entries, rights = next(acl_iter)
-        assert entries == ['BadGuy']
+        assert entries == ["BadGuy"]
         assert rights == []
 
     def testAllowExtraWhitespace(self):
-        """ security: allow extra white space between entries """
-        acl_iter = acliter('UserOne,user two:read,write   user three,UserFour:read  All:')
+        """security: allow extra white space between entries"""
+        acl_iter = acliter("UserOne,user two:read,write   user three,UserFour:read  All:")
         mod, entries, rights = next(acl_iter)
-        assert entries == ['UserOne', 'user two']
-        assert rights == ['read', 'write']
+        assert entries == ["UserOne", "user two"]
+        assert rights == ["read", "write"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['user three', 'UserFour']
-        assert rights == ['read']
+        assert entries == ["user three", "UserFour"]
+        assert rights == ["read"]
         mod, entries, rights = next(acl_iter)
-        assert entries == ['All']
+        assert entries == ["All"]
         assert rights == []
 
 
 class TestAcl:
-    """ security: testing access control list
+    """security: testing access control list
 
     TO DO: test unknown user?
     """
+
     def testhasACL(self):
         acl = AccessControlList(valid=app.cfg.acl_rights_contents)
         assert not acl.has_acl()
-        acl = AccessControlList(["All:read", ], valid=app.cfg.acl_rights_contents)
+        acl = AccessControlList(["All:read"], valid=app.cfg.acl_rights_contents)
         assert acl.has_acl()
 
     def testApplyACLByUser(self):
-        """ security: applying acl by user name"""
+        """security: applying acl by user name"""
         # This acl string...
         acl_rights = [
             "-MinusGuy:read "
@@ -230,31 +231,30 @@ def testApplyACLByUser(self):
         users = (
             # user,                 rights
             # CamelCase names
-            ('Admin1', ('read', 'write', 'admin')),
-            ('Admin2', ('read', 'write', 'admin')),
-            ('Admin3', ('read', 'write', 'admin')),
-            ('JoeDoe', ('read', 'write')),
-            ('SomeGuy', ('read', )),
+            ("Admin1", ("read", "write", "admin")),
+            ("Admin2", ("read", "write", "admin")),
+            ("Admin3", ("read", "write", "admin")),
+            ("JoeDoe", ("read", "write")),
+            ("SomeGuy", ("read",)),
             # Extended names or mix of extended and CamelCase
-            ('name with spaces', ('read', 'write', )),
-            ('another one', ('read', 'write', )),
-            ('CamelCase', ('read', 'write', )),
-            ('extended name', ('read', 'write', )),
+            ("name with spaces", ("read", "write")),
+            ("another one", ("read", "write")),
+            ("CamelCase", ("read", "write")),
+            ("extended name", ("read", "write")),
             # Blocking bad guys
-            ('BadGuy', ()),
+            ("BadGuy", ()),
             # All other users - every one not mentioned in the acl lines
-            ('All', ('read', )),
-            ('Anonymous', ('read', )),
+            ("All", ("read",)),
+            ("Anonymous", ("read",)),
             # we check whether ACL processing stops for a user/right match
             # with ACL modifiers
-            ('MinusGuy', ()),
-            ('PlusGuy', ('read', )),
+            ("MinusGuy", ()),
+            ("PlusGuy", ("read",)),
         )
 
         # Check rights
         for user, may in users:
-            mayNot = [right for right in app.cfg.acl_rights_contents
-                      if right not in may]
+            mayNot = [right for right in app.cfg.acl_rights_contents if right not in may]
             # User should have these rights...
             for right in may:
                 assert acl.may(user, right)
@@ -270,39 +270,35 @@ def cfg(self):
         class Config(wikiconfig.Config):
             def groups(cfg):
                 groups = {
-                    'PGroup': frozenset(['Antony', 'Beatrice', ]),
-                    'AGroup': frozenset(['All', ]),
+                    "PGroup": frozenset(["Antony", "Beatrice"]),
+                    "AGroup": frozenset(["All"]),
                     # note: the next line is a INTENDED misnomer, there is "All" in
                     # the group NAME, but not in the group members. This makes
                     # sure that a bug that erroneously checked "in groupname" (instead
                     # of "in groupmembers") does not reappear.
-                    'AllGroup': frozenset([]),  # note: intended misnomer
+                    "AllGroup": frozenset([]),  # note: intended misnomer
                 }
                 return ConfigGroups(groups)
 
         return Config
 
     def testApplyACLByGroup(self):
-        """ security: applying acl by group name"""
+        """security: applying acl by group name"""
         # This acl string...
-        acl_rights = [
-            "PGroup,AllGroup:read,write,admin "
-            "AGroup:read "
-        ]
+        acl_rights = ["PGroup,AllGroup:read,write,admin " "AGroup:read "]
         acl = AccessControlList(acl_rights, valid=app.cfg.acl_rights_contents)
 
         # Should apply these rights:
         users = (
             # user, rights
-            ('Antony', ('read', 'write', 'admin', )),  # in PGroup
-            ('Beatrice', ('read', 'write', 'admin', )),  # in PGroup
-            ('Charles', ('read', )),  # virtually in AGroup
+            ("Antony", ("read", "write", "admin")),  # in PGroup
+            ("Beatrice", ("read", "write", "admin")),  # in PGroup
+            ("Charles", ("read",)),  # virtually in AGroup
         )
 
         # Check rights
         for user, may in users:
-            mayNot = [right for right in app.cfg.acl_rights_contents
-                      if right not in may]
+            mayNot = [right for right in app.cfg.acl_rights_contents if right not in may]
             # User should have these rights...
             for right in may:
                 assert acl.may(user, right)
@@ -312,39 +308,44 @@ def testApplyACLByGroup(self):
 
 
 class TestItemAcls:
-    """ security: real-life access control list on items testing
-    """
-    mainitem_name = 'AclTestMainItem'
-    subitem1_name = 'AclTestMainItem/SubItem1'
-    subitem2_name = 'AclTestMainItem/SubItem2'
-    item_rwforall = 'EveryoneMayReadWriteMe'
-    subitem_4boss = 'EveryoneMayReadWriteMe/OnlyTheBossMayWMe'
+    """security: real-life access control list on items testing"""
+
+    mainitem_name = "AclTestMainItem"
+    subitem1_name = "AclTestMainItem/SubItem1"
+    subitem2_name = "AclTestMainItem/SubItem2"
+    item_rwforall = "EveryoneMayReadWriteMe"
+    subitem_4boss = "EveryoneMayReadWriteMe/OnlyTheBossMayWMe"
     items = [
         # itemname, acl, content
-        (mainitem_name, 'JoeDoe: JaneDoe:read,write', 'Foo!'),
+        (mainitem_name, "JoeDoe: JaneDoe:read,write", "Foo!"),
         # acl None means: "no acl given in item metadata" - this will trigger
         # usage of default acl (non-hierarchical) or usage of default acl and
         # inheritance (hierarchical):
-        (subitem1_name, None, 'FooFoo!'),
+        (subitem1_name, None, "FooFoo!"),
         # acl '' means: "empty acl (no rights for anyone) given" - this will
         # INHIBIT usage of default acl / inheritance (we DO HAVE an item acl,
         # it is just empty!):
-        (subitem2_name, '', 'BarBar!'),
-        (item_rwforall, 'All:read,write', 'May be read from and written to by anyone'),
-        (subitem_4boss, 'JoeDoe:read,write', 'Only JoeDoe (the boss) may write'),
+        (subitem2_name, "", "BarBar!"),
+        (item_rwforall, "All:read,write", "May be read from and written to by anyone"),
+        (subitem_4boss, "JoeDoe:read,write", "Only JoeDoe (the boss) may write"),
     ]
 
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            default_acl = dict(hierarchic=False, before="WikiAdmin:admin,read,write,create,destroy", default="All:read,write", after="All:read")
+            default_acl = dict(
+                hierarchic=False,
+                before="WikiAdmin:admin,read,write,create,destroy",
+                default="All:read,write",
+                after="All:read",
+            )
             acl_functions = "SuperUser:superuser"
 
         return Config
 
     @pytest.fixture(autouse=True)
     def custom_setup(self):
-        become_trusted(username='WikiAdmin')
+        become_trusted(username="WikiAdmin")
         for item_name, item_acl, item_content in self.items:
             if item_acl is not None:
                 update_item(item_name, {ACL: item_acl}, item_content)
@@ -352,21 +353,21 @@ def custom_setup(self):
                 update_item(item_name, {}, item_content)
 
     def test_ItemACLs(self):
-        """ security: test item acls """
+        """security: test item acls"""
         tests = [
             # itemname, username, expected_rights
-            (self.mainitem_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.mainitem_name, 'AnyUser', ['read']),  # by after acl
-            (self.mainitem_name, 'JaneDoe', ['read', 'write']),  # by item acl
-            (self.mainitem_name, 'JoeDoe', []),  # by item acl
-            (self.subitem1_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.subitem1_name, 'AnyUser', ['read', 'write']),  # by default acl
-            (self.subitem1_name, 'JoeDoe', ['read', 'write']),  # by default acl
-            (self.subitem1_name, 'JaneDoe', ['read', 'write']),  # by default acl
-            (self.subitem2_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.subitem2_name, 'AnyUser', ['read']),  # by after acl
-            (self.subitem2_name, 'JoeDoe', ['read']),  # by after acl
-            (self.subitem2_name, 'JaneDoe', ['read']),  # by after acl
+            (self.mainitem_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.mainitem_name, "AnyUser", ["read"]),  # by after acl
+            (self.mainitem_name, "JaneDoe", ["read", "write"]),  # by item acl
+            (self.mainitem_name, "JoeDoe", []),  # by item acl
+            (self.subitem1_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.subitem1_name, "AnyUser", ["read", "write"]),  # by default acl
+            (self.subitem1_name, "JoeDoe", ["read", "write"]),  # by default acl
+            (self.subitem1_name, "JaneDoe", ["read", "write"]),  # by default acl
+            (self.subitem2_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.subitem2_name, "AnyUser", ["read"]),  # by after acl
+            (self.subitem2_name, "JoeDoe", ["read"]),  # by after acl
+            (self.subitem2_name, "JaneDoe", ["read"]),  # by after acl
         ]
 
         for itemname, username, may in tests:
@@ -385,45 +386,50 @@ def test_ItemACLs(self):
                 assert not can_access, f"{u.name!r} may not {right} {itemname!r} (normal)"
 
         # check function rights
-        u = User(auth_username='SuperUser')
+        u = User(auth_username="SuperUser")
         assert u.may.superuser()
-        u = User(auth_username='SomeGuy')
+        u = User(auth_username="SomeGuy")
         assert not u.may.superuser()
 
 
 class TestItemHierachicalAcls:
-    """ security: real-life access control list on items testing
-    """
-    mainitem_name = 'AclTestMainItem'
-    subitem1_name = 'AclTestMainItem/SubItem1'
-    subitem2_name = 'AclTestMainItem/SubItem2'
-    item_rwforall = 'EveryoneMayReadWriteMe'
-    subitem_4boss = 'EveryoneMayReadWriteMe/OnlyTheBossMayWMe'
+    """security: real-life access control list on items testing"""
+
+    mainitem_name = "AclTestMainItem"
+    subitem1_name = "AclTestMainItem/SubItem1"
+    subitem2_name = "AclTestMainItem/SubItem2"
+    item_rwforall = "EveryoneMayReadWriteMe"
+    subitem_4boss = "EveryoneMayReadWriteMe/OnlyTheBossMayWMe"
     items = [
         # itemname, acl, content
-        (mainitem_name, 'JoeDoe: JaneDoe:read,write', 'Foo!'),
+        (mainitem_name, "JoeDoe: JaneDoe:read,write", "Foo!"),
         # acl None means: "no acl given in item metadata" - this will trigger
         # usage of default acl (non-hierarchical) or usage of default acl and
         # inheritance (hierarchical):
-        (subitem1_name, None, 'FooFoo!'),
+        (subitem1_name, None, "FooFoo!"),
         # acl '' means: "empty acl (no rights for anyone) given" - this will
         # INHIBIT usage of default acl / inheritance (we DO HAVE an item acl,
         # it is just empty!):
-        (subitem2_name, '', 'BarBar!'),
-        (item_rwforall, 'All:read,write', 'May be read from and written to by anyone'),
-        (subitem_4boss, 'JoeDoe:read,write', 'Only JoeDoe (the boss) may write'),
+        (subitem2_name, "", "BarBar!"),
+        (item_rwforall, "All:read,write", "May be read from and written to by anyone"),
+        (subitem_4boss, "JoeDoe:read,write", "Only JoeDoe (the boss) may write"),
     ]
 
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            default_acl = dict(hierarchic=True, before="WikiAdmin:admin,read,write,create,destroy", default="All:read,write", after="All:read")
+            default_acl = dict(
+                hierarchic=True,
+                before="WikiAdmin:admin,read,write,create,destroy",
+                default="All:read,write",
+                after="All:read",
+            )
 
         return Config
 
     @pytest.fixture(autouse=True)
     def custom_setup(self):
-        become_trusted(username='WikiAdmin')
+        become_trusted(username="WikiAdmin")
         for item_name, item_acl, item_content in self.items:
             if item_acl is not None:
                 update_item(item_name, {ACL: item_acl}, item_content)
@@ -431,23 +437,23 @@ def custom_setup(self):
                 update_item(item_name, {}, item_content)
 
     def testItemACLs(self):
-        """ security: test item acls """
+        """security: test item acls"""
         tests = [
             # itemname, username, expected_rights
-            (self.mainitem_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.mainitem_name, 'AnyUser', ['read']),  # by after acl
-            (self.mainitem_name, 'JaneDoe', ['read', 'write']),  # by item acl
-            (self.mainitem_name, 'JoeDoe', []),  # by item acl
-            (self.subitem1_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.subitem1_name, 'AnyUser', ['read']),  # by after acl
-            (self.subitem1_name, 'JoeDoe', []),  # by inherited acl from main item
-            (self.subitem1_name, 'JaneDoe', ['read', 'write']),  # by inherited acl from main item
-            (self.subitem2_name, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),
-            (self.subitem2_name, 'AnyUser', ['read']),  # by after acl
-            (self.subitem2_name, 'JoeDoe', ['read']),  # by after acl
-            (self.subitem2_name, 'JaneDoe', ['read']),  # by after acl
-            (self.subitem_4boss, 'AnyUser', ['read']),  # by after acl
-            (self.subitem_4boss, 'JoeDoe', ['read', 'write']),  # by item acl
+            (self.mainitem_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.mainitem_name, "AnyUser", ["read"]),  # by after acl
+            (self.mainitem_name, "JaneDoe", ["read", "write"]),  # by item acl
+            (self.mainitem_name, "JoeDoe", []),  # by item acl
+            (self.subitem1_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.subitem1_name, "AnyUser", ["read"]),  # by after acl
+            (self.subitem1_name, "JoeDoe", []),  # by inherited acl from main item
+            (self.subitem1_name, "JaneDoe", ["read", "write"]),  # by inherited acl from main item
+            (self.subitem2_name, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),
+            (self.subitem2_name, "AnyUser", ["read"]),  # by after acl
+            (self.subitem2_name, "JoeDoe", ["read"]),  # by after acl
+            (self.subitem2_name, "JaneDoe", ["read"]),  # by after acl
+            (self.subitem_4boss, "AnyUser", ["read"]),  # by after acl
+            (self.subitem_4boss, "JoeDoe", ["read", "write"]),  # by item acl
         ]
 
         for itemname, username, may in tests:
@@ -460,26 +466,25 @@ def testItemACLs(self):
                 assert can_access, f"{u.name!r} may {right} {itemname!r} (hierarchic)"
 
             # User should NOT have these rights:
-            mayNot = [right for right in app.cfg.acl_rights_contents
-                      if right not in may]
+            mayNot = [right for right in app.cfg.acl_rights_contents if right not in may]
             for right in mayNot:
                 can_access = getattr(u.may, right)(itemname)
                 assert not can_access, f"{u.name!r} may not {right} {itemname!r} (hierarchic)"
 
 
 class TestItemHierachicalAclsMultiItemNames:
-    """ security: real-life access control list on items testing
-    """
+    """security: real-life access control list on items testing"""
+
     # parent / child item names
-    p1 = ['p1', ]
-    c1 = ['p1/c1', ]
-    p2 = ['p2', ]
-    c2 = ['p2/c2', ]
-    c12 = ['p1/c12', 'p2/c12', ]
-    content = b''
+    p1 = ["p1"]
+    c1 = ["p1/c1"]
+    p2 = ["p2"]
+    c2 = ["p2/c2"]
+    c12 = ["p1/c12", "p2/c12"]
+    content = b""
     items = [
         # itemnames, acl, content
-        (p1, 'Editor:', content),  # deny access (due to hierarchic acl mode also effective for children)
+        (p1, "Editor:", content),  # deny access (due to hierarchic acl mode also effective for children)
         (c1, None, content),  # no own acl -> inherit from parent
         (p2, None, content),  # default acl effective (also for children)
         (c2, None, content),  # no own acl -> inherit from parent
@@ -489,12 +494,18 @@ class TestItemHierachicalAclsMultiItemNames:
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            default_acl = dict(hierarchic=True, before="WikiAdmin:admin,read,write,create,destroy", default="Editor:read,write", after="All:read")
+            default_acl = dict(
+                hierarchic=True,
+                before="WikiAdmin:admin,read,write,create,destroy",
+                default="Editor:read,write",
+                after="All:read",
+            )
+
         return Config
 
     @pytest.fixture(autouse=True)
     def custom_setup(self):
-        become_trusted(username='WikiAdmin')
+        become_trusted(username="WikiAdmin")
         for item_names, item_acl, item_content in self.items:
             meta = {NAME: item_names}
             if item_acl is not None:
@@ -502,25 +513,25 @@ def custom_setup(self):
             update_item(item_names[0], meta, item_content)
 
     def testItemACLs(self):
-        """ security: test item acls """
+        """security: test item acls"""
         tests = [
             # itemname, username, expected_rights
-            (self.p1, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),  # by before acl
-            (self.p2, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),  # by before acl
-            (self.c1, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),  # by before acl
-            (self.c2, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),  # by before acl
-            (self.c12, 'WikiAdmin', ['read', 'write', 'admin', 'create', 'destroy']),  # by before acl
-            (self.p1, 'Editor', []),  # by p1 acl
-            (self.c1, 'Editor', []),  # by p1 acl
-            (self.p1, 'SomeOne', ['read']),  # by after acl
-            (self.c1, 'SomeOne', ['read']),  # by after acl
-            (self.p2, 'Editor', ['read', 'write']),  # by default acl
-            (self.c2, 'Editor', ['read', 'write']),  # by default acl
-            (self.p2, 'SomeOne', ['read']),  # by after acl
-            (self.c2, 'SomeOne', ['read']),  # by after acl
-            (self.c12, 'SomeOne', ['read']),  # by after acl
+            (self.p1, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),  # by before acl
+            (self.p2, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),  # by before acl
+            (self.c1, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),  # by before acl
+            (self.c2, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),  # by before acl
+            (self.c12, "WikiAdmin", ["read", "write", "admin", "create", "destroy"]),  # by before acl
+            (self.p1, "Editor", []),  # by p1 acl
+            (self.c1, "Editor", []),  # by p1 acl
+            (self.p1, "SomeOne", ["read"]),  # by after acl
+            (self.c1, "SomeOne", ["read"]),  # by after acl
+            (self.p2, "Editor", ["read", "write"]),  # by default acl
+            (self.c2, "Editor", ["read", "write"]),  # by default acl
+            (self.p2, "SomeOne", ["read"]),  # by after acl
+            (self.c2, "SomeOne", ["read"]),  # by after acl
+            (self.c12, "SomeOne", ["read"]),  # by after acl
             # now check the rather special stuff:
-            (self.c12, 'Editor', ['read', 'write']),  # disallowed via p1, but allowed via p2 via default acl
+            (self.c12, "Editor", ["read", "write"]),  # disallowed via p1, but allowed via p2 via default acl
         ]
 
         for itemnames, username, may in tests:
@@ -534,8 +545,7 @@ def testItemACLs(self):
                 assert can_access, f"{u.name!r} may {right} {itemname!r} (hierarchic)"
 
             # User should NOT have these rights:
-            mayNot = [right for right in app.cfg.acl_rights_contents
-                      if right not in may]
+            mayNot = [right for right in app.cfg.acl_rights_contents if right not in may]
             for right in mayNot:
                 can_access = getattr(u.may, right)(itemname)
                 assert not can_access, f"{u.name!r} may not {right} {itemname!r} (hierarchic)"
@@ -543,4 +553,4 @@ def testItemACLs(self):
 
 # XXX TODO add tests for a user having multiple usernames (one resulting in more permissions than other)
 
-coverage_modules = ['moin.security']
+coverage_modules = ["moin.security"]
diff --git a/src/moin/signalling/log.py b/src/moin/signalling/log.py
index e5357b89b..bacc14082 100644
--- a/src/moin/signalling/log.py
+++ b/src/moin/signalling/log.py
@@ -10,6 +10,7 @@
 from flask import got_request_exception
 
 from .. import log
+
 logging = log.getLogger(__name__)
 
 
diff --git a/src/moin/signalling/signals.py b/src/moin/signalling/signals.py
index 1cf2b82bf..1dfcec964 100644
--- a/src/moin/signalling/signals.py
+++ b/src/moin/signalling/signals.py
@@ -12,5 +12,5 @@
 
 _signals = Namespace()
 
-item_displayed = _signals.signal('item_displayed')
-item_modified = _signals.signal('item_modified')
+item_displayed = _signals.signal("item_displayed")
+item_modified = _signals.signal("item_modified")
diff --git a/src/moin/storage/__init__.py b/src/moin/storage/__init__.py
index 305cfbbfe..472f57b56 100644
--- a/src/moin/storage/__init__.py
+++ b/src/moin/storage/__init__.py
@@ -21,27 +21,32 @@
                                    over key/value pairs
 """
 
-from moin.constants.namespaces import (NAMESPACE_DEFAULT, NAMESPACE_USERPROFILES, NAMESPACE_USERS,
-                                       NAMESPACE_HELP_COMMON, NAMESPACE_HELP_EN)
+from moin.constants.namespaces import (
+    NAMESPACE_DEFAULT,
+    NAMESPACE_USERPROFILES,
+    NAMESPACE_USERS,
+    NAMESPACE_HELP_COMMON,
+    NAMESPACE_HELP_EN,
+)
 
-BACKENDS_PACKAGE = 'moin.storage.backends'
+BACKENDS_PACKAGE = "moin.storage.backends"
 
-BACKEND_DEFAULT = 'default'
-BACKEND_USERPROFILES = 'userprofiles'
-BACKEND_USERS = 'users'
-BACKEND_HELP_COMMON = 'help-common'
-BACKEND_HELP_EN = 'help-en'
+BACKEND_DEFAULT = "default"
+BACKEND_USERPROFILES = "userprofiles"
+BACKEND_USERS = "users"
+BACKEND_HELP_COMMON = "help-common"
+BACKEND_HELP_EN = "help-en"
 
 
 def backend_from_uri(uri):
     """
     create a backend instance for uri
     """
-    backend_name_uri = uri.split(':', 1)
+    backend_name_uri = uri.split(":", 1)
     if len(backend_name_uri) != 2:
         raise ValueError(f"malformed backend uri: {uri}")
     backend_name, backend_uri = backend_name_uri
-    module = __import__(BACKENDS_PACKAGE + '.' + backend_name, globals(), locals(), ['MutableBackend', ])
+    module = __import__(BACKENDS_PACKAGE + "." + backend_name, globals(), locals(), ["MutableBackend"])
     return module.MutableBackend.from_uri(backend_uri)
 
 
@@ -49,16 +54,22 @@ def create_mapping(uri, namespaces, backends, acls):
     namespace_mapping = namespaces.items()
     acl_mapping = acls.items()
     backend_mapping = [
-        (backend_name, backend_from_uri(uri % dict(backend=backend_name, kind="%(kind)s")))
-        for backend_name in backends]
+        (backend_name, backend_from_uri(uri % dict(backend=backend_name, kind="%(kind)s"))) for backend_name in backends
+    ]
     # we need the longest mountpoints first, shortest last (-> '' is very last)
     namespace_mapping = sorted(namespace_mapping, key=lambda x: len(x[0]), reverse=True)
     acl_mapping = sorted(acl_mapping, key=lambda x: len(x[0]), reverse=True)
     return namespace_mapping, dict(backend_mapping), acl_mapping
 
 
-def create_simple_mapping(uri='stores:fs:instance', default_acl=None, userprofiles_acl=None,
-                          users_acl=None, help_common_acl=None, help_en_acl=None, ):
+def create_simple_mapping(
+    uri="stores:fs:instance",
+    default_acl=None,
+    userprofiles_acl=None,
+    users_acl=None,
+    help_common_acl=None,
+    help_en_acl=None,
+):
     """
     When configuring storage, the admin needs to provide a namespace_mapping.
     To ease creation of such a mapping, this function provides sane defaults
@@ -84,15 +95,15 @@ def create_simple_mapping(uri='stores:fs:instance', default_acl=None, userprofil
     """
     # if no acls are given, use something mostly harmless:
     if not default_acl:
-        default_acl = dict(before='', default='All:read,write,create,admin', after='', hierarchic=False)
+        default_acl = dict(before="", default="All:read,write,create,admin", after="", hierarchic=False)
     if not userprofiles_acl:
-        userprofiles_acl = dict(before='All:', default='', after='', hierarchic=False)
+        userprofiles_acl = dict(before="All:", default="", after="", hierarchic=False)
     if not users_acl:
-        users_acl = dict(before='', default='All:read,write,create,admin', after='', hierarchic=False)
+        users_acl = dict(before="", default="All:read,write,create,admin", after="", hierarchic=False)
     if not help_common_acl:
-        help_common_acl = dict(before='', default='All:read,write,create,admin', after='', hierarchic=False)
+        help_common_acl = dict(before="", default="All:read,write,create,admin", after="", hierarchic=False)
     if not help_en_acl:
-        help_en_acl = dict(before='', default='All:read,write,create,admin', after='', hierarchic=False)
+        help_en_acl = dict(before="", default="All:read,write,create,admin", after="", hierarchic=False)
     namespaces = {
         NAMESPACE_DEFAULT: BACKEND_DEFAULT,
         NAMESPACE_USERPROFILES: BACKEND_USERPROFILES,
diff --git a/src/moin/storage/backends/__init__.py b/src/moin/storage/backends/__init__.py
index 93f27a0b0..46f890ac8 100644
--- a/src/moin/storage/backends/__init__.py
+++ b/src/moin/storage/backends/__init__.py
@@ -50,6 +50,7 @@ class MutableBackendBase(BackendBase):
     """
     same as Backend, but read/write
     """
+
     @abstractmethod
     def create(self):
         """
diff --git a/src/moin/storage/backends/_tests/__init__.py b/src/moin/storage/backends/_tests/__init__.py
index 951e5e375..cc738bc5a 100644
--- a/src/moin/storage/backends/_tests/__init__.py
+++ b/src/moin/storage/backends/_tests/__init__.py
@@ -27,7 +27,7 @@ def teardown_method(self, method):
 
     def test_getrevision_raises(self):
         with pytest.raises(KeyError):
-            self.be.retrieve('doesnotexist')
+            self.be.retrieve("doesnotexist")
 
     def test_iter(self):
         assert list(self.be) == []
@@ -49,11 +49,11 @@ def teardown_method(self, method):
 
     def test_getrevision_raises(self):
         with pytest.raises(KeyError):
-            self.be.retrieve('doesnotexist')
+            self.be.retrieve("doesnotexist")
 
     def test_store_get_del(self):
-        meta = dict(foo='bar')
-        data = b'baz'
+        meta = dict(foo="bar")
+        data = b"baz"
         metaid = self.be.store(meta, BytesIO(data))
         m, d = self.be.retrieve(metaid)
         assert m == meta
@@ -65,54 +65,54 @@ def test_store_get_del(self):
 
     def test_store_check_size(self):
         # no size
-        meta = dict(name='foo')
-        data = b'barbaz'
+        meta = dict(name="foo")
+        data = b"barbaz"
         metaid = self.be.store(meta, BytesIO(data))
         m, d = self.be.retrieve(metaid)
         assert meta[SIZE] == 6
         # correct size
-        meta = dict(name='foo', size=6)
-        data = b'barbaz'
+        meta = dict(name="foo", size=6)
+        data = b"barbaz"
         metaid = self.be.store(meta, BytesIO(data))
         m, d = self.be.retrieve(metaid)
         assert meta[SIZE] == 6
         # wrong size (less data than size declared in meta)
-        meta = dict(name='foo', size=42)
-        data = b'barbaz'
+        meta = dict(name="foo", size=42)
+        data = b"barbaz"
         with pytest.raises(ValueError):
             metaid = self.be.store(meta, BytesIO(data))
         # wrong size (more data than size declared in meta)
-        meta = dict(name='foo', size=3)
-        data = b'barbaz'
+        meta = dict(name="foo", size=3)
+        data = b"barbaz"
         with pytest.raises(ValueError):
             metaid = self.be.store(meta, BytesIO(data))
 
     def test_store_check_hash(self):
         # no hash
-        meta = dict(name='foo')
-        data = b'barbaz'
+        meta = dict(name="foo")
+        data = b"barbaz"
         metaid = self.be.store(meta, BytesIO(data))
         m, d = self.be.retrieve(metaid)
         hashcode = meta[HASH_ALGORITHM]
         # correct hash
-        meta = dict(name='foo')
+        meta = dict(name="foo")
         meta[HASH_ALGORITHM] = hashcode
-        data = b'barbaz'
+        data = b"barbaz"
         metaid = self.be.store(meta, BytesIO(data))
         m, d = self.be.retrieve(metaid)
         assert meta[HASH_ALGORITHM] == hashcode
         # wrong data -> hash mismatch
-        meta = dict(name='foo')
+        meta = dict(name="foo")
         meta[HASH_ALGORITHM] = hashcode
-        data = b'brrbrr'
+        data = b"brrbrr"
         with pytest.raises(ValueError):
             metaid = self.be.store(meta, BytesIO(data))
 
     def test_iter(self):
         mds = [  # (metadata items, data str)
-            (dict(name='one'), b'ONE'),
-            (dict(name='two'), b'TWO'),
-            (dict(name='three'), b'THREE'),
+            (dict(name="one"), b"ONE"),
+            (dict(name="two"), b"TWO"),
+            (dict(name="three"), b"THREE"),
         ]
         expected_result = set()
         for m, d in mds:
diff --git a/src/moin/storage/backends/_tests/test_fileserver.py b/src/moin/storage/backends/_tests/test_fileserver.py
index 9b29dd08f..cb9f8dd1b 100644
--- a/src/moin/storage/backends/_tests/test_fileserver.py
+++ b/src/moin/storage/backends/_tests/test_fileserver.py
@@ -28,7 +28,7 @@ def _prepare(self, items):
                 os.makedirs(dn)
             except:  # noqa
                 pass
-            with open(fn, 'wb') as f:
+            with open(fn, "wb") as f:
                 f.write(data)
             meta[NAME] = name
             meta = tuple(sorted(meta.items()))
@@ -42,24 +42,26 @@ def test_iter(self):
         assert len(contents) == 1
         root_revid = contents[0]
         # revids are like relpath.mtime
-        relpath, mtime = root_revid.split('.')
-        assert relpath == ''
+        relpath, mtime = root_revid.split(".")
+        assert relpath == ""
 
     def test_files(self):
         # note: as we can only store the data into the file system, meta can
         # only have items that are generated by the fileserver backend:
         items = [  # name,  meta,   data
-            ('foo.png', dict(size=11, contenttype='image/png'), b'png content'),
-            ('bar.txt', dict(size=12, contenttype='text/plain'), b'text content'),
+            ("foo.png", dict(size=11, contenttype="image/png"), b"png content"),
+            ("bar.txt", dict(size=12, contenttype="text/plain"), b"text content"),
         ]
         expected_result = self._prepare(items)
-        dir_meta = tuple(sorted(dict(name='', size=0, contenttype='text/x.moin.wiki;charset=utf-8').items()))
+        dir_meta = tuple(sorted(dict(name="", size=0, contenttype="text/x.moin.wiki;charset=utf-8").items()))
         dir_data = """\
 = Directory contents =
  * [[../]]
  * [[/bar.txt|bar.txt]]
  * [[/foo.png|foo.png]]
-""".replace('\n', '\r\n').encode()
+""".replace(
+            "\n", "\r\n"
+        ).encode()
         expected_result.add((dir_meta, dir_data))
         result = set()
         for i in self.be:
@@ -78,24 +80,28 @@ def test_dir(self):
         # note: as we can only store the data into the file system, meta can
         # only have items that are generated by the fileserver backend:
         items = [  # name,  meta,   data
-            ('dir/foo.png', dict(size=11, contenttype='image/png'), b'png content'),
-            ('dir/bar.txt', dict(size=12, contenttype='text/plain'), b'text content'),
+            ("dir/foo.png", dict(size=11, contenttype="image/png"), b"png content"),
+            ("dir/bar.txt", dict(size=12, contenttype="text/plain"), b"text content"),
         ]
         expected_result = self._prepare(items)
-        dir_meta = tuple(sorted(dict(name='', size=0, contenttype='text/x.moin.wiki;charset=utf-8').items()))
+        dir_meta = tuple(sorted(dict(name="", size=0, contenttype="text/x.moin.wiki;charset=utf-8").items()))
         dir_data = """\
 = Directory contents =
  * [[../]]
  * [[/dir|dir/]]
-""".replace('\n', '\r\n').encode()
+""".replace(
+            "\n", "\r\n"
+        ).encode()
         expected_result.add((dir_meta, dir_data))
-        dir_meta = tuple(sorted(dict(name='dir', size=0, contenttype='text/x.moin.wiki;charset=utf-8').items()))
+        dir_meta = tuple(sorted(dict(name="dir", size=0, contenttype="text/x.moin.wiki;charset=utf-8").items()))
         dir_data = """\
 = Directory contents =
  * [[../]]
  * [[/bar.txt|bar.txt]]
  * [[/foo.png|foo.png]]
-""".replace('\n', '\r\n').encode()
+""".replace(
+            "\n", "\r\n"
+        ).encode()
         expected_result.add((dir_meta, dir_data))
         result = set()
         for i in self.be:
diff --git a/src/moin/storage/backends/_util.py b/src/moin/storage/backends/_util.py
index 6dc547e30..6b5012fd2 100644
--- a/src/moin/storage/backends/_util.py
+++ b/src/moin/storage/backends/_util.py
@@ -17,13 +17,14 @@ class TrackingFileWrapper:
     After this self.hash and self.size will have the wanted values.
     self.hash is the hash instance, you may want to call self.hash.hexdigest().
     """
-    def __init__(self, realfile, hash_method='sha1'):
+
+    def __init__(self, realfile, hash_method="sha1"):
         self._realfile = realfile
         self._read = realfile.read
         self._hash = hashlib.new(hash_method)
         self._size = 0
         self._finished = False
-        if hasattr(realfile, 'tell'):
+        if hasattr(realfile, "tell"):
             fpos = realfile.tell()
             if fpos:
                 raise ValueError("file needs to be at pos 0")
diff --git a/src/moin/storage/backends/fileserver.py b/src/moin/storage/backends/fileserver.py
index 64dff992e..98cc13d0b 100644
--- a/src/moin/storage/backends/fileserver.py
+++ b/src/moin/storage/backends/fileserver.py
@@ -25,13 +25,14 @@
 
 from moin.utils.mimetype import MimeType
 
-NAME_SEP = '/'
+NAME_SEP = "/"
 
 
 class Backend(BackendBase):
     """
     exposes part of the filesystem (read-only)
     """
+
     @classmethod
     def from_uri(cls, uri):
         return cls(uri)
@@ -54,7 +55,7 @@ def _mkpath(self, key):
         """
         # XXX unsafe keys?
         try:
-            itemname, mtime = key.rsplit('.', 1)
+            itemname, mtime = key.rsplit(".", 1)
         except ValueError:
             # we only generate revids that look like path.mtime,
             # so if the split does not work, the revid is invalid
@@ -74,7 +75,7 @@ def _mkkey(self, path):
         st = os.stat(path)
         root = self.path
         assert path.startswith(root)
-        relpath = path[len(root) + 1:]
+        relpath = path[len(root) + 1 :]
         # we always want to give NAME_SEP-separated names (not backslash):
         if os.sep == NAME_SEP:
             itemname = relpath
@@ -88,7 +89,7 @@ def _encode(self, key):
         we need to get rid of slashes in revids because we put them into URLs
         and it would confuse the URL routing.
         """
-        return url_quote(key, safe='')
+        return url_quote(key, safe="")
 
     def _decode(self, qkey):
         return url_unquote(qkey)
@@ -103,13 +104,13 @@ def _get_meta(self, itemname, path):
         meta = {}
         meta[NAME] = itemname
         meta[MTIME] = int(st.st_mtime)  # use int, not float
-        meta[REVID] = str(self._encode('%s.%d' % (meta[NAME], meta[MTIME])))
+        meta[REVID] = str(self._encode("%s.%d" % (meta[NAME], meta[MTIME])))
         meta[ITEMID] = meta[REVID]
-        meta[HASH_ALGORITHM] = ''  # XXX crap, but sendfile needs it for etag
+        meta[HASH_ALGORITHM] = ""  # XXX crap, but sendfile needs it for etag
         if stat.S_ISDIR(st.st_mode):
             # directory
             # we create a virtual wiki page listing links to subitems:
-            ct = 'text/x.moin.wiki;charset=utf-8'
+            ct = "text/x.moin.wiki;charset=utf-8"
             size = 0
         elif stat.S_ISREG(st.st_mode):
             # normal file
@@ -117,7 +118,7 @@ def _get_meta(self, itemname, path):
             size = int(st.st_size)  # use int instead of long
         else:
             # symlink, device file, etc.
-            ct = 'application/octet-stream'
+            ct = "application/octet-stream"
             size = 0
         meta[CONTENTTYPE] = ct
         meta[SIZE] = size
@@ -134,14 +135,11 @@ def _make_directory_page(self, path):
                     dirs.append(name)
                 else:
                     files.append(name)
-            content = [
-                "= Directory contents =",
-                " * [[../]]",
-            ]
+            content = ["= Directory contents =", " * [[../]]"]
             content.extend(f" * [[/{name}|{name}/]]" for name in sorted(dirs))
             content.extend(f" * [[/{name}|{name}]]" for name in sorted(files))
             content.append("")
-            content = '\r\n'.join(content)
+            content = "\r\n".join(content)
         except OSError as err:
             content = str(err)
         return content
@@ -151,11 +149,11 @@ def _get_data(self, itemname, path):
             st = os.stat(path)
             if stat.S_ISDIR(st.st_mode):
                 data = self._make_directory_page(path)
-                return BytesIO(data.encode('utf-8'))
+                return BytesIO(data.encode("utf-8"))
             elif stat.S_ISREG(st.st_mode):
-                return open(path, 'rb')
+                return open(path, "rb")
             else:
-                return BytesIO(b'')
+                return BytesIO(b"")
         except OSError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError(itemname)
@@ -168,9 +166,9 @@ def __iter__(self):
         for dirpath, dirnames, filenames in os.walk(self.path):
             key, mtime = self._mkkey(dirpath)
             if 1:  # key:
-                yield self._encode('%s.%d' % (key, mtime))
+                yield self._encode("%s.%d" % (key, mtime))
             for filename in filenames:
-                yield self._encode('%s.%d' % self._mkkey(os.path.join(dirpath, filename)))
+                yield self._encode("%s.%d" % self._mkkey(os.path.join(dirpath, filename)))
 
     def retrieve(self, key):
         key = self._decode(key)
diff --git a/src/moin/storage/backends/stores.py b/src/moin/storage/backends/stores.py
index 6bb98328c..35e13eb9c 100644
--- a/src/moin/storage/backends/stores.py
+++ b/src/moin/storage/backends/stores.py
@@ -26,22 +26,23 @@
 from . import BackendBase, MutableBackendBase
 from ._util import TrackingFileWrapper
 
-STORES_PACKAGE = 'moin.storage.stores'
+STORES_PACKAGE = "moin.storage.stores"
 
 
 class Backend(BackendBase):
     """
     ties together a store for metadata and a store for data, readonly
     """
+
     @classmethod
     def from_uri(cls, uri):
-        store_name_uri = uri.split(':', 1)
+        store_name_uri = uri.split(":", 1)
         if len(store_name_uri) != 2:
             raise ValueError(f"malformed store uri: {uri}")
         store_name, store_uri = store_name_uri
-        module = __import__(STORES_PACKAGE + '.' + store_name, globals(), locals(), ['BytesStore', 'FileStore', ])
-        meta_store_uri = store_uri % dict(kind='meta')
-        data_store_uri = store_uri % dict(kind='data')
+        module = __import__(STORES_PACKAGE + "." + store_name, globals(), locals(), ["BytesStore", "FileStore"])
+        meta_store_uri = store_uri % dict(kind="meta")
+        data_store_uri = store_uri % dict(kind="data")
         return cls(module.BytesStore.from_uri(meta_store_uri), module.FileStore.from_uri(data_store_uri))
 
     def __init__(self, meta_store, data_store):
@@ -64,7 +65,7 @@ def __iter__(self):
         yield from self.meta_store
 
     def _deserialize(self, meta_str):
-        text = meta_str.decode('utf-8')
+        text = meta_str.decode("utf-8")
         meta = json.loads(text)
         return meta
 
@@ -94,6 +95,7 @@ class MutableBackend(Backend, MutableBackendBase):
     """
     same as Backend, but read/write
     """
+
     def create(self):
         self.meta_store.create()
         self.data_store.create()
@@ -104,7 +106,7 @@ def destroy(self):
 
     def _serialize(self, meta):
         text = json.dumps(meta, ensure_ascii=False)
-        meta_str = text.encode('utf-8')
+        meta_str = text.encode("utf-8")
         return meta_str
 
     def _store_meta(self, meta):
@@ -132,14 +134,20 @@ def store(self, meta, data):
             size_expected = meta.get(SIZE)
             size_real = tfw.size
             if size_expected is not None and size_expected != size_real:
-                raise ValueError("computed data size ({}) does not match data size declared in metadata ({})".format(
-                                 size_real, size_expected))
+                raise ValueError(
+                    "computed data size ({}) does not match data size declared in metadata ({})".format(
+                        size_real, size_expected
+                    )
+                )
             meta[SIZE] = size_real
             hash_expected = meta.get(HASH_ALGORITHM)
             hash_real = tfw.hash.hexdigest()
             if hash_expected is not None and hash_expected != hash_real:
-                raise ValueError("computed data hash ({}) does not match data hash declared in metadata ({})".format(
-                                 hash_real, hash_expected))
+                raise ValueError(
+                    "computed data hash ({}) does not match data hash declared in metadata ({})".format(
+                        hash_real, hash_expected
+                    )
+                )
             meta[HASH_ALGORITHM] = hash_real
         else:
             dataid = meta[DATAID]
diff --git a/src/moin/storage/middleware/_tests/test_indexing.py b/src/moin/storage/middleware/_tests/test_indexing.py
index 8262fbc18..13440f945 100644
--- a/src/moin/storage/middleware/_tests/test_indexing.py
+++ b/src/moin/storage/middleware/_tests/test_indexing.py
@@ -13,11 +13,28 @@
 
 from flask import g as flaskg
 
-from moin.constants.keys import (NAME, NAME_EXACT, SIZE, ITEMID, REVID, DATAID,
-                                 HASH_ALGORITHM, CONTENT, COMMENT, LATEST_REVS,
-                                 ALL_REVS, NAMESPACE, NAMERE, NAMEPREFIX,
-                                 CONTENTTYPE, ITEMTYPE, ITEMLINKS, REV_NUMBER,
-                                 PARENTID, MTIME)
+from moin.constants.keys import (
+    NAME,
+    NAME_EXACT,
+    SIZE,
+    ITEMID,
+    REVID,
+    DATAID,
+    HASH_ALGORITHM,
+    CONTENT,
+    COMMENT,
+    LATEST_REVS,
+    ALL_REVS,
+    NAMESPACE,
+    NAMERE,
+    NAMEPREFIX,
+    CONTENTTYPE,
+    ITEMTYPE,
+    ITEMLINKS,
+    REV_NUMBER,
+    PARENTID,
+    MTIME,
+)
 
 from moin.constants.namespaces import NAMESPACE_USERS
 
@@ -44,15 +61,14 @@ def imw(self):
         return self.imw
 
     def test_nonexisting_item(self):
-        item = self.imw['foo']
+        item = self.imw["foo"]
         assert not item  # does not exist
 
     def test_store_revision(self):
-        item_name = 'foo'
-        data = b'bar'
+        item_name = "foo"
+        data = b"bar"
         item = self.imw[item_name]
-        rev = item.store_revision(dict(name=[item_name, ]), BytesIO(data),
-                                  return_rev=True)
+        rev = item.store_revision(dict(name=[item_name]), BytesIO(data), return_rev=True)
         revid = rev.revid
         # check if we have the revision now:
         item = self.imw[item_name]
@@ -64,36 +80,38 @@ def test_store_revision(self):
         assert revids == [revid]
 
     def test_overwrite_revision(self):
-        item_name = 'foo'
-        data = b'bar'
-        newdata = b'baz'
+        item_name = "foo"
+        data = b"bar"
+        newdata = b"baz"
         item = self.imw[item_name]
-        rev = item.store_revision(dict(name=[item_name, ], comment='spam'), BytesIO(data),
-                                  return_rev=True)
+        rev = item.store_revision(dict(name=[item_name], comment="spam"), BytesIO(data), return_rev=True)
         revid = rev.revid
         # clear revision:
-        item.store_revision(dict(name=[item_name, ], revid=revid, comment='no spam'), BytesIO(newdata), overwrite=True)
+        item.store_revision(dict(name=[item_name], revid=revid, comment="no spam"), BytesIO(newdata), overwrite=True)
         # check if the revision was overwritten:
         item = self.imw[item_name]
         rev = item.get_revision(revid)
         assert rev.name == item_name
-        assert rev.meta[COMMENT] == 'no spam'
+        assert rev.meta[COMMENT] == "no spam"
         assert rev.data.read() == newdata
         revids = [_rev.revid for _rev in item.iter_revs()]
         assert len(revids) == 1  # we still have the revision, cleared
         assert revid in revids  # it is still same revid
 
     def _store_three_revs(self, acl=None):
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        rev = item.store_revision(dict(name=[item_name, ], mtime=1, acl=acl),
-                                  BytesIO(b'bar'), trusted=True, return_rev=True)
+        rev = item.store_revision(
+            dict(name=[item_name], mtime=1, acl=acl), BytesIO(b"bar"), trusted=True, return_rev=True
+        )
         revid0 = rev.revid
-        rev = item.store_revision(dict(name=[item_name, ], mtime=2, parentid=revid0, acl=acl),
-                                  BytesIO(b'baz'), trusted=True, return_rev=True)
+        rev = item.store_revision(
+            dict(name=[item_name], mtime=2, parentid=revid0, acl=acl), BytesIO(b"baz"), trusted=True, return_rev=True
+        )
         revid1 = rev.revid
-        rev = item.store_revision(dict(name=[item_name, ], mtime=3, parentid=revid1, acl=acl),
-                                  BytesIO(b'...'), trusted=True, return_rev=True)
+        rev = item.store_revision(
+            dict(name=[item_name], mtime=3, parentid=revid1, acl=acl), BytesIO(b"..."), trusted=True, return_rev=True
+        )
         revid2 = rev.revid
         print("revids:", revid0, revid1, revid2)
         return item, item_name, revid0, revid1, revid2
@@ -148,13 +166,11 @@ def test_destroy_middle_revision(self):
 
     def test_destroy_item(self):
         revids = []
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        rev = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                  BytesIO(b'bar'), trusted=True, return_rev=True)
+        rev = item.store_revision(dict(name=[item_name], mtime=1), BytesIO(b"bar"), trusted=True, return_rev=True)
         revids.append(rev.revid)
-        rev = item.store_revision(dict(name=[item_name, ], mtime=2),
-                                  BytesIO(b'baz'), trusted=True, return_rev=True)
+        rev = item.store_revision(dict(name=[item_name], mtime=2), BytesIO(b"baz"), trusted=True, return_rev=True)
         revids.append(rev.revid)
         # destroy item:
         item.destroy_all_revisions()
@@ -163,36 +179,35 @@ def test_destroy_item(self):
         assert not item  # does not exist
 
     def test_all_revisions(self):
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'does not count, different name'))
-        item_name = 'bar'
+        item.store_revision(dict(name=[item_name]), BytesIO(b"does not count, different name"))
+        item_name = "bar"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'1st'))
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'2nd'))
+        item.store_revision(dict(name=[item_name]), BytesIO(b"1st"))
+        item.store_revision(dict(name=[item_name]), BytesIO(b"2nd"))
         item = self.imw[item_name]
         revs = [rev.data.read() for rev in item.iter_revs()]
         assert len(revs) == 2
-        assert set(revs) == {b'1st', b'2nd'}
+        assert set(revs) == {b"1st", b"2nd"}
 
     def test_latest_revision(self):
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'does not count, different name'))
-        item_name = 'bar'
+        item.store_revision(dict(name=[item_name]), BytesIO(b"does not count, different name"))
+        item_name = "bar"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'1st'))
-        expected_rev = item.store_revision(dict(name=[item_name, ]), BytesIO(b'2nd'),
-                                           return_rev=True)
+        item.store_revision(dict(name=[item_name]), BytesIO(b"1st"))
+        expected_rev = item.store_revision(dict(name=[item_name]), BytesIO(b"2nd"), return_rev=True)
         revs = list(self.imw.documents(name=item_name))
         assert len(revs) == 1  # there is only 1 latest revision
         assert expected_rev.revid == revs[0].revid  # it is really the latest one
 
     def test_auto_meta(self):
-        item_name = 'foo'
-        data = b'bar'
+        item_name = "foo"
+        data = b"bar"
         item = self.imw[item_name]
-        rev = item.store_revision(dict(name=[item_name, ]), BytesIO(data), return_rev=True)
+        rev = item.store_revision(dict(name=[item_name]), BytesIO(data), return_rev=True)
         print(repr(rev.meta))
         assert rev.name == item_name
         assert rev.meta[SIZE] == len(data)
@@ -202,23 +217,28 @@ def test_auto_meta(self):
         assert DATAID in rev.meta
 
     def test_meta_itemlinks_moin(self):
-        meta1 = {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8', ITEMTYPE: 'default', REV_NUMBER: 1}
-        rev1 = update_item('item01', meta1, '[[Home]] [[users/user]] [[/Subitem01]]')
-        assert 'Home' in rev1.meta[ITEMLINKS]
-        assert 'users/user' in rev1.meta[ITEMLINKS]
-        assert 'item01/Subitem01' in rev1.meta[ITEMLINKS]
-        meta2 = {CONTENTTYPE: 'text/x.moin.wiki;charset=utf-8', NAME: ['user', ],
-                 NAMESPACE: NAMESPACE_USERS, ITEMTYPE: 'default', REV_NUMBER: 1}
-        rev2 = update_item('%s/user' % NAMESPACE_USERS, meta2, '[[users/usr1]] [[../usr2]]')
-        assert 'users/usr1' in rev2.meta[ITEMLINKS]
-        assert 'users/usr2' in rev2.meta[ITEMLINKS]
+        meta1 = {CONTENTTYPE: "text/x.moin.wiki;charset=utf-8", ITEMTYPE: "default", REV_NUMBER: 1}
+        rev1 = update_item("item01", meta1, "[[Home]] [[users/user]] [[/Subitem01]]")
+        assert "Home" in rev1.meta[ITEMLINKS]
+        assert "users/user" in rev1.meta[ITEMLINKS]
+        assert "item01/Subitem01" in rev1.meta[ITEMLINKS]
+        meta2 = {
+            CONTENTTYPE: "text/x.moin.wiki;charset=utf-8",
+            NAME: ["user"],
+            NAMESPACE: NAMESPACE_USERS,
+            ITEMTYPE: "default",
+            REV_NUMBER: 1,
+        }
+        rev2 = update_item("%s/user" % NAMESPACE_USERS, meta2, "[[users/usr1]] [[../usr2]]")
+        assert "users/usr1" in rev2.meta[ITEMLINKS]
+        assert "users/usr2" in rev2.meta[ITEMLINKS]
 
     def test_documents(self):
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'x'), return_rev=True)
-        rev2 = item.store_revision(dict(name=[item_name, ]), BytesIO(b'xx'), return_rev=True)
-        item.store_revision(dict(name=[item_name, ]), BytesIO(b'xxx'), return_rev=True)
+        item.store_revision(dict(name=[item_name]), BytesIO(b"x"), return_rev=True)
+        rev2 = item.store_revision(dict(name=[item_name]), BytesIO(b"xx"), return_rev=True)
+        item.store_revision(dict(name=[item_name]), BytesIO(b"xxx"), return_rev=True)
         rev = self.imw.document(idx_name=ALL_REVS, size=2)
         assert rev
         assert rev.revid == rev2.revid
@@ -228,27 +248,25 @@ def test_documents(self):
 
     def test_xml_document(self):
         """Test that XML documents can be stored and indexed."""
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        meta = dict(name=[item_name, ], contenttype='text/xml')
+        meta = dict(name=[item_name], contenttype="text/xml")
         rev = item.store_revision(meta, BytesIO(b'<?xml version="1.0" encoding="UTF-8"?>'), return_rev=True)
         assert rev
 
     def test_index_rebuild(self):
         # first we index some stuff the slow "on-the-fly" way:
         expected_latest_revids = []
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                BytesIO(b'does not count, different name'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(
+            dict(name=[item_name], mtime=1), BytesIO(b"does not count, different name"), trusted=True, return_rev=True
+        )
         expected_latest_revids.append(r.revid)
-        item_name = 'bar'
+        item_name = "bar"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ], mtime=2),
-                            BytesIO(b'1st'), trusted=True)
-        r = item.store_revision(dict(name=[item_name, ], mtime=3),
-                                BytesIO(b'2nd'), trusted=True, return_rev=True)
+        item.store_revision(dict(name=[item_name], mtime=2), BytesIO(b"1st"), trusted=True)
+        r = item.store_revision(dict(name=[item_name], mtime=3), BytesIO(b"2nd"), trusted=True, return_rev=True)
         expected_latest_revids.append(r.revid)
 
         # now we remember the index contents built that way:
@@ -289,31 +307,29 @@ def test_index_update(self):
         expected_all_revids = []
         expected_latest_revids = []
         missing_revids = []
-        item_name = 'updated'
+        item_name = "updated"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                BytesIO(b'updated 1st'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(dict(name=[item_name], mtime=1), BytesIO(b"updated 1st"), trusted=True, return_rev=True)
         expected_all_revids.append(r.revid)
         # we update this item below, so we don't add it to expected_latest_revids
-        item_name = 'destroyed'
+        item_name = "destroyed"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                BytesIO(b'destroyed 1st'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(
+            dict(name=[item_name], mtime=1), BytesIO(b"destroyed 1st"), trusted=True, return_rev=True
+        )
         destroy_revid = r.revid
         # we destroy this item below, so we don't add it to expected_all_revids
         # we destroy this item below, so we don't add it to expected_latest_revids
-        item_name = 'stayssame'
+        item_name = "stayssame"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                BytesIO(b'stayssame 1st'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(
+            dict(name=[item_name], mtime=1), BytesIO(b"stayssame 1st"), trusted=True, return_rev=True
+        )
         expected_all_revids.append(r.revid)
         # we update this item below, so we don't add it to expected_latest_revids
-        r = item.store_revision(dict(name=[item_name, ], mtime=2),
-                                BytesIO(b'stayssame 2nd'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(
+            dict(name=[item_name], mtime=2), BytesIO(b"stayssame 2nd"), trusted=True, return_rev=True
+        )
         expected_all_revids.append(r.revid)
         expected_latest_revids.append(r.revid)
 
@@ -326,23 +342,19 @@ def test_index_update(self):
 
         # while the fresh index still sits at the tmp location, we update and add some items.
         # this will not change the fresh index, but the old index we are still using.
-        item_name = 'updated'
+        item_name = "updated"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=2),
-                                BytesIO(b'updated 2nd'), trusted=True,
-                                return_rev=True)
+        r = item.store_revision(dict(name=[item_name], mtime=2), BytesIO(b"updated 2nd"), trusted=True, return_rev=True)
         expected_all_revids.append(r.revid)
         expected_latest_revids.append(r.revid)
         missing_revids.append(r.revid)
-        item_name = 'added'
+        item_name = "added"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], mtime=1),
-                                BytesIO(b'added 1st'),
-                                trusted=True, return_rev=True)
+        r = item.store_revision(dict(name=[item_name], mtime=1), BytesIO(b"added 1st"), trusted=True, return_rev=True)
         expected_all_revids.append(r.revid)
         expected_latest_revids.append(r.revid)
         missing_revids.append(r.revid)
-        item_name = 'destroyed'
+        item_name = "destroyed"
         item = self.imw[item_name]
         item.destroy_revision(destroy_revid)
 
@@ -384,9 +396,9 @@ def test_index_update(self):
 
     def test_revision_contextmanager(self):
         # check if rev.data is closed after leaving the with-block
-        item_name = 'foo'
-        meta = dict(name=[item_name, ])
-        data = b'some test content'
+        item_name = "foo"
+        meta = dict(name=[item_name])
+        data = b"some test content"
         item = self.imw[item_name]
         data_file = BytesIO(data)
         with item.store_revision(meta, data_file, return_rev=True) as rev:
@@ -402,24 +414,23 @@ def test_revision_contextmanager(self):
     def test_indexed_content(self):
         # TODO: this is a very simple check that assumes that data is put 1:1
         # into index' CONTENT field.
-        item_name = 'foo'
-        meta = dict(name=[item_name, ], contenttype='text/plain;charset=utf-8')
-        data = b'some test content\n'
+        item_name = "foo"
+        meta = dict(name=[item_name], contenttype="text/plain;charset=utf-8")
+        data = b"some test content\n"
         item = self.imw[item_name]
         data_file = BytesIO(data)
         with item.store_revision(meta, data_file, return_rev=True) as rev:
             expected_revid = rev.revid
-        doc = self.imw._document(content='test')
+        doc = self.imw._document(content="test")
         assert doc is not None
         assert expected_revid == doc[REVID]
         assert doc[CONTENT] == data.decode()
 
     def test_indexing_subscriptions(self):
         item_name = "foo"
-        meta = dict(name=[item_name, ], subscriptions=[f"{NAME}::foo",
-                                                       f"{NAMERE}::.*"])
+        meta = dict(name=[item_name], subscriptions=[f"{NAME}::foo", f"{NAMERE}::.*"])
         item = self.imw[item_name]
-        item.store_revision(meta, BytesIO(item_name.encode('utf-8')))
+        item.store_revision(meta, BytesIO(item_name.encode("utf-8")))
         doc1 = self.imw.document(subscription_ids=f"{NAME}::foo")
         doc2 = self.imw.document(subscription_patterns=f"{NAMERE}::.*")
         assert doc1 is not None
@@ -430,32 +441,39 @@ def test_indexing_subscriptions(self):
         assert doc4 is None
 
     def test_namespaces(self):
-        item_name_n = 'normal'
+        item_name_n = "normal"
         item = self.imw[item_name_n]
-        rev_n = item.store_revision(dict(name=[item_name_n, ], contenttype='text/plain;charset=utf-8'),
-                                    BytesIO(item_name_n.encode('utf-8')), return_rev=True)
-        item_name_u = '%s/user' % NAMESPACE_USERS
+        rev_n = item.store_revision(
+            dict(name=[item_name_n], contenttype="text/plain;charset=utf-8"),
+            BytesIO(item_name_n.encode("utf-8")),
+            return_rev=True,
+        )
+        item_name_u = "%s/user" % NAMESPACE_USERS
         fqname_u = split_fqname(item_name_u)
         item = self.imw.get_item(**fqname_u.query)
-        rev_u = item.store_revision(dict(name=[fqname_u.value], namespace=fqname_u.namespace, contenttype='text/plain;charset=utf-8'),
-                                    BytesIO(item_name_u.encode('utf-8')), return_rev=True)
+        rev_u = item.store_revision(
+            dict(name=[fqname_u.value], namespace=fqname_u.namespace, contenttype="text/plain;charset=utf-8"),
+            BytesIO(item_name_u.encode("utf-8")),
+            return_rev=True,
+        )
         item = self.imw[item_name_n]
         rev_n = item.get_revision(rev_n.revid)
-        assert rev_n.meta[NAMESPACE] == ''
-        assert rev_n.meta[NAME] == [item_name_n, ]
+        assert rev_n.meta[NAMESPACE] == ""
+        assert rev_n.meta[NAME] == [item_name_n]
         item = self.imw[item_name_u]
         rev_u = item.get_revision(rev_u.revid)
         assert rev_u.meta[NAMESPACE] == NAMESPACE_USERS
-        assert rev_u.meta[NAME] == [item_name_u.split('/')[1]]
+        assert rev_u.meta[NAME] == [item_name_u.split("/")[1]]
 
     def test_parentnames(self):
-        item_name = 'child'
+        item_name = "child"
         item = self.imw[item_name]
-        item.store_revision(dict(name=['child', 'p1/a', 'p2/b', 'p2/c', 'p3/p4/d', ],
-                                 contenttype='text/plain;charset=utf-8'),
-                            BytesIO(b''))
+        item.store_revision(
+            dict(name=["child", "p1/a", "p2/b", "p2/c", "p3/p4/d"], contenttype="text/plain;charset=utf-8"),
+            BytesIO(b""),
+        )
         item = self.imw[item_name]
-        assert item.parentnames == {'p1', 'p2', 'p3/p4', }  # one p2 duplicate removed
+        assert item.parentnames == {"p1", "p2", "p3/p4"}  # one p2 duplicate removed
 
 
 class TestProtectedIndexingMiddleware:
@@ -464,7 +482,8 @@ class TestProtectedIndexingMiddleware:
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            auth = [GivenAuth(user_name='joe', autocreate=True), ]
+            auth = [GivenAuth(user_name="joe", autocreate=True)]
+
         return Config
 
     @pytest.fixture(autouse=True)
@@ -472,45 +491,44 @@ def imw(self):
         self.imw = flaskg.unprotected_storage
 
     def test_documents(self):
-        item_name = 'public'
+        item_name = "public"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], acl='joe:read'),
-                                BytesIO(b'public content'), return_rev=True)
+        r = item.store_revision(dict(name=[item_name], acl="joe:read"), BytesIO(b"public content"), return_rev=True)
         revid_public = r.revid
-        revids = [rev.revid for rev in self.imw.documents()
-                  if rev.name != 'joe']  # the user profile is a revision in the backend
+        revids = [
+            rev.revid for rev in self.imw.documents() if rev.name != "joe"
+        ]  # the user profile is a revision in the backend
         assert revids == [revid_public]
 
     def test_getitem(self):
-        item_name = 'public'
+        item_name = "public"
         item = self.imw[item_name]
-        r = item.store_revision(dict(name=[item_name, ], acl='joe:read'),
-                                BytesIO(b'public content'), return_rev=True)
+        r = item.store_revision(dict(name=[item_name], acl="joe:read"), BytesIO(b"public content"), return_rev=True)
         revid_public = r.revid
         # now testing:
-        item_name = 'public'
+        item_name = "public"
         item = self.imw[item_name]
         r = item[revid_public]
-        assert r.data.read() == b'public content'
+        assert r.data.read() == b"public content"
 
     def test_perf_create_only(self):
         pytest.skip("usually we do no performance tests")
         # determine create revisions performance
         # for the memory backend we use, this is likely mostly building the indexes
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
         for i in range(100):
-            item.store_revision(dict(name=[item_name, ], acl='joe:create joe:read'), BytesIO(b'some content'))
+            item.store_revision(dict(name=[item_name], acl="joe:create joe:read"), BytesIO(b"some content"))
 
     def test_perf_create_read(self):
         pytest.skip("usually we do no performance tests")
         # determine create + read revisions performance
         # for the memory backend we use, this is likely mostly building the indexes and
         # doing index lookups name -> itemid, itemid -> revids list
-        item_name = 'foo'
+        item_name = "foo"
         item = self.imw[item_name]
         for i in range(100):
-            item.store_revision(dict(name=[item_name, ], acl='joe:create joe:read'), BytesIO(b'rev number {}'.format(i)))
+            item.store_revision(dict(name=[item_name], acl="joe:create joe:read"), BytesIO(b"rev number {}".format(i)))
         for r in item.iter_revs():
             # print r.meta
             # print r.data.read()
diff --git a/src/moin/storage/middleware/_tests/test_protecting.py b/src/moin/storage/middleware/_tests/test_protecting.py
index 951da6e24..66fbe1955 100644
--- a/src/moin/storage/middleware/_tests/test_protecting.py
+++ b/src/moin/storage/middleware/_tests/test_protecting.py
@@ -15,15 +15,15 @@
 
 from .test_indexing import TestIndexingMiddleware
 
-UNPROTECTED = 'unprotected'
-PROTECTED = 'protected'
+UNPROTECTED = "unprotected"
+PROTECTED = "protected"
 
-UNPROTECTED_CONTENT = b'unprotected content'
-PROTECTED_CONTENT = b'protected content'
+UNPROTECTED_CONTENT = b"unprotected content"
+PROTECTED_CONTENT = b"protected content"
 
 acl_mapping = [
-    ('', dict(before='', default='joe:read,write,create,admin All:read,write,create', after='', hierarchic=False)),
-    ('users', dict(before='', default='joe:read,write,create,admin All:read,write,create', after='', hierarchic=False)),
+    ("", dict(before="", default="joe:read,write,create,admin All:read,write,create", after="", hierarchic=False)),
+    ("users", dict(before="", default="joe:read,write,create,admin All:read,write,create", after="", hierarchic=False)),
 ]
 
 
@@ -31,8 +31,9 @@ class FakeUser:
     """
     fake user object, just to give user.name
     """
+
     def __init__(self, name):
-        self.name = [name, ]
+        self.name = [name]
 
     @property
     def name0(self):
@@ -42,7 +43,7 @@ def name0(self):
 class TestProtectingMiddleware(TestIndexingMiddleware):
     @pytest.fixture(autouse=True)
     def protected_imw(self, imw):
-        self.imw = ProtectingMiddleware(imw, FakeUser('joe'), acl_mapping=acl_mapping)
+        self.imw = ProtectingMiddleware(imw, FakeUser("joe"), acl_mapping=acl_mapping)
         return self.imw
 
     def _dummy(self):
@@ -54,24 +55,25 @@ def _dummy(self):
     test_indexed_content = _dummy
 
     def make_items(self, unprotected_acl, protected_acl):
-        items = [(UNPROTECTED, unprotected_acl, UNPROTECTED_CONTENT),
-                 (PROTECTED, protected_acl, PROTECTED_CONTENT),
-                 ]
+        items = [(UNPROTECTED, unprotected_acl, UNPROTECTED_CONTENT), (PROTECTED, protected_acl, PROTECTED_CONTENT)]
         revids = []
         for item_name, acl, content in items:
             item = self.imw[item_name]
-            r = item.store_revision(dict(name=[item_name, ], acl=acl, contenttype='text/plain;charset=utf-8'),
-                                    BytesIO(content), return_rev=True)
+            r = item.store_revision(
+                dict(name=[item_name], acl=acl, contenttype="text/plain;charset=utf-8"),
+                BytesIO(content),
+                return_rev=True,
+            )
             revids.append(r.revid)
         return revids
 
     def test_documents(self):
-        revid_unprotected, revid_protected = self.make_items('joe:read', 'boss:read')
+        revid_unprotected, revid_protected = self.make_items("joe:read", "boss:read")
         revids = [rev.revid for rev in self.imw.documents()]
         assert revids == [revid_unprotected]  # without revid_protected!
 
     def test_getitem(self):
-        revid_unprotected, revid_protected = self.make_items('joe:read', 'boss:read')
+        revid_unprotected, revid_protected = self.make_items("joe:read", "boss:read")
         # now testing:
         item = self.imw[UNPROTECTED]
         r = item[revid_unprotected]
@@ -81,33 +83,55 @@ def test_getitem(self):
             r = item[revid_protected]
 
     def test_write(self):
-        revid_unprotected, revid_protected = self.make_items('joe:write', 'boss:write')
+        revid_unprotected, revid_protected = self.make_items("joe:write", "boss:write")
         # now testing:
         item = self.imw[UNPROTECTED]
-        item.store_revision(dict(name=[UNPROTECTED, ], acl='joe:write', contenttype='text/plain;charset=utf-8'), BytesIO(UNPROTECTED_CONTENT))
+        item.store_revision(
+            dict(name=[UNPROTECTED], acl="joe:write", contenttype="text/plain;charset=utf-8"),
+            BytesIO(UNPROTECTED_CONTENT),
+        )
         item = self.imw[PROTECTED]
         with pytest.raises(AccessDenied):
-            item.store_revision(dict(name=[PROTECTED, ], acl='boss:write', contenttype='text/plain;charset=utf-8'), BytesIO(UNPROTECTED_CONTENT))
+            item.store_revision(
+                dict(name=[PROTECTED], acl="boss:write", contenttype="text/plain;charset=utf-8"),
+                BytesIO(UNPROTECTED_CONTENT),
+            )
 
     def test_write_create(self):
         # now testing:
-        item_name = 'newitem'
+        item_name = "newitem"
         item = self.imw[item_name]
-        item.store_revision(dict(name=[item_name, ], contenttype='text/plain;charset=utf-8'), BytesIO(b'new content'))
+        item.store_revision(dict(name=[item_name], contenttype="text/plain;charset=utf-8"), BytesIO(b"new content"))
 
     def test_overwrite_revision(self):
-        revid_unprotected, revid_protected = self.make_items('joe:write,destroy', 'boss:write,destroy')
+        revid_unprotected, revid_protected = self.make_items("joe:write,destroy", "boss:write,destroy")
         # now testing:
         item = self.imw[UNPROTECTED]
-        item.store_revision(dict(name=[UNPROTECTED, ], acl='joe:write,destroy', contenttype='text/plain;charset=utf-8', revid=revid_unprotected),
-                            BytesIO(UNPROTECTED_CONTENT), overwrite=True)
+        item.store_revision(
+            dict(
+                name=[UNPROTECTED],
+                acl="joe:write,destroy",
+                contenttype="text/plain;charset=utf-8",
+                revid=revid_unprotected,
+            ),
+            BytesIO(UNPROTECTED_CONTENT),
+            overwrite=True,
+        )
         item = self.imw[PROTECTED]
         with pytest.raises(AccessDenied):
-            item.store_revision(dict(name=[PROTECTED, ], acl='boss:write,destroy', contenttype='text/plain;charset=utf-8', revid=revid_protected),
-                                BytesIO(UNPROTECTED_CONTENT), overwrite=True)
+            item.store_revision(
+                dict(
+                    name=[PROTECTED],
+                    acl="boss:write,destroy",
+                    contenttype="text/plain;charset=utf-8",
+                    revid=revid_protected,
+                ),
+                BytesIO(UNPROTECTED_CONTENT),
+                overwrite=True,
+            )
 
     def test_destroy_revision(self):
-        revid_unprotected, revid_protected = self.make_items('joe:destroy', 'boss:destroy')
+        revid_unprotected, revid_protected = self.make_items("joe:destroy", "boss:destroy")
         # now testing:
         item = self.imw[UNPROTECTED]
         item.destroy_revision(revid_unprotected)
@@ -116,7 +140,7 @@ def test_destroy_revision(self):
             item.destroy_revision(revid_protected)
 
     def test_destroy_middle_revision(self):
-        item, item_name, revid0, revid1, revid2 = self._store_three_revs('joe:read,write,destroy')
+        item, item_name, revid0, revid1, revid2 = self._store_three_revs("joe:read,write,destroy")
         # destroy the middle revision:
         item.destroy_revision(revid1)
         with item.get_revision(revid2) as rev:
@@ -124,7 +148,7 @@ def test_destroy_middle_revision(self):
             assert rev.meta[PARENTID] == revid0
 
     def test_destroy_item(self):
-        revid_unprotected, revid_protected = self.make_items('joe:destroy', 'boss:destroy')
+        revid_unprotected, revid_protected = self.make_items("joe:destroy", "boss:destroy")
         # now testing:
         item = self.imw[UNPROTECTED]
         item.destroy_all_revisions()
diff --git a/src/moin/storage/middleware/_tests/test_routing.py b/src/moin/storage/middleware/_tests/test_routing.py
index 94d20c329..40324b920 100644
--- a/src/moin/storage/middleware/_tests/test_routing.py
+++ b/src/moin/storage/middleware/_tests/test_routing.py
@@ -22,8 +22,8 @@ def make_ro_backend():
     store = StoreBackend(MemoryBytesStore(), MemoryFileStore())
     store.create()
     store.open()
-    store.store({NAME: 'test'}, BytesIO(b''))
-    store.store({NAME: 'test2'}, BytesIO(b''))
+    store.store({NAME: "test"}, BytesIO(b""))
+    store.store({NAME: "test2"}, BytesIO(b""))
     return ROBackend(store.meta_store, store.data_store)
 
 
@@ -32,8 +32,8 @@ def router(request):
     default_be = StoreBackend(MemoryBytesStore(), MemoryFileStore())
     other_be = StoreBackend(MemoryBytesStore(), MemoryFileStore())
     ro_be = make_ro_backend()
-    namespaces = [('other:', 'other'), ('ro:', 'ro'), ('', 'default')]
-    backends = {'other': other_be, 'ro': ro_be, 'default': default_be, }
+    namespaces = [("other:", "other"), ("ro:", "ro"), ("", "default")]
+    backends = {"other": other_be, "ro": ro_be, "default": default_be}
     router = RoutingBackend(namespaces, backends)
     router.create()
     router.open()
@@ -47,18 +47,18 @@ def finalize():
 
 
 def test_store_get_del(router):
-    default_name = 'foo'
-    default_backend_name, default_revid = router.store(dict(name=[default_name, ]), BytesIO(b''))
-    other_name = 'other:bar'
-    other_backend_name, other_revid = router.store(dict(name=[other_name, ]), BytesIO(b''))
+    default_name = "foo"
+    default_backend_name, default_revid = router.store(dict(name=[default_name]), BytesIO(b""))
+    other_name = "other:bar"
+    other_backend_name, other_revid = router.store(dict(name=[other_name]), BytesIO(b""))
 
     # check if store() updates the to-store metadata with correct NAMESPACE and NAME
     default_meta, _ = router.retrieve(default_backend_name, default_revid)
     other_meta, _ = router.retrieve(other_backend_name, other_revid)
-    assert '' == default_meta[NAMESPACE]
-    assert [default_name, ] == default_meta[NAME]
-    assert other_name.split(':')[0] == other_meta[NAMESPACE]
-    assert other_name.split(':')[1] == other_meta[NAME][0]
+    assert "" == default_meta[NAMESPACE]
+    assert [default_name] == default_meta[NAME]
+    assert other_name.split(":")[0] == other_meta[NAMESPACE]
+    assert other_name.split(":")[1] == other_meta[NAME][0]
 
     # delete revs:
     router.remove(default_backend_name, default_revid, destroy_data=True)
@@ -67,7 +67,7 @@ def test_store_get_del(router):
 
 def test_store_readonly_fails(router):
     with pytest.raises(TypeError):
-        router.store(dict(name=['ro:testing', ]), BytesIO(b''))
+        router.store(dict(name=["ro:testing"]), BytesIO(b""))
 
 
 def test_del_readonly_fails(router):
@@ -79,8 +79,8 @@ def test_del_readonly_fails(router):
 
 def test_destroy_create_dont_touch_ro(router):
     existing = set(router)
-    default_be_name, default_revid = router.store(dict(name=['foo', ]), BytesIO(b''))
-    other_be_name, other_revid = router.store(dict(name=['other:bar', ]), BytesIO(b''))
+    default_be_name, default_revid = router.store(dict(name=["foo"]), BytesIO(b""))
+    other_be_name, other_revid = router.store(dict(name=["other:bar"]), BytesIO(b""))
 
     router.close()
     router.destroy()
@@ -92,7 +92,7 @@ def test_destroy_create_dont_touch_ro(router):
 
 def test_iter(router):
     existing_before = {revid for be_name, revid in router}
-    default_be_name, default_revid = router.store(dict(name=['foo', ]), BytesIO(b''))
-    other_be_name, other_revid = router.store(dict(name=['other:bar', ]), BytesIO(b''))
+    default_be_name, default_revid = router.store(dict(name=["foo"]), BytesIO(b""))
+    other_be_name, other_revid = router.store(dict(name=["other:bar"]), BytesIO(b""))
     existing_now = {revid for be_name, revid in router}
     assert existing_now == {default_revid, other_revid} | existing_before
diff --git a/src/moin/storage/middleware/_tests/test_serialization.py b/src/moin/storage/middleware/_tests/test_serialization.py
index 3bb59b9c1..c295b2834 100644
--- a/src/moin/storage/middleware/_tests/test_serialization.py
+++ b/src/moin/storage/middleware/_tests/test_serialization.py
@@ -21,22 +21,19 @@
 
 
 contents = [
-    ('Foo', {NAME: ['Foo', ], CONTENTTYPE: 'text/plain;charset=utf-8'}, b''),
-    ('Foo', {NAME: ['Foo', ], CONTENTTYPE: 'text/plain;charset=utf-8'}, b'2nd'),
-    ('Subdir', {NAME: ['Subdir', ], CONTENTTYPE: 'text/plain;charset=utf-8'}, b''),
-    ('Subdir/Foo', {NAME: ['Subdir/Foo', ], CONTENTTYPE: 'text/plain;charset=utf-8'}, b''),
-    ('Subdir/Bar', {NAME: ['Subdir/Bar', ], CONTENTTYPE: 'text/plain;charset=utf-8'}, b''),
+    ("Foo", {NAME: ["Foo"], CONTENTTYPE: "text/plain;charset=utf-8"}, b""),
+    ("Foo", {NAME: ["Foo"], CONTENTTYPE: "text/plain;charset=utf-8"}, b"2nd"),
+    ("Subdir", {NAME: ["Subdir"], CONTENTTYPE: "text/plain;charset=utf-8"}, b""),
+    ("Subdir/Foo", {NAME: ["Subdir/Foo"], CONTENTTYPE: "text/plain;charset=utf-8"}, b""),
+    ("Subdir/Bar", {NAME: ["Subdir/Bar"], CONTENTTYPE: "text/plain;charset=utf-8"}, b""),
 ]
 
 
-scenarios = [
-    ('Simple', ['']),
-    ('Nested', ['', 'Subdir']),
-]
+scenarios = [("Simple", [""]), ("Nested", ["", "Subdir"])]
 
 
 def pytest_generate_tests(metafunc):
-    metafunc.parametrize('source,target', [('Simple', 'Simple'), ], ids=['Simple->Simple', ], indirect=True)
+    metafunc.parametrize("source,target", [("Simple", "Simple")], ids=["Simple->Simple"], indirect=True)
 
 
 @pytest.fixture
@@ -56,16 +53,15 @@ def make_middleware(request, tmpdir):
     meta_store = BytesStore()
     data_store = FileStore()
     _backend = MutableBackend(meta_store, data_store)
-    namespaces = [(NAMESPACE_DEFAULT, 'backend')]
-    backends = {'backend': _backend}
+    namespaces = [(NAMESPACE_DEFAULT, "backend")]
+    backends = {"backend": _backend}
     backend = RoutingBackend(namespaces, backends)
     backend.create()
     backend.open()
     request.addfinalizer(backend.destroy)
     request.addfinalizer(backend.close)
 
-    mw = IndexingMiddleware(index_storage=(WHOOSH_FILESTORAGE, (str(tmpdir / 'foo'), ), {}),
-                            backend=backend)
+    mw = IndexingMiddleware(index_storage=(WHOOSH_FILESTORAGE, (str(tmpdir / "foo"),), {}), backend=backend)
     mw.create()
     mw.open()
     request.addfinalizer(mw.destroy)
diff --git a/src/moin/storage/middleware/_tests/test_validation.py b/src/moin/storage/middleware/_tests/test_validation.py
index 48f0e4e13..f661df95a 100644
--- a/src/moin/storage/middleware/_tests/test_validation.py
+++ b/src/moin/storage/middleware/_tests/test_validation.py
@@ -18,7 +18,7 @@
 class TestValidation:
     def test_content(self):
         class REV(dict):
-            """ fake rev """
+            """fake rev"""
 
         rev = REV()
         rev[keys.ITEMID] = make_uuid()
@@ -28,32 +28,33 @@ class REV(dict):
         meta = {
             keys.REVID: make_uuid(),
             keys.PARENTID: make_uuid(),
-            keys.NAME: ["a", ],
+            keys.NAME: ["a"],
             keys.NAMESPACE: "",
             keys.ACL: "All:read",
             keys.TAGS: ["foo", "bar"],
         }
 
-        state = {'trusted': False,  # True for loading a serialized representation or other trusted sources
-                 keys.NAME: 'somename',  # name we decoded from URL path
-                 keys.ACTION: keys.ACTION_SAVE,
-                 keys.HOSTNAME: 'localhost',
-                 keys.ADDRESS: '127.0.0.1',
-                 keys.USERID: make_uuid(),
-                 keys.HASH_ALGORITHM: 'b9064b9a5efd8c6cef2d38a8169a0e1cbfdb41ba',
-                 keys.SIZE: 0,
-                 keys.WIKINAME: 'ThisWiki',
-                 keys.NAMESPACE: '',
-                 'rev_parent': rev,
-                 'acl_parent': "All:read",
-                 'contenttype_current': 'text/x.moin.wiki;charset=utf-8',
-                 'contenttype_guessed': 'text/plain;charset=utf-8',
-                 keys.FQNAME: CompositeName('', '', 'somename'),
-                 }
+        state = {
+            "trusted": False,  # True for loading a serialized representation or other trusted sources
+            keys.NAME: "somename",  # name we decoded from URL path
+            keys.ACTION: keys.ACTION_SAVE,
+            keys.HOSTNAME: "localhost",
+            keys.ADDRESS: "127.0.0.1",
+            keys.USERID: make_uuid(),
+            keys.HASH_ALGORITHM: "b9064b9a5efd8c6cef2d38a8169a0e1cbfdb41ba",
+            keys.SIZE: 0,
+            keys.WIKINAME: "ThisWiki",
+            keys.NAMESPACE: "",
+            "rev_parent": rev,
+            "acl_parent": "All:read",
+            "contenttype_current": "text/x.moin.wiki;charset=utf-8",
+            "contenttype_guessed": "text/plain;charset=utf-8",
+            keys.FQNAME: CompositeName("", "", "somename"),
+        }
 
         m = ContentMetaSchema(meta)
         valid = m.validate(state)
-        assert m[keys.CONTENTTYPE].value == 'text/x.moin.wiki;charset=utf-8'
+        assert m[keys.CONTENTTYPE].value == "text/x.moin.wiki;charset=utf-8"
         if not valid:
             for e in m.children:
                 print(e.valid, e)
@@ -64,33 +65,30 @@ def test_user(self):
         meta = {
             keys.ITEMID: make_uuid(),
             keys.REVID: make_uuid(),
-            keys.NAME: ["user name", ],
+            keys.NAME: ["user name"],
             keys.NAMESPACE: "userprofiles",
             keys.EMAIL: "foo@example.org",
-            keys.SUBSCRIPTIONS: [f"{keys.ITEMID}:{make_uuid()}",
-                                 f"{keys.NAME}::foo",
-                                 f"{keys.TAGS}::bar",
-                                 f"{keys.NAMERE}::",
-                                 f"{keys.NAMEPREFIX}:userprofiles:a",
-                                 ]
+            keys.SUBSCRIPTIONS: [
+                f"{keys.ITEMID}:{make_uuid()}",
+                f"{keys.NAME}::foo",
+                f"{keys.TAGS}::bar",
+                f"{keys.NAMERE}::",
+                f"{keys.NAMEPREFIX}:userprofiles:a",
+            ],
         }
 
-        invalid_meta = {
-            keys.SUBSCRIPTIONS: ["", "unknown_tag:123",
-                                 f"{keys.ITEMID}:123",
-                                 f"{keys.NAME}:foo",
-                                 ]
-        }
+        invalid_meta = {keys.SUBSCRIPTIONS: ["", "unknown_tag:123", f"{keys.ITEMID}:123", f"{keys.NAME}:foo"]}
 
-        state = {'trusted': False,  # True for loading a serialized representation or other trusted sources
-                 keys.NAME: 'somename',  # name we decoded from URL path
-                 keys.ACTION: keys.ACTION_SAVE,
-                 keys.HOSTNAME: 'localhost',
-                 keys.ADDRESS: '127.0.0.1',
-                 keys.WIKINAME: 'ThisWiki',
-                 keys.NAMESPACE: '',
-                 keys.FQNAME: CompositeName('', '', 'somename')
-                 }
+        state = {
+            "trusted": False,  # True for loading a serialized representation or other trusted sources
+            keys.NAME: "somename",  # name we decoded from URL path
+            keys.ACTION: keys.ACTION_SAVE,
+            keys.HOSTNAME: "localhost",
+            keys.ADDRESS: "127.0.0.1",
+            keys.WIKINAME: "ThisWiki",
+            keys.NAMESPACE: "",
+            keys.FQNAME: CompositeName("", "", "somename"),
+        }
 
         m = UserMetaSchema(meta)
         valid = m.validate(state)
diff --git a/src/moin/storage/middleware/indexing.py b/src/moin/storage/middleware/indexing.py
index 4ce395ab1..b9b50f4ef 100644
--- a/src/moin/storage/middleware/indexing.py
+++ b/src/moin/storage/middleware/indexing.py
@@ -85,14 +85,15 @@
 from moin.i18n import _
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
-WHOOSH_FILESTORAGE = 'FileStorage'
-INDEXES = [LATEST_REVS, ALL_REVS, ]
+WHOOSH_FILESTORAGE = "FileStorage"
+INDEXES = [LATEST_REVS, ALL_REVS]
 
-VALIDATION_HANDLING_STRICT = 'strict'
-VALIDATION_HANDLING_WARN = 'warn'
+VALIDATION_HANDLING_STRICT = "strict"
+VALIDATION_HANDLING_WARN = "warn"
 # TODO: fix tests to create valid metadata
 VALIDATION_HANDLING = VALIDATION_HANDLING_WARN if "pytest" in sys.modules else VALIDATION_HANDLING_STRICT
 
@@ -118,7 +119,7 @@ def get_indexer(fn, **kw):
             break
         time.sleep(2)
         if time.time() > until:
-            raise KeyError(kw.get('revid', '') + ' - server overload or corrupt index')
+            raise KeyError(kw.get("revid", "") + " - server overload or corrupt index")
     return indexer
 
 
@@ -131,7 +132,7 @@ def parent_names(names):
     """
     parents = set()
     for name in names:
-        parent_tail = name.rsplit('/', 1)
+        parent_tail = name.rsplit("/", 1)
         if len(parent_tail) == 2:
             parents.add(parent_tail[0])
     return parents
@@ -166,9 +167,7 @@ def backend_to_index(meta, content, schema, wikiname, backend_name):
     :param wikiname: interwikiname of this wiki
     :returns: document to put into whoosh index
     """
-    doc = {key: value
-                for key, value in meta.items()
-                if key in schema}
+    doc = {key: value for key, value in meta.items() if key in schema}
     if SUBSCRIPTION_IDS in schema and SUBSCRIPTIONS in meta:
         doc[SUBSCRIPTION_IDS], doc[SUBSCRIPTION_PATTERNS] = backend_subscriptions_to_index(meta[SUBSCRIPTIONS])
     for key in [MTIME, PTIME]:
@@ -184,24 +183,24 @@ def backend_to_index(meta, content, schema, wikiname, backend_name):
     if SUMMARYNGRAM in schema and SUMMARY in meta:
         doc[SUMMARYNGRAM] = meta[SUMMARY]
     if NAMENGRAM in schema and NAME in meta:
-        doc[NAMENGRAM] = ' '.join(meta[NAME])
+        doc[NAMENGRAM] = " ".join(meta[NAME])
     if doc.get(TAGS, None):
         # global tags uses this to search for items with tags
         doc[HAS_TAG] = True
     if doc.get(NAME, None):
         if doc.get(NAMESPACE, None):
-            fullnames = [doc[NAMESPACE] + '/' + x for x in doc[NAME]]
-            doc[NAMES] = ' | '.join(fullnames)
+            fullnames = [doc[NAMESPACE] + "/" + x for x in doc[NAME]]
+            doc[NAMES] = " | ".join(fullnames)
         else:
-            doc[NAMES] = ' | '.join(doc[NAME])
-        doc[NAME_SORT] = doc[NAMES].replace('/', '')
+            doc[NAMES] = " | ".join(doc[NAME])
+        doc[NAME_SORT] = doc[NAMES].replace("/", "")
     else:
         doc[NAME_SORT] = ""
     return doc
 
 
 def backend_subscriptions_to_index(subscriptions):
-    """ Split subscriptions list to subscription_ids and subscription_patterns lists
+    """Split subscriptions list to subscription_ids and subscription_patterns lists
     which match the fields of the whoosh schema
 
     :param subscriptions: user subscriptions meta
@@ -211,10 +210,10 @@ def backend_subscriptions_to_index(subscriptions):
     subscription_ids = []
     subscription_patterns = []
     for subscription in subscriptions:
-        keyword = subscription.split(':')[0]
-        if keyword in (ITEMID, NAME, TAGS, ):
+        keyword = subscription.split(":")[0]
+        if keyword in (ITEMID, NAME, TAGS):
             subscription_ids.append(subscription)
-        elif keyword in (NAMERE, NAMEPREFIX, ):
+        elif keyword in (NAMERE, NAMEPREFIX):
             subscription_patterns.append(subscription)
     return subscription_ids, subscription_patterns
 
@@ -235,11 +234,11 @@ def convert_to_indexable(meta, data, item_name=None, is_new=False):
     """
     if not item_name:
         try:
-            item_name = meta[NAMESPACE] + '/' + meta[NAME][0]
+            item_name = meta[NAMESPACE] + "/" + meta[NAME][0]
         except IndexError:
-            item_name = meta[NAMESPACE] + '/' + 'DoesNotExist'
+            item_name = meta[NAMESPACE] + "/" + "DoesNotExist"
     elif item_name and meta.get(NAMESPACE):
-        item_name = meta[NAMESPACE] + '/' + meta[NAME][0]
+        item_name = meta[NAMESPACE] + "/" + meta[NAME][0]
     fqname = split_fqname(item_name)
 
     class PseudoRev:
@@ -252,6 +251,7 @@ class PseudoItem:
                 def __init__(self, fqname):
                     self.fqname = fqname
                     self.name = fqname.value
+
             self.item = PseudoItem(fqname)
 
         def read(self, *args, **kw):
@@ -265,7 +265,7 @@ def tell(self, *args, **kw):
 
     if meta[CONTENTTYPE] in app.cfg.mimetypes_to_index_as_empty:
         logging.debug(f"not indexing content of {meta[NAME]!r} as requested by configuration")
-        return ''
+        return ""
 
     rev = PseudoRev(meta, data)
     try:
@@ -274,7 +274,7 @@ def tell(self, *args, **kw):
         # different output than for normal rendering), esp. for the non-markup
         # content types (images, etc.).
         input_contenttype = meta[CONTENTTYPE]
-        output_contenttype = 'text/plain'
+        output_contenttype = "text/plain"
         type_input_contenttype = Type(input_contenttype)
         type_output_contenttype = Type(output_contenttype)
         reg = default_registry
@@ -287,7 +287,7 @@ def tell(self, *args, **kw):
         # otherwise try via DOM as intermediate format (this is useful if
         # input type is markup, to get rid of the markup):
         input_conv = reg.get(type_input_contenttype, type_moin_document)
-        refs_conv = reg.get(type_moin_document, type_moin_document, items='refs')
+        refs_conv = reg.get(type_moin_document, type_moin_document, items="refs")
         output_conv = reg.get(type_moin_document, type_output_contenttype)
         if input_conv and output_conv:
             doc = input_conv(rev, input_contenttype)
@@ -297,7 +297,7 @@ def tell(self, *args, **kw):
             # transclusions.
             if is_new:
                 # we only can modify new, uncommitted revisions, not stored revs
-                i = Iri(scheme='wiki', authority='', path='/' + item_name)
+                i = Iri(scheme="wiki", authority="", path="/" + item_name)
                 doc.set(moin_page.page_href, str(i))
                 refs_conv(doc)
                 # side effect: we update some metadata:
@@ -309,9 +309,12 @@ def tell(self, *args, **kw):
         # no way
         raise TypeError(f"No converter for {input_contenttype} --> {output_contenttype}")
     except Exception as e:  # catch all exceptions, we don't want to break an indexing run
-        logging.exception("Exception happened in conversion of item {!r} rev {} contenttype {}:".format(
-                          item_name, meta.get(REVID, 'new'), meta.get(CONTENTTYPE, '')))
-        doc = f'ERROR [{e!s}]'
+        logging.exception(
+            "Exception happened in conversion of item {!r} rev {} contenttype {}:".format(
+                item_name, meta.get(REVID, "new"), meta.get(CONTENTTYPE, "")
+            )
+        )
+        doc = f"ERROR [{e!s}]"
         return doc
 
 
@@ -441,13 +444,11 @@ def __init__(self, index_storage, backend, wiki_name=None, acl_rights_contents=[
 
         blog_entry_fields = {
             # blog publish time from metadata (converted to UTC datetime)
-            PTIME: DATETIME(stored=True),
+            PTIME: DATETIME(stored=True)
         }
         latest_revs_fields.update(**blog_entry_fields)
 
-        all_revs_fields = {
-            ITEMID: ID(stored=True),
-        }
+        all_revs_fields = {ITEMID: ID(stored=True)}
         all_revs_fields.update(**common_fields)
 
         latest_revisions_schema = Schema(**latest_revs_fields)
@@ -458,13 +459,14 @@ def __init__(self, index_storage, backend, wiki_name=None, acl_rights_contents=[
         self.schemas[LATEST_REVS] = latest_revisions_schema
 
         # Define dynamic fields
-        dynamic_fields = [("*_id", ID(stored=True)),
-                          ("*_text", TEXT(stored=True)),
-                          ("*_keyword", KEYWORD(stored=True)),
-                          ("*_numeric", NUMERIC(stored=True)),
-                          ("*_datetime", DATETIME(stored=True)),
-                          ("*_boolean", BOOLEAN(stored=True)),
-                          ]
+        dynamic_fields = [
+            ("*_id", ID(stored=True)),
+            ("*_text", TEXT(stored=True)),
+            ("*_keyword", KEYWORD(stored=True)),
+            ("*_numeric", NUMERIC(stored=True)),
+            ("*_datetime", DATETIME(stored=True)),
+            ("*_boolean", BOOLEAN(stored=True)),
+        ]
 
         # Adding dynamic fields to schemas
         for glob, field_type in dynamic_fields:
@@ -481,8 +483,9 @@ def get_storage_params(self, tmp=False):
         if kind == WHOOSH_FILESTORAGE:
             # index_storage = 'FileStorage', (index_dir, ), {}
             if tmp:
-                params[0] += '.temp'
+                params[0] += ".temp"
             from whoosh.filedb.filestore import FileStorage
+
             cls = FileStorage
         else:
             raise ValueError(f"index_storage = {kind!r} is not supported!")
@@ -579,9 +582,12 @@ def index_revision(self, meta, content, backend_name, async_=True, force_latest=
             is_latest = True
         else:
             with self.ix[ALL_REVS].searcher() as searcher:
-                is_latest = (searcher.search(Term(ITEMID, doc[ITEMID]),
-                                             sortedby=FieldFacet(MTIME, reverse=True),
-                                             limit=1)[0][REVID] == doc[REVID])
+                is_latest = (
+                    searcher.search(Term(ITEMID, doc[ITEMID]), sortedby=FieldFacet(MTIME, reverse=True), limit=1)[0][
+                        REVID
+                    ]
+                    == doc[REVID]
+                )
         if is_latest:
             doc = backend_to_index(meta, content, self.schemas[LATEST_REVS], self.wikiname, backend_name)
             if async_:
@@ -626,14 +632,15 @@ def remove_revision(self, revid, async_=True):
                     with self.ix[ALL_REVS].searcher() as searcher:
                         doc = searcher.document(revid=latest_backend_revid[1])
                         content = doc[CONTENT]
-                    doc = backend_to_index(meta, content, self.schemas[LATEST_REVS], self.wikiname,
-                                           backend_name=latest_backend_revid[0])
+                    doc = backend_to_index(
+                        meta, content, self.schemas[LATEST_REVS], self.wikiname, backend_name=latest_backend_revid[0]
+                    )
                     writer.update_document(**doc)
                 else:
                     # this is no revision left in this item that could be the new "latest rev", just kill the rev
                     writer.delete_document(docnum_remove)
 
-    def _modify_index(self, index, schema, wikiname, revids, mode='add', procs=1, limitmb=256):
+    def _modify_index(self, index, schema, wikiname, revids, mode="add", procs=1, limitmb=256):
         """
         modify index contents - add, update, delete the indexed documents for all given revids
 
@@ -642,15 +649,15 @@ def _modify_index(self, index, schema, wikiname, revids, mode='add', procs=1, li
         """
         with index.writer(procs=procs, limitmb=limitmb) as writer:
             for backend_name, revid in revids:
-                if mode in ['add', 'update', ]:
+                if mode in ["add", "update"]:
                     meta, data = self.backend.retrieve(backend_name, revid)
                     content = convert_to_indexable(meta, data, is_new=False)
                     doc = backend_to_index(meta, content, schema, wikiname, backend_name)
-                if mode == 'update':
+                if mode == "update":
                     writer.update_document(**doc)
-                elif mode == 'add':
+                elif mode == "add":
                     writer.add_document(**doc)
-                elif mode == 'delete':
+                elif mode == "delete":
                     writer.delete_by_term(REVID, revid)
                 else:
                     raise ValueError(f"mode must be 'update', 'add' or 'delete', not '{mode}'")
@@ -669,9 +676,10 @@ def _find_latest_backends_revids(self, index, query=None):
             result = searcher.search(query, groupedby=ITEMID, sortedby=FieldFacet(MTIME, reverse=True))
             by_item = result.groups(ITEMID)
             # values in v list are in same relative order as in results, so latest MTIME is first:
-            latest_backends_revids = [(searcher.stored_fields(v[0])[BACKENDNAME],
-                                      searcher.stored_fields(v[0])[REVID])
-                                      for v in by_item.values()]
+            latest_backends_revids = [
+                (searcher.stored_fields(v[0])[BACKENDNAME], searcher.stored_fields(v[0])[REVID])
+                for v in by_item.values()
+            ]
         return latest_backends_revids
 
     def rebuild(self, tmp=False, procs=1, limitmb=256):
@@ -688,7 +696,7 @@ def rebuild(self, tmp=False, procs=1, limitmb=256):
         try:
             # build an index of all we have (so we know what we have)
             all_revids = self.backend  # the backend is an iterator over all revids
-            self._modify_index(index, self.schemas[ALL_REVS], self.wikiname, all_revids, 'add', procs, limitmb)
+            self._modify_index(index, self.schemas[ALL_REVS], self.wikiname, all_revids, "add", procs, limitmb)
             latest_backends_revids = self._find_latest_backends_revids(index)
         finally:
             index.close()
@@ -696,8 +704,9 @@ def rebuild(self, tmp=False, procs=1, limitmb=256):
         # now build the index of the latest revisions:
         index = storage.open_index(LATEST_REVS)
         try:
-            self._modify_index(index, self.schemas[LATEST_REVS], self.wikiname, latest_backends_revids, 'add',
-                               procs, limitmb)
+            self._modify_index(
+                index, self.schemas[LATEST_REVS], self.wikiname, latest_backends_revids, "add", procs, limitmb
+            )
         finally:
             index.close()
 
@@ -731,8 +740,8 @@ def update(self, tmp=False):
             changed = add_revids or del_revids
             add_revids = [(revids_backends[revid], revid) for revid in add_revids]
             del_revids = [(revids_backends[revid], revid) for revid in del_revids]
-            self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, add_revids, 'add')
-            self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, del_revids, 'delete')
+            self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, add_revids, "add")
+            self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, del_revids, "delete")
 
             backend_latest_backends_revids = set(self._find_latest_backends_revids(index_all))
         finally:
@@ -745,8 +754,8 @@ def update(self, tmp=False):
             backend_latest_revids = {revid for name, revid in backend_latest_backends_revids}
             upd_revids = backend_latest_revids - ix_revids
             upd_revids = [(revids_backends[revid], revid) for revid in upd_revids]
-            self._modify_index(index_latest, self.schemas[LATEST_REVS], self.wikiname, upd_revids, 'update')
-            self._modify_index(index_latest, self.schemas[LATEST_REVS], self.wikiname, del_revids, 'delete')
+            self._modify_index(index_latest, self.schemas[LATEST_REVS], self.wikiname, upd_revids, "update")
+            self._modify_index(index_latest, self.schemas[LATEST_REVS], self.wikiname, del_revids, "delete")
         finally:
             index_latest.close()
         return changed
@@ -782,14 +791,14 @@ def dump(self, tmp=False, idx_name=LATEST_REVS):
         storage = self.get_storage(tmp)
         ix = storage.open_index(idx_name)
         while not ix.up_to_date():
-            logging.info('waiting for ix.up_to_date()')
+            logging.info("waiting for ix.up_to_date()")
             time.sleep(0.1)
         try:
             with ix.searcher() as searcher:
                 for doc in searcher.all_stored_fields():
                     name = doc.pop(NAME, "")
                     content = doc.pop(CONTENT, "")
-                    yield [(NAME, name), ] + sorted(doc.items()) + [(CONTENT, content), ]
+                    yield [(NAME, name)] + sorted(doc.items()) + [(CONTENT, content)]
         finally:
             ix.close()
 
@@ -808,8 +817,9 @@ def query_parser(self, default_fields, idx_name=LATEST_REVS):
 
         def userid_pseudo_field_factory(fieldname):
             """generate a translator function, that searches for the userid
-               in the given fieldname when provided with the username
+            in the given fieldname when provided with the username
             """
+
             def userid_pseudo_field(node):
                 username = node.text
                 users = user.search_users(**{NAME_EXACT: username})
@@ -819,13 +829,19 @@ def userid_pseudo_field(node):
                     node.set_fieldname(fieldname)
                     return node
                 return node
+
             return userid_pseudo_field
-        qp.add_plugin(PseudoFieldPlugin(dict(
-            # username:JoeDoe searches for revisions modified by JoeDoe
-            username=userid_pseudo_field_factory(USERID),
-            # assigned:JoeDoe searches for tickets assigned to JoeDoe
-            assigned=userid_pseudo_field_factory(ASSIGNED_TO),
-        )))
+
+        qp.add_plugin(
+            PseudoFieldPlugin(
+                dict(
+                    # username:JoeDoe searches for revisions modified by JoeDoe
+                    username=userid_pseudo_field_factory(USERID),
+                    # assigned:JoeDoe searches for tickets assigned to JoeDoe
+                    assigned=userid_pseudo_field_factory(ASSIGNED_TO),
+                )
+            )
+        )
         return qp
 
     def search(self, q, idx_name=LATEST_REVS, **kw):
@@ -929,7 +945,7 @@ def __getitem__(self, name):
         """
         Return item with <name> (may be a new or existing item).
         """
-        if name.startswith('@itemid/'):
+        if name.startswith("@itemid/"):
             return Item(self, **{ITEMID: name[8:]})
         fqname = split_fqname(name)
         return Item(self, **{NAME_EXACT: fqname.value, NAMESPACE: fqname.namespace})
@@ -966,6 +982,7 @@ class PropertiesMixin:
     """
     PropertiesMixin offers methods to find out some additional information from meta.
     """
+
     @property
     def name(self):
         if self._name and self._name in self.names:
@@ -981,7 +998,7 @@ def name(self):
 
     @property
     def namespace(self):
-        return self.meta.get(NAMESPACE, '')
+        return self.meta.get(NAMESPACE, "")
 
     def _fqname(self, name=None):
         """
@@ -1079,6 +1096,7 @@ def _get_itemid(self):
 
     def _set_itemid(self, value):
         self._current[ITEMID] = value
+
     itemid = property(_get_itemid, _set_itemid)
 
     @property
@@ -1120,7 +1138,7 @@ def existing(cls, indexer, **query):
         raise NoSuchItemError(repr(query))
 
     def __repr__(self):
-        return f'<Item {self.name}>'
+        return f"<Item {self.name}>"
 
     def __bool__(self):
         """
@@ -1155,19 +1173,23 @@ def preprocess(self, meta, data):
         content = convert_to_indexable(meta, data, self.name, is_new=True)
         return meta, data, content
 
-    def store_revision(self, meta, data, overwrite=False,
-                       trusted=False,  # True for loading a serialized representation or other trusted sources
-                       name=None,  # TODO name we decoded from URL path
-                       action=ACTION_SAVE,
-                       remote_addr=None,
-                       userid=None,
-                       wikiname=None,
-                       contenttype_current=None,
-                       contenttype_guessed=None,
-                       acl_parent=None,
-                       return_rev=False,
-                       fqname=None,
-                       ):
+    def store_revision(
+        self,
+        meta,
+        data,
+        overwrite=False,
+        trusted=False,  # True for loading a serialized representation or other trusted sources
+        name=None,  # TODO name we decoded from URL path
+        action=ACTION_SAVE,
+        remote_addr=None,
+        userid=None,
+        wikiname=None,
+        contenttype_current=None,
+        contenttype_guessed=None,
+        acl_parent=None,
+        return_rev=False,
+        fqname=None,
+    ):
         """
         Store a revision into the backend, write metadata and data to it.
 
@@ -1195,19 +1217,20 @@ def store_revision(self, meta, data, overwrite=False,
                 pass
         if wikiname is None:
             wikiname = app.cfg.interwikiname
-        state = {'trusted': trusted,
-                 NAME: [name],
-                 ACTION: action,
-                 ADDRESS: remote_addr,
-                 USERID: userid,
-                 WIKINAME: wikiname,
-                 NAMESPACE: None,
-                 ITEMID: self.itemid,  # real itemid or None
-                 'contenttype_current': contenttype_current,
-                 'contenttype_guessed': contenttype_guessed,
-                 'acl_parent': acl_parent,
-                 FQNAME: fqname,
-                 }
+        state = {
+            "trusted": trusted,
+            NAME: [name],
+            ACTION: action,
+            ADDRESS: remote_addr,
+            USERID: userid,
+            WIKINAME: wikiname,
+            NAMESPACE: None,
+            ITEMID: self.itemid,  # real itemid or None
+            "contenttype_current": contenttype_current,
+            "contenttype_guessed": contenttype_guessed,
+            "acl_parent": acl_parent,
+            FQNAME: fqname,
+        }
         ct = meta.get(CONTENTTYPE)
         if ct == CONTENTTYPE_USER:
             Schema = UserMetaSchema
@@ -1219,7 +1242,7 @@ def store_revision(self, meta, data, overwrite=False,
             logging.warning("data validation skipped because metadata is invalid, see below")
             val = []
             for e in m.children:
-                if e.name == 'subscriptions':
+                if e.name == "subscriptions":
                     for sub in e.children:
                         if sub.valid is False:
                             val.append(f'"{str(sub)}". {str(sub.errors[0])}')
@@ -1228,21 +1251,21 @@ def store_revision(self, meta, data, overwrite=False,
                     val.append(str(e))
                 logging.warning(f"{e.valid}, {e.name}, {e.raw}")
             if VALIDATION_HANDLING == VALIDATION_HANDLING_STRICT:
-                raise ValueError(_('Error: metadata validation failed, invalid field value(s) = {0}').format(
-                    ', '.join(val)
-                ))
+                raise ValueError(
+                    _("Error: metadata validation failed, invalid field value(s) = {0}").format(", ".join(val))
+                )
 
         # we do not have anything in m that is not defined in the schema,
         # e.g. userdefined meta keys or stuff we do not validate. thus, we
         # just update the meta dict with the validated stuff:
         meta.update(dict(m.value.items()))
-        if hasattr(flaskg, 'data_mtime'):
+        if hasattr(flaskg, "data_mtime"):
             # this is maint-reduce-revisions OR item-put CL process, restore saved time of item's last update
             meta[MTIME] = flaskg.data_mtime
             del flaskg.data_mtime
         # we do not want None / empty values:
         # XXX do not kick out empty lists before fixing NAME processing:
-        meta = {k: v for k, v in meta.items() if v not in [None, ]}
+        meta = {k: v for k, v in meta.items() if v not in [None]}
         # file upload UI does not have a summary field
         if SUMMARY not in meta:
             meta[SUMMARY] = ""
@@ -1250,16 +1273,16 @@ def store_revision(self, meta, data, overwrite=False,
         if valid and not validate_data(meta, data):  # need valid metadata to validate data
             logging.warning(f"data validation failed for item {meta[NAME]} ")
             if VALIDATION_HANDLING == VALIDATION_HANDLING_STRICT:
-                raise ValueError(_('Error: nothing changed. Data unicode validation failed.'))
+                raise ValueError(_("Error: nothing changed. Data unicode validation failed."))
 
         if self.itemid is None:
             self.itemid = meta[ITEMID]
         backend = self.backend
         if not overwrite:
             revid = meta.get(REVID)
-            backend_name = dict(app.cfg.namespace_mapping)[meta.get(NAMESPACE, '')]
+            backend_name = dict(app.cfg.namespace_mapping)[meta.get(NAMESPACE, "")]
             if revid is not None and (revid in backend or (backend_name, revid) in backend):
-                raise ValueError('need overwrite=True to overwrite existing revisions')
+                raise ValueError("need overwrite=True to overwrite existing revisions")
         meta, data, content = self.preprocess(meta, data)
         data.seek(0)  # rewind file
         backend_name, revid = backend.store(meta, data)
@@ -1313,6 +1336,7 @@ class Revision(PropertiesMixin):
     """
     An existing revision (exists in the backend).
     """
+
     def __init__(self, item, revid, doc=None, name=None):
         is_current = revid == CURRENT
         if doc is None:
@@ -1377,7 +1401,7 @@ def __lt__(self, other):
         return self.meta < other.meta
 
     def __repr__(self):
-        return f'<Revision {self.revid[:6]} of Item {self.name}>'
+        return f"<Revision {self.revid[:6]} of Item {self.name}>"
 
 
 class Meta(Mapping):
diff --git a/src/moin/storage/middleware/protecting.py b/src/moin/storage/middleware/protecting.py
index 2e4cab653..60d147610 100644
--- a/src/moin/storage/middleware/protecting.py
+++ b/src/moin/storage/middleware/protecting.py
@@ -15,7 +15,7 @@
 
 from whoosh.util.cache import lfu_cache
 
-from moin.constants.rights import (CREATE, READ, PUBREAD, WRITE, ADMIN, DESTROY, ACL_RIGHTS_CONTENTS)
+from moin.constants.rights import CREATE, READ, PUBREAD, WRITE, ADMIN, DESTROY, ACL_RIGHTS_CONTENTS
 from moin.constants.keys import ACL, ALL_REVS, LATEST_REVS, NAME_EXACT, ITEMID, FQNAMES, NAME, NAMESPACE
 from moin.constants.namespaces import NAMESPACE_ALL
 
@@ -24,6 +24,7 @@
 from moin.utils.interwiki import split_fqname, CompositeName
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -110,8 +111,8 @@ def _get_configured_acls(self, fqname):
         else:
             if fqname.namespace == NAMESPACE_ALL:
                 # prevent traceback, /+index/all page has several links to /+index/all
-                return {'default': 'All:', 'hierarchic': False, 'after': '', 'before': ''}
-            raise ValueError(f'No acl_mapping entry found for item {fqname!r}')
+                return {"default": "All:", "hierarchic": False, "after": "", "before": ""}
+            raise ValueError(f"No acl_mapping entry found for item {fqname!r}")
 
     def _get_acls(self, itemid=None, fqname=None):
         """
@@ -135,9 +136,9 @@ def _get_acls(self, itemid=None, fqname=None):
         acl = item.acl
         fqname = item.fqname
         if acl is not None:
-            return [acl, ]
+            return [acl]
         acl_cfg = self._get_configured_acls(fqname)
-        if acl_cfg['hierarchic']:
+        if acl_cfg["hierarchic"]:
             # check parent(s), recursively
             parentids = item.parentids
             if parentids:
@@ -146,10 +147,10 @@ def _get_acls(self, itemid=None, fqname=None):
                     pacls = self.get_acls(parentid, None)
                     acl_list.extend(pacls)
                 return acl_list
-        return [None, ]
+        return [None]
 
-    def _parse_acl(self, acl, default=''):
-        return AccessControlList([acl, ], default=default, valid=self.valid_rights)
+    def _parse_acl(self, acl, default=""):
+        return AccessControlList([acl], default=default, valid=self.valid_rights)
 
     def _eval_acl(self, acl, default_acl, user_name, right):
         aclobj = self.parse_acl(acl, default_acl)
@@ -190,10 +191,12 @@ def may_read_rev(self, meta):
         Called by ajaxsearch template, others.
         """
         from .indexing import parent_names
+
         self.meta = meta
         self.fqnames = gen_fqnames(meta)
-        may_read = self.allows(tuple(self.user.name), meta.get(ACL, None),
-                               tuple(parent_names(meta[NAME])), meta[NAMESPACE], READ)
+        may_read = self.allows(
+            tuple(self.user.name), meta.get(ACL, None), tuple(parent_names(meta[NAME])), meta[NAMESPACE], READ
+        )
         return may_read
 
     def full_acls(self):
@@ -204,12 +207,12 @@ def full_acls(self):
         fqname = self.fqnames[0]
         itemid = self.meta[ITEMID]
         acl_cfg = self._get_configured_acls(fqname)
-        before_acl = acl_cfg['before']
-        after_acl = acl_cfg['after']
+        before_acl = acl_cfg["before"]
+        after_acl = acl_cfg["after"]
         for item_acl in self.get_acls(itemid, fqname):
             if item_acl is None:
-                item_acl = acl_cfg['default']
-            yield ' '.join([before_acl, item_acl, after_acl])
+                item_acl = acl_cfg["default"]
+            yield " ".join([before_acl, item_acl, after_acl])
 
     def _allows(self, user_names, acls, parentnames, namespace, right):
         """
@@ -224,7 +227,7 @@ def _allows(self, user_names, acls, parentnames, namespace, right):
         acl_cfg = self._get_configured_acls(self.fqnames[0])
         for user_name in user_names:
             for full_acl in self.full_acls():
-                allowed = self.eval_acl(full_acl, acl_cfg['default'], user_name, right)
+                allowed = self.eval_acl(full_acl, acl_cfg["default"], user_name, right)
                 if allowed and pchecker(right, allowed, self.meta):
                     return True
         return False
@@ -248,8 +251,9 @@ def search_meta_page(self, q, idx_name=LATEST_REVS, pagenum=None, pagelen=None,
         for meta in self.indexer.search_meta_page(q, idx_name=idx_name, pagenum=pagenum, pagelen=pagelen, **kw):
             self.meta = meta
             self.fqnames = gen_fqnames(meta)
-            result = self.allows(tuple(self.user.name), meta.get(ACL, None),
-                                 tuple(parent_names(meta[NAME])), meta[NAMESPACE], READ)
+            result = self.allows(
+                tuple(self.user.name), meta.get(ACL, None), tuple(parent_names(meta[NAME])), meta[NAMESPACE], READ
+            )
             if result:
                 yield meta
 
@@ -292,8 +296,8 @@ def may(self, fqname, capability, usernames=None):
         if usernames is not None and isinstance(usernames, (bytes, str)):
             # we got a single username (maybe bytes), make a list of str:
             if isinstance(usernames, bytes):
-                usernames = usernames.decode('utf-8')
-            usernames = [usernames, ]
+                usernames = usernames.decode("utf-8")
+            usernames = [usernames]
         # TODO Make sure that fqname must be a CompositeName class instance, not unicode or list.
         fqname = fqname[0] if isinstance(fqname, list) else fqname
         if isinstance(fqname, str):
@@ -351,15 +355,15 @@ def full_acls(self):
         fqname = self.item.fqname
         itemid = self.item.itemid
         acl_cfg = self.protector._get_configured_acls(fqname)
-        before_acl = acl_cfg['before']
-        after_acl = acl_cfg['after']
+        before_acl = acl_cfg["before"]
+        after_acl = acl_cfg["after"]
         for item_acl in self.protector.get_acls(itemid, fqname):
             if item_acl is None:
-                item_acl = acl_cfg['default']
-            yield ' '.join([before_acl, item_acl, after_acl])
+                item_acl = acl_cfg["default"]
+            yield " ".join([before_acl, item_acl, after_acl])
 
     def allows(self, right, user_names=None):
-        """ Check if usernames may have <right> access on this item.
+        """Check if usernames may have <right> access on this item.
 
         :param right: the right to check
         :param user_names: user names to use for permissions check (default is to
@@ -375,7 +379,7 @@ def allows(self, right, user_names=None):
         acl_cfg = self.protector._get_configured_acls(self.item.fqname)
         for user_name in user_names:
             for full_acl in self.full_acls():
-                allowed = self.protector.eval_acl(full_acl, acl_cfg['default'], user_name, right)
+                allowed = self.protector.eval_acl(full_acl, acl_cfg["default"], user_name, right)
                 if allowed is True and pchecker(right, allowed, self.item):
                     return True
         return False
@@ -384,8 +388,11 @@ def require(self, *capabilities):
         """require that at least one of the capabilities is allowed"""
         if not any(self.allows(c) for c in capabilities):
             capability = " or ".join(capabilities)
-            raise AccessDenied("item does not allow user '{!r}' to '{!r}' [{!r}]".format(
-                               self.protector.user.name, capability, self.item.acl))
+            raise AccessDenied(
+                "item does not allow user '{!r}' to '{!r}' [{!r}]".format(
+                    self.protector.user.name, capability, self.item.acl
+                )
+            )
 
     def iter_revs(self):
         self.require(READ)
@@ -456,8 +463,11 @@ def require(self, *capabilities):
         """require that at least one of the capabilities is allowed"""
         if not any(self.allows(c) for c in capabilities):
             capability = " or ".join(capabilities)
-            raise AccessDenied("revision does not allow user '{!r}' to '{!r}' [{!r}]".format(
-                               self.protector.user.name, capability, self.item.item.acl))
+            raise AccessDenied(
+                "revision does not allow user '{!r}' to '{!r}' [{!r}]".format(
+                    self.protector.user.name, capability, self.item.item.acl
+                )
+            )
 
     @property
     def revid(self):
diff --git a/src/moin/storage/middleware/routing.py b/src/moin/storage/middleware/routing.py
index 72624eb62..a7e5713db 100644
--- a/src/moin/storage/middleware/routing.py
+++ b/src/moin/storage/middleware/routing.py
@@ -17,6 +17,7 @@ class Backend(MutableBackendBase):
     """
     namespace dispatcher, behaves readonly for readonly mounts
     """
+
     def __init__(self, namespaces, backends):
         """
         Initialize.
@@ -79,8 +80,8 @@ def _get_backend(self, fq_names):
         fq_name = fq_names[0]
         for namespace, backend_name in self.namespaces:
             if fq_name.startswith(namespace):
-                item_names = [_fq_name[len(namespace):] for _fq_name in fq_names]
-                return backend_name, item_names, namespace.rstrip(':')
+                item_names = [_fq_name[len(namespace) :] for _fq_name in fq_names]
+                return backend_name, item_names, namespace.rstrip(":")
         raise AssertionError(f"No backend found for {fq_name!r}. Namespaces: {self.namespaces!r}")
 
     def __iter__(self):
@@ -119,15 +120,15 @@ def store(self, meta, data):
                 meta[NAMESPACE] = namespace
                 meta[NAME] = item_names
             else:
-                raise ValueError('can not determine namespace: empty NAME list, no NAMESPACE metadata present')
+                raise ValueError("can not determine namespace: empty NAME list, no NAMESPACE metadata present")
         else:
             if namespace:
-                namespace += ':'  # needed for _get_backend
+                namespace += ":"  # needed for _get_backend
             backend_name, _, _ = self._get_backend([namespace])
         backend = self.backends[backend_name]
 
         if not isinstance(backend, MutableBackendBase):
-            raise TypeError(f'backend {backend_name} is readonly!')
+            raise TypeError(f"backend {backend_name} is readonly!")
 
         revid = backend.store(meta, data)
 
@@ -139,5 +140,5 @@ def store(self, meta, data):
     def remove(self, backend_name, revid, destroy_data):
         backend = self.backends[backend_name]
         if not isinstance(backend, MutableBackendBase):
-            raise TypeError(f'backend {backend_name} is readonly')
+            raise TypeError(f"backend {backend_name} is readonly")
         backend.remove(revid, destroy_data)
diff --git a/src/moin/storage/middleware/serialization.py b/src/moin/storage/middleware/serialization.py
index 633b1f276..c90e00144 100644
--- a/src/moin/storage/middleware/serialization.py
+++ b/src/moin/storage/middleware/serialization.py
@@ -26,6 +26,7 @@
 from moin.storage.backends._util import TrackingFileWrapper
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -36,11 +37,11 @@ def serialize(backend, dst):
 def serialize_rev(meta, data):
     if meta is None:
         # this is the end!
-        yield struct.pack('!i', 0)
+        yield struct.pack("!i", 0)
     else:
         text = json.dumps(meta, ensure_ascii=False)
-        meta_str = text.encode('utf-8')
-        yield struct.pack('!i', len(meta_str))
+        meta_str = text.encode("utf-8")
+        yield struct.pack("!i", len(meta_str))
         yield meta_str
         while True:
             block = data.read(8192)
@@ -56,8 +57,10 @@ def get_rev_str(meta):
     names = meta.get(NAME)
     if names:
         name = names[0]
-    return f'name: {ns + "/" if ns else ""}{name} item: {meta.get(ITEMID)} rev_number: {meta.get(REV_NUMBER)} ' \
-           f'rev_id: {meta.get(REVID)}'
+    return (
+        f'name: {ns + "/" if ns else ""}{name} item: {meta.get(ITEMID)} rev_number: {meta.get(REV_NUMBER)} '
+        f"rev_id: {meta.get(REVID)}"
+    )
 
 
 def correcting_rev_iter(backend: Backend):
@@ -78,11 +81,13 @@ def correcting_rev_iter(backend: Backend):
         while tfw.read(64 * 1024):
             pass
         if tfw.size != meta[SIZE]:
-            issues.append(f'{SIZE}_error {get_rev_str(meta)} meta_size: {meta[SIZE]} real_size: {tfw.size}')
+            issues.append(f"{SIZE}_error {get_rev_str(meta)} meta_size: {meta[SIZE]} real_size: {tfw.size}")
             meta[SIZE] = tfw.size
         if (real_hash := tfw.hash.hexdigest()) != meta[HASH_ALGORITHM]:
-            issues.append(f'{HASH_ALGORITHM}_error {get_rev_str(meta)} meta_{HASH_ALGORITHM}: {meta[HASH_ALGORITHM]} '
-                          f'real_{HASH_ALGORITHM}: {real_hash}')
+            issues.append(
+                f"{HASH_ALGORITHM}_error {get_rev_str(meta)} meta_{HASH_ALGORITHM}: {meta[HASH_ALGORITHM]} "
+                f"real_{HASH_ALGORITHM}: {real_hash}"
+            )
             meta[HASH_ALGORITHM] = real_hash
         data.seek(0)
         yield meta, data, issues
@@ -99,7 +104,7 @@ def serialize_iter(backend):
     for data in serialize_rev(None, None):
         yield data
     if issues_found:
-        logging.warning('metadata issues exist! maint-validate-metadata followed by index rebuild is recommended')
+        logging.warning("metadata issues exist! maint-validate-metadata followed by index rebuild is recommended")
 
 
 def deserialize(src, backend, new_ns=None, old_ns=None, kill_ns=None):
@@ -109,21 +114,21 @@ def deserialize(src, backend, new_ns=None, old_ns=None, kill_ns=None):
     If new_ns and old_ns are passed, then all items in the old_ns are renamed into the new_ns.
     If kill_ns is passed, then all items in that namespace are not loaded.
     """
-    assert bool(new_ns is None) == bool(old_ns is None), 'new_ns and old_ns are co-dependent options'
+    assert bool(new_ns is None) == bool(old_ns is None), "new_ns and old_ns are co-dependent options"
     while True:
         meta_size_bytes = src.read(4)
         if not len(meta_size_bytes):
             return  # end of file
-        meta_size = struct.unpack('!i', meta_size_bytes)[0]
+        meta_size = struct.unpack("!i", meta_size_bytes)[0]
         if not meta_size:
             continue  # end of store
         meta_str = src.read(meta_size)
-        text = meta_str.decode('utf-8')
+        text = meta_str.decode("utf-8")
         meta = json.loads(text)
         name = meta.get(NAME)
         if isinstance(name, str):
             # if we encounter single names, make a list of names:
-            meta[NAME] = [name, ]
+            meta[NAME] = [name]
         if ITEMTYPE not in meta:
             # temporary hack to upgrade serialized item files:
             meta[ITEMTYPE] = ITEMTYPE_DEFAULT
diff --git a/src/moin/storage/middleware/validation.py b/src/moin/storage/middleware/validation.py
index c599c6171..7c8a5f20c 100644
--- a/src/moin/storage/middleware/validation.py
+++ b/src/moin/storage/middleware/validation.py
@@ -35,7 +35,7 @@
 
 class DuckDict(Dict):
     # in duck mode, keys unknown to the schema will not cause errors
-    policy = 'duck'
+    policy = "duck"
 
 
 def uuid_validator(element, state):
@@ -58,7 +58,7 @@ def itemid_validator(element, state):
     """
     an itemid is a uuid that identifies an item
     """
-    if not state['trusted'] or element.raw is Unset:
+    if not state["trusted"] or element.raw is Unset:
         fqname = state[keys.FQNAME]
         itemid = fqname.value if fqname and fqname.field == keys.ITEMID else state.get(keys.ITEMID)
         if itemid is None:
@@ -81,7 +81,7 @@ def userid_validator(element, state):
     """
     a userid is a uuid that identifies a user (profile)
     """
-    if not state['trusted']:
+    if not state["trusted"]:
         userid = state[keys.USERID]
         element.set(userid)
         if userid is None:
@@ -101,11 +101,11 @@ def name_validator(element, state):
         return False
     if v != v.strip():
         return False
-    if v.startswith('+'):  # used for views, like /+meta/<itemname>
+    if v.startswith("+"):  # used for views, like /+meta/<itemname>
         return False
-    if v.startswith('/') or v.endswith('/'):
+    if v.startswith("/") or v.endswith("/"):
         return False
-    if '//' in v:  # empty ancestor name is invalid
+    if "//" in v:  # empty ancestor name is invalid
         return False
     return True
 
@@ -162,9 +162,9 @@ def contenttype_validator(element, state):
     a supported content type
     """
     if element.raw is Unset:
-        ct = state.get('contenttype_current')
+        ct = state.get("contenttype_current")
         if ct is None:
-            ct = state.get('contenttype_guessed')
+            ct = state.get("contenttype_guessed")
             if ct is None:
                 ct = CONTENTTYPE_DEFAULT
         element.set(ct)
@@ -172,16 +172,16 @@ def contenttype_validator(element, state):
     if not isinstance(v, str):
         return False
     ct = Type(v)
-    if ct.type not in ['text', 'image', 'audio', 'video', 'application', ]:
+    if ct.type not in ["text", "image", "audio", "video", "application"]:
         return False
     if not ct.subtype:
         return False
-    if ct.type == 'text':
-        charset = ct.parameters.get('charset')
+    if ct.type == "text":
+        charset = ct.parameters.get("charset")
         if charset is None:
             # we must have the charset, otherwise decoding is impossible
             return False
-        if charset.lower() not in ['ascii', 'utf-8', ]:
+        if charset.lower() not in ["ascii", "utf-8"]:
             # currently we do not recode
             return False
     return True
@@ -191,7 +191,7 @@ def mtime_validator(element, state):
     """
     a modification time (UNIX timestamp)
     """
-    if not state['trusted'] or element.raw is Unset:
+    if not state["trusted"] or element.raw is Unset:
         now = int(time.time())
         element.set(now)
     v = element.value
@@ -209,13 +209,19 @@ def action_validator(element, state):
     """
     an action
     """
-    if not state['trusted']:
+    if not state["trusted"]:
         element.value = state[keys.ACTION]
     v = element.value
     if not isinstance(v, str):
         return False
-    if v not in [keys.ACTION_SAVE, keys.ACTION_REVERT, keys.ACTION_TRASH,
-                 keys.ACTION_COPY, keys.ACTION_RENAME, keys.ACTION_CONVERT]:
+    if v not in [
+        keys.ACTION_SAVE,
+        keys.ACTION_REVERT,
+        keys.ACTION_TRASH,
+        keys.ACTION_COPY,
+        keys.ACTION_RENAME,
+        keys.ACTION_CONVERT,
+    ]:
         return False
     return True
 
@@ -226,7 +232,7 @@ def acl_validator(element, state):
     """
     if element.raw is Unset:
         return True
-    if state['trusted']:
+    if state["trusted"]:
         if element.value is None:
             return False
         return True
@@ -259,7 +265,7 @@ def hostname_validator(element, state):
     """
     a hostname (dns name)
     """
-    if not state['trusted']:
+    if not state["trusted"]:
         # addr = state[keys.ADDRESS] # TODO
         element.value = None  # TODO: lookup(addr)
         return True
@@ -273,7 +279,7 @@ def address_validator(element, state):
     """
     an IP address
     """
-    if not state['trusted']:
+    if not state["trusted"]:
         element.value = state[keys.ADDRESS]
     v = element.value
     if not isinstance(v, str):
@@ -286,7 +292,7 @@ def size_validator(element, state):
     a content size
     """
     v = element.value
-    if not state['trusted'] and v is None:
+    if not state["trusted"] and v is None:
         # untrusted size gets overwritten by the real value
         # in the storage code, so everything is acceptable.
         return True
@@ -304,7 +310,7 @@ def hash_validator(element, state):
     a content hash
     """
     v = element.value
-    if not state['trusted'] and v is None:
+    if not state["trusted"] and v is None:
         # untrusted hash gets overwritten by the real value
         # in the storage code, so everything is acceptable.
         return True
@@ -329,10 +335,10 @@ def subscription_validator(element, state):
         element.add_error("Subscription must contain colon delimiters.")
         return False
 
-    if keyword in (keys.ITEMID, ):
+    if keyword in (keys.ITEMID,):
         value_element = String(value)
         valid = uuid_validator(value_element, state)
-    elif keyword in (keys.NAME, keys.TAGS, keys.NAMERE, keys.NAMEPREFIX, ):
+    elif keyword in (keys.NAME, keys.TAGS, keys.NAMERE, keys.NAMEPREFIX):
         try:
             namespace, value = value.split(":", 1)
         except ValueError:
@@ -345,16 +351,14 @@ def subscription_validator(element, state):
     else:
         element.add_error(
             "Subscription must start with one of the keywords: "
-            "'{}', '{}', '{}', '{}' or '{}'.".format(keys.ITEMID,
-                                                          keys.NAME, keys.TAGS,
-                                                          keys.NAMERE,
-                                                          keys.NAMEPREFIX))
+            "'{}', '{}', '{}', '{}' or '{}'.".format(keys.ITEMID, keys.NAME, keys.TAGS, keys.NAMERE, keys.NAMEPREFIX)
+        )
         return False
 
     value_element = String(value)
     if keyword == keys.TAGS:
         valid = tag_validator(value_element, state)
-    elif keyword in (keys.NAME, keys.NAMEPREFIX, ):
+    elif keyword in (keys.NAME, keys.NAMEPREFIX):
         valid = name_validator(value_element, state)
     elif keyword == keys.NAMERE:
         try:
@@ -381,24 +385,25 @@ def subscription_validator(element, state):
     String.named(keys.COMMENT).validated_by(comment_validator),
     String.named(keys.ADDRESS).validated_by(address_validator),
     String.named(keys.HOSTNAME).validated_by(hostname_validator).using(optional=True),
-    List.named(keys.TAGS).of(String.named('tag').validated_by(tag_validator)).using(optional=True),
+    List.named(keys.TAGS).of(String.named("tag").validated_by(tag_validator)).using(optional=True),
 )
 
-ContentMetaSchema = DuckDict.named('ContentMetaSchema').of(
+ContentMetaSchema = DuckDict.named("ContentMetaSchema").of(
     String.named(keys.CONTENTTYPE).validated_by(contenttype_validator),
     String.named(keys.USERID).validated_by(userid_validator),
     Integer.named(keys.SIZE).validated_by(size_validator),
     String.named(keys.HASH_ALGORITHM).validated_by(hash_validator),
     String.named(keys.DATAID).validated_by(uuid_validator).using(optional=True),
     # markup items may have this:
-    List.named(keys.ITEMLINKS).of(String.named('itemlink').validated_by(wikiname_validator)).using(optional=True),
-    List.named(keys.ITEMTRANSCLUSIONS).of(String.named('itemtransclusion').validated_by(wikiname_validator)).using(
-        optional=True),
+    List.named(keys.ITEMLINKS).of(String.named("itemlink").validated_by(wikiname_validator)).using(optional=True),
+    List.named(keys.ITEMTRANSCLUSIONS)
+    .of(String.named("itemtransclusion").validated_by(wikiname_validator))
+    .using(optional=True),
     # TODO: CONTENT validation? can we do it here?
-    *common_meta
+    *common_meta,
 )
 
-UserMetaSchema = DuckDict.named('UserMetaSchema').of(
+UserMetaSchema = DuckDict.named("UserMetaSchema").of(
     String.named(keys.CONTENTTYPE).validated_by(user_contenttype_validator),
     String.named(keys.EMAIL).using(optional=True),
     String.named(keys.ENC_PASSWORD).using(optional=True),
@@ -416,12 +421,13 @@ def subscription_validator(element, state):
     Boolean.named(keys.SCROLL_PAGE_AFTER_EDIT).using(optional=True),
     Boolean.named(keys.MAILTO_AUTHOR).using(optional=True),
     Boolean.named(keys.ISO_8601).using(optional=True),
-    List.named(keys.QUICKLINKS).of(String.named('quicklinks')).using(optional=True),
+    List.named(keys.QUICKLINKS).of(String.named("quicklinks")).using(optional=True),
     List.named(keys.SUBSCRIPTIONS)
-    .of(String.named('subscription').validated_by(subscription_validator)).using(optional=True),
-    List.named(keys.EMAIL_SUBSCRIBED_EVENTS).of(String.named('email_subscribed_event')).using(optional=True),
+    .of(String.named("subscription").validated_by(subscription_validator))
+    .using(optional=True),
+    List.named(keys.EMAIL_SUBSCRIBED_EVENTS).of(String.named("email_subscribed_event")).using(optional=True),
     # TODO: DuckDict.named('bookmarks').using(optional=True),
-    *common_meta
+    *common_meta,
 )
 
 
@@ -434,10 +440,10 @@ def validate_data(meta, data):
     :return: validation ok [bool]
     """
     ct = Type(meta[keys.CONTENTTYPE])
-    if ct.type != 'text':
+    if ct.type != "text":
         return True  # we can't validate non-text mimetypes, so assume it is ok
-    coding = ct.parameters['charset'].lower()
-    if coding not in ['ascii', 'utf-8', ]:
+    coding = ct.parameters["charset"].lower()
+    if coding not in ["ascii", "utf-8"]:
         return True  # checking 8bit encodings this way is pointless, decoding never raises
     text_bytes = data.read()
     data.seek(0)  # rewind, so it can be read again
diff --git a/src/moin/storage/stores/__init__.py b/src/moin/storage/stores/__init__.py
index 2ac05625c..35b0bc6bb 100644
--- a/src/moin/storage/stores/__init__.py
+++ b/src/moin/storage/stores/__init__.py
@@ -18,6 +18,7 @@ class StoreBase(Mapping):
     """
     A simple read-only key/value store.
     """
+
     @classmethod
     @abstractmethod
     def from_uri(cls, uri):
@@ -80,6 +81,7 @@ class MutableStoreBase(StoreBase, MutableMapping):
     """
     A simple read/write key/value store.
     """
+
     def create(self):
         """
         create an empty store
@@ -118,6 +120,7 @@ class BytesMutableStoreMixin:
     class BytesStore(BytesMutableStoreMixin, FileStore, BytesMutableStoreBase):
         # that's all, nothing more needed
     """
+
     def __getitem__(self, key):
         with super().__getitem__(key) as stream:
             return stream.read()
@@ -146,6 +149,7 @@ class FileMutableStoreMixin:
     class FileStore(FileMutableStoreMixin, BytesStore, FileMutableStoreBase)
         # that's all, nothing more needed
     """
+
     def __getitem__(self, key):
         value = super().__getitem__(key)
         return BytesIO(value)
diff --git a/src/moin/storage/stores/_tests/conftest.py b/src/moin/storage/stores/_tests/conftest.py
index 0e2a06fe4..6a2b15211 100644
--- a/src/moin/storage/stores/_tests/conftest.py
+++ b/src/moin/storage/stores/_tests/conftest.py
@@ -8,34 +8,34 @@
 import pytest
 from ..wrappers import ByteToStreamWrappingStore
 
-STORES_PACKAGE = 'moin.storage.stores'
+STORES_PACKAGE = "moin.storage.stores"
 
-STORES = 'fs memory sqlite sqlite:compressed sqla'.split()
+STORES = "fs memory sqlite sqlite:compressed sqla".split()
 
 
 constructors = {
-    'memory': lambda store, _: store(),
-    'fs': lambda store, tmpdir: store(str(tmpdir.join('store'))),
-    'sqlite': lambda store, tmpdir: store(str(tmpdir.join('store.sqlite')), 'test_table', compression_level=0),
-    'sqlite:compressed': lambda store, tmpdir: store(
-        str(tmpdir.join('store.sqlite')), 'test_table', compression_level=1
+    "memory": lambda store, _: store(),
+    "fs": lambda store, tmpdir: store(str(tmpdir.join("store"))),
+    "sqlite": lambda store, tmpdir: store(str(tmpdir.join("store.sqlite")), "test_table", compression_level=0),
+    "sqlite:compressed": lambda store, tmpdir: store(
+        str(tmpdir.join("store.sqlite")), "test_table", compression_level=1
     ),
-    'sqla': lambda store, tmpdir: store('sqlite:///{!s}'.format(tmpdir.join('store.sqlite')), 'test_table'),
+    "sqla": lambda store, tmpdir: store("sqlite:///{!s}".format(tmpdir.join("store.sqlite")), "test_table"),
 }
 
 
 def pytest_generate_tests(metafunc):
     argnames = metafunc.fixturenames
 
-    if 'store' in argnames:
-        klasses = 'BytesStore', 'FileStore'
-        argname = 'store'
-    elif 'bst' in argnames:
-        klasses = 'BytesStore',
-        argname = 'bst'
-    elif 'fst' in argnames:
-        klasses = 'FileStore',
-        argname = 'fst'
+    if "store" in argnames:
+        klasses = "BytesStore", "FileStore"
+        argname = "store"
+    elif "bst" in argnames:
+        klasses = ("BytesStore",)
+        argname = "bst"
+    elif "fst" in argnames:
+        klasses = ("FileStore",)
+        argname = "fst"
     else:
         klasses = None
         argname = None
@@ -45,28 +45,28 @@ def pytest_generate_tests(metafunc):
         argvalues = []
         for storename in STORES:
             for klass in klasses:
-                ids.append(f'{storename}/{klass}')
+                ids.append(f"{storename}/{klass}")
                 argvalues.append((storename, klass))
         metafunc.parametrize(argname, argvalues, ids=ids, indirect=True)
 
-    multi_mark = metafunc.definition.get_closest_marker('multi')
+    multi_mark = metafunc.definition.get_closest_marker("multi")
     if multi_mark is not None:
         ids = []
         argvalues = []
-        stores = multi_mark.kwargs['Store']
+        stores = multi_mark.kwargs["Store"]
         for store in stores:
             ids.append(store.__name__)
             argvalues.append(store)
-        metafunc.parametrize('Store', argvalues, ids=ids)
+        metafunc.parametrize("Store", argvalues, ids=ids)
 
 
 def make_store(request, tmpdir):
     storename, kind = request.param
-    storemodule = pytest.importorskip(STORES_PACKAGE + '.' + storename.split(':')[0])
+    storemodule = pytest.importorskip(STORES_PACKAGE + "." + storename.split(":")[0])
     klass = getattr(storemodule, kind)
     construct = constructors.get(storename)
     if construct is None:
-        pytest.xfail(f'don\'t know how to construct {storename} store')
+        pytest.xfail(f"don't know how to construct {storename} store")
     store = construct(klass, tmpdir)
     store.create()
     store.open()
@@ -91,7 +91,7 @@ def fst(request):
 def store(request, tmpdir):
     store = make_store(request, tmpdir)
     storename, kind = request.param
-    if kind == 'FileStore':
+    if kind == "FileStore":
         store = ByteToStreamWrappingStore(store)
     # store here always is a ByteStore and can be tested as such
     return store
diff --git a/src/moin/storage/stores/_tests/test_all.py b/src/moin/storage/stores/_tests/test_all.py
index 3ef9769a8..562789f2d 100644
--- a/src/moin/storage/stores/_tests/test_all.py
+++ b/src/moin/storage/stores/_tests/test_all.py
@@ -11,11 +11,11 @@
 
 def test_getitem_raises(store):
     with pytest.raises(KeyError):
-        store['doesnotexist']
+        store["doesnotexist"]
 
 
 def test_setitem_getitem_delitem(store):
-    k, v = 'key', b'value'
+    k, v = "key", b"value"
     store[k] = v
     assert v == store[k]
     del store[k]
@@ -24,7 +24,7 @@ def test_setitem_getitem_delitem(store):
 
 
 def test_setitem_getitem_delitem_binary(store):
-    k, v = 'key', b'\000\001\002'
+    k, v = "key", b"\000\001\002"
     store[k] = v
     assert v == store[k]
     assert len(v) == 3
@@ -34,7 +34,7 @@ def test_setitem_getitem_delitem_binary(store):
 
 
 def test_iter(store):
-    kvs = {('1', b'one'), ('2', b'two'), ('3', b'three'), }
+    kvs = {("1", b"one"), ("2", b"two"), ("3", b"three")}
     for k, v in kvs:
         store[k] = v
     result = set()
@@ -45,9 +45,9 @@ def test_iter(store):
 
 def test_len(store):
     assert len(store) == 0
-    store['foo'] = b'bar'
+    store["foo"] = b"bar"
     assert len(store) == 1
-    del store['foo']
+    del store["foo"]
     assert len(store) == 0
 
 
diff --git a/src/moin/storage/stores/_tests/test_fs.py b/src/moin/storage/stores/_tests/test_fs.py
index 2b0ac5dc3..abf20a84f 100644
--- a/src/moin/storage/stores/_tests/test_fs.py
+++ b/src/moin/storage/stores/_tests/test_fs.py
@@ -11,9 +11,9 @@
 from ..fs import BytesStore, FileStore
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_create_and_destroy(tmpdir, Store):
-    target = tmpdir.join('store')
+    target = tmpdir.join("store")
     assert not target.check()
     store = Store(str(target))
     assert not target.check()
@@ -23,7 +23,7 @@ def test_create_and_destroy(tmpdir, Store):
     assert not target.check()
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_from_uri(tmpdir, Store):
     store = Store.from_uri("%s" % tmpdir)
     assert store.path == tmpdir
diff --git a/src/moin/storage/stores/_tests/test_memory.py b/src/moin/storage/stores/_tests/test_memory.py
index 29f737d90..85f895f17 100644
--- a/src/moin/storage/stores/_tests/test_memory.py
+++ b/src/moin/storage/stores/_tests/test_memory.py
@@ -11,7 +11,7 @@
 from ..memory import BytesStore, FileStore
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_create_and_destroy(Store):
     store = Store()
     assert store._st is None
@@ -23,7 +23,7 @@ def test_create_and_destroy(Store):
     assert store._st is None
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_from_uri(Store):
     store = Store.from_uri("mem://")
     assert isinstance(store, Store)
diff --git a/src/moin/storage/stores/_tests/test_sqla.py b/src/moin/storage/stores/_tests/test_sqla.py
index 9541c56b2..19e993e38 100644
--- a/src/moin/storage/stores/_tests/test_sqla.py
+++ b/src/moin/storage/stores/_tests/test_sqla.py
@@ -11,14 +11,14 @@
 
 from ..sqla import BytesStore, FileStore
 
-pytest.importorskip('moin.storage.stores.sqla')  # noqa
+pytest.importorskip("moin.storage.stores.sqla")  # noqa
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_create_and_destroy(tmpdir, Store):
-    dbfile = tmpdir.join('store.sqlite')
+    dbfile = tmpdir.join("store.sqlite")
     assert not dbfile.check()
-    store = Store(f'sqlite:///{dbfile!s}')
+    store = Store(f"sqlite:///{dbfile!s}")
     assert not dbfile.check()
     store.create()
     assert dbfile.check()
@@ -26,7 +26,7 @@ def test_create_and_destroy(tmpdir, Store):
     # TODO: check for dropped table
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_from_uri(tmpdir, Store):
     store = Store.from_uri("sqlite://%s::test_base" % tmpdir)
     assert store.db_uri == "sqlite://%s" % tmpdir
diff --git a/src/moin/storage/stores/_tests/test_sqlite.py b/src/moin/storage/stores/_tests/test_sqlite.py
index ebf32c980..f703484a1 100644
--- a/src/moin/storage/stores/_tests/test_sqlite.py
+++ b/src/moin/storage/stores/_tests/test_sqlite.py
@@ -13,32 +13,29 @@
 
 
 def bytes_compressed(path):
-    return BytesStore(path, 'test_table', compression_level=1)
+    return BytesStore(path, "test_table", compression_level=1)
 
 
 def bytes_uncompressed(path):
-    return BytesStore(path, 'test_table', compression_level=0)
+    return BytesStore(path, "test_table", compression_level=0)
 
 
 def file_compressed(path):
-    return FileStore(path, 'test_table', compression_level=1)
+    return FileStore(path, "test_table", compression_level=1)
 
 
 def file_uncompressed(path):
-    return FileStore(path, 'test_table', compression_level=0)
+    return FileStore(path, "test_table", compression_level=0)
 
 
-all_setups = pytest.mark.parametrize('Store', [
-    bytes_uncompressed,
-    bytes_compressed,
-    file_uncompressed,
-    file_compressed,
-])
+all_setups = pytest.mark.parametrize(
+    "Store", [bytes_uncompressed, bytes_compressed, file_uncompressed, file_compressed]
+)
 
 
 @all_setups
 def test_create(tmpdir, Store):
-    dbfile = tmpdir.join('store.sqlite')
+    dbfile = tmpdir.join("store.sqlite")
     assert not dbfile.check()
     store = Store(str(dbfile))
     assert not dbfile.check()
@@ -48,14 +45,14 @@ def test_create(tmpdir, Store):
     # TODO: check for dropped table
 
 
-@pytest.mark.parametrize('Store', [BytesStore, FileStore])
+@pytest.mark.parametrize("Store", [BytesStore, FileStore])
 def test_from_uri(tmpdir, Store):
     store = Store.from_uri("%s::test_table::0" % tmpdir)
     assert store.db_name == tmpdir
-    assert store.table_name == 'test_table'
+    assert store.table_name == "test_table"
     assert store.compression_level == 0
 
     store = Store.from_uri("%s::test_table::2" % tmpdir)
     assert store.db_name == tmpdir
-    assert store.table_name == 'test_table'
+    assert store.table_name == "test_table"
     assert store.compression_level == 2
diff --git a/src/moin/storage/stores/fs.py b/src/moin/storage/stores/fs.py
index d8f7f6107..cb607ef30 100644
--- a/src/moin/storage/stores/fs.py
+++ b/src/moin/storage/stores/fs.py
@@ -11,7 +11,7 @@
 import errno
 import shutil
 
-from . import (BytesMutableStoreBase, FileMutableStoreBase, BytesMutableStoreMixin)
+from . import BytesMutableStoreBase, FileMutableStoreBase, BytesMutableStoreMixin
 
 
 class FileStore(FileMutableStoreBase):
@@ -20,6 +20,7 @@ class FileStore(FileMutableStoreBase):
 
     keys are required to be valid filenames.
     """
+
     @classmethod
     def from_uri(cls, uri):
         return cls(uri)
@@ -52,7 +53,7 @@ def __delitem__(self, key):
 
     def __getitem__(self, key):
         try:
-            return open(self._mkpath(key), 'rb')
+            return open(self._mkpath(key), "rb")
         except OSError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError(key)
diff --git a/src/moin/storage/stores/memory.py b/src/moin/storage/stores/memory.py
index 871911d95..31657e1e8 100644
--- a/src/moin/storage/stores/memory.py
+++ b/src/moin/storage/stores/memory.py
@@ -9,13 +9,14 @@
 Note: likely this is mostly useful for unit tests.
 """
 
-from . import (BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin)
+from . import BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin
 
 
 class BytesStore(BytesMutableStoreBase):
     """
     A simple dict-based in-memory store. No persistence!
     """
+
     @classmethod
     def from_uri(cls, uri):
         return cls()
diff --git a/src/moin/storage/stores/sqla.py b/src/moin/storage/stores/sqla.py
index e6ea14000..efd0fb150 100644
--- a/src/moin/storage/stores/sqla.py
+++ b/src/moin/storage/stores/sqla.py
@@ -14,7 +14,7 @@
 from sqlalchemy.exc import IntegrityError
 
 from moin.constants.namespaces import NAMESPACE_USERPROFILES
-from . import (BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin)
+from . import BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin
 
 KEY_LEN = 128
 VALUE_LEN = 1024 * 1024  # 1MB binary data
@@ -24,6 +24,7 @@ class BytesStore(BytesMutableStoreBase):
     """
     A simple dict-based in-memory store. No persistence!
     """
+
     @classmethod
     def from_uri(cls, uri):
         """
@@ -37,7 +38,7 @@ def from_uri(cls, uri):
         params = uri.split("::")
         return cls(*params)
 
-    def __init__(self, db_uri=None, table_name='store', verbose=False):
+    def __init__(self, db_uri=None, table_name="store", verbose=False):
         """
         :param db_uri: The database uri that we pass on to SQLAlchemy.
                        May contain user/password/host/port/etc.
@@ -49,8 +50,8 @@ def __init__(self, db_uri=None, table_name='store', verbose=False):
         self.engine = None
         self.table = None
         self.table_name = table_name
-        if db_uri.startswith('sqlite:///'):
-            db_path = os.path.dirname(self.db_uri.split('sqlite:///')[1])
+        if db_uri.startswith("sqlite:///"):
+            db_path = os.path.dirname(self.db_uri.split("sqlite:///")[1])
             if not os.path.exists(db_path):
                 os.makedirs(db_path)
 
@@ -59,17 +60,19 @@ def open(self):
         if db_uri is None:
             # These are settings that apply only for development / testing only. The additional args are necessary
             # due to some limitations of the in-memory sqlite database.
-            db_uri = 'sqlite:///:memory:'
-            self.engine = create_engine(db_uri, poolclass=StaticPool, connect_args={'check_same_thread': False})
+            db_uri = "sqlite:///:memory:"
+            self.engine = create_engine(db_uri, poolclass=StaticPool, connect_args={"check_same_thread": False})
         else:
             self.engine = create_engine(db_uri, echo=self.verbose, echo_pool=self.verbose)
 
         metadata = MetaData()
         metadata.bind = self.engine
-        self.table = Table(self.table_name, metadata,
-                           Column('key', String(KEY_LEN), primary_key=True),
-                           Column('value', LargeBinary(VALUE_LEN)),
-                           )
+        self.table = Table(
+            self.table_name,
+            metadata,
+            Column("key", String(KEY_LEN), primary_key=True),
+            Column("value", LargeBinary(VALUE_LEN)),
+        )
 
     def close(self):
         self.engine.dispose()
diff --git a/src/moin/storage/stores/sqlite.py b/src/moin/storage/stores/sqlite.py
index ff2da1fe6..e132767b9 100644
--- a/src/moin/storage/stores/sqlite.py
+++ b/src/moin/storage/stores/sqlite.py
@@ -17,13 +17,14 @@
 from sqlite3 import connect, Row, IntegrityError
 
 from moin.constants.namespaces import NAMESPACE_USERPROFILES
-from . import (BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin)
+from . import BytesMutableStoreBase, FileMutableStoreBase, FileMutableStoreMixin
 
 
 class BytesStore(BytesMutableStoreBase):
     """
     A simple sqlite3 based store.
     """
+
     @classmethod
     def from_uri(cls, uri):
         """
@@ -41,7 +42,7 @@ def from_uri(cls, uri):
             params[2] = int(params[2])
         return cls(*params)
 
-    def __init__(self, db_name, table_name='store', compression_level=0):
+    def __init__(self, db_name, table_name="store", compression_level=0):
         """
         Just store the params.
 
@@ -63,12 +64,12 @@ def __init__(self, db_name, table_name='store', compression_level=0):
     def create(self):
         conn = connect(self.db_name)
         with conn:
-            conn.execute(f'create table {self.table_name} (key text primary key, value blob)')
+            conn.execute(f"create table {self.table_name} (key text primary key, value blob)")
 
     def destroy(self):
         conn = connect(self.db_name)
         with conn:
-            conn.execute(f'drop table {self.table_name}')
+            conn.execute(f"drop table {self.table_name}")
 
     def open(self):
         self.conn = connect(self.db_name, check_same_thread=False)
@@ -79,11 +80,11 @@ def close(self):
 
     def __iter__(self):
         for row in self.conn.execute(f"select key from {self.table_name}"):
-            yield row['key']
+            yield row["key"]
 
     def __delitem__(self, key):
         with self.conn:
-            self.conn.execute(f'delete from {self.table_name} where key=?', (key, ))
+            self.conn.execute(f"delete from {self.table_name} where key=?", (key,))
 
     def _compress(self, value):
         if self.compression_level:
@@ -105,10 +106,10 @@ def _decompress(self, value):
         return value
 
     def __getitem__(self, key):
-        rows = list(self.conn.execute(f"select value from {self.table_name} where key=?", (key, )))
+        rows = list(self.conn.execute(f"select value from {self.table_name} where key=?", (key,)))
         if not rows:
             raise KeyError(key)
-        value = str(rows[0]['value'])  # a str in base64 encoding
+        value = str(rows[0]["value"])  # a str in base64 encoding
         value = base64.b64decode(value.encode())
         return self._decompress(value)
 
@@ -117,14 +118,12 @@ def __setitem__(self, key, value):
         with self.conn:
             value = base64.b64encode(value).decode()  # a str in base64 encoding
             try:
-                self.conn.execute(f'insert into {self.table_name} values (?, ?)', (key, value))
+                self.conn.execute(f"insert into {self.table_name} values (?, ?)", (key, value))
             except IntegrityError:
                 if NAMESPACE_USERPROFILES in self.db_name:
                     # userprofiles namespace does support revisions so we update existing row
                     self.conn.execute(
-                        'UPDATE {0} SET value = "{2}" WHERE key = "{1}"'.format(
-                            self.table_name, key, value
-                        )
+                        'UPDATE {0} SET value = "{2}" WHERE key = "{1}"'.format(self.table_name, key, value)
                     )
                 else:
                     raise
diff --git a/src/moin/themes/__init__.py b/src/moin/themes/__init__.py
index 02d92ad77..83b785317 100644
--- a/src/moin/themes/__init__.py
+++ b/src/moin/themes/__init__.py
@@ -29,8 +29,16 @@
 from moin.constants.namespaces import NAMESPACE_DEFAULT, NAMESPACE_USERS, NAMESPACE_ALL
 from moin.constants.rights import SUPERUSER
 from moin.search import SearchForm
-from moin.utils.interwiki import (split_interwiki, getInterwikiHome, is_local_wiki, is_known_wiki,
-                                  url_for_item, CompositeName, split_fqname, get_fqname)
+from moin.utils.interwiki import (
+    split_interwiki,
+    getInterwikiHome,
+    is_local_wiki,
+    is_known_wiki,
+    url_for_item,
+    CompositeName,
+    split_fqname,
+    get_fqname,
+)
 from moin.utils.crypto import cache_key
 from moin.utils.forms import make_generator
 from moin.utils.clock import timed
@@ -38,12 +46,13 @@
 from moin.utils import show_time
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 def get_current_theme():
     # this might be called at a time when flaskg.user is not setup yet:
-    u = getattr(flaskg, 'user', None)
+    u = getattr(flaskg, "user", None)
     if u and u.theme_name is not None:
         theme_name = u.theme_name
     else:
@@ -61,19 +70,17 @@ def render_template(template, **context):
 
 
 def themed_error(e):
-    item_name = request.view_args.get('item_name', '')
+    item_name = request.view_args.get("item_name", "")
     if e.code == 403:
-        title = L_('Access Denied')
-        description = L_('You are not allowed to access this resource.')
-        if e.description.startswith(' '):
+        title = L_("Access Denied")
+        description = L_("You are not allowed to access this resource.")
+        if e.description.startswith(" "):
             # leading blank indicates supplemental info, not standard werkzeug message
             description += e.description
     else:
         # if we have no special code, we just return the HTTPException instance
         return e
-    content = render_template('error.html',
-                              item_name=item_name,
-                              title=title, description=description)
+    content = render_template("error.html", item_name=item_name, title=title, description=description)
     return content, e.code
 
 
@@ -81,6 +88,7 @@ class ThemeSupport:
     """
     Support code for template feeding.
     """
+
     def __init__(self, cfg):
         self.cfg = cfg
         self.user = flaskg.user
@@ -89,10 +97,10 @@ def __init__(self, cfg):
         self.ui_dir = cfg.content_dir
         self.user_lang = flaskg.user.language or self.ui_lang
         self.user_dir = Locale(self.user_lang).text_direction
-        if request.url_root[len(request.host_url):-1]:
-            self.wiki_root = '/' + request.url_root[len(request.host_url):-1]
+        if request.url_root[len(request.host_url) : -1]:
+            self.wiki_root = "/" + request.url_root[len(request.host_url) : -1]
         else:
-            self.wiki_root = ''
+            self.wiki_root = ""
 
     def get_fullname(self, meta):
         """
@@ -101,7 +109,7 @@ def get_fullname(self, meta):
         :rtype: tuple
         :returns: list of item names with namespace prefix or item names if default namespace
         """
-        fullname = (name if not meta[NAMESPACE] else meta[NAMESPACE] + '/' + name for name in meta[NAME])
+        fullname = (name if not meta[NAMESPACE] else meta[NAMESPACE] + "/" + name for name in meta[NAME])
         return fullname
 
     def field_term(self, field, term):
@@ -120,19 +128,19 @@ def field_term(self, field, term):
                 #     %2C&boolajax=true&is_ticket= HTTP/1.1
                 url = request.url
                 url = urllib.parse.unquote(url)
-                args = url.split('?q=')[1]
-                args = args.split('&')[0]
-                if '+' in args:
-                    terms = args.split('+')
-                elif ' ' in args:
+                args = url.split("?q=")[1]
+                args = args.split("&")[0]
+                if "+" in args:
+                    terms = args.split("+")
+                elif " " in args:
                     terms = args.split()
                 else:
                     terms = [args]
                 for keyval in terms:
-                    fld, trm = keyval.split(':')
-                    if fld == 'mtime' == field:
+                    fld, trm = keyval.split(":")
+                    if fld == "mtime" == field:
                         return fld, trm
-                    elif fld == 'rev_number' == field:
+                    elif fld == "rev_number" == field:
                         return fld, trm
                 term = "unknown"
             except Exception:
@@ -153,17 +161,24 @@ def get_action_tabs(self, fqname, current_endpoint):
         # TODO: Need to add fqname support to has_item in indexing.py
         exists = bool(flaskg.storage.get_item(**fqname.query))
 
-        navtabs_endpoints = ['frontend.show_item', 'frontend.history',
-                             'frontend.show_item_meta', 'frontend.highlight_item', 'frontend.backrefs',
-                             'frontend.index', 'frontend.sitemap', 'frontend.similar_names', ]
+        navtabs_endpoints = [
+            "frontend.show_item",
+            "frontend.history",
+            "frontend.show_item_meta",
+            "frontend.highlight_item",
+            "frontend.backrefs",
+            "frontend.index",
+            "frontend.sitemap",
+            "frontend.similar_names",
+        ]
 
         if self.user.may.write(fqname):
-            navtabs_endpoints.append('frontend.modify_item')
+            navtabs_endpoints.append("frontend.modify_item")
 
         icon = self.get_endpoint_iconmap()
 
         navtabs = []
-        spl_active = [('frontend.history', 'frontend.diff'), ]
+        spl_active = [("frontend.history", "frontend.diff")]
 
         for endpoint, label, title, check_exists in app.cfg.item_views:
             if endpoint not in app.cfg.endpoints_excluded:
@@ -173,16 +188,16 @@ def get_action_tabs(self, fqname, current_endpoint):
                         iconcls = icon[endpoint]
                         linkcls = None
 
-                        if endpoint == 'special.comments':
+                        if endpoint == "special.comments":
                             maincls = "moin-toggle-comments-button"
                             href = "#"
-                        elif endpoint == 'special.transclusions':
+                        elif endpoint == "special.transclusions":
                             maincls = "moin-transclusions-button"
                             href = "#"
                         else:
                             maincls = None
                             # special case for modify item link, this depends on the double click to edit JS
-                            if endpoint == 'frontend.modify_item':
+                            if endpoint == "frontend.modify_item":
                                 linkcls = "moin-modify-button"
                             href = url_for(endpoint, item_name=fqname)
                             if endpoint == current_endpoint or (endpoint, current_endpoint) in spl_active:
@@ -207,11 +222,20 @@ def get_local_panel(self, fqname):
         if not item:
             return [], [], []
 
-        user_actions_endpoints = ['frontend.quicklink_item', 'frontend.subscribe_item', ]
-        item_navigation_endpoints = ['special.supplementation']
-        item_actions_endpoints = ['frontend.rename_item', 'frontend.delete_item', 'frontend.destroy_item',
-                                  'frontend.download_item', 'frontend.convert_item',
-                                  'frontend.copy_item', ] if self.user.may.write(fqname) else []
+        user_actions_endpoints = ["frontend.quicklink_item", "frontend.subscribe_item"]
+        item_navigation_endpoints = ["special.supplementation"]
+        item_actions_endpoints = (
+            [
+                "frontend.rename_item",
+                "frontend.delete_item",
+                "frontend.destroy_item",
+                "frontend.download_item",
+                "frontend.convert_item",
+                "frontend.copy_item",
+            ]
+            if self.user.may.write(fqname)
+            else []
+        )
 
         user_actions = []
         item_navigation = []
@@ -228,17 +252,17 @@ def get_local_panel(self, fqname):
                             iconcls = icon[endpoint]
                             # endpoint = iconcls = label = None
 
-                            if endpoint == 'frontend.quicklink_item':
+                            if endpoint == "frontend.quicklink_item":
                                 if not flaskg.user.is_quicklinked_to([fqname]):
-                                    label = _('Add Link')
+                                    label = _("Add Link")
                                 else:
-                                    label = _('Remove Link')
+                                    label = _("Remove Link")
                                 user_actions.append((endpoint, href, iconcls, label, title, True))
-                            elif endpoint == 'frontend.subscribe_item':
+                            elif endpoint == "frontend.subscribe_item":
                                 if flaskg.user.is_subscribed_to(item.item):
-                                    label = _('Unsubscribe')
+                                    label = _("Unsubscribe")
                                 else:
-                                    label = _('Subscribe')
+                                    label = _("Subscribe")
                                 user_actions.append((endpoint, href, iconcls, label, title, True))
 
                     elif endpoint in item_actions_endpoints:
@@ -253,14 +277,14 @@ def get_local_panel(self, fqname):
 
                         iconcls = icon[endpoint]
 
-                        if endpoint == 'special.supplementation':
+                        if endpoint == "special.supplementation":
                             for sub_item_name in app.cfg.supplementation_item_names:
-                                current_sub = fqname.value.rsplit('/', 1)[-1]
+                                current_sub = fqname.value.rsplit("/", 1)[-1]
                                 if current_sub not in app.cfg.supplementation_item_names:
-                                    supp_name = f'{fqname.value}/{sub_item_name}'
+                                    supp_name = f"{fqname.value}/{sub_item_name}"
                                     if flaskg.storage.has_item(supp_name) or flaskg.user.may.write(supp_name):
                                         subitem_exists = self.storage.has_item(supp_name)
-                                        href = url_for('frontend.show_item', item_name=supp_name)
+                                        href = url_for("frontend.show_item", item_name=supp_name)
                                         label = _(sub_item_name)
                                         title = None
 
@@ -272,26 +296,28 @@ def get_local_panel(self, fqname):
         return user_actions, item_navigation, item_actions
 
     def get_endpoint_iconmap(self):
-        icon = {'frontend.quicklink_item': "fa fa-star-o",
-                'frontend.subscribe_item': "fa fa-envelope-o",
-                'frontend.index': "fa fa-list-alt",
-                'frontend.sitemap': "fa fa-sitemap",
-                'frontend.rename_item': "fa fa-i-cursor",
-                'frontend.delete_item': "fa fa-trash-o",
-                'frontend.destroy_item': "fa fa-fire",
-                'frontend.convert_item': "fa fa-clone",
-                'frontend.similar_names': "fa fa-search-minus",
-                'frontend.download_item': "fa fa-download",
-                'frontend.copy_item': "fa fa-comment-o",
-                'special.supplementation': "fa fa-comments-o",
-                'frontend.show_item': "fa fa-eye",
-                'frontend.modify_item': "fa fa-pencil",
-                'frontend.history': "fa fa-history",
-                'frontend.show_item_meta': "fa fa-table",
-                'frontend.highlight_item': "fa fa-code",
-                'frontend.backrefs': "fa fa-share",
-                'special.comments': "fa fa-comment-o",
-                'special.transclusions': "fa fa-object-group", }
+        icon = {
+            "frontend.quicklink_item": "fa fa-star-o",
+            "frontend.subscribe_item": "fa fa-envelope-o",
+            "frontend.index": "fa fa-list-alt",
+            "frontend.sitemap": "fa fa-sitemap",
+            "frontend.rename_item": "fa fa-i-cursor",
+            "frontend.delete_item": "fa fa-trash-o",
+            "frontend.destroy_item": "fa fa-fire",
+            "frontend.convert_item": "fa fa-clone",
+            "frontend.similar_names": "fa fa-search-minus",
+            "frontend.download_item": "fa fa-download",
+            "frontend.copy_item": "fa fa-comment-o",
+            "special.supplementation": "fa fa-comments-o",
+            "frontend.show_item": "fa fa-eye",
+            "frontend.modify_item": "fa fa-pencil",
+            "frontend.history": "fa fa-history",
+            "frontend.show_item_meta": "fa fa-table",
+            "frontend.highlight_item": "fa fa-code",
+            "frontend.backrefs": "fa fa-share",
+            "special.comments": "fa fa-comment-o",
+            "special.transclusions": "fa fa-object-group",
+        }
         return icon
 
     def location_breadcrumbs(self, fqname):
@@ -304,7 +330,7 @@ def location_breadcrumbs(self, fqname):
         :returns: location breadcrumbs items in tuple (segment_name, fq_name, exists)
         """
         breadcrumbs = []
-        current_item = ''
+        current_item = ""
         if not isinstance(fqname, CompositeName):
             fqname = split_fqname(fqname)
         if fqname.field != NAME_EXACT:
@@ -314,13 +340,13 @@ def location_breadcrumbs(self, fqname):
         item_name = fqname.value
         if not item_name:
             return breadcrumbs
-        for segment in item_name.split('/'):
+        for segment in item_name.split("/"):
             current_item += segment
             fq_current = CompositeName(namespace, NAME_EXACT, current_item)
             fq_segment = CompositeName(segment1_namespace, NAME_EXACT, segment)
             breadcrumbs.append((fq_segment, fq_current, bool(self.storage.get_item(**fq_current.query))))
-            current_item += '/'
-            segment1_namespace = ''
+            current_item += "/"
+            segment1_namespace = ""
         return breadcrumbs
 
     def path_breadcrumbs(self):
@@ -340,7 +366,7 @@ def path_breadcrumbs(self):
             href = url_for_item(wiki_name=wiki_name, **fqname.split)
             if is_local_wiki(wiki_name):
                 exists = bool(self.storage.get_item(**fqname.query))
-                wiki_name = ''  # means "this wiki" for the theme code
+                wiki_name = ""  # means "this wiki" for the theme code
             else:
                 exists = True  # we can't detect existance of remote items
             if item_name:
@@ -387,13 +413,13 @@ def split_navilink(self, text):
         :returns: pagename or url, link to page or url
         """
         title = None
-        wiki_local = ''  # means local wiki
+        wiki_local = ""  # means local wiki
 
         # Handle [[pagename|title]] or [[url|title]] formats
-        if text.startswith('[[') and text.endswith(']]'):
+        if text.startswith("[[") and text.endswith("]]"):
             text = text[2:-2]
             try:
-                target, title = text.split('|', 1)
+                target, title = text.split("|", 1)
                 target = target.strip()
                 title = title.strip()
             except (ValueError, TypeError):
@@ -412,8 +438,8 @@ def split_navilink(self, text):
             target = target[5:]
 
         wiki_name, namespace, field, item_name = split_interwiki(target)
-        if wiki_name == 'Self':
-            wiki_name = ''
+        if wiki_name == "Self":
+            wiki_name = ""
         href = url_for_item(item_name, namespace=namespace, wiki_name=wiki_name, field=field)
         if not title:
             title = shorten_fqname(CompositeName(namespace, field, item_name))
@@ -438,17 +464,17 @@ def navibar(self, fqname):
                 endpoint = "frontend.show_item"
                 root_fqname = fqname.get_root_fqname()
                 default_root = app.cfg.root_mapping.get(NAMESPACE_DEFAULT, app.cfg.default_root)
-                args['item_name'] = root_fqname.fullname if fqname.namespace != NAMESPACE_ALL else default_root
+                args["item_name"] = root_fqname.fullname if fqname.namespace != NAMESPACE_ALL else default_root
                 # override link_text to show untranslated <default_root> itemname or <namespace>/<default_root>
-                link_text = args['item_name']
+                link_text = args["item_name"]
             elif endpoint in ["frontend.global_history", "frontend.global_tags"]:
-                args['namespace'] = fqname.namespace
+                args["namespace"] = fqname.namespace
                 if fqname and fqname.namespace:
-                    link_text = f'{fqname.namespace}/{link_text}'
+                    link_text = f"{fqname.namespace}/{link_text}"
             elif endpoint == "frontend.index":
-                args['item_name'] = fqname.namespace
+                args["item_name"] = fqname.namespace
                 if fqname and fqname.namespace:
-                    link_text = f'{fqname.namespace}/{link_text}'
+                    link_text = f"{fqname.namespace}/{link_text}"
             elif endpoint == "admin.index" and not getattr(flaskg.user.may, SUPERUSER)():
                 continue
             items.append((cls, url_for(endpoint, **args), link_text, title))
@@ -456,26 +482,26 @@ def navibar(self, fqname):
         # Add user links to wiki links.
         for text in self.user.quicklinks:
             url, link_text, title = self.split_navilink(text)
-            items.append(('userlink', url, link_text, title))
+            items.append(("userlink", url, link_text, title))
 
         # Add sister pages (see http://usemod.com/cgi-bin/mb.pl?SisterSitesImplementationGuide )
         for sistername, sisterurl in self.cfg.sistersites:
             if is_local_wiki(sistername):
-                items.append(('sisterwiki current', sisterurl, sistername, ''))
+                items.append(("sisterwiki current", sisterurl, sistername, ""))
             else:
                 cid = cache_key(usage="SisterSites", sistername=sistername)
                 sisteritems = app.cache.get(cid)
                 if sisteritems is None:
                     uo = urllib.request.URLopener()
-                    uo.version = 'MoinMoin SisterItem list fetcher 1.0'
+                    uo.version = "MoinMoin SisterItem list fetcher 1.0"
                     try:
                         sisteritems = {}
                         f = uo.open(sisterurl)
                         for line in f:
                             line = line.strip()
                             try:
-                                item_url, item_name = line.split(' ', 1)
-                                sisteritems[item_name.decode('utf-8')] = item_url
+                                item_url, item_name = line.split(" ", 1)
+                                sisteritems[item_name.decode("utf-8")] = item_url
                             except Exception:
                                 pass  # ignore invalid lines
                         f.close()
@@ -487,7 +513,7 @@ def navibar(self, fqname):
                         logging.exception("exception was:")
                 if current in sisteritems:
                     url = sisteritems[current]
-                    items.append(('sisterwiki', url, sistername, ''))
+                    items.append(("sisterwiki", url, sistername, ""))
         return items
 
     def parent_item(self, item_name):
@@ -511,6 +537,7 @@ def parentnames(self, names):
         """
         # must import here to avoid circular import error
         from moin.storage.middleware.indexing import parent_names
+
         return parent_names(names)
 
     # Properties ##############################################################
@@ -523,10 +550,10 @@ def login_url(self):
         :returns: url for user login
         """
         url = None
-        if self.cfg.auth_login_inputs == ['special_no_input']:
-            url = url_for('frontend.login', login=1)
+        if self.cfg.auth_login_inputs == ["special_no_input"]:
+            url = url_for("frontend.login", login=1)
         if self.cfg.auth_have_login:
-            url = url or url_for('frontend.login')
+            url = url or url_for("frontend.login")
         return url
 
     def get_fqnames(self, fqname):
@@ -545,14 +572,14 @@ def get_namespaces(self, ns=None):
         Return the list of tuples (composite name, namespace) referring to namespaces other
         than the current namespace.
         """
-        if ns is not None and ns.value == '~':
-            ns = ''
+        if ns is not None and ns.value == "~":
+            ns = ""
         namespace_root_mapping = []
         for namespace, _unused in app.cfg.namespace_mapping:
-            namespace = namespace.rstrip('/')
+            namespace = namespace.rstrip("/")
             if ns is None or namespace != ns:
-                fq_namespace = CompositeName(namespace, NAME_EXACT, '')
-                namespace_root_mapping.append((namespace or '~', fq_namespace.get_root_fqname()))
+                fq_namespace = CompositeName(namespace, NAME_EXACT, "")
+                namespace_root_mapping.append((namespace or "~", fq_namespace.get_root_fqname()))
         return namespace_root_mapping
 
     def item_exists(self, itemname):
@@ -571,7 +598,7 @@ def variables_css(self):
         :rtype: boolean
         :returns: whether variables.css file exists or not
         """
-        path = os.path.join(get_current_theme().path, 'static/css/variables.css')
+        path = os.path.join(get_current_theme().path, "static/css/variables.css")
         return os.path.isfile(path)
 
     def is_markup_or_text(self, contenttype):
@@ -592,9 +619,9 @@ def get_editor_info(meta, external=False):
     """
     addr = meta.get(ADDRESS)
     hostname = meta.get(HOSTNAME)
-    text = _('anonymous')  # link text
-    title = ''  # link title
-    css = 'editor'  # link/span css class
+    text = _("anonymous")  # link text
+    title = ""  # link title
+    css = "editor"  # link/span css class
     name = None  # author name
     uri = None  # author homepage uri
     email = None  # pure email address of author
@@ -602,12 +629,12 @@ def get_editor_info(meta, external=False):
         # only tell ip / hostname if show_hosts is True
         if hostname:
             text = hostname[:15]  # 15 = len(ipaddr)
-            name = title = f'{hostname}[{addr}]'
-            css = 'editor host'
+            name = title = f"{hostname}[{addr}]"
+            css = "editor host"
         else:
             name = text = addr
-            title = f'[{addr}]'
-            css = 'editor ip'
+            title = f"[{addr}]"
+            css = "editor ip"
 
     userid = meta.get(USERID)
     if userid:
@@ -622,25 +649,25 @@ def get_editor_info(meta, external=False):
             title = display_name
         if u.mailto_author and u.email:
             email = u.email
-            css = 'editor mail'
+            css = "editor mail"
         else:
             homewiki = app.cfg.user_homewiki
             if is_local_wiki(homewiki):
-                css = 'editor homepage local'
+                css = "editor homepage local"
             else:
-                css = 'editor homepage interwiki'
+                css = "editor homepage interwiki"
             uri = url_for_item(name, wiki_name=homewiki, _external=external, namespace=NAMESPACE_USERS)
 
     result = dict(name=name, text=text, css=css, title=title)
     if uri:
-        result['uri'] = uri
+        result["uri"] = uri
     if email:
-        result['email'] = email
+        result["email"] = email
     return result
 
 
 def get_assigned_to_info(meta):
-    display_name = ''
+    display_name = ""
     userid = meta.get(ASSIGNED_TO)
     if userid:
         u = user.User(userid)
@@ -660,7 +687,7 @@ def shorten_fqname(fqname, length=25):
     """
     if fqname.namespace and fqname.field in (REVID, ITEMID):
         # users/@itemid12345678901234567890...12 > users/1234567
-        return fqname.namespace + '/' + shorten_id(fqname.value)
+        return fqname.namespace + "/" + shorten_id(fqname.value)
     name = fqname.fullname
     if len(name) > length:
         if fqname.field in [REVID, ITEMID]:
@@ -685,14 +712,14 @@ def shorten_item_name(name, length=25):
     """
     # First use only the sub page name, that might be enough
     if len(name) > length:
-        name_part = name.split('/')[-1]
+        name_part = name.split("/")[-1]
         # If it's not enough, replace the middle with '...'
         if len(name_part) > length:
             half, left = divmod(length - 3, 2)
-            name = f'{name_part[:half + left]}...{name_part[-half:]}'
+            name = f"{name_part[:half + left]}...{name_part[-half:]}"
         elif len(name_part) < length - 6:
             # now it is too short, add back starting characters
-            name = f'{name[:length - len(name_part) - 3]}...{name_part}'
+            name = f"{name[:length - len(name_part) - 3]}...{name_part}"
         else:
             name = name_part
     return name
@@ -710,17 +737,17 @@ def shorten_id(name, length=7):
     :rtype: unicode
     :returns: <name> truncated to <length> characters
     """
-    if name.startswith('@itemid/'):
-        return name[8:8 + length]
+    if name.startswith("@itemid/"):
+        return name[8 : 8 + length]
     return name[:length]
 
 
 MIMETYPE_TO_CLASS = {
-    'application/pdf': 'pdf',
-    'application/zip': 'package',
-    'application/x-tar': 'package',
-    'application/x-gtar': 'package',
-    'application/x-svgdraw': 'drawing',
+    "application/pdf": "pdf",
+    "application/zip": "package",
+    "application/x-tar": "package",
+    "application/x-gtar": "package",
+    "application/x-svgdraw": "drawing",
 }
 
 
@@ -731,8 +758,8 @@ def contenttype_to_class(contenttype):
     cls = MIMETYPE_TO_CLASS.get(contenttype)
     if not cls:
         # just use the major part of mimetype
-        cls = contenttype.split('/', 1)[0]
-    return f'moin-mime-{cls}'
+        cls = contenttype.split("/", 1)[0]
+    return f"moin-mime-{cls}"
 
 
 def utctimestamp(dt):
@@ -743,6 +770,7 @@ def utctimestamp(dt):
           functions and also to UTC (see time.gmtime, see datetime.utcfromtimestamp).
     """
     from calendar import timegm
+
     return timegm(dt.timetuple())
 
 
@@ -762,7 +790,7 @@ def time_hh_mm(dt):
     Convert a datetime object or timestamp into a short string of the form HH:MM
     where HH varies from 0 to 23.
     """
-    return show_time.format_time(dt, fmt='HH:mm')
+    return show_time.format_time(dt, fmt="HH:mm")
 
 
 def time_datetime(dt):
@@ -775,39 +803,41 @@ def time_datetime(dt):
 
 
 def setup_jinja_env():
-    app.jinja_env.filters['shorten_fqname'] = shorten_fqname
-    app.jinja_env.filters['shorten_item_name'] = shorten_item_name
-    app.jinja_env.filters['shorten_id'] = shorten_id
-    app.jinja_env.filters['contenttype_to_class'] = contenttype_to_class
-    app.jinja_env.filters['json_dumps'] = dumps
-    app.jinja_env.filters['shorten_ctype'] = shorten_ctype
-    app.jinja_env.filters['time_hh_mm'] = time_hh_mm
-    app.jinja_env.filters['time_datetime'] = time_datetime
+    app.jinja_env.filters["shorten_fqname"] = shorten_fqname
+    app.jinja_env.filters["shorten_item_name"] = shorten_item_name
+    app.jinja_env.filters["shorten_id"] = shorten_id
+    app.jinja_env.filters["contenttype_to_class"] = contenttype_to_class
+    app.jinja_env.filters["json_dumps"] = dumps
+    app.jinja_env.filters["shorten_ctype"] = shorten_ctype
+    app.jinja_env.filters["time_hh_mm"] = time_hh_mm
+    app.jinja_env.filters["time_datetime"] = time_datetime
     # please note that these filters are installed by flask-babel:
     # datetimeformat, dateformat, timeformat, timedeltaformat
 
-    app.jinja_env.globals.update({
-        # please note that flask-babel/jinja2.ext installs:
-        # _, gettext, ngettext
-        'isinstance': isinstance,
-        'list': list,
-        'Type': Type,
-        # please note that flask-theme installs:
-        # theme, theme_static
-        'theme_supp': ThemeSupport(app.cfg),
-        'user': flaskg.user,
-        'storage': flaskg.storage,
-        'clock': flaskg.clock,
-        'cfg': app.cfg,
-        'item_name': request.view_args.get('item_name', ''),
-        'url_for_item': url_for_item,
-        'get_fqname': get_fqname,
-        'get_editor_info': lambda meta: get_editor_info(meta),
-        'get_assigned_to_info': lambda meta: get_assigned_to_info(meta),
-        'utctimestamp': lambda dt: utctimestamp(dt),
-        'gen': make_generator(),
-        'search_form': SearchForm.from_defaults(),
-    })
+    app.jinja_env.globals.update(
+        {
+            # please note that flask-babel/jinja2.ext installs:
+            # _, gettext, ngettext
+            "isinstance": isinstance,
+            "list": list,
+            "Type": Type,
+            # please note that flask-theme installs:
+            # theme, theme_static
+            "theme_supp": ThemeSupport(app.cfg),
+            "user": flaskg.user,
+            "storage": flaskg.storage,
+            "clock": flaskg.clock,
+            "cfg": app.cfg,
+            "item_name": request.view_args.get("item_name", ""),
+            "url_for_item": url_for_item,
+            "get_fqname": get_fqname,
+            "get_editor_info": lambda meta: get_editor_info(meta),
+            "get_assigned_to_info": lambda meta: get_assigned_to_info(meta),
+            "utctimestamp": lambda dt: utctimestamp(dt),
+            "gen": make_generator(),
+            "search_form": SearchForm.from_defaults(),
+        }
+    )
 
     # if Jinja whitespace control options are turned on, it becomes obvious why the default is off
     # app.jinja_env.trim_blocks = True
diff --git a/src/moin/themes/_tests/test_navi_bar.py b/src/moin/themes/_tests/test_navi_bar.py
index 1024e9133..94e22a506 100644
--- a/src/moin/themes/_tests/test_navi_bar.py
+++ b/src/moin/themes/_tests/test_navi_bar.py
@@ -20,7 +20,7 @@ class TestNaviBar:
     @pytest.fixture
     def cfg(self):
         class Config(wikiconfig.Config):
-            interwiki_map = dict(Self='http://localhost:8080/', MoinMoin='http://moinmo.in/', )
+            interwiki_map = dict(Self="http://localhost:8080/", MoinMoin="http://moinmo.in/")
 
         return Config
 
@@ -31,63 +31,63 @@ def theme(self):
     def test_split_navilink(self, theme):
         tests = [
             # (navilink, (href, text, interwiki)),
-            ('ItemName', ('/ItemName', 'ItemName', '')),
-            ('[[ItemName|LinkText]]', ('/ItemName', 'LinkText', '')),
-            ('MoinMoin/ItemName', ('http://moinmo.in/ItemName', 'ItemName', 'MoinMoin')),
-            ('[[MoinMoin/ItemName|LinkText]]', ('http://moinmo.in/ItemName', 'LinkText', 'MoinMoin')),
-            ('[[wiki:MoinMoin/ItemName|LinkText]]', ('http://moinmo.in/ItemName', 'LinkText', 'MoinMoin')),
-            ('http://example.org/', ('http://example.org/', 'http://example.org/', '')),
-            ('[[http://example.org/|LinkText]]', ('http://example.org/', 'LinkText', '')),
+            ("ItemName", ("/ItemName", "ItemName", "")),
+            ("[[ItemName|LinkText]]", ("/ItemName", "LinkText", "")),
+            ("MoinMoin/ItemName", ("http://moinmo.in/ItemName", "ItemName", "MoinMoin")),
+            ("[[MoinMoin/ItemName|LinkText]]", ("http://moinmo.in/ItemName", "LinkText", "MoinMoin")),
+            ("[[wiki:MoinMoin/ItemName|LinkText]]", ("http://moinmo.in/ItemName", "LinkText", "MoinMoin")),
+            ("http://example.org/", ("http://example.org/", "http://example.org/", "")),
+            ("[[http://example.org/|LinkText]]", ("http://example.org/", "LinkText", "")),
         ]
         for navilink, expected in tests:
             result = theme.split_navilink(navilink)
             assert result == expected
 
     def test_location_breadcrumbs(self, theme):
-        test_result = ThemeSupport.location_breadcrumbs(theme, 'some/place/test_item')
+        test_result = ThemeSupport.location_breadcrumbs(theme, "some/place/test_item")
         test_segment_name_1, test_item_name_1, test_item_exists_1 = test_result[0]
         test_segment_name_2, test_item_name_2, test_item_exists_2 = test_result[1]
         test_segment_name_3, test_item_name_3, test_item_exists_3 = test_result[2]
 
-        assert test_segment_name_1.namespace == ''
-        assert test_item_name_1.namespace == ''
-        assert test_segment_name_1.value == 'some'
-        assert test_item_name_1.value == 'some'
-        assert test_segment_name_2.value == 'place'
-        assert test_item_name_2.value == 'some/place'
-        assert test_segment_name_3.value == 'test_item'
-        assert test_item_name_3.value == 'some/place/test_item'
+        assert test_segment_name_1.namespace == ""
+        assert test_item_name_1.namespace == ""
+        assert test_segment_name_1.value == "some"
+        assert test_item_name_1.value == "some"
+        assert test_segment_name_2.value == "place"
+        assert test_item_name_2.value == "some/place"
+        assert test_segment_name_3.value == "test_item"
+        assert test_item_name_3.value == "some/place/test_item"
 
-        test_result = ThemeSupport.location_breadcrumbs(theme, 'users/some/place/test_item')
+        test_result = ThemeSupport.location_breadcrumbs(theme, "users/some/place/test_item")
         test_segment_name_1, test_item_name_1, test_item_exists_1 = test_result[0]
         test_segment_name_2, test_item_name_2, test_item_exists_2 = test_result[1]
         test_segment_name_3, test_item_name_3, test_item_exists_3 = test_result[2]
 
-        assert test_segment_name_1.namespace == 'users'
-        assert test_item_name_1.namespace == 'users'
-        assert test_segment_name_1.value == 'some'
-        assert test_item_name_1.value == 'some'
-        assert test_segment_name_2.value == 'place'
-        assert test_item_name_2.value == 'some/place'
-        assert test_segment_name_3.value == 'test_item'
-        assert test_item_name_3.value == 'some/place/test_item'
+        assert test_segment_name_1.namespace == "users"
+        assert test_item_name_1.namespace == "users"
+        assert test_segment_name_1.value == "some"
+        assert test_item_name_1.value == "some"
+        assert test_segment_name_2.value == "place"
+        assert test_item_name_2.value == "some/place"
+        assert test_segment_name_3.value == "test_item"
+        assert test_item_name_3.value == "some/place/test_item"
 
     def test_parent_item(self, theme):
-        test_result = ThemeSupport.parent_item(theme, 'moin/moin-2.0/Item')
-        expected = 'moin/moin-2.0'
+        test_result = ThemeSupport.parent_item(theme, "moin/moin-2.0/Item")
+        expected = "moin/moin-2.0"
         assert test_result == expected, 'Expected "%(expected)s" but got "%(test_result)s"' % locals()
 
 
 def test_shorten_item_name():
-    test_result1 = themes.shorten_item_name('MoinMoin/some/value', 0)
-    assert test_result1 == 'valu...lue'
-    test_result2 = themes.shorten_item_name('MoinMoin/some/value', 5)
-    assert test_result2 == 'value'
-    test_result3 = themes.shorten_item_name('MoinMoin/some/value')
-    assert test_result3 == 'MoinMoin/some/value'
+    test_result1 = themes.shorten_item_name("MoinMoin/some/value", 0)
+    assert test_result1 == "valu...lue"
+    test_result2 = themes.shorten_item_name("MoinMoin/some/value", 5)
+    assert test_result2 == "value"
+    test_result3 = themes.shorten_item_name("MoinMoin/some/value")
+    assert test_result3 == "MoinMoin/some/value"
 
 
 def test_contenttype_to_class():
-    test_result = themes.contenttype_to_class('MoinMoin/some/value')
-    expected = 'moin-mime-MoinMoin'
+    test_result = themes.contenttype_to_class("MoinMoin/some/value")
+    expected = "moin-mime-MoinMoin"
     assert test_result == expected
diff --git a/src/moin/user.py b/src/moin/user.py
index c113dc4c8..95de95df8 100644
--- a/src/moin/user.py
+++ b/src/moin/user.py
@@ -34,8 +34,25 @@
 from moin.constants.contenttypes import CONTENTTYPE_USER
 from moin.constants.namespaces import NAMESPACE_USERPROFILES
 from moin.constants.keys import (
-    BOOKMARKS, CONTENTTYPE, CURRENT, DISABLED, EMAIL, EMAIL_UNVALIDATED, ENC_PASSWORD, ITEMID, NAME, NAME_EXACT,
-    NAMEPREFIX, NAMERE, NAMESPACE, RECOVERPASS_KEY, SESSION_KEY, SESSION_TOKEN, TAGS, USEROBJ_ATTRS, WIKINAME
+    BOOKMARKS,
+    CONTENTTYPE,
+    CURRENT,
+    DISABLED,
+    EMAIL,
+    EMAIL_UNVALIDATED,
+    ENC_PASSWORD,
+    ITEMID,
+    NAME,
+    NAME_EXACT,
+    NAMEPREFIX,
+    NAMERE,
+    NAMESPACE,
+    RECOVERPASS_KEY,
+    SESSION_KEY,
+    SESSION_TOKEN,
+    TAGS,
+    USEROBJ_ATTRS,
+    WIKINAME,
 )
 
 from moin.constants.misc import ANON
@@ -47,6 +64,7 @@
 from moin.storage.error import NoSuchItemError, NoSuchRevisionError
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -70,16 +88,18 @@ def create_user(username, password, email, validate=True, is_encrypted=False, ve
 
     # Don't allow creating users with invalid names
     if validate and not isValidName(username):
-        return _("""Invalid user name '{name}'.
+        return _(
+            """Invalid user name '{name}'.
 Name may contain any Unicode alpha numeric character, with optional one
-space between words. Group page name is not allowed.""").format(name=username)
+space between words. Group page name is not allowed."""
+        ).format(name=username)
 
     # Name required to be unique. Check if name belong to another user.
     if validate and search_users(**{NAME_EXACT: username}):
         return _("This user name already belongs to somebody else.")
 
     # XXX currently we just support creating with 1 name:
-    theuser.profile[NAME] = [str(username), ]
+    theuser.profile[NAME] = [str(username)]
 
     pw_checker = app.cfg.password_checker
     if validate and pw_checker:
@@ -91,8 +111,7 @@ def create_user(username, password, email, validate=True, is_encrypted=False, ve
 
     # try to get the email, for new users it is required
     if validate and not email:
-        return _("Please provide your email address. If you lose your"
-                 " login information, you can get it by email.")
+        return _("Please provide your email address. If you lose your" " login information, you can get it by email.")
 
     # Email should be unique - see also MoinMoin/scripts/accounts/moin_usercheck.py
     if validate and email and app.cfg.user_email_unique:
@@ -122,15 +141,15 @@ def update_user_query(**q):
         NAMESPACE: NAMESPACE_USERPROFILES,
         CONTENTTYPE: CONTENTTYPE_USER,
         WIKINAME: app.cfg.interwikiname,  # XXX for now, search only users of THIS wiki
-                                          # maybe add option to not index wiki users
-                                          # separately, but share them in the index also.
+        # maybe add option to not index wiki users
+        # separately, but share them in the index also.
     }
     q.update(USER_QUERY_STDARGS)
     return q
 
 
 def search_users(**q):
-    """ Searches for a users with given query keys/values """
+    """Searches for a users with given query keys/values"""
     # Since item name is a list, it's possible a list have been passed as parameter.
     # No problem, since user always have just one name (TODO: validate single name for user)
     if q.get(NAME_EXACT) and isinstance(q.get(NAME_EXACT), list):
@@ -142,28 +161,28 @@ def search_users(**q):
 
 
 def get_editor(userid, addr, hostname):
-    """ Return a tuple of type id and string or Page object
-        representing the user that did the edit.
+    """Return a tuple of type id and string or Page object
+    representing the user that did the edit.
 
-        The type id is one of 'ip' (DNS or numeric IP), 'email' (email addr),
-        'interwiki' (Interwiki homepage) or 'anon' ('').
+    The type id is one of 'ip' (DNS or numeric IP), 'email' (email addr),
+    'interwiki' (Interwiki homepage) or 'anon' ('').
     """
-    result = 'anon', ''
+    result = "anon", ""
     if app.cfg.show_hosts and hostname:
-        result = 'ip', hostname
+        result = "ip", hostname
     if userid:
         userdata = User(userid)
         if userdata.mailto_author and userdata.email:
-            return 'email', userdata.email
+            return "email", userdata.email
         elif userdata.name:
             interwiki = getInterwikiHome(userdata.name0)
             if interwiki:
-                result = ('interwiki', interwiki)
+                result = ("interwiki", interwiki)
     return result
 
 
 def normalizeName(name):
-    """ Make normalized user name
+    """Make normalized user name
 
     Prevent impersonating another user with names containing leading,
     trailing or multiple whitespace, or using invisible unicode
@@ -183,17 +202,17 @@ def normalizeName(name):
     # We also allow _ in usernames for nicer URLs.
     username_allowedchars = "'@.-_"
     # Strip non alpha numeric characters (except username_allowedchars), keep white space
-    name = ''.join([c for c in name if c.isalnum() or c.isspace() or c in username_allowedchars])
+    name = "".join([c for c in name if c.isalnum() or c.isspace() or c in username_allowedchars])
 
     # Normalize white space. Each name can contain multiple
     # words separated with only one space.
-    name = ' '.join(name.split())
+    name = " ".join(name.split())
 
     return name
 
 
 def isValidName(name):
-    """ Validate user name
+    """Validate user name
 
     :param name: user name, unicode
     """
@@ -202,7 +221,7 @@ def isValidName(name):
 
 
 def assemble_subscription(keyword, value, namespace=None):
-    """ Create a valid subscription string
+    """Create a valid subscription string
 
     :param keyword: the keyword (itemid, name, tags, nameprefix, namere) by which
                     the type of the subscription is determined
@@ -212,7 +231,7 @@ def assemble_subscription(keyword, value, namespace=None):
     """
     if keyword == ITEMID:
         subscription = f"{ITEMID}:{value}"
-    elif keyword in [NAME, TAGS, NAMERE, NAMEPREFIX, ]:
+    elif keyword in [NAME, TAGS, NAMERE, NAMEPREFIX]:
         if namespace is not None:
             subscription = f"{keyword}:{namespace}:{value}"
         else:
@@ -223,7 +242,7 @@ def assemble_subscription(keyword, value, namespace=None):
 
 
 class UserProfile:
-    """ A User Profile"""
+    """A User Profile"""
 
     def __init__(self, **q):
         self._defaults = copy.deepcopy(app.cfg.user_defaults)
@@ -291,16 +310,16 @@ def save(self, force=False):
             q = {ITEMID: self[ITEMID]}
             q = update_user_query(**q)
             item = get_user_backend().get_item(**q)
-            item.store_revision(self._meta, BytesIO(b''), overwrite=True)
+            item.store_revision(self._meta, BytesIO(b""), overwrite=True)
             self._stored = True
             self._changed = False
 
 
 class User:
-    """ A MoinMoin User """
+    """A MoinMoin User"""
 
     def __init__(self, uid=None, name="", password=None, auth_username="", trusted=False, **kw):
-        """ Initialize User object
+        """Initialize User object
 
         :param uid: (optional) user ID (user itemid)
         :param name: (optional) user name
@@ -320,8 +339,8 @@ def __init__(self, uid=None, name="", password=None, auth_username="", trusted=F
         self._cfg = app.cfg
         self.valid = False
         self.trusted = trusted
-        self.auth_method = kw.get('auth_method', 'internal')
-        self.auth_attribs = kw.get('auth_attribs', ())
+        self.auth_method = kw.get("auth_method", "internal")
+        self.auth_attribs = kw.get("auth_attribs", ())
 
         # XXX currently we just support creating with 1 name:
         _name = name or auth_username
@@ -340,7 +359,7 @@ def __init__(self, uid=None, name="", password=None, auth_username="", trusted=F
         else:
             self.profile[ITEMID] = make_uuid()
             if _name:
-                self.profile[NAME] = [_name, ]
+                self.profile[NAME] = [_name]
             if password is not None:
                 self.set_password(password)
 
@@ -353,8 +372,8 @@ def __repr__(self):
         itemid = getattr(self, ITEMID, None)
 
         return "<{}.{} at {:#x} name:{!r} itemid:{!r} valid:{!r} trusted:{!r}>".format(
-            self.__class__.__module__, self.__class__.__name__, id(self),
-            name, itemid, self.valid, self.trusted)
+            self.__class__.__module__, self.__class__.__name__, id(self), name, itemid, self.valid, self.trusted
+        )
 
     def __getattr__(self, name):
         """
@@ -399,16 +418,14 @@ def avatar(self, size=30):
 
         email = self.email
         if not email:
-            return static_file_url(theme, theme.info.get('default_avatar', 'img/default_avatar.png'))
+            return static_file_url(theme, theme.info.get("default_avatar", "img/default_avatar.png"))
 
         param = {}
-        param['gravatar_id'] = hashlib.md5(email.lower()).hexdigest()
+        param["gravatar_id"] = hashlib.md5(email.lower()).hexdigest()
 
-        param['default'] = static_file_url(theme,
-                                           theme.info.get('default_avatar', 'img/default_avatar.png'),
-                                           True)
+        param["default"] = static_file_url(theme, theme.info.get("default_avatar", "img/default_avatar.png"), True)
 
-        param['size'] = str(size)
+        param["size"] = str(size)
         # TODO: use same protocol of Moin site (might be https instead of http)]
         gravatar_url = "http://www.gravatar.com/avatar.php?"
         gravatar_url += werkzeug.url_encode(param)
@@ -416,7 +433,7 @@ def avatar(self, size=30):
         return gravatar_url
 
     def create_or_update(self, changed=False):
-        """ Create or update a user profile
+        """Create or update a user profile
 
         :param changed: bool, set this to True if you updated the user profile values
         """
@@ -424,7 +441,7 @@ def create_or_update(self, changed=False):
             self.save()  # yes, create/update user profile
 
     def exists(self):
-        """ Do we have a user profile for this user?
+        """Do we have a user profile for this user?
 
         :rtype: bool
         :returns: true, if we have a user account
@@ -432,7 +449,7 @@ def exists(self):
         return self.profile.stored
 
     def load_from_id(self, itemid, password=None):
-        """ Load user account data from disk.
+        """Load user account data from disk.
 
         :param password: If not None, then the given password must match the
                          password in the user account file.
@@ -483,8 +500,9 @@ def _validate_password(self, data, password):
         try:
             password_correct, recomputed_hash = pwd_context.verify_and_update(password, pw_hash)
         except (ValueError, TypeError) as err:
-            logging.error('in user profile %r, verifying the passlib pw hash raised an Exception [%s]' % (
-                self.name, str(err)))
+            logging.error(
+                "in user profile %r, verifying the passlib pw hash raised an Exception [%s]" % (self.name, str(err))
+            )
         else:
             if recomputed_hash is not None:
                 data[ENC_PASSWORD] = recomputed_hash
@@ -504,13 +522,13 @@ def set_password(self, password, is_encrypted=False):
         """
         if not password:
             # invalidate the pw hash
-            password = ''
+            password = ""
         elif not is_encrypted:
             password = self._cfg.cache.pwd_context.hash(password)
         self.profile[ENC_PASSWORD] = password
         # Invalidate all other browser sessions except this one.
         try:
-            session['user.session_token'] = self.generate_session_token(False)
+            session["user.session_token"] = self.generate_session_token(False)
         except RuntimeError:  # CLI call has no valid session context
             pass
 
@@ -518,10 +536,10 @@ def has_invalidated_password(self):
         """
         Check if the password hash of this user is invalid.
         """
-        return self.profile[ENC_PASSWORD] == ''
+        return self.profile[ENC_PASSWORD] == ""
 
     def disable(self):
-        """ Disable user """
+        """Disable user"""
         self.profile[DISABLED] = True
 
     def save(self, force=False):
@@ -540,19 +558,19 @@ def save(self, force=False):
             pass  # XXX UserChangedEvent
 
     def getText(self, text):
-        """ translate a text to the language of this user """
+        """translate a text to the language of this user"""
         return text  # FIXME, was: self._request.getText(text, lang=self.language)
 
     # Bookmarks --------------------------------------------------------------
 
     def _set_bookmark(self, tm):
-        """ Set bookmark timestamp.
+        """Set bookmark timestamp.
 
         :param tm: timestamp (int or None)
         """
         if self.valid:
             if not (tm is None or isinstance(tm, int)):
-                raise ValueError('tm should be int or None')
+                raise ValueError("tm should be int or None")
             if tm is None:
                 self.profile[BOOKMARKS].pop(self._cfg.interwikiname)
             else:
@@ -560,7 +578,7 @@ def _set_bookmark(self, tm):
             self.save(force=True)
 
     def _get_bookmark(self):
-        """ Get bookmark timestamp.
+        """Get bookmark timestamp.
 
         :rtype: int / None
         :returns: bookmark timestamp or None
@@ -578,13 +596,14 @@ def _get_bookmark(self):
     # Subscribed Items -------------------------------------------------------
 
     def is_subscribed_to(self, item):
-        """ Check if user is subscribed to the following item
+        """Check if user is subscribed to the following item
 
         :param item: Item object
         :rtype: bool
         :returns: if user is subscribed to the item
         """
         from moin.items import NonExistent
+
         if not self.valid or isinstance(item, (NonExistent, Undefined)):
             return False
 
@@ -594,10 +613,8 @@ def is_subscribed_to(self, item):
         itemid = meta.get(ITEMID)
         if itemid is not None:
             subscriptions.update([f"{ITEMID}:{itemid}"])
-        subscriptions.update(f"{NAME}:{item_namespace}:{name}"
-                             for name in meta.get(NAME, []))
-        subscriptions.update(f"{TAGS}:{item_namespace}:{tag}"
-                             for tag in meta.get(TAGS, []))
+        subscriptions.update(f"{NAME}:{item_namespace}:{name}" for name in meta.get(NAME, []))
+        subscriptions.update(f"{TAGS}:{item_namespace}:{tag}" for tag in meta.get(TAGS, []))
         if subscriptions & set(self.subscriptions):
             return True
 
@@ -606,7 +623,7 @@ def is_subscribed_to(self, item):
         return False
 
     def subscribe(self, keyword, value, namespace=None):
-        """ Subscribe to a wiki page.
+        """Subscribe to a wiki page.
 
         The user can subscribe in 5 different ways:
 
@@ -633,7 +650,7 @@ def subscribe(self, keyword, value, namespace=None):
         return False
 
     def unsubscribe(self, keyword, value, namespace=None, item=None):
-        """ Unsubscribe from a wiki page.
+        """Unsubscribe from a wiki page.
 
         Same as for subscribing, user can also unsubscribe in 5 ways.
         The unsubscribe action doesn't guarantee that user will not receive any
@@ -660,7 +677,7 @@ def unsubscribe(self, keyword, value, namespace=None, item=None):
     # Quicklinks -------------------------------------------------------------
 
     def is_quicklinked_to(self, pagelist):
-        """ Check if user quicklink matches any page in pagelist.
+        """Check if user quicklink matches any page in pagelist.
 
         :param pagelist: list of pages to check for quicklinks
         :rtype: bool
@@ -678,7 +695,7 @@ def is_quicklinked_to(self, pagelist):
         return False
 
     def quicklink(self, pagename):
-        """ Adds a page to the user quicklinks
+        """Adds a page to the user quicklinks
 
         Add links as interwiki names.
 
@@ -696,7 +713,7 @@ def quicklink(self, pagename):
         return False
 
     def quickunlink(self, pagename):
-        """ Remove a page from user quicklinks
+        """Remove a page from user quicklinks
 
         Remove interwiki name from quicklinks.
 
@@ -716,46 +733,46 @@ def quickunlink(self, pagename):
     # Trail ------------------------------------------------------------------
 
     def add_trail(self, item_name):
-        """ Add item name to trail.
+        """Add item name to trail.
 
         :param item_name: the item name (unicode) to add to the trail
         """
         item_name = getInterwikiName(item_name)
-        trail_in_session = session.get('trail', [])
+        trail_in_session = session.get("trail", [])
         trail = trail_in_session[:]
         trail = [i for i in trail if i != item_name]  # avoid dupes
         trail.append(item_name)  # append current item name at end
-        trail = trail[-self._cfg.trail_size:]  # limit trail length
+        trail = trail[-self._cfg.trail_size :]  # limit trail length
         if trail != trail_in_session:
-            session['trail'] = trail
+            session["trail"] = trail
 
     def get_trail(self):
-        """ Return list of recently visited item names.
+        """Return list of recently visited item names.
 
         :rtype: list
         :returns: item names (unicode) in trail
         """
-        return session.get('trail', [])
+        return session.get("trail", [])
 
     # Other ------------------------------------------------------------------
 
     def is_current_user(self):
-        """ Check if this user object is the user doing the current request """
+        """Check if this user object is the user doing the current request"""
         return flaskg.user.itemid == self.itemid
 
     # Sessions ---------------------------------------------------
 
     def logout_session(self, all_browsers=True):
-        """ Terminate session in all browsers unless all_browsers is set to False """
+        """Terminate session in all browsers unless all_browsers is set to False"""
         if all_browsers:
             self.generate_session_token(False)
 
-        for key in ['user.itemid', 'user.trusted', 'user.auth_method', 'user.auth_attribs', 'user.session_token', ]:
+        for key in ["user.itemid", "user.trusted", "user.auth_method", "user.auth_attribs", "user.session_token"]:
             if key in session:
                 del session[key]
 
     def generate_session_token(self, save=True):
-        """ Generate new session token and key pair. Used to validate sessions. """
+        """Generate new session token and key pair. Used to validate sessions."""
         key, token = generate_token()
         self.profile[SESSION_TOKEN] = token
         self.profile[SESSION_KEY] = key
@@ -765,14 +782,14 @@ def generate_session_token(self, save=True):
         return token
 
     def get_session_token(self):
-        """ Get current session token. If there is no token, generate a new one. """
+        """Get current session token. If there is no token, generate a new one."""
         try:
             return self.profile[SESSION_TOKEN]
         except KeyError:
             return self.generate_session_token()
 
     def validate_session(self, token):
-        """ Check if the session token is valid.
+        """Check if the session token is valid.
 
         Invalid session tokens happen for these cases:
 
@@ -808,8 +825,8 @@ def apply_recovery_token(self, token, newpass):
         return True
 
     def mail_password_recovery(self, cleartext_passwd=None, subject=None, text=None):
-        """ Mail a user who forgot his password a message enabling
-            him to login again.
+        """Mail a user who forgot his password a message enabling
+        him to login again.
         """
         if not self.email:
             return False, "user has no E-Mail address in his profile."
@@ -817,23 +834,23 @@ def mail_password_recovery(self, cleartext_passwd=None, subject=None, text=None)
         token = self.generate_recovery_token()
 
         if subject is None:
-            subject = _('[{sitename}] Your wiki password recovery link').format(sitename='{sitename}')
+            subject = _("[{sitename}] Your wiki password recovery link").format(sitename="{sitename}")
         subject = subject % dict(sitename=self._cfg.sitename or "Wiki")
         if text is None:
-            link = url_for('frontend.recoverpass', username=self.name0, token=token, _external=True)
-            text = render_template('mail/password_recovery.txt', link=link)
+            link = url_for("frontend.recoverpass", username=self.name0, token=token, _external=True)
+            text = render_template("mail/password_recovery.txt", link=link)
 
         mailok, msg = sendmail.sendmail(subject, text, to=[self.email], mail_from=self._cfg.mail_from)
         return mailok, msg
 
     def mail_email_verification(self):
-        """ Mail a user a link to verify his email address. """
+        """Mail a user a link to verify his email address."""
         token = self.generate_recovery_token()
 
-        link = url_for('frontend.verifyemail', username=self.name0, token=token, _external=True)
-        text = render_template('mail/account_verification.txt', link=link)
+        link = url_for("frontend.verifyemail", username=self.name0, token=token, _external=True)
+        text = render_template("mail/account_verification.txt", link=link)
 
-        subject = _('[{sitename}] Please verify your email address').format(sitename=self._cfg.sitename or "Wiki")
+        subject = _("[{sitename}] Please verify your email address").format(sitename=self._cfg.sitename or "Wiki")
         email = self.profile[EMAIL_UNVALIDATED]
         mailok, msg = sendmail.sendmail(subject, text, to=[email], mail_from=self._cfg.mail_from)
         return mailok, msg
diff --git a/src/moin/utils/SubProcess.py b/src/moin/utils/SubProcess.py
index 3e0484ce4..8c87d0f37 100644
--- a/src/moin/utils/SubProcess.py
+++ b/src/moin/utils/SubProcess.py
@@ -20,6 +20,7 @@
     import select
     import errno
 
+
 class Popen(subprocess.Popen):
     def communicate(self, input=None, timeout=None):
         """Interact with process: Send data to stdin.  Read data from
@@ -53,20 +54,19 @@ def communicate(self, input=None, timeout=None):
         return self._communicate(input)
 
     if subprocess.mswindows:
+
         def _communicate(self, input):
-            stdout = None # Return
-            stderr = None # Return
+            stdout = None  # Return
+            stderr = None  # Return
 
             if self.stdout:
                 stdout = []
-                stdout_thread = threading.Thread(target=self._readerthread,
-                                                 args=(self.stdout, stdout))
+                stdout_thread = threading.Thread(target=self._readerthread, args=(self.stdout, stdout))
                 stdout_thread.setDaemon(True)
                 stdout_thread.start()
             if self.stderr:
                 stderr = []
-                stderr_thread = threading.Thread(target=self._readerthread,
-                                                 args=(self.stderr, stderr))
+                stderr_thread = threading.Thread(target=self._readerthread, args=(self.stderr, stderr))
                 stderr_thread.setDaemon(True)
                 stderr_thread.start()
 
@@ -81,8 +81,7 @@ def _communicate(self, input):
                 stderr_thread.join(self.timeout)
 
             # if the threads are still alive, that means the thread join timed out
-            timed_out = (self.stdout and stdout_thread.isAlive() or
-                         self.stderr and stderr_thread.isAlive())
+            timed_out = self.stdout and stdout_thread.isAlive() or self.stderr and stderr_thread.isAlive()
             if timed_out:
                 self.kill()
             else:
@@ -98,7 +97,7 @@ def _communicate(self, input):
             # object do the translation: It is based on stdio, which is
             # impossible to combine with select (unless forcing no
             # buffering).
-            if self.universal_newlines and hasattr(file, 'newlines'):
+            if self.universal_newlines and hasattr(file, "newlines"):
                 if stdout:
                     stdout = self._translate_newlines(stdout)
                 if stderr:
@@ -106,13 +105,14 @@ def _communicate(self, input):
 
             return (stdout, stderr)
 
-    else: # POSIX
+    else:  # POSIX
+
         def _communicate(self, input):
             timed_out = False
             read_set = []
             write_set = []
-            stdout = None # Return
-            stderr = None # Return
+            stdout = None  # Return
+            stderr = None  # Return
 
             if self.stdin:
                 # Flush stdio buffer.  This might block, if the user has
@@ -146,7 +146,7 @@ def _communicate(self, input):
                     # When select has indicated that the file is writable,
                     # we can write up to PIPE_BUF bytes without risk
                     # blocking.  POSIX defines PIPE_BUF >= 512
-                    chunk = input[input_offset:input_offset + 512]
+                    chunk = input[input_offset : input_offset + 512]
                     bytes_written = os.write(self.stdin.fileno(), chunk)
                     input_offset += bytes_written
                     if input_offset >= len(input):
@@ -169,15 +169,15 @@ def _communicate(self, input):
 
             # All data exchanged.  Translate lists into strings.
             if stdout is not None:
-                stdout = ''.join(stdout)
+                stdout = "".join(stdout)
             if stderr is not None:
-                stderr = ''.join(stderr)
+                stderr = "".join(stderr)
 
             # Translate newlines, if requested.  We cannot let the file
             # object do the translation: It is based on stdio, which is
             # impossible to combine with select (unless forcing no
             # buffering).
-            if self.universal_newlines and hasattr(file, 'newlines'):
+            if self.universal_newlines and hasattr(file, "newlines"):
                 if stdout:
                     stdout = self._translate_newlines(stdout)
                 if stderr:
@@ -191,16 +191,19 @@ def _communicate(self, input):
 
 
 def exec_cmd(cmd, input=None, timeout=None):
-    p = Popen(cmd, shell=True,
-              close_fds=not subprocess.mswindows,
-              bufsize=1024,
-              stdin=subprocess.PIPE,
-              stdout=subprocess.PIPE,
-              stderr=subprocess.PIPE)
+    p = Popen(
+        cmd,
+        shell=True,
+        close_fds=not subprocess.mswindows,
+        bufsize=1024,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
     data, errors = p.communicate(input, timeout=timeout)
     return data, errors, p.returncode
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print(exec_cmd("python", "import time ; time.sleep(20) ; print 'never!' ;", timeout=10))
     print(exec_cmd("python", "import time ; time.sleep(20) ; print '20s gone' ;"))
diff --git a/src/moin/utils/__init__.py b/src/moin/utils/__init__.py
index 98f2a1039..a4352c37d 100644
--- a/src/moin/utils/__init__.py
+++ b/src/moin/utils/__init__.py
@@ -19,37 +19,32 @@
 # XML helper functions
 #############################################################################
 
-g_xmlIllegalCharPattern = re.compile('[\x01-\x08\x0B-\x0D\x0E-\x1F\x80-\xFF]')
-g_undoUtf8Pattern = re.compile('\xC2([^\xC2])')
-g_cdataCharPattern = re.compile('[&<\'\"]')
-g_textCharPattern = re.compile('[&<]')
-g_charToEntity = {
-    '&': '&amp;',
-    '<': '&lt;',
-    "'": '&apos;',
-    '"': '&quot;'
-}
+g_xmlIllegalCharPattern = re.compile("[\x01-\x08\x0B-\x0D\x0E-\x1F\x80-\xFF]")
+g_undoUtf8Pattern = re.compile("\xC2([^\xC2])")
+g_cdataCharPattern = re.compile("[&<'\"]")
+g_textCharPattern = re.compile("[&<]")
+g_charToEntity = {"&": "&amp;", "<": "&lt;", "'": "&apos;", '"': "&quot;"}
 
 
 def TranslateCDATA(text):
     """
-        Convert a string to a CDATA-encoded one
-        Copyright (c) 1999-2000 FourThought
+    Convert a string to a CDATA-encoded one
+    Copyright (c) 1999-2000 FourThought
     """
     new_string, num_subst = re.subn(g_undoUtf8Pattern, lambda m: m.group(1), text)
     new_string, num_subst = re.subn(g_cdataCharPattern, lambda m, d=g_charToEntity: d[m.group()], new_string)
-    new_string, num_subst = re.subn(g_xmlIllegalCharPattern, lambda m: '&#x%02X;' % ord(m.group()), new_string)
+    new_string, num_subst = re.subn(g_xmlIllegalCharPattern, lambda m: "&#x%02X;" % ord(m.group()), new_string)
     return new_string
 
 
 def TranslateText(text):
     """
-        Convert a string to a PCDATA-encoded one (do minimal encoding)
-        Copyright (c) 1999-2000 FourThought
+    Convert a string to a PCDATA-encoded one (do minimal encoding)
+    Copyright (c) 1999-2000 FourThought
     """
     new_string, num_subst = re.subn(g_undoUtf8Pattern, lambda m: m.group(1), text)
     new_string, num_subst = re.subn(g_textCharPattern, lambda m, d=g_charToEntity: d[m.group()], new_string)
-    new_string, num_subst = re.subn(g_xmlIllegalCharPattern, lambda m: '&#x%02X;' % ord(m.group()), new_string)
+    new_string, num_subst = re.subn(g_xmlIllegalCharPattern, lambda m: "&#x%02X;" % ord(m.group()), new_string)
     return new_string
 
 
@@ -57,24 +52,25 @@ def TranslateText(text):
 # Misc
 #############################################################################
 
+
 def rangelist(numbers):
-    """ Convert a list of integers to a range string in the form
-        '1,2-5,7'.
+    """Convert a list of integers to a range string in the form
+    '1,2-5,7'.
     """
     numbers = sorted(numbers[:])
     numbers.append(999999)
-    pattern = ','
+    pattern = ","
     for i in range(len(numbers) - 1):
-        if pattern[-1] == ',':
+        if pattern[-1] == ",":
             pattern += str(numbers[i])
             if numbers[i] + 1 == numbers[i + 1]:
-                pattern += '-'
+                pattern += "-"
             else:
-                pattern += ','
+                pattern += ","
         elif numbers[i] + 1 != numbers[i + 1]:
-            pattern = pattern + str(numbers[i]) + ','
+            pattern = pattern + str(numbers[i]) + ","
 
-    if pattern[-1] in ',-':
+    if pattern[-1] in ",-":
         return pattern[1:-1]
     return pattern[1:]
 
@@ -88,5 +84,5 @@ def close_file(f):
         The process cannot access the file because it is being used by another process.
     """
     # some tests reuse BytesIO objects and will fail with I/O operation on closed file.
-    if hasattr(f, 'close') and not f.closed and not isinstance(f, BytesIO):
+    if hasattr(f, "close") and not f.closed and not isinstance(f, BytesIO):
         f.close()
diff --git a/src/moin/utils/_tests/test_crypto.py b/src/moin/utils/_tests/test_crypto.py
index d7deb2152..271d2a628 100644
--- a/src/moin/utils/_tests/test_crypto.py
+++ b/src/moin/utils/_tests/test_crypto.py
@@ -10,18 +10,20 @@
 
 
 class TestRandom:
-    """ crypto: random tests """
+    """crypto: random tests"""
 
     def testRandomString(self):
-        """ utils.random_string: test randomness and length """
+        """utils.random_string: test randomness and length"""
         length = 8
         chars = "abcdefghijklmnopqrstuvwxyz"
         result1 = crypto.random_string(length, chars)
         result2 = crypto.random_string(length, chars)
-        assert result1 != result2, 'Expected different random strings, but got "%(result1)s" and "%(result2)s"' % locals()
+        assert result1 != result2, (
+            'Expected different random strings, but got "%(result1)s" and "%(result2)s"' % locals()
+        )
 
         result_string = crypto.random_string(length, chars)
-        assert isinstance(result_string, str), ('Expected a string value, but got ' + str(type(result_string)))
+        assert isinstance(result_string, str), "Expected a string value, but got " + str(type(result_string))
 
         result = len(crypto.random_string(length, chars))
         expected = length
@@ -29,11 +31,11 @@ def testRandomString(self):
 
 
 class TestToken:
-    """ tests for the generated tokens """
+    """tests for the generated tokens"""
 
     def test_validtoken(self):
-        """ validate the token """
-        test_key, test_token = crypto.generate_token(key='MoinMoin')  # having some key value
+        """validate the token"""
+        test_key, test_token = crypto.generate_token(key="MoinMoin")  # having some key value
         result = crypto.valid_token(test_key, test_token)
         assert result
 
@@ -41,28 +43,28 @@ def test_validtoken(self):
         result = crypto.valid_token(test_key, test_token)
         assert result
 
-        test_parts = test_token.split('-')
-        test_parts[0] = 'not_valid'
+        test_parts = test_token.split("-")
+        test_parts[0] = "not_valid"
         # changed value of the first part, should not be string
-        test_token_changed = '-'.join(test_parts)
+        test_token_changed = "-".join(test_parts)
         result = crypto.valid_token(test_key, test_token_changed)
         assert not result
 
-        test_key, test_token = 'MoinMoin', 'incorrect_token'
+        test_key, test_token = "MoinMoin", "incorrect_token"
         result = crypto.valid_token(test_key, test_token)
         assert not result
 
 
 class TestCacheKey:
-    """ tests for cache key generation """
+    """tests for cache key generation"""
 
     def test_cache_key(self):
-        """ The key must be different for different <kw> """
-        test_kw1 = {'MoinMoin': 'value1'}
+        """The key must be different for different <kw>"""
+        test_kw1 = {"MoinMoin": "value1"}
         result1 = crypto.cache_key(**test_kw1)
-        test_kw2 = {'Moin2': 'value2'}
+        test_kw2 = {"Moin2": "value2"}
         result2 = crypto.cache_key(**test_kw2)
         assert result1 != result2, "Expected different keys for different <kw> but got the same"
 
 
-coverage_modules = ['moin.utils.crypto']
+coverage_modules = ["moin.utils.crypto"]
diff --git a/src/moin/utils/_tests/test_diff3.py b/src/moin/utils/_tests/test_diff3.py
index 6d6d1656e..505198080 100644
--- a/src/moin/utils/_tests/test_diff3.py
+++ b/src/moin/utils/_tests/test_diff3.py
@@ -12,7 +12,7 @@
 class TestDiff3:
 
     def testTextMerge(self):
-        """ utils.diff3.text_merge: test correct merging """
+        """utils.diff3.text_merge: test correct merging"""
         in1 = """AAA 001
 AAA 002
 AAA 003
@@ -83,4 +83,4 @@ def testTextMerge(self):
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
 
-coverage_modules = ['moin.utils.diff3']
+coverage_modules = ["moin.utils.diff3"]
diff --git a/src/moin/utils/_tests/test_diff_datastruct.py b/src/moin/utils/_tests/test_diff_datastruct.py
index f4bcc8704..d8b68a873 100644
--- a/src/moin/utils/_tests/test_diff_datastruct.py
+++ b/src/moin/utils/_tests/test_diff_datastruct.py
@@ -23,82 +23,91 @@ def test_diff_no_change(self):
             assert diff(d, d) == []
 
     def test_diff_none(self):
-        tests = [(None, None, []),
-                 (Undefined, None, [(INSERT, [], None)]),
-                 (None, Undefined, [(DELETE, [], None)])]
+        tests = [(None, None, []), (Undefined, None, [(INSERT, [], None)]), (None, Undefined, [(DELETE, [], None)])]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_bool(self):
-        tests = [(True, True, []),
-                 (Undefined, True, [(INSERT, [], True)]),
-                 (True, Undefined, [(DELETE, [], True)]),
-                 (True, False, [(DELETE, [], True), (INSERT, [], False)])]
+        tests = [
+            (True, True, []),
+            (Undefined, True, [(INSERT, [], True)]),
+            (True, Undefined, [(DELETE, [], True)]),
+            (True, False, [(DELETE, [], True), (INSERT, [], False)]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_int(self):
-        tests = [(1, 1, []),
-                 (Undefined, 2, [(INSERT, [], 2)]),
-                 (2, Undefined, [(DELETE, [], 2)]),
-                 (3, 4, [(DELETE, [], 3), (INSERT, [], 4)])]
+        tests = [
+            (1, 1, []),
+            (Undefined, 2, [(INSERT, [], 2)]),
+            (2, Undefined, [(DELETE, [], 2)]),
+            (3, 4, [(DELETE, [], 3), (INSERT, [], 4)]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_float(self):
-        tests = [(1.1, 1.1, []),
-                 (Undefined, 2.2, [(INSERT, [], 2.2)]),
-                 (2.2, Undefined, [(DELETE, [], 2.2)]),
-                 (3.3, 4.4, [(DELETE, [], 3.3), (INSERT, [], 4.4)])]
+        tests = [
+            (1.1, 1.1, []),
+            (Undefined, 2.2, [(INSERT, [], 2.2)]),
+            (2.2, Undefined, [(DELETE, [], 2.2)]),
+            (3.3, 4.4, [(DELETE, [], 3.3), (INSERT, [], 4.4)]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_unicode(self):
-        tests = [("same", "same", []),
-                 (Undefined, "new", [(INSERT, [], "new")]),
-                 ("old", Undefined, [(DELETE, [], "old")]),
-                 ("some value", "some other value",
-                  [(DELETE, [], "some value"), (INSERT, [], "some other value")])]
+        tests = [
+            ("same", "same", []),
+            (Undefined, "new", [(INSERT, [], "new")]),
+            ("old", Undefined, [(DELETE, [], "old")]),
+            ("some value", "some other value", [(DELETE, [], "some value"), (INSERT, [], "some other value")]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_list(self):
-        tests = [([1], [1], []),
-                 (Undefined, [2], [(INSERT, [], [2])]),
-                 ([2], Undefined, [(DELETE, [], [2])]),
-                 ([1, 2], [2, 3], [(DELETE, [], [1]), (INSERT, [], [3])]),
-                 ([9, 8], [8, 7, 6, 5], [(DELETE, [], [9]), (INSERT, [], [7, 6, 5])])]
+        tests = [
+            ([1], [1], []),
+            (Undefined, [2], [(INSERT, [], [2])]),
+            ([2], Undefined, [(DELETE, [], [2])]),
+            ([1, 2], [2, 3], [(DELETE, [], [1]), (INSERT, [], [3])]),
+            ([9, 8], [8, 7, 6, 5], [(DELETE, [], [9]), (INSERT, [], [7, 6, 5])]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_dict(self):
-        tests = [(dict(same=1), dict(same=1), []),
-                 (Undefined, dict(new=1), [(INSERT, ["new"], 1)]),
-                 (dict(old=1), Undefined, [(DELETE, ["old"], 1)]),
-                 (dict(same=1, old=2), dict(same=1, new1=3, new2=4),
-                  [(INSERT, ["new1"], 3), (INSERT, ["new2"], 4),
-                   (DELETE, ["old"], 2)])]
+        tests = [
+            (dict(same=1), dict(same=1), []),
+            (Undefined, dict(new=1), [(INSERT, ["new"], 1)]),
+            (dict(old=1), Undefined, [(DELETE, ["old"], 1)]),
+            (
+                dict(same=1, old=2),
+                dict(same=1, new1=3, new2=4),
+                [(INSERT, ["new1"], 3), (INSERT, ["new2"], 4), (DELETE, ["old"], 2)],
+            ),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_nested_dict(self):
-        tests = [(dict(key=dict(same=None)), dict(key=dict(same=None)), []),
-                 (dict(key=dict()), dict(key=dict(added=None)), [(INSERT, ["key", "added"], None)]),
-                 (dict(key=dict(removed=None)), dict(key=dict()), [(DELETE, ["key", "removed"], None)])]
+        tests = [
+            (dict(key=dict(same=None)), dict(key=dict(same=None)), []),
+            (dict(key=dict()), dict(key=dict(added=None)), [(INSERT, ["key", "added"], None)]),
+            (dict(key=dict(removed=None)), dict(key=dict()), [(DELETE, ["key", "removed"], None)]),
+        ]
         for d1, d2, expected in tests:
             assert diff(d1, d2) == expected
 
     def test_diff_str_unicode_keys(self):
         d1 = {"old": "old", "same1": "same1", "same2": "same2"}
         d2 = {"new": "new", "same1": "same1", "same2": "same2"}
-        assert diff(d1, d2) == [(INSERT, ["new"], "new"),
-                                (DELETE, ["old"], "old")]
+        assert diff(d1, d2) == [(INSERT, ["new"], "new"), (DELETE, ["old"], "old")]
 
     def test_diff_errors(self):
-        tests = [("foo", True),
-                 ((1, 2, ), (3, 4, )),
-                 (dict(key=(1, 2, )), dict()),
-                 (None, [1, 2, ])]
+        tests = [("foo", True), ((1, 2), (3, 4)), (dict(key=(1, 2)), dict()), (None, [1, 2])]
         for d1, d2 in tests:
             with pytest.raises(TypeError):
                 diff(d1, d2)
@@ -108,41 +117,39 @@ def test_make_text_diff_empty(self):
             assert got == ""
 
     def test_make_text_diff_none(self):
-        tests = [([(INSERT, [], None)], "+ None"),
-                 ([(DELETE, [], None)], "- None")]
+        tests = [([(INSERT, [], None)], "+ None"), ([(DELETE, [], None)], "- None")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_bool(self):
-        tests = [([(INSERT, [], True)], "+ True"),
-                 ([(DELETE, [], False)], "- False")]
+        tests = [([(INSERT, [], True)], "+ True"), ([(DELETE, [], False)], "- False")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_int(self):
-        tests = [([(INSERT, [], 123)], "+ 123"),
-                 ([(DELETE, [], 321)], "- 321")]
+        tests = [([(INSERT, [], 123)], "+ 123"), ([(DELETE, [], 321)], "- 321")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_float(self):
-        tests = [([(INSERT, [], 1.2)], "+ 1.2"),
-                 ([(DELETE, [], 3.4)], "- 3.4")]
+        tests = [([(INSERT, [], 1.2)], "+ 1.2"), ([(DELETE, [], 3.4)], "- 3.4")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_unicode(self):
-        tests = [([(INSERT, [], "new value")], "+ new value"),
-                 ([(DELETE, [], "old value")], "- old value")]
+        tests = [([(INSERT, [], "new value")], "+ new value"), ([(DELETE, [], "old value")], "- old value")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_list(self):
-        tests = [([(INSERT, [], [1, 2, 3, ])], "+ [1, 2, 3]"),
-                 ([(DELETE, [], [4, 5, ])], "- [4, 5]")]
+        tests = [([(INSERT, [], [1, 2, 3])], "+ [1, 2, 3]"), ([(DELETE, [], [4, 5])], "- [4, 5]")]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_one_key(self):
-        tests = [([(INSERT, ["key"], "new value")], "+ key: new value"),
-                 ([(DELETE, ["key"], "old value")], "- key: old value")]
+        tests = [
+            ([(INSERT, ["key"], "new value")], "+ key: new value"),
+            ([(DELETE, ["key"], "old value")], "- key: old value"),
+        ]
         self._test_make_text_diff(tests)
 
     def test_make_text_diff_multiple_keys(self):
-        tests = [([(INSERT, ["key1", "key2"], 1)], "+ key1.key2: 1"),
-                 ([(DELETE, ["key1", "key2", "key3"], 2)], "- key1.key2.key3: 2")]
+        tests = [
+            ([(INSERT, ["key1", "key2"], 1)], "+ key1.key2: 1"),
+            ([(DELETE, ["key1", "key2", "key3"], 2)], "- key1.key2.key3: 2"),
+        ]
         self._test_make_text_diff(tests)
diff --git a/src/moin/utils/_tests/test_diff_html.py b/src/moin/utils/_tests/test_diff_html.py
index 6c657a1e8..a3163d628 100644
--- a/src/moin/utils/_tests/test_diff_html.py
+++ b/src/moin/utils/_tests/test_diff_html.py
@@ -52,8 +52,14 @@ def test_diff():
 BBB 100
 """
     result = diff_html.diff(test_input1, test_input2)
-    expected = [(4, '<span><br>AAA 001<br>AAA 002<br>AAA 003<br>AAA 004<br>AAA 005</span>',
-                 4, '<span>BBB 006<br>BBB 007<br>BBB 008<br>BBB 009<br>BBB 100</span>')]
+    expected = [
+        (
+            4,
+            "<span><br>AAA 001<br>AAA 002<br>AAA 003<br>AAA 004<br>AAA 005</span>",
+            4,
+            "<span>BBB 006<br>BBB 007<br>BBB 008<br>BBB 009<br>BBB 100</span>",
+        )
+    ]
     assert result == expected
 
     # Case 2 : charobj.ratio() > 0.5 i.e. Some similarities
@@ -66,6 +72,12 @@ def test_diff():
 AAA 100
 """
     result = diff_html.diff(test_input1, test_input3)
-    expected = [(4, '<br>AAA 00<span>1</span><br>AAA 00<span>2</span><br>AAA 00<span>3</span><br>AAA 00<span>4<br>AAA 005</span>',
-                 4, '<span>AAA 006</span><br>AAA 00<span>7</span><br>AAA 00<span>8</span><br>AAA 00<span>9</span><br>AAA <span>1</span>00')]
+    expected = [
+        (
+            4,
+            "<br>AAA 00<span>1</span><br>AAA 00<span>2</span><br>AAA 00<span>3</span><br>AAA 00<span>4<br>AAA 005</span>",
+            4,
+            "<span>AAA 006</span><br>AAA 00<span>7</span><br>AAA 00<span>8</span><br>AAA 00<span>9</span><br>AAA <span>1</span>00",
+        )
+    ]
     assert result == expected
diff --git a/src/moin/utils/_tests/test_diff_text.py b/src/moin/utils/_tests/test_diff_text.py
index 85ab8d7e1..60653743f 100644
--- a/src/moin/utils/_tests/test_diff_text.py
+++ b/src/moin/utils/_tests/test_diff_text.py
@@ -12,7 +12,7 @@
 class TestDiffText:
 
     def testDiff(self):
-        """ utils.diff_text.diff: test correct diff calculation """
+        """utils.diff_text.diff: test correct diff calculation"""
         in1 = """AAA 001
 AAA 002
 AAA 003
@@ -67,4 +67,4 @@ def testDiff(self):
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
 
-coverage_modules = ['moin.utils.diff_text']
+coverage_modules = ["moin.utils.diff_text"]
diff --git a/src/moin/utils/_tests/test_filesys.py b/src/moin/utils/_tests/test_filesys.py
index 367c92ed0..4242ae6c7 100644
--- a/src/moin/utils/_tests/test_filesys.py
+++ b/src/moin/utils/_tests/test_filesys.py
@@ -18,10 +18,10 @@
 
 
 class TestRename:
-    """ test filesys.rename* """
+    """test filesys.rename*"""
 
     def setup_method(self, method):
-        self.test_dir = tempfile.mkdtemp('', 'rename_')
+        self.test_dir = tempfile.mkdtemp("", "rename_")
         self.src = os.path.join(self.test_dir, "rename-src")
         self.dst = os.path.join(self.test_dir, "rename-dst")
 
@@ -77,7 +77,7 @@ class TestCopy:
     """test filesys.copytree"""
 
     def setup_method(self, method):
-        self.test_dir = tempfile.mkdtemp('', 'copytree1')
+        self.test_dir = tempfile.mkdtemp("", "copytree1")
         self.src1 = os.path.join(self.test_dir, "copytree-src1")
         self.src2 = os.path.join(self.test_dir, "copytree-src2")
 
@@ -91,18 +91,18 @@ def makefile(self, src, content):
         f.close()
 
     def test_copytree(self):
-        self.makefile(self.src1, 'src1')
-        self.makefile(self.src2, 'src2')
-        self.test_dest_dir = self.test_dir + '_copy'
+        self.makefile(self.src1, "src1")
+        self.makefile(self.src2, "src2")
+        self.test_dest_dir = self.test_dir + "_copy"
         filesys.copytree(self.test_dir, self.test_dest_dir)
         # check for the dir contents
         assert sorted(os.listdir(self.test_dir)) == sorted(os.listdir(self.test_dest_dir))
 
     def test_dir_exist(self):
-        """ raise Error if dir already exist """
-        self.test_dest_dir = tempfile.mkdtemp('', 'temp_dir')
+        """raise Error if dir already exist"""
+        self.test_dest_dir = tempfile.mkdtemp("", "temp_dir")
         with pytest.raises(OSError):
             filesys.copytree(self.test_dir, self.test_dest_dir)
 
 
-coverage_modules = ['moin.utils.filesys']
+coverage_modules = ["moin.utils.filesys"]
diff --git a/src/moin/utils/_tests/test_forms.py b/src/moin/utils/_tests/test_forms.py
index 02730f90a..e95896da2 100644
--- a/src/moin/utils/_tests/test_forms.py
+++ b/src/moin/utils/_tests/test_forms.py
@@ -9,56 +9,57 @@
 
 
 class Bind:
-    """ class for self defined test_bind attributes """
+    """class for self defined test_bind attributes"""
+
     def __init__(self):
-        self.label = 'test_content'
-        self.default_value = 'test_bind_default'
+        self.label = "test_content"
+        self.default_value = "test_bind_default"
         self.optional = True
-        self.properties = {'autofocus': False, 'placeholder': None}
+        self.properties = {"autofocus": False, "placeholder": None}
         self.errors = None
 
 
 test_bind = Bind()
 
-test_attributes = {'type': 'submit', 'required': 'test_required', 'autofocus': None, 'placeholder': None}
+test_attributes = {"type": "submit", "required": "test_required", "autofocus": None, "placeholder": None}
 
 
 def test_label_filter():
     # when content is None
-    result1 = forms.label_filter('test_tagname', test_attributes, None, 'test_context', test_bind)
-    expected = 'test_content'
+    result1 = forms.label_filter("test_tagname", test_attributes, None, "test_context", test_bind)
+    expected = "test_content"
     assert result1 == expected
 
     # when content is not None
-    result2 = forms.label_filter('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    expected = 'new_content'
+    result2 = forms.label_filter("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    expected = "new_content"
     assert result2 == expected
 
 
 def test_button_filter():
-    result = forms.button_filter('test_tagname', test_attributes, 'new_content', 'test_context', None)
-    expected = 'new_content'
+    result = forms.button_filter("test_tagname", test_attributes, "new_content", "test_context", None)
+    expected = "new_content"
     assert result == expected
 
     # attributes.get('type') in ['submit', 'reset', ])
-    content_result = forms.button_filter('input', test_attributes, 'new_content', 'test_context', test_bind)
-    expected = 'new_content'
+    content_result = forms.button_filter("input", test_attributes, "new_content", "test_context", test_bind)
+    expected = "new_content"
     assert content_result == expected
-    attributes_result = test_attributes['value']
-    expected = 'test_bind_default'
+    attributes_result = test_attributes["value"]
+    expected = "test_bind_default"
     assert attributes_result == expected
 
     # tagname == 'button'
-    content_result = forms.button_filter('button', test_attributes, None, 'test_context', test_bind)
-    expected = 'test_bind_default'
+    content_result = forms.button_filter("button", test_attributes, None, "test_context", test_bind)
+    expected = "test_bind_default"
     assert content_result == expected
 
 
 def test_required_filter():
     test_bind.optional = False
-    test_attributes['class'] = 'test_class'
-    content_result = forms.required_filter('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    expected = 'new_content'
+    test_attributes["class"] = "test_class"
+    content_result = forms.required_filter("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    expected = "new_content"
     assert content_result == expected
     # fixing a class for the form element, restricts the HTML we can generate
     # attribute_result = test_attributes['class']
@@ -66,44 +67,44 @@ def test_required_filter():
     # assert attribute_result == expected
 
     # tagname == 'input'
-    content_result = forms.required_filter('input', test_attributes, 'new_content', 'test_context', test_bind)
-    expected = 'new_content'
+    content_result = forms.required_filter("input", test_attributes, "new_content", "test_context", test_bind)
+    expected = "new_content"
     assert content_result == expected
-    attribute_result = test_attributes['required']
-    expected = 'required'
+    attribute_result = test_attributes["required"]
+    expected = "required"
     assert attribute_result == expected
 
 
 def test_autofocus_filter():
-    test_bind.properties = {'autofocus': True}
-    content_result = forms.autofocus_filter('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    assert content_result == 'new_content'
-    attribute_result = test_attributes['autofocus']
-    assert attribute_result == 'autofocus'
+    test_bind.properties = {"autofocus": True}
+    content_result = forms.autofocus_filter("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    assert content_result == "new_content"
+    attribute_result = test_attributes["autofocus"]
+    assert attribute_result == "autofocus"
 
 
 def test_placeholder_filter():
-    test_bind.properties['placeholder'] = 'test_placeholder'
-    content_result = forms.placeholder_filter('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    assert content_result == 'new_content'
-    attribute_result = test_attributes['placeholder']
-    assert attribute_result == 'test_placeholder'
+    test_bind.properties["placeholder"] = "test_placeholder"
+    content_result = forms.placeholder_filter("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    assert content_result == "new_content"
+    attribute_result = test_attributes["placeholder"]
+    assert attribute_result == "test_placeholder"
 
 
 def test_error_filter_factory():
     # when 'class' not in test_attributes
-    test_bind.errors = 'test_errors'
-    test_attributes.pop('class')
-    test_fun_returned = forms.error_filter_factory('test_moin_error')
-    content_result = test_fun_returned('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    assert content_result == 'new_content'
-    attribute_result = test_attributes['class']
-    assert attribute_result == 'test_moin_error'
+    test_bind.errors = "test_errors"
+    test_attributes.pop("class")
+    test_fun_returned = forms.error_filter_factory("test_moin_error")
+    content_result = test_fun_returned("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    assert content_result == "new_content"
+    attribute_result = test_attributes["class"]
+    assert attribute_result == "test_moin_error"
 
     # class in test_attributes
-    test_attributes['class'] = 'test_attribute_class'
-    content_result = test_fun_returned('test_tagname', test_attributes, 'new_content', 'test_context', test_bind)
-    assert content_result == 'new_content'
-    attribute_result = test_attributes['class']
-    expected = 'test_attribute_class test_moin_error'
+    test_attributes["class"] = "test_attribute_class"
+    content_result = test_fun_returned("test_tagname", test_attributes, "new_content", "test_context", test_bind)
+    assert content_result == "new_content"
+    attribute_result = test_attributes["class"]
+    expected = "test_attribute_class test_moin_error"
     assert attribute_result == expected
diff --git a/src/moin/utils/_tests/test_interwiki.py b/src/moin/utils/_tests/test_interwiki.py
index fb411fb24..3cdd65ed4 100644
--- a/src/moin/utils/_tests/test_interwiki.py
+++ b/src/moin/utils/_tests/test_interwiki.py
@@ -26,90 +26,126 @@ class TestInterWiki:
     def cfg(self):
         class Config(wikiconfig.Config):
             interwiki_map = {
-                'Self': 'http://localhost:8080/',
-                'MoinMoin': 'http://moinmo.in/',
-                'OtherWiki': 'http://otherwiki.com/',
-                'OtherWiki/ns1': 'http://otherwiki.com/ns1/',
-                'OtherWiki/ns1/ns2': 'http://otherwiki.com/ns1/ns2/',
+                "Self": "http://localhost:8080/",
+                "MoinMoin": "http://moinmo.in/",
+                "OtherWiki": "http://otherwiki.com/",
+                "OtherWiki/ns1": "http://otherwiki.com/ns1/",
+                "OtherWiki/ns1/ns2": "http://otherwiki.com/ns1/ns2/",
             }
 
         return Config
 
     def test_url_for_item(self):
         before_wiki()
-        revid = 'cdc431e0fc624d6fb8372152dcb66457'
-
-        tests = [(('SomePage', '', '', '', CURRENT, 'frontend.show_item', False), '/SomePage'),
-                 # Method signature to understand the tuple parameters
-                 # (item_name, wiki_name='', namespace='', rev=CURRENT, endpoint='frontend.show_item', _external=False):
-                 (('SomePage', '', '', '', CURRENT, 'frontend.show_item', True), 'http://localhost:8080/SomePage'),
-                 (('SomePage', '', '', '', CURRENT, 'frontend.modify_item', False), '/+modify/SomePage'),
-                 # FIXME if you set interwiki_map = dict(Self='http://localhost:8080', MoinMoin='http://moinmo.in/', ),
-                 # the above line make it fails, it returns http://localhost/+modify/SomePage
-                 # (('SomePage', '', '', CURRENT, 'frontend.modify_item', True), 'http://localhost:8080/+modify/SomePage'),
-                 (('SomeRevID', '', 'revid', '', revid, 'frontend.show_item', False), f'/+show/+{revid}/@revid/SomeRevID'),
-                 (('SomePage', '', '', '', revid, 'frontend.show_item_meta', False), f'/+meta/+{revid}/SomePage'),
-                 # Valid namespaces
-                 (('SomePage', '', '', 'ns1', CURRENT, 'frontend.show_item', False), '/ns1/SomePage'),
-                 (('SomeTag', '', 'tags', 'ns1', CURRENT, 'frontend.show_item', False), '/ns1/@tags/SomeTag'),
-                 (('SomePage', '', '', 'ns1/ns2', CURRENT, 'frontend.show_item', True), 'http://localhost:8080/ns1/ns2/SomePage'),
-                 (('SomePage', '', '', 'ns1', CURRENT, 'frontend.modify_item', False), '/+modify/ns1/SomePage'),
-                 (('SomePage', '', '', 'ns1/ns2', CURRENT, 'frontend.show_item_meta', True), 'http://localhost:8080/+meta/ns1/ns2/SomePage'),
-                 (('SomePage', '', '', 'ns1', revid, 'frontend.show_item', False), f'/+show/+{revid}/ns1/SomePage'),
-                 (('SomePage', '', '', 'ns1/ns2', revid, 'frontend.show_item_meta', False), f'/+meta/+{revid}/ns1/ns2/SomePage'),
-                 (('SomeRevID', '', 'revid', 'ns1/ns2', CURRENT, 'frontend.show_item_meta', False), '/+meta/ns1/ns2/@revid/SomeRevID'),
-
-                 (('SomePage', 'MoinMoin', '', 'ns1', CURRENT, 'frontend.show_item', False), 'http://moinmo.in/ns1/SomePage'),
-                 (('SomePage', 'MoinMoin', '', '', CURRENT, 'frontend.show_item', False), 'http://moinmo.in/SomePage'),
-                 # FIXME will exist a map for this case? maybe there should be a placeholder for it.
-                 # we need that for wiki farms with common search index and search in non-current revisions.
-                 (('SomePage', 'MoinMoin', '', '', revid, 'frontend.show_item', False), f'http://moinmo.in/+show/+{revid}/SomePage'),
-                 (('SomeItemID', 'non-existent', 'itemid', '', CURRENT, 'frontend.show_item', False), '/non-existent/@itemid/SomeItemID'),
-                 (('SomePage', 'non-existent', '', 'ns1', CURRENT, 'frontend.show_item', False), '/non-existent/ns1/SomePage'),
-                 ]
+        revid = "cdc431e0fc624d6fb8372152dcb66457"
+
+        tests = [
+            (("SomePage", "", "", "", CURRENT, "frontend.show_item", False), "/SomePage"),
+            # Method signature to understand the tuple parameters
+            # (item_name, wiki_name='', namespace='', rev=CURRENT, endpoint='frontend.show_item', _external=False):
+            (("SomePage", "", "", "", CURRENT, "frontend.show_item", True), "http://localhost:8080/SomePage"),
+            (("SomePage", "", "", "", CURRENT, "frontend.modify_item", False), "/+modify/SomePage"),
+            # FIXME if you set interwiki_map = dict(Self='http://localhost:8080', MoinMoin='http://moinmo.in/', ),
+            # the above line make it fails, it returns http://localhost/+modify/SomePage
+            # (('SomePage', '', '', CURRENT, 'frontend.modify_item', True), 'http://localhost:8080/+modify/SomePage'),
+            (("SomeRevID", "", "revid", "", revid, "frontend.show_item", False), f"/+show/+{revid}/@revid/SomeRevID"),
+            (("SomePage", "", "", "", revid, "frontend.show_item_meta", False), f"/+meta/+{revid}/SomePage"),
+            # Valid namespaces
+            (("SomePage", "", "", "ns1", CURRENT, "frontend.show_item", False), "/ns1/SomePage"),
+            (("SomeTag", "", "tags", "ns1", CURRENT, "frontend.show_item", False), "/ns1/@tags/SomeTag"),
+            (
+                ("SomePage", "", "", "ns1/ns2", CURRENT, "frontend.show_item", True),
+                "http://localhost:8080/ns1/ns2/SomePage",
+            ),
+            (("SomePage", "", "", "ns1", CURRENT, "frontend.modify_item", False), "/+modify/ns1/SomePage"),
+            (
+                ("SomePage", "", "", "ns1/ns2", CURRENT, "frontend.show_item_meta", True),
+                "http://localhost:8080/+meta/ns1/ns2/SomePage",
+            ),
+            (("SomePage", "", "", "ns1", revid, "frontend.show_item", False), f"/+show/+{revid}/ns1/SomePage"),
+            (
+                ("SomePage", "", "", "ns1/ns2", revid, "frontend.show_item_meta", False),
+                f"/+meta/+{revid}/ns1/ns2/SomePage",
+            ),
+            (
+                ("SomeRevID", "", "revid", "ns1/ns2", CURRENT, "frontend.show_item_meta", False),
+                "/+meta/ns1/ns2/@revid/SomeRevID",
+            ),
+            (
+                ("SomePage", "MoinMoin", "", "ns1", CURRENT, "frontend.show_item", False),
+                "http://moinmo.in/ns1/SomePage",
+            ),
+            (("SomePage", "MoinMoin", "", "", CURRENT, "frontend.show_item", False), "http://moinmo.in/SomePage"),
+            # FIXME will exist a map for this case? maybe there should be a placeholder for it.
+            # we need that for wiki farms with common search index and search in non-current revisions.
+            (
+                ("SomePage", "MoinMoin", "", "", revid, "frontend.show_item", False),
+                f"http://moinmo.in/+show/+{revid}/SomePage",
+            ),
+            (
+                ("SomeItemID", "non-existent", "itemid", "", CURRENT, "frontend.show_item", False),
+                "/non-existent/@itemid/SomeItemID",
+            ),
+            (
+                ("SomePage", "non-existent", "", "ns1", CURRENT, "frontend.show_item", False),
+                "/non-existent/ns1/SomePage",
+            ),
+        ]
 
         for (item_name, wiki_name, field, namespace, rev, endpoint, _external), url in tests:
             # Workaround: substitute %40 with @ to allow both Werkzeug versions 2.2. and 2.3 TODO: remove later
-            assert re.sub('%40', '@', url_for_item(item_name, wiki_name, field, namespace, rev, endpoint, _external)) == url
+            assert (
+                re.sub("%40", "@", url_for_item(item_name, wiki_name, field, namespace, rev, endpoint, _external))
+                == url
+            )
 
     def test__split_namespace(self):
         map = set()
-        map.add('ns1')
-        map.add('ns1/ns2')
-        tests = [('', ('', '')),
-                 ('OtherWiki/', ('', 'OtherWiki/')),
-                 ('ns1/', ('ns1', '')),
-                 ('ns3/foo', ('', 'ns3/foo')),
-                 ('ns1/OtherPage', ('ns1', 'OtherPage')),
-                 ('ns1/ns2/OtherPage', ('ns1/ns2', 'OtherPage')),
-                 ('ns1/ns2/ns1/ns2/OtherPage', ('ns1/ns2', 'ns1/ns2/OtherPage')),
-                 ('SomePage', ('', 'SomePage')),
-                 ('OtherWiki/ns1/OtherPage', ('', 'OtherWiki/ns1/OtherPage')),
-                 ]
+        map.add("ns1")
+        map.add("ns1/ns2")
+        tests = [
+            ("", ("", "")),
+            ("OtherWiki/", ("", "OtherWiki/")),
+            ("ns1/", ("ns1", "")),
+            ("ns3/foo", ("", "ns3/foo")),
+            ("ns1/OtherPage", ("ns1", "OtherPage")),
+            ("ns1/ns2/OtherPage", ("ns1/ns2", "OtherPage")),
+            ("ns1/ns2/ns1/ns2/OtherPage", ("ns1/ns2", "ns1/ns2/OtherPage")),
+            ("SomePage", ("", "SomePage")),
+            ("OtherWiki/ns1/OtherPage", ("", "OtherWiki/ns1/OtherPage")),
+        ]
         for markup, (namespace, pagename) in tests:
             assert _split_namespace(map, markup) == (namespace, pagename)
             namespace, pagename = _split_namespace(map, markup)
 
     def test_split_interwiki(self):
-        app.cfg.namespace_mapping = [('', 'default_backend'), ('ns1/', 'default_backend'), ('ns1/ns2/', 'other_backend')]
-        tests = [('', ('Self', '', 'name_exact', '')),
-                 ('OtherWiki/', ('OtherWiki', '', 'name_exact', '')),
-                 ('/ns1/', ('Self', 'ns1', 'name_exact', '')),
-                 ('/@itemid/', ('Self', '', 'itemid', '')),
-                 ('/ns3/foo', ('Self', '', 'name_exact', 'ns3/foo')),
-                 ('@tags/SomeTag', ('Self', '', 'tags', 'SomeTag')),
-                 ('OtherWiki/OtherPage', ('OtherWiki', '', 'name_exact', 'OtherPage')),
-                 ('NonExistentWiki/OtherPage', ('Self', '', 'name_exact', 'NonExistentWiki/OtherPage')),
-                 ('OtherWiki/ns1/@invalidID/Page', ('OtherWiki', 'ns1', 'name_exact', '@invalidID/Page')),
-                 ('/ns1/OtherPage', ('Self', 'ns1', 'name_exact', 'OtherPage')),
-                 ('/ns1/ns2/OtherPage', ('Self', 'ns1/ns2', 'name_exact', 'OtherPage')),
-                 ('ns1/OtherPage', ('Self', 'ns1', 'name_exact', 'OtherPage')),
-                 ('ns1/ns2/OtherPage', ('Self', 'ns1/ns2', 'name_exact', 'OtherPage')),
-                 ('OtherWiki/ns1/OtherPage', ('OtherWiki', 'ns1', 'name_exact', 'OtherPage')),
-                 ('OtherWiki/ns1/ns2/OtherPage', ('OtherWiki', 'ns1/ns2', 'name_exact', 'OtherPage')),
-                 ('OtherWiki/ns1/ns2/@userid/SomeUserID', ('OtherWiki', 'ns1/ns2', 'userid', 'SomeUserID')),
-                 ('OtherWiki/ns3/ns2/@Notfield/OtherPage/foo', ('OtherWiki', '', 'name_exact', 'ns3/ns2/@Notfield/OtherPage/foo')),
-                 ]
+        app.cfg.namespace_mapping = [
+            ("", "default_backend"),
+            ("ns1/", "default_backend"),
+            ("ns1/ns2/", "other_backend"),
+        ]
+        tests = [
+            ("", ("Self", "", "name_exact", "")),
+            ("OtherWiki/", ("OtherWiki", "", "name_exact", "")),
+            ("/ns1/", ("Self", "ns1", "name_exact", "")),
+            ("/@itemid/", ("Self", "", "itemid", "")),
+            ("/ns3/foo", ("Self", "", "name_exact", "ns3/foo")),
+            ("@tags/SomeTag", ("Self", "", "tags", "SomeTag")),
+            ("OtherWiki/OtherPage", ("OtherWiki", "", "name_exact", "OtherPage")),
+            ("NonExistentWiki/OtherPage", ("Self", "", "name_exact", "NonExistentWiki/OtherPage")),
+            ("OtherWiki/ns1/@invalidID/Page", ("OtherWiki", "ns1", "name_exact", "@invalidID/Page")),
+            ("/ns1/OtherPage", ("Self", "ns1", "name_exact", "OtherPage")),
+            ("/ns1/ns2/OtherPage", ("Self", "ns1/ns2", "name_exact", "OtherPage")),
+            ("ns1/OtherPage", ("Self", "ns1", "name_exact", "OtherPage")),
+            ("ns1/ns2/OtherPage", ("Self", "ns1/ns2", "name_exact", "OtherPage")),
+            ("OtherWiki/ns1/OtherPage", ("OtherWiki", "ns1", "name_exact", "OtherPage")),
+            ("OtherWiki/ns1/ns2/OtherPage", ("OtherWiki", "ns1/ns2", "name_exact", "OtherPage")),
+            ("OtherWiki/ns1/ns2/@userid/SomeUserID", ("OtherWiki", "ns1/ns2", "userid", "SomeUserID")),
+            (
+                "OtherWiki/ns3/ns2/@Notfield/OtherPage/foo",
+                ("OtherWiki", "", "name_exact", "ns3/ns2/@Notfield/OtherPage/foo"),
+            ),
+        ]
         for markup, (wikiname, namespace, field, pagename) in tests:
             assert split_interwiki(markup) == (wikiname, namespace, field, pagename)
             wikiname, namespace, field, pagename = split_interwiki(markup)
@@ -119,31 +155,54 @@ def test_split_interwiki(self):
             assert isinstance(wikiname, str)
 
     def testJoinWiki(self):
-        tests = [(('http://example.org/', 'SomePage', '', ''), 'http://example.org/SomePage'),
-                 (('', 'SomePage', '', ''), 'SomePage'),
-                 (('http://example.org/?page=$PAGE&action=show', 'SomePage', '', ''), 'http://example.org/?page=SomePage&action=show'),
-                 (('http://example.org/', 'Aktuelle\xc4nderungen', '', ''), 'http://example.org/Aktuelle%C3%84nderungen'),
-                 (('http://example.org/$PAGE/show', 'Aktuelle\xc4nderungen', '', ''), 'http://example.org/Aktuelle%C3%84nderungen/show'),
-
-                 (('http://example.org/', 'SomeItemID', 'itemid', 'ns1'), 'http://example.org/ns1/@itemid/SomeItemID'),
-                 (('http://example.org/?page=$PAGE&action=show&namespace=$NAMESPACE', 'SomePage', '', 'ns1'), 'http://example.org/?page=SomePage&action=show&namespace=ns1'),
-                 (('http://example.org/', 'Aktuelle\xc4nderungen', '', 'ns1\xc4'), 'http://example.org/ns1%C3%84/Aktuelle%C3%84nderungen'),
-                 (('http://example.org/$NAMESPACE/$PAGE/show', 'Aktuelle\xc4nderungen', '', 'ns\xc41'), 'http://example.org/ns%C3%841/Aktuelle%C3%84nderungen/show'),
-                 (('http://example.org/@$FIELD/$PAGE/show', 'Aktuelle\xc4nderungen', 'itemid', ''), 'http://example.org/@itemid/Aktuelle%C3%84nderungen/show'),
-                 ]
+        tests = [
+            (("http://example.org/", "SomePage", "", ""), "http://example.org/SomePage"),
+            (("", "SomePage", "", ""), "SomePage"),
+            (
+                ("http://example.org/?page=$PAGE&action=show", "SomePage", "", ""),
+                "http://example.org/?page=SomePage&action=show",
+            ),
+            (("http://example.org/", "Aktuelle\xc4nderungen", "", ""), "http://example.org/Aktuelle%C3%84nderungen"),
+            (
+                ("http://example.org/$PAGE/show", "Aktuelle\xc4nderungen", "", ""),
+                "http://example.org/Aktuelle%C3%84nderungen/show",
+            ),
+            (("http://example.org/", "SomeItemID", "itemid", "ns1"), "http://example.org/ns1/@itemid/SomeItemID"),
+            (
+                ("http://example.org/?page=$PAGE&action=show&namespace=$NAMESPACE", "SomePage", "", "ns1"),
+                "http://example.org/?page=SomePage&action=show&namespace=ns1",
+            ),
+            (
+                ("http://example.org/", "Aktuelle\xc4nderungen", "", "ns1\xc4"),
+                "http://example.org/ns1%C3%84/Aktuelle%C3%84nderungen",
+            ),
+            (
+                ("http://example.org/$NAMESPACE/$PAGE/show", "Aktuelle\xc4nderungen", "", "ns\xc41"),
+                "http://example.org/ns%C3%841/Aktuelle%C3%84nderungen/show",
+            ),
+            (
+                ("http://example.org/@$FIELD/$PAGE/show", "Aktuelle\xc4nderungen", "itemid", ""),
+                "http://example.org/@itemid/Aktuelle%C3%84nderungen/show",
+            ),
+        ]
         for (baseurl, pagename, field, namespace), url in tests:
             assert join_wiki(baseurl, pagename, field, namespace) == url
 
     def test_split_fqname(self):
-        app.cfg.namespace_mapping = [('', 'default_backend'), ('ns1/', 'default_backend'), ('ns1/ns2/', 'other_backend')]
-        tests = [('ns1/ns2/@itemid/SomeItemID', ('ns1/ns2', 'itemid', 'SomeItemID')),
-                 ('ns3/@itemid/SomeItemID', ('', 'name_exact', 'ns3/@itemid/SomeItemID')),
-                 ('Page', ('', 'name_exact', 'Page')),
-                 ('ns1/ns2/@tags/SomeTag', ('ns1/ns2', 'tags', 'SomeTag')),
-                 ('@tags/SomeTag', ('', 'tags', 'SomeTag')),
-                 ('ns1/ns2/@notid', ('ns1/ns2', 'name_exact', '@notid')),
-                 ('ns1/ns2/ns3/Thisisapagename/ns4', ('ns1/ns2', 'name_exact', 'ns3/Thisisapagename/ns4')),
-                 ]
+        app.cfg.namespace_mapping = [
+            ("", "default_backend"),
+            ("ns1/", "default_backend"),
+            ("ns1/ns2/", "other_backend"),
+        ]
+        tests = [
+            ("ns1/ns2/@itemid/SomeItemID", ("ns1/ns2", "itemid", "SomeItemID")),
+            ("ns3/@itemid/SomeItemID", ("", "name_exact", "ns3/@itemid/SomeItemID")),
+            ("Page", ("", "name_exact", "Page")),
+            ("ns1/ns2/@tags/SomeTag", ("ns1/ns2", "tags", "SomeTag")),
+            ("@tags/SomeTag", ("", "tags", "SomeTag")),
+            ("ns1/ns2/@notid", ("ns1/ns2", "name_exact", "@notid")),
+            ("ns1/ns2/ns3/Thisisapagename/ns4", ("ns1/ns2", "name_exact", "ns3/Thisisapagename/ns4")),
+        ]
         for url, (namespace, field, pagename) in tests:
             assert split_fqname(url) == (namespace, field, pagename)
 
@@ -161,22 +220,19 @@ def test_load_file(self):
 
         # test an invalid file
         with pytest.raises(IOError):
-            InterWikiMap.from_file(os.path.join(tmpdir, 'void'))
+            InterWikiMap.from_file(os.path.join(tmpdir, "void"))
 
         # test a consistent valid file
-        testfile = os.path.join(tmpdir, 'foo.iwm')
-        with open(testfile, 'w') as f:
-            f.write('foo bar\n'
-                    'baz spam\n'
-                    'ham end end # this is really the end.')
+        testfile = os.path.join(tmpdir, "foo.iwm")
+        with open(testfile, "w") as f:
+            f.write("foo bar\n" "baz spam\n" "ham end end # this is really the end.")
         testiwm = InterWikiMap.from_file(testfile)
-        assert testiwm.iwmap == dict(foo='bar', baz='spam', ham='end end')
+        assert testiwm.iwmap == dict(foo="bar", baz="spam", ham="end end")
 
         # test a malformed file
-        testfile = os.path.join(tmpdir, 'bar.iwm')
-        with open(testfile, 'w') as f:
-            f.write('# This is a malformed interwiki file\n'
-                    'fails # ever')
+        testfile = os.path.join(tmpdir, "bar.iwm")
+        with open(testfile, "w") as f:
+            f.write("# This is a malformed interwiki file\n" "fails # ever")
         with pytest.raises(ValueError):
             InterWikiMap.from_file(testfile)
 
@@ -188,40 +244,39 @@ def test_load_string(self):
         Test that InterWikiMap.from_unicode correctly loads unicode objects.
         """
         # test for void wiki maps
-        assert InterWikiMap.from_string('').iwmap == dict()
-        assert InterWikiMap.from_string('#spam\r\n').iwmap == dict()
+        assert InterWikiMap.from_string("").iwmap == dict()
+        assert InterWikiMap.from_string("#spam\r\n").iwmap == dict()
         # test for comments
-        s = ('# foo bar\n'
-             '#spamham\r\n'
-             '#       space     space\n'
-             'foo bar\r\n'
-             'ham spam # this is a valid description')
-        assert InterWikiMap.from_string(s).iwmap == dict(foo='bar', ham='spam')
+        s = (
+            "# foo bar\n"
+            "#spamham\r\n"
+            "#       space     space\n"
+            "foo bar\r\n"
+            "ham spam # this is a valid description"
+        )
+        assert InterWikiMap.from_string(s).iwmap == dict(foo="bar", ham="spam")
         # test for valid strings
-        s = ('link1 http://link1.com/\r\n'
-             'link2 http://link2.in/\r\n')
-        assert (InterWikiMap.from_string(s).iwmap ==
-                dict(link1='http://link1.com/',
-                     link2='http://link2.in/'))
+        s = "link1 http://link1.com/\r\n" "link2 http://link2.in/\r\n"
+        assert InterWikiMap.from_string(s).iwmap == dict(link1="http://link1.com/", link2="http://link2.in/")
         # test invalid strings
         with pytest.raises(ValueError):
-            InterWikiMap.from_string('foobarbaz')
+            InterWikiMap.from_string("foobarbaz")
 
     def test_real_interwiki_map(self):
         """
         Test a 'real' interwiki file.
         """
         this_dir = os.path.dirname(__file__)
-        testfile = os.path.join(this_dir, 'test_interwiki_intermap.txt')
+        testfile = os.path.join(this_dir, "test_interwiki_intermap.txt")
         testiwm = InterWikiMap.from_file(testfile)
 
-        assert 'MoinMaster' in testiwm.iwmap
-        assert testiwm.iwmap['MoinMaster'] == 'https://master.moinmo.in/'
-        assert 'PythonInfo' in testiwm.iwmap
-        assert 'this' not in testiwm.iwmap
-        assert testiwm.iwmap['MoinMoin'] == 'https://moinmo.in/'
-        assert testiwm.iwmap['hg'] == 'https://www.mercurial-scm.org/wiki/'
-        assert testiwm.iwmap['h2g2'] == 'http://h2g2.com/dna/h2g2/'
+        assert "MoinMaster" in testiwm.iwmap
+        assert testiwm.iwmap["MoinMaster"] == "https://master.moinmo.in/"
+        assert "PythonInfo" in testiwm.iwmap
+        assert "this" not in testiwm.iwmap
+        assert testiwm.iwmap["MoinMoin"] == "https://moinmo.in/"
+        assert testiwm.iwmap["hg"] == "https://www.mercurial-scm.org/wiki/"
+        assert testiwm.iwmap["h2g2"] == "http://h2g2.com/dna/h2g2/"
 
 
-coverage_modules = ['moin.utils.interwiki']
+coverage_modules = ["moin.utils.interwiki"]
diff --git a/src/moin/utils/_tests/test_iri.py b/src/moin/utils/_tests/test_iri.py
index 31080b318..17c61e08b 100644
--- a/src/moin/utils/_tests/test_iri.py
+++ b/src/moin/utils/_tests/test_iri.py
@@ -10,423 +10,422 @@
 
 
 def test_Iri_init_1():
-    u = Iri(scheme='wiki', path='/StartSeite', query='action=raw')
-    assert u.scheme == 'wiki'
+    u = Iri(scheme="wiki", path="/StartSeite", query="action=raw")
+    assert u.scheme == "wiki"
     assert u.authority is None
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
     assert u.fragment is None
 
 
 def test_Iri_init_2():
-    i = 'wiki://MoinMoin/StartSeite?action=raw#body'
-    u = Iri(i, scheme='newwiki', path='/newStartSeite', query='action=false')
-    assert u.scheme == 'newwiki'
-    assert u.authority == 'MoinMoin'
-    assert u.path == '/newStartSeite'
-    assert u.query == 'action=false'
-    assert u.fragment == 'body'
+    i = "wiki://MoinMoin/StartSeite?action=raw#body"
+    u = Iri(i, scheme="newwiki", path="/newStartSeite", query="action=false")
+    assert u.scheme == "newwiki"
+    assert u.authority == "MoinMoin"
+    assert u.path == "/newStartSeite"
+    assert u.query == "action=false"
+    assert u.fragment == "body"
 
 
 def test_Iri_init_3():
-    i = Iri(scheme='wiki', path='/StartSeite', query='action=raw')
+    i = Iri(scheme="wiki", path="/StartSeite", query="action=raw")
     u = Iri(i)
     assert i is not u
     assert i == u
 
 
 def test_Iri_parser():
-    i = 'http://moinmo.in/StartSeite?action=raw#body'
+    i = "http://moinmo.in/StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http://moinmo.in/StartSeite?action=raw'
+    i = "http://moinmo.in/StartSeite?action=raw"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http://moinmo.in/StartSeite'
+    i = "http://moinmo.in/StartSeite"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/StartSeite'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/StartSeite"
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http://moinmo.in'
+    i = "http://moinmo.in"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
     assert u.path is None
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http:///StartSeite?action=raw#body'
+    i = "http:///StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == ''
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.scheme == "http"
+    assert u.authority == ""
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http:///StartSeite?action=raw'
+    i = "http:///StartSeite?action=raw"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == ''
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
+    assert u.scheme == "http"
+    assert u.authority == ""
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http:///StartSeite'
+    i = "http:///StartSeite"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == ''
-    assert u.path == '/StartSeite'
+    assert u.scheme == "http"
+    assert u.authority == ""
+    assert u.path == "/StartSeite"
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http:///'
+    i = "http:///"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == ''
-    assert u.path == '/'
+    assert u.scheme == "http"
+    assert u.authority == ""
+    assert u.path == "/"
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http://'
+    i = "http://"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == ''
+    assert u.scheme == "http"
+    assert u.authority == ""
     assert u.path is None
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http:'
+    i = "http:"
     u = Iri(i)
-    assert u.scheme == 'http'
+    assert u.scheme == "http"
     assert u.authority is None
     assert u.path is None
     assert u.query is None
     assert u.fragment is None
     assert str(u) == i
 
-    i = 'http://moinmo.in/StartSeite#body'
+    i = "http://moinmo.in/StartSeite#body"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/StartSeite'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/StartSeite"
     assert u.query is None
-    assert u.fragment == 'body'
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http://moinmo.in#body'
+    i = "http://moinmo.in#body"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
     assert u.path is None
     assert u.query is None
-    assert u.fragment == 'body'
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http:#body'
+    i = "http:#body"
     u = Iri(i)
-    assert u.scheme == 'http'
+    assert u.scheme == "http"
     assert u.authority is None
     assert u.path is None
     assert u.query is None
-    assert u.fragment == 'body'
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http://moinmo.in?action=raw#body'
+    i = "http://moinmo.in?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'http'
-    assert u.authority == 'moinmo.in'
+    assert u.scheme == "http"
+    assert u.authority == "moinmo.in"
     assert u.path is None
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http:?action=raw#body'
+    i = "http:?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'http'
+    assert u.scheme == "http"
     assert u.authority is None
     assert u.path is None
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'http:/StartSeite?action=raw#body'
+    i = "http:/StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'http'
+    assert u.scheme == "http"
     assert u.authority is None
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
 
 def test_Iri_2():
-    i = 'wiki://MoinMoin/StartSeite?action=raw#body'
+    i = "wiki://MoinMoin/StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'wiki'
-    assert u.authority == 'MoinMoin'
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.scheme == "wiki"
+    assert u.authority == "MoinMoin"
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
-    i = 'wiki:///StartSeite?action=raw#body'
+    i = "wiki:///StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'wiki'
-    assert u.authority == ''
-    assert u.path == '/StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.scheme == "wiki"
+    assert u.authority == ""
+    assert u.path == "/StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
 
 def test_Iri_3():
-    i = 'wiki.local:StartSeite?action=raw#body'
+    i = "wiki.local:StartSeite?action=raw#body"
     u = Iri(i)
-    assert u.scheme == 'wiki.local'
+    assert u.scheme == "wiki.local"
     assert u.authority is None
-    assert u.path == 'StartSeite'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'body'
+    assert u.path == "StartSeite"
+    assert u.query == "action=raw"
+    assert u.fragment == "body"
     assert str(u) == i
 
 
 def test_Iri_add_1():
-    base = Iri('wiki://moinmo.in/Some/Page?action=raw#body')
+    base = Iri("wiki://moinmo.in/Some/Page?action=raw#body")
 
-    u = base + Iri('http://thinkmo.de/')
-    assert u.scheme == 'http'
-    assert u.authority == 'thinkmo.de'
-    assert u.path == '/'
+    u = base + Iri("http://thinkmo.de/")
+    assert u.scheme == "http"
+    assert u.authority == "thinkmo.de"
+    assert u.path == "/"
     assert u.query is None
     assert u.fragment is None
 
-    u = base + Iri('//thinkmo.de/')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'thinkmo.de'
-    assert u.path == '/'
+    u = base + Iri("//thinkmo.de/")
+    assert u.scheme == "wiki"
+    assert u.authority == "thinkmo.de"
+    assert u.path == "/"
     assert u.query is None
     assert u.fragment is None
 
-    u = base + Iri('/')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/'
+    u = base + Iri("/")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/"
     assert u.query is None
     assert u.fragment is None
 
-    u = base + Iri('/?action=edit')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/'
-    assert u.query == 'action=edit'
+    u = base + Iri("/?action=edit")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/"
+    assert u.query == "action=edit"
     assert u.fragment is None
 
-    u = base + Iri('')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/Some/Page'
-    assert u.query == 'action=raw'
+    u = base + Iri("")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/Some/Page"
+    assert u.query == "action=raw"
     assert u.fragment is None
 
-    u = base + Iri('.')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/Some/'
+    u = base + Iri(".")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/Some/"
     assert u.query is None
     assert u.fragment is None
 
-    u = base + Iri('..')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/'
+    u = base + Iri("..")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/"
     assert u.query is None
     assert u.fragment is None
 
-    u = base + Iri('?action=edit')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/Some/Page'
-    assert u.query == 'action=edit'
+    u = base + Iri("?action=edit")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/Some/Page"
+    assert u.query == "action=edit"
     assert u.fragment is None
 
-    u = base + Iri('#head')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'moinmo.in'
-    assert u.path == '/Some/Page'
-    assert u.query == 'action=raw'
-    assert u.fragment == 'head'
+    u = base + Iri("#head")
+    assert u.scheme == "wiki"
+    assert u.authority == "moinmo.in"
+    assert u.path == "/Some/Page"
+    assert u.query == "action=raw"
+    assert u.fragment == "head"
 
 
 def test_Iri_quote_1():
-    u = Iri(scheme='wiki', authority='authority_ä%?#',
-            path='/path_ä%?#', query='query_ä%?#', fragment='fragment_ä%?#')
-    assert u.scheme == 'wiki'
-    assert u.authority == 'authority_ä%?#'
-    authority = 'authority_ä%25%3F%23'
+    u = Iri(scheme="wiki", authority="authority_ä%?#", path="/path_ä%?#", query="query_ä%?#", fragment="fragment_ä%?#")
+    assert u.scheme == "wiki"
+    assert u.authority == "authority_ä%?#"
+    authority = "authority_ä%25%3F%23"
     assert u.authority.fullquoted == authority
-    assert u.authority.quoted == 'authority_ä%25?#'
-    assert u.authority.urlquoted == 'authority_%C3%A4%25%3F%23'
-    assert u.path == '/path_ä%?#'
-    path = '/path_ä%25%3F%23'
+    assert u.authority.quoted == "authority_ä%25?#"
+    assert u.authority.urlquoted == "authority_%C3%A4%25%3F%23"
+    assert u.path == "/path_ä%?#"
+    path = "/path_ä%25%3F%23"
     assert u.path.fullquoted == path
-    assert u.path.quoted == '/path_ä%25?#'
-    assert u.path.urlquoted == '/path_%C3%A4%25%3F%23'
-    assert u.query == 'query_ä%?#'
-    query = 'query_ä%25?%23'
+    assert u.path.quoted == "/path_ä%25?#"
+    assert u.path.urlquoted == "/path_%C3%A4%25%3F%23"
+    assert u.query == "query_ä%?#"
+    query = "query_ä%25?%23"
     assert u.query.fullquoted == query
-    assert u.query.quoted == 'query_ä%25?#'
-    assert u.query.urlquoted == 'query_%C3%A4%25?%23'
-    assert u.fragment == 'fragment_ä%?#'
-    fragment = 'fragment_ä%25?%23'
+    assert u.query.quoted == "query_ä%25?#"
+    assert u.query.urlquoted == "query_%C3%A4%25?%23"
+    assert u.fragment == "fragment_ä%?#"
+    fragment = "fragment_ä%25?%23"
     assert u.fragment.fullquoted == fragment
-    assert u.fragment.quoted == 'fragment_ä%25?#'
-    assert u.fragment.urlquoted == 'fragment_%C3%A4%25?%23'
-    assert str(u) == f'wiki://{authority}{path}?{query}#{fragment}'
+    assert u.fragment.quoted == "fragment_ä%25?#"
+    assert u.fragment.urlquoted == "fragment_%C3%A4%25?%23"
+    assert str(u) == f"wiki://{authority}{path}?{query}#{fragment}"
 
 
 def test_Iri_quote_2():
-    authority = 'authority_ä%25%3F%23'
-    path = '/path_ä%25%3F%23'
-    query = 'query_ä%25?%23'
-    fragment = 'fragment_ä%25?%23'
-    i = f'wiki://{authority}{path}?{query}#{fragment}'
+    authority = "authority_ä%25%3F%23"
+    path = "/path_ä%25%3F%23"
+    query = "query_ä%25?%23"
+    fragment = "fragment_ä%25?%23"
+    i = f"wiki://{authority}{path}?{query}#{fragment}"
     u = Iri(i)
     assert str(u) == i
 
 
 def test_Iri_quote_3():
-    i = 'wiki:///path_%92%92'
+    i = "wiki:///path_%92%92"
     u = Iri(i)
-    assert u.path.fullquoted == '/path_%92%92'
-    assert u.path.quoted == '/path_%92%92'
+    assert u.path.fullquoted == "/path_%92%92"
+    assert u.path.quoted == "/path_%92%92"
     assert str(u) == i
 
 
 def test_IriAuthority_parser_1():
-    i = 'moinmo.in'
+    i = "moinmo.in"
     u = IriAuthority(i)
     assert u.userinfo is None
-    assert u.host == 'moinmo.in'
+    assert u.host == "moinmo.in"
     assert u.port is None
     assert str(u) == i
 
 
 def test_IriAuthority_parser_2():
-    i = '@moinmo.in:'
+    i = "@moinmo.in:"
     u = IriAuthority(i)
-    assert u.userinfo == ''
-    assert u.host == 'moinmo.in'
+    assert u.userinfo == ""
+    assert u.host == "moinmo.in"
     assert u.port == 0
     assert str(u) == i
 
 
 def test_IriAuthority_parser_3():
-    i = 'test:test@moinmo.in:1234'
+    i = "test:test@moinmo.in:1234"
     u = IriAuthority(i)
-    assert u.userinfo == 'test:test'
-    assert u.host == 'moinmo.in'
+    assert u.userinfo == "test:test"
+    assert u.host == "moinmo.in"
     assert u.port == 1234
     assert str(u) == i
 
 
 def test_IriPath_1():
-    i = '/'
+    i = "/"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
+    assert u[0] == ""
+    assert u[1] == ""
     assert str(u) == i
 
 
 def test_IriPath_2():
-    i = '/.'
+    i = "/."
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
-    i = '/./'
+    i = "/./"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
 
 def test_IriPath_3():
-    i = '/..'
+    i = "/.."
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
-    i = '/../'
+    i = "/../"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
 
 def test_IriPath_4():
-    i = '/test'
+    i = "/test"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == 'test'
+    assert u[0] == ""
+    assert u[1] == "test"
     assert str(u) == i
 
-    i = '/test/'
+    i = "/test/"
     u = IriPath(i)
     assert len(u) == 3
-    assert u[0] == ''
-    assert u[1] == 'test'
-    assert u[2] == ''
+    assert u[0] == ""
+    assert u[1] == "test"
+    assert u[2] == ""
     assert str(u) == i
 
-    i = '/test/..'
+    i = "/test/.."
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
-    i = '/test/../'
+    i = "/test/../"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == ''
-    assert str(u) == '/'
+    assert u[0] == ""
+    assert u[1] == ""
+    assert str(u) == "/"
 
 
 def test_IriPath_5():
-    i = '/test/test1/../../test2'
+    i = "/test/test1/../../test2"
     u = IriPath(i)
     assert len(u) == 2
-    assert u[0] == ''
-    assert u[1] == 'test2'
-    assert str(u) == '/test2'
+    assert u[0] == ""
+    assert u[1] == "test2"
+    assert str(u) == "/test2"
diff --git a/src/moin/utils/_tests/test_mime.py b/src/moin/utils/_tests/test_mime.py
index 697c05381..4675effeb 100644
--- a/src/moin/utils/_tests/test_mime.py
+++ b/src/moin/utils/_tests/test_mime.py
@@ -10,22 +10,22 @@
 
 
 def test_Type_init_1():
-    t = Type(type='foo', subtype='bar', parameters={'foo': 'bar'})
-    assert t.type == 'foo'
-    assert t.subtype == 'bar'
-    assert t.parameters == {'foo': 'bar'}
+    t = Type(type="foo", subtype="bar", parameters={"foo": "bar"})
+    assert t.type == "foo"
+    assert t.subtype == "bar"
+    assert t.parameters == {"foo": "bar"}
 
 
 def test_Type_init_2():
-    i = 'text/plain;encoding=utf-8'
-    t = Type(i, type='foo', subtype='bar', parameters={'foo': 'bar'})
-    assert t.type == 'foo'
-    assert t.subtype == 'bar'
-    assert t.parameters == {'encoding': 'utf-8', 'foo': 'bar'}
+    i = "text/plain;encoding=utf-8"
+    t = Type(i, type="foo", subtype="bar", parameters={"foo": "bar"})
+    assert t.type == "foo"
+    assert t.subtype == "bar"
+    assert t.parameters == {"encoding": "utf-8", "foo": "bar"}
 
 
 def test_Type_init_3():
-    i = Type(type='foo', subtype='bar')
+    i = Type(type="foo", subtype="bar")
     t = Type(i)
     assert i is not t
     assert i == t
@@ -33,62 +33,62 @@ def test_Type_init_3():
 
 
 def test_Type_text():
-    i = '*/*'
+    i = "*/*"
     t = Type(i)
-    assert t.type == ''
-    assert t.subtype == ''
+    assert t.type == ""
+    assert t.subtype == ""
     assert t.parameters == {}
     assert str(t) == i
 
-    i = 'text/*'
+    i = "text/*"
     t = Type(i)
-    assert t.type == 'text'
-    assert t.subtype == ''
+    assert t.type == "text"
+    assert t.subtype == ""
     assert t.parameters == {}
     assert str(t) == i
 
-    i = 'text/plain'
+    i = "text/plain"
     t = Type(i)
-    assert t.type == 'text'
-    assert t.subtype == 'plain'
+    assert t.type == "text"
+    assert t.subtype == "plain"
     assert t.parameters == {}
     assert str(t) == i
 
-    i = 'text/plain;encoding=utf-8;foo=bar'
+    i = "text/plain;encoding=utf-8;foo=bar"
     t = Type(i)
-    assert t.type == 'text'
-    assert t.subtype == 'plain'
-    assert t.parameters == {'encoding': 'utf-8', 'foo': 'bar'}
+    assert t.type == "text"
+    assert t.subtype == "plain"
+    assert t.parameters == {"encoding": "utf-8", "foo": "bar"}
     assert str(t) == i
 
     i = 'text/plain;encoding=utf-8;foo="["'
     t = Type(i)
-    assert t.parameters == {'encoding': 'utf-8', 'foo': '['}
+    assert t.parameters == {"encoding": "utf-8", "foo": "["}
     assert str(t) == i
 
 
 def test_Type_compare():
-    t1 = Type(type='text', subtype='plain')
+    t1 = Type(type="text", subtype="plain")
 
     assert t1 == t1
     assert t1.issupertype(t1)
 
-    t2 = Type(type='text')
+    t2 = Type(type="text")
     assert t1 != t2
     assert t2.issupertype(t1)
     assert not t1.issupertype(t2)
 
-    t2 = Type(type='text', subtype='plain', parameters={'encoding': 'iso8859-1'})
+    t2 = Type(type="text", subtype="plain", parameters={"encoding": "iso8859-1"})
     assert t1 != t2
     assert t1.issupertype(t2)
     assert not t2.issupertype(t1)
 
-    t3 = Type(type='text', subtype='plain', parameters={'encoding': 'utf-8'})
+    t3 = Type(type="text", subtype="plain", parameters={"encoding": "utf-8"})
     assert t2 != t3
     assert not t2.issupertype(t3)
     assert not t3.issupertype(t2)
 
-    t2 = Type(type='text', subtype='html')
+    t2 = Type(type="text", subtype="html")
     assert t1 != t2
     assert not t1.issupertype(t2)
     assert not t2.issupertype(t1)
diff --git a/src/moin/utils/_tests/test_mimetype.py b/src/moin/utils/_tests/test_mimetype.py
index 125d62aca..474525892 100644
--- a/src/moin/utils/_tests/test_mimetype.py
+++ b/src/moin/utils/_tests/test_mimetype.py
@@ -10,17 +10,17 @@
 
 
 class TestMimeType:
-    """ Test: utils.mimetype """
+    """Test: utils.mimetype"""
 
     def test_parse_format(self):
-        MimeType_obj = mimetype.MimeType(filename='test_file.jpg')
+        MimeType_obj = mimetype.MimeType(filename="test_file.jpg")
         # format in PARSER_TEXT_MIMETYPE
         test = [
             # test_format, test_mimetype
-            ('html', ('text', 'html')),
-            ('css', ('text', 'css')),
-            ('python', ('text', 'python')),
-            ('latex', ('text', 'latex')),
+            ("html", ("text", "html")),
+            ("css", ("text", "css")),
+            ("python", ("text", "python")),
+            ("latex", ("text", "latex")),
         ]
 
         for test_format, test_mimetype in test:
@@ -30,9 +30,9 @@ def test_parse_format(self):
         # format not in PARSER_TEXT_MIMETYPE
         test = [
             # test_format, test_mimetype
-            ('wiki', ('text', 'x.moin.wiki')),
-            ('irc', ('text', 'irssi')),
-            ('test_random', ('text', 'x-test_random')),
+            ("wiki", ("text", "x.moin.wiki")),
+            ("irc", ("text", "irssi")),
+            ("test_random", ("text", "x-test_random")),
         ]
 
         for test_format, test_mimetype in test:
@@ -42,40 +42,40 @@ def test_parse_format(self):
     def test_mime_type(self):
         test = [
             # test_extension, test_major/minor
-            ('.mpeg', 'video/mpeg'),
-            ('.pdf', 'application/pdf'),
-            ('.txt', 'text/plain'),
-            ('.jpeg', 'image/jpeg'),
-            ('.png', 'image/png'),
-            ('.svg', 'image/svg+xml'),
-            ('', 'application/octet-stream'),
+            (".mpeg", "video/mpeg"),
+            (".pdf", "application/pdf"),
+            (".txt", "text/plain"),
+            (".jpeg", "image/jpeg"),
+            (".png", "image/png"),
+            (".svg", "image/svg+xml"),
+            ("", "application/octet-stream"),
         ]
 
         # when mimestr is None
         for test_extension, test_major_minor in test:
-            MimeType_obj = mimetype.MimeType(filename='test_file' + test_extension)
+            MimeType_obj = mimetype.MimeType(filename="test_file" + test_extension)
             result = MimeType_obj.mime_type()
             expected = test_major_minor
             assert result == expected
 
         # when mimestr is not None
-        MimeType_obj = mimetype.MimeType(filename='test_file', mimestr='image/jpeg;charset="utf-8";misc=moin_misc')
+        MimeType_obj = mimetype.MimeType(filename="test_file", mimestr='image/jpeg;charset="utf-8";misc=moin_misc')
         result = MimeType_obj.mime_type()
-        assert result == 'image/jpeg'
+        assert result == "image/jpeg"
 
     def test_content_type(self):
-        MimeType_obj = mimetype.MimeType('test_file.mpeg')
+        MimeType_obj = mimetype.MimeType("test_file.mpeg")
 
-        result1 = MimeType_obj.content_type(major='application', minor='pdf', charset="utf-16", params=None)
-        expected = 'application/pdf'
+        result1 = MimeType_obj.content_type(major="application", minor="pdf", charset="utf-16", params=None)
+        expected = "application/pdf"
         assert result1 == expected
 
         # major == 'text'
-        result2 = MimeType_obj.content_type(major='text', minor='plain', charset="utf-16", params=None)
+        result2 = MimeType_obj.content_type(major="text", minor="plain", charset="utf-16", params=None)
         expected = 'text/plain;charset="utf-16"'
         assert result2 == expected
 
         # when all the parameters passed are None
         result3 = MimeType_obj.content_type()
-        expected = 'text/x-test_file.mpeg'
+        expected = "text/x-test_file.mpeg"
         assert result3 == expected
diff --git a/src/moin/utils/_tests/test_notifications.py b/src/moin/utils/_tests/test_notifications.py
index e08a5a97a..747497050 100644
--- a/src/moin/utils/_tests/test_notifications.py
+++ b/src/moin/utils/_tests/test_notifications.py
@@ -31,44 +31,50 @@ def custom_setup(self):
 
     def test_get_content_diff(self):
         item = self.imw[self.item_name]
-        rev1 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain;charset=utf-8'),
-                                   BytesIO(b'x'), trusted=True, return_rev=True)
+        rev1 = item.store_revision(
+            dict(name=[self.item_name], contenttype="text/plain;charset=utf-8"),
+            BytesIO(b"x"),
+            trusted=True,
+            return_rev=True,
+        )
         notification = Notification(app, self.fqname, ACTION_SAVE, None, None, rev1.data, rev1.meta)
         assert notification.get_content_diff() == ["+ x"]
         rev1.data.seek(0, 0)
 
-        rev2 = item.store_revision(dict(name=[self.item_name, ], contenttype='text/plain;charset=utf-8'),
-                                   BytesIO(b'xx'), trusted=True, return_rev=True)
-        notification = Notification(app, self.fqname, ACTION_SAVE, rev1.data, rev1.meta, rev2.data, rev2.meta,)
-        assert notification.get_content_diff() == ['- x', '+ xx']
+        rev2 = item.store_revision(
+            dict(name=[self.item_name], contenttype="text/plain;charset=utf-8"),
+            BytesIO(b"xx"),
+            trusted=True,
+            return_rev=True,
+        )
+        notification = Notification(app, self.fqname, ACTION_SAVE, rev1.data, rev1.meta, rev2.data, rev2.meta)
+        assert notification.get_content_diff() == ["- x", "+ xx"]
         rev2.data.seek(0, 0)
 
         notification = Notification(app, self.fqname, ACTION_TRASH, rev2.data, rev2.meta, None, None)
-        assert notification.get_content_diff() == ['- xx']
+        assert notification.get_content_diff() == ["- xx"]
         rev2.data.seek(0, 0)
 
         item = Item.create(self.item_name)
         notification = Notification(app, self.fqname, DESTROY_REV, rev2.data, rev2.meta, None, None)
-        assert notification.get_content_diff() == ['- xx']
+        assert notification.get_content_diff() == ["- xx"]
         rev2.data.seek(0, 0)
 
         item = Item.create(self.item_name)
         notification = Notification(app, self.fqname, DESTROY_ALL, rev2.data, rev2.meta, None, None)
-        assert notification.get_content_diff() == ['- xx']
+        assert notification.get_content_diff() == ["- xx"]
 
     def test_get_meta_diff(self):
         item = self.imw[self.item_name]
-        rev1 = item.store_revision(dict(name=[self.item_name, ]), BytesIO(b'x'),
-                                   trusted=True, return_rev=True)
+        rev1 = item.store_revision(dict(name=[self.item_name]), BytesIO(b"x"), trusted=True, return_rev=True)
         notification = Notification(app, self.fqname, ACTION_SAVE, None, None, rev1.data, rev1.meta)
         assert notification.get_meta_diff() == dict_diff(dict(), rev1.meta._meta)
 
-        rev2 = item.store_revision(dict(name=[self.item_name, ]), BytesIO(b'xx'),
-                                   trusted=True, return_rev=True)
+        rev2 = item.store_revision(dict(name=[self.item_name]), BytesIO(b"xx"), trusted=True, return_rev=True)
         notification = Notification(app, self.fqname, ACTION_SAVE, rev1.data, rev1.meta, rev2.data, rev2.meta)
         assert notification.get_meta_diff() == dict_diff(rev1.meta._meta, rev2.meta._meta)
 
-        actions = [DESTROY_REV, DESTROY_ALL, ACTION_TRASH, ]
+        actions = [DESTROY_REV, DESTROY_ALL, ACTION_TRASH]
         for action in actions:
             notification = Notification(app, self.fqname, action, rev2.data, rev2.meta, rev1.data, rev1.meta)
             assert notification.get_meta_diff() == dict_diff(rev2.meta._meta, dict())
@@ -79,14 +85,12 @@ def test_generate_diff_url(self):
         assert notification.generate_diff_url(domain) == ""
 
         item = self.imw[self.item_name]
-        rev1 = item.store_revision(dict(name=[self.item_name, ]), BytesIO(b'x'),
-                                   trusted=True, return_rev=True)
+        rev1 = item.store_revision(dict(name=[self.item_name]), BytesIO(b"x"), trusted=True, return_rev=True)
         notification = Notification(app, self.fqname, DESTROY_REV, rev1.data, rev1.meta, None, None)
         assert notification.generate_diff_url(domain) == ""
 
-        rev2 = item.store_revision(dict(name=[self.item_name, ]), BytesIO(b'xx'),
-                                   trusted=True, return_rev=True)
+        rev2 = item.store_revision(dict(name=[self.item_name]), BytesIO(b"xx"), trusted=True, return_rev=True)
         notification = Notification(app, self.fqname, DESTROY_REV, rev1.data, rev1.meta, rev2.data, rev2.meta)
         assert notification.generate_diff_url(domain) == "{}{}".format(
-            domain, url_for('frontend.diff', item_name=self.item_name,
-                            rev1=rev1.revid, rev2=rev2.revid))
+            domain, url_for("frontend.diff", item_name=self.item_name, rev1=rev1.revid, rev2=rev2.revid)
+        )
diff --git a/src/moin/utils/_tests/test_paramparser.py b/src/moin/utils/_tests/test_paramparser.py
index 7553a1eb6..883a3b4da 100644
--- a/src/moin/utils/_tests/test_paramparser.py
+++ b/src/moin/utils/_tests/test_paramparser.py
@@ -13,44 +13,44 @@
 
 class TestParamParsing:
     def testMacroArgs(self):
-        abcd = ['a', 'b', 'c', 'd']
-        abcd_dict = {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
+        abcd = ["a", "b", "c", "d"]
+        abcd_dict = {"a": "1", "b": "2", "c": "3", "d": "4"}
         tests = [
             # regular and quoting tests
-            ('d = 4,c=3,b=2,a= 1 ', ([], abcd_dict, [])),
-            ('a,b,c,d', (abcd, {}, [])),
-            (' a , b , c , d ', (abcd, {}, [])),
-            ('   a   ', (['a'], {}, [])),
-            ('"  a  "', (['  a  '], {}, [])),
-            ('a,b,c,d, "a,b,c,d"', (abcd + ['a,b,c,d'], {}, [])),
-            ('quote " :), b', (['quote " :)', 'b'], {}, [])),
-            ('"quote "" :)", b', (['quote " :)', 'b'], {}, [])),
-            ('=7', ([], {'': '7'}, [])),
-            (',,', ([None, None, None], {}, [])),
-            (',"",', ([None, '', None], {}, [])),
-            (',"", ""', ([None, '', ''], {}, [])),
-            ('  ""  ,"", ""', (['', '', ''], {}, [])),
+            ("d = 4,c=3,b=2,a= 1 ", ([], abcd_dict, [])),
+            ("a,b,c,d", (abcd, {}, [])),
+            (" a , b , c , d ", (abcd, {}, [])),
+            ("   a   ", (["a"], {}, [])),
+            ('"  a  "', (["  a  "], {}, [])),
+            ('a,b,c,d, "a,b,c,d"', (abcd + ["a,b,c,d"], {}, [])),
+            ('quote " :), b', (['quote " :)', "b"], {}, [])),
+            ('"quote "" :)", b', (['quote " :)', "b"], {}, [])),
+            ("=7", ([], {"": "7"}, [])),
+            (",,", ([None, None, None], {}, [])),
+            (',"",', ([None, "", None], {}, [])),
+            (',"", ""', ([None, "", ""], {}, [])),
+            ('  ""  ,"", ""', (["", "", ""], {}, [])),
             # some name=value test
-            ('d = 4,c=3,b=2,a= 1 ', ([], abcd_dict, [])),
-            ('d=d,e="a,b,c,d"', ([], {'d': 'd', 'e': 'a,b,c,d'}, [])),
-            ('d = d,e = "a,b,c,d"', ([], {'d': 'd', 'e': 'a,b,c,d'}, [])),
-            ('d = d, e = "a,b,c,d"', ([], {'d': 'd', 'e': 'a,b,c,d'}, [])),
-            ('d = , e = "a,b,c,d"', ([], {'d': None, 'e': 'a,b,c,d'}, [])),
-            ('d = "", e = "a,b,c,d"', ([], {'d': '', 'e': 'a,b,c,d'}, [])),
-            ('d = "", e = ', ([], {'d': '', 'e': None}, [])),
-            ('d=""', ([], {'d': ''}, [])),
-            ('d = "", e = ""', ([], {'d': '', 'e': ''}, [])),
+            ("d = 4,c=3,b=2,a= 1 ", ([], abcd_dict, [])),
+            ('d=d,e="a,b,c,d"', ([], {"d": "d", "e": "a,b,c,d"}, [])),
+            ('d = d,e = "a,b,c,d"', ([], {"d": "d", "e": "a,b,c,d"}, [])),
+            ('d = d, e = "a,b,c,d"', ([], {"d": "d", "e": "a,b,c,d"}, [])),
+            ('d = , e = "a,b,c,d"', ([], {"d": None, "e": "a,b,c,d"}, [])),
+            ('d = "", e = "a,b,c,d"', ([], {"d": "", "e": "a,b,c,d"}, [])),
+            ('d = "", e = ', ([], {"d": "", "e": None}, [])),
+            ('d=""', ([], {"d": ""}, [])),
+            ('d = "", e = ""', ([], {"d": "", "e": ""}, [])),
             # no, None as key isn't accepted
-            (' = "",  e = ""', ([], {'': '', 'e': ''}, [])),
+            (' = "",  e = ""', ([], {"": "", "e": ""}, [])),
             # can quote both name and value:
-            ('d = d," e "= "a,b,c,d"', ([], {'d': 'd', ' e ': 'a,b,c,d'}, [])),
+            ('d = d," e "= "a,b,c,d"', ([], {"d": "d", " e ": "a,b,c,d"}, [])),
             # trailing args
-            ('1,2,a=b,3,4', (['1', '2'], {'a': 'b'}, ['3', '4'])),
+            ("1,2,a=b,3,4", (["1", "2"], {"a": "b"}, ["3", "4"])),
             # can quote quotes:
-            ('d = """d"', ([], {'d': '"d'}, [])),
-            ('d = """d"""', ([], {'d': '"d"'}, [])),
-            ('d = "d"" ", e=7', ([], {'d': 'd" ', 'e': '7'}, [])),
-            ('d = "d""", e=8', ([], {'d': 'd"', 'e': '8'}, [])),
+            ('d = """d"', ([], {"d": '"d'}, [])),
+            ('d = """d"""', ([], {"d": '"d"'}, [])),
+            ('d = "d"" ", e=7', ([], {"d": 'd" ', "e": "7"}, [])),
+            ('d = "d""", e=8', ([], {"d": 'd"', "e": "8"}, [])),
         ]
         for args, expected in tests:
             result = paramparser.parse_quoted_separated(args)
@@ -67,9 +67,9 @@ def testMacroArgs(self):
     def testLimited(self):
         tests = [
             # regular and quoting tests
-            ('d = 4,c=3,b=2,a= 1 ', ([], {'d': '4', 'c': '3,b=2,a= 1'}, [])),
-            ('a,b,c,d', (['a', 'b,c,d'], {}, [])),
-            ('a=b,b,c,d', ([], {'a': 'b'}, ['b,c,d'])),
+            ("d = 4,c=3,b=2,a= 1 ", ([], {"d": "4", "c": "3,b=2,a= 1"}, [])),
+            ("a,b,c,d", (["a", "b,c,d"], {}, [])),
+            ("a=b,b,c,d", ([], {"a": "b"}, ["b,c,d"])),
         ]
         for args, expected in tests:
             result = paramparser.parse_quoted_separated(args, seplimit=1)
@@ -83,31 +83,34 @@ def testLimited(self):
             for val in result[2]:
                 assert val is None or isinstance(val, str)
 
-    @pytest.mark.parametrize('args,expected', [
-        # regular and quoting tests
-        ('d==4,=3 ', ([], {'d': '=4', '': '3'}, [])),
-        ('===a,b,c,d', ([], {'': '==a'}, ['b', 'c', 'd'])),
-        ('a,b,===,c,d', (['a', 'b'], {'': '=='}, ['c', 'd'])),
-    ])
+    @pytest.mark.parametrize(
+        "args,expected",
+        [
+            # regular and quoting tests
+            ("d==4,=3 ", ([], {"d": "=4", "": "3"}, [])),
+            ("===a,b,c,d", ([], {"": "==a"}, ["b", "c", "d"])),
+            ("a,b,===,c,d", (["a", "b"], {"": "=="}, ["c", "d"])),
+        ],
+    )
     def testDoubleNameValueSeparator(self, args, expected):
         result = paramparser.parse_quoted_separated(args)
         assert result == expected
 
     def testNoNameValue(self):
-        abcd = ['a', 'b', 'c', 'd']
+        abcd = ["a", "b", "c", "d"]
         tests = [
             # regular and quoting tests
-            ('d = 4,c=3,b=2,a= 1 ', ['d = 4', 'c=3', 'b=2', 'a= 1']),
-            ('a,b,c,d', abcd),
-            (' a , b , c , d ', abcd),
-            ('   a   ', ['a']),
-            ('"  a  "', ['  a  ']),
-            ('a,b,c,d, "a,b,c,d"', abcd + ['a,b,c,d']),
-            ('quote " :), b', ['quote " :)', 'b']),
-            ('"quote "" :)", b', ['quote " :)', 'b']),
+            ("d = 4,c=3,b=2,a= 1 ", ["d = 4", "c=3", "b=2", "a= 1"]),
+            ("a,b,c,d", abcd),
+            (" a , b , c , d ", abcd),
+            ("   a   ", ["a"]),
+            ('"  a  "', ["  a  "]),
+            ('a,b,c,d, "a,b,c,d"', abcd + ["a,b,c,d"]),
+            ('quote " :), b', ['quote " :)', "b"]),
+            ('"quote "" :)", b', ['quote " :)', "b"]),
             ('"unended quote', ['"unended quote']),
             ('"', ['"']),
-            ('d=d,e="a,b,c,d"', ['d=d', 'e="a', 'b', 'c', 'd"']),
+            ('d=d,e="a,b,c,d"', ["d=d", 'e="a', "b", "c", 'd"']),
         ]
         for args, expected in tests:
             result = paramparser.parse_quoted_separated(args, name_value=False)
@@ -116,160 +119,175 @@ def testNoNameValue(self):
                 assert val is None or isinstance(val, str)
 
     def testUnitArgument(self):
-        result = paramparser.UnitArgument('7mm', float, ['%', 'mm'])
-        assert result.get_default() == (7.0, 'mm')
-        assert result.parse_argument('8%') == (8.0, '%')
-        pytest.raises(ValueError, result.parse_argument, '7m')
-        pytest.raises(ValueError, result.parse_argument, '7')
-        pytest.raises(ValueError, result.parse_argument, 'mm')
-
-    @pytest.mark.parametrize('args,sep,kwsep,expected', [
-        ('"a", "b", "c"', ',', None, ['a', 'b', 'c']),
-        ('a:b, b:c, c:d', ',', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b, b:c, c:d', ',', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b, b=c, c=d', ',', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b, b=c, c=d', ',', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a"; "b"; "c"', ';', None, ['a', 'b', 'c']),
-        ('a:b; b:c; c:d', ';', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b; b:c; c:d', ';', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b; b=c; c=d', ';', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b; b=c; c=d', ';', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a" "b" "c"', None, None, ['a', 'b', 'c']),
-        ('" a " "b" "c"', None, None, [' a ', 'b', 'c']),
-        ('"a  " "b" "c"', None, None, ['a  ', 'b', 'c']),
-        ('"  a" "b" "c"', None, None, ['  a', 'b', 'c']),
-        ('"  a" "b" "c"', None, ':', ['  a', 'b', 'c']),
-        ('"a:a" "b:b" "c:b"', None, ':', ['a:a', 'b:b', 'c:b']),
-        ('   a:a  ', None, ':', [None, None, None, ('a', 'a'), None, None]),
-        ('a a: a', None, ':', ['a', ('a', None), 'a']),
-        ('a a:"b c d" a', None, ':', ['a', ('a', 'b c d'), 'a']),
-        ('a a:"b "" d" a', None, ':', ['a', ('a', 'b " d'), 'a']),
-        ('title:Help* dog cat', None, ':', [('title', 'Help*'), 'dog', 'cat']),
-        ('title:Help* "dog cat"', None, ':', [('title', 'Help*'), 'dog cat']),
-        ('a:b:c d:e:f', None, ':', [('a', 'b:c'), ('d', 'e:f')]),
-        ('a:b:c:d', None, ':', [('a', 'b:c:d')]),
-    ])
+        result = paramparser.UnitArgument("7mm", float, ["%", "mm"])
+        assert result.get_default() == (7.0, "mm")
+        assert result.parse_argument("8%") == (8.0, "%")
+        pytest.raises(ValueError, result.parse_argument, "7m")
+        pytest.raises(ValueError, result.parse_argument, "7")
+        pytest.raises(ValueError, result.parse_argument, "mm")
+
+    @pytest.mark.parametrize(
+        "args,sep,kwsep,expected",
+        [
+            ('"a", "b", "c"', ",", None, ["a", "b", "c"]),
+            ("a:b, b:c, c:d", ",", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b, b:c, c:d", ",", None, ["a:b", "b:c", "c:d"]),
+            ("a=b, b=c, c=d", ",", None, ["a=b", "b=c", "c=d"]),
+            ("a=b, b=c, c=d", ",", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a"; "b"; "c"', ";", None, ["a", "b", "c"]),
+            ("a:b; b:c; c:d", ";", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b; b:c; c:d", ";", None, ["a:b", "b:c", "c:d"]),
+            ("a=b; b=c; c=d", ";", None, ["a=b", "b=c", "c=d"]),
+            ("a=b; b=c; c=d", ";", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a" "b" "c"', None, None, ["a", "b", "c"]),
+            ('" a " "b" "c"', None, None, [" a ", "b", "c"]),
+            ('"a  " "b" "c"', None, None, ["a  ", "b", "c"]),
+            ('"  a" "b" "c"', None, None, ["  a", "b", "c"]),
+            ('"  a" "b" "c"', None, ":", ["  a", "b", "c"]),
+            ('"a:a" "b:b" "c:b"', None, ":", ["a:a", "b:b", "c:b"]),
+            ("   a:a  ", None, ":", [None, None, None, ("a", "a"), None, None]),
+            ("a a: a", None, ":", ["a", ("a", None), "a"]),
+            ('a a:"b c d" a', None, ":", ["a", ("a", "b c d"), "a"]),
+            ('a a:"b "" d" a', None, ":", ["a", ("a", 'b " d'), "a"]),
+            ("title:Help* dog cat", None, ":", [("title", "Help*"), "dog", "cat"]),
+            ('title:Help* "dog cat"', None, ":", [("title", "Help*"), "dog cat"]),
+            ("a:b:c d:e:f", None, ":", [("a", "b:c"), ("d", "e:f")]),
+            ("a:b:c:d", None, ":", [("a", "b:c:d")]),
+        ],
+    )
     def testExtendedParser(self, args, sep, kwsep, expected):
         res = paramparser.parse_quoted_separated_ext(args, sep, kwsep)
         assert res == expected
 
-    @pytest.mark.parametrize('args,sep,kwsep,expected', [
-        ('"a", "b", "c"', ',', None, ['a', 'b', 'c']),
-        ('("a", "b", "c")', ',', None, [['(', 'a', 'b', 'c']]),
-        ('("a"("b", "c"))', ',', None, [['(', 'a', ['(', 'b', 'c']]]),
-        ('("a"("b)))", "c"))', ',', None, [['(', 'a', ['(', 'b)))', 'c']]]),
-        ('("a"("b>>> ( ab )>", "c"))', ',', None, [['(', 'a', ['(', 'b>>> ( ab )>', 'c']]]),
-        ('("a" ("b" "c"))', None, None, [['(', 'a', ['(', 'b', 'c']]]),
-        ('("a"("b", "c") ) ', ',', None, [['(', 'a', ['(', 'b', 'c']]]),
-        ('("a", <"b", ("c")>)', ',', None, [['(', 'a', ['<', 'b', ['(', 'c']]]]),
-        (',,,(a, b, c)', ',', None, [None, None, None, ['(', 'a', 'b', 'c']]),
-    ])
+    @pytest.mark.parametrize(
+        "args,sep,kwsep,expected",
+        [
+            ('"a", "b", "c"', ",", None, ["a", "b", "c"]),
+            ('("a", "b", "c")', ",", None, [["(", "a", "b", "c"]]),
+            ('("a"("b", "c"))', ",", None, [["(", "a", ["(", "b", "c"]]]),
+            ('("a"("b)))", "c"))', ",", None, [["(", "a", ["(", "b)))", "c"]]]),
+            ('("a"("b>>> ( ab )>", "c"))', ",", None, [["(", "a", ["(", "b>>> ( ab )>", "c"]]]),
+            ('("a" ("b" "c"))', None, None, [["(", "a", ["(", "b", "c"]]]),
+            ('("a"("b", "c") ) ', ",", None, [["(", "a", ["(", "b", "c"]]]),
+            ('("a", <"b", ("c")>)', ",", None, [["(", "a", ["<", "b", ["(", "c"]]]]),
+            (",,,(a, b, c)", ",", None, [None, None, None, ["(", "a", "b", "c"]]),
+        ],
+    )
     def testExtendedParserBracketing(self, args, sep, kwsep, expected):
-        res = paramparser.parse_quoted_separated_ext(args, sep, kwsep, brackets=('<>', '()'))
+        res = paramparser.parse_quoted_separated_ext(args, sep, kwsep, brackets=("<>", "()"))
         assert res == expected
 
-    @pytest.mark.parametrize('args,quotes,expected', [
-        ('"a b" -a b-', '"', ['a b', '-a', 'b-']),
-        ('"a b" -a b-', "-", ['"a', 'b"', 'a b']),
-        ('"a b" -a b-', '"-', ['a b', 'a b']),
-        ('"a- b" -a b-', '"-', ['a- b', 'a b']),
-        ('"a- b" -a" b-', '"-', ['a- b', 'a" b']),
-    ])
+    @pytest.mark.parametrize(
+        "args,quotes,expected",
+        [
+            ('"a b" -a b-', '"', ["a b", "-a", "b-"]),
+            ('"a b" -a b-', "-", ['"a', 'b"', "a b"]),
+            ('"a b" -a b-', '"-', ["a b", "a b"]),
+            ('"a- b" -a b-', '"-', ["a- b", "a b"]),
+            ('"a- b" -a" b-', '"-', ["a- b", 'a" b']),
+        ],
+    )
     def testExtendedParserQuoting(self, args, quotes, expected):
         res = paramparser.parse_quoted_separated_ext(args, quotes=quotes)
         assert res == expected
 
-    @pytest.mark.parametrize('args,sep,kwsep,expected', [
-        ('"a", "b", "c"', ',', None, ['a', 'b', 'c']),
-        ('a:b, b:c, c:d', ',', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b, b:c, c:d', ',', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b, b=c, c=d', ',', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b, b=c, c=d', ',', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a"; "b"; "c"', ';', None, ['a', 'b', 'c']),
-        ('a:b; b:c; c:d', ';', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b; b:c; c:d', ';', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b; b=c; c=d', ';', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b; b=c; c=d', ';', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a" "b" "c"', None, None, ['a', 'b', 'c']),
-        ('" a " "b" "c"', None, None, [' a ', 'b', 'c']),
-        ('"a  " "b" "c"', None, None, ['a  ', 'b', 'c']),
-        ('"  a" "b" "c"', None, None, ['  a', 'b', 'c']),
-        ('"  a" "b" "c"', None, ':', ['  a', 'b', 'c']),
-        ('"a:a" "b:b" "c:b"', None, ':', ['a:a', 'b:b', 'c:b']),
-        ('   a:a  ', None, ':', [None, None, None, ('a', 'a'), None, None]),
-        ('a a: a', None, ':', ['a', ('a', None), 'a']),
-        ('a a:"b c d" a', None, ':', ['a', ('a', 'b c d'), 'a']),
-        ('a a:"b "" d" a', None, ':', ['a', ('a', 'b " d'), 'a']),
-        ('title:Help* dog cat', None, ':', [('title', 'Help*'), 'dog', 'cat']),
-        ('title:Help* "dog cat"', None, ':', [('title', 'Help*'), 'dog cat']),
-        ('a:b:c d:e:f', None, ':', [('a', 'b', 'c'), ('d', 'e', 'f')]),
-        ('a:b:c:d', None, ':', [('a', 'b', 'c', 'd')]),
-        ('a:"b:c":d', None, ':', [('a', 'b:c', 'd')]),
-    ])
+    @pytest.mark.parametrize(
+        "args,sep,kwsep,expected",
+        [
+            ('"a", "b", "c"', ",", None, ["a", "b", "c"]),
+            ("a:b, b:c, c:d", ",", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b, b:c, c:d", ",", None, ["a:b", "b:c", "c:d"]),
+            ("a=b, b=c, c=d", ",", None, ["a=b", "b=c", "c=d"]),
+            ("a=b, b=c, c=d", ",", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a"; "b"; "c"', ";", None, ["a", "b", "c"]),
+            ("a:b; b:c; c:d", ";", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b; b:c; c:d", ";", None, ["a:b", "b:c", "c:d"]),
+            ("a=b; b=c; c=d", ";", None, ["a=b", "b=c", "c=d"]),
+            ("a=b; b=c; c=d", ";", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a" "b" "c"', None, None, ["a", "b", "c"]),
+            ('" a " "b" "c"', None, None, [" a ", "b", "c"]),
+            ('"a  " "b" "c"', None, None, ["a  ", "b", "c"]),
+            ('"  a" "b" "c"', None, None, ["  a", "b", "c"]),
+            ('"  a" "b" "c"', None, ":", ["  a", "b", "c"]),
+            ('"a:a" "b:b" "c:b"', None, ":", ["a:a", "b:b", "c:b"]),
+            ("   a:a  ", None, ":", [None, None, None, ("a", "a"), None, None]),
+            ("a a: a", None, ":", ["a", ("a", None), "a"]),
+            ('a a:"b c d" a', None, ":", ["a", ("a", "b c d"), "a"]),
+            ('a a:"b "" d" a', None, ":", ["a", ("a", 'b " d'), "a"]),
+            ("title:Help* dog cat", None, ":", [("title", "Help*"), "dog", "cat"]),
+            ('title:Help* "dog cat"', None, ":", [("title", "Help*"), "dog cat"]),
+            ("a:b:c d:e:f", None, ":", [("a", "b", "c"), ("d", "e", "f")]),
+            ("a:b:c:d", None, ":", [("a", "b", "c", "d")]),
+            ('a:"b:c":d', None, ":", [("a", "b:c", "d")]),
+        ],
+    )
     def testExtendedParserMultikey(self, args, sep, kwsep, expected):
         res = paramparser.parse_quoted_separated_ext(args, sep, kwsep, multikey=True)
         assert res == expected
 
-    P = paramparser.ParserPrefix('+')
-    M = paramparser.ParserPrefix('-')
-
-    @pytest.mark.parametrize('args,sep,kwsep,expected', [
-        ('"a", "b", "c"', ',', None, ['a', 'b', 'c']),
-        ('a:b, b:c, c:d', ',', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b, b:c, c:d', ',', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b, b=c, c=d', ',', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b, b=c, c=d', ',', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a"; "b"; "c"', ';', None, ['a', 'b', 'c']),
-        ('a:b; b:c; c:d', ';', ':', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('a:b; b:c; c:d', ';', None, ['a:b', 'b:c', 'c:d']),
-        ('a=b; b=c; c=d', ';', None, ['a=b', 'b=c', 'c=d']),
-        ('a=b; b=c; c=d', ';', '=', [('a', 'b'), ('b', 'c'), ('c', 'd')]),
-        ('"a" "b" "c"', None, None, ['a', 'b', 'c']),
-        ('" a " "b" "c"', None, None, [' a ', 'b', 'c']),
-        ('"a  " "b" "c"', None, None, ['a  ', 'b', 'c']),
-        ('"  a" "b" "c"', None, None, ['  a', 'b', 'c']),
-        ('"  a" "b" "c"', None, ':', ['  a', 'b', 'c']),
-        ('"a:a" "b:b" "c:b"', None, ':', ['a:a', 'b:b', 'c:b']),
-        ('   a:a  ', None, ':', [None, None, None, ('a', 'a'), None, None]),
-        ('a a: a', None, ':', ['a', ('a', None), 'a']),
-        ('a a:"b c d" a', None, ':', ['a', ('a', 'b c d'), 'a']),
-        ('a a:"b "" d" a', None, ':', ['a', ('a', 'b " d'), 'a']),
-        ('title:Help* dog cat', None, ':', [('title', 'Help*'), 'dog', 'cat']),
-        ('title:Help* "dog cat"', None, ':', [('title', 'Help*'), 'dog cat']),
-        ('a:b:c d:e:f', None, ':', [('a', 'b', 'c'), ('d', 'e', 'f')]),
-        ('a:b:c:d', None, ':', [('a', 'b', 'c', 'd')]),
-        ('a:"b:c":d', None, ':', [('a', 'b:c', 'd')]),
-        ('-a:b:d', None, ':', [(M, 'a', 'b', 'd')]),
-        ('"-a:b:d"', None, ':', [('-a:b:d')]),
-        ('-"a:b:d"', None, ':', [(M, 'a:b:d')]),
-        ('-a:"b:c":"d e f g"', None, ':', [(M, 'a', 'b:c', 'd e f g')]),
-        ('+-a:b:d', None, ':', [(P, '-a', 'b', 'd')]),
-        ('-"+a:b:d"', None, ':', [(M, '+a:b:d')]),
-        # bit of a weird case...
-        ('-+"a:b:d"', None, ':', [(M, '+"a', 'b', 'd"')]),
-        ('-a:"b:c" a +b', None, ':', [(M, 'a', 'b:c'), 'a', (P, 'b')]),
-    ])
+    P = paramparser.ParserPrefix("+")
+    M = paramparser.ParserPrefix("-")
+
+    @pytest.mark.parametrize(
+        "args,sep,kwsep,expected",
+        [
+            ('"a", "b", "c"', ",", None, ["a", "b", "c"]),
+            ("a:b, b:c, c:d", ",", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b, b:c, c:d", ",", None, ["a:b", "b:c", "c:d"]),
+            ("a=b, b=c, c=d", ",", None, ["a=b", "b=c", "c=d"]),
+            ("a=b, b=c, c=d", ",", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a"; "b"; "c"', ";", None, ["a", "b", "c"]),
+            ("a:b; b:c; c:d", ";", ":", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ("a:b; b:c; c:d", ";", None, ["a:b", "b:c", "c:d"]),
+            ("a=b; b=c; c=d", ";", None, ["a=b", "b=c", "c=d"]),
+            ("a=b; b=c; c=d", ";", "=", [("a", "b"), ("b", "c"), ("c", "d")]),
+            ('"a" "b" "c"', None, None, ["a", "b", "c"]),
+            ('" a " "b" "c"', None, None, [" a ", "b", "c"]),
+            ('"a  " "b" "c"', None, None, ["a  ", "b", "c"]),
+            ('"  a" "b" "c"', None, None, ["  a", "b", "c"]),
+            ('"  a" "b" "c"', None, ":", ["  a", "b", "c"]),
+            ('"a:a" "b:b" "c:b"', None, ":", ["a:a", "b:b", "c:b"]),
+            ("   a:a  ", None, ":", [None, None, None, ("a", "a"), None, None]),
+            ("a a: a", None, ":", ["a", ("a", None), "a"]),
+            ('a a:"b c d" a', None, ":", ["a", ("a", "b c d"), "a"]),
+            ('a a:"b "" d" a', None, ":", ["a", ("a", 'b " d'), "a"]),
+            ("title:Help* dog cat", None, ":", [("title", "Help*"), "dog", "cat"]),
+            ('title:Help* "dog cat"', None, ":", [("title", "Help*"), "dog cat"]),
+            ("a:b:c d:e:f", None, ":", [("a", "b", "c"), ("d", "e", "f")]),
+            ("a:b:c:d", None, ":", [("a", "b", "c", "d")]),
+            ('a:"b:c":d', None, ":", [("a", "b:c", "d")]),
+            ("-a:b:d", None, ":", [(M, "a", "b", "d")]),
+            ('"-a:b:d"', None, ":", [("-a:b:d")]),
+            ('-"a:b:d"', None, ":", [(M, "a:b:d")]),
+            ('-a:"b:c":"d e f g"', None, ":", [(M, "a", "b:c", "d e f g")]),
+            ("+-a:b:d", None, ":", [(P, "-a", "b", "d")]),
+            ('-"+a:b:d"', None, ":", [(M, "+a:b:d")]),
+            # bit of a weird case...
+            ('-+"a:b:d"', None, ":", [(M, '+"a', "b", 'd"')]),
+            ('-a:"b:c" a +b', None, ":", [(M, "a", "b:c"), "a", (P, "b")]),
+        ],
+    )
     def testExtendedParserPrefix(self, args, sep, kwsep, expected):
-        res = paramparser.parse_quoted_separated_ext(args, sep, kwsep, multikey=True, prefixes='-+')
+        res = paramparser.parse_quoted_separated_ext(args, sep, kwsep, multikey=True, prefixes="-+")
         assert res == expected
 
     UCE = paramparser.BracketUnexpectedCloseError
     MCE = paramparser.BracketMissingCloseError
 
-    @pytest.mark.parametrize('args,sep,kwsep,err', [
-        ('("a", "b", "c"', ',', None, MCE),
-        ('("a"("b", "c")', ',', None, MCE),
-        ('("a"<"b", "c")>', ',', None, UCE),
-        (')("a" ("b" "c"))', None, None, UCE),
-        ('("a", ("b", "c">))', ',', None, UCE),
-        ('("a", ("b", <"c">>))', ',', None, UCE),
-        ('(<(<)>)>', ',', None, UCE),
-    ])
+    @pytest.mark.parametrize(
+        "args,sep,kwsep,err",
+        [
+            ('("a", "b", "c"', ",", None, MCE),
+            ('("a"("b", "c")', ",", None, MCE),
+            ('("a"<"b", "c")>', ",", None, UCE),
+            (')("a" ("b" "c"))', None, None, UCE),
+            ('("a", ("b", "c">))', ",", None, UCE),
+            ('("a", ("b", <"c">>))', ",", None, UCE),
+            ("(<(<)>)>", ",", None, UCE),
+        ],
+    )
     def testExtendedParserBracketingErrors(self, args, sep, kwsep, err):
-        pytest.raises(err,
-                      paramparser.parse_quoted_separated_ext,
-                      args, sep, kwsep,
-                      brackets=('<>', '()'))
+        pytest.raises(err, paramparser.parse_quoted_separated_ext, args, sep, kwsep, brackets=("<>", "()"))
 
 
 class TestArgGetters:
@@ -279,18 +297,17 @@ def testGetBoolean(self):
             (None, None, None, None),
             (None, None, False, False),
             (None, None, True, True),
-
             # some real values
-            ('0', None, None, False),
-            ('1', None, None, True),
-            ('false', None, None, False),
-            ('true', None, None, True),
-            ('FALSE', None, None, False),
-            ('TRUE', None, None, True),
-            ('no', None, None, False),
-            ('yes', None, None, True),
-            ('NO', None, None, False),
-            ('YES', None, None, True),
+            ("0", None, None, False),
+            ("1", None, None, True),
+            ("false", None, None, False),
+            ("true", None, None, True),
+            ("FALSE", None, None, False),
+            ("TRUE", None, None, True),
+            ("no", None, None, False),
+            ("yes", None, None, True),
+            ("NO", None, None, False),
+            ("YES", None, None, True),
         ]
         for arg, name, default, expected in tests:
             assert paramparser.get_bool(arg, name, default) == expected
@@ -303,15 +320,15 @@ def testGetBooleanRaising(self):
         pytest.raises(TypeError, paramparser.get_bool, True)
         pytest.raises(TypeError, paramparser.get_bool, 42)
         pytest.raises(TypeError, paramparser.get_bool, 42.0)
-        pytest.raises(TypeError, paramparser.get_bool, b'')
+        pytest.raises(TypeError, paramparser.get_bool, b"")
         pytest.raises(TypeError, paramparser.get_bool, tuple())
         pytest.raises(TypeError, paramparser.get_bool, [])
         pytest.raises(TypeError, paramparser.get_bool, {})
 
         # any value not convertable to boolean raises ValueError
-        pytest.raises(ValueError, paramparser.get_bool, '')
-        pytest.raises(ValueError, paramparser.get_bool, '42')
-        pytest.raises(ValueError, paramparser.get_bool, 'wrong')
+        pytest.raises(ValueError, paramparser.get_bool, "")
+        pytest.raises(ValueError, paramparser.get_bool, "42")
+        pytest.raises(ValueError, paramparser.get_bool, "wrong")
         pytest.raises(ValueError, paramparser.get_bool, '"True"')  # must not be quoted!
 
     def testGetInt(self):
@@ -320,11 +337,10 @@ def testGetInt(self):
             (None, None, None, None),
             (None, None, -23, -23),
             (None, None, 42, 42),
-
             # some real values
-            ('0', None, None, 0),
-            ('42', None, None, 42),
-            ('-23', None, None, -23),
+            ("0", None, None, 0),
+            ("42", None, None, 42),
+            ("-23", None, None, -23),
         ]
         for arg, name, default, expected in tests:
             assert paramparser.get_int(arg, name, default) == expected
@@ -337,15 +353,15 @@ def testGetIntRaising(self):
         pytest.raises(TypeError, paramparser.get_int, True)
         pytest.raises(TypeError, paramparser.get_int, 42)
         pytest.raises(TypeError, paramparser.get_int, 42.0)
-        pytest.raises(TypeError, paramparser.get_int, b'')
+        pytest.raises(TypeError, paramparser.get_int, b"")
         pytest.raises(TypeError, paramparser.get_int, tuple())
         pytest.raises(TypeError, paramparser.get_int, [])
         pytest.raises(TypeError, paramparser.get_int, {})
 
         # any value not convertable to int raises ValueError
-        pytest.raises(ValueError, paramparser.get_int, '')
-        pytest.raises(ValueError, paramparser.get_int, '23.42')
-        pytest.raises(ValueError, paramparser.get_int, 'wrong')
+        pytest.raises(ValueError, paramparser.get_int, "")
+        pytest.raises(ValueError, paramparser.get_int, "23.42")
+        pytest.raises(ValueError, paramparser.get_int, "wrong")
         pytest.raises(ValueError, paramparser.get_int, '"4711"')  # must not be quoted!
 
     def testGetFloat(self):
@@ -354,33 +370,32 @@ def testGetFloat(self):
             (None, None, None, None),
             (None, None, -23.42, -23.42),
             (None, None, 42.23, 42.23),
-
             # some real values
-            ('0', None, None, 0),
-            ('42.23', None, None, 42.23),
-            ('-23.42', None, None, -23.42),
-            ('-23.42E3', None, None, -23.42E3),
-            ('23.42E-3', None, None, 23.42E-3),
+            ("0", None, None, 0),
+            ("42.23", None, None, 42.23),
+            ("-23.42", None, None, -23.42),
+            ("-23.42E3", None, None, -23.42e3),
+            ("23.42E-3", None, None, 23.42e-3),
         ]
         for arg, name, default, expected in tests:
             assert paramparser.get_float(arg, name, default) == expected
 
     def testGetFloatRaising(self):
         # wrong default type
-        pytest.raises(AssertionError, paramparser.get_float, None, None, '42')
+        pytest.raises(AssertionError, paramparser.get_float, None, None, "42")
 
         # anything except None or str raises TypeError
         pytest.raises(TypeError, paramparser.get_float, True)
         pytest.raises(TypeError, paramparser.get_float, 42)
         pytest.raises(TypeError, paramparser.get_float, 42.0)
-        pytest.raises(TypeError, paramparser.get_float, b'')
+        pytest.raises(TypeError, paramparser.get_float, b"")
         pytest.raises(TypeError, paramparser.get_float, tuple())
         pytest.raises(TypeError, paramparser.get_float, [])
         pytest.raises(TypeError, paramparser.get_float, {})
 
         # any value not convertable to int raises ValueError
-        pytest.raises(ValueError, paramparser.get_float, '')
-        pytest.raises(ValueError, paramparser.get_float, 'wrong')
+        pytest.raises(ValueError, paramparser.get_float, "")
+        pytest.raises(ValueError, paramparser.get_float, "wrong")
         pytest.raises(ValueError, paramparser.get_float, '"47.11"')  # must not be quoted!
 
     def testGetComplex(self):
@@ -389,57 +404,55 @@ def testGetComplex(self):
             (None, None, None, None),
             (None, None, -23.42, -23.42),
             (None, None, 42.23, 42.23),
-
             # some real values
-            ('0', None, None, 0),
-            ('42.23', None, None, 42.23),
-            ('-23.42', None, None, -23.42),
-            ('-23.42E3', None, None, -23.42E3),
-            ('23.42E-3', None, None, 23.42E-3),
-            ('23.42E-3+3.04j', None, None, 23.42E-3 + 3.04j),
-            ('3.04j', None, None, 3.04j),
-            ('-3.04j', None, None, -3.04j),
-            ('23.42E-3+3.04i', None, None, 23.42E-3 + 3.04j),
-            ('3.04i', None, None, 3.04j),
-            ('-3.04i', None, None, -3.04j),
-            ('-3', None, None, -3),
-            ('-300000000000000000000', None, None, -300000000000000000000),
+            ("0", None, None, 0),
+            ("42.23", None, None, 42.23),
+            ("-23.42", None, None, -23.42),
+            ("-23.42E3", None, None, -23.42e3),
+            ("23.42E-3", None, None, 23.42e-3),
+            ("23.42E-3+3.04j", None, None, 23.42e-3 + 3.04j),
+            ("3.04j", None, None, 3.04j),
+            ("-3.04j", None, None, -3.04j),
+            ("23.42E-3+3.04i", None, None, 23.42e-3 + 3.04j),
+            ("3.04i", None, None, 3.04j),
+            ("-3.04i", None, None, -3.04j),
+            ("-3", None, None, -3),
+            ("-300000000000000000000", None, None, -300000000000000000000),
         ]
         for arg, name, default, expected in tests:
             assert paramparser.get_complex(arg, name, default) == expected
 
     def testGetComplexRaising(self):
         # wrong default type
-        pytest.raises(AssertionError, paramparser.get_complex, None, None, '42')
+        pytest.raises(AssertionError, paramparser.get_complex, None, None, "42")
 
         # anything except None or str raises TypeError
         pytest.raises(TypeError, paramparser.get_complex, True)
         pytest.raises(TypeError, paramparser.get_complex, 42)
         pytest.raises(TypeError, paramparser.get_complex, 42.0)
         pytest.raises(TypeError, paramparser.get_complex, 3j)
-        pytest.raises(TypeError, paramparser.get_complex, b'')
+        pytest.raises(TypeError, paramparser.get_complex, b"")
         pytest.raises(TypeError, paramparser.get_complex, tuple())
         pytest.raises(TypeError, paramparser.get_complex, [])
         pytest.raises(TypeError, paramparser.get_complex, {})
 
         # any value not convertable to int raises ValueError
-        pytest.raises(ValueError, paramparser.get_complex, '')
-        pytest.raises(ValueError, paramparser.get_complex, '3jj')
-        pytest.raises(ValueError, paramparser.get_complex, '3Ij')
-        pytest.raises(ValueError, paramparser.get_complex, '3i-3i')
-        pytest.raises(ValueError, paramparser.get_complex, 'wrong')
+        pytest.raises(ValueError, paramparser.get_complex, "")
+        pytest.raises(ValueError, paramparser.get_complex, "3jj")
+        pytest.raises(ValueError, paramparser.get_complex, "3Ij")
+        pytest.raises(ValueError, paramparser.get_complex, "3i-3i")
+        pytest.raises(ValueError, paramparser.get_complex, "wrong")
         pytest.raises(ValueError, paramparser.get_complex, '"47.11"')  # must not be quoted!
 
     def testGetUnicode(self):
         tests = [
             # default testing for None value
             (None, None, None, None),
-            (None, None, '', ''),
-            (None, None, 'abc', 'abc'),
-
+            (None, None, "", ""),
+            (None, None, "abc", "abc"),
             # some real values
-            ('', None, None, ''),
-            ('abc', None, None, 'abc'),
+            ("", None, None, ""),
+            ("abc", None, None, "abc"),
             ('"abc"', None, None, '"abc"'),
         ]
         for arg, name, default, expected in tests:
@@ -453,7 +466,7 @@ def testGetStrRaising(self):
         pytest.raises(TypeError, paramparser.get_str, True)
         pytest.raises(TypeError, paramparser.get_str, 42)
         pytest.raises(TypeError, paramparser.get_str, 42.0)
-        pytest.raises(TypeError, paramparser.get_str, b'')
+        pytest.raises(TypeError, paramparser.get_str, b"")
         pytest.raises(TypeError, paramparser.get_str, tuple())
         pytest.raises(TypeError, paramparser.get_str, [])
         pytest.raises(TypeError, paramparser.get_str, {})
@@ -477,19 +490,19 @@ def _test_invoke_float_None(self, i=float):
     def _test_invoke_float_required(self, i=paramparser.required_arg(float)):
         assert i == 1.4
 
-    def _test_invoke_choice(self, a, choice=['a', 'b', 'c']):
+    def _test_invoke_choice(self, a, choice=["a", "b", "c"]):
         assert a == 7
-        assert choice == 'a'
+        assert choice == "a"
 
-    def _test_invoke_choicet(self, a, choice=('a', 'b', 'c')):
+    def _test_invoke_choicet(self, a, choice=("a", "b", "c")):
         assert a == 7
-        assert choice == 'a'
+        assert choice == "a"
 
-    def _test_invoke_choice_required(self, i=paramparser.required_arg(('b', 'a'))):
-        assert i == 'a'
+    def _test_invoke_choice_required(self, i=paramparser.required_arg(("b", "a"))):
+        assert i == "a"
 
     def _test_trailing(self, a, _trailing_args=[]):
-        assert _trailing_args == ['a']
+        assert _trailing_args == ["a"]
 
     def _test_arbitrary_kw(self, expect, _kwargs={}):
         assert _kwargs == expect
@@ -504,71 +517,53 @@ def _test_invoke_int_fixed(a, b, i=int):
             assert i == 1 or i is None
 
         ief = paramparser.invoke_extension_function
-        ief(self._test_invoke_bool, 'False')
-        ief(self._test_invoke_bool, 'b=False')
-        ief(_test_invoke_int, '1')
-        ief(_test_invoke_int, 'i=1')
-        ief(self._test_invoke_bool_def, 'False, False')
-        ief(self._test_invoke_bool_def, 'b=False, v=False')
-        ief(self._test_invoke_bool_def, 'False')
-        ief(self._test_invoke_int_None, 'i=1')
-        ief(self._test_invoke_int_None, 'i=')
-        ief(self._test_invoke_int_None, '')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_int_None, 'x')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_int_None, '""')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_int_None, 'i=""')
-        pytest.raises(ValueError, ief,
-                      _test_invoke_int_fixed, 'a=7', [7, 8])
-        ief(_test_invoke_int_fixed, 'i=1', [7, 8])
-        pytest.raises(ValueError, ief,
-                      _test_invoke_int_fixed, 'i=""', [7, 8])
-        ief(_test_invoke_int_fixed, 'i=', [7, 8])
+        ief(self._test_invoke_bool, "False")
+        ief(self._test_invoke_bool, "b=False")
+        ief(_test_invoke_int, "1")
+        ief(_test_invoke_int, "i=1")
+        ief(self._test_invoke_bool_def, "False, False")
+        ief(self._test_invoke_bool_def, "b=False, v=False")
+        ief(self._test_invoke_bool_def, "False")
+        ief(self._test_invoke_int_None, "i=1")
+        ief(self._test_invoke_int_None, "i=")
+        ief(self._test_invoke_int_None, "")
+        pytest.raises(ValueError, ief, self._test_invoke_int_None, "x")
+        pytest.raises(ValueError, ief, self._test_invoke_int_None, '""')
+        pytest.raises(ValueError, ief, self._test_invoke_int_None, 'i=""')
+        pytest.raises(ValueError, ief, _test_invoke_int_fixed, "a=7", [7, 8])
+        ief(_test_invoke_int_fixed, "i=1", [7, 8])
+        pytest.raises(ValueError, ief, _test_invoke_int_fixed, 'i=""', [7, 8])
+        ief(_test_invoke_int_fixed, "i=", [7, 8])
 
         for choicefn in (self._test_invoke_choice, self._test_invoke_choicet):
-            ief(choicefn, '', [7])
-            ief(choicefn, 'choice=a', [7])
-            ief(choicefn, 'choice=', [7])
+            ief(choicefn, "", [7])
+            ief(choicefn, "choice=a", [7])
+            ief(choicefn, "choice=", [7])
             ief(choicefn, 'choice="a"', [7])
-            pytest.raises(ValueError, ief,
-                          choicefn, 'x', [7])
-            pytest.raises(ValueError, ief,
-                          choicefn, 'choice=x', [7])
-
-        ief(self._test_invoke_float_None, 'i=1.4')
-        ief(self._test_invoke_float_None, 'i=')
-        ief(self._test_invoke_float_None, '')
-        ief(self._test_invoke_float_None, '1.4')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_float_None, 'x')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_float_None, '""')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_float_None, 'i=""')
-        ief(self._test_trailing, 'a=7, a')
-        ief(self._test_trailing, '7, a')
-        ief(self._test_arbitrary_kw, 'test=x, \xc3=test',
-            [{'\xc3': 'test', 'test': 'x'}])
-        ief(self._test_arbitrary_kw, 'test=x, "\xc3"=test',
-            [{'\xc3': 'test', 'test': 'x'}])
-        ief(self._test_arbitrary_kw, 'test=x, "7 \xc3"=test',
-            [{'7 \xc3': 'test', 'test': 'x'}])
-        ief(self._test_arbitrary_kw, 'test=x, 7 \xc3=test',
-            [{'7 \xc3': 'test', 'test': 'x'}])
-        ief(self._test_arbitrary_kw, '7 \xc3=test, test= x ',
-            [{'7 \xc3': 'test', 'test': 'x'}])
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_float_required, '')
-        ief(self._test_invoke_float_required, '1.4')
-        ief(self._test_invoke_float_required, 'i=1.4')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_choice_required, '')
-        ief(self._test_invoke_choice_required, 'a')
-        ief(self._test_invoke_choice_required, 'i=a')
-        pytest.raises(ValueError, ief,
-                      self._test_invoke_float_required, ',')
+            pytest.raises(ValueError, ief, choicefn, "x", [7])
+            pytest.raises(ValueError, ief, choicefn, "choice=x", [7])
+
+        ief(self._test_invoke_float_None, "i=1.4")
+        ief(self._test_invoke_float_None, "i=")
+        ief(self._test_invoke_float_None, "")
+        ief(self._test_invoke_float_None, "1.4")
+        pytest.raises(ValueError, ief, self._test_invoke_float_None, "x")
+        pytest.raises(ValueError, ief, self._test_invoke_float_None, '""')
+        pytest.raises(ValueError, ief, self._test_invoke_float_None, 'i=""')
+        ief(self._test_trailing, "a=7, a")
+        ief(self._test_trailing, "7, a")
+        ief(self._test_arbitrary_kw, "test=x, \xc3=test", [{"\xc3": "test", "test": "x"}])
+        ief(self._test_arbitrary_kw, 'test=x, "\xc3"=test', [{"\xc3": "test", "test": "x"}])
+        ief(self._test_arbitrary_kw, 'test=x, "7 \xc3"=test', [{"7 \xc3": "test", "test": "x"}])
+        ief(self._test_arbitrary_kw, "test=x, 7 \xc3=test", [{"7 \xc3": "test", "test": "x"}])
+        ief(self._test_arbitrary_kw, "7 \xc3=test, test= x ", [{"7 \xc3": "test", "test": "x"}])
+        pytest.raises(ValueError, ief, self._test_invoke_float_required, "")
+        ief(self._test_invoke_float_required, "1.4")
+        ief(self._test_invoke_float_required, "i=1.4")
+        pytest.raises(ValueError, ief, self._test_invoke_choice_required, "")
+        ief(self._test_invoke_choice_required, "a")
+        ief(self._test_invoke_choice_required, "i=a")
+        pytest.raises(ValueError, ief, self._test_invoke_float_required, ",")
 
     def testConstructors(self):
         ief = paramparser.invoke_extension_function
@@ -582,16 +577,16 @@ def __init__(self, a=int):
         class TEST2(TEST1):
             pass
 
-        obj = ief(TEST1, 'a=7')
+        obj = ief(TEST1, "a=7")
         assert isinstance(obj, TEST1)
         assert obj.constructed
-        pytest.raises(ValueError, ief, TEST1, 'b')
+        pytest.raises(ValueError, ief, TEST1, "b")
 
-        obj = ief(TEST2, 'a=7')
+        obj = ief(TEST2, "a=7")
         assert isinstance(obj, TEST1)
         assert isinstance(obj, TEST2)
         assert obj.constructed
-        pytest.raises(ValueError, ief, TEST2, 'b')
+        pytest.raises(ValueError, ief, TEST2, "b")
 
         # old style class
         class TEST3:
@@ -602,21 +597,21 @@ def __init__(self, a=int):
         class TEST4(TEST3):
             pass
 
-        obj = ief(TEST3, 'a=7')
+        obj = ief(TEST3, "a=7")
         assert isinstance(obj, TEST3)
         assert obj.constructed
-        pytest.raises(ValueError, ief, TEST3, 'b')
+        pytest.raises(ValueError, ief, TEST3, "b")
 
-        obj = ief(TEST4, 'a=7')
+        obj = ief(TEST4, "a=7")
         assert isinstance(obj, TEST3)
         assert isinstance(obj, TEST4)
         assert obj.constructed
-        pytest.raises(ValueError, ief, TEST4, 'b')
+        pytest.raises(ValueError, ief, TEST4, "b")
 
     def testFailing(self):
         ief = paramparser.invoke_extension_function
 
-        pytest.raises(TypeError, ief, hex, '15')
+        pytest.raises(TypeError, ief, hex, "15")
 
     def testAllDefault(self):
         ief = paramparser.invoke_extension_function
@@ -628,15 +623,15 @@ def has_many_defaults(a=1, b=2, c=3, d=4):
             assert d == 4
             return True
 
-        assert ief(has_many_defaults, '1, 2, 3, 4')
-        assert ief(has_many_defaults, '2, 3, 4', [1])
-        assert ief(has_many_defaults, '3, 4', [1, 2])
-        assert ief(has_many_defaults, '4', [1, 2, 3])
-        assert ief(has_many_defaults, '', [1, 2, 3, 4])
-        assert ief(has_many_defaults, 'd=4,c=3,b=2,a=1')
-        assert ief(has_many_defaults, 'd=4,c=3,b=2', [1])
-        assert ief(has_many_defaults, 'd=4,c=3', [1, 2])
-        assert ief(has_many_defaults, 'd=4', [1, 2, 3])
+        assert ief(has_many_defaults, "1, 2, 3, 4")
+        assert ief(has_many_defaults, "2, 3, 4", [1])
+        assert ief(has_many_defaults, "3, 4", [1, 2])
+        assert ief(has_many_defaults, "4", [1, 2, 3])
+        assert ief(has_many_defaults, "", [1, 2, 3, 4])
+        assert ief(has_many_defaults, "d=4,c=3,b=2,a=1")
+        assert ief(has_many_defaults, "d=4,c=3,b=2", [1])
+        assert ief(has_many_defaults, "d=4,c=3", [1, 2])
+        assert ief(has_many_defaults, "d=4", [1, 2, 3])
 
     def testInvokeComplex(self):
         ief = paramparser.invoke_extension_function
@@ -645,9 +640,9 @@ def has_complex(a=complex, b=complex):
             assert a == b
             return True
 
-        assert ief(has_complex, '3-3i, 3-3j')
-        assert ief(has_complex, '2i, 2j')
-        assert ief(has_complex, 'b=2i, a=2j')
-        assert ief(has_complex, '2.007, 2.007')
-        assert ief(has_complex, '2.007', [2.007])
-        assert ief(has_complex, 'b=2.007', [2.007])
+        assert ief(has_complex, "3-3i, 3-3j")
+        assert ief(has_complex, "2i, 2j")
+        assert ief(has_complex, "b=2i, a=2j")
+        assert ief(has_complex, "2.007, 2.007")
+        assert ief(has_complex, "2.007", [2.007])
+        assert ief(has_complex, "b=2.007", [2.007])
diff --git a/src/moin/utils/_tests/test_pysupport.py b/src/moin/utils/_tests/test_pysupport.py
index 7261a1293..29be131a1 100644
--- a/src/moin/utils/_tests/test_pysupport.py
+++ b/src/moin/utils/_tests/test_pysupport.py
@@ -19,46 +19,46 @@
 
 
 class TestImportNameFromMoin:
-    """ Test importName of MoinMoin modules
+    """Test importName of MoinMoin modules
 
     We don't make any testing for files, assuming that moin package is
     not broken.
     """
 
     def testNonExistingModule(self):
-        """ pysupport: import nonexistent module raises ImportError """
-        pytest.raises(ImportError, pysupport.importName, 'moin.utils.nonexistent', 'importName')
+        """pysupport: import nonexistent module raises ImportError"""
+        pytest.raises(ImportError, pysupport.importName, "moin.utils.nonexistent", "importName")
 
     def testNonExistingAttribute(self):
-        """ pysupport: import nonexistent attritbue raises AttributeError """
-        pytest.raises(AttributeError, pysupport.importName, 'moin.utils.pysupport', 'nonexistent')
+        """pysupport: import nonexistent attritbue raises AttributeError"""
+        pytest.raises(AttributeError, pysupport.importName, "moin.utils.pysupport", "nonexistent")
 
     def testExisting(self):
-        """ pysupport: import name from existing module """
+        """pysupport: import name from existing module"""
         from moin.utils.pysupport import importName
-        t = pysupport.importName('moin.utils.pysupport', 'importName')
+
+        t = pysupport.importName("moin.utils.pysupport", "importName")
         assert importName is t
 
 
 class TestImportNameFromPlugin:
-    """ Base class for import plugin tests """
+    """Base class for import plugin tests"""
 
-    name = 'Parser'
+    name = "Parser"
 
     @pytest.fixture(autouse=True)
     def custom_setup(self):
-        """ Check for valid plugin package """
-        self.pluginDirectory = os.path.join(app.cfg.data_dir, 'plugin', 'parser')
+        """Check for valid plugin package"""
+        self.pluginDirectory = os.path.join(app.cfg.data_dir, "plugin", "parser")
         self.checkPackage(self.pluginDirectory)
 
     def checkPackage(self, path):
-        for item in (path, os.path.join(path, '__init__.py')):
+        for item in (path, os.path.join(path, "__init__.py")):
             if not os.path.exists(item):
                 pytest.skip(f"Missing or wrong permissions: {item}")
 
     def pluginExists(self):
-        return (os.path.exists(self.pluginFilePath('.py')) or
-                os.path.exists(self.pluginFilePath('.pyc')))
+        return os.path.exists(self.pluginFilePath(".py")) or os.path.exists(self.pluginFilePath(".pyc"))
 
     def pluginFilePath(self, suffix):
         return os.path.join(self.pluginDirectory, self.plugin + suffix)
@@ -66,22 +66,22 @@ def pluginFilePath(self, suffix):
 
 class TestImportNonExisting(TestImportNameFromPlugin):
 
-    plugin = 'NonExistingWikiPlugin'
+    plugin = "NonExistingWikiPlugin"
 
     def testNonExisting(self):
-        """ pysupport: import nonexistent wiki plugin fail """
+        """pysupport: import nonexistent wiki plugin fail"""
         if self.pluginExists():
-            pytest.skip(f'plugin exists: {self.plugin}')
-        pytest.raises(plugins.PluginMissingError, plugins.importWikiPlugin, app.cfg, 'parser', self.plugin, 'Parser')
+            pytest.skip(f"plugin exists: {self.plugin}")
+        pytest.raises(plugins.PluginMissingError, plugins.importWikiPlugin, app.cfg, "parser", self.plugin, "Parser")
 
 
 class TestImportExisting(TestImportNameFromPlugin):
 
-    plugin = 'AutoCreatedMoinMoinTestPlugin'
+    plugin = "AutoCreatedMoinMoinTestPlugin"
     shouldDeleteTestPlugin = True
 
     def testExisting(self):
-        """ pysupport: import existing wiki plugin
+        """pysupport: import existing wiki plugin
 
         Tests if a module can be imported from an arbitrary path
         like it is done in moin for plugins. Some strange bug
@@ -93,36 +93,38 @@ def testExisting(self):
             self.createTestPlugin()
             # clear the plugin cache...
             app.cfg._site_plugin_lists = {}
-            parser = plugins.importWikiPlugin(app.cfg, 'parser', self.plugin, 'Parser')
-            assert getattr(parser, '__name__', None) == 'Parser'
+            parser = plugins.importWikiPlugin(app.cfg, "parser", self.plugin, "Parser")
+            assert getattr(parser, "__name__", None) == "Parser"
             assert parser.key == self.key
         finally:
             self.deleteTestPlugin()
 
     def createTestPlugin(self):
-        """ Create test plugin, skiping if plugin exists """
+        """Create test plugin, skiping if plugin exists"""
         if self.pluginExists():
             self.shouldDeleteTestPlugin = False
             pytest.skip(f"Won't overwrite existing plugin: {self.plugin}")
-        self.key = crypto.random_string(32, 'abcdefg')
-        data = '''
+        self.key = crypto.random_string(32, "abcdefg")
+        data = """
 # If you find this file in your wiki plugin directory, you can safely
 # delete it.
 import sys, os
 
 class Parser:
     key = '{}'
-'''.format(self.key)
+""".format(
+            self.key
+        )
         try:
-            open(self.pluginFilePath('.py'), 'w').write(data)
+            open(self.pluginFilePath(".py"), "w").write(data)
         except Exception as err:
             pytest.skip(f"Can't create test plugin: {err!s}")
 
     def deleteTestPlugin(self):
-        """ Delete plugin files ignoring missing files errors """
+        """Delete plugin files ignoring missing files errors"""
         if not self.shouldDeleteTestPlugin:
             return
-        for suffix in ('.py', '.pyc'):
+        for suffix in (".py", ".pyc"):
             try:
                 os.unlink(self.pluginFilePath(suffix))
             except OSError as err:
@@ -130,4 +132,4 @@ def deleteTestPlugin(self):
                     raise
 
 
-coverage_modules = ['moin.utils.pysupport']
+coverage_modules = ["moin.utils.pysupport"]
diff --git a/src/moin/utils/_tests/test_registry.py b/src/moin/utils/_tests/test_registry.py
index a2549612e..e63b50c08 100644
--- a/src/moin/utils/_tests/test_registry.py
+++ b/src/moin/utils/_tests/test_registry.py
@@ -24,7 +24,7 @@ def factory_none(arg):
 
 
 def factory_special(arg):
-    if arg == 'a':
+    if arg == "a":
         return 2
 
 
@@ -33,15 +33,15 @@ def test_Registry_get():
 
     r.register(factory_none)
     r.register(factory_special)
-    assert r.get('a') == 2
+    assert r.get("a") == 2
 
     r.register(factory_all)
     assert r.get(None) == 1
-    assert r.get('a') == 2
+    assert r.get("a") == 2
 
     r.register(factory_all2, r.PRIORITY_FIRST)
     assert r.get(None) == 3
-    assert r.get('a') == 3
+    assert r.get("a") == 3
 
 
 def test_Registry_lifecycle():
diff --git a/src/moin/utils/_tests/test_send_file.py b/src/moin/utils/_tests/test_send_file.py
index aba66f28d..02573cf3b 100644
--- a/src/moin/utils/_tests/test_send_file.py
+++ b/src/moin/utils/_tests/test_send_file.py
@@ -15,10 +15,10 @@
 
 
 class TestFuid:
-    """ test for send_file """
+    """test for send_file"""
 
     def setup_method(self, method):
-        self.test_dir = tempfile.mkdtemp('', 'test_dir')
+        self.test_dir = tempfile.mkdtemp("", "test_dir")
         self.fname = os.path.join(self.test_dir, "test_file")
 
     def teardown_method(self, method):
@@ -30,9 +30,9 @@ def makefile(self, fname, content):
         f.close()
 
     def test_temptest(self):
-        self.makefile(self.fname, 'test_content')
+        self.makefile(self.fname, "test_content")
         result = send_file.send_file(self.fname, as_attachment=True, conditional=True)
-        expected = '<Response streamed [200 OK]>'
+        expected = "<Response streamed [200 OK]>"
         assert str(result) == expected
 
         with pytest.raises(TypeError):
diff --git a/src/moin/utils/_tests/test_show_time.py b/src/moin/utils/_tests/test_show_time.py
index bfbf92965..a22c48eaa 100644
--- a/src/moin/utils/_tests/test_show_time.py
+++ b/src/moin/utils/_tests/test_show_time.py
@@ -12,58 +12,59 @@
 class TestShowTime:
 
     def test_showTime_duration(self):
-        """ test somewhat arbitrary duration results """
-        seconds_expected = ((25, ('seconds', 25)),
-                            (89, ('seconds', 89)),
-                            (91, ('minutes', 2)),
-                            (5399, ('minutes', 90)),
-                            (5401, ('hours', 2)),
-                            (128999, ('hours', 36)),
-                            (864000, ('weeks', 1)),
-                            (4838399, ('weeks', 8)),
-                            (4838401, ('months', 2)),
-                            (63071999, ('months', 24)),
-                            (126144000, ('years', 4)),
-                            )
+        """test somewhat arbitrary duration results"""
+        seconds_expected = (
+            (25, ("seconds", 25)),
+            (89, ("seconds", 89)),
+            (91, ("minutes", 2)),
+            (5399, ("minutes", 90)),
+            (5401, ("hours", 2)),
+            (128999, ("hours", 36)),
+            (864000, ("weeks", 1)),
+            (4838399, ("weeks", 8)),
+            (4838401, ("months", 2)),
+            (63071999, ("months", 24)),
+            (126144000, ("years", 4)),
+        )
 
         for seconds, expected in seconds_expected:
             result = show_time.duration(seconds)
             assert result == expected
 
     def test_show_time_datetime(self):
-        """ users who are not logged-in get ISO 8601 Zulu dates """
+        """users who are not logged-in get ISO 8601 Zulu dates"""
         formatted_date = show_time.format_date(utc_dt=0)
-        assert formatted_date == '1970-01-01z'
+        assert formatted_date == "1970-01-01z"
         formatted_time = show_time.format_time(utc_dt=0)
-        assert formatted_time == '00:00:00z'
+        assert formatted_time == "00:00:00z"
         formatted_date_time = show_time.format_date_time(utc_dt=0)
-        assert formatted_date_time == '1970-01-01 00:00:00z'
+        assert formatted_date_time == "1970-01-01 00:00:00z"
 
     def test_show_time_datetime_logged_in_utc(self):
         """users who are logged-in, selected UTC timezone and checked ISO-8601 get ISO 8601 Zulu dates"""
         flaskg.user.valid = True
-        flaskg.user.timezone = 'UTC'
-        flaskg.user.locale = 'en'
+        flaskg.user.timezone = "UTC"
+        flaskg.user.locale = "en"
         flaskg.user.iso_8601 = True
         formatted_date = show_time.format_date(utc_dt=0)
-        assert formatted_date == '1970-01-01z'
+        assert formatted_date == "1970-01-01z"
         formatted_time = show_time.format_time(utc_dt=0)
-        assert formatted_time == '00:00:00z'
+        assert formatted_time == "00:00:00z"
         formatted_date_time = show_time.format_date_time(utc_dt=0)
-        assert formatted_date_time == '1970-01-01 00:00:00z'
+        assert formatted_date_time == "1970-01-01 00:00:00z"
 
     def test_show_time_datetime_logged_in_local(self):
         """users who are logged-in, unchecked ISO-8601 get dates based on locale and timezone"""
         flaskg.user.valid = True
-        flaskg.user.locale = 'en'
+        flaskg.user.locale = "en"
         flaskg.user.iso_8601 = False
-        flaskg.user.timezone = 'America/Phoenix'
+        flaskg.user.timezone = "America/Phoenix"
         formatted_date = show_time.format_date(utc_dt=0)
-        assert formatted_date == 'Dec 31, 1969'
+        assert formatted_date == "Dec 31, 1969"
         formatted_time = show_time.format_time(utc_dt=0)
-        assert formatted_time in ['5:00:00\u202fPM', '5:00:00 PM', ]  # TODO: 2nd string can be removed in future
+        assert formatted_time in ["5:00:00\u202fPM", "5:00:00 PM"]  # TODO: 2nd string can be removed in future
         formatted_date_time = show_time.format_date_time(utc_dt=0)
-        assert formatted_date_time in ['Dec 31, 1969, 5:00:00\u202fPM', 'Dec 31, 1969, 5:00:00 PM', ]  # TODO: ditto
+        assert formatted_date_time in ["Dec 31, 1969, 5:00:00\u202fPM", "Dec 31, 1969, 5:00:00 PM"]  # TODO: ditto
 
 
-coverage_modules = ['moin.utils.show_time']
+coverage_modules = ["moin.utils.show_time"]
diff --git a/src/moin/utils/_tests/test_subscriptions.py b/src/moin/utils/_tests/test_subscriptions.py
index 6141a5c06..b6b0c48ce 100644
--- a/src/moin/utils/_tests/test_subscriptions.py
+++ b/src/moin/utils/_tests/test_subscriptions.py
@@ -9,8 +9,7 @@
 
 from moin import user
 from moin.items import Item
-from moin.constants.keys import (ACL, ITEMID, CONTENTTYPE, NAME, NAMERE, NAMEPREFIX,
-                                 SUBSCRIPTIONS, TAGS)
+from moin.constants.keys import ACL, ITEMID, CONTENTTYPE, NAME, NAMERE, NAMEPREFIX, SUBSCRIPTIONS, TAGS
 from moin.constants.namespaces import NAMESPACE_DEFAULT, NAMESPACE_USERPROFILES
 from moin.utils.subscriptions import get_subscribers, get_matched_subscription_patterns
 
@@ -20,11 +19,11 @@ class TestSubscriptions:
 
     @pytest.fixture
     def item_name(self):
-        return 'foo'
+        return "foo"
 
     @pytest.fixture
     def tag_name(self):
-        return 'XXX'
+        return "XXX"
 
     @pytest.fixture
     def namespace(self):
@@ -32,7 +31,7 @@ def namespace(self):
 
     @pytest.fixture
     def meta(self, tag_name):
-        return {CONTENTTYPE: 'text/plain;charset=utf-8', TAGS: [tag_name]}
+        return {CONTENTTYPE: "text/plain;charset=utf-8", TAGS: [tag_name]}
 
     @pytest.fixture
     def item(self, item_name, meta):
@@ -44,14 +43,14 @@ def test_get_subscribers(self, item, item_name, namespace, tag_name):
         users = get_subscribers(**item.meta)
         assert users == set()
 
-        name1 = 'baz'
-        password = 'password'
-        email1 = 'baz@example.org'
+        name1 = "baz"
+        password = "password"
+        email1 = "baz@example.org"
         name2 = "bar"
         email2 = "bar@example.org"
         name3 = "barbaz"
         email3 = "barbaz@example.org"
-        user.create_user(username=name1, password=password, email=email1, validate=False, locale='en')
+        user.create_user(username=name1, password=password, email=email1, validate=False, locale="en")
         user1 = user.User(name=name1, password=password)
         user.create_user(username=name2, password=password, email=email2, validate=False)
         user2 = user.User(name=name2, password=password)
@@ -60,7 +59,7 @@ def test_get_subscribers(self, item, item_name, namespace, tag_name):
         subscribers = get_subscribers(**item.meta)
         assert subscribers == set()
 
-        namere = r'.*'
+        namere = r".*"
         nameprefix = "fo"
         subscription_lists = [
             [f"{ITEMID}:{item.meta[ITEMID]}"],
@@ -79,8 +78,7 @@ def test_get_subscribers(self, item, item_name, namespace, tag_name):
             subscribers_names = {subscriber.name for subscriber in subscribers}
             assert subscribers_names == expected_names
 
-        meta = {CONTENTTYPE: 'text/plain;charset=utf-8',
-                ACL: f"{user1.name0}: All:read,write"}
+        meta = {CONTENTTYPE: "text/plain;charset=utf-8", ACL: f"{user1.name0}: All:read,write"}
         item._save(meta, comment="")
         item = Item.create(item_name)
         subscribers = get_subscribers(**item.meta)
@@ -113,14 +111,13 @@ def test_perf_get_subscribers(self):
             f"{NAME}:{self.namespace}:{self.item_name}",
             f"{TAGS}:{self.namespace}:{self.tagname}",
             "{}:{}:{}".format(NAMEPREFIX, self.namespace, "fo"),
-            "{}:{}:{}".format(NAMERE, self.namespace, r"\wo")
+            "{}:{}:{}".format(NAMERE, self.namespace, r"\wo"),
         ]
         users = set()
         expected_names = set()
         for i in range(10000):
             i = str(i)
-            user.create_user(username=i, password=password, email=f"{i}@example.org",
-                             validate=False, locale='en')
+            user.create_user(username=i, password=password, email=f"{i}@example.org", validate=False, locale="en")
             user_ = user.User(name=i, password=password)
             users.add(user_)
             expected_names.add(user_.name0)
@@ -130,9 +127,9 @@ def test_perf_get_subscribers(self):
         tests = [(users_sliced, expected_names_sliced), (users, expected_names)]
 
         import time
+
         for users_, expected_names_ in tests:
-            print("\nTesting {} subscribers from a total of {} users".format(
-                len(users_), len(users)))
+            print("\nTesting {} subscribers from a total of {} users".format(len(users_), len(users)))
             for subscription in subscriptions:
                 for user_ in users_:
                     user_.profile._meta[SUBSCRIPTIONS] = [subscription]
@@ -140,6 +137,6 @@ def test_perf_get_subscribers(self):
                 t = time.time()
                 subscribers = get_subscribers(**self.item.meta)
                 elapsed_time = time.time() - t
-                print("{}: {} s".format(subscription.split(':', 1)[0], elapsed_time))
+                print("{}: {} s".format(subscription.split(":", 1)[0], elapsed_time))
                 subscribers_names = {subscriber.name for subscriber in subscribers}
                 assert subscribers_names == expected_names_
diff --git a/src/moin/utils/_tests/test_thread_monitor.py b/src/moin/utils/_tests/test_thread_monitor.py
index 4d9c3f45a..280708940 100644
--- a/src/moin/utils/_tests/test_thread_monitor.py
+++ b/src/moin/utils/_tests/test_thread_monitor.py
@@ -13,17 +13,17 @@
 
 
 class TestMonitor:
-    """ Tests: Monitor """
+    """Tests: Monitor"""
 
     def setup_method(self, method):
-        self.test_dir = tempfile.mkdtemp('', 'test_dump')
+        self.test_dir = tempfile.mkdtemp("", "test_dump")
         self.src = os.path.join(self.test_dir, "test_dumpfile")
 
     def teardown_method(self, method):
         shutil.rmtree(self.test_dir)
 
     def test_hook(self):
-        """ tests for hooks """
+        """tests for hooks"""
         Monitor_test_obj = Monitor()
         result_inactivated = Monitor_test_obj.hook_enabled()
         assert not result_inactivated
@@ -33,7 +33,7 @@ def test_hook(self):
         assert result_activated
 
     def test_trigger_dump(self):
-        """ test for trigger_dump """
+        """test for trigger_dump"""
         Monitor_test_obj = Monitor()
         # activate the hook first
         Monitor_test_obj.activate_hook()
@@ -42,4 +42,4 @@ def test_trigger_dump(self):
         # read the content of first line
         with open(self.src) as f:
             f.readline()
-            assert 'Dumping thread' in f.readline()
+            assert "Dumping thread" in f.readline()
diff --git a/src/moin/utils/_tests/test_tree.py b/src/moin/utils/_tests/test_tree.py
index 0f5c64dd6..814b82f43 100644
--- a/src/moin/utils/_tests/test_tree.py
+++ b/src/moin/utils/_tests/test_tree.py
@@ -11,13 +11,13 @@
 
 
 def test_Name():
-    uri = 'uri:a'
+    uri = "uri:a"
 
-    name = Name('a', uri)
+    name = Name("a", uri)
     assert isinstance(name, ET.QName)
-    assert name.name == 'a'
+    assert name.name == "a"
     assert name.uri == uri
-    assert name == '{uri:a}a'
+    assert name == "{uri:a}a"
 
     element = name()
     assert isinstance(element, ET.Element)
@@ -25,7 +25,7 @@ def test_Name():
 
 
 def test_Namespace():
-    uri = 'uri:a'
+    uri = "uri:a"
 
     namespace = Namespace(uri)
     assert namespace == uri
@@ -33,32 +33,32 @@ def test_Namespace():
 
     name = namespace.a
     assert isinstance(name, Name)
-    assert name.name == 'a'
+    assert name.name == "a"
     assert name.uri == uri
 
-    name = namespace('a')
+    name = namespace("a")
     assert isinstance(name, Name)
-    assert name.name == 'a'
+    assert name.name == "a"
     assert name.uri == uri
 
     name = namespace.outline_level
-    assert name.name == 'outline-level'
+    assert name.name == "outline-level"
     assert name.uri == uri
 
-    name = namespace('outline-level')
-    assert name.name == 'outline-level'
+    name = namespace("outline-level")
+    assert name.name == "outline-level"
     assert name.uri == uri
 
     name = namespace.class_
-    assert name.name == 'class'
+    assert name.name == "class"
     assert name.uri == uri
 
-    name = namespace('class')
-    assert name.name == 'class'
+    name = namespace("class")
+    assert name.name == "class"
     assert name.uri == uri
 
-    name = namespace('class_')
-    assert name.name == 'class_'
+    name = namespace("class_")
+    assert name.name == "class_"
     assert name.uri == uri
 
 
diff --git a/src/moin/utils/_tests/test_util.py b/src/moin/utils/_tests/test_util.py
index dc8ea5ff9..7fcad1e37 100644
--- a/src/moin/utils/_tests/test_util.py
+++ b/src/moin/utils/_tests/test_util.py
@@ -12,34 +12,34 @@
 class TestUtil:
 
     def testRangeList(self):
-        """ utils.rangelist: test correct function for misc. input values """
+        """utils.rangelist: test correct function for misc. input values"""
         result = utils.rangelist([])
-        expected = ''
+        expected = ""
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([42])
-        expected = '42'
+        expected = "42"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([42, 23])
-        expected = '23,42'
+        expected = "23,42"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([1, 2, 3, 4, 5])
-        expected = '1-5'
+        expected = "1-5"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([2, 5, 3])
-        expected = '2-3,5'
+        expected = "2-3,5"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([2, 3, 5, 6])
-        expected = '2-3,5-6'
+        expected = "2-3,5-6"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
         result = utils.rangelist([2, 3, 5, 6, 23, 100, 101, 102, 104])
-        expected = '2-3,5-6,23,100-102,104'
+        expected = "2-3,5-6,23,100-102,104"
         assert result == expected, 'Expected "%(expected)s" but got "%(result)s"' % locals()
 
 
-coverage_modules = ['moin.utils']
+coverage_modules = ["moin.utils"]
diff --git a/src/moin/utils/clock.py b/src/moin/utils/clock.py
index f05228320..1db538f0c 100644
--- a/src/moin/utils/clock.py
+++ b/src/moin/utils/clock.py
@@ -13,6 +13,7 @@
 from flask import g as flaskg
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -42,7 +43,7 @@ def start(self, timer):
     def stop(self, timer):
         if timer in self.timers:
             value = time.time() - self.timers[timer].pop()
-            logging.debug(f'timer {timer}({len(self.timers[timer])}): {value * 1000:.2f}ms')
+            logging.debug(f"timer {timer}({len(self.timers[timer])}): {value * 1000:.2f}ms")
             if not self.timers[timer]:
                 del self.timers[timer]
             return value
@@ -62,6 +63,7 @@ def wrapper(*args, **kw):
         retval = f(*args, **kw)
         flaskg.clock.stop(name)
         return retval
+
     return wrapper
 
 
diff --git a/src/moin/utils/crypto.py b/src/moin/utils/crypto.py
index 83e76a0a3..5b846cad6 100644
--- a/src/moin/utils/crypto.py
+++ b/src/moin/utils/crypto.py
@@ -47,6 +47,7 @@ def random_string(length, allowed_chars=None):
 
 # password recovery token
 
+
 def generate_token(key=None, stamp=None):
     """
     generate a pair of a secret key and a crypto token.
@@ -89,7 +90,7 @@ def valid_token(key, token, timeout=2 * 60 * 60):
     :rtype: bool
     :returns: token is valid and not timed out
     """
-    parts = token.split('-')
+    parts = token.split("-")
     if len(parts) != 2:
         return False
     try:
@@ -104,6 +105,7 @@ def valid_token(key, token, timeout=2 * 60 * 60):
 
 # miscellaneous
 
+
 def cache_key(**kw):
     """
     Calculate a cache key (ascii only)
diff --git a/src/moin/utils/diff3.py b/src/moin/utils/diff3.py
index 5b35ea9c2..94c9410b4 100644
--- a/src/moin/utils/diff3.py
+++ b/src/moin/utils/diff3.py
@@ -6,21 +6,18 @@
 """
 
 
-default_markers = ('<<<<<<<<<<<<<<<<<<<<<<<<<\n',
-                   '=========================\n',
-                   '>>>>>>>>>>>>>>>>>>>>>>>>>\n')
+default_markers = ("<<<<<<<<<<<<<<<<<<<<<<<<<\n", "=========================\n", ">>>>>>>>>>>>>>>>>>>>>>>>>\n")
 
 
 def text_merge(old, other, new, allow_conflicts=1, *markers):
-    """ do line by line diff3 merge with three strings """
-    result = merge(old.splitlines(1), other.splitlines(1), new.splitlines(1),
-                   allow_conflicts, *markers)
-    return ''.join(result)
+    """do line by line diff3 merge with three strings"""
+    result = merge(old.splitlines(1), other.splitlines(1), new.splitlines(1), allow_conflicts, *markers)
+    return "".join(result)
 
 
 def merge(old, other, new, allow_conflicts=1, *markers):
-    """ do line by line diff3 merge
-        input must be lists containing single lines
+    """do line by line diff3 merge
+    input must be lists containing single lines
     """
     if not markers:
         markers = default_markers
@@ -50,9 +47,8 @@ def merge(old, other, new, allow_conflicts=1, *markers):
             if new_match != (old_nr, new_nr):
                 new_changed_lines = new_match[0] - old_nr
                 # other is unchanged
-                if match(old, other, old_nr, other_nr,
-                         new_changed_lines) == new_changed_lines:
-                    result.extend(new[new_nr:new_match[1]])
+                if match(old, other, old_nr, other_nr, new_changed_lines) == new_changed_lines:
+                    result.extend(new[new_nr : new_match[1]])
                     old_nr = new_match[0]
                     new_nr = new_match[1]
                     other_nr += new_changed_lines
@@ -60,8 +56,7 @@ def merge(old, other, new, allow_conflicts=1, *markers):
                 else:
                     if not allow_conflicts:
                         return None
-                    old_m, other_m, new_m = tripple_match(
-                        old, other, new, other_match, new_match)
+                    old_m, other_m, new_m = tripple_match(old, other, new, other_match, new_match)
                     result.append(marker1)
                     result.extend(other[other_nr:other_m])
                     result.append(marker2)
@@ -72,9 +67,8 @@ def merge(old, other, new, allow_conflicts=1, *markers):
             else:
                 other_changed_lines = other_match[0] - other_nr
                 # new is unchanged
-                if match(old, new, old_nr, new_nr,
-                         other_changed_lines) == other_changed_lines:
-                    result.extend(other[other_nr:other_match[1]])
+                if match(old, new, old_nr, new_nr, other_changed_lines) == other_changed_lines:
+                    result.extend(other[other_nr : other_match[1]])
                     old_nr = other_match[0]
                     other_nr = other_match[1]
                     new_nr += other_changed_lines
@@ -82,8 +76,7 @@ def merge(old, other, new, allow_conflicts=1, *markers):
                 else:
                     if not allow_conflicts:
                         return None
-                    old_m, other_m, new_m = tripple_match(
-                        old, other, new, other_match, new_match)
+                    old_m, other_m, new_m = tripple_match(old, other, new, other_match, new_match)
                     result.append(marker1)
                     result.extend(other[other_nr:other_m])
                     result.append(marker2)
@@ -102,12 +95,18 @@ def merge(old, other, new, allow_conflicts=1, *markers):
     elif old_nr == old_len and new_nr == new_len:
         result.extend(other[other_nr:])
     # new deleted lines
-    elif (new_nr == new_len and (old_len - old_nr == other_len - other_nr) and
-          match(old, other, old_nr, other_nr, old_len - old_nr) == old_len - old_nr):
+    elif (
+        new_nr == new_len
+        and (old_len - old_nr == other_len - other_nr)
+        and match(old, other, old_nr, other_nr, old_len - old_nr) == old_len - old_nr
+    ):
         pass
     # other deleted lines
-    elif (other_nr == other_len and (old_len - old_nr == new_len - new_nr) and
-          match(old, new, old_nr, new_nr, old_len - old_nr) == old_len - old_nr):
+    elif (
+        other_nr == other_len
+        and (old_len - old_nr == new_len - new_nr)
+        and match(old, new, old_nr, new_nr, old_len - old_nr) == old_len - old_nr
+    ):
         pass
     # conflict
     else:
@@ -126,32 +125,25 @@ def merge(old, other, new, allow_conflicts=1, *markers):
 
 def tripple_match(old, other, new, other_match, new_match):
     """find next matching pattern unchanged in both other and new
-       return the position in all three lists
+    return the position in all three lists
     """
     while True:
         difference = new_match[0] - other_match[0]
         # new changed more lines
         if difference > 0:
-            match_len = match(old, other, other_match[0], other_match[1],
-                              difference)
+            match_len = match(old, other, other_match[0], other_match[1], difference)
             if match_len == difference:
                 return new_match[0], other_match[1] + difference, new_match[1]
             else:
-                other_match = find_match(old, other,
-                                         other_match[0] + match_len,
-                                         other_match[1] + match_len)
+                other_match = find_match(old, other, other_match[0] + match_len, other_match[1] + match_len)
         # other changed more lines
         elif difference < 0:
             difference = -difference
-            match_len = match(old, new, new_match[0], new_match[1],
-                              difference)
+            match_len = match(old, new, new_match[0], new_match[1], difference)
             if match_len == difference:
-                return (other_match[0], other_match[1],
-                        new_match[0] + difference)
+                return (other_match[0], other_match[1], new_match[0] + difference)
             else:
-                new_match = find_match(old, new,
-                                       new_match[0] + match_len,
-                                       new_match[1] + match_len)
+                new_match = find_match(old, new, new_match[0] + match_len, new_match[1] + match_len)
         # both conflicts change same number of lines
         # or no match till the end
         else:
@@ -159,8 +151,8 @@ def tripple_match(old, other, new, other_match, new_match):
 
 
 def match(list1, list2, nr1, nr2, maxcount=3):
-    """ return the number matching items after the given positions
-        maximum maxcount lines are are processed
+    """return the number matching items after the given positions
+    maximum maxcount lines are are processed
     """
     i = 0
     len1 = len(list1)
@@ -176,7 +168,7 @@ def match(list1, list2, nr1, nr2, maxcount=3):
 
 def find_match(list1, list2, nr1, nr2, mincount=3):
     """searches next matching pattern with lenght mincount
-       if no pattern is found len of the both lists is returned
+    if no pattern is found len of the both lists is returned
     """
     len1 = len(list1)
     len2 = len(list2)
@@ -271,5 +263,5 @@ def main():
     print(text)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/moin/utils/diff_datastruct.py b/src/moin/utils/diff_datastruct.py
index ddafb503d..2256c6e97 100644
--- a/src/moin/utils/diff_datastruct.py
+++ b/src/moin/utils/diff_datastruct.py
@@ -10,14 +10,14 @@
 
 
 class UndefinedType:
-    """ Represents a non-existing value """
+    """Represents a non-existing value"""
 
 
 Undefined = UndefinedType()
 
 
 def diff(d1, d2, basekeys=None):
-    """ Get the diff of 2 datastructures (usually 2 meta dicts)
+    """Get the diff of 2 datastructures (usually 2 meta dicts)
 
     :param d1: old datastructure
     :param d2: new datastructure
@@ -29,9 +29,9 @@ def diff(d1, d2, basekeys=None):
         basekeys = []
     changes = []
 
-    if isinstance(d1, UndefinedType) and isinstance(d2, (dict, list, )):
+    if isinstance(d1, UndefinedType) and isinstance(d2, (dict, list)):
         d1 = type(d2)()
-    elif isinstance(d2, UndefinedType) and isinstance(d1, (dict, list, )):
+    elif isinstance(d2, UndefinedType) and isinstance(d1, (dict, list)):
         d2 = type(d1)()
     if isinstance(d1, dict) and isinstance(d2, dict):
         added = set(d2) - set(d1)
@@ -46,21 +46,19 @@ def diff(d1, d2, basekeys=None):
             else:
                 changes.extend(diff(d1[key], d2[key], keys))
     elif isinstance(d1, list) and isinstance(d2, list):
-        hashable = all(isinstance(d1, str) or all(
-            isinstance(v, Hashable) for v in d) for d in [d1, d2])
+        hashable = all(isinstance(d1, str) or all(isinstance(v, Hashable) for v in d) for d in [d1, d2])
         if hashable:
             matches = difflib.SequenceMatcher(None, d1, d2)
             for tag, d1_start, d1_end, d2_start, d2_end in matches.get_opcodes():
                 if tag == REPLACE:
-                    changes.extend([(DELETE, basekeys, d1[d1_start:d1_end]),
-                                    (INSERT, basekeys, d2[d2_start:d2_end])])
+                    changes.extend([(DELETE, basekeys, d1[d1_start:d1_end]), (INSERT, basekeys, d2[d2_start:d2_end])])
                 elif tag == DELETE:
                     changes.append((DELETE, basekeys, d1[d1_start:d1_end]))
                 elif tag == INSERT:
                     changes.append((INSERT, basekeys, d2[d2_start:d2_end]))
         else:
             changes.extend(diff(str(d1), str(d2), basekeys))
-    elif any(isinstance(d, (type(None), bool, int, float, str, )) for d in (d1, d2)):
+    elif any(isinstance(d, (type(None), bool, int, float, str)) for d in (d1, d2)):
         if isinstance(d1, UndefinedType):
             changes.append((INSERT, basekeys, d2))
         elif isinstance(d2, UndefinedType):
@@ -69,18 +67,14 @@ def diff(d1, d2, basekeys=None):
             if d1 != d2:
                 changes.extend([(DELETE, basekeys, d1), (INSERT, basekeys, d2)])
         else:
-            raise TypeError(
-                "Unsupported diff between {} and {} data types".format(
-                    type(d1), type(d2)))
+            raise TypeError("Unsupported diff between {} and {} data types".format(type(d1), type(d2)))
     else:
-        raise TypeError(
-            "Unsupported diff between {} and {} data types".format(
-                type(d1), type(d2)))
+        raise TypeError("Unsupported diff between {} and {} data types".format(type(d1), type(d2)))
     return changes
 
 
 def make_text_diff(changes):
-    """ Transform change tuples into text diffs
+    """Transform change tuples into text diffs
 
     :param changes: a list of tuples of the format (<change type>, <basekeys>, <value>)
                     that represent a diff
@@ -88,6 +82,6 @@ def make_text_diff(changes):
     """
     marker = {INSERT: "+", DELETE: "-"}
     for change_type, keys, value in changes:
-        yield "{} {}{}{}".format(marker[change_type],
-                                     ".".join(str(key) for key in keys),
-                                     ": " if keys else "", str(value))
+        yield "{} {}{}{}".format(
+            marker[change_type], ".".join(str(key) for key in keys), ": " if keys else "", str(value)
+        )
diff --git a/src/moin/utils/diff_html.py b/src/moin/utils/diff_html.py
index a23ef9db4..a82b55ed3 100644
--- a/src/moin/utils/diff_html.py
+++ b/src/moin/utils/diff_html.py
@@ -13,9 +13,9 @@
 
 
 def indent(line):
-    eol = ''
-    while line and line[0] == '\n':
-        eol += '\n'
+    eol = ""
+    while line and line[0] == "\n":
+        eol += "\n"
         line = line[1:]
     stripped = line.lstrip()
     if len(line) - len(stripped):
@@ -26,11 +26,11 @@ def indent(line):
 
 # This code originally by Scott Moonen, used with permission.
 def diff(old, new):
-    """ Find changes between old and new and return
-        HTML markup visualising them.
+    """Find changes between old and new and return
+    HTML markup visualising them.
 
-        :param old: old text [unicode]
-        :param new: new text [unicode]
+    :param old: old text [unicode]
+    :param new: new text [unicode]
     """
     seq1 = old.splitlines()
     seq2 = new.splitlines()
@@ -52,17 +52,17 @@ def diff(old, new):
             lastmatch = (match[0] + match[2], match[1] + match[2])
             continue
         llineno, rlineno = lastmatch[0] + 1, lastmatch[1] + 1
-        leftpane = ''
-        rightpane = ''
+        leftpane = ""
+        rightpane = ""
         linecount = max(match[0] - lastmatch[0], match[1] - lastmatch[1])
         for line in range(linecount):
             if line < match[0] - lastmatch[0]:
                 if line > 0:
-                    leftpane += '\n'
+                    leftpane += "\n"
                 leftpane += seq1[lastmatch[0] + line]
             if line < match[1] - lastmatch[1]:
                 if line > 0:
-                    rightpane += '\n'
+                    rightpane += "\n"
                 rightpane += seq2[lastmatch[1] + line]
 
         charobj = difflib.SequenceMatcher(None, leftpane, rightpane)
@@ -73,30 +73,28 @@ def diff(old, new):
             if leftpane:
                 leftresult = f"""<span>{indent(str(escape(leftpane)))}</span>"""
             else:
-                leftresult = ''
+                leftresult = ""
 
             if rightpane:
                 rightresult = f"""<span>{indent(str(escape(rightpane)))}</span>"""
             else:
-                rightresult = ''
+                rightresult = ""
         else:
             # Some similarities; markup changes.
             charlast = (0, 0)
-            leftresult = ''
-            rightresult = ''
+            leftresult = ""
+            rightresult = ""
             for thismatch in charmatch:
                 if thismatch[0] - charlast[0] != 0:
-                    leftresult += """<span>{}</span>""".format(indent(
-                        escape(leftpane[charlast[0]:thismatch[0]])))
+                    leftresult += """<span>{}</span>""".format(indent(escape(leftpane[charlast[0] : thismatch[0]])))
                 if thismatch[1] - charlast[1] != 0:
-                    rightresult += """<span>{}</span>""".format(indent(
-                        escape(rightpane[charlast[1]:thismatch[1]])))
-                leftresult += str(escape(leftpane[thismatch[0]:thismatch[0] + thismatch[2]]))
-                rightresult += str(escape(rightpane[thismatch[1]:thismatch[1] + thismatch[2]]))
+                    rightresult += """<span>{}</span>""".format(indent(escape(rightpane[charlast[1] : thismatch[1]])))
+                leftresult += str(escape(leftpane[thismatch[0] : thismatch[0] + thismatch[2]]))
+                rightresult += str(escape(rightpane[thismatch[1] : thismatch[1] + thismatch[2]]))
                 charlast = (thismatch[0] + thismatch[2], thismatch[1] + thismatch[2])
 
-        leftpane = '<br>'.join([indent(x) for x in leftresult.splitlines()])
-        rightpane = '<br>'.join([indent(x) for x in rightresult.splitlines()])
+        leftpane = "<br>".join([indent(x) for x in leftresult.splitlines()])
+        rightpane = "<br>".join([indent(x) for x in rightresult.splitlines()])
         result.append((llineno, leftpane, rlineno, rightpane))
 
         lastmatch = (match[0] + match[2], match[1] + match[2])
diff --git a/src/moin/utils/diff_text.py b/src/moin/utils/diff_text.py
index 701f04300..c19bc703e 100644
--- a/src/moin/utils/diff_text.py
+++ b/src/moin/utils/diff_text.py
@@ -20,7 +20,7 @@ def diff(oldlines, newlines, **kw):
     :returns: lines like diff tool does output.
     """
     false = lambda s: None  # noqa
-    if kw.get('ignorews', 0):
+    if kw.get("ignorews", 0):
         d = difflib.Differ(false)
     else:
         d = difflib.Differ(false, false)
@@ -30,51 +30,51 @@ def diff(oldlines, newlines, **kw):
     # return empty list if there were no changes
     changed = 0
     for line in lines:
-        if line[0] != ' ':
+        if line[0] != " ":
             changed = 1
             break
     if not changed:
         return []
 
-#    if not "we want the unchanged lines, too":
-#        if "no questionmark lines":
-#            lines = [line for line in lines if line[0] != '?']
-#        return lines
+    #    if not "we want the unchanged lines, too":
+    #        if "no questionmark lines":
+    #            lines = [line for line in lines if line[0] != '?']
+    #        return lines
 
     # calculate the hunks and remove the unchanged lines between them
-    i = 0              # actual index in lines
-    count = 0          # number of unchanged lines
-    lcount_old = 0     # line count old file
-    lcount_new = 0     # line count new file
+    i = 0  # actual index in lines
+    count = 0  # number of unchanged lines
+    lcount_old = 0  # line count old file
+    lcount_new = 0  # line count new file
     while i < len(lines):
         marker = lines[i][0]
-        if marker == ' ':
+        if marker == " ":
             count += 1
             i += 1
             lcount_old += 1
             lcount_new += 1
-        elif marker in ['-', '+']:
+        elif marker in ["-", "+"]:
             if (count == i) and count > 3:
-                lines[:i - 3] = []
+                lines[: i - 3] = []
                 i = 4
                 count = 0
             elif count > 6:
                 # remove lines and insert new hunk indicator
-                lines[i - count + 3:i - 3] = [f'@@ -{lcount_old:d}, +{lcount_new:d} @@\n']
+                lines[i - count + 3 : i - 3] = [f"@@ -{lcount_old:d}, +{lcount_new:d} @@\n"]
                 i = i - count + 8
                 count = 0
             else:
                 count = 0
                 i += 1
-            if marker == '-':
+            if marker == "-":
                 lcount_old += 1
             else:
                 lcount_new += 1
-        elif marker == '?':
-            lines[i:i + 1] = []
+        elif marker == "?":
+            lines[i : i + 1] = []
 
     # remove unchanged lines a the end
     if count > 3:
-        lines[-count + 3:] = []
+        lines[-count + 3 :] = []
 
     return lines
diff --git a/src/moin/utils/edit_locking.py b/src/moin/utils/edit_locking.py
index 1fca7fc6f..2e805d41c 100644
--- a/src/moin/utils/edit_locking.py
+++ b/src/moin/utils/edit_locking.py
@@ -45,13 +45,14 @@
 from moin.utils import show_time
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
 # these are used to create paths to the sql database and saved drafts
-SQL = 'sql'
-DB_NAME = 'edit_utils.db'
-PREVIEW = 'preview'
+SQL = "sql"
+DB_NAME = "edit_utils.db"
+PREVIEW = "preview"
 
 
 class Edit_Utils:
@@ -65,17 +66,17 @@ class Edit_Utils:
     def __init__(self, item):
         self.item = item
         self.user_name = self.get_user_name()
-        self.item_name = ','.join(item.names)
+        self.item_name = ",".join(item.names)
         # new items will not have rev_number, revid, nor itemid
         self.rev_number = item.meta.get(REV_NUMBER, 0)
-        self.rev_id = item.meta.get(REVID, 'new-item')
+        self.rev_id = item.meta.get(REVID, "new-item")
         self.item_id = item.meta.get(ITEMID, item.meta.get(NAME)[0])
 
-        self.coding = 'utf-8'
-        contenttype = self.item.meta.get('contenttype', None)
+        self.coding = "utf-8"
+        contenttype = self.item.meta.get("contenttype", None)
         if contenttype is not None:
             ct = Type(contenttype)
-            self.coding = ct.parameters.get('charset', self.coding)
+            self.coding = ct.parameters.get("charset", self.coding)
 
         self.sql_filename = os.path.join(app.cfg.instance_dir, SQL, DB_NAME)
         if os.path.exists(self.sql_filename):
@@ -86,8 +87,8 @@ def __init__(self, item):
         self.preview_path = os.path.join(app.cfg.instance_dir, PREVIEW)
         self.draft_name = self.make_draft_name(self.rev_id)
 
-        self.conn.isolation_level = 'EXCLUSIVE'
-        self.conn.execute('BEGIN EXCLUSIVE')
+        self.conn.isolation_level = "EXCLUSIVE"
+        self.conn.execute("BEGIN EXCLUSIVE")
 
     def create_db_tables(self):
         """
@@ -102,13 +103,16 @@ def create_db_tables(self):
             os.mkdir(os.path.join(app.cfg.instance_dir, PREVIEW))
         con = sqlite3.connect(self.sql_filename)  # opens existing file or creates new file
         cursor = con.cursor()
-        cursor.execute('''CREATE TABLE editlock(item_id TEXT NOT NULL PRIMARY KEY,
+        cursor.execute(
+            """CREATE TABLE editlock(item_id TEXT NOT NULL PRIMARY KEY,
                                                 item_name TEXT,
                                                 user_name TEXT,
                                                 timeout FLOAT
                                                 )
-        ''')
-        cursor.execute('''
+        """
+        )
+        cursor.execute(
+            """
             CREATE TABLE editdraft(user_name TEXT NOT NULL PRIMARY KEY,
                                    item_id TEXT,
                                    item_name TEXT,
@@ -116,7 +120,8 @@ def create_db_tables(self):
                                    save_time INTEGER,
                                    rev_id TEXT
                                    )
-        ''')
+        """
+        )
         con.commit()
         return con
 
@@ -127,10 +132,11 @@ def cursor_close(self):
 
     def make_draft_name(self, rev_id):
         """Return a file name consisting of rev_id + user_name."""
-        keepchars = ('-', '.', '_')
-        return os.path.join(self.preview_path, rev_id + '-' + "".join(
-            c for c in self.user_name if c.isalnum() or c in keepchars
-        ).rstrip())
+        keepchars = ("-", ".", "_")
+        return os.path.join(
+            self.preview_path,
+            rev_id + "-" + "".join(c for c in self.user_name if c.isalnum() or c in keepchars).rstrip(),
+        )
 
     def get_user_name(self):
         """Return user name or user IP address."""
@@ -164,18 +170,19 @@ def put_draft(self, data_in, overwrite=True):
                 draft_rev_number = rev_number  # XXX per line 1074 in __init__
                 rev_id = i_rev_id
                 self.draft_name = self.make_draft_name(rev_id)
-            self.cursor.execute('''DELETE FROM editdraft WHERE user_name = ? ''', (self.user_name, ))
+            self.cursor.execute("""DELETE FROM editdraft WHERE user_name = ? """, (self.user_name,))
         if data_in:
             data_in = data_in.encode(self.coding)
-            with open(self.draft_name, 'wb') as f:
+            with open(self.draft_name, "wb") as f:
                 f.write(data_in)
             save_time = int(time.time())
         else:
             save_time = 0  # indicates user is editing item but has not done a preview, no draft has been saved
         self.cursor.execute(
-            '''INSERT INTO editdraft(user_name, item_id, item_name, rev_number, save_time, rev_id)
-                           VALUES(?,?,?,?,?,?)''',
-            (self.user_name, self.item_id, self.item_name, draft_rev_number, save_time, rev_id))
+            """INSERT INTO editdraft(user_name, item_id, item_name, rev_number, save_time, rev_id)
+                           VALUES(?,?,?,?,?,?)""",
+            (self.user_name, self.item_id, self.item_name, draft_rev_number, save_time, rev_id),
+        )
         self.conn.commit()
 
     def get_draft(self):
@@ -185,9 +192,10 @@ def get_draft(self):
         If existing draft is for wrong item, log error and delete.
         """
         self.cursor.execute(
-            '''SELECT user_name, item_id, item_name, rev_number, save_time, rev_id FROM editdraft
-               WHERE user_name=?''',
-            (self.user_name, ))
+            """SELECT user_name, item_id, item_name, rev_number, save_time, rev_id FROM editdraft
+               WHERE user_name=?""",
+            (self.user_name,),
+        )
         draft = self.cursor.fetchone()
         if draft:
             u_name, i_id, i_name, rev_number, save_time, rev_id = draft
@@ -195,7 +203,7 @@ def get_draft(self):
                 if save_time:
                     self.draft_name = self.make_draft_name(rev_id)
                     try:
-                        with open(self.draft_name, 'rb') as f:
+                        with open(self.draft_name, "rb") as f:
                             data = f.read()
                         data = data.decode(self.coding)
                         return draft, data
@@ -226,7 +234,7 @@ def _delete_draft(self, save_time, rev_id):
             except OSError:
                 # draft file is created only when user does Preview
                 logging.error(f"IOError when deleting draft named {draft_name} for user {self.user_name}")
-        self.cursor.execute('''DELETE FROM editdraft WHERE user_name = ? ''', (self.user_name, ))
+        self.cursor.execute("""DELETE FROM editdraft WHERE user_name = ? """, (self.user_name,))
         self.conn.commit()
 
     # editlock methods start here
@@ -234,15 +242,16 @@ def update_editlock(self):
         """Reset existing editlock, same user or different user is given the item lock."""
         timeout = int(time.time()) + app.cfg.edit_lock_time * 60
         self.cursor.execute(
-            '''UPDATE editlock SET timeout = ?, user_name = ? WHERE item_id = ? ''',
-            (timeout, self.user_name, self.item_id))
+            """UPDATE editlock SET timeout = ?, user_name = ? WHERE item_id = ? """,
+            (timeout, self.user_name, self.item_id),
+        )
         self.conn.commit()
 
     def get_lock_status(self):
         """Return lock status of item_id, either a row of editlock or None"""
         self.cursor.execute(
-            '''SELECT item_id, item_name, user_name, timeout FROM editlock WHERE item_id=?''',
-            (self.item_id, ))
+            """SELECT item_id, item_name, user_name, timeout FROM editlock WHERE item_id=?""", (self.item_id,)
+        )
         locked = self.cursor.fetchone()
         return locked
 
@@ -267,15 +276,16 @@ def lock_item(self):
                     # some other user's lock has timed out, give one-time alert user about potential future conflict,
                     msg = L_(
                         "Edit lock for {user_name} timed out {number} {interval} ago, click 'Cancel' "
-                        "to yield more time, clicking 'Save' may require {user_name} to resolve conflicting edits.").format(
-                            user_name=u_name, number=number, interval=interval)
+                        "to yield more time, clicking 'Save' may require {user_name} to resolve conflicting edits."
+                    ).format(user_name=u_name, number=number, interval=interval)
                     self.update_editlock()
                     self.put_draft(None)
                     return LOCKED, msg
                 else:
                     # item is locked by somebody else, make current user wait
-                    msg = L_("Item '{item_name}' is locked by {user_name}. Try again in {number} {interval}."
-                            ).format(item_name=i_name, user_name=u_name, number=number, interval=interval)
+                    msg = L_("Item '{item_name}' is locked by {user_name}. Try again in {number} {interval}.").format(
+                        item_name=i_name, user_name=u_name, number=number, interval=interval
+                    )
                     return NO_LOCK, msg
 
             else:
@@ -286,19 +296,25 @@ def lock_item(self):
                     u_name, i_id, i_name, rev_number, save_time, rev_id = draft
                     if self.rev_number > rev_number:
                         # current user timed out, then other user updated and saved
-                        msg = L_("Someone else updated '{item_name}' after your edit lock timed out. "
-                                 "If you click 'Save', conflicting changes must be manually merged. "
-                                 "Click 'Cancel' to discard changes."
-                                ).format(item_name=self.item_name)
-                    self.cursor.execute('''INSERT INTO editlock(item_id, item_name, user_name, timeout)
-                                      VALUES(?,?,?,?)''', (self.item_id, self.item_name, self.user_name, timeout))
+                        msg = L_(
+                            "Someone else updated '{item_name}' after your edit lock timed out. "
+                            "If you click 'Save', conflicting changes must be manually merged. "
+                            "Click 'Cancel' to discard changes."
+                        ).format(item_name=self.item_name)
+                    self.cursor.execute(
+                        """INSERT INTO editlock(item_id, item_name, user_name, timeout)
+                                      VALUES(?,?,?,?)""",
+                        (self.item_id, self.item_name, self.user_name, timeout),
+                    )
                     self.conn.commit()
                     return LOCKED, msg
                 # if no draft, preserve starting rev_number by creating entry without rev_id
                 self.put_draft(None)
 
-                self.cursor.execute('''INSERT INTO editlock(item_id, item_name, user_name, timeout) VALUES(?,?,?,?)''',
-                                    (self.item_id, self.item_name, self.user_name, timeout))
+                self.cursor.execute(
+                    """INSERT INTO editlock(item_id, item_name, user_name, timeout) VALUES(?,?,?,?)""",
+                    (self.item_id, self.item_name, self.user_name, timeout),
+                )
                 self.conn.commit()
         return LOCKED, msg
 
@@ -313,15 +329,16 @@ def unlock_item(self, cancel=False):
         if locked:
             i_id, i_name, u_name, timeout = locked
             if u_name == user_name:
-                self.cursor.execute('''DELETE FROM editlock WHERE item_id = ? ''', (self.item_id, ))
+                self.cursor.execute("""DELETE FROM editlock WHERE item_id = ? """, (self.item_id,))
                 self.conn.commit()
                 return
             elif not cancel:
                 # bug: someone else has active edit lock, relock_item() should have been called prior to item save
                 logging.error(f"User {user_name} tried to unlock item that was locked by someone else: {i_name}")
-                msg = L_("Item '{item_name}' is locked by {user_name}. Edit lock error, "
-                         "check Item History to verify no changes were lost."
-                        ).format(item_name=i_name, user_name=u_name)
+                msg = L_(
+                    "Item '{item_name}' is locked by {user_name}. Edit lock error, "
+                    "check Item History to verify no changes were lost."
+                ).format(item_name=i_name, user_name=u_name)
                 return msg
         if not cancel:
             # bug: there should have been a lock_item call prior to unlock call
diff --git a/src/moin/utils/filesys.py b/src/moin/utils/filesys.py
index 00a48db3a..11cc8d750 100644
--- a/src/moin/utils/filesys.py
+++ b/src/moin/utils/filesys.py
@@ -19,6 +19,7 @@
 from os import replace as rename
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -26,9 +27,9 @@
 # Misc Helpers
 #############################################################################
 
+
 def chmod(name, mode, catchexception=True):
-    """ change mode of some file/dir on platforms that support it.
-    """
+    """change mode of some file/dir on platforms that support it."""
     try:
         os.chmod(name, mode)
     except OSError:
@@ -40,7 +41,7 @@ def chmod(name, mode, catchexception=True):
 
 
 def rename_no_overwrite(oldname, newname, delete_old=False):
-    """ Multiplatform rename
+    """Multiplatform rename
 
     This kind of rename is doing things differently: it fails if newname
     already exists. This is the usual thing on win32, but not on posix.
@@ -48,7 +49,7 @@ def rename_no_overwrite(oldname, newname, delete_old=False):
     If delete_old is True, oldname is removed in any case (even if the
     rename did not succeed).
     """
-    if os.name == 'nt':
+    if os.name == "nt":
         try:
             try:
                 os.rename(oldname, newname)
@@ -73,21 +74,24 @@ def rename_no_overwrite(oldname, newname, delete_old=False):
 
 
 def touch(name):
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
         import win32file
         import win32con
         import pywintypes
 
         access = win32file.GENERIC_WRITE
-        share = (win32file.FILE_SHARE_DELETE |
-                 win32file.FILE_SHARE_READ |
-                 win32file.FILE_SHARE_WRITE)
+        share = win32file.FILE_SHARE_DELETE | win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE
         create = win32file.OPEN_EXISTING
         mtime = time.gmtime()
-        handle = win32file.CreateFile(name, access, share, None, create,
-                                      win32file.FILE_ATTRIBUTE_NORMAL |
-                                      win32con.FILE_FLAG_BACKUP_SEMANTICS,
-                                      None)
+        handle = win32file.CreateFile(
+            name,
+            access,
+            share,
+            None,
+            create,
+            win32file.FILE_ATTRIBUTE_NORMAL | win32con.FILE_FLAG_BACKUP_SEMANTICS,
+            None,
+        )
         try:
             newTime = pywintypes.Time(mtime)
             win32file.SetFileTime(handle, newTime, newTime, newTime)
@@ -98,11 +102,12 @@ def touch(name):
 
 
 def access_denied_decorator(fn):
-    """ Due to unknown reasons, some os.* functions on Win32 sometimes fail
-        with Access Denied (although access should be possible).
-        Just retrying it a bit later works and this is what we do.
+    """Due to unknown reasons, some os.* functions on Win32 sometimes fail
+    with Access Denied (although access should be possible).
+    Just retrying it a bit later works and this is what we do.
     """
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
+
         def wrapper(*args, **kwargs):
             max_retries = 42
             retry = 0
@@ -114,10 +119,11 @@ def wrapper(*args, **kwargs):
                     if retry > max_retries:
                         raise
                     if err.errno == errno.EACCES:
-                        logging.warning(f'{fn.__name__}({args!r}, {kwargs!r}) -> access denied. retrying...')
+                        logging.warning(f"{fn.__name__}({args!r}, {kwargs!r}) -> access denied. retrying...")
                         time.sleep(0.01)
                         continue
                     raise
+
         return wrapper
     else:
         return fn
@@ -137,11 +143,11 @@ def copystat(src, dst):
     According to the official docs written by Microsoft, it returns ENOACCES if the
     supplied filename is a directory. Looks like a trainee implemented the function.
     """
-    if sys.platform == 'win32' and S_ISDIR(os.stat(dst)[ST_MODE]):
-        if os.name == 'nt':
+    if sys.platform == "win32" and S_ISDIR(os.stat(dst)[ST_MODE]):
+        if os.name == "nt":
             st = os.stat(src)
             mode = S_IMODE(st[ST_MODE])
-            if hasattr(os, 'chmod'):
+            if hasattr(os, "chmod"):
                 os.chmod(dst, mode)  # KEEP THIS ONE!
     else:
         shutil.copystat(src, dst)
@@ -186,5 +192,5 @@ def copytree(src, dst, symlinks=False):
 
 def wiki_index_exists():
     """Return true if a wiki index exists."""
-    logging.debug('CWD: %s', os.getcwd())
-    return bool(glob('wiki/index/_all_revs_*.toc'))
+    logging.debug("CWD: %s", os.getcwd())
+    return bool(glob("wiki/index/_all_revs_*.toc"))
diff --git a/src/moin/utils/forms.py b/src/moin/utils/forms.py
index 5acf4a01c..a0d7460a4 100644
--- a/src/moin/utils/forms.py
+++ b/src/moin/utils/forms.py
@@ -22,71 +22,72 @@ def label_filter(tagname, attributes, contents, context, bind):
     return contents
 
 
-label_filter.tags = {'label'}
+label_filter.tags = {"label"}
 
 
 def button_filter(tagname, attributes, contents, context, bind):
     """Show translated text in clickable buttons and submits."""
     if bind is None:
         return contents
-    if tagname == 'input':
-        if ('value' not in attributes and
-                attributes.get('type') in ['submit', 'reset', ]):
-            attributes['value'] = _(bind.default_value)
-    elif tagname == 'button' and not contents:
+    if tagname == "input":
+        if "value" not in attributes and attributes.get("type") in ["submit", "reset"]:
+            attributes["value"] = _(bind.default_value)
+    elif tagname == "button" and not contents:
         contents = _(bind.default_value)
     return contents
 
 
-button_filter.tags = {'input', 'button'}
+button_filter.tags = {"input", "button"}
 
 
 def required_filter(tagname, attributes, contents, context, bind):
     if bind is not None and not bind.optional:
-        if tagname == 'input':
-            attributes['required'] = 'required'
+        if tagname == "input":
+            attributes["required"] = "required"
     return contents
 
 
-required_filter.tags = {'input', 'label'}
+required_filter.tags = {"input", "label"}
 
 
 def autofocus_filter(tagname, attributes, contents, context, bind):
     if bind is not None:
-        autofocus = bind.properties.get('autofocus')
+        autofocus = bind.properties.get("autofocus")
         if autofocus:
-            attributes['autofocus'] = 'autofocus'
+            attributes["autofocus"] = "autofocus"
     return contents
 
 
-autofocus_filter.tags = {'input', 'textarea', }
+autofocus_filter.tags = {"input", "textarea"}
 
 
 def placeholder_filter(tagname, attributes, contents, context, bind):
     if bind is not None:
-        placeholder = bind.properties.get('placeholder')
+        placeholder = bind.properties.get("placeholder")
         if placeholder:
-            attributes['placeholder'] = placeholder
+            attributes["placeholder"] = placeholder
     return contents
 
 
-placeholder_filter.tags = {'input', 'textarea', }
+placeholder_filter.tags = {"input", "textarea"}
 
 
-def error_filter_factory(class_='moin-error'):
+def error_filter_factory(class_="moin-error"):
     """Returns an HTML generation filter annotating field CSS class on error.
 
     :param class: The css class to apply in case of validation error on a
                   field.  Default: 'error'
     """
+
     def error_filter(tagname, attributes, contents, context, bind):
         if bind is not None and bind.errors:
-            if 'class' in attributes:
-                attributes['class'] = ' '.join([attributes['class'], class_])
+            if "class" in attributes:
+                attributes["class"] = " ".join([attributes["class"], class_])
             else:
-                attributes['class'] = class_
+                attributes["class"] = class_
         return contents
-    error_filter.tags = {'input'}
+
+    error_filter.tags = {"input"}
     return error_filter
 
 
@@ -95,11 +96,13 @@ def error_filter(tagname, attributes, contents, context, bind):
 
 def make_generator():
     """make an html generator"""
-    return Generator(auto_domid=True, auto_for=True, auto_filter=True,
-                     markup_wrapper=Markup,
-                     filters=[label_filter, button_filter,
-                              error_filter,
-                              required_filter, placeholder_filter, autofocus_filter])
+    return Generator(
+        auto_domid=True,
+        auto_for=True,
+        auto_filter=True,
+        markup_wrapper=Markup,
+        filters=[label_filter, button_filter, error_filter, required_filter, placeholder_filter, autofocus_filter],
+    )
 
 
 class FileStorage(Scalar):
diff --git a/src/moin/utils/interwiki.py b/src/moin/utils/interwiki.py
index 0ac41537e..8ab72fef0 100644
--- a/src/moin/utils/interwiki.py
+++ b/src/moin/utils/interwiki.py
@@ -18,6 +18,7 @@
 from moin.constants.contenttypes import CHARSET
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -25,7 +26,7 @@ def is_local_wiki(wiki_name):
     """
     check if <wiki_name> is THIS wiki
     """
-    return wiki_name in ['', 'Self', app.cfg.interwikiname, ]
+    return wiki_name in ["", "Self", app.cfg.interwikiname]
 
 
 def is_known_wiki(wiki_name):
@@ -44,14 +45,22 @@ def get_fqname(item_name, field, namespace):
     composite name == [NAMESPACE/][@FIELD/]NAME
     """
     if field and field != NAME_EXACT:
-        item_name = f'@{field}/{item_name}'
+        item_name = f"@{field}/{item_name}"
     if namespace:
-        item_name = f'{namespace}/{item_name}'
+        item_name = f"{namespace}/{item_name}"
     return item_name
 
 
-def url_for_item(item_name, wiki_name='', field='', namespace='', rev=CURRENT,
-                 endpoint='frontend.show_item', _external=False, regex=''):
+def url_for_item(
+    item_name,
+    wiki_name="",
+    field="",
+    namespace="",
+    rev=CURRENT,
+    endpoint="frontend.show_item",
+    _external=False,
+    regex="",
+):
     """
     Compute URL for some local or remote/interwiki item.
 
@@ -68,7 +77,7 @@ def url_for_item(item_name, wiki_name='', field='', namespace='', rev=CURRENT,
     Computed URLs are always fully specified.
     """
     if field == NAME_EXACT:
-        field = ''
+        field = ""
     if is_local_wiki(wiki_name):
         item_name = get_fqname(item_name, field, namespace)
         if rev is None or rev == CURRENT:
@@ -82,12 +91,12 @@ def url_for_item(item_name, wiki_name='', field='', namespace='', rev=CURRENT,
             logging.warning(f"no interwiki_map entry for {wiki_name!r}")
             item_name = get_fqname(item_name, field, namespace)
             if wiki_name:
-                url = f'{wiki_name}/{item_name}'
+                url = f"{wiki_name}/{item_name}"
             else:
                 url = item_name
-            url = f'/{url}'
+            url = f"/{url}"
         else:
-            if (rev is None or rev == CURRENT) and endpoint == 'frontend.show_item':
+            if (rev is None or rev == CURRENT) and endpoint == "frontend.show_item":
                 # we just want to show latest revision (no special revision given) -
                 # this is the generic interwiki url support, should work for any remote wiki
                 url = join_wiki(wiki_base_url, item_name, field, namespace)
@@ -100,11 +109,11 @@ def url_for_item(item_name, wiki_name='', field='', namespace='', rev=CURRENT,
                 # we know that everything left of the + belongs to script url, but we
                 # just want e.g. +show/42/FooBar to append it to the other wiki's
                 # base URL.
-                i = local_url.index('/+')
-                path = local_url[i + 1:]
+                i = local_url.index("/+")
+                path = local_url[i + 1 :]
                 url = wiki_base_url + path
     if regex:
-        url += f'?regex={url_quote(regex, encoding=CHARSET)}'
+        url += f"?regex={url_quote(regex, encoding=CHARSET)}"
     return url
 
 
@@ -115,7 +124,7 @@ def get_download_file_name(fqname):
     if fqname.field == NAME_EXACT:
         return fqname.value
     else:
-        return f'{fqname.field}-{fqname.value}'
+        return f"{fqname.field}-{fqname.value}"
 
 
 def _split_namespace(namespaces, url):
@@ -132,11 +141,11 @@ def _split_namespace(namespaces, url):
     param url: string
     returns: (namespace, url)
     """
-    namespace = ''
-    tokens_list = url.split('/')
+    namespace = ""
+    tokens_list = url.split("/")
     for token in tokens_list:
         if namespace:
-            token = f'{namespace}/{token}'
+            token = f"{namespace}/{token}"
         if token in namespaces:
             namespace = token
         else:
@@ -147,16 +156,17 @@ def _split_namespace(namespaces, url):
     return namespace, url
 
 
-class CompositeName(namedtuple('CompositeName', 'namespace, field, value')):
+class CompositeName(namedtuple("CompositeName", "namespace, field, value")):
     """
     namedtuple to hold the compositename
     """
+
     @property
     def split(self):
         """
         returns a dict of field_names/field_values
         """
-        return {NAMESPACE: self.namespace, 'field': self.field, 'item_name': self.value}
+        return {NAMESPACE: self.namespace, "field": self.field, "item_name": self.value}
 
     @property
     def fullname(self):
@@ -197,15 +207,15 @@ def split_fqname(url):
         url: 'ns1/ns2/@notfield' return 'ns1/ns2', '', '@notfield'
     """
     if not url:
-        return CompositeName('', NAME_EXACT, '')
-    namespaces = {namespace.rstrip('/') for namespace, _ in app.cfg.namespace_mapping}
+        return CompositeName("", NAME_EXACT, "")
+    namespaces = {namespace.rstrip("/") for namespace, _ in app.cfg.namespace_mapping}
     namespace, url = _split_namespace(namespaces, url)
     field = NAME_EXACT
-    if url.startswith('@'):
-        tokens = url[1:].split('/', 1)
+    if url.startswith("@"):
+        tokens = url[1:].split("/", 1)
         if tokens[0] in FIELDS:
             field = tokens[0]
-            url = tokens[1] if len(tokens) > 1 else ''
+            url = tokens[1] if len(tokens) > 1 else ""
     return CompositeName(namespace, field, url)
 
 
@@ -234,25 +244,25 @@ def split_interwiki(wikiurl):
         :returns: (wikiname, namespace, field, pagename)
     """
     if not isinstance(wikiurl, str):
-        wikiurl = wikiurl.decode('utf-8')
+        wikiurl = wikiurl.decode("utf-8")
     # Base case: no colon in wikiurl
-    if '/' not in wikiurl:
-        return 'Self', '', NAME_EXACT, wikiurl
-    wikiname = field = namespace = ''
-    if not wikiurl.startswith('/'):
+    if "/" not in wikiurl:
+        return "Self", "", NAME_EXACT, wikiurl
+    wikiname = field = namespace = ""
+    if not wikiurl.startswith("/"):
         interwiki_mapping = set()
         for interwiki_name in app.cfg.interwiki_map:
-            interwiki_mapping.add(interwiki_name.split('/')[0])
+            interwiki_mapping.add(interwiki_name.split("/")[0])
         wikiname, item_name = _split_namespace(interwiki_mapping, wikiurl)
         if wikiname:
-            wikiurl = wikiurl[len(wikiname) + 1:]
+            wikiurl = wikiurl[len(wikiname) + 1 :]
         namespace, field, item_name = split_fqname(wikiurl)
         if not wikiname:
-            wikiname = 'Self'
+            wikiname = "Self"
         return wikiname, namespace, field, item_name
     else:
-        namespace, field, item_name = split_fqname(wikiurl.split('/', 1)[1])
-        return 'Self', namespace, field, item_name
+        namespace, field, item_name = split_fqname(wikiurl.split("/", 1)[1])
+        return "Self", namespace, field, item_name
 
 
 def join_wiki(wikiurl, wikitail, field, namespace):
@@ -268,17 +278,17 @@ def join_wiki(wikiurl, wikitail, field, namespace):
     :rtype: string
     :returns: generated URL of the page in the other wiki
     """
-    wikitail = url_quote(wikitail, encoding=CHARSET, safe='/')
-    field = url_quote(field, encoding=CHARSET, safe='/')
-    namespace = url_quote(namespace, encoding=CHARSET, safe='/')
-    if not ('$PAGE' in wikiurl or '$NAMESPACE' in wikiurl or '$FIELD' in wikiurl):
+    wikitail = url_quote(wikitail, encoding=CHARSET, safe="/")
+    field = url_quote(field, encoding=CHARSET, safe="/")
+    namespace = url_quote(namespace, encoding=CHARSET, safe="/")
+    if not ("$PAGE" in wikiurl or "$NAMESPACE" in wikiurl or "$FIELD" in wikiurl):
         return wikiurl + get_fqname(wikitail, field, namespace)
-    if '$PAGE' in wikiurl:
-        wikiurl = wikiurl.replace('$PAGE', wikitail)
-    if '$FIELD' in wikiurl:
-        wikiurl = wikiurl.replace('$FIELD', field)
-    if '$NAMESPACE' in wikiurl:
-        wikiurl = wikiurl.replace('$NAMESPACE', namespace)
+    if "$PAGE" in wikiurl:
+        wikiurl = wikiurl.replace("$PAGE", wikitail)
+    if "$FIELD" in wikiurl:
+        wikiurl = wikiurl.replace("$FIELD", field)
+    if "$NAMESPACE" in wikiurl:
+        wikiurl = wikiurl.replace("$NAMESPACE", namespace)
     return wikiurl
 
 
@@ -309,7 +319,7 @@ def getInterwikiHome(username):
     """
     homewiki = app.cfg.user_homewiki
     if is_local_wiki(homewiki):
-        homewiki = 'Self'
+        homewiki = "Self"
     return homewiki, username
 
 
@@ -320,7 +330,7 @@ class InterWikiMap:
     Provides a set of utilities for parsing and checking a interwiki maps.
     """
 
-    SKIP = '#'
+    SKIP = "#"
 
     def __init__(self, s):
         """
@@ -341,7 +351,7 @@ def __init__(self, s):
                 name, url = line.split(None, 1)
                 self.iwmap[name] = url
             except ValueError:
-                raise ValueError(f'malformed interwiki map string: {line}')
+                raise ValueError(f"malformed interwiki map string: {line}")
 
     @staticmethod
     def from_string(ustring):
diff --git a/src/moin/utils/iri.py b/src/moin/utils/iri.py
index a4ef0b133..0dc40a1a6 100644
--- a/src/moin/utils/iri.py
+++ b/src/moin/utils/iri.py
@@ -20,15 +20,15 @@ def _iriquote_replace(exc):
     if not isinstance(exc, UnicodeDecodeError):
         raise exc
 
-    text = ''.join('%%%02X' % code for code in exc.object[exc.start:exc.end])
+    text = "".join("%%%02X" % code for code in exc.object[exc.start : exc.end])
     return text, exc.end
 
 
-codecs.register_error('iriquote', _iriquote_replace)
+codecs.register_error("iriquote", _iriquote_replace)
 
 
 class Iri(AutoNe):
-    __slots__ = '_scheme', '_authority', '_path', '_query', '_fragment'
+    __slots__ = "_scheme", "_authority", "_path", "_query", "_fragment"
 
     overall_rules = r"""
     ^
@@ -92,25 +92,25 @@ def __init__(self, _iri=None, _quoted=True, scheme=None, authority=None, path=No
         elif _iri:
             match = self._overall_re.match(str(_iri))
             if not match:
-                raise ValueError('Input does not look like an IRI')
+                raise ValueError("Input does not look like an IRI")
 
-            _scheme = match.group('scheme')
+            _scheme = match.group("scheme")
             if _scheme is not None:
                 _scheme = str(_scheme).lower()
 
-            _authority = match.group('authority')
+            _authority = match.group("authority")
             if _authority is not None:
                 _authority = IriAuthority(_authority, _quoted)
 
-            _path = match.group('path')
+            _path = match.group("path")
             if _path is not None:
                 _path = IriPath(_path, _quoted)
 
-            _query = match.group('query')
+            _query = match.group("query")
             if _query is not None:
                 _query = IriQuery(_query, _quoted)
 
-            _fragment = match.group('fragment')
+            _fragment = match.group("fragment")
             if _fragment is not None:
                 _fragment = IriFragment(_fragment, _quoted)
 
@@ -162,24 +162,19 @@ def __eq__(self, other):
         return NotImplemented
 
     def __repr__(self):
-        return '{}(scheme={!r}, authority={!r}, path={!r}, query={!r}, fragment={!r})'.format(
-            self.__class__.__name__,
-            self.scheme,
-            self._authority,
-            self._path,
-            self._query,
-            self._fragment,
+        return "{}(scheme={!r}, authority={!r}, path={!r}, query={!r}, fragment={!r})".format(
+            self.__class__.__name__, self.scheme, self._authority, self._path, self._query, self._fragment
         )
 
     def __str__(self):
         ret = []
 
         if self.scheme:
-            ret.extend((self.scheme, ':'))
+            ret.extend((self.scheme, ":"))
 
         authority = self._authority
         if authority is not None:
-            ret.extend(('//', authority.fullquoted))
+            ret.extend(("//", authority.fullquoted))
 
         path = self._path
         if path is not None:
@@ -187,13 +182,13 @@ def __str__(self):
 
         query = self._query
         if query is not None:
-            ret.extend(('?', query.fullquoted))
+            ret.extend(("?", query.fullquoted))
 
         fragment = self._fragment
         if fragment is not None:
-            ret.extend(('#', fragment.fullquoted))
+            ret.extend(("#", fragment.fullquoted))
 
-        return ''.join(ret)
+        return "".join(ret)
 
     def __add__(self, other):
         if isinstance(other, Iri):
@@ -216,8 +211,9 @@ def __add__(self, other):
                     else:
                         new_path = self.path + new_path
 
-            return Iri(scheme=new_scheme, authority=new_authority, path=new_path,
-                       query=new_query, fragment=other.fragment)
+            return Iri(
+                scheme=new_scheme, authority=new_authority, path=new_path, query=new_query, fragment=other.fragment
+            )
 
         if isinstance(other, str):
             return self + Iri(other)
@@ -232,6 +228,7 @@ def __get_scheme(self):
 
     def __set_scheme(self, value):
         self._scheme = str(value).lower()
+
     scheme = property(__get_scheme, __set_scheme, __del_scheme, """Scheme part of the IRI.""")
 
     def __del_authority(self):
@@ -244,6 +241,7 @@ def __set_authority(self, value):
         if value.__class__ is not IriAuthority:
             value = IriAuthority(value, False)
         self._authority = value
+
     authority = property(__get_authority, __set_authority, __del_authority, """Authority part of the IRI.""")
 
     def __del_path(self):
@@ -256,6 +254,7 @@ def __set_path(self, value):
         if value.__class__ is not IriPath:
             value = IriPath(value, False)
         self._path = value
+
     path = property(__get_path, __set_path, __del_path, """Path part of the IRI.""")
 
     def __del_query(self):
@@ -266,6 +265,7 @@ def __get_query(self):
 
     def __set_query(self, value):
         self._query = IriQuery(value, False)
+
     query = property(__get_query, __set_query, __del_query, """Query part of the IRI.""")
 
     def __del_fragment(self):
@@ -276,19 +276,24 @@ def __get_fragment(self):
 
     def __set_fragment(self, value):
         self._fragment = IriFragment(value, False)
+
     fragment = property(__get_fragment, __set_fragment, __del_fragment, """Fragment part of the IRI.""")
 
 
 class _Value(str):
-    __slots__ = '_quoted'
+    __slots__ = "_quoted"
 
     # Rules for quoting parts of the IRI.
-    quote_rules_iri = ("""((?:%[0-9a-fA-F]{2})+)|"""
-                       """([^-!$&'*+.0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz|"""
-                       """\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)""")
-    quote_rules_uri = ("""((?:%[0-9a-fA-F]{2})+)|"""
-                       """([^-!$&'*+.0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz|"""
-                       """]+)""")
+    quote_rules_iri = (
+        """((?:%[0-9a-fA-F]{2})+)|"""
+        """([^-!$&'*+.0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz|"""
+        """\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)"""
+    )
+    quote_rules_uri = (
+        """((?:%[0-9a-fA-F]{2})+)|"""
+        """([^-!$&'*+.0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz|"""
+        """]+)"""
+    )
     quote_filter = frozenset()
 
     _quote_re_iri = re.compile(quote_rules_iri)
@@ -330,11 +335,13 @@ def subrepl(match):
 
             if t_quoted:
                 if not requote:
-                    t_quoted = t_quoted.replace('%', '%25')
+                    t_quoted = t_quoted.replace("%", "%25")
                 return t_quoted
 
-            return ''.join(char if char in quote_filter else ''.join('%%%02X' % b for b in char.encode('utf-8'))
-                           for char in t_plain)
+            return "".join(
+                char if char in quote_filter else "".join("%%%02X" % b for b in char.encode("utf-8"))
+                for char in t_plain
+            )
 
         re = url and cls._quote_re_uri or cls._quote_re_iri
         return re.sub(subrepl, input)
@@ -353,23 +360,23 @@ def _unquote(cls, s):
 
         for match in cls._unquote_re.finditer(s):
             # Handle leading text
-            t = s[pos:match.start()]
+            t = s[pos : match.start()]
             ret1.append(t)
             ret2.append(t)
             pos = match.end()
 
             part = []
-            for item in match.group().split('%')[1:]:
+            for item in match.group().split("%")[1:]:
                 part.append(int(item, 16))
             part = bytes(part)
-            ret1.append(part.decode('utf-8', 'replace'))
-            ret2.append(part.replace(b'%', b'%25').decode('utf-8', 'iriquote'))
+            ret1.append(part.decode("utf-8", "replace"))
+            ret2.append(part.replace(b"%", b"%25").decode("utf-8", "iriquote"))
 
         # Handle trailing text
         t = s[pos:]
         ret1.append(t)
         ret2.append(t)
-        return ''.join(ret1), ''.join(ret2)
+        return "".join(ret1), "".join(ret2)
 
     @property
     def fullquoted(self):
@@ -393,7 +400,7 @@ def quoted(self):
         """
         if self._quoted is not None:
             return self._quoted
-        return self.replace('%', '%25')
+        return self.replace("%", "%25")
 
     @property
     def urlquoted(self):
@@ -453,9 +460,7 @@ def __eq__(self, other):
         if isinstance(other, str):
             return str(self) == other
         if isinstance(other, IriAuthority):
-            return self._userinfo == other._userinfo and \
-                self._host == other._host and \
-                self.port == other.port
+            return self._userinfo == other._userinfo and self._host == other._host and self.port == other.port
         return NotImplemented
 
     def __bool__(self):
@@ -464,11 +469,8 @@ def __bool__(self):
         return False
 
     def __repr__(self):
-        return '{}(userinfo={!r}, host={!r}, port={!r})'.format(
-            self.__class__.__name__,
-            self._userinfo,
-            self._host,
-            self.port,
+        return "{}(userinfo={!r}, host={!r}, port={!r})".format(
+            self.__class__.__name__, self._userinfo, self._host, self.port
         )
 
     def __str__(self):
@@ -478,31 +480,31 @@ def __get(self, userinfo, host):
         ret = []
 
         if userinfo is not None:
-            ret.extend((userinfo, '@'))
+            ret.extend((userinfo, "@"))
         if host is not None:
             ret.append(host)
         if self.port is not None:
-            ret.append(':')
+            ret.append(":")
             if self.port:
                 ret.append(str(self.port))
 
-        return ''.join(ret)
+        return "".join(ret)
 
     def _parse(self, iri_authority, quoted):
         match = self._authority_re.match(iri_authority)
 
         if not match:
-            raise ValueError('Input does not look like an IRI authority')
+            raise ValueError("Input does not look like an IRI authority")
 
-        userinfo = match.group('userinfo')
+        userinfo = match.group("userinfo")
         if userinfo is not None:
             self._userinfo = IriAuthorityUserinfo(userinfo, quoted)
 
-        host = match.group('host')
+        host = match.group("host")
         if host is not None:
             self._host = IriAuthorityHost(host, quoted)
 
-        port = match.group('port')
+        port = match.group("port")
         if port is not None:
             if port:
                 self.port = int(port)
@@ -553,6 +555,7 @@ def __get_userinfo(self):
 
     def __set_userinfo(self, value):
         self._userinfo = IriAuthorityUserinfo(value, False)
+
     userinfo = property(__get_userinfo, __set_userinfo, __del_userinfo)
 
     def __del_host(self):
@@ -563,6 +566,7 @@ def __get_host(self):
 
     def __set_host(self, value):
         self._host = IriAuthorityHost(value, False)
+
     host = property(__get_host, __set_host, __del_host)
 
 
@@ -575,7 +579,7 @@ class IriAuthorityHost(_Value):
 
 
 class IriPath(AutoNe):
-    __slots__ = '_list'
+    __slots__ = "_list"
 
     def __init__(self, iri_path=None, _quoted=True):
         self._list = []
@@ -586,7 +590,7 @@ def __init__(self, iri_path=None, _quoted=True):
             elif isinstance(iri_path, (tuple, list)):
                 self._list = [IriPathSegment(i, False) for i in iri_path]
             else:
-                _list = [IriPathSegment(i, _quoted) for i in iri_path.split('/')]
+                _list = [IriPathSegment(i, _quoted) for i in iri_path.split("/")]
                 self._list = self._remove_dots(_list)
 
     def __eq__(self, other):
@@ -613,7 +617,7 @@ def __add__(self, other):
             return self + IriPath(other, False)
 
         if isinstance(other, IriPath):
-            if other._list and other._list[0] == '':
+            if other._list and other._list[0] == "":
                 segments = other._list
             else:
                 segments = self._list[:-1] + other._list
@@ -622,16 +626,13 @@ def __add__(self, other):
         return NotImplemented
 
     def __str__(self):
-        return '/'.join(self._list)
+        return "/".join(self._list)
 
     def __repr__(self):
-        return '{}({!r})'.format(
-            self.__class__.__name__,
-            str(self),
-        )
+        return "{}({!r})".format(self.__class__.__name__, str(self))
 
     def _remove_dots(self, segments):
-        if not segments or segments[0] != '':
+        if not segments or segments[0] != "":
             return segments
 
         empty = segments[0]
@@ -641,10 +642,10 @@ def _remove_dots(self, segments):
 
         # Get reversed list with first (empty) element removed
         for i in segments[:0:-1]:
-            if i == '.':
+            if i == ".":
                 if not output:
                     output.insert(0, empty)
-            elif i == '..':
+            elif i == "..":
                 if not output:
                     output.insert(0, empty)
                 remove += 1
@@ -668,7 +669,7 @@ def fullquoted(self):
         All characters which are illegal in the path part are encoded.
         Used to generate the full IRI.
         """
-        return '/'.join(i.fullquoted for i in self._list)
+        return "/".join(i.fullquoted for i in self._list)
 
     @property
     def quoted(self):
@@ -678,7 +679,7 @@ def quoted(self):
         Only '%' and illegal UTF-8 sequences are encoded. Primarily used to
         have a one-to-one mapping with non-UTF-8 URIs.
         """
-        return '/'.join(i.quoted for i in self._list)
+        return "/".join(i.quoted for i in self._list)
 
     @property
     def urlquoted(self):
@@ -688,16 +689,16 @@ def urlquoted(self):
         All characters which are illegal in the path part are encoded.
         Used to generate the full URI.
         """
-        return '/'.join(i.urlquoted for i in self._list)
+        return "/".join(i.urlquoted for i in self._list)
 
 
 class IriPathSegment(_Value):
-    quote_filter = frozenset('@:/')
+    quote_filter = frozenset("@:/")
 
 
 class IriQuery(_Value):
-    quote_filter = frozenset('@:/?')
+    quote_filter = frozenset("@:/?")
 
 
 class IriFragment(_Value):
-    quote_filter = frozenset('@:/?')
+    quote_filter = frozenset("@:/?")
diff --git a/src/moin/utils/mime.py b/src/moin/utils/mime.py
index d688a9ed4..dd308be61 100644
--- a/src/moin/utils/mime.py
+++ b/src/moin/utils/mime.py
@@ -10,7 +10,7 @@
 from moin.utils.pysupport import AutoNe
 
 
-class Type(namedtuple('Type', 'type subtype parameters'), AutoNe):
+class Type(namedtuple("Type", "type subtype parameters"), AutoNe):
     """
     :ivar type: Type part
     :type type: str
@@ -20,8 +20,9 @@ class Type(namedtuple('Type', 'type subtype parameters'), AutoNe):
     :type parameters: dict
     """
 
-    __token_allowed = s = frozenset(r"""!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"""
-                                    r"""^_`abcdefghijklmnopqrstuvwxyz{|}~""")
+    __token_allowed = s = frozenset(
+        r"""!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ""" r"""^_`abcdefghijklmnopqrstuvwxyz{|}~"""
+    )
 
     def __new__(cls, _type=None, type=None, subtype=None, parameters=None):
         """
@@ -57,16 +58,16 @@ def __eq__(self, other):
         return NotImplemented
 
     def __str__(self):
-        ret = ['{}/{}'.format(self.type or '*', self.subtype or '*')]
+        ret = ["{}/{}".format(self.type or "*", self.subtype or "*")]
 
         parameters = sorted(self.parameters.items())
         for key, value in parameters:
             if self.__token_check(value):
-                ret.append(f'{key}={value}')
+                ret.append(f"{key}={value}")
             else:
                 ret.append(f'{key}="{value}"')
 
-        return ';'.join(ret)
+        return ";".join(ret)
 
     def __token_check(self, value):
         token_allowed = self.__token_allowed
@@ -77,16 +78,16 @@ def __token_check(self, value):
 
     @classmethod
     def _parse(cls, type):
-        parts = type.split(';')
+        parts = type.split(";")
 
-        type, subtype = parts[0].strip().lower().split('/', 1)
+        type, subtype = parts[0].strip().lower().split("/", 1)
 
-        type = type != '*' and type or ''
-        subtype = subtype != '*' and subtype or ''
+        type = type != "*" and type or ""
+        subtype = subtype != "*" and subtype or ""
         parameters = {}
 
         for param in parts[1:]:
-            key, value = param.strip().split('=', 1)
+            key, value = param.strip().split("=", 1)
             # remove quotes
             if value[0] == '"' and value[-1] == '"':
                 value = value[1:-1]
@@ -116,11 +117,11 @@ def issupertype(self, other):
 
 
 # Own types, application type
-type_moin_document = Type(type='application', subtype='x.moin.document')
+type_moin_document = Type(type="application", subtype="x.moin.document")
 
 # Own types, text type
-type_moin_creole = Type(type='text', subtype='x.moin.creole')
-type_moin_wiki = Type(type='text', subtype='x.moin.wiki')
+type_moin_creole = Type(type="text", subtype="x.moin.creole")
+type_moin_wiki = Type(type="text", subtype="x.moin.wiki")
 
 # Generic types, text type
-type_text_plain = Type(type='text', subtype='plain')
+type_text_plain = Type(type="text", subtype="plain")
diff --git a/src/moin/utils/mimetype.py b/src/moin/utils/mimetype.py
index 50f405b34..54a213d8c 100644
--- a/src/moin/utils/mimetype.py
+++ b/src/moin/utils/mimetype.py
@@ -18,53 +18,53 @@
 
 MIMETYPES_MORE = {
     # OpenOffice 2.x & other open document stuff
-    '.odt': 'application/vnd.oasis.opendocument.text',
-    '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
-    '.odp': 'application/vnd.oasis.opendocument.presentation',
-    '.odg': 'application/vnd.oasis.opendocument.graphics',
-    '.odc': 'application/vnd.oasis.opendocument.chart',
-    '.odf': 'application/vnd.oasis.opendocument.formula',
-    '.odb': 'application/vnd.oasis.opendocument.database',
-    '.odi': 'application/vnd.oasis.opendocument.image',
-    '.odm': 'application/vnd.oasis.opendocument.text-master',
-    '.ott': 'application/vnd.oasis.opendocument.text-template',
-    '.ots': 'application/vnd.oasis.opendocument.spreadsheet-template',
-    '.otp': 'application/vnd.oasis.opendocument.presentation-template',
-    '.otg': 'application/vnd.oasis.opendocument.graphics-template',
+    ".odt": "application/vnd.oasis.opendocument.text",
+    ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+    ".odp": "application/vnd.oasis.opendocument.presentation",
+    ".odg": "application/vnd.oasis.opendocument.graphics",
+    ".odc": "application/vnd.oasis.opendocument.chart",
+    ".odf": "application/vnd.oasis.opendocument.formula",
+    ".odb": "application/vnd.oasis.opendocument.database",
+    ".odi": "application/vnd.oasis.opendocument.image",
+    ".odm": "application/vnd.oasis.opendocument.text-master",
+    ".ott": "application/vnd.oasis.opendocument.text-template",
+    ".ots": "application/vnd.oasis.opendocument.spreadsheet-template",
+    ".otp": "application/vnd.oasis.opendocument.presentation-template",
+    ".otg": "application/vnd.oasis.opendocument.graphics-template",
     # some systems (like Mac OS X) don't have some of these:
-    '.patch': 'text/x-diff',
-    '.diff': 'text/x-diff',
-    '.py': 'text/x-python',
-    '.cfg': 'text/plain',
-    '.conf': 'text/plain',
-    '.irc': 'text/plain',
-    '.md5': 'text/plain',
-    '.csv': 'text/csv',
-    '.rst': 'text/x-rst',
-    '.flv': 'video/x-flv',
-    '.wmv': 'video/x-ms-wmv',
-    '.wma': 'audio/x-ms-wma',
-    '.swf': 'application/x-shockwave-flash',
-    '.swd': 'application/x-svgdraw',
-    '.dbx': 'application/docbook+xml',
-    '.moin': 'text/x.moin.wiki',
-    '.creole': 'text/x.moin.creole',
-    '.md': 'text/x.markdown',
-    '.markdown': 'text/x.markdown',
-    '.mediawiki': 'text/x-mediawiki',
-    '.ico': 'image/x-icon',
-    '.svg': 'image/svg+xml',
+    ".patch": "text/x-diff",
+    ".diff": "text/x-diff",
+    ".py": "text/x-python",
+    ".cfg": "text/plain",
+    ".conf": "text/plain",
+    ".irc": "text/plain",
+    ".md5": "text/plain",
+    ".csv": "text/csv",
+    ".rst": "text/x-rst",
+    ".flv": "video/x-flv",
+    ".wmv": "video/x-ms-wmv",
+    ".wma": "audio/x-ms-wma",
+    ".swf": "application/x-shockwave-flash",
+    ".swd": "application/x-svgdraw",
+    ".dbx": "application/docbook+xml",
+    ".moin": "text/x.moin.wiki",
+    ".creole": "text/x.moin.creole",
+    ".md": "text/x.markdown",
+    ".markdown": "text/x.markdown",
+    ".mediawiki": "text/x-mediawiki",
+    ".ico": "image/x-icon",
+    ".svg": "image/svg+xml",
     # supported compressed archives
-    '.zip': 'application/zip',
-    '.tgz': 'application/x-gtar',
-    '.targz': 'application/x-gtar',
+    ".zip": "application/zip",
+    ".tgz": "application/x-gtar",
+    ".targz": "application/x-gtar",
 }
 
 # add all mimetype patterns of pygments
 for name, short, patterns, mime in pygments.lexers.get_all_lexers():
     for pattern in patterns:
-        if pattern.startswith('*.') and mime:
-            if pattern in ('*.txt', ):
+        if pattern.startswith("*.") and mime:
+            if pattern in ("*.txt",):
                 # there are some pygments lexers that claim *.txt for different
                 # stuff than text/plain, we do not want that.
                 continue
@@ -74,11 +74,11 @@
 
 MIMETYPES_sanitize_mapping = {
     # this stuff is text, but got application/* for unknown reasons
-    ('application', 'docbook+xml'): ('text', 'docbook'),
-    ('application', 'x-latex'): ('text', 'latex'),
-    ('application', 'x-tex'): ('text', 'tex'),
-    ('application', 'javascript'): ('text', 'javascript'),
-    ('application', 'x-dos-batch'): ('text', 'bat'),
+    ("application", "docbook+xml"): ("text", "docbook"),
+    ("application", "x-latex"): ("text", "latex"),
+    ("application", "x-tex"): ("text", "tex"),
+    ("application", "javascript"): ("text", "javascript"),
+    ("application", "x-dos-batch"): ("text", "bat"),
 }
 
 MIMETYPES_spoil_mapping = {}  # inverse mapping of above
@@ -87,7 +87,7 @@
 
 
 class MimeType:
-    """ represents a mimetype like text/plain """
+    """represents a mimetype like text/plain"""
 
     def __init__(self, mimestr=None, filename=None):
         self.major = self.minor = None  # sanitized mime type and subtype
@@ -103,17 +103,17 @@ def __init__(self, mimestr=None, filename=None):
     def parse_filename(self, filename):
         mtype, encoding = mimetypes.guess_type(filename)
         if mtype is None:
-            mtype = 'application/octet-stream'
+            mtype = "application/octet-stream"
         self.parse_mimetype(mtype)
 
     def parse_mimetype(self, mimestr):
-        """ take a string like used in content-type and parse it into components,
-            alternatively it also can process some abbreviated string like "wiki"
+        """take a string like used in content-type and parse it into components,
+        alternatively it also can process some abbreviated string like "wiki"
         """
         parameters = mimestr.split(";")
         parameters = [p.strip() for p in parameters]
         mimetype, parameters = parameters[0], parameters[1:]
-        mimetype = mimetype.split('/')
+        mimetype = mimetype.split("/")
         if len(mimetype) >= 2:
             major, minor = mimetype[:2]  # we just ignore more than 2 parts
         else:
@@ -121,66 +121,62 @@ def parse_mimetype(self, mimestr):
         self.major = major.lower()
         self.minor = minor.lower()
         for param in parameters:
-            key, value = param.split('=')
+            key, value = param.split("=")
             if value[0] == '"' and value[-1] == '"':  # remove quotes
                 value = value[1:-1]
             self.params[key.lower()] = value
-        if 'charset' in self.params:
-            self.charset = self.params['charset'].lower()
+        if "charset" in self.params:
+            self.charset = self.params["charset"].lower()
         self.sanitize()
 
     def parse_format(self, format):
-        """ maps from what we currently use on-page in a #format xxx processing
-            instruction to a sanitized mimetype major, minor tuple.
-            can also be user later for easier entry by the user, so he can just
-            type "wiki" instead of "text/x.moin.wiki".
+        """maps from what we currently use on-page in a #format xxx processing
+        instruction to a sanitized mimetype major, minor tuple.
+        can also be user later for easier entry by the user, so he can just
+        type "wiki" instead of "text/x.moin.wiki".
         """
         format = format.lower()
         if format in PARSER_TEXT_MIMETYPE:
-            mimetype = 'text', format
+            mimetype = "text", format
         else:
-            mapping = {
-                'wiki': ('text', 'x.moin.wiki'),
-                'irc': ('text', 'irssi'),
-            }
+            mapping = {"wiki": ("text", "x.moin.wiki"), "irc": ("text", "irssi")}
             try:
                 mimetype = mapping[format]
             except KeyError:
-                mimetype = 'text', f'x-{format}'
+                mimetype = "text", f"x-{format}"
         return mimetype
 
     def sanitize(self):
-        """ convert to some representation that makes sense - this is not necessarily
-            conformant to /etc/mime.types or IANA listing, but if something is
-            readable text, we will return some ``text/*`` mimetype, not ``application/*``,
-            because we need text/plain as fallback and not application/octet-stream.
+        """convert to some representation that makes sense - this is not necessarily
+        conformant to /etc/mime.types or IANA listing, but if something is
+        readable text, we will return some ``text/*`` mimetype, not ``application/*``,
+        because we need text/plain as fallback and not application/octet-stream.
         """
         self.major, self.minor = MIMETYPES_sanitize_mapping.get((self.major, self.minor), (self.major, self.minor))
 
     def spoil(self):
-        """ this returns something conformant to /etc/mime.type or IANA as a string,
-            kind of inverse operation of sanitize(), but doesn't change self
+        """this returns something conformant to /etc/mime.type or IANA as a string,
+        kind of inverse operation of sanitize(), but doesn't change self
         """
         major, minor = MIMETYPES_spoil_mapping.get((self.major, self.minor), (self.major, self.minor))
         return self.content_type(major, minor)
 
     def content_type(self, major=None, minor=None, charset=None, params=None):
-        """ return a string suitable for Content-Type header
-        """
+        """return a string suitable for Content-Type header"""
         major = major or self.major
         minor = minor or self.minor
         params = params or self.params or {}
-        if major == 'text':
+        if major == "text":
             charset = charset or self.charset
             if charset:
-                params['charset'] = charset
+                params["charset"] = charset
         mimestr = f"{major}/{minor}"
         params = [f'{key.lower()}="{value}"' for key, value in params.items()]
         params.insert(0, mimestr)
         return ";".join(params)
 
     def mime_type(self):
-        """ return a string major/minor only, no params """
+        """return a string major/minor only, no params"""
         return f"{self.major}/{self.minor}"
 
     def as_attachment(self, cfg):
@@ -191,19 +187,19 @@ def as_attachment(self, cfg):
         return mime_type in cfg.mimetypes_xss_protect
 
     def module_name(self):
-        """ convert this mimetype to a string useable as python module name,
-            we yield the exact module name first and then proceed to shorter
-            module names (useful for falling back to them, if the more special
-            module is not found) - e.g. first "text_python", next "text".
-            Finally, we yield "application_octet_stream" as the most general
-            mimetype we have.
-
-            Hint: the fallback handler module for text/* should be implemented
-            in module "text" (not "text_plain")
+        """convert this mimetype to a string useable as python module name,
+        we yield the exact module name first and then proceed to shorter
+        module names (useful for falling back to them, if the more special
+        module is not found) - e.g. first "text_python", next "text".
+        Finally, we yield "application_octet_stream" as the most general
+        mimetype we have.
+
+        Hint: the fallback handler module for text/* should be implemented
+        in module "text" (not "text_plain")
         """
         mimetype = self.mime_type()
         modname = mimetype.replace("/", "_").replace("-", "_").replace(".", "_")
-        fragments = modname.split('_')
+        fragments = modname.split("_")
         for length in range(len(fragments), 1, -1):
             yield "_".join(fragments[:length])
         yield self.raw_mimestr
diff --git a/src/moin/utils/notifications.py b/src/moin/utils/notifications.py
index b8e0c667c..752c8bfbb 100644
--- a/src/moin/utils/notifications.py
+++ b/src/moin/utils/notifications.py
@@ -14,8 +14,15 @@
 from flask import url_for, g as flaskg
 from flask import abort
 
-from moin.constants.keys import (ACTION_COPY, ACTION_RENAME, ACTION_REVERT,
-                                 ACTION_CONVERT, ACTION_SAVE, ACTION_TRASH, CONTENTTYPE)
+from moin.constants.keys import (
+    ACTION_COPY,
+    ACTION_RENAME,
+    ACTION_REVERT,
+    ACTION_CONVERT,
+    ACTION_SAVE,
+    ACTION_TRASH,
+    CONTENTTYPE,
+)
 from moin.i18n import _, L_
 from moin.i18n import force_locale
 from moin.items.content import Content
@@ -27,6 +34,7 @@
 from moin.utils.interwiki import url_for_item
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 # additional action values
@@ -39,7 +47,7 @@
 
 
 def msgs():
-    """ Encapsulates the main notification messages
+    """Encapsulates the main notification messages
 
     :return: a dictionary of notification messages
     """
@@ -65,6 +73,7 @@ class Notification:
     """
     Represents a mail notification about an item change
     """
+
     txt_template = "mail/notification.txt"
     html_template = "mail/notification_main.html"
 
@@ -76,22 +85,26 @@ def __init__(self, app, fqname, action, data, meta, new_data, new_meta, **kwargs
         self.meta = meta
         self.new_meta = new_meta
         self.new_data = new_data
-        self.comment = kwargs.get('comment', None)
+        self.comment = kwargs.get("comment", None)
         self.wiki_name = self.app.cfg.interwikiname
 
         if self.action == ACTION_SAVE:
             self.action = ACTION_CREATE if meta is None else ACTION_MODIFY
 
-        kw = dict(fqname=str(fqname), wiki_name=self.wiki_name, user_name=flaskg.user.name0,
-                  item_url=url_for_item(self.fqname))
+        kw = dict(
+            fqname=str(fqname),
+            wiki_name=self.wiki_name,
+            user_name=flaskg.user.name0,
+            item_url=url_for_item(self.fqname),
+        )
         self.notification_sentence = L_(MESSAGES[self.action]).format(**kw)
 
     def get_content_diff(self):
-        """ Create a content diff for the last item change
+        """Create a content diff for the last item change
 
         :return: list of diff lines
         """
-        if self.action in [ACTION_TRASH, DESTROY_REV, DESTROY_ALL, ]:
+        if self.action in [ACTION_TRASH, DESTROY_REV, DESTROY_ALL]:
             contenttype = self.meta[CONTENTTYPE]
             oldfile, newfile = self.data, BytesIO(b"")
         else:
@@ -103,6 +116,7 @@ def get_content_diff(self):
                     oldfile = BytesIO(b"")
                 else:
                     from moin.apps.frontend.views import _common_type
+
                     contenttype = _common_type(self.new_meta[CONTENTTYPE], self.meta[CONTENTTYPE])
                     oldfile = self.data
             else:
@@ -111,12 +125,12 @@ def get_content_diff(self):
         return content._get_data_diff_text(oldfile, newfile)
 
     def get_meta_diff(self):
-        """ Create a meta diff for the last item change
+        """Create a meta diff for the last item change
 
         :return: a list of tuples of the format (<change type>, <basekeys>, <value>)
                  that can be used to format a diff
         """
-        if self.action in [ACTION_TRASH, DESTROY_REV, DESTROY_ALL, ]:
+        if self.action in [ACTION_TRASH, DESTROY_REV, DESTROY_ALL]:
             old_meta, new_meta = dict(self.meta), dict()
         else:
             new_meta = dict(self.new_meta)
@@ -128,7 +142,7 @@ def get_meta_diff(self):
         return meta_diff
 
     def generate_diff_url(self, domain):
-        """ Generate the URL that leads to diff page of the last 2 revisions
+        """Generate the URL that leads to diff page of the last 2 revisions
 
         :param domain: domain name
         :return: the absolute URL to the diff page
@@ -138,48 +152,50 @@ def generate_diff_url(self, domain):
         """
         if self.new_data is None or self.data is None:
             return ""
-        diff_rel_url = url_for('frontend.diff', item_name=self.fqname, rev1=self.meta['revid'],
-                               rev2=self.new_meta['revid'])
+        diff_rel_url = url_for(
+            "frontend.diff", item_name=self.fqname, rev1=self.meta["revid"], rev2=self.new_meta["revid"]
+        )
         return urljoin(domain, diff_rel_url)
 
     def render_templates(self, content_diff, meta_diff):
-        """ Render both plain text and HTML templates by providing all the
+        """Render both plain text and HTML templates by providing all the
         necessary arguments
 
         :return: tuple consisting of plain text and HTML notification message
-         """
+        """
         meta_diff_txt = list(make_text_diff(meta_diff))
         domain = self.app.cfg.interwiki_map[self.app.cfg.interwikiname]
-        unsubscribe_url = urljoin(domain, url_for('frontend.subscribe_item',
-                                                  item_name=self.fqname))
+        unsubscribe_url = urljoin(domain, url_for("frontend.subscribe_item", item_name=self.fqname))
         diff_url = self.generate_diff_url(domain)
-        item_url = urljoin(domain, url_for('frontend.show_item', item_name=self.fqname))
-        txt_template = render_template(Notification.txt_template,
-                                       wiki_name=self.wiki_name,
-                                       notification_sentence=self.notification_sentence,
-                                       diff_url=diff_url,
-                                       item_url=item_url,
-                                       comment=self.comment,
-                                       content_diff_=content_diff,
-                                       meta_diff_=meta_diff_txt,
-                                       unsubscribe_url=unsubscribe_url,
-                                       )
-        html_template = render_template(Notification.html_template,
-                                        wiki_name=self.wiki_name,
-                                        notification_sentence=self.notification_sentence,
-                                        diff_url=diff_url,
-                                        item_url=item_url,
-                                        comment=self.comment,
-                                        content_diff_=content_diff,
-                                        meta_diff_=meta_diff,
-                                        unsubscribe_url=unsubscribe_url,
-                                        )
+        item_url = urljoin(domain, url_for("frontend.show_item", item_name=self.fqname))
+        txt_template = render_template(
+            Notification.txt_template,
+            wiki_name=self.wiki_name,
+            notification_sentence=self.notification_sentence,
+            diff_url=diff_url,
+            item_url=item_url,
+            comment=self.comment,
+            content_diff_=content_diff,
+            meta_diff_=meta_diff_txt,
+            unsubscribe_url=unsubscribe_url,
+        )
+        html_template = render_template(
+            Notification.html_template,
+            wiki_name=self.wiki_name,
+            notification_sentence=self.notification_sentence,
+            diff_url=diff_url,
+            item_url=item_url,
+            comment=self.comment,
+            content_diff_=content_diff,
+            meta_diff_=meta_diff,
+            unsubscribe_url=unsubscribe_url,
+        )
         return txt_template, html_template
 
 
 @item_modified.connect_via(ANY)
 def send_notifications(app, fqname, action, data=None, meta=None, new_data=None, new_meta=None, **kwargs):
-    """ Send mail notifications to subscribers on item change
+    """Send mail notifications to subscribers on item change
 
     :param app: local proxy app
     :param fqname: fqname of the changed item
@@ -191,14 +207,10 @@ def send_notifications(app, fqname, action, data=None, meta=None, new_data=None,
     :param kwargs: optional comment
     """
     if new_meta is None:
-        subscribers = {
-            subscriber for subscriber in get_subscribers(**meta)
-            if subscriber.itemid != flaskg.user.itemid
-        }
+        subscribers = {subscriber for subscriber in get_subscribers(**meta) if subscriber.itemid != flaskg.user.itemid}
     else:
         subscribers = {
-            subscriber for subscriber in get_subscribers(**new_meta)
-            if subscriber.itemid != flaskg.user.itemid
+            subscriber for subscriber in get_subscribers(**new_meta) if subscriber.itemid != flaskg.user.itemid
         }
     if not subscribers:
         return
@@ -208,14 +220,14 @@ def send_notifications(app, fqname, action, data=None, meta=None, new_data=None,
     except Exception:
         # current user has likely corrupted an item or fixed a corrupted item
         # if current item is corrupt, another exception will occur in a downstream script
-        content_diff = ['- ' + _('An error has occurred, the current or prior revision of this item may be corrupt.')]
+        content_diff = ["- " + _("An error has occurred, the current or prior revision of this item may be corrupt.")]
     meta_diff = notification.get_meta_diff()
     subscribers_locale = {subscriber.locale for subscriber in subscribers}
     for locale in subscribers_locale:
         with force_locale(locale):
             txt_msg, html_msg = notification.render_templates(content_diff, meta_diff)
             subject = _('[{moin_name}] Update of "{fqname}" by {user_name}').format(
-                        moin_name=app.cfg.interwikiname, fqname=str(fqname), user_name=flaskg.user.name0)
-            subscribers_emails = [subscriber.email for subscriber in subscribers
-                                  if subscriber.locale == locale]
+                moin_name=app.cfg.interwikiname, fqname=str(fqname), user_name=flaskg.user.name0
+            )
+            subscribers_emails = [subscriber.email for subscriber in subscribers if subscriber.locale == locale]
             sendmail(subject, txt_msg, to=subscribers_emails, html=html_msg)
diff --git a/src/moin/utils/paramparser.py b/src/moin/utils/paramparser.py
index 19549c782..f80ffe6f1 100644
--- a/src/moin/utils/paramparser.py
+++ b/src/moin/utils/paramparser.py
@@ -33,6 +33,7 @@ class ParserPrefix:
     the possible prefixes for parse_quoted_separated_ext
     and implementing rich equal comparison.
     """
+
     def __init__(self, prefix):
         self.prefix = prefix
 
@@ -40,12 +41,19 @@ def __eq__(self, other):
         return isinstance(other, ParserPrefix) and other.prefix == self.prefix
 
     def __repr__(self):
-        return '<ParserPrefix({})>'.format(self.prefix.encode('utf-8'))
-
-
-def parse_quoted_separated_ext(args, separator=None, name_value_separator=None,
-                               brackets=None, seplimit=0, multikey=False,
-                               prefixes=None, quotes='"\''):
+        return "<ParserPrefix({})>".format(self.prefix.encode("utf-8"))
+
+
+def parse_quoted_separated_ext(
+    args,
+    separator=None,
+    name_value_separator=None,
+    brackets=None,
+    seplimit=0,
+    multikey=False,
+    prefixes=None,
+    quotes="\"'",
+):
     """
     Parses the given string according to the other parameters.
 
@@ -112,23 +120,23 @@ def parse_quoted_separated_ext(args, separator=None, name_value_separator=None,
     assert name_value_separator is None or name_value_separator != separator
     assert name_value_separator is None or len(name_value_separator) == 1
     if not isinstance(args, str):
-        raise TypeError('args must be str')
+        raise TypeError("args must be str")
     max = len(args)
-    result = []         # result list
-    cur = [None]        # current item
-    quoted = None       # we're inside quotes, indicates quote character used
-    skipquote = 0       # next quote is a quoted quote
-    noquote = False     # no quotes expected because word didn't start with one
+    result = []  # result list
+    cur = [None]  # current item
+    quoted = None  # we're inside quotes, indicates quote character used
+    skipquote = 0  # next quote is a quoted quote
+    noquote = False  # no quotes expected because word didn't start with one
     seplimit_reached = False  # number of separators exhausted
     separator_count = 0  # number of separators encountered
-    SPACE = [' ', '\t', ]
-    nextitemsep = [separator]   # used for skipping trailing space
-    SPACE = [' ', '\t', ]
+    SPACE = [" ", "\t"]
+    nextitemsep = [separator]  # used for skipping trailing space
+    SPACE = [" ", "\t"]
     if separator is None:
         nextitemsep = SPACE[:]
         separators = SPACE
     else:
-        nextitemsep = [separator]   # used for skipping trailing space
+        nextitemsep = [separator]  # used for skipping trailing space
         separators = [separator]
     if name_value_separator:
         nextitemsep.append(name_value_separator)
@@ -169,7 +177,7 @@ def additem(result, cur, separator_count, nextitemsep):
         if skipquote:
             skipquote -= 1
         if separator is not None and not quoted and char in SPACE:
-            spaces = ''
+            spaces = ""
             # accumulate all space
             while char in SPACE and idx < max - 1:
                 spaces += char
@@ -190,18 +198,19 @@ def additem(result, cur, separator_count, nextitemsep):
             else:
                 if not multikey:
                     if cur[-1] is None:
-                        cur[-1] = ''
+                        cur[-1] = ""
                     cur[-1] += name_value_separator
                 else:
                     cur.append(None)
             noquote = False
         elif not quoted and not seplimit_reached and char in separators:
-            (cur, noquote, separator_count, seplimit_reached,
-             nextitemsep) = additem(result, cur, separator_count, nextitemsep)
+            (cur, noquote, separator_count, seplimit_reached, nextitemsep) = additem(
+                result, cur, separator_count, nextitemsep
+            )
         elif not quoted and not noquote and char in quotes:
             if len(cur) and cur[-1] is None:
                 del cur[-1]
-            cur.append('')
+            cur.append("")
             quoted = char
         elif char == quoted and not skipquote:
             if next == quoted:
@@ -211,15 +220,17 @@ def additem(result, cur, separator_count, nextitemsep):
         elif not quoted and char in opening:
             while len(cur) and cur[-1] is None:
                 del cur[-1]
-            (cur, noquote, separator_count, seplimit_reached,
-             nextitemsep) = additem(result, cur, separator_count, nextitemsep)
+            (cur, noquote, separator_count, seplimit_reached, nextitemsep) = additem(
+                result, cur, separator_count, nextitemsep
+            )
             bracketstack.append((matchingbracket[char], result))
             result = [char]
         elif not quoted and char in closing:
             while len(cur) and cur[-1] is None:
                 del cur[-1]
-            (cur, noquote, separator_count, seplimit_reached,
-             nextitemsep) = additem(result, cur, separator_count, nextitemsep)
+            (cur, noquote, separator_count, seplimit_reached, nextitemsep) = additem(
+                result, cur, separator_count, nextitemsep
+            )
             cur = []
             if not bracketstack:
                 raise BracketUnexpectedCloseError(char)
@@ -261,24 +272,24 @@ def additem(result, cur, separator_count, nextitemsep):
     return result
 
 
-def parse_quoted_separated(args, separator=',', name_value=True, seplimit=0):
+def parse_quoted_separated(args, separator=",", name_value=True, seplimit=0):
     result = []
     positional = result
     if name_value:
-        name_value_separator = '='
+        name_value_separator = "="
         trailing = []
         keywords = {}
     else:
         name_value_separator = None
 
-    items = parse_quoted_separated_ext(args, separator=separator,
-                                       name_value_separator=name_value_separator,
-                                       seplimit=seplimit)
+    items = parse_quoted_separated_ext(
+        args, separator=separator, name_value_separator=name_value_separator, seplimit=seplimit
+    )
     for item in items:
         if isinstance(item, tuple):
             key, value = item
             if key is None:
-                key = ''
+                key = ""
             keywords[key] = value
             positional = trailing
         else:
@@ -307,19 +318,17 @@ def get_bool(arg, name=None, default=None):
     if arg is None:
         return default
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
     arg = arg.lower()
-    if arg in ['0', 'false', 'no']:
+    if arg in ["0", "false", "no"]:
         return False
-    elif arg in ['1', 'true', 'yes']:
+    elif arg in ["1", "true", "yes"]:
         return True
     else:
         if name:
-            raise ValueError(
-                _('Argument "{name}" must be a boolean value, not "{value}"').format(name=name, value=arg))
+            raise ValueError(_('Argument "{name}" must be a boolean value, not "{value}"').format(name=name, value=arg))
         else:
-            raise ValueError(
-                _('Argument must be a boolean value, not "{value}"').format(value=arg))
+            raise ValueError(_('Argument must be a boolean value, not "{value}"').format(value=arg))
 
 
 def get_int(arg, name=None, default=None):
@@ -339,16 +348,16 @@ def get_int(arg, name=None, default=None):
     if arg is None:
         return default
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
     try:
         return int(arg)
     except ValueError:
         if name:
             raise ValueError(
-                _('Argument "{name}" must be an integer value, not "{value}"').format(name=name, value=arg))
+                _('Argument "{name}" must be an integer value, not "{value}"').format(name=name, value=arg)
+            )
         else:
-            raise ValueError(
-                _('Argument must be an integer value, not "{value}"').format(value=arg))
+            raise ValueError(_('Argument must be an integer value, not "{value}"').format(value=arg))
 
 
 def get_float(arg, name=None, default=None):
@@ -367,16 +376,16 @@ def get_float(arg, name=None, default=None):
     if arg is None:
         return default
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
     try:
         return float(arg)
     except ValueError:
         if name:
             raise ValueError(
-                _('Argument "{name}" must be a floating point value, not "{value}"').format(name=name, value=arg))
+                _('Argument "{name}" must be a floating point value, not "{value}"').format(name=name, value=arg)
+            )
         else:
-            raise ValueError(
-                _('Argument must be a floating point value, not "{value}"').format(value=arg))
+            raise ValueError(_('Argument must be a floating point value, not "{value}"').format(value=arg))
 
 
 def get_complex(arg, name=None, default=None):
@@ -395,18 +404,16 @@ def get_complex(arg, name=None, default=None):
     if arg is None:
         return default
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
     try:
         # allow writing 'i' instead of 'j'
-        arg = arg.replace('i', 'j').replace('I', 'j')
+        arg = arg.replace("i", "j").replace("I", "j")
         return complex(arg)
     except ValueError:
         if name:
-            raise ValueError(
-                _('Argument "{name}" must be a complex value, not "{value}"').format(name=name, value=arg))
+            raise ValueError(_('Argument "{name}" must be a complex value, not "{value}"').format(name=name, value=arg))
         else:
-            raise ValueError(
-                _('Argument must be a complex value, not "{value}"').format(value=arg))
+            raise ValueError(_('Argument must be a complex value, not "{value}"').format(value=arg))
 
 
 def get_str(arg, name=None, default=None):
@@ -425,7 +432,7 @@ def get_str(arg, name=None, default=None):
     if arg is None:
         return default
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
 
     return arg
 
@@ -454,19 +461,25 @@ def get_choice(arg, name=None, choices=[None], default_none=False):
         else:
             return choices[0]
     elif not isinstance(arg, str):
-        raise TypeError('Argument must be None or str')
+        raise TypeError("Argument must be None or str")
     elif arg not in choices:
         if name:
             raise ValueError(
-                _('Argument "{name}" must be one of "{choices}").format(not "{value}"',
+                _(
+                    'Argument "{name}" must be one of "{choices}").format(not "{value}"',
                     name=name,
                     choices='", "'.join([repr(choice) for choice in choices]),
-                    value=arg))
+                    value=arg,
+                )
+            )
         else:
             raise ValueError(
-                _('Argument must be one of "{choices}").format(not "{value}"',
+                _(
+                    'Argument must be one of "{choices}").format(not "{value}"',
                     choices='", "'.join([repr(choice) for choice in choices]),
-                    value=arg))
+                    value=arg,
+                )
+            )
 
     return arg
 
@@ -476,6 +489,7 @@ class IEFArgument:
     Base class for new argument parsers for
     invoke_extension_function.
     """
+
     def __init__(self):
         pass
 
@@ -507,7 +521,8 @@ class UnitArgument(IEFArgument):
     the default unit. NOTE: This doesn't work with a choice
     (tuple or list) argtype.
     """
-    def __init__(self, default, argtype, units=['mm'], defaultunit=None):
+
+    def __init__(self, default, argtype, units=["mm"], defaultunit=None):
         """
         Initialise a UnitArgument giving the default,
         argument type and the permitted units.
@@ -526,14 +541,14 @@ def __init__(self, default, argtype, units=['mm'], defaultunit=None):
     def parse_argument(self, s):
         for unit in self._units:
             if s.endswith(unit):
-                ret = (self._type(s[:len(s) - len(unit)]), unit)
+                ret = (self._type(s[: len(s) - len(unit)]), unit)
                 return ret
         if self._defaultunit is not None:
             try:
                 return self._type(s), self._defaultunit
             except ValueError:
                 pass
-        units = ', '.join(self._units)
+        units = ", ".join(self._units)
         # XXX: how can we translate this?
         raise ValueError(f"Invalid unit in value {s} (allowed units: {units})")
 
@@ -547,13 +562,13 @@ class required_arg:
     for a function passed to invoke_extension_function() in
     order to get generic checking that the argument is given.
     """
+
     def __init__(self, argtype):
         """
         Initialise a required_arg
         :param argtype: the type the argument should have
         """
-        if not (argtype in (bool, int, float, complex, str) or
-                isinstance(argtype, (IEFArgument, tuple, list))):
+        if not (argtype in (bool, int, float, complex, str) or isinstance(argtype, (IEFArgument, tuple, list))):
             raise TypeError("argtype must be a valid type")
         self.argtype = argtype
 
@@ -644,7 +659,7 @@ def _convert_arg(value, default, name=None):
     elif isclass(function):
         f = function.__init__
     else:
-        raise TypeError('function must be a function, method or class')
+        raise TypeError("function must be a function, method or class")
     argnames, varargs, varkw, defaultlist, kwonlyargs, kwonlydefaults, annotations = getfullargspec(f)
 
     # self is implicit!
@@ -671,10 +686,10 @@ def _convert_arg(value, default, name=None):
     # fill all arguments that weren't given with None
     for idx in range(argc):
         argname = argnames[idx]
-        if argname == '_kwargs':
+        if argname == "_kwargs":
             allow_kwargs = True
             continue
-        if argname == '_trailing_args':
+        if argname == "_trailing_args":
             allow_trailing = True
             continue
         if positional:
@@ -686,14 +701,13 @@ def _convert_arg(value, default, name=None):
 
     if positional:
         if not allow_trailing:
-            raise ValueError(_('Too many arguments'))
+            raise ValueError(_("Too many arguments"))
         trailing_args.extend(positional)
 
     if trailing_args:
         if not allow_trailing:
-            raise ValueError(_('Cannot have arguments without name following'
-                               ' named arguments'))
-        kwargs['_trailing_args'] = trailing_args
+            raise ValueError(_("Cannot have arguments without name following" " named arguments"))
+        kwargs["_trailing_args"] = trailing_args
 
     # type-convert all keyword arguments to the type
     # that the default value indicates
@@ -703,8 +717,7 @@ def _convert_arg(value, default, name=None):
             # macro's 'argname' argument, so convert that giving the
             # name to the converter so the user is told which argument
             # went wrong (if it does)
-            kwargs[argname] = _convert_arg(kwargs[argname],
-                                           defaults[argname], argname)
+            kwargs[argname] = _convert_arg(kwargs[argname], defaults[argname], argname)
             if kwargs[argname] is None:
                 if isinstance(defaults[argname], required_arg):
                     raise ValueError(_('Argument "{name}" is required').format(name=argname))
@@ -717,7 +730,7 @@ def _convert_arg(value, default, name=None):
             del kwargs[argname]
 
     if kwargs_to_pass:
-        kwargs['_kwargs'] = kwargs_to_pass
+        kwargs["_kwargs"] = kwargs_to_pass
         if not allow_kwargs:
             raise ValueError(_('No argument named "{name}"').format(name=list(kwargs_to_pass.keys())[0]))
 
diff --git a/src/moin/utils/plugins.py b/src/moin/utils/plugins.py
index ad8276fe1..203309d58 100644
--- a/src/moin/utils/plugins.py
+++ b/src/moin/utils/plugins.py
@@ -22,19 +22,19 @@
 
 
 class PluginError(Exception):
-    """ Base class for plugin errors """
+    """Base class for plugin errors"""
 
 
 class PluginMissingError(PluginError):
-    """ Raised when a plugin is not found """
+    """Raised when a plugin is not found"""
 
 
 class PluginAttributeError(PluginError):
-    """ Raised when plugin does not contain an attribtue """
+    """Raised when plugin does not contain an attribtue"""
 
 
 def importPlugin(cfg, kind, name, function="execute"):
-    """ Import wiki or builtin plugin
+    """Import wiki or builtin plugin
 
     Returns <function> attr from a plugin module <name>.
     If <function> attr is missing, raise PluginAttributeError.
@@ -63,7 +63,7 @@ def importPlugin(cfg, kind, name, function="execute"):
 
 
 def importWikiPlugin(cfg, kind, name, function="execute"):
-    """ Import plugin from the wiki data directory
+    """Import plugin from the wiki data directory
 
     See importPlugin docstring.
     """
@@ -71,26 +71,26 @@ def importWikiPlugin(cfg, kind, name, function="execute"):
     modname = plugins.get(name, None)
     if modname is None:
         raise PluginMissingError()
-    moduleName = f'{modname}.{name}'
+    moduleName = f"{modname}.{name}"
     return importNameFromPlugin(moduleName, function)
 
 
 def importBuiltinPlugin(kind, name, function="execute"):
-    """ Import builtin plugin from MoinMoin package
+    """Import builtin plugin from MoinMoin package
 
     See importPlugin docstring.
     """
     if name not in builtinPlugins(kind):
         raise PluginMissingError()
-    moduleName = f'moin.{kind}.{name}'
+    moduleName = f"moin.{kind}.{name}"
     return importNameFromPlugin(moduleName, function)
 
 
 def importNameFromPlugin(moduleName, name):
-    """ Return <name> attr from <moduleName> module,
-        raise PluginAttributeError if name does not exist.
+    """Return <name> attr from <moduleName> module,
+    raise PluginAttributeError if name does not exist.
 
-        If name is None, return the <moduleName> module object.
+    If name is None, return the <moduleName> module object.
     """
     if name is None:
         fromlist = []
@@ -105,14 +105,14 @@ def importNameFromPlugin(moduleName, name):
             raise PluginAttributeError
     else:
         # module now has the toplevel module of <moduleName> (see __import__ docs!)
-        components = moduleName.split('.')
+        components = moduleName.split(".")
         for comp in components[1:]:
             module = getattr(module, comp)
         return module
 
 
 def builtinPlugins(kind):
-    """ Gets a list of modules in moin.'kind'
+    """Gets a list of modules in moin.'kind'
 
     :param kind: what kind of modules we look for
     :rtype: list
@@ -145,7 +145,7 @@ def wikiPlugins(kind, cfg):
                 plugins = pysupport.getPluginModules(packagepath)
                 for p in plugins:
                     if p not in result:
-                        result[p] = f'{modname}.{kind}'
+                        result[p] = f"{modname}.{kind}"
             except AttributeError:
                 pass
         cache[kind] = result
@@ -153,7 +153,7 @@ def wikiPlugins(kind, cfg):
 
 
 def getPlugins(kind, cfg):
-    """ Gets a list of plugin names of kind
+    """Gets a list of plugin names of kind
 
     :param kind: what kind of modules we look for
     :rtype: list
@@ -171,8 +171,7 @@ def getPlugins(kind, cfg):
 
 
 def searchAndImportPlugin(cfg, type, name, what=None):
-    type2classname = {
-    }
+    type2classname = {}
     if what is None:
         what = type2classname[type]
     mt = MimeType(name)
@@ -203,9 +202,9 @@ def _loadPluginModule(cfg):
     cfg._plugin_modules = []
     for pdir in cfg.plugin_dirs:
         assert isinstance(pdir, str)
-        modname = 'moin_p_{}'.format(hashlib.new('sha1', pdir.encode()).hexdigest())
+        modname = "moin_p_{}".format(hashlib.new("sha1", pdir.encode()).hexdigest())
         if modname not in sys.modules:
-            init_path = os.path.join(os.path.abspath(pdir), '__init__.py')
+            init_path = os.path.join(os.path.abspath(pdir), "__init__.py")
             spec = importlib.util.spec_from_file_location(modname, init_path)
             if spec is not None:
                 module = importlib.util.module_from_spec(spec)
@@ -217,7 +216,9 @@ def _loadPluginModule(cfg):
 
 Make sure your data directory path is correct, check permissions, and
 that the data/plugin directory has an __init__.py file.
-""" % dict(path=pdir)
+""" % dict(
+                    path=pdir
+                )
                 raise error.ConfigurationError(msg)
         if modname not in cfg._plugin_modules:
             cfg._plugin_modules.append(modname)
diff --git a/src/moin/utils/profile.py b/src/moin/utils/profile.py
index a5c1a18c3..6031c1192 100644
--- a/src/moin/utils/profile.py
+++ b/src/moin/utils/profile.py
@@ -44,7 +44,7 @@
 
 
 class Profiler:
-    """ Profile memory usage
+    """Profile memory usage
 
     Profiler count requests and sample memory usage.
 
@@ -52,24 +52,25 @@ class Profiler:
     data dir, but the data dir is available only later in request. This
     should be fixed by loading the config earlier.
     """
+
     def __init__(self, name, requestsPerSample=100, collect=0):
-        """ Initialize a profiler
+        """Initialize a profiler
 
         :param name: profiler name, used in the log file name
         :param requestsPerSample: how many request to run between samples
         :param collect: should call gc.collect() in each sample
         """
-        logname = '{}--{}.log'.format(name, time.strftime('%Y-%m-%d--%H-%M'))
-        self.logfile = open(logname, 'a')
+        logname = "{}--{}.log".format(name, time.strftime("%Y-%m-%d--%H-%M"))
+        self.logfile = open(logname, "a")
         self.requestsPerSample = requestsPerSample
         self.collect = collect
         self.pid = os.getpid()
         self.count = 0  # count between somples
         self.requests = 0  # requests added
-        self.data = {'collect': 'NA'}  # Sample data
+        self.data = {"collect": "NA"}  # Sample data
 
     def addRequest(self):
-        """ Add a request to the profile
+        """Add a request to the profile
 
         Call this for each page request.
 
@@ -86,7 +87,7 @@ def addRequest(self):
             self.sample()
 
     def sample(self):
-        """ Make a sample of memory usage and log it
+        """Make a sample of memory usage and log it
 
         You can call this to make samples between the samples done each
         requestsPerSample, for example, at startup.
@@ -101,59 +102,62 @@ def sample(self):
     # Private methods ------------------------------------------------------
 
     def _setData(self):
-        """ Collect sample data into self.data
+        """Collect sample data into self.data
 
         Private method used by profilers.
         """
         d = self.data
-        d['date'] = time.strftime('%Y-%m-%d %H:%M:%S')
-        d['requests'] = self.requests
+        d["date"] = time.strftime("%Y-%m-%d %H:%M:%S")
+        d["requests"] = self.requests
         if self.collect:
-            d['collect'] = str(gc.collect())
-        d['objects'] = len(gc.get_objects())
-        d['garbage'] = len(gc.garbage)
+            d["collect"] = str(gc.collect())
+        d["objects"] = len(gc.get_objects())
+        d["garbage"] = len(gc.garbage)
 
     def _setMemory(self):
-        """ Get process memory usage
+        """Get process memory usage
 
         Private method used by profilers.
 
         Uses ps call, maybe we should use procfs on Linux or maybe
         getrusage system call (using the ctypes module).
         """
-        lines = os.popen(f'/bin/ps -p {self.pid} -o rss').readlines()
-        self.data['memory'] = lines[1].strip()
+        lines = os.popen(f"/bin/ps -p {self.pid} -o rss").readlines()
+        self.data["memory"] = lines[1].strip()
 
     def _log(self):
-        """ Format sample and write to log
+        """Format sample and write to log
 
         Private method used by profilers.
         """
-        line = ('%(date)s req:%(requests)d mem:%(memory)sKB collect:%(collect)s '
-                'objects:%(objects)d garbage:%(garbage)d\n' % self.data)
+        line = (
+            "%(date)s req:%(requests)d mem:%(memory)sKB collect:%(collect)s "
+            "objects:%(objects)d garbage:%(garbage)d\n" % self.data
+        )
         self.logfile.write(line)
         self.logfile.flush()
 
 
 class TwistedProfiler(Profiler):
-    """ Twisted specific memory profiler
+    """Twisted specific memory profiler
 
     Customize the way we call ps, to overcome blocking problems on
     twisted.
     """
 
     def __init__(self, name, requestsPerSample=100, collect=0):
-        """ Initialized twisted profiler
+        """Initialized twisted profiler
 
         Invoke Profiler.__init__ and import getProcessOuput from
         twisted.
         """
         Profiler.__init__(self, name, requestsPerSample, collect)
         from twisted.internet.utils import getProcessOutput
+
         self._getProcessOutput = getProcessOutput
 
     def sample(self):
-        """ Make a sample of memory usage and log it
+        """Make a sample of memory usage and log it
 
         On twisted we can't just call ps - we have to use deferred,
         which will call us using a callback when its finished, and then
@@ -164,21 +168,20 @@ def sample(self):
         """
         self._setData()
         # Memory will be available little later
-        deferred = self._getProcessOutput('/bin/ps',
-                                          ('-p', str(self.pid), '-o', 'rss'))
+        deferred = self._getProcessOutput("/bin/ps", ("-p", str(self.pid), "-o", "rss"))
         deferred.addCallback(self._callback)
 
     # Private methods ------------------------------------------------------
 
     def _callback(self, data):
-        """ Called from deferred when ps output is available
+        """Called from deferred when ps output is available
 
         Private method, don't call this.
         """
-        self.data['memory'] = data.split('\n')[1].strip()
+        self.data["memory"] = data.split("\n")[1].strip()
         self._log()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # In case someone try to run as a script
     print(__doc__)
diff --git a/src/moin/utils/pysupport.py b/src/moin/utils/pysupport.py
index b922127d4..8d6a454be 100644
--- a/src/moin/utils/pysupport.py
+++ b/src/moin/utils/pysupport.py
@@ -16,6 +16,7 @@
 # Module import / Plugins
 #############################################################################
 
+
 def load_package_modules(package_name, package_pathes):
     """
     Load (import) all modules from some package (except those starting with _).
@@ -30,15 +31,14 @@ def load_package_modules(package_name, package_pathes):
     assert isinstance(package_pathes, (list, tuple))
     for path in package_pathes:
         for fname in os.listdir(path):
-            if fname.endswith('.py') and not fname.startswith('_'):
-                module = package_name + '.' + fname[:-3]
+            if fname.endswith(".py") and not fname.startswith("_"):
+                module = package_name + "." + fname[:-3]
                 if module not in sys.modules:
                     importlib.import_module(module)
 
 
 def isImportable(module):
-    """ Check whether a certain module is available.
-    """
+    """Check whether a certain module is available."""
     try:
         __import__(module)
         return 1
@@ -60,8 +60,8 @@ def getPluginModules(packagedir):
 
 
 def getPackageModules(packagefile):
-    """ Return a list of modules for a package, omitting any modules
-        starting with an underscore.
+    """Return a list of modules for a package, omitting any modules
+    starting with an underscore.
     """
     packagedir = os.path.dirname(packagefile)
     dirlist = os.listdir(packagedir)
@@ -72,7 +72,7 @@ def getPackageModules(packagefile):
 
 
 def importName(modulename, name):
-    """ Import name dynamically from module
+    """Import name dynamically from module
 
     Used to do dynamic import of modules and names that you know their
     names only in runtime.
@@ -89,7 +89,7 @@ def importName(modulename, name):
 
 
 def makeThreadSafe(function, lock=None):
-    """ Call with a function you want to make thread safe
+    """Call with a function you want to make thread safe
 
     Call without lock to make the function thread safe using one lock per
     function. Call with existing lock object if you want to make several
@@ -103,6 +103,7 @@ def makeThreadSafe(function, lock=None):
     """
     if lock is None:
         import threading
+
         lock = threading.Lock()
 
     def decorated(*args, **kw):
@@ -119,6 +120,7 @@ class AutoNe:
     """
     Implement __ne__ in terms of __eq__. This is a mixin class.
     """
+
     def __ne__(self, other):
         ret = self.__eq__(other)
         if ret is NotImplemented:
diff --git a/src/moin/utils/registry.py b/src/moin/utils/registry.py
index a4dab8bde..04f0d1973 100644
--- a/src/moin/utils/registry.py
+++ b/src/moin/utils/registry.py
@@ -20,7 +20,7 @@ class RegistryBase:
     PRIORITY_LAST = 10
     PRIORITY_REALLY_LAST = 20
 
-    class Entry(namedtuple('Entry', 'factory priority')):
+    class Entry(namedtuple("Entry", "factory priority")):
         def __call__(self, *args, **kw):
             return self.factory(*args, **kw)
 
@@ -33,7 +33,7 @@ def __init__(self):
         self._entries = []
 
     def __repr__(self):
-        return f'<{self.__class__.__name__}: {self._entries!r}>'
+        return f"<{self.__class__.__name__}: {self._entries!r}>"
 
     def get(self, *args, **kw):
         """
diff --git a/src/moin/utils/rev_navigation.py b/src/moin/utils/rev_navigation.py
index a45348eb4..b188e6807 100644
--- a/src/moin/utils/rev_navigation.py
+++ b/src/moin/utils/rev_navigation.py
@@ -18,19 +18,19 @@ def prior_next_revs(revid, fqname):
     return prior, current, and next revids and time stamps else return None * 6.
     """
     try:
-        show_revision = request.view_args['rev'] != CURRENT
+        show_revision = request.view_args["rev"] != CURRENT
     except KeyError:
         # maintenance scripts, such as dump-html, have request.view_args == {}
         show_revision = False
     if show_revision:
-        terms = [Term(WIKINAME, app.cfg.interwikiname), ]
+        terms = [Term(WIKINAME, app.cfg.interwikiname)]
         terms.extend(Term(term, value) for term, value in fqname.query.items())
         query = And(terms)
         revs = flaskg.storage.search(query, idx_name=ALL_REVS, sortedby=[MTIME], reverse=True, limit=None)
         rev_ids = []
         mtimes = []
         for rev in revs:
-            mtimes.append(dict(rev.meta)['mtime'])
+            mtimes.append(dict(rev.meta)["mtime"])
             rev_ids.append(rev.revid)
         prior_rev = next_rev = prior_mtime = next_mtime = None
         current_idx = rev_ids.index(revid)
@@ -42,4 +42,4 @@ def prior_next_revs(revid, fqname):
             prior_rev = rev_ids[current_idx + 1]
             prior_mtime = mtimes[current_idx + 1]
         return (prior_rev, revid, next_rev, prior_mtime, current_mtime, next_mtime)
-    return (None, ) * 6
+    return (None,) * 6
diff --git a/src/moin/utils/send_file.py b/src/moin/utils/send_file.py
index 26becf412..fa1c0f3ad 100644
--- a/src/moin/utils/send_file.py
+++ b/src/moin/utils/send_file.py
@@ -31,7 +31,7 @@
 from flask import current_app, request
 
 
-def encode_rfc2231(value, coding='UTF-8', lang=''):
+def encode_rfc2231(value, coding="UTF-8", lang=""):
     """
     Encode a value according to RFC2231/5987.
 
@@ -42,11 +42,18 @@ def encode_rfc2231(value, coding='UTF-8', lang=''):
     return f"{coding}'{lang}'{quote(value, encoding=coding)}"
 
 
-def send_file(filename=None, file=None,
-              mimetype=None,
-              as_attachment=False, attachment_filename=None,
-              mtime=None, cache_timeout=60 * 60 * 12,
-              add_etags=True, etag=None, conditional=False):
+def send_file(
+    filename=None,
+    file=None,
+    mimetype=None,
+    as_attachment=False,
+    attachment_filename=None,
+    mtime=None,
+    cache_timeout=60 * 60 * 12,
+    add_etags=True,
+    etag=None,
+    conditional=False,
+):
     """Sends the contents of a file to the client.
 
     A file can be either a filesystem file or a file-like object (this code
@@ -113,7 +120,7 @@ def send_file(filename=None, file=None,
     if mimetype is None and (filename or attachment_filename):
         mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
     if mimetype is None:
-        mimetype = 'application/octet-stream'
+        mimetype = "application/octet-stream"
 
     headers = Headers()
 
@@ -122,7 +129,7 @@ def send_file(filename=None, file=None,
     # See `_ensure_sequence` in werkzeug/wrappers.py
     if filename:
         fsize = os.path.getsize(filename)
-    elif file and hasattr(file, 'seek') and hasattr(file, 'tell'):
+    elif file and hasattr(file, "seek") and hasattr(file, "tell"):
         fsize = None
         # be extra careful as some file-like objects (like zip members) have a seek
         # and tell methods, but they just raise some exception (e.g. UnsupportedOperation)
@@ -139,27 +146,27 @@ def send_file(filename=None, file=None,
     else:
         fsize = None
     if fsize is not None:
-        headers.add('Content-Length', fsize)
+        headers.add("Content-Length", fsize)
 
     if as_attachment:
         if attachment_filename is None:
             if not filename:
-                raise TypeError('filename unavailable, required for sending as attachment')
+                raise TypeError("filename unavailable, required for sending as attachment")
             attachment_filename = os.path.basename(filename)
         # Note: we only give filename* param, not filename param, hoping that a user agent that
         # does not support filename* then falls back into using the last URL fragment (and decodes
         # that correctly). See there for details: http://greenbytes.de/tech/tc2231/
-        headers.add('Content-Disposition', f'attachment; filename*={encode_rfc2231(attachment_filename)}')
+        headers.add("Content-Disposition", f"attachment; filename*={encode_rfc2231(attachment_filename)}")
 
-    if current_app.config['USE_X_SENDFILE'] and filename:
+    if current_app.config["USE_X_SENDFILE"] and filename:
         if file:
             file.close()
-        headers['X-Sendfile'] = filename
+        headers["X-Sendfile"] = filename
         data = None
     else:
         if filename:
             if not file:
-                file = open(filename, 'rb')
+                file = open(filename, "rb")
             if mtime is None:
                 mtime = os.path.getmtime(filename)
         data = wrap_file(request.environ, file)
@@ -183,10 +190,8 @@ def send_file(filename=None, file=None,
     if add_etags:
         if etag is None and filename:
             filename_encoded = filename if isinstance(filename, bytes) else filename.encode()
-            etag = 'flask-{}-{}-{}'.format(
-                mtime or os.path.getmtime(filename),
-                os.path.getsize(filename),
-                adler32(filename_encoded) & 0xffffffff
+            etag = "flask-{}-{}-{}".format(
+                mtime or os.path.getmtime(filename), os.path.getsize(filename), adler32(filename_encoded) & 0xFFFFFFFF
             )
         if etag is None:
             raise TypeError("can't determine etag - please give etag or filename")
@@ -196,5 +201,5 @@ def send_file(filename=None, file=None,
             # make sure we don't send x-sendfile for servers that
             # ignore the 304 status code for x-sendfile.
             if rv.status_code == 304:
-                rv.headers.pop('x-sendfile', None)
+                rv.headers.pop("x-sendfile", None)
     return rv
diff --git a/src/moin/utils/show_time.py b/src/moin/utils/show_time.py
index 35ec9b8f9..1a6db3d8a 100644
--- a/src/moin/utils/show_time.py
+++ b/src/moin/utils/show_time.py
@@ -34,7 +34,7 @@ def duration(seconds):
     return _("years"), (seconds + 15768000) // 31536000
 
 
-def format_date_time(utc_dt=None, fmt='yyyy-MM-dd HH:mm:ss', interval='datetime'):
+def format_date_time(utc_dt=None, fmt="yyyy-MM-dd HH:mm:ss", interval="datetime"):
     """
     Add an ISO 8601 alternative to babel's date/time formatting.
 
@@ -58,26 +58,26 @@ def format_date_time(utc_dt=None, fmt='yyyy-MM-dd HH:mm:ss', interval='datetime'
 
     if not flaskg.user.valid:
         # users who are not logged-in get moin version of ISO 8601: 2019-07-15 07:08:09z
-        return flask_babel.format_datetime(utc_dt, fmt) + 'z'
+        return flask_babel.format_datetime(utc_dt, fmt) + "z"
 
     if flaskg.user.iso_8601:
-        suffix = ''
+        suffix = ""
         user_tz = i18n.get_timezone()
         if user_tz:
             if pytz.timezone(user_tz) == pytz.utc:
-                suffix = 'z'
+                suffix = "z"
         return flask_babel.format_datetime(utc_dt, fmt) + suffix
 
-    if interval == 'date':
+    if interval == "date":
         return flask_babel.format_date(utc_dt)
-    elif interval == 'time':
+    elif interval == "time":
         return flask_babel.format_time(utc_dt)
     return flask_babel.format_datetime(utc_dt)
 
 
-def format_date(utc_dt=None, fmt='yyyy-MM-dd', interval='date'):
+def format_date(utc_dt=None, fmt="yyyy-MM-dd", interval="date"):
     return format_date_time(utc_dt=utc_dt, fmt=fmt, interval=interval)
 
 
-def format_time(utc_dt=None, fmt='HH:mm:ss', interval='time'):
+def format_time(utc_dt=None, fmt="HH:mm:ss", interval="time"):
     return format_date_time(utc_dt=utc_dt, fmt=fmt, interval=interval)
diff --git a/src/moin/utils/subscriptions.py b/src/moin/utils/subscriptions.py
index 6c3287ce0..53c828b4e 100644
--- a/src/moin/utils/subscriptions.py
+++ b/src/moin/utils/subscriptions.py
@@ -13,21 +13,33 @@
 
 from whoosh.query import Term, Or
 
-from moin.constants.keys import (DEFAULT_LOCALE, EMAIL, ITEMID, LATEST_REVS, LOCALE,
-                                 NAME, NAMERE, NAMEPREFIX, NAMESPACE, SUBSCRIPTION_IDS,
-                                 SUBSCRIPTION_PATTERNS, TAGS)
+from moin.constants.keys import (
+    DEFAULT_LOCALE,
+    EMAIL,
+    ITEMID,
+    LATEST_REVS,
+    LOCALE,
+    NAME,
+    NAMERE,
+    NAMEPREFIX,
+    NAMESPACE,
+    SUBSCRIPTION_IDS,
+    SUBSCRIPTION_PATTERNS,
+    TAGS,
+)
 
 from moin.utils.interwiki import CompositeName
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
-Subscriber = namedtuple('Subscriber', [ITEMID, NAME, EMAIL, LOCALE])
+Subscriber = namedtuple("Subscriber", [ITEMID, NAME, EMAIL, LOCALE])
 
 
 def get_subscribers(**meta):
-    """ Get all users that are subscribed to the item
+    """Get all users that are subscribed to the item
 
     :param meta: key/value pairs from item metadata - itemid, name, namespace, tags keys
     :return: a set of Subscriber objects
@@ -42,18 +54,15 @@ def get_subscribers(**meta):
         terms.extend([Term(SUBSCRIPTION_IDS, f"{ITEMID}:{itemid}")])
     if namespace is not None:
         if name is not None:
-            terms.extend(Term(SUBSCRIPTION_IDS, f"{NAME}:{namespace}:{name_}")
-                         for name_ in name)
+            terms.extend(Term(SUBSCRIPTION_IDS, f"{NAME}:{namespace}:{name_}") for name_ in name)
         if tags is not None:
-            terms.extend(Term(SUBSCRIPTION_IDS, f"{TAGS}:{namespace}:{tag}")
-                         for tag in tags)
+            terms.extend(Term(SUBSCRIPTION_IDS, f"{TAGS}:{namespace}:{tag}") for tag in tags)
     query = Or(terms)
     with flaskg.storage.indexer.ix[LATEST_REVS].searcher() as searcher:
-        result_iterators = [searcher.search(query, limit=None), ]
+        result_iterators = [searcher.search(query, limit=None)]
         subscription_patterns = searcher.lexicon(SUBSCRIPTION_PATTERNS)
         # looks like whoosh gives us bytes (not str), decode them:
-        subscription_patterns = [p if isinstance(p, str) else p.decode()
-                                 for p in subscription_patterns]
+        subscription_patterns = [p if isinstance(p, str) else p.decode() for p in subscription_patterns]
         patterns = get_matched_subscription_patterns(subscription_patterns, **meta)
         result_iterators.extend(searcher.documents(subscription_patterns=pattern) for pattern in patterns)
         subscribers = set()
@@ -61,6 +70,7 @@ def get_subscribers(**meta):
             email = user.get(EMAIL)
             if email:
                 from moin.user import User
+
                 u = User(uid=user.get(ITEMID))
                 if u.may.read(fqname):
                     locale = user.get(LOCALE, DEFAULT_LOCALE)
@@ -69,7 +79,7 @@ def get_subscribers(**meta):
 
 
 def get_matched_subscription_patterns(subscription_patterns, **meta):
-    """ Get all the subscriptions with patterns that match at least one of item names
+    """Get all the subscriptions with patterns that match at least one of item names
 
     :param subscription_patterns: a list of subscription patterns (the ones that
                                     start with NAMERE or NAMEPREFIX)
@@ -85,7 +95,7 @@ def get_matched_subscription_patterns(subscription_patterns, **meta):
         except ValueError:
             logging.exception(f"User {flaskg.user.name[0]} has invalid subscription entry: {subscription}")
             continue
-        if keyword in (NAMEPREFIX, NAMERE, ) and item_namespace is not None and item_names:
+        if keyword in (NAMEPREFIX, NAMERE) and item_namespace is not None and item_names:
             try:
                 namespace, pattern = value.split(":", 1)
             except ValueError:
diff --git a/src/moin/utils/thread_monitor.py b/src/moin/utils/thread_monitor.py
index 3c9f235bc..55524fe5c 100644
--- a/src/moin/utils/thread_monitor.py
+++ b/src/moin/utils/thread_monitor.py
@@ -26,13 +26,13 @@ def __init__(self):
         assert hasattr(sys, "_current_frames")  # make sure we have py >= 2.5
 
     def activate_hook(self):
-        """ Activates the thread monitor hook. Note that this might interfere
-        with any kind of profiler and some debugging extensions. """
+        """Activates the thread monitor hook. Note that this might interfere
+        with any kind of profiler and some debugging extensions."""
         self.enabled = True
 
     def trigger_dump(self, dumpfile=None):
-        """ Triggers the dump of the tracebacks of all threads.
-            If dumpfile is specified, it is used as the output file. """
+        """Triggers the dump of the tracebacks of all threads.
+        If dumpfile is specified, it is used as the output file."""
         if not self.enabled:
             return
         dumpfile = dumpfile or sys.stderr
@@ -44,12 +44,12 @@ def trigger_dump(self, dumpfile=None):
             dumpfile.write(f.getvalue())
 
     def hook_enabled(self):
-        """ Returns true if the thread_monitor hook is enabled. """
+        """Returns true if the thread_monitor hook is enabled."""
         return self.enabled
 
 
 def dump_regularly(seconds):
-    """ Dumps the tracebacks every 'seconds' seconds. """
+    """Dumps the tracebacks every 'seconds' seconds."""
     activate_hook()
 
     def background_dumper(seconds):
@@ -57,7 +57,7 @@ def background_dumper(seconds):
             sleep(seconds)
             trigger_dump()
 
-    threading.Thread(target=background_dumper, args=(seconds, )).start()
+    threading.Thread(target=background_dumper, args=(seconds,)).start()
 
 
 mon = Monitor()
diff --git a/src/moin/utils/tree.py b/src/moin/utils/tree.py
index 9edab94ef..9d7e788f7 100644
--- a/src/moin/utils/tree.py
+++ b/src/moin/utils/tree.py
@@ -13,6 +13,7 @@ class Name(ET.QName):
     """
     Represents a QName and factory for elements with this QName
     """
+
     def __call__(self, attrib=None, children=(), **extra):
         return ET.Element(self, attrib=attrib, children=children, **extra)
 
@@ -21,6 +22,7 @@ class Namespace(str):
     """
     Represents a namespace and factory for Names within this namespace
     """
+
     def __call__(self, name):
         """
         Create a Name within this namespace
@@ -41,16 +43,16 @@ def __getattr__(self, key):
 
         :returns: A Name
         """
-        if '_' in key:
-            if key.startswith('_'):
+        if "_" in key:
+            if key.startswith("_"):
                 raise AttributeError(key)
-            if key.endswith('_'):
+            if key.endswith("_"):
                 key = key[:-1]
-            key = key.replace('_', '-')
+            key = key.replace("_", "-")
         return Name(key, self)
 
     def __repr__(self):
-        return f'<{self.__class__.__name__}({str(self)!r})>'
+        return f"<{self.__class__.__name__}({str(self)!r})>"
 
     @property
     def namespace(self):
@@ -74,14 +76,14 @@ def namespace(self):
 #    the mathml namespace is not used
 #    the svg namespace is not used
 
-moin_page = Namespace('http://moinmo.in/namespaces/page')
+moin_page = Namespace("http://moinmo.in/namespaces/page")
 
 # Well-known namespaces
-dc = Namespace('http://purl.org/dc/elements/1.1/')
-html = Namespace('http://www.w3.org/1999/xhtml')
-mathml = Namespace('http://www.w3.org/1998/Math/MathML')
-svg = Namespace('http://www.w3.org/2000/svg')
-xinclude = Namespace('http://www.w3.org/2001/XInclude')
-xlink = Namespace('http://www.w3.org/1999/xlink')
-docbook = Namespace('http://docbook.org/ns/docbook')
-xml = Namespace('http://www.w3.org/XML/1998/namespace')
+dc = Namespace("http://purl.org/dc/elements/1.1/")
+html = Namespace("http://www.w3.org/1999/xhtml")
+mathml = Namespace("http://www.w3.org/1998/Math/MathML")
+svg = Namespace("http://www.w3.org/2000/svg")
+xinclude = Namespace("http://www.w3.org/2001/XInclude")
+xlink = Namespace("http://www.w3.org/1999/xlink")
+docbook = Namespace("http://docbook.org/ns/docbook")
+xml = Namespace("http://www.w3.org/XML/1998/namespace")
diff --git a/src/moin/wikiutil.py b/src/moin/wikiutil.py
index e43ef4040..e75c2e8cf 100644
--- a/src/moin/wikiutil.py
+++ b/src/moin/wikiutil.py
@@ -24,6 +24,7 @@
 from moin.utils.mimetype import MimeType
 
 from moin import log
+
 logging = log.getLogger(__name__)
 
 
@@ -38,20 +39,21 @@
 # Data validation / cleanup
 #############################################################################
 
+
 # TODO: use similar code in a flatland validator
 def clean_input(text, max_len=201):
-    """ Clean input:
-        replace CR, LF, TAB by whitespace
-        delete control chars
+    """Clean input:
+    replace CR, LF, TAB by whitespace
+    delete control chars
 
-        :param text: unicode text to clean (if we get str, we decode)
-        :rtype: unicode
-        :returns: cleaned text
+    :param text: unicode text to clean (if we get str, we decode)
+    :rtype: unicode
+    :returns: cleaned text
     """
     # we only have input fields with max 200 chars, but spammers send us more
     length = len(text)
     if length == 0 or length > max_len:
-        return ''
+        return ""
     else:
         if isinstance(text, bytes):
             # the translate() below can ONLY process unicode, thus, if we get
@@ -62,7 +64,7 @@ def clean_input(text, max_len=201):
 
 # TODO: use similar code in a flatland validator
 def normalize_pagename(name, cfg):
-    """ Normalize page name
+    """Normalize page name
 
     Prevent creating page names with invisible characters or funny
     whitespace that might confuse the users or abuse the wiki, or
@@ -75,10 +77,10 @@ def normalize_pagename(name, cfg):
     :returns: decoded and sanitized page name
     """
     # Strip invalid characters
-    name = ITEM_INVALID_CHARS_REGEX.sub('', name)
+    name = ITEM_INVALID_CHARS_REGEX.sub("", name)
 
     # Split to pages and normalize each one
-    pages = name.split('/')
+    pages = name.split("/")
     normalized = []
     for page in pages:
         # Ignore empty or whitespace only pages
@@ -88,18 +90,17 @@ def normalize_pagename(name, cfg):
         # Cleanup group pages.
         # Strip non alpha numeric characters, keep white space
         if isGroupItem(page):
-            page = ''.join([c for c in page
-                            if c.isalnum() or c.isspace()])
+            page = "".join([c for c in page if c.isalnum() or c.isspace()])
 
         # Normalize white space. Each name can contain multiple
         # words separated with only one space. Split handle all
         # 30 unicode spaces (isspace() == True)
-        page = ' '.join(page.split())
+        page = " ".join(page.split())
 
         normalized.append(page)
 
     # Assemble components into full pagename
-    name = '/'.join(normalized)
+    name = "/".join(normalized)
     return name
 
 
@@ -107,8 +108,9 @@ def normalize_pagename(name, cfg):
 # Item types / Item names
 #############################################################################
 
+
 def isGroupItem(itemname):
-    """ Is this a name of group item?
+    """Is this a name of group item?
 
     :param itemname: the item name
     :rtype: bool
@@ -128,12 +130,12 @@ def AbsItemName(context, itemname):
     """
     if itemname.startswith(PARENT_PREFIX):
         while context and itemname.startswith(PARENT_PREFIX):
-            context = '/'.join(context.split('/')[:-1])
+            context = "/".join(context.split("/")[:-1])
             itemname = itemname[PARENT_PREFIX_LEN:]
-        itemname = '/'.join([e for e in [context, itemname, ] if e])
+        itemname = "/".join([e for e in [context, itemname] if e])
     elif itemname.startswith(CHILD_PREFIX):
         if context:
-            itemname = context + '/' + itemname[CHILD_PREFIX_LEN:]
+            itemname = context + "/" + itemname[CHILD_PREFIX_LEN:]
         else:
             itemname = itemname[CHILD_PREFIX_LEN:]
     return itemname
@@ -148,17 +150,17 @@ def RelItemName(context, itemname):
     :rtype: unicode
     :returns: the relative item name
     """
-    if context == '':
+    if context == "":
         # special case, context is some "virtual root" item with name == ''
         # every item is a subitem of this virtual root
         return CHILD_PREFIX + itemname
     elif itemname.startswith(context + CHILD_PREFIX):
         # simple child
-        return itemname[len(context):]
+        return itemname[len(context) :]
     else:
         # some kind of sister/aunt
-        context_frags = context.split('/')   # A, B, C, D, E
-        itemname_frags = itemname.split('/')  # A, B, C, F
+        context_frags = context.split("/")  # A, B, C, D, E
+        itemname_frags = itemname.split("/")  # A, B, C, F
         # first throw away common parents:
         common = 0
         for cf, pf in zip(context_frags, itemname_frags):
@@ -169,7 +171,7 @@ def RelItemName(context, itemname):
         context_frags = context_frags[common:]  # D, E
         itemname_frags = itemname_frags[common:]  # F
         go_up = len(context_frags)
-        return PARENT_PREFIX * go_up + '/'.join(itemname_frags)
+        return PARENT_PREFIX * go_up + "/".join(itemname_frags)
 
 
 def ParentItemName(itemname):
@@ -181,22 +183,23 @@ def ParentItemName(itemname):
     :returns: the parent item name (or empty string for toplevel items)
     """
     if itemname:
-        pos = itemname.rfind('/')
+        pos = itemname.rfind("/")
         if pos > 0:
             return itemname[:pos]
-    return ''
+    return ""
 
 
 #############################################################################
 # Misc
 #############################################################################
 
+
 def drawing2fname(drawing):
     _, ext = os.path.splitext(drawing)
     # note: do not just check for empty extension or stuff like drawing:foo.bar
     # will fail, instead of being expanded to foo.bar.svgdraw
     if ext not in DRAWING_EXTENSIONS:
-        drawing += '.svgdraw'
+        drawing += ".svgdraw"
     return drawing
 
 
@@ -210,30 +213,30 @@ def getUnicodeIndexGroup(name):
     :returns: group letter or None
     """
     c = name[0]
-    if '\uAC00' <= c <= '\uD7AF':  # Hangul Syllables
-        return chr(0xac00 + (int(ord(c) - 0xac00) / 588) * 588)
+    if "\uAC00" <= c <= "\uD7AF":  # Hangul Syllables
+        return chr(0xAC00 + (int(ord(c) - 0xAC00) / 588) * 588)
     else:
         return c.upper()  # we put lower and upper case words into the same index group
 
 
 def is_URL(arg, schemes=URI_SCHEMES):
-    """ Return True if arg is a URL (with a scheme given in the schemes list).
+    """Return True if arg is a URL (with a scheme given in the schemes list).
 
-        Note: there are not that many requirements for generic URLs, basically
-        the only mandatory requirement is the ':' between scheme and rest.
-        Scheme itself could be anything, also the rest (but we only support some
-        schemes, as given in URI_SCHEMES, so it is a bit less ambiguous).
+    Note: there are not that many requirements for generic URLs, basically
+    the only mandatory requirement is the ':' between scheme and rest.
+    Scheme itself could be anything, also the rest (but we only support some
+    schemes, as given in URI_SCHEMES, so it is a bit less ambiguous).
     """
-    if ':' not in arg:
+    if ":" not in arg:
         return False
     for scheme in schemes:
-        if arg.startswith(scheme + ':'):
+        if arg.startswith(scheme + ":"):
             return True
     return False
 
 
 def containsConflictMarker(text):
-    """ Returns true if there is a conflict marker in the text. """
+    """Returns true if there is a conflict marker in the text."""
     return "/!\\ '''Edit conflict" in text
 
 
@@ -246,10 +249,10 @@ def anchor_name_from_text(text):
     valid ID/name, it will return it without modification (identity
     transformation).
     """
-    quoted = urllib.parse.quote_plus(text, safe=':', encoding='utf-7', )
-    res = quoted.replace('%', '.').replace('+', '_')
+    quoted = urllib.parse.quote_plus(text, safe=":", encoding="utf-7")
+    res = quoted.replace("%", ".").replace("+", "_")
     if not res[:1].isalpha():
-        return f'A{res}'
+        return f"A{res}"
     return res
 
 
@@ -273,7 +276,7 @@ def split_anchor(pagename):
           pagename part (and no anchor). Also, we need to append #anchor
           at the END of the generated URL (AFTER the query string).
     """
-    parts = pagename.rsplit('#', 1)
+    parts = pagename.rsplit("#", 1)
     if len(parts) == 2:
         return parts
     else:
@@ -290,6 +293,7 @@ def get_hostname(addr):
     """
     if app.cfg.log_reverse_dns_lookups:
         import socket
+
         try:
             return str(socket.gethostbyaddr(addr)[0], CHARSET)
         except (OSError, UnicodeError):
@@ -315,11 +319,11 @@ def file_headers(filename=None, content_type=None, content_length=None):
         if mt is not None:
             content_type = mt.content_type()
         else:
-            content_type = 'application/octet-stream'
+            content_type = "application/octet-stream"
     else:
         mt = MimeType(mimestr=content_type)
 
-    headers = [('Content-Type', content_type)]
+    headers = [("Content-Type", content_type)]
     if content_length is not None:
-        headers.append(('Content-Length', str(content_length)))
+        headers.append(("Content-Length", str(content_length)))
     return headers