Merge ~cjwatson/launchpad:black-utilities into launchpad:master

[Colin Watson]

utilities: Apply black

[Colin Watson (cjwatson)]

Self-approving based on previous discussions.

review: Approve

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 2c740b8..40d232e 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -98,3 +98,5 @@ b56a741985ca580c281f142bea589b1ef05d3e93
 0bf877facbd96ece340dd26a7429ebbf0fb9b65a
 # apply black to {cronscripts,scripts}
 86d834967ddae3eecd13deda5ac9eefea538195d
+# apply black to utilities
+35ac52c1c63d184b4660abbab4bead59408d3937
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 4cc7030..b925ca3 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -67,7 +67,13 @@ repos:
               |xmlrpc
             )
             |scripts
+            |utilities
           )/
+        exclude: |
+          (?x)^(
+            utilities/community-contributions\.py
+            |utilities/update-sourcecode
+          )$
 -   repo: https://github.com/PyCQA/isort
     rev: 5.9.2
     hooks:
@@ -110,6 +116,7 @@ repos:
               |xmlrpc
             )
             |scripts
+            |utilities
           )/
     -   id: isort
         alias: isort-black
@@ -143,6 +150,7 @@ repos:
               |xmlrpc
             )
             |scripts
+            |utilities
           )/
 -   repo: https://github.com/PyCQA/flake8
     rev: 3.9.2
diff --git a/utilities/audit-security-settings.py b/utilities/audit-security-settings.py
index 41e133f..5a5aa20 100755
--- a/utilities/audit-security-settings.py
+++ b/utilities/audit-security-settings.py
@@ -18,11 +18,8 @@ import os
 
 from lp.scripts.utilities.settingsauditor import SettingsAuditor
 
-
-BRANCH_ROOT = os.path.split(
-    os.path.dirname(os.path.abspath(__file__)))[0]
-SECURITY_PATH = os.path.join(
-    BRANCH_ROOT, 'database', 'schema', 'security.cfg')
+BRANCH_ROOT = os.path.split(os.path.dirname(os.path.abspath(__file__)))[0]
+SECURITY_PATH = os.path.join(BRANCH_ROOT, "database", "schema", "security.cfg")
 
 
 def main():
@@ -30,9 +27,10 @@ def main():
         data = f.read()
     auditor = SettingsAuditor(data)
     settings = auditor.audit()
-    with open(SECURITY_PATH, 'w') as f:
+    with open(SECURITY_PATH, "w") as f:
         f.write(settings)
     print(auditor.error_data)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/utilities/community-contributions.py b/utilities/community-contributions.py
index 8080d94..edaac47 100755
--- a/utilities/community-contributions.py
+++ b/utilities/community-contributions.py
@@ -39,10 +39,7 @@ Options:
 # For understanding the code, you may find it helpful to see
 # bzrlib/log.py and http://bazaar-vcs.org/Integrating_with_Bazaar.
 
-from __future__ import (
-    absolute_import,
-    print_function,
-    )
+from __future__ import absolute_import, print_function
 
 import getopt
 import re
@@ -52,7 +49,6 @@ from bzrlib import log
 from bzrlib.branch import Branch
 from bzrlib.osutils import format_date
 
-
 try:
     from editmoin import editshortcut
 except ImportError:
diff --git a/utilities/create-lp-wadl-and-apidoc.py b/utilities/create-lp-wadl-and-apidoc.py
index ec91422..9bd13d8 100755
--- a/utilities/create-lp-wadl-and-apidoc.py
+++ b/utilities/create-lp-wadl-and-apidoc.py
@@ -13,14 +13,14 @@ Example:
 
 import _pythonpath  # noqa: F401
 
-from multiprocessing import Process
 import optparse
 import os
 import subprocess
 import sys
+from multiprocessing import Process
 
-from lazr.restful.interfaces import IWebServiceConfiguration
 import six
+from lazr.restful.interfaces import IWebServiceConfiguration
 from zope.component import getUtility
 from zope.pagetemplate.pagetemplatefile import PageTemplateFile
 
@@ -29,27 +29,27 @@ from lp.services.webservice.wadl import (
     generate_html,
     generate_json,
     generate_wadl,
-    )
+)
 from lp.systemhomes import WebServiceApplication
 
 
 def write(filename, content, timestamp):
     """Replace the named file with the given string."""
-    with open(filename, 'wb') as f:
+    with open(filename, "wb") as f:
         f.write(six.ensure_binary(content))
     os.utime(filename, (timestamp, timestamp))  # (atime, mtime)
 
 
 def make_files(directory, version, timestamp, force):
     version_directory = os.path.join(directory, version)
-    base_filename = os.path.join(version_directory, os.environ['LPCONFIG'])
-    wadl_filename = base_filename + '.wadl'
-    json_filename = base_filename + '.json'
+    base_filename = os.path.join(version_directory, os.environ["LPCONFIG"])
+    wadl_filename = base_filename + ".wadl"
+    json_filename = base_filename + ".json"
     html_filename = os.path.join(directory, version + ".html")
-    wadl_index = os.path.join(version_directory, 'index.wadl')
-    json_index = os.path.join(version_directory, 'index.json')
-    html_index = os.path.join(version_directory, 'index.html')
-    brokenwadl_index = os.path.join(version_directory, 'index.brokenwadl')
+    wadl_index = os.path.join(version_directory, "index.wadl")
+    json_index = os.path.join(version_directory, "index.json")
+    html_index = os.path.join(version_directory, "index.html")
+    brokenwadl_index = os.path.join(version_directory, "index.brokenwadl")
 
     # Make sure we have our dir.
     if not os.path.exists(version_directory):
@@ -58,16 +58,15 @@ def make_files(directory, version, timestamp, force):
 
     # Make wadl and json files.
     for src, dest, gen, name in (
-        (wadl_filename, wadl_index, generate_wadl, 'WADL'),
-        (json_filename, json_index, generate_json, 'JSON')):
+        (wadl_filename, wadl_index, generate_wadl, "WADL"),
+        (json_filename, json_index, generate_json, "JSON"),
+    ):
         # If the src doesn't exist or we are forced to regenerate it...
-        if (not os.path.exists(src) or force):
-            print("Writing %s for version %s to %s." % (
-                name, version, src))
+        if not os.path.exists(src) or force:
+            print("Writing %s for version %s to %s." % (name, version, src))
             write(src, gen(version), timestamp)
         else:
-            print("Skipping already present %s file: %s" % (
-                name, src))
+            print("Skipping already present %s file: %s" % (name, src))
         # Make "index" symlinks, removing any preexisting ones.
         if os.path.exists(dest):
             os.remove(dest)
@@ -104,11 +103,13 @@ def make_files(directory, version, timestamp, force):
     # put the HTML in the same directory as the WADL.
     # If the HTML file doesn't exist or we're being forced to regenerate
     # it...
-    if (not os.path.exists(html_filename) or force):
-        print("Writing apidoc for version %s to %s" % (
-            version, html_filename))
-        write(html_filename, generate_html(wadl_filename,
-            suppress_stderr=False), timestamp)
+    if not os.path.exists(html_filename) or force:
+        print("Writing apidoc for version %s to %s" % (version, html_filename))
+        write(
+            html_filename,
+            generate_html(wadl_filename, suppress_stderr=False),
+            timestamp,
+        )
     else:
         print("Skipping already present HTML file:", html_filename)
 
@@ -117,7 +118,8 @@ def make_files(directory, version, timestamp, force):
     if not os.path.exists(html_index):
         os.symlink(
             os.path.join(os.path.pardir, os.path.basename(html_filename)),
-            html_index)
+            html_index,
+        )
 
 
 def main(directory, force=False):
@@ -127,25 +129,29 @@ def main(directory, force=False):
 
     # First, create an index.html with links to all the HTML
     # documentation files we're about to generate.
-    template_file = 'apidoc-index.pt'
+    template_file = "apidoc-index.pt"
     template = PageTemplateFile(template_file)
     index_filename = os.path.join(directory, "index.html")
     print("Writing index:", index_filename)
-    f = open(index_filename, 'w')
+    f = open(index_filename, "w")
     f.write(template(config=config))
 
     # Get the time of the last commit.  We will use this as the mtime for the
     # generated files so that we can safely use it as part of Apache's etag
     # generation in the face of multiple servers/filesystems.
-    timestamp = int(subprocess.check_output(
-        ["git", "log", "-1", "--format=%ct", "HEAD"],
-        universal_newlines=True))
+    timestamp = int(
+        subprocess.check_output(
+            ["git", "log", "-1", "--format=%ct", "HEAD"],
+            universal_newlines=True,
+        )
+    )
 
     # Start a process to build each set of WADL and HTML files.
     processes = []
     for version in config.active_versions:
-        p = Process(target=make_files,
-            args=(directory, version, timestamp, force))
+        p = Process(
+            target=make_files, args=(directory, version, timestamp, force)
+        )
         p.start()
         processes.append(p)
 
@@ -160,8 +166,10 @@ def parse_args(args):
     usage = "usage: %prog [options] DIR"
     parser = optparse.OptionParser(usage=usage)
     parser.add_option(
-        "--force", action="store_true",
-        help="Replace any already-existing files.")
+        "--force",
+        action="store_true",
+        help="Replace any already-existing files.",
+    )
     parser.set_defaults(force=False)
     options, args = parser.parse_args(args)
     if len(args) != 2:
@@ -170,6 +178,6 @@ def parse_args(args):
     return options, args
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     options, args = parse_args(sys.argv)
     sys.exit(main(args[1], options.force))
diff --git a/utilities/generate-external-bug-status-docs b/utilities/generate-external-bug-status-docs
index 94ad229..cbe193e 100755
--- a/utilities/generate-external-bug-status-docs
+++ b/utilities/generate-external-bug-status-docs
@@ -21,10 +21,10 @@
 import _pythonpath  # noqa: F401
 
 import codecs
+import sys
 from datetime import datetime
 from itertools import chain
 from optparse import OptionParser
-import sys
 
 from lp.bugs.externalbugtracker import BUG_TRACKER_CLASSES
 
@@ -32,16 +32,17 @@ from lp.bugs.externalbugtracker import BUG_TRACKER_CLASSES
 def generate_blank_lines(num):
     """Generate `num` blank lines."""
     for i in range(num):
-        yield ''
+        yield ""
 
 
 def generate_page_header():
     """Generate the header for the page."""
-    yield '<<Anchor(StatusTables)>>'
-    yield '== Status mapping tables =='
-    yield ''
-    yield 'Last generated: %s.' % (
-        datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC'),)
+    yield "<<Anchor(StatusTables)>>"
+    yield "== Status mapping tables =="
+    yield ""
+    yield "Last generated: %s." % (
+        datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC"),
+    )
 
 
 def generate_table_header(typ):
@@ -49,8 +50,8 @@ def generate_table_header(typ):
 
     :param typ: A member of `BugTrackerType`.
     """
-    yield '<<Anchor(%s)>>' % (typ.name,)
-    yield '=== %s ===' % (typ.title,)
+    yield "<<Anchor(%s)>>" % (typ.name,)
+    yield "=== %s ===" % (typ.title,)
 
 
 def generate_table_grid(lookup, titles):
@@ -69,44 +70,46 @@ def generate_table(typ, cls):
     lookup = cls._status_lookup
 
     # Find or fabricate titles.
-    titles = getattr(cls, '_status_lookup_titles', None)
+    titles = getattr(cls, "_status_lookup_titles", None)
     if titles is None:
-        titles = ['Key %d' % (i + 1) for i in range(lookup.max_depth)]
+        titles = ["Key %d" % (i + 1) for i in range(lookup.max_depth)]
     else:
         titles = list(titles)
-    titles.append('Launchpad status')
+    titles.append("Launchpad status")
 
     # Format the table.
     return chain(
         generate_table_header(typ),
         generate_blank_lines(1),
-        generate_table_grid(lookup, titles))
+        generate_table_grid(lookup, titles),
+    )
 
 
 def generate_documentable_classes():
     """Yield each class that has a mapping table defined."""
     for typ, cls in BUG_TRACKER_CLASSES.items():
-        if getattr(cls, '_status_lookup', None) is not None:
+        if getattr(cls, "_status_lookup", None) is not None:
             yield typ, cls
 
 
 def generate_tables():
     """Generate all the tables."""
     documentable_classes = sorted(
-        generate_documentable_classes(),
-        key=(lambda typ_cls: typ_cls[0].title))
+        generate_documentable_classes(), key=(lambda typ_cls: typ_cls[0].title)
+    )
     return chain(
-        *(chain(generate_table(typ, cls),
-                generate_blank_lines(2))
-          for (typ, cls) in documentable_classes))
+        *(
+            chain(generate_table(typ, cls), generate_blank_lines(2))
+            for (typ, cls) in documentable_classes
+        )
+    )
 
 
 def generate_page():
     """Generate the MoinMoin-style page."""
     return chain(
-        generate_page_header(),
-        generate_blank_lines(2),
-        generate_tables())
+        generate_page_header(), generate_blank_lines(2), generate_tables()
+    )
 
 
 def write_page(outfile):
@@ -115,22 +118,29 @@ def write_page(outfile):
     :param outfile: A `file`-like object.
     """
     # By default, encode using UTF-8.
-    write = codecs.getwriter('UTF-8')(outfile).write
+    write = codecs.getwriter("UTF-8")(outfile).write
     for line in generate_page():
         write(line)
-        write('\n')
+        write("\n")
 
 
 def get_option_parser():
     """Return the option parser for this program."""
     usage = "Usage: %prog [options]"
     parser = OptionParser(
-        usage=usage, description=(
+        usage=usage,
+        description=(
             "Generates MoinMoin-style tables to document the mapping of "
-            "remote bug statuses to Launchpad statuses."))
+            "remote bug statuses to Launchpad statuses."
+        ),
+    )
     parser.add_option(
-        "-o", "--file-out", dest="outfile", default='-', help=(
-            "write data to OUTFILE"))
+        "-o",
+        "--file-out",
+        dest="outfile",
+        default="-",
+        help=("write data to OUTFILE"),
+    )
     return parser
 
 
@@ -139,12 +149,12 @@ def main(args):
     (options, args) = parser.parse_args(args)
     if len(args) > 0:
         parser.error("Incorrect number of arguments.")
-    if options.outfile == '-':
+    if options.outfile == "-":
         outfile = sys.stdout
     else:
-        outfile = open(options.outfile, 'wb')
+        outfile = open(options.outfile, "wb")
     write_page(outfile)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv[1:]))
diff --git a/utilities/get-branch-info b/utilities/get-branch-info
index 911d8f4..cea827a 100755
--- a/utilities/get-branch-info
+++ b/utilities/get-branch-info
@@ -32,18 +32,19 @@ def main(args):
         return
     print(branch.bzr_identity)
     print()
-    print('Unique name:', branch.unique_name)
-    print('ID:', branch.id)
-    print('Private:', branch.private)
-    print('Type:', branch.branch_type)
-    print('URL:', canonical_url(branch))
+    print("Unique name:", branch.unique_name)
+    print("ID:", branch.id)
+    print("Private:", branch.private)
+    print("Type:", branch.branch_type)
+    print("URL:", canonical_url(branch))
     if branch.url is not None:
-        print('External URL:', branch.url)
+        print("External URL:", branch.url)
     branch_path = branch_id_to_path(branch.id)
     mirrored_path = join(
-        config.codehosting.mirrored_branches_root, branch_path)
-    print('Mirrored copy:', mirrored_path)
+        config.codehosting.mirrored_branches_root, branch_path
+    )
+    print("Mirrored copy:", mirrored_path)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv)
diff --git a/utilities/js-deps b/utilities/js-deps
index 30d9b36..06cd626 100755
--- a/utilities/js-deps
+++ b/utilities/js-deps
@@ -4,5 +4,4 @@ import _pythonpath  # noqa: F401
 
 from convoy.meta import main
 
-
 main()
diff --git a/utilities/link-external-sourcecode b/utilities/link-external-sourcecode
index 400ff4d..bc2a58b 100755
--- a/utilities/link-external-sourcecode
+++ b/utilities/link-external-sourcecode
@@ -4,34 +4,18 @@
 # Affero General Public License version 3 (see the file LICENSE).
 
 import optparse
-from os import (
-    curdir,
-    listdir,
-    makedirs,
-    symlink,
-    unlink,
-    )
-from os.path import (
-    abspath,
-    basename,
-    exists,
-    islink,
-    join,
-    realpath,
-    relpath,
-    )
 import subprocess
-from sys import (
-    stderr,
-    stdout,
-    )
+from os import curdir, listdir, makedirs, symlink, unlink
+from os.path import abspath, basename, exists, islink, join, realpath, relpath
+from sys import stderr, stdout
 
 
 def get_main_worktree(branch_dir):
     """Return the main worktree directory, otherwise `None`."""
     worktree_list = subprocess.check_output(
-        ['git', 'worktree', 'list', '--porcelain'], universal_newlines=True)
-    main_worktree = worktree_list.splitlines()[0].split(' ', 1)[1]
+        ["git", "worktree", "list", "--porcelain"], universal_newlines=True
+    )
+    main_worktree = worktree_list.splitlines()[0].split(" ", 1)[1]
     if realpath(main_worktree) != realpath(branch_dir):
         return main_worktree
     return None
@@ -60,38 +44,58 @@ def link(source, destination):
         symlink(source, destination)
     except OSError as error:
         stderr.write(
-            '  Error linking %s: %s\n' % (basename(destination), error))
+            "  Error linking %s: %s\n" % (basename(destination), error)
+        )
     else:
         if options.verbose:
-            stdout.write('%s -> %s\n' % (relpath(destination), source))
+            stdout.write("%s -> %s\n" % (relpath(destination), source))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = optparse.OptionParser(
         usage="%prog [options] [parent]",
         description=(
             "Add a symlink in <target>/sourcecode for each corresponding "
-            "file in <parent>/sourcecode."),
+            "file in <parent>/sourcecode."
+        ),
         epilog=(
             "Most of the time this does the right thing if run "
-            "with no arguments."),
-        add_help_option=False)
+            "with no arguments."
+        ),
+        add_help_option=False,
+    )
     parser.add_option(
-        '-p', '--parent', dest='parent', default=None,
-        help=("The directory of the parent tree. If not specified, "
-              "the main Git worktree."),
-        metavar="DIR")
+        "-p",
+        "--parent",
+        dest="parent",
+        default=None,
+        help=(
+            "The directory of the parent tree. If not specified, "
+            "the main Git worktree."
+        ),
+        metavar="DIR",
+    )
     parser.add_option(
-        '-t', '--target', dest='target', default=curdir,
-        help=("The directory of the target tree. If not specified, "
-              "the current working directory."),
-        metavar="DIR")
+        "-t",
+        "--target",
+        dest="target",
+        default=curdir,
+        help=(
+            "The directory of the target tree. If not specified, "
+            "the current working directory."
+        ),
+        metavar="DIR",
+    )
     parser.add_option(
-        '-q', '--quiet', dest='verbose', action='store_false',
-        help="Be less verbose.")
+        "-q",
+        "--quiet",
+        dest="verbose",
+        action="store_false",
+        help="Be less verbose.",
+    )
     parser.add_option(
-        '-h', '--help', action='help',
-        help="Show this help message and exit.")
+        "-h", "--help", action="help", help="Show this help message and exit."
+    )
     parser.set_defaults(verbose=True)
 
     options, args = parser.parse_args()
@@ -101,8 +105,10 @@ if __name__ == '__main__':
         if options.parent is None:
             options.parent = args[0]
         else:
-            parser.error("Cannot specify parent tree as named "
-                         "argument and positional argument.")
+            parser.error(
+                "Cannot specify parent tree as named "
+                "argument and positional argument."
+            )
     elif len(args) >= 2:
         parser.error("Too many arguments.")
 
@@ -113,23 +119,25 @@ if __name__ == '__main__':
     if options.parent is None:
         parser.error("Parent tree not specified.")
 
-    if not exists(join(options.target, 'sourcecode')):
-        makedirs(join(options.target, 'sourcecode'))
+    if not exists(join(options.target, "sourcecode")):
+        makedirs(join(options.target, "sourcecode"))
 
     missing_files = gen_missing_files(
-        abspath(join(options.parent, 'sourcecode')),
-        abspath(join(options.target, 'sourcecode')))
+        abspath(join(options.parent, "sourcecode")),
+        abspath(join(options.target, "sourcecode")),
+    )
 
     for source, destination in missing_files:
         link(source, destination)
 
-    for folder_name in ('download-cache',):
+    for folder_name in ("download-cache",):
         source = abspath(join(options.parent, folder_name))
         destination = abspath(join(options.target, folder_name))
         if not exists(destination):
             if not exists(source):
                 stderr.write(
-                    '  Wanted to link %s to %s but source does not exist\n' %
-                    (source, destination))
+                    "  Wanted to link %s to %s but source does not exist\n"
+                    % (source, destination)
+                )
             else:
                 link(source, destination)
diff --git a/utilities/link-system-packages.py b/utilities/link-system-packages.py
index 14d4bda..17ced92 100755
--- a/utilities/link-system-packages.py
+++ b/utilities/link-system-packages.py
@@ -5,11 +5,11 @@
 
 """Link system-installed Python modules into Launchpad's virtualenv."""
 
-from argparse import ArgumentParser
-from distutils.sysconfig import get_python_lib
 import importlib
 import os.path
 import re
+from argparse import ArgumentParser
+from distutils.sysconfig import get_python_lib
 
 # Importing this from the vendored version in pkg_resources is a bit dodgy
 # (using packaging.markers directly would be better), but we want to
@@ -32,9 +32,11 @@ def link_module(name, virtualenv_libdir, optional=False):
     system_libdir = get_python_lib(plat_specific=path.endswith(".so"))
     if os.path.commonprefix([path, system_libdir]) != system_libdir:
         raise RuntimeError(
-            "%s imported from outside %s (%s)" % (name, system_libdir, path))
+            "%s imported from outside %s (%s)" % (name, system_libdir, path)
+        )
     target_path = os.path.join(
-        virtualenv_libdir, os.path.relpath(path, system_libdir))
+        virtualenv_libdir, os.path.relpath(path, system_libdir)
+    )
     if os.path.lexists(target_path) and os.path.islink(target_path):
         os.unlink(target_path)
     os.symlink(path, target_path)
@@ -52,7 +54,8 @@ def main():
             continue
         match = re.match(
             r"^(\[optional\])?\s*([A-Za-z_][A-Za-z0-9_]*)(?:\s*;\s*(.*))?",
-            line)
+            line,
+        )
         if not match:
             raise ValueError("Parse error: %s" % line)
         optional = bool(match.group(1))
diff --git a/utilities/list-pages b/utilities/list-pages
index 3dd9314..5c720cf 100755
--- a/utilities/list-pages
+++ b/utilities/list-pages
@@ -44,29 +44,22 @@ because our cheat objects don't match the app-encoded business logic.
 
 import _pythonpath  # noqa: F401
 
-from inspect import getmro
 import os
+from inspect import getmro
 
 from zope.app.wsgi.testlayer import BrowserLayer
 from zope.browserpage.simpleviewclass import simple
-from zope.component import (
-    adapter,
-    getGlobalSiteManager,
-    )
-from zope.interface import (
-    directlyProvides,
-    implementer,
-    )
+from zope.component import adapter, getGlobalSiteManager
+from zope.interface import directlyProvides, implementer
 from zope.publisher.interfaces.browser import IDefaultBrowserLayer
 
+import zcml
 from lp.services.config import config
 from lp.services.scripts import execute_zcml_for_scripts
 from lp.services.webapp.interfaces import ICanonicalUrlData
 from lp.services.webapp.publisher import canonical_url
-import zcml
 
-
-ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 
 
 def load_zcml(zopeless=False):
@@ -76,7 +69,7 @@ def load_zcml(zopeless=False):
     if zopeless:
         execute_zcml_for_scripts()
     else:
-        BrowserLayer(zcml, zcml_file='webapp.zcml').setUp()
+        BrowserLayer(zcml, zcml_file="webapp.zcml").setUp()
 
 
 def is_page_adapter(a):
@@ -117,27 +110,33 @@ def has_page_title(a):
     template = get_template_filename(view)
     if template is None:
         return False
-    if (getattr(view, 'page_title', marker) is marker):
+    if getattr(view, "page_title", marker) is marker:
         return False
     return has_html_element(template)
 
 
 def has_html_element(template):
     with open(template) as f:
-        return '</html>' in f.read()
+        return "</html>" in f.read()
 
 
 def iter_page_adapters():
     """Iterate over adapters for browser:page directives."""
     gsm = getGlobalSiteManager()
-    return (a for a in gsm.registeredAdapters()
-            if is_page_adapter(a) and has_page_title(a))
+    return (
+        a
+        for a in gsm.registeredAdapters()
+        if is_page_adapter(a) and has_page_title(a)
+    )
 
 
 def iter_url_adapters():
     gsm = getGlobalSiteManager()
-    return (a for a in gsm.registeredAdapters()
-            if issubclass(a.provided, ICanonicalUrlData))
+    return (
+        a
+        for a in gsm.registeredAdapters()
+        if issubclass(a.provided, ICanonicalUrlData)
+    )
 
 
 def format_page_adapter(a):
@@ -156,28 +155,31 @@ def format_page_adapter(a):
     # z.app.pagetemplate.simpleviewclass). Ideally, we'd just construct the
     # view, but that's hard, since in general they won't construct without an
     # object that implements the interface they need.
-    bases = [b for b in bases
-             if b is not simple
-             and 'SimpleViewClass' not in b.__name__]
+    bases = [
+        b
+        for b in bases
+        if b is not simple and "SimpleViewClass" not in b.__name__
+    ]
     template = get_template_filename(get_view(a))
     if template:
         template = os.path.relpath(template, ROOT)
-    url = '%s/%s' % (get_example_canonical_url(a.required[0]), a.name)
-    return '%s:%s,%s,%s,%s,%s' % (
+    url = "%s/%s" % (get_example_canonical_url(a.required[0]), a.name)
+    return "%s:%s,%s,%s,%s,%s" % (
         bases[0].__name__,
         a.name,
         a.required[0].__name__,
         a.required[1].__name__,
         template,
         url,
-        )
+    )
 
 
 _BLACKLIST = [
-    '__conform__',
-    ]
-class Whatever:
+    "__conform__",
+]
+
 
+class Whatever:
     def __init__(self, name, interface=None):
         self._name = name
         self._interface = interface
@@ -185,23 +187,23 @@ class Whatever:
             directlyProvides(self, interface)
 
     def __str__(self):
-        return '<%s>' % (self._name,)
+        return "<%s>" % (self._name,)
 
     def __repr__(self):
-        return '<%s>' % str(self)
+        return "<%s>" % str(self)
 
     def __int__(self):
         return 1
 
     def __call__(self, *args, **kwargs):
         args = map(repr, args)
-        args.extend('%s=%r' % (k, v) for k, v in kwargs.items())
+        args.extend("%s=%r" % (k, v) for k, v in kwargs.items())
         # If we're being called with no args, assume this is part of crazy
         # TALES stuff:
         #   webapp/metazcml.py(365)path()
         #   -> return self._compiled_path_expression(self._expression_context)
         if args:
-            name = '%s(%s)' % (self._name, ', '.join(args))
+            name = "%s(%s)" % (self._name, ", ".join(args))
             return Whatever(name)
         else:
             return str(self)
@@ -210,11 +212,11 @@ class Whatever:
         if name in _BLACKLIST:
             raise AttributeError
         if self._interface:
-            interface = getattr(self._interface[name], 'schema', None)
+            interface = getattr(self._interface[name], "schema", None)
         else:
             interface = None
-        child = Whatever('%s.%s' % (self._name, name), interface)
-        if 'name' in name:
+        child = Whatever("%s.%s" % (self._name, name), interface)
+        if "name" in name:
             # Then it's probably displayname, or something.
             return str(child)
         else:
@@ -225,7 +227,7 @@ class Whatever:
 @adapter(object)
 class DefaultCanonicalUrlData:
     def __init__(self, name):
-        self.path = '[[%s]]' % (name,)
+        self.path = "[[%s]]" % (name,)
         self.rootsite = None
         self.inside = None
 
@@ -253,5 +255,5 @@ def main():
         print(format_page_adapter(a))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/utilities/local-latency b/utilities/local-latency
index 1c7dec1..dd33c58 100755
--- a/utilities/local-latency
+++ b/utilities/local-latency
@@ -3,11 +3,7 @@
 import subprocess
 import sys
 
-from script_commands import (
-    helps,
-    run_subcommand,
-    UserError,
-    )
+from script_commands import UserError, helps, run_subcommand
 
 
 def tc(command):
@@ -15,35 +11,40 @@ def tc(command):
 
     :param tc: The remainder of the command (leaving out tc).
     """
-    subprocess.call('sudo tc ' + command, shell=True)
+    subprocess.call("sudo tc " + command, shell=True)
 
 
-@helps(delay='Length of delay in miliseconds (each way).',
-       port='Port to induce delay on.')
+@helps(
+    delay="Length of delay in miliseconds (each way).",
+    port="Port to induce delay on.",
+)
 def start(delay=500, port=443):
     """Add artificial latency to the lo interface on the specified port."""
-    tc('qdisc add dev lo root handle 1: prio')
-    tc('qdisc add dev lo parent 1:3 handle 30: netem delay %dms' % delay)
-    tc('filter add dev lo protocol ip parent 1:0 prio 3 u32 match ip'
-       ' dport %d 0xffff flowid 1:3' % port)
-    tc('filter add dev lo protocol ip parent 1:0 prio 3 u32 match ip'
-       ' sport %d 0xffff flowid 1:3' % port)
+    tc("qdisc add dev lo root handle 1: prio")
+    tc("qdisc add dev lo parent 1:3 handle 30: netem delay %dms" % delay)
+    tc(
+        "filter add dev lo protocol ip parent 1:0 prio 3 u32 match ip"
+        " dport %d 0xffff flowid 1:3" % port
+    )
+    tc(
+        "filter add dev lo protocol ip parent 1:0 prio 3 u32 match ip"
+        " sport %d 0xffff flowid 1:3" % port
+    )
 
 
 def stop():
     """Remove latency from the lo."""
-    tc('qdisc del dev lo root')
+    tc("qdisc del dev lo root")
 
 
 subcommands = {
-    'start': start,
-    'stop': stop,
-    }
-
+    "start": start,
+    "stop": stop,
+}
 
 
 if __name__ == "__main__":
     try:
         run_subcommand(subcommands, sys.argv[1:])
     except UserError as e:
-        sys.stderr.write(str(e)+'\n')
+        sys.stderr.write(str(e) + "\n")
diff --git a/utilities/lsconf.py b/utilities/lsconf.py
index ba23a7b..c05e502 100755
--- a/utilities/lsconf.py
+++ b/utilities/lsconf.py
@@ -10,24 +10,24 @@ __metatype__ = type
 # Scripts may have relative imports.
 import _pythonpath  # noqa: F401
 
-from operator import attrgetter
-from optparse import OptionParser
 import os
 import sys
+from operator import attrgetter
+from optparse import OptionParser
 from textwrap import dedent
 
 from lazr.config import ImplicitTypeSchema
 
 import lp.services.config
 
-
 _schema_dir = os.path.abspath(os.path.dirname(lp.services.config.__file__))
 _root = os.path.dirname(os.path.dirname(os.path.dirname(_schema_dir)))
 
 
 class Configuration:
     """A lazr.config configuration."""
-    _schema_path = os.path.join(_schema_dir, 'schema-lazr.conf')
+
+    _schema_path = os.path.join(_schema_dir, "schema-lazr.conf")
 
     def __init__(self, config):
         self.config = config
@@ -52,13 +52,15 @@ class Configuration:
         previous_config_data = self.config.data
         # Walk the stack of config_data until a change is found.
         for config_data in self.config.overlays:
-            if (section.name in config_data
-                and config_data[section.name][key] != value):
+            if (
+                section.name in config_data
+                and config_data[section.name][key] != value
+            ):
                 conf_file_name = previous_config_data.filename
                 break
             previous_config_data = config_data
         conf_path = os.path.abspath(conf_file_name)
-        return conf_path[len(_root) + 1:]
+        return conf_path[len(_root) + 1 :]
 
     def list_config(self, verbose=False, section_name=None):
         """Print all the sections and keys in a configuration.
@@ -70,51 +72,65 @@ class Configuration:
             was defined.
         :param section_name: Only print the named section.
         """
-        print('# This configuration derives from:')
+        print("# This configuration derives from:")
         for config_data in self.config.overlays:
-            print('#     %s' % config_data.filename)
+            print("#     %s" % config_data.filename)
         print()
-        name_key = attrgetter('name')
+        name_key = attrgetter("name")
         for count, section in enumerate(sorted(self.config, key=name_key)):
             if section_name is not None and section_name != section.name:
                 continue
             if count > 0:
                 # Separate sections by a blank line, or two when verbose.
                 print()
-            print('[%s]' % section.name)
+            print("[%s]" % section.name)
             if verbose and section.optional:
-                print('# This section is optional.\n')
+                print("# This section is optional.\n")
             for count, key in enumerate(sorted(section)):
                 if verbose:
                     if count > 0:
                         # Separate keys by a blank line.
                         print()
                     conf_file_name = self.config_file_for_value(section, key)
-                    print('# Defined in: %s' % conf_file_name)
-                print('%s: %s' % (key, section[key]))
+                    print("# Defined in: %s" % conf_file_name)
+                print("%s: %s" % (key, section[key]))
 
 
 def get_option_parser():
     """Return the option parser for this program."""
-    usage = dedent("""    %prog [options] lazr-config.conf
+    usage = dedent(
+        """    %prog [options] lazr-config.conf
 
     List all the sections and keys in an environment's lazr configuration.
     The configuration is assembled from the schema and conf files. Verbose
     annotates each key with the location of the file that set its value.
-    The 'section' option limits the list to just the named section.""")
+    The 'section' option limits the list to just the named section."""
+    )
     parser = OptionParser(usage=usage)
     parser.add_option(
-        "-l", "--schema", dest="schema_path",
-        help="the path to the lazr.config schema file")
+        "-l",
+        "--schema",
+        dest="schema_path",
+        help="the path to the lazr.config schema file",
+    )
     parser.add_option(
-        "-v", "--verbose", action="store_true",
-        help="explain where the section and keys are set")
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="explain where the section and keys are set",
+    )
     parser.add_option(
-        "-s", "--section", dest="section_name",
-        help="restrict the listing to the section")
+        "-s",
+        "--section",
+        dest="section_name",
+        help="restrict the listing to the section",
+    )
     parser.add_option(
-        '-i', "--instance", dest="instance_name",
-        help="the configuration instance to use")
+        "-i",
+        "--instance",
+        dest="instance_name",
+        help="the configuration instance to use",
+    )
     return parser
 
 
@@ -134,11 +150,12 @@ def main(argv=None):
         conf_path = arguments[0]
         configuration = Configuration.load(conf_path, options.schema_path)
     else:
-        parser.error('Too many arguments.')
+        parser.error("Too many arguments.")
         # Does not return.
     configuration.list_config(
-        verbose=options.verbose, section_name=options.section_name)
+        verbose=options.verbose, section_name=options.section_name
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/make-dev-certificate b/utilities/make-dev-certificate
index 0a6859a..7142882 100755
--- a/utilities/make-dev-certificate
+++ b/utilities/make-dev-certificate
@@ -17,7 +17,6 @@ import subprocess
 import sys
 import tempfile
 
-
 vhosts = [
     "launchpad.test",
     "answers.launchpad.test",
@@ -30,7 +29,7 @@ vhosts = [
     "translations.launchpad.test",
     "xmlrpc.launchpad.test",
     "testopenid.test",
-    ]
+]
 
 
 def main():
@@ -43,26 +42,37 @@ def main():
     shutil.copy2("/etc/ssl/openssl.cnf", config)
     with open(config, "a") as f:
         f.write(
-            "\n[subjectAltName]\nsubjectAltName=%s\n" %
-            ",".join("DNS:%s" % vhost for vhost in vhosts))
-    subprocess.check_call([
-        "openssl", "req",
-        "-config", config,
-        "-new",
-        "-newkey", "rsa:4096",
-        "-nodes",
-        "-sha256",
-        "-subj", "/CN=%s/" % vhosts[0],
-        "-extensions", "subjectAltName",
-        "-x509",
-        "-days", "3650",
-        "-keyout", key,
-        "-out", certificate,
-        ])
+            "\n[subjectAltName]\nsubjectAltName=%s\n"
+            % ",".join("DNS:%s" % vhost for vhost in vhosts)
+        )
+    subprocess.check_call(
+        [
+            "openssl",
+            "req",
+            "-config",
+            config,
+            "-new",
+            "-newkey",
+            "rsa:4096",
+            "-nodes",
+            "-sha256",
+            "-subj",
+            "/CN=%s/" % vhosts[0],
+            "-extensions",
+            "subjectAltName",
+            "-x509",
+            "-days",
+            "3650",
+            "-keyout",
+            key,
+            "-out",
+            certificate,
+        ]
+    )
     print("Created new local key and self-signed certificate.")
     subprocess.check_call(["openssl", "x509", "-in", certificate, "-text"])
     return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/make-dummy-hosted-branches b/utilities/make-dummy-hosted-branches
index def0bed..2b40eb8 100755
--- a/utilities/make-dummy-hosted-branches
+++ b/utilities/make-dummy-hosted-branches
@@ -36,22 +36,24 @@ from lp.services.scripts import execute_zcml_for_scripts
 def make_bazaar_branch_and_tree(db_branch):
     """Make a dummy Bazaar branch and working tree from a database Branch."""
     assert db_branch.branch_type == BranchType.HOSTED, (
-        "Can only create branches for HOSTED branches: %r"
-        % db_branch)
+        "Can only create branches for HOSTED branches: %r" % db_branch
+    )
     branch_dir = os.path.join(
         config.codehosting.mirrored_branches_root,
-        branch_id_to_path(db_branch.id))
+        branch_id_to_path(db_branch.id),
+    )
     return create_branch_with_one_revision(branch_dir)
 
 
 def main(argv):
-    os.environ['BZR_HOME'] = tempfile.mkdtemp()
+    os.environ["BZR_HOME"] = tempfile.mkdtemp()
     if os.path.exists(config.codehosting.mirrored_branches_root):
         shutil.rmtree(config.codehosting.mirrored_branches_root)
     execute_zcml_for_scripts()
     try:
         branches = Branch.select(
-            "Branch.branch_type = %s" % sqlvalues(BranchType.HOSTED))
+            "Branch.branch_type = %s" % sqlvalues(BranchType.HOSTED)
+        )
         for branch in branches:
             make_bazaar_branch_and_tree(branch)
     finally:
@@ -59,5 +61,5 @@ def main(argv):
     print("Created %d branches based on sample data." % len(list(branches)))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv)
diff --git a/utilities/make-lp-user b/utilities/make-lp-user
index 6278075..8be2a16 100755
--- a/utilities/make-lp-user
+++ b/utilities/make-lp-user
@@ -31,33 +31,30 @@ production environments.
 
 import _pythonpath  # noqa: F401
 
-from optparse import OptionParser
 import os
 import re
 import subprocess
 import sys
+from optparse import OptionParser
 
-from storm.store import Store
 import transaction
+from storm.store import Store
 from zope.component import getUtility
 
 from lp.registry.interfaces.gpg import IGPGKeySet
 from lp.registry.interfaces.person import IPersonSet
 from lp.registry.interfaces.ssh import ISSHKeySet
 from lp.registry.interfaces.teammembership import TeamMembershipStatus
-from lp.services.gpg.interfaces import (
-    get_gpg_path,
-    IGPGHandler,
-    )
+from lp.services.gpg.interfaces import IGPGHandler, get_gpg_path
 from lp.services.scripts import execute_zcml_for_scripts
 from lp.services.timeout import set_default_timeout_function
 from lp.testing.factory import LaunchpadObjectFactory
 
-
 factory = LaunchpadObjectFactory()
 
 set_default_timeout_function(lambda: 100)
 
+
 def make_person(username, email):
     """Create and return a person with the given username.
 
@@ -87,10 +84,9 @@ def add_person_to_teams(person, team_names):
         if not team.is_team:
             print("ERROR: %s is not a team." % (team_name,))
             continue
-        team.addMember(
-            person, person, status=TeamMembershipStatus.APPROVED)
+        team.addMember(person, person, status=TeamMembershipStatus.APPROVED)
         teams_joined.append(team_name)
-    print("teams:    %s" % ' '.join(teams_joined))
+    print("teams:    %s" % " ".join(teams_joined))
 
 
 def add_ssh_public_keys(person):
@@ -99,9 +95,9 @@ def add_ssh_public_keys(person):
     This function looks in ~/.ssh/id_rsa.pub and ~/.ssh/id_dsa.pub for SSH
     public keys and registers them as SSH keys for `person`.
     """
-    ssh_dir = os.path.expanduser('~/.ssh')
+    ssh_dir = os.path.expanduser("~/.ssh")
     key_set = getUtility(ISSHKeySet)
-    for filename in ('id_rsa.pub', 'id_dsa.pub'):
+    for filename in ("id_rsa.pub", "id_dsa.pub"):
         try:
             public_key_file = open(os.path.join(ssh_dir, filename))
             try:
@@ -111,10 +107,10 @@ def add_ssh_public_keys(person):
         except OSError:
             continue
         key_set.new(person, public_key)
-        print('Registered SSH key: %s' % (filename,))
+        print("Registered SSH key: %s" % (filename,))
         break
     else:
-        print('No SSH key files found in %s' % ssh_dir)
+        print("No SSH key files found in %s" % ssh_dir)
 
 
 def parse_fingerprints(gpg_output):
@@ -133,28 +129,36 @@ def run_native_gpg(arguments):
     # Need to override GNUPGHOME or we'll get a dummy GPG in a temp
     # directory, which won't find any keys.
     env = os.environ.copy()
-    if 'GNUPGHOME' in env:
-        del env['GNUPGHOME']
+    if "GNUPGHOME" in env:
+        del env["GNUPGHOME"]
 
     command_line = [get_gpg_path()] + arguments
     pipe = subprocess.Popen(
-        command_line, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-        universal_newlines=True)
+        command_line,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+    )
     stdout, stderr = pipe.communicate()
-    if stderr != '':
+    if stderr != "":
         print(stderr)
     if pipe.returncode != 0:
-        raise Exception('GPG error during "%s"' % ' '.join(command_line))
+        raise Exception('GPG error during "%s"' % " ".join(command_line))
 
     return stdout
 
 
 def add_gpg_key(person, fingerprint):
     """Add the GPG key with the given fingerprint to `person`."""
-    run_native_gpg([
-        '--keyserver', 'hkp://keyserver.launchpad.test:11371',
-        '--send-key', fingerprint
-        ])
+    run_native_gpg(
+        [
+            "--keyserver",
+            "hkp://keyserver.launchpad.test:11371",
+            "--send-key",
+            fingerprint,
+        ]
+    )
 
     gpghandler = getUtility(IGPGHandler)
     key = gpghandler.retrieveKey(fingerprint)
@@ -166,14 +170,20 @@ def add_gpg_key(person, fingerprint):
 
     can_encrypt = True
     lpkey = gpgkeyset.new(
-        person.id, key.keyid, fingerprint, key.keysize, key.algorithm,
-        active=True, can_encrypt=can_encrypt)
+        person.id,
+        key.keyid,
+        fingerprint,
+        key.keysize,
+        key.algorithm,
+        active=True,
+        can_encrypt=can_encrypt,
+    )
     Store.of(person).add(lpkey)
 
 
 def attach_gpg_keys(email, person):
     """Attach the GPG key(s) for `email` to `person`."""
-    output = run_native_gpg(['--fingerprint', email])
+    output = run_native_gpg(["--fingerprint", email])
 
     fingerprints = parse_fingerprints(output)
     if len(fingerprints) == 0:
@@ -190,11 +200,15 @@ def parse_args(arguments):
     """
     parser = OptionParser(description="Create a local Launchpad user.")
     parser.add_option(
-        '-e', '--email', action='store', dest='email', default=None,
-        help="Email address")
+        "-e",
+        "--email",
+        action="store",
+        dest="email",
+        default=None,
+        help="Email address",
+    )
     parser.add_option(
-        '-g', '--gpg', action='store_true', dest='gpg',
-        help="Use real GPG key"
+        "-g", "--gpg", action="store_true", dest="gpg", help="Use real GPG key"
     )
 
     options, args = parser.parse_args(arguments)
@@ -212,7 +226,7 @@ def main(arguments):
     """Run the script."""
     options = parse_args(arguments)
     if options.email is None:
-        email = '[e-mail]' % options.username
+        email = "[e-mail]" % options.username
     else:
         email = options.email
 
@@ -231,5 +245,5 @@ def main(arguments):
     return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv[1:]))
diff --git a/utilities/make-requirements.py b/utilities/make-requirements.py
index 21b68da..e75e246 100755
--- a/utilities/make-requirements.py
+++ b/utilities/make-requirements.py
@@ -5,10 +5,10 @@
 
 """Build a pip constraints file from inputs."""
 
+import logging
 from argparse import ArgumentParser
 from collections import defaultdict
 from configparser import ConfigParser
-import logging
 
 from pkg_resources import parse_requirements
 
@@ -29,7 +29,7 @@ def read_buildout_versions(path):
         if section == "versions":
             python_version = None
         elif section.startswith("versions:python"):
-            python_suffix = section[len("versions:python"):]
+            python_suffix = section[len("versions:python") :]
             if len(python_suffix) == 1 and python_suffix.isdigit():
                 python_version = "%s.*" % python_suffix
             elif len(python_suffix) == 2 and python_suffix.isdigit():
@@ -50,15 +50,18 @@ def read_buildout_versions(path):
                 if python_version is None:
                     continue
                 requirements.append(
-                    '%s==%s; python_version == "%s"' %
-                    (name, versions[name][python_version], python_version))
+                    '%s==%s; python_version == "%s"'
+                    % (name, versions[name][python_version], python_version)
+                )
             if None in python_versions:
                 marker = " and ".join(
                     'python_version != "%s"' % python_version
                     for python_version in python_versions
-                    if python_version is not None)
+                    if python_version is not None
+                )
                 requirements.append(
-                    "%s==%s; %s" % (name, versions[name][None], marker))
+                    "%s==%s; %s" % (name, versions[name][None], marker)
+                )
     return list(parse_requirements(requirements))
 
 
@@ -93,19 +96,28 @@ def write_requirements(include_requirements, exclude_requirements):
 def main():
     parser = ArgumentParser()
     parser.add_argument(
-        "--buildout", action="append", metavar="VERSIONS",
-        help="Include requirements from this buildout versions file")
+        "--buildout",
+        action="append",
+        metavar="VERSIONS",
+        help="Include requirements from this buildout versions file",
+    )
     parser.add_argument(
-        "--include", action="append", metavar="REQUIREMENTS",
-        help="Include requirements from this PEP 508 requirements file")
+        "--include",
+        action="append",
+        metavar="REQUIREMENTS",
+        help="Include requirements from this PEP 508 requirements file",
+    )
     parser.add_argument(
-        "--exclude", action="append", metavar="REQUIREMENTS",
-        help="Exclude requirements from this PEP 508 requirements file")
+        "--exclude",
+        action="append",
+        metavar="REQUIREMENTS",
+        help="Exclude requirements from this PEP 508 requirements file",
+    )
     args = parser.parse_args()
 
-    include_requirements = (
-        [read_buildout_versions(path) for path in args.buildout] +
-        [read_requirements(path) for path in args.include])
+    include_requirements = [
+        read_buildout_versions(path) for path in args.buildout
+    ] + [read_requirements(path) for path in args.include]
     exclude_requirements = [read_requirements(path) for path in args.exclude]
 
     write_requirements(include_requirements, exclude_requirements)
diff --git a/utilities/massage-bug-import-xml b/utilities/massage-bug-import-xml
index 7e43831..8142896 100755
--- a/utilities/massage-bug-import-xml
+++ b/utilities/massage-bug-import-xml
@@ -1,13 +1,12 @@
 #!/usr/bin/env python
 # -*- mode: python -*-
 
+import sys
 from base64 import standard_b64encode
 from optparse import OptionParser
-import sys
 
 from lxml import etree
 
-
 NS = "https://launchpad.net/xmlns/2006/bugs"
 
 
@@ -26,8 +25,7 @@ def truncate(text, message=None):
             message = "[Truncated]"
         else:
             message = "[Truncated; %s]" % message
-        return "%s...\n\n%s" % (
-            "\n".join(lines[:30]).strip(), message)
+        return "%s...\n\n%s" % ("\n".join(lines[:30]).strip(), message)
     else:
         return text
 
@@ -70,58 +68,58 @@ def massage(root, project_name, fix_nickname, tag_nickname):
     # Resolve duplicates as far as they'll go.
     duplicates = {
         node.getparent().get("id"): node.text
-        for node in root.findall('{%s}bug/{%s}duplicateof' % (NS, NS))
-        if node.text is not None and node.text.isdigit()}
+        for node in root.findall("{%s}bug/{%s}duplicateof" % (NS, NS))
+        if node.text is not None and node.text.isdigit()
+    }
 
     def resolve(bug_id):
         dupe_of = duplicates.get(bug_id)
-        return (bug_id if dupe_of is None else resolve(dupe_of))
+        return bug_id if dupe_of is None else resolve(dupe_of)
 
-    duplicates = {
-        bug_id: resolve(bug_id) for bug_id in duplicates}
+    duplicates = {bug_id: resolve(bug_id) for bug_id in duplicates}
 
     # Scan the tree, fixing up issues.
-    for bug in root.findall('{%s}bug' % NS):
+    for bug in root.findall("{%s}bug" % NS):
         # Get or create the tags element.
-        tags = bug.find('{%s}tags' % NS)
+        tags = bug.find("{%s}tags" % NS)
         if tags is None:
-            tags = etree.SubElement(bug, '{%s}tags' % NS)
+            tags = etree.SubElement(bug, "{%s}tags" % NS)
 
-        nickname = bug.find('{%s}nickname' % NS)
+        nickname = bug.find("{%s}nickname" % NS)
         if nickname is None:
             # Add an empty nickname to be filled in later.
-            nickname = etree.SubElement(bug, '{%s}nickname' % NS)
+            nickname = etree.SubElement(bug, "{%s}nickname" % NS)
         elif tag_nickname:
             # Add the original nickname as a tag.
-            etree.SubElement(tags, '{%s}tag' % NS).text = nickname.text
+            etree.SubElement(tags, "{%s}tag" % NS).text = nickname.text
 
         # Change the nickname.
         if nickname.text is None or fix_nickname:
-            nickname.text = "%s-%s" % (project_name, bug.get('id'))
+            nickname.text = "%s-%s" % (project_name, bug.get("id"))
 
         # Resolve duplicateof, if it exists.
         if bug.get("id") in duplicates:
             bug.find("{%s}duplicateof" % NS).text = duplicates[bug.get("id")]
 
         # Get the first comment and its text. We'll need these later.
-        first_comment = bug.find('{%s}comment' % NS)
-        first_comment_text = first_comment.find('{%s}text' % NS)
+        first_comment = bug.find("{%s}comment" % NS)
+        first_comment_text = first_comment.find("{%s}text" % NS)
         norm_text(first_comment_text)
 
         # Check the description.
-        description = bug.find('{%s}description' % NS)
+        description = bug.find("{%s}description" % NS)
         norm_text(description)
         if len(description.text) == 0:
-            problem("Bug %s has no description." % bug.get('id'))
+            problem("Bug %s has no description." % bug.get("id"))
             # Try and get the description from the first comment.
             if first_comment_text is None:
                 problem_detail("No comments!")
                 problem_resolution("Setting description to '-'.")
-                description.text = '-'
+                description.text = "-"
             elif len(first_comment_text.text) == 0:
                 problem_detail("First comment has no text!")
                 problem_resolution("Setting description to '-'.")
-                description.text = '-'
+                description.text = "-"
             else:
                 problem_detail("First comment has text.")
                 problem_resolution("Removing description.")
@@ -131,8 +129,12 @@ def massage(root, project_name, fix_nickname, tag_nickname):
             problem_resolved()
         elif len(description.text) > 50000:
             problem(
-                "Bug %s's description is too long (%d chars)." % (
-                    bug.get('id'), len(description.text),))
+                "Bug %s's description is too long (%d chars)."
+                % (
+                    bug.get("id"),
+                    len(description.text),
+                )
+            )
             # Compare the description to the first comment. If it's
             # the same, we don't need the description.
             if first_comment_text is None:
@@ -140,14 +142,15 @@ def massage(root, project_name, fix_nickname, tag_nickname):
                 problem_resolution("Adding comment.")
                 raise NotImplementedError("Add a comment.")
             elif description.text == first_comment_text.text:
-                problem_detail('Description is same as first comment.')
-                problem_resolution('Trimming description.')
+                problem_detail("Description is same as first comment.")
+                problem_resolution("Trimming description.")
                 # It's safe to point the user to an attachment here,
                 # even though it has not yet been created. It will be
                 # created later because the first comment is also too
                 # long.
                 description.text = truncate(
-                    description.text, 'see "Full description" attachment')
+                    description.text, 'see "Full description" attachment'
+                )
             else:
                 problem_resolution("Truncating description.")
                 raise NotImplementedError("Fix overlong description.")
@@ -156,35 +159,45 @@ def massage(root, project_name, fix_nickname, tag_nickname):
         # Check first comment text.
         if first_comment_text is not None:
             if len(first_comment_text.text) == 0:
-                problem(
-                    "Bug %s's first comment has no text." % bug.get('id'))
+                problem("Bug %s's first comment has no text." % bug.get("id"))
                 problem_resolution("Setting comment text to '-'.")
-                first_comment_text.text = '-'
+                first_comment_text.text = "-"
                 problem_resolved()
             elif len(first_comment_text.text) > 50000:
                 problem(
-                    "Bug %s's first comment is too long (%d chars)." % (
-                        bug.get('id'), len(first_comment_text.text)))
+                    "Bug %s's first comment is too long (%d chars)."
+                    % (bug.get("id"), len(first_comment_text.text))
+                )
                 # Save the original text as an attachment.
-                problem_resolution('Adding attachment.')
+                problem_resolution("Adding attachment.")
                 attachment = etree.SubElement(
-                    first_comment, '{%s}attachment' % NS)
-                etree.SubElement(attachment, '{%s}filename' % NS).text = (
-                    "%s-bug-%s-full-description.txt" % (
-                        project_name, bug.get('id')))
-                etree.SubElement(attachment, '{%s}title' % NS).text = (
-                    "Full description (text/plain, utf-8)")
-                etree.SubElement(attachment, '{%s}mimetype' % NS).text = (
-                    "text/plain")
-                etree.SubElement(attachment, '{%s}contents' % NS).text = (
-                    standard_b64encode(
-                        first_comment_text.text.encode('utf-8')
-                        ).decode('ascii'))
+                    first_comment, "{%s}attachment" % NS
+                )
+                etree.SubElement(
+                    attachment, "{%s}filename" % NS
+                ).text = "%s-bug-%s-full-description.txt" % (
+                    project_name,
+                    bug.get("id"),
+                )
+                etree.SubElement(
+                    attachment, "{%s}title" % NS
+                ).text = "Full description (text/plain, utf-8)"
+                etree.SubElement(
+                    attachment, "{%s}mimetype" % NS
+                ).text = "text/plain"
+                etree.SubElement(
+                    attachment, "{%s}contents" % NS
+                ).text = standard_b64encode(
+                    first_comment_text.text.encode("utf-8")
+                ).decode(
+                    "ascii"
+                )
                 # Trim the comment text.
-                problem_resolution('Trimming comment text.')
+                problem_resolution("Trimming comment text.")
                 first_comment_text.text = truncate(
                     first_comment_text.text,
-                    'see "Full description" attachment')
+                    'see "Full description" attachment',
+                )
                 problem_resolved()
 
 
@@ -200,25 +213,33 @@ def main(arguments):
         truncated and an attachment is created to hold the original.
         """
     parser = OptionParser(
-        usage=usage,
-        description=description.strip(),
-        add_help_option=False)
+        usage=usage, description=description.strip(), add_help_option=False
+    )
     parser.add_option(
-        "-p", "--project", dest="project_name", metavar="NAME",
-        help="The project to which this import data refers.")
+        "-p",
+        "--project",
+        dest="project_name",
+        metavar="NAME",
+        help="The project to which this import data refers.",
+    )
     parser.add_option(
-        "--fix-nickname", action="store_true", dest="fix_nickname",
-        help="Normalize the nickname to ${project_name}-${bug-id}.")
+        "--fix-nickname",
+        action="store_true",
+        dest="fix_nickname",
+        help="Normalize the nickname to ${project_name}-${bug-id}.",
+    )
     parser.add_option(
-        "--tag-nickname", action="store_true", dest="tag_nickname",
-        help="Add the original bug nickname as a tag.")
+        "--tag-nickname",
+        action="store_true",
+        dest="tag_nickname",
+        help="Add the original bug nickname as a tag.",
+    )
     parser.add_option(
-        "-h", "--help", action="help",
-        help="Show this help message and exit.")
+        "-h", "--help", action="help", help="Show this help message and exit."
+    )
     parser.set_defaults(
-        project_name=None,
-        fix_nickname=False,
-        tag_nickname=False)
+        project_name=None, fix_nickname=False, tag_nickname=False
+    )
 
     options, filenames = parser.parse_args(arguments)
     if options.project_name is None:
@@ -233,13 +254,17 @@ def main(arguments):
             root=tree.getroot(),
             project_name=options.project_name,
             fix_nickname=options.fix_nickname,
-            tag_nickname=options.tag_nickname)
+            tag_nickname=options.tag_nickname,
+        )
         tree.write(
-            (sys.stdout if filename == "-" else filename), encoding='utf-8',
-            pretty_print=True, xml_declaration=True)
+            (sys.stdout if filename == "-" else filename),
+            encoding="utf-8",
+            pretty_print=True,
+            xml_declaration=True,
+        )
 
     return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv[1:]))
diff --git a/utilities/paste b/utilities/paste
index 5d857fb..227f06d 100755
--- a/utilities/paste
+++ b/utilities/paste
@@ -5,24 +5,24 @@
 
 import _pythonpath  # noqa: F401
 
-from http.cookiejar import Cookie
-from optparse import OptionParser
 import os
 import pwd
 import sys
-from urllib.parse import urljoin
 import webbrowser
+from http.cookiejar import Cookie
+from optparse import OptionParser
+from urllib.parse import urljoin
 
 from fixtures import MonkeyPatch
 from zope.testbrowser.browser import Browser
 
-
 # Should we be able to override any of these?
-AUTH_FILE = '~/.lp_auth_cookie'
-PRIVATE_PASTE_HOST = 'pastebin.canonical.com'
-PUBLIC_PASTE_HOST = 'pastebin.ubuntu.com'
-PASTE_PATH = ''
-LP_AUTH_INSTRUCTIONS = """
+AUTH_FILE = "~/.lp_auth_cookie"
+PRIVATE_PASTE_HOST = "pastebin.canonical.com"
+PUBLIC_PASTE_HOST = "pastebin.ubuntu.com"
+PASTE_PATH = ""
+LP_AUTH_INSTRUCTIONS = (
+    """
 %s doesn't contain a valid LP authentication cookie.
 
 Please update this file, with the 'lp' cookie value your browser sends
@@ -30,26 +30,43 @@ when visiting https://launchpad.net (while being logged in). It should
 look something like this:
 
     sd33JsfeJop3esf6joi8sldfjJoIj3dssD6isfsdweJDe6i9JIKEYK
-""" % AUTH_FILE
+"""
+    % AUTH_FILE
+)
 
 
 def parse_arguments():
-    parser = OptionParser(usage='%prog [options] < stdin')
-    parser.add_option('-b', '--browser',
-                      default=False, action='store_true',
-                      help='Open web browser to the pastebin.')
-    parser.add_option('-p', '--private',
-                      default=False, action='store_true',
-                      help='Use a private pastebin (pastebin.canonical.com).')
-    parser.add_option('-s', '--syntax',
-                      default='text', type='string',
-                      help='The syntax of the pastebin.')
-    parser.add_option('-f', '--file',
-                      type='string',
-                      help='File to pastebin instead of stdin.')
+    parser = OptionParser(usage="%prog [options] < stdin")
+    parser.add_option(
+        "-b",
+        "--browser",
+        default=False,
+        action="store_true",
+        help="Open web browser to the pastebin.",
+    )
+    parser.add_option(
+        "-p",
+        "--private",
+        default=False,
+        action="store_true",
+        help="Use a private pastebin (pastebin.canonical.com).",
+    )
+    parser.add_option(
+        "-s",
+        "--syntax",
+        default="text",
+        type="string",
+        help="The syntax of the pastebin.",
+    )
+    parser.add_option(
+        "-f",
+        "--file",
+        type="string",
+        help="File to pastebin instead of stdin.",
+    )
     options, arguments = parser.parse_args()
     if arguments:
-        parser.error('Too many arguments')
+        parser.error("Too many arguments")
         # Does not return
     parser.options = options
     parser.arguments = arguments
@@ -67,25 +84,37 @@ def get_lp_auth_cookie(path):
     finally:
         f.close()
     return Cookie(
-        version=0, name='lp', value=cookie_value,
-        port=None, port_specified=False,
-        domain='login.launchpad.net', domain_specified=True,
-        domain_initial_dot=False, path='', path_specified=None,
-        secure=True, expires=None, discard=True,
-        comment=None, comment_url=None, rest=None, rfc2109=False)
+        version=0,
+        name="lp",
+        value=cookie_value,
+        port=None,
+        port_specified=False,
+        domain="login.launchpad.net",
+        domain_specified=True,
+        domain_initial_dot=False,
+        path="",
+        path_specified=None,
+        secure=True,
+        expires=None,
+        discard=True,
+        comment=None,
+        comment_url=None,
+        rest=None,
+        rfc2109=False,
+    )
 
 
 def authenticate(browser):
     """Go through the OpenID process and authenticate."""
     # First click on the page where it says we have to log in.
-    browser.getControl('Continue').click()
+    browser.getControl("Continue").click()
     return True
 
 
 def main():
     parser = parse_arguments()
     try:
-        poster = os.environ['USER']
+        poster = os.environ["USER"]
     except KeyError:
         poster = pwd.getpwuid(os.getuid()).pw_name
 
@@ -99,10 +128,10 @@ def main():
         content = sys.stdin.read()
 
     form = (
-        ('poster', poster),
-        ('syntax', [parser.options.syntax]),
-        ('content', content),
-        )
+        ("poster", poster),
+        ("syntax", [parser.options.syntax]),
+        ("content", content),
+    )
 
     browser = Browser()
     paste_host = PUBLIC_PASTE_HOST
@@ -118,12 +147,12 @@ def main():
     # Remove the check for robots.txt, since the one on
     # pastebin.ubuntu.com doesn't allow us to open the page. We're not
     # really a robot.
-    with MonkeyPatch('urllib.robotparser.RobotFileParser.allow_all', True):
-        browser.open(urljoin('https://' + paste_host, PASTE_PATH))
+    with MonkeyPatch("urllib.robotparser.RobotFileParser.allow_all", True):
+        browser.open(urljoin("https://" + paste_host, PASTE_PATH))
 
     if parser.options.private:
         # We need to authenticate before pasting.
-        oid_form = browser.getForm(id='openid_message')
+        oid_form = browser.getForm(id="openid_message")
         if oid_form is not None:
             authenticated = authenticate(browser)
             if not authenticated:
@@ -131,11 +160,11 @@ def main():
                 return
     for name, value in form:
         browser.getControl(name=name).value = value
-    browser.getControl('Paste!').click()
+    browser.getControl("Paste!").click()
     print(browser.url)
     if parser.options.browser:
         webbrowser.open(browser.url)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/utilities/pgbackup.py b/utilities/pgbackup.py
index 3454dc9..d78c9a1 100755
--- a/utilities/pgbackup.py
+++ b/utilities/pgbackup.py
@@ -11,34 +11,35 @@ Suitable for use in crontab for daily backups.
 
 __all__ = []
 
-from datetime import datetime
 import logging
-from optparse import OptionParser
 import os
 import os.path
 import stat
 import subprocess
 import sys
+from datetime import datetime
+from optparse import OptionParser
 
+MB = float(1024 * 1024)
 
-MB = float(1024*1024)
+return_code = 0  # Return code of this script. Set to the most recent failed
+# system call's return code
 
-return_code = 0 # Return code of this script. Set to the most recent failed
-                # system call's return code
 
 def call(cmd, **kw):
-    log.debug(' '.join(cmd))
+    log.debug(" ".join(cmd))
     rv = subprocess.call(cmd, **kw)
     if rv != 0:
         global return_code
         return_code = rv
     return rv
 
+
 def main(options, databases):
     global return_code
-    #Need longer file names if this is used more than daily
-    #today = datetime.now().strftime('%Y%m%d_%H:%M:%S')
-    today = datetime.now().strftime('%Y%m%d')
+    # Need longer file names if this is used more than daily
+    # today = datetime.now().strftime('%Y%m%d_%H:%M:%S')
+    today = datetime.now().strftime("%Y%m%d")
 
     backup_dir = options.backup_dir
 
@@ -47,13 +48,13 @@ def main(options, databases):
     # Better to bomb out now rather than to bomb out later, as later might
     # be several hours away.
     for database in databases:
-        dest =  os.path.join(backup_dir, '%s.%s.dump' % (database, today))
+        dest = os.path.join(backup_dir, "%s.%s.dump" % (database, today))
         if os.path.exists(dest):
             log.fatal("%s already exists." % dest)
             return 1
 
     for database in databases:
-        dest =  os.path.join(backup_dir, '%s.%s.dump' % (database, today))
+        dest = os.path.join(backup_dir, "%s.%s.dump" % (database, today))
 
         if os.path.exists(dest):
             log.fatal("%s already exists." % dest)
@@ -61,55 +62,57 @@ def main(options, databases):
 
         cmd = [
             "/usr/bin/pg_dump",
-            "-U", "postgres",
+            "-U",
+            "postgres",
             "--format=c",
             "--compress=9",
             "--blobs",
             "--file=%s" % dest,
             database,
-            ]
+        ]
 
-        rv = call(cmd, stdin=subprocess.PIPE) # Sets return_code on failure.
+        rv = call(cmd, stdin=subprocess.PIPE)  # Sets return_code on failure.
         if rv != 0:
             log.critical("Failed to backup %s (%d)" % (database, rv))
             continue
         size = os.stat(dest)[stat.ST_SIZE]
 
-        log.info("Backed up %s (%0.2fMB)" % (database, size/MB))
+        log.info("Backed up %s (%0.2fMB)" % (database, size / MB))
 
     return return_code
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     parser = OptionParser(
-            usage="usage: %prog [options] database [database ..]"
-            )
-    parser.add_option("-v", "--verbose", dest="verbose", default=0,
-            action="count")
-    parser.add_option("-q", "--quiet", dest="quiet", default=0,
-            action="count")
-    parser.add_option("-d", "--dir", dest="backup_dir",
-            default="/var/lib/postgres/backups")
+        usage="usage: %prog [options] database [database ..]"
+    )
+    parser.add_option(
+        "-v", "--verbose", dest="verbose", default=0, action="count"
+    )
+    parser.add_option("-q", "--quiet", dest="quiet", default=0, action="count")
+    parser.add_option(
+        "-d", "--dir", dest="backup_dir", default="/var/lib/postgres/backups"
+    )
     (options, databases) = parser.parse_args()
     if len(databases) == 0:
         parser.error("must specify at least one database")
     if not os.path.isdir(options.backup_dir):
         parser.error(
-                "Incorrect --dir. %s does not exist or is not a directory" % (
-                    options.backup_dir
-                    )
-                )
+            "Incorrect --dir. %s does not exist or is not a directory"
+            % (options.backup_dir)
+        )
 
     # Setup our log
-    log = logging.getLogger('pgbackup')
+    log = logging.getLogger("pgbackup")
     hdlr = logging.StreamHandler(strm=sys.stderr)
-    hdlr.setFormatter(logging.Formatter(
-            fmt='%(asctime)s %(levelname)s %(message)s'
-            ))
+    hdlr.setFormatter(
+        logging.Formatter(fmt="%(asctime)s %(levelname)s %(message)s")
+    )
     log.addHandler(hdlr)
     verbosity = options.verbose - options.quiet
     if verbosity > 0:
         log.setLevel(logging.DEBUG)
-    elif verbosity == 0: # Default
+    elif verbosity == 0:  # Default
         log.setLevel(logging.INFO)
     elif verbosity == -1:
         log.setLevel(logging.WARN)
diff --git a/utilities/pgcreate.py b/utilities/pgcreate.py
index 9a67a9a..b6d8ac4 100755
--- a/utilities/pgcreate.py
+++ b/utilities/pgcreate.py
@@ -16,21 +16,20 @@ import psycopg2
 
 def main():
     if len(sys.argv) != 3:
-        print('Usage: %s [template] [dbname]' % sys.argv[0], file=sys.stderr)
+        print("Usage: %s [template] [dbname]" % sys.argv[0], file=sys.stderr)
         return 1
 
     template, dbname = sys.argv[1:]
 
     for attempt in range(0, 10):
-        con = psycopg2.connect('dbname=template1')
+        con = psycopg2.connect("dbname=template1")
         con.set_isolation_level(0)
         try:
             cur = con.cursor()
             cur.execute(
-                    "CREATE DATABASE %s TEMPLATE = %s ENCODING = 'UTF8'" % (
-                        dbname, template
-                        )
-                    )
+                "CREATE DATABASE %s TEMPLATE = %s ENCODING = 'UTF8'"
+                % (dbname, template)
+            )
         except psycopg2.Error:
             if attempt == 9:
                 raise
@@ -40,5 +39,6 @@ def main():
             return 0
     return 1
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/pgkillactive.py b/utilities/pgkillactive.py
index 25d722a..d06c481 100755
--- a/utilities/pgkillactive.py
+++ b/utilities/pgkillactive.py
@@ -10,10 +10,10 @@ __all__ = []
 
 import _pythonpath  # noqa: F401
 
-from optparse import OptionParser
 import os
 import signal
 import sys
+from optparse import OptionParser
 
 import psycopg2
 
@@ -23,59 +23,92 @@ from lp.services.database import activity_cols
 def main():
     parser = OptionParser()
     parser.add_option(
-        '-c', '--connection', type='string', dest='connect_string',
-        default='', help="Psycopg connection string",
-        )
+        "-c",
+        "--connection",
+        type="string",
+        dest="connect_string",
+        default="",
+        help="Psycopg connection string",
+    )
     parser.add_option(
-        '-s', '--max-seconds', type='int',
-        dest='max_seconds', default=60 * 60,
-        help='Maximum seconds time connections are allowed to remain active.',
-        )
+        "-s",
+        "--max-seconds",
+        type="int",
+        dest="max_seconds",
+        default=60 * 60,
+        help="Maximum seconds time connections are allowed to remain active.",
+    )
     parser.add_option(
-        '-q', '--quiet', action='store_true', dest="quiet",
-        default=False, help='Silence output',
-        )
+        "-q",
+        "--quiet",
+        action="store_true",
+        dest="quiet",
+        default=False,
+        help="Silence output",
+    )
     parser.add_option(
-        '-n', '--dry-run', action='store_true', default=False,
-        dest='dry_run', help="Dry run - don't kill anything",
-        )
+        "-n",
+        "--dry-run",
+        action="store_true",
+        default=False,
+        dest="dry_run",
+        help="Dry run - don't kill anything",
+    )
     parser.add_option(
-        '-u', '--user', action='append', dest='users',
-        help='Kill connection of users matching REGEXP', metavar='REGEXP')
+        "-u",
+        "--user",
+        action="append",
+        dest="users",
+        help="Kill connection of users matching REGEXP",
+        metavar="REGEXP",
+    )
     options, args = parser.parse_args()
     if len(args) > 0:
-        parser.error('Too many arguments')
+        parser.error("Too many arguments")
     if not options.users:
-        parser.error('--user is required')
+        parser.error("--user is required")
 
-    user_match_sql = 'AND (%s)' % ' OR '.join(
-        ['usename ~* %s'] * len(options.users))
+    user_match_sql = "AND (%s)" % " OR ".join(
+        ["usename ~* %s"] * len(options.users)
+    )
 
     con = psycopg2.connect(options.connect_string)
     cur = con.cursor()
-    cur.execute(("""
+    cur.execute(
+        (
+            """
         SELECT usename, %(pid)s, backend_start, xact_start
         FROM pg_stat_activity
         WHERE xact_start < CURRENT_TIMESTAMP - '%%d seconds'::interval %%s
         ORDER BY %(pid)s
-        """ % activity_cols(cur))
-        % (options.max_seconds, user_match_sql), options.users)
+        """
+            % activity_cols(cur)
+        )
+        % (options.max_seconds, user_match_sql),
+        options.users,
+    )
 
     rows = list(cur.fetchall())
 
     if len(rows) == 0:
         if not options.quiet:
-            print('No transactions to kill')
+            print("No transactions to kill")
             return 0
 
     for usename, pid, backend_start, transaction_start in rows:
-        print('Killing %s (%d), %s, %s' % (
-            usename, pid, backend_start, transaction_start,
-            ))
+        print(
+            "Killing %s (%d), %s, %s"
+            % (
+                usename,
+                pid,
+                backend_start,
+                transaction_start,
+            )
+        )
         if not options.dry_run:
             os.kill(pid, signal.SIGTERM)
     return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/pgkillidle.py b/utilities/pgkillidle.py
index 917c4ae..6dab70b 100755
--- a/utilities/pgkillidle.py
+++ b/utilities/pgkillidle.py
@@ -10,10 +10,10 @@ __all__ = []
 
 import _pythonpath  # noqa: F401
 
-from optparse import OptionParser
 import os
 import signal
 import sys
+from optparse import OptionParser
 
 import psycopg2
 
@@ -23,57 +23,89 @@ from lp.services.database import activity_cols
 def main():
     parser = OptionParser()
     parser.add_option(
-        '-c', '--connection', type='string', dest='connect_string',
-        default='', help="Psycopg connection string",
-        )
+        "-c",
+        "--connection",
+        type="string",
+        dest="connect_string",
+        default="",
+        help="Psycopg connection string",
+    )
     parser.add_option(
-        '-s', '--max-idle-seconds', type='int',
-        dest='max_idle_seconds', default=10 * 60,
-        help='Maximum seconds time idle but open transactions are allowed',
-        )
+        "-s",
+        "--max-idle-seconds",
+        type="int",
+        dest="max_idle_seconds",
+        default=10 * 60,
+        help="Maximum seconds time idle but open transactions are allowed",
+    )
     parser.add_option(
-        '-q', '--quiet', action='store_true', dest="quiet",
-        default=False, help='Silence output',
-        )
+        "-q",
+        "--quiet",
+        action="store_true",
+        dest="quiet",
+        default=False,
+        help="Silence output",
+    )
     parser.add_option(
-        '-n', '--dry-run', action='store_true', default=False,
-        dest='dryrun', help="Dry run - don't kill anything",
-        )
+        "-n",
+        "--dry-run",
+        action="store_true",
+        default=False,
+        dest="dryrun",
+        help="Dry run - don't kill anything",
+    )
     parser.add_option(
-        '-i', '--ignore', action='append', dest='ignore',
-        help='Ignore connections by USER', metavar='USER')
+        "-i",
+        "--ignore",
+        action="append",
+        dest="ignore",
+        help="Ignore connections by USER",
+        metavar="USER",
+    )
     options, args = parser.parse_args()
     if len(args) > 0:
-        parser.error('Too many arguments')
+        parser.error("Too many arguments")
 
-    ignore_sql = ' AND usename <> %s' * len(options.ignore or [])
+    ignore_sql = " AND usename <> %s" * len(options.ignore or [])
 
     con = psycopg2.connect(options.connect_string)
     cur = con.cursor()
-    cur.execute(("""
+    cur.execute(
+        (
+            """
         SELECT usename, %(pid)s, backend_start, query_start
         FROM pg_stat_activity
         WHERE %(query)s = '<IDLE> in transaction'
             AND query_start < CURRENT_TIMESTAMP - '%%d seconds'::interval %%s
         ORDER BY %(pid)s
-        """ % activity_cols(cur))
-        % (options.max_idle_seconds, ignore_sql), options.ignore)
+        """
+            % activity_cols(cur)
+        )
+        % (options.max_idle_seconds, ignore_sql),
+        options.ignore,
+    )
 
     rows = cur.fetchall()
 
     if len(rows) == 0:
         if not options.quiet:
-            print('No IDLE transactions to kill')
+            print("No IDLE transactions to kill")
             return 0
 
     for usename, pid, backend_start, query_start in rows:
-        print('Killing %s(%d), %s, %s' % (
-            usename, pid, backend_start, query_start,
-            ))
+        print(
+            "Killing %s(%d), %s, %s"
+            % (
+                usename,
+                pid,
+                backend_start,
+                query_start,
+            )
+        )
         if not options.dryrun:
             os.kill(pid, signal.SIGTERM)
     return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/pglogwatch.py b/utilities/pglogwatch.py
index 8d61ed1..1f61d3b 100755
--- a/utilities/pglogwatch.py
+++ b/utilities/pglogwatch.py
@@ -7,30 +7,39 @@
 Watch live PostgreSQL logs for interesting stuff
 """
 
-from optparse import OptionParser
 import re
 import subprocess
 import sys
+from optparse import OptionParser
 
 
 def get_options(args=None):
     parser = OptionParser()
-    parser.add_option("-l", "--logfile", dest="logfile",
-            default="/var/log/postgresql/postgres.log",
-            metavar="LOG", help="Monitor LOG instead of the default"
-            )
-    parser.add_option("--slow", dest="slow",
-            type="float", default=100.0, metavar="TIME",
-            help="Report slow queries taking over TIME seconds",
-            )
+    parser.add_option(
+        "-l",
+        "--logfile",
+        dest="logfile",
+        default="/var/log/postgresql/postgres.log",
+        metavar="LOG",
+        help="Monitor LOG instead of the default",
+    )
+    parser.add_option(
+        "--slow",
+        dest="slow",
+        type="float",
+        default=100.0,
+        metavar="TIME",
+        help="Report slow queries taking over TIME seconds",
+    )
     (options, args) = parser.parse_args(args)
     return options
 
+
 def generate_loglines(logfile):
     """Generator returning the next line in the logfile (blocking)"""
     cmd = subprocess.Popen(
-            ['tail', '-f', logfile],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        ["tail", "-f", logfile], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+    )
     while cmd.poll() is None:
         yield cmd.stdout.readline()
     if cmd.returncode != 0:
@@ -49,34 +58,55 @@ class Process:
 
 
 class Watcher:
-    _line_re = re.compile(r"""
+    _line_re = re.compile(
+        r"""
         ^\d{4}-\d\d-\d\d \s \d\d:\d\d:\d\d \s
         \[(?P<pid>\d+)\] \s (?P<type>LOG|ERROR|DETAIL): \s+ (?P<rest>.*)$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _statement_re = re.compile(r"""
+    _statement_re = re.compile(
+        r"""
         ^statement: \s (?P<statement>.*)$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _duration_re = re.compile(r"""
+    _duration_re = re.compile(
+        r"""
         ^duration: \s (?P<duration>\d+\.\d+) \s ms$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _connection_received_re = re.compile(r"""
+    _connection_received_re = re.compile(
+        r"""
         ^connection \s received: \s+ (?P<connection>.*)$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _connection_authorized_re = re.compile(r"""
+    _connection_authorized_re = re.compile(
+        r"""
         ^connection \s authorized: \s+ (?P<auth>.*)$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _ignored_rest_re = re.compile(r"""
+    _ignored_rest_re = re.compile(
+        r"""
         ^(received \s | ERROR: \s | unexpected \s EOF \s) .*$
-        """, re.X)
+        """,
+        re.X,
+    )
 
-    _ignored_statements_re = re.compile(r"""
+    _ignored_statements_re = re.compile(
+        r"""
         ^(BEGIN.*|END)$
-        """, re.X)
+        """,
+        re.X,
+    )
 
     def __init__(self, options):
         self.processes = {}
@@ -91,23 +121,23 @@ class Watcher:
     def feed(self, line):
 
         # Handle continuations of previous statement
-        if line.startswith('\t'):
+        if line.startswith("\t"):
             if self.previous_process is not None:
-                self.previous_process.statement += '\n%s' % line[1:-1]
+                self.previous_process.statement += "\n%s" % line[1:-1]
             return
 
         match = self._line_re.search(line)
         if match is None:
-            raise ValueError('Badly formatted line %r' % (line,))
+            raise ValueError("Badly formatted line %r" % (line,))
 
-        t = match.group('type')
-        if t in ['ERROR', 'DETAIL']:
+        t = match.group("type")
+        if t in ["ERROR", "DETAIL"]:
             return
-        if t != 'LOG':
-            raise ValueError('Unknown line type %s (%r)' % (t, line))
+        if t != "LOG":
+            raise ValueError("Unknown line type %s (%r)" % (t, line))
 
-        pid = int(match.group('pid'))
-        rest = match.group('rest')
+        pid = int(match.group("pid"))
+        rest = match.group("rest")
 
         process = self.processes.get(pid, None)
         if process is None:
@@ -117,16 +147,16 @@ class Watcher:
 
         match = self._statement_re.search(rest)
         if match is not None:
-            statement = match.group('statement')
+            statement = match.group("statement")
             if process.statement:
-                process.statement += '\n%s' % statement
+                process.statement += "\n%s" % statement
             else:
                 process.statement = statement
             return
 
         match = self._duration_re.search(rest)
         if match is not None:
-            process.duration = float(match.group('duration'))
+            process.duration = float(match.group("duration"))
             self.reportDuration(process)
             self.previous_process = None
             del self.processes[process.pid]
@@ -134,19 +164,19 @@ class Watcher:
 
         match = self._connection_received_re.search(rest)
         if match is not None:
-            process.connection = match.group('connection')
+            process.connection = match.group("connection")
             return
 
         match = self._connection_authorized_re.search(rest)
         if match is not None:
-            process.auth = match.group('auth')
+            process.auth = match.group("auth")
             return
 
         match = self._ignored_rest_re.search(rest)
         if match is not None:
             return
 
-        raise ValueError('Unknown entry: %r' % (rest,))
+        raise ValueError("Unknown entry: %r" % (rest,))
 
     def reportDuration(self, process):
         """Report a slow statement if it is above a threshold"""
@@ -158,11 +188,11 @@ class Watcher:
             return
 
         if process.duration > options.slow:
-            print('[%5d] %s' % (process.pid, process.statement))
-            print('        Duration: %0.3f' % (process.duration,))
+            print("[%5d] %s" % (process.pid, process.statement))
+            print("        Duration: %0.3f" % (process.duration,))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     options = get_options()
 
     watcher = Watcher(options)
diff --git a/utilities/pgmassacre.py b/utilities/pgmassacre.py
index 503c14c..4fbf9e2 100755
--- a/utilities/pgmassacre.py
+++ b/utilities/pgmassacre.py
@@ -15,9 +15,9 @@ Cut off access, slaughter connections and burn the database to the ground
 
 import _pythonpath  # noqa: F401
 
-from optparse import OptionParser
 import sys
 import time
+from optparse import OptionParser
 
 import psycopg2
 import psycopg2.extensions
@@ -25,7 +25,7 @@ import psycopg2.extensions
 from lp.services.database import activity_cols
 
 
-def connect(dbname='template1'):
+def connect(dbname="template1"):
     """Connect to the database, returning the DB-API connection."""
     if options.user is not None:
         return psycopg2.connect("dbname=%s user=%s" % (dbname, options.user))
@@ -45,8 +45,8 @@ def rollback_prepared_transactions(database):
 
     # Get a list of outstanding prepared transactions.
     cur.execute(
-            "SELECT gid FROM pg_prepared_xacts WHERE database=%(database)s",
-            vars())
+        "SELECT gid FROM pg_prepared_xacts WHERE database=%(database)s", vars()
+    )
     xids = [row[0] for row in cur.fetchall()]
     for xid in xids:
         cur.execute("ROLLBACK PREPARED %(xid)s", vars())
@@ -67,13 +67,17 @@ def still_open(database, max_wait=120):
     # of the backends are gone.
     start = time.time()
     while time.time() < start + max_wait:
-        cur.execute("""
+        cur.execute(
+            """
             SELECT TRUE FROM pg_stat_activity
             WHERE
                 datname=%%s
                 AND %(pid)s != pg_backend_pid()
             LIMIT 1
-            """ % activity_cols(cur), [database])
+            """
+            % activity_cols(cur),
+            [database],
+        )
         if cur.fetchone() is None:
             return False
         time.sleep(0.6)  # Stats only updated every 500ms.
@@ -89,8 +93,8 @@ def massacre(database):
     # Allow connections to the doomed database if something turned this off,
     # such as an aborted run of this script.
     cur.execute(
-        "UPDATE pg_database SET datallowconn=TRUE WHERE datname=%s",
-        [database])
+        "UPDATE pg_database SET datallowconn=TRUE WHERE datname=%s", [database]
+    )
 
     # Rollback prepared transactions.
     rollback_prepared_transactions(database)
@@ -99,7 +103,8 @@ def massacre(database):
         # Stop connections to the doomed database.
         cur.execute(
             "UPDATE pg_database SET datallowconn=FALSE WHERE datname=%s",
-            [database])
+            [database],
+        )
 
         # New connections are disabled, but pg_stat_activity is only
         # updated every 500ms. Ensure that pg_stat_activity has
@@ -108,21 +113,25 @@ def massacre(database):
         time.sleep(1)
 
         # Terminate open connections.
-        cur.execute("""
+        cur.execute(
+            """
             SELECT %(pid)s, pg_terminate_backend(%(pid)s)
             FROM pg_stat_activity
             WHERE datname=%%s AND %(pid)s <> pg_backend_pid()
-            """ % activity_cols(cur), [database])
+            """
+            % activity_cols(cur),
+            [database],
+        )
         for pid, success in cur.fetchall():
             if not success:
-                print(
-                    "pg_terminate_backend(%s) failed" % pid, file=sys.stderr)
+                print("pg_terminate_backend(%s) failed" % pid, file=sys.stderr)
         con.close()
 
         if still_open(database):
             print(
                 "Unable to kill all backends! Database not destroyed.",
-                file=sys.stderr)
+                file=sys.stderr,
+            )
             return 9
 
         # Destroy the database.
@@ -140,8 +149,9 @@ def massacre(database):
         con.set_isolation_level(0)
         cur = con.cursor()
         cur.execute(
-                "UPDATE pg_database SET datallowconn=TRUE WHERE datname=%s",
-                [database])
+            "UPDATE pg_database SET datallowconn=TRUE WHERE datname=%s",
+            [database],
+        )
         con.close()
 
 
@@ -149,7 +159,8 @@ def rebuild(database, template):
     if still_open(template, 20):
         print(
             "Giving up waiting for connections to %s to drop." % template,
-            file=sys.stderr)
+            file=sys.stderr,
+        )
         report_open_connections(template)
         return 10
 
@@ -160,7 +171,10 @@ def rebuild(database, template):
     con.set_isolation_level(0)  # Autocommit required for CREATE DATABASE.
     create_db_cmd = """
         CREATE DATABASE %s WITH ENCODING='UTF8' TEMPLATE=%s
-        """ % (database, template)
+        """ % (
+        database,
+        template,
+    )
     # 8.4 allows us to create empty databases with a different locale
     # to template1 by using the template0 database as a template.
     # We make use of this feature so we don't have to care what locale
@@ -187,17 +201,21 @@ def rebuild(database, template):
 def report_open_connections(database):
     con = connect()
     cur = con.cursor()
-    cur.execute("""
+    cur.execute(
+        """
         SELECT usename, datname, count(*)
         FROM pg_stat_activity
         WHERE %(pid)s != pg_backend_pid()
         GROUP BY usename, datname
         ORDER BY datname, usename
-        """ % activity_cols(cur))
+        """
+        % activity_cols(cur)
+    )
     for usename, datname, num_connections in cur.fetchall():
         print(
             "%d connections by %s to %s" % (num_connections, usename, datname),
-            file=sys.stderr)
+            file=sys.stderr,
+        )
     con.close()
 
 
@@ -206,24 +224,36 @@ options = None
 
 def main():
     parser = OptionParser("Usage: %prog [options] DBNAME")
-    parser.add_option("-U", "--user", dest="user", default=None,
-        help="Connect as USER", metavar="USER")
-    parser.add_option("-t", "--template", dest="template", default=None,
+    parser.add_option(
+        "-U",
+        "--user",
+        dest="user",
+        default=None,
+        help="Connect as USER",
+        metavar="USER",
+    )
+    parser.add_option(
+        "-t",
+        "--template",
+        dest="template",
+        default=None,
         help="Recreate database using DBNAME as a template database."
-            " If template0, database will be created in the C locale.",
-        metavar="DBNAME")
+        " If template0, database will be created in the C locale.",
+        metavar="DBNAME",
+    )
     global options
     (options, args) = parser.parse_args()
 
     if len(args) != 1:
-        parser.error('Must specify one, and only one, database to destroy')
+        parser.error("Must specify one, and only one, database to destroy")
 
     database = args[0]
 
     # Don't be stupid protection.
-    if database in ('template1', 'template0'):
+    if database in ("template1", "template0"):
         parser.error(
-            "Running this script against template1 or template0 is nuts.")
+            "Running this script against template1 or template0 is nuts."
+        )
 
     con = connect()
     cur = con.cursor()
@@ -231,11 +261,12 @@ def main():
     # Ensure the template database exists.
     if options.template is not None:
         cur.execute(
-            "SELECT TRUE FROM pg_database WHERE datname=%s",
-            [options.template])
+            "SELECT TRUE FROM pg_database WHERE datname=%s", [options.template]
+        )
         if cur.fetchone() is None:
             parser.error(
-                "Template database %s does not exist." % options.template)
+                "Template database %s does not exist." % options.template
+            )
     # If the database doesn't exist, no point attempting to drop it.
     cur.execute("SELECT TRUE FROM pg_database WHERE datname=%s", [database])
     db_exists = cur.fetchone() is not None
@@ -253,5 +284,5 @@ def main():
         return 0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
diff --git a/utilities/pgstats.py b/utilities/pgstats.py
index 546350d..d470605 100755
--- a/utilities/pgstats.py
+++ b/utilities/pgstats.py
@@ -16,53 +16,58 @@ import psycopg2
 def percentage(num, total):
     """Return a percentage string of num/total"""
     if total == 0:
-        return 'Unknown'
+        return "Unknown"
     else:
-        return '%3.2f%%' % ( (num * 100.0) / total, )
+        return "%3.2f%%" % ((num * 100.0) / total,)
 
 
 def print_row(key, value):
-    print('%(key)-20s: %(value)s' % vars())
+    print("%(key)-20s: %(value)s" % vars())
 
 
 def pgstattuple(cur, table):
-    """Return the result of PostgreSQL contribs's pgstattuple function
-    """
-    cur.execute("""
+    """Return the result of PostgreSQL contribs's pgstattuple function"""
+    cur.execute(
+        """
         SELECT
             table_len, tuple_count, tuple_len, tuple_percent,
             dead_tuple_count, dead_tuple_len, dead_tuple_percent,
             free_space, free_percent
         FROM pgstattuple(%(table)s)
-        """, vars())
+        """,
+        vars(),
+    )
     pgstattuple = cur.fetchone()
     return {
-        'name': table,
-        'table_len': pgstattuple[0],
-        'tuple_count': pgstattuple[1],
-        'tuple_len': pgstattuple[2],
-        'tuple_percent': pgstattuple[3],
-        'dead_tuple_count': pgstattuple[4],
-        'dead_tuple_len': pgstattuple[5],
-        'dead_tuple_percent': pgstattuple[6],
-        'free_space': pgstattuple[7],
-        'free_percent': pgstattuple[8],
-        }
+        "name": table,
+        "table_len": pgstattuple[0],
+        "tuple_count": pgstattuple[1],
+        "tuple_len": pgstattuple[2],
+        "tuple_percent": pgstattuple[3],
+        "dead_tuple_count": pgstattuple[4],
+        "dead_tuple_len": pgstattuple[5],
+        "dead_tuple_percent": pgstattuple[6],
+        "free_space": pgstattuple[7],
+        "free_percent": pgstattuple[8],
+    }
 
 
 def main(dbname):
     con = psycopg2.connect("dbname=%s" % dbname)
     cur = con.cursor()
 
-    print('Statistics for %s' % dbname)
-    print('===============' + '=' * (len(dbname)))
+    print("Statistics for %s" % dbname)
+    print("===============" + "=" * (len(dbname)))
 
     # Database level statistics
-    cur.execute("""
+    cur.execute(
+        """
         SELECT blks_hit, blks_read, numbackends,xact_commit, xact_rollback
             FROM pg_stat_database
             WHERE datname=%(dbname)s
-        """, vars())
+        """,
+        vars(),
+    )
     hit, read, backends, commits, rollbacks = cur.fetchone()
 
     hit_rate = percentage(hit, hit + read)
@@ -75,56 +80,67 @@ def main(dbname):
     print_row("Commit rate", commit_rate)
 
     # Determine dead tuple bloat, if we have pgstattuple installed
-    cur.execute("""
+    cur.execute(
+        """
         SELECT COUNT(*) FROM pg_proc, pg_namespace
         WHERE pg_proc.pronamespace = pg_namespace.oid
             AND pg_namespace.nspname = 'public'
             AND proname = 'pgstattuple'
-        """)
-    pgstattuple_installed = (cur.fetchone()[0] > 0)
+        """
+    )
+    pgstattuple_installed = cur.fetchone()[0] > 0
     if pgstattuple_installed:
-        cur.execute("""
+        cur.execute(
+            """
             SELECT nspname || '.' || relname
             FROM pg_class, pg_namespace
             WHERE pg_class.relnamespace = pg_namespace.oid
                 AND pg_class.relkind = 'r'
                 ORDER BY nspname, relname
-            """)
+            """
+        )
         all_tables = [r[0] for r in cur.fetchall()]
         total_live_bytes = 0
         total_dead_bytes = 0
         stats = []
         for table in all_tables:
             stat = pgstattuple(cur, table)
-            total_live_bytes += stat['tuple_len']
-            total_dead_bytes += stat['dead_tuple_len']
+            total_live_bytes += stat["tuple_len"]
+            total_dead_bytes += stat["dead_tuple_len"]
             stats.append(stat)
         # Just report the worst offenders
-        stats.sort(key=lambda x: x['dead_tuple_percent'], reverse=True)
+        stats.sort(key=lambda x: x["dead_tuple_percent"], reverse=True)
         stats = [
-            s for s in stats if s['dead_tuple_percent'] >= 10
-                and s['dead_tuple_len'] >= 25 * 1024 * 1024
-            ]
+            s
+            for s in stats
+            if s["dead_tuple_percent"] >= 10
+            and s["dead_tuple_len"] >= 25 * 1024 * 1024
+        ]
+
         def statstr(stat):
-            name = stat['name']
-            dead_tuple_percent = stat['dead_tuple_percent']
-            dead_len = stat['dead_tuple_len'] / (1024*1024)
+            name = stat["name"]
+            dead_tuple_percent = stat["dead_tuple_percent"]
+            dead_len = stat["dead_tuple_len"] / (1024 * 1024)
             return (
-                '%(name)s (%(dead_len)0.2fMB, '
-                '%(dead_tuple_percent)0.2f%%)' % {
-                    'name': name,
-                    'dead_len': dead_len,
-                    'dead_tuple_percent': dead_tuple_percent,
-                    })
+                "%(name)s (%(dead_len)0.2fMB, "
+                "%(dead_tuple_percent)0.2f%%)"
+                % {
+                    "name": name,
+                    "dead_len": dead_len,
+                    "dead_tuple_percent": dead_tuple_percent,
+                }
+            )
+
         if len(stats) > 0:
-            print_row('Needing vacuum', statstr(stats[0]))
+            print_row("Needing vacuum", statstr(stats[0]))
             for stat in stats[1:]:
-                print_row('', statstr(stat))
+                print_row("", statstr(stat))
 
     # Unused indexes, ignoring primary keys.
     # XXX Stuart Bishop 2005-06-28:
     # We should identify constraints used to enforce uniqueness too
-    cur.execute("""
+    cur.execute(
+        """
         SELECT relname, indexrelname
             FROM pg_stat_user_indexes AS u JOIN pg_indexes AS i
                 ON u.schemaname = i.schemaname
@@ -135,17 +151,19 @@ def main(dbname):
                 AND indexrelname NOT LIKE '%_pkey'
                 AND indexdef NOT LIKE 'CREATE UNIQUE %'
             ORDER BY relname, indexrelname
-        """)
+        """
+    )
 
     rows = cur.fetchall()
     if len(rows) == 0:
-        print_row('Unused indexes', 'N/A')
+        print_row("Unused indexes", "N/A")
     else:
-        print_row('Unused indexes', rows[0][1])
+        print_row("Unused indexes", rows[0][1])
         for table, index in rows[1:]:
-            print_row('', index)
+            print_row("", index)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     if len(sys.argv) != 2:
         print("Usage: %s [DBNAME]" % sys.argv[0], file=sys.stderr)
         sys.exit(1)
diff --git a/utilities/publish-to-swift b/utilities/publish-to-swift
index 84de4c1..93280d8 100755
--- a/utilities/publish-to-swift
+++ b/utilities/publish-to-swift
@@ -7,17 +7,17 @@
 
 import _pythonpath  # noqa: F401
 
-from argparse import ArgumentParser
 import os
+from argparse import ArgumentParser
 
 import iso8601
 import requests
 from swiftclient.service import (
-    get_conn,
-    process_options,
     SwiftService,
     SwiftUploadObject,
-    )
+    get_conn,
+    process_options,
+)
 from swiftclient.shell import add_default_args
 
 
@@ -38,30 +38,42 @@ def get_swift_storage_url(options):
     return get_conn(options).get_auth()[0]
 
 
-def publish_file_to_swift(options, container_name, object_path, local_path,
-                          overwrite=True):
+def publish_file_to_swift(
+    options, container_name, object_path, local_path, overwrite=True
+):
     """Publish a file to a Swift container."""
     storage_url = get_swift_storage_url(options)
 
     with SwiftService(options=options) as swift:
         stat_results = swift.stat(
-            container=container_name, objects=[object_path])
+            container=container_name, objects=[object_path]
+        )
         if stat_results and next(stat_results)["success"]:
-            print("Object {} already published to {}.".format(
-                object_path, container_name))
+            print(
+                "Object {} already published to {}.".format(
+                    object_path, container_name
+                )
+            )
             if not overwrite:
                 return
 
-        print("Publishing {} to {} as {}.".format(
-            local_path, container_name, object_path))
+        print(
+            "Publishing {} to {} as {}.".format(
+                local_path, container_name, object_path
+            )
+        )
         for r in swift.upload(
-                container_name,
-                [SwiftUploadObject(local_path, object_name=object_path)]):
+            container_name,
+            [SwiftUploadObject(local_path, object_name=object_path)],
+        ):
             if not r["success"]:
                 raise r["error"]
 
-        print("Published file: {}/{}/{}".format(
-            storage_url, container_name, object_path))
+        print(
+            "Published file: {}/{}/{}".format(
+                storage_url, container_name, object_path
+            )
+        )
 
 
 def prune_old_files_from_swift(options, container_name, object_dir):
@@ -74,8 +86,9 @@ def prune_old_files_from_swift(options, container_name, object_dir):
         objs = {}
         production_mtime = None
         for stats in swift.list(
-                container=container_name,
-                options={"prefix": "{}/".format(object_dir)}):
+            container=container_name,
+            options={"prefix": "{}/".format(object_dir)},
+        ):
             if not stats["success"]:
                 raise stats["error"]
             for item in stats["listing"]:
@@ -83,20 +96,23 @@ def prune_old_files_from_swift(options, container_name, object_dir):
                     mtime = iso8601.parse_date(item["last_modified"])
                     objs[item["name"]] = mtime
                     if item["name"].startswith(
-                            "{}/{}/".format(object_dir, production_revision)):
+                        "{}/{}/".format(object_dir, production_revision)
+                    ):
                         production_mtime = mtime
 
         if production_mtime is None:
             print(
                 "No file in {} corresponding to production revision {}; "
-                "not pruning.".format(container_name, production_revision))
+                "not pruning.".format(container_name, production_revision)
+            )
             return
 
         for object_name, mtime in sorted(objs.items()):
             if mtime < production_mtime:
                 print("Pruning {} (older than production)".format(object_name))
                 for r in swift.delete(
-                        container=container_name, objects=[object_name]):
+                    container=container_name, objects=[object_name]
+                ):
                     if not r["success"]:
                         raise r["error"]
 
@@ -137,7 +153,7 @@ def main():
             "OS_USER_DOMAIN_ID",
             "OS_USER_DOMAIN_NAME",
             "OS_USER_ID",
-            }
+        }
         for key, value in sorted(os.environ.items()):
             if key.startswith("OS_"):
                 if key not in safe_keys:
@@ -150,10 +166,15 @@ def main():
     overwrite = "FORCE_REBUILD" in os.environ
     ensure_container_privs(options, args.container_name)
     publish_file_to_swift(
-        options, args.container_name, args.swift_object_path, args.local_path,
-        overwrite=overwrite)
+        options,
+        args.container_name,
+        args.swift_object_path,
+        args.local_path,
+        overwrite=overwrite,
+    )
     prune_old_files_from_swift(
-        options, args.container_name, args.swift_object_path.split("/")[0])
+        options, args.container_name, args.swift_object_path.split("/")[0]
+    )
 
 
 if __name__ == "__main__":
diff --git a/utilities/report-database-stats.py b/utilities/report-database-stats.py
index a63b487..4396ef5 100755
--- a/utilities/report-database-stats.py
+++ b/utilities/report-database-stats.py
@@ -8,17 +8,11 @@ import _pythonpath  # noqa: F401
 
 from datetime import datetime
 from operator import attrgetter
-from textwrap import (
-    dedent,
-    fill,
-    )
+from textwrap import dedent, fill
 
 from lp.scripts.helpers import LPOptionParser
 from lp.services.database.namedrow import named_fetchall
-from lp.services.database.sqlbase import (
-    connect,
-    sqlvalues,
-    )
+from lp.services.database.sqlbase import connect, sqlvalues
 from lp.services.scripts import db_options
 
 
@@ -26,7 +20,7 @@ class Table:
     pass
 
 
-def get_where_clause(options, fuzz='0 seconds'):
+def get_where_clause(options, fuzz="0 seconds"):
     "Generate a WHERE clause referencing the date_created column."
     # We have two of the from timestamp, the until timestamp and an
     # interval. The interval is in a format unsuitable for processing in
@@ -36,40 +30,49 @@ def get_where_clause(options, fuzz='0 seconds'):
     # generate the SQL representation of the from timestamp and the
     # until timestamp.
     if options.from_ts:
-        from_sql = ("CAST(%s AS timestamp without time zone)"
-            % sqlvalues(options.from_ts))
+        from_sql = "CAST(%s AS timestamp without time zone)" % sqlvalues(
+            options.from_ts
+        )
     elif options.interval and options.until_ts:
         from_sql = (
             "CAST(%s AS timestamp without time zone) - CAST(%s AS interval)"
-            % sqlvalues(options.until_ts, options.interval))
+            % sqlvalues(options.until_ts, options.interval)
+        )
     elif options.interval:
         from_sql = (
             "(CURRENT_TIMESTAMP AT TIME ZONE 'UTC') - CAST(%s AS interval)"
-            % sqlvalues(options.interval))
+            % sqlvalues(options.interval)
+        )
     else:
         from_sql = "CAST('1970-01-01' AS timestamp without time zone)"
 
     if options.until_ts:
-        until_sql = (
-            "CAST(%s AS timestamp without time zone)"
-            % sqlvalues(options.until_ts))
+        until_sql = "CAST(%s AS timestamp without time zone)" % sqlvalues(
+            options.until_ts
+        )
     elif options.interval and options.from_ts:
         until_sql = (
             "CAST(%s AS timestamp without time zone) + CAST(%s AS interval)"
-            % sqlvalues(options.from_ts, options.interval))
+            % sqlvalues(options.from_ts, options.interval)
+        )
     else:
         until_sql = "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'"
 
     fuzz_sql = "CAST(%s AS interval)" % sqlvalues(fuzz)
     clause = "date_created BETWEEN (%s - %s) AND (%s + %s)" % (
-        from_sql, fuzz_sql, until_sql, fuzz_sql)
+        from_sql,
+        fuzz_sql,
+        until_sql,
+        fuzz_sql,
+    )
 
     return clause
 
 
 def get_table_stats(cur, options):
-    params = {'where': get_where_clause(options)}
-    tablestats_query = dedent("""\
+    params = {"where": get_where_clause(options)}
+    tablestats_query = dedent(
+        """\
         SELECT
             Earliest.date_created AS date_start,
             Latest.date_created AS date_end,
@@ -101,7 +104,9 @@ def get_table_stats(cur, options):
                 WHERE %(where)s)
             AND Earliest.schemaname = Latest.schemaname
             AND Earliest.relname = Latest.relname
-        """ % params)
+        """
+        % params
+    )
     cur.execute(tablestats_query)
 
     # description[0] is the column name, per PEP-0249
@@ -113,7 +118,8 @@ def get_table_stats(cur, options):
             setattr(table, fields[index], row[index])
         table.total_tup_read = table.seq_tup_read + table.idx_tup_fetch
         table.total_tup_written = (
-            table.n_tup_ins + table.n_tup_upd + table.n_tup_del)
+            table.n_tup_ins + table.n_tup_upd + table.n_tup_del
+        )
         tables.add(table)
 
     return tables
@@ -127,8 +133,9 @@ def get_cpu_stats(cur, options):
     # database users not connected when the sample was taken are not
     # recorded - we want the average utilization over the time period,
     # not the subset of the time period the user was actually connected.
-    params = {'where': get_where_clause(options)}
-    query = dedent("""\
+    params = {"where": get_where_clause(options)}
+    query = dedent(
+        """\
         SELECT (
             CAST(SUM(cpu) AS float) / (
                 SELECT COUNT(DISTINCT date_created) FROM DatabaseCpuStats
@@ -137,7 +144,9 @@ def get_cpu_stats(cur, options):
         FROM DatabaseCpuStats
         WHERE %(where)s
         GROUP BY username
-        """ % params)
+        """
+        % params
+    )
     cur.execute(query)
     cpu_stats = set(cur.fetchall())
 
@@ -148,13 +157,13 @@ def get_cpu_stats(cur, options):
     edge_avg_cpu = 0.0
     for stats_tuple in list(cpu_stats):
         avg_cpu, username = stats_tuple
-        if username == 'lpnet':
+        if username == "lpnet":
             lpnet_avg_cpu = avg_cpu
             cpu_stats.discard(stats_tuple)
-        elif username == 'edge':
+        elif username == "edge":
             edge_avg_cpu = avg_cpu
             cpu_stats.discard(stats_tuple)
-    cpu_stats.add((lpnet_avg_cpu + edge_avg_cpu, 'lpnet'))
+    cpu_stats.add((lpnet_avg_cpu + edge_avg_cpu, "lpnet"))
 
     return cpu_stats
 
@@ -168,12 +177,13 @@ def get_bloat_stats(cur, options, kind):
         # we cannot guarantee the disk utilization statistics occur
         # exactly 24 hours apart. Our most recent snapshot could be 1
         # day ago, give or take a few hours.
-        'where': get_where_clause(options, fuzz='1 day 6 hours'),
-        'bloat': options.bloat,
-        'min_bloat': options.min_bloat,
-        'kind': kind,
-        }
-    query = dedent("""
+        "where": get_where_clause(options, fuzz="1 day 6 hours"),
+        "bloat": options.bloat,
+        "min_bloat": options.min_bloat,
+        "kind": kind,
+    }
+    query = dedent(
+        """
         SELECT * FROM (
             SELECT DISTINCT
                 namespace,
@@ -210,7 +220,9 @@ def get_bloat_stats(cur, options, kind):
             table_len >= %(min_bloat)s
             AND end_bloat_percent >= %(bloat)s
         ORDER BY bloat_len DESC
-        """ % params)
+        """
+        % params
+    )
     cur.execute(query, params)
     bloat_stats = named_fetchall(cur)
     return list(bloat_stats)
@@ -220,38 +232,69 @@ def main():
     parser = LPOptionParser()
     db_options(parser)
     parser.add_option(
-        "-f", "--from", dest="from_ts", type=datetime,
-        default=None, metavar="TIMESTAMP",
-        help="Use statistics collected since TIMESTAMP.")
+        "-f",
+        "--from",
+        dest="from_ts",
+        type=datetime,
+        default=None,
+        metavar="TIMESTAMP",
+        help="Use statistics collected since TIMESTAMP.",
+    )
     parser.add_option(
-        "-u", "--until", dest="until_ts", type=datetime,
-        default=None, metavar="TIMESTAMP",
-        help="Use statistics collected up until TIMESTAMP.")
+        "-u",
+        "--until",
+        dest="until_ts",
+        type=datetime,
+        default=None,
+        metavar="TIMESTAMP",
+        help="Use statistics collected up until TIMESTAMP.",
+    )
     parser.add_option(
-        "-i", "--interval", dest="interval", type=str,
-        default=None, metavar="INTERVAL",
+        "-i",
+        "--interval",
+        dest="interval",
+        type=str,
+        default=None,
+        metavar="INTERVAL",
         help=(
             "Use statistics collected over the last INTERVAL period. "
             "INTERVAL is a string parsable by PostgreSQL "
-            "such as '5 minutes'."))
+            "such as '5 minutes'."
+        ),
+    )
     parser.add_option(
-        "-n", "--limit", dest="limit", type=int,
-        default=15, metavar="NUM",
-        help="Display the top NUM items in each category.")
+        "-n",
+        "--limit",
+        dest="limit",
+        type=int,
+        default=15,
+        metavar="NUM",
+        help="Display the top NUM items in each category.",
+    )
     parser.add_option(
-        "-b", "--bloat", dest="bloat", type=float,
-        default=40, metavar="BLOAT",
-        help="Display tables and indexes bloated by more than BLOAT%.")
+        "-b",
+        "--bloat",
+        dest="bloat",
+        type=float,
+        default=40,
+        metavar="BLOAT",
+        help="Display tables and indexes bloated by more than BLOAT%.",
+    )
     parser.add_option(
-        "--min-bloat", dest="min_bloat", type=int,
-        default=10000000, metavar="BLOAT",
-        help="Don't report tables bloated less than BLOAT bytes.")
+        "--min-bloat",
+        dest="min_bloat",
+        type=int,
+        default=10000000,
+        metavar="BLOAT",
+        help="Don't report tables bloated less than BLOAT bytes.",
+    )
     parser.set_defaults(dbuser="database_stats_report")
     options, args = parser.parse_args()
 
     if options.from_ts and options.until_ts and options.interval:
         parser.error(
-            "Only two of --from, --until and --interval may be specified.")
+            "Only two of --from, --until and --interval may be specified."
+        )
 
     con = connect()
     cur = con.cursor()
@@ -268,19 +311,27 @@ def main():
     user_cpu = get_cpu_stats(cur, options)
     print("== Most Active Users ==")
     print()
-    for cpu, username in sorted(user_cpu, reverse=True)[:options.limit]:
+    for cpu, username in sorted(user_cpu, reverse=True)[: options.limit]:
         print("%40s || %10.2f%% CPU" % (username, float(cpu) / 10))
 
     print()
     print("== Most Written Tables ==")
     print()
     tables_sort = [
-        'total_tup_written', 'n_tup_upd', 'n_tup_ins', 'n_tup_del', 'relname']
+        "total_tup_written",
+        "n_tup_upd",
+        "n_tup_ins",
+        "n_tup_del",
+        "relname",
+    ]
     most_written_tables = sorted(
-        tables, key=attrgetter(*tables_sort), reverse=True)
-    for table in most_written_tables[:options.limit]:
-        print("%40s || %10.2f tuples/sec" % (
-            table.relname, table.total_tup_written / per_second))
+        tables, key=attrgetter(*tables_sort), reverse=True
+    )
+    for table in most_written_tables[: options.limit]:
+        print(
+            "%40s || %10.2f tuples/sec"
+            % (table.relname, table.total_tup_written / per_second)
+        )
 
     print()
     print("== Most Read Tables ==")
@@ -289,14 +340,17 @@ def main():
     # namespace (normally 'public'), relname is the table (relation)
     # name. total_tup_red is the total number of rows read.
     # idx_tup_fetch is the number of rows looked up using an index.
-    tables_sort = ['total_tup_read', 'idx_tup_fetch', 'schemaname', 'relname']
+    tables_sort = ["total_tup_read", "idx_tup_fetch", "schemaname", "relname"]
     most_read_tables = sorted(
-        tables, key=attrgetter(*tables_sort), reverse=True)
-    for table in most_read_tables[:options.limit]:
-        print("%40s || %10.2f tuples/sec" % (
-            table.relname, table.total_tup_read / per_second))
+        tables, key=attrgetter(*tables_sort), reverse=True
+    )
+    for table in most_read_tables[: options.limit]:
+        print(
+            "%40s || %10.2f tuples/sec"
+            % (table.relname, table.total_tup_read / per_second)
+        )
 
-    table_bloat_stats = get_bloat_stats(cur, options, 'r')
+    table_bloat_stats = get_bloat_stats(cur, options, "r")
 
     if not table_bloat_stats:
         print()
@@ -306,67 +360,91 @@ def main():
         print()
         print("== Most Bloated Tables ==")
         print()
-        for bloated_table in table_bloat_stats[:options.limit]:
-            print("%40s || %2d%% || %s of %s" % (
-                bloated_table.name,
-                bloated_table.end_bloat_percent,
-                bloated_table.bloat_size,
-                bloated_table.table_size))
-
-        index_bloat_stats = get_bloat_stats(cur, options, 'i')
+        for bloated_table in table_bloat_stats[: options.limit]:
+            print(
+                "%40s || %2d%% || %s of %s"
+                % (
+                    bloated_table.name,
+                    bloated_table.end_bloat_percent,
+                    bloated_table.bloat_size,
+                    bloated_table.table_size,
+                )
+            )
+
+        index_bloat_stats = get_bloat_stats(cur, options, "i")
 
         print()
         print("== Most Bloated Indexes ==")
         print()
-        for bloated_index in index_bloat_stats[:options.limit]:
-            print("%65s || %2d%% || %s of %s" % (
-                bloated_index.sub_name,
-                bloated_index.end_bloat_percent,
-                bloated_index.bloat_size,
-                bloated_index.table_size))
+        for bloated_index in index_bloat_stats[: options.limit]:
+            print(
+                "%65s || %2d%% || %s of %s"
+                % (
+                    bloated_index.sub_name,
+                    bloated_index.end_bloat_percent,
+                    bloated_index.bloat_size,
+                    bloated_index.table_size,
+                )
+            )
 
         # Order bloat delta report by size of bloat increase.
         # We might want to change this to percentage bloat increase.
         bloating_sort_key = lambda x: x.delta_bloat_len
 
         table_bloating_stats = sorted(
-            table_bloat_stats, key=bloating_sort_key, reverse=True)
+            table_bloat_stats, key=bloating_sort_key, reverse=True
+        )
 
         if table_bloating_stats[0].num_samples <= 1:
             print()
-            print(fill(dedent("""\
+            print(
+                fill(
+                    dedent(
+                        """\
                 (There are not enough samples in this time range to display
                 bloat change statistics)
-                """)))
+                """
+                    )
+                )
+            )
         else:
             print()
             print("== Most Bloating Tables ==")
             print()
 
-            for bloated_table in table_bloating_stats[:options.limit]:
+            for bloated_table in table_bloating_stats[: options.limit]:
                 # Bloat decreases are uninteresting, and would need to be in
                 # a separate table sorted in reverse anyway.
                 if bloated_table.delta_bloat_percent > 0:
-                    print("%40s || +%4.2f%% || +%s" % (
-                        bloated_table.name,
-                        bloated_table.delta_bloat_percent,
-                        bloated_table.delta_bloat_size))
+                    print(
+                        "%40s || +%4.2f%% || +%s"
+                        % (
+                            bloated_table.name,
+                            bloated_table.delta_bloat_percent,
+                            bloated_table.delta_bloat_size,
+                        )
+                    )
 
             index_bloating_stats = sorted(
-                index_bloat_stats, key=bloating_sort_key, reverse=True)
+                index_bloat_stats, key=bloating_sort_key, reverse=True
+            )
 
             print()
             print("== Most Bloating Indexes ==")
             print()
-            for bloated_index in index_bloating_stats[:options.limit]:
+            for bloated_index in index_bloating_stats[: options.limit]:
                 # Bloat decreases are uninteresting, and would need to be in
                 # a separate table sorted in reverse anyway.
                 if bloated_index.delta_bloat_percent > 0:
-                    print("%65s || +%4.2f%% || +%s" % (
-                        bloated_index.sub_name,
-                        bloated_index.delta_bloat_percent,
-                        bloated_index.delta_bloat_size))
+                    print(
+                        "%65s || +%4.2f%% || +%s"
+                        % (
+                            bloated_index.sub_name,
+                            bloated_index.delta_bloat_percent,
+                            bloated_index.delta_bloat_size,
+                        )
+                    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/utilities/roundup-sniffer.py b/utilities/roundup-sniffer.py
index 16bebbe..6e82bd6 100755
--- a/utilities/roundup-sniffer.py
+++ b/utilities/roundup-sniffer.py
@@ -33,16 +33,13 @@ populate the class-level "fields" variable. See MplayerStatusSniffer
 for an example.
 """
 
-from base64 import urlsafe_b64encode
 import csv
 import optparse
+import sys
+from base64 import urlsafe_b64encode
 from os import mkdir
-from os.path import (
-    exists,
-    join,
-    )
+from os.path import exists, join
 from pprint import pprint
-import sys
 from time import sleep
 from urllib.parse import urlencode
 from urllib.request import urlopen
@@ -53,7 +50,7 @@ from lp.services.beautifulsoup import BeautifulSoup
 class RoundupSniffer:
     """Sniffs the meaning of numeric fields in remote Roundups."""
 
-    fields = ('status',)
+    fields = ("status",)
 
     def __init__(self, base_url, cache_dir):
         self.base_url = base_url
@@ -65,23 +62,24 @@ class RoundupSniffer:
         """Fetch the URL, consulting the cache first."""
         filename = join(
             self.cache_dir,
-            urlsafe_b64encode(url.encode('UTF-8')).decode('ASCII'))
+            urlsafe_b64encode(url.encode("UTF-8")).decode("ASCII"),
+        )
         if not exists(filename):
-            open(filename, 'wb').write(urlopen(url).read())
-        return open(filename, 'rb')
+            open(filename, "wb").write(urlopen(url).read())
+        return open(filename, "rb")
 
     def get_all_bugs(self):
-        all_fields = ['id']
+        all_fields = ["id"]
         all_fields.extend(self.fields)
         query = [
-            ('@action', 'export_csv'),
-            ('@columns', ','.join(all_fields)),
-            ('@sort', 'activity'),
-            ('@group', 'priority'),
-            ('@pagesize', '50'),
-            ('@startwith', '0'),
-            ]
-        url = '%s?%s' % (self.base_url, urlencode(query))
+            ("@action", "export_csv"),
+            ("@columns", ",".join(all_fields)),
+            ("@sort", "activity"),
+            ("@group", "priority"),
+            ("@pagesize", "50"),
+            ("@startwith", "0"),
+        ]
+        url = "%s?%s" % (self.base_url, urlencode(query))
         bugs = csv.DictReader(self.fetch(url))
         return list(bugs)
 
@@ -98,19 +96,22 @@ class MplayerStatusSniffer(RoundupSniffer):
     be useful in general.
     """
 
-    fields = ('status', 'substatus')
+    fields = ("status", "substatus")
 
     def get_text_values(self, bug):
         """Returns the text of status and substatus for the given bug.
 
         This is done by downloading the HTML bug page and scraping it.
         """
-        url = '%s%s' % (self.base_url, bug['id'])
+        url = "%s%s" % (self.base_url, bug["id"])
         page = self.fetch(url).read()
         soup = BeautifulSoup(page)
         return tuple(
-            node.string for node in
-            soup.find('th', text='Status').find_next('td').find_all('span'))
+            node.string
+            for node in soup.find("th", text="Status")
+            .find_next("td")
+            .find_all("span")
+        )
 
 
 def get_distinct(things, fields):
@@ -118,8 +119,10 @@ def get_distinct(things, fields):
 
     For each combination also return one example thing.
     """
+
     def key(thing):
         return tuple(thing[field] for field in fields)
+
     return {key(thing): thing for thing in things}
 
 
@@ -135,41 +138,56 @@ def gen_mapping(sniffer):
 def parse_args(args):
     parser = optparse.OptionParser()
     parser.add_option(
-        "--base-url", dest="base_url",
+        "--base-url",
+        dest="base_url",
         help="The base URL at the remote Roundup instance.",
-        metavar="URL")
+        metavar="URL",
+    )
     parser.add_option(
-        "--delay", dest="delay", type="int",
-        help=("The number of seconds to wait between each page "
-              "load [default: %default]."))
+        "--delay",
+        dest="delay",
+        type="int",
+        help=(
+            "The number of seconds to wait between each page "
+            "load [default: %default]."
+        ),
+    )
     parser.add_option(
-        "--cache-dir", dest="cache_dir",
-        help=("A directory in which to cache fetched resources "
-              "[default: %default]."),
-        metavar="DIR")
+        "--cache-dir",
+        dest="cache_dir",
+        help=(
+            "A directory in which to cache fetched resources "
+            "[default: %default]."
+        ),
+        metavar="DIR",
+    )
     parser.add_option(
-        "--sniffer-class", dest="sniffer_class",
+        "--sniffer-class",
+        dest="sniffer_class",
         help="The sniffer class to use [default: %default].",
-        metavar="CLASSNAME")
+        metavar="CLASSNAME",
+    )
     parser.set_defaults(
-        delay=0, cache_dir="roundup_sniffer_cache",
-        sniffer_class="MplayerStatusSniffer")
+        delay=0,
+        cache_dir="roundup_sniffer_cache",
+        sniffer_class="MplayerStatusSniffer",
+    )
 
     options, args = parser.parse_args(args)
 
     if not options.base_url:
         parser.error("Please specify a base URL.")
     if len(args) > 0:
-        parser.error("Positional arguments are not accepted: %s" %
-                     ' '.join(args))
+        parser.error(
+            "Positional arguments are not accepted: %s" % " ".join(args)
+        )
 
     return options
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     options = parse_args(sys.argv[1:])
-    sniffer = eval(options.sniffer_class)(
-        options.base_url, options.cache_dir)
+    sniffer = eval(options.sniffer_class)(options.base_url, options.cache_dir)
     mapping = {}
     for raw, text in gen_mapping(sniffer):
         mapping[raw] = text
diff --git a/utilities/run-as b/utilities/run-as
index f936e77..d834287 100755
--- a/utilities/run-as
+++ b/utilities/run-as
@@ -15,7 +15,6 @@ import pwd
 import resource
 import sys
 
-
 user = sys.argv[1]
 pw = pwd.getpwnam(user)
 os.setresgid(pw.pw_gid, pw.pw_gid, pw.pw_gid)
diff --git a/utilities/script_commands.py b/utilities/script_commands.py
index 13fc27d..27e8afd 100644
--- a/utilities/script_commands.py
+++ b/utilities/script_commands.py
@@ -12,9 +12,11 @@ def add_dict(name, **kwargs):
     The kwargs are the contents of the dict.
     :param name: The name of the dictionary to add.
     """
+
     def decorator(func):
         setattr(func, name, kwargs)
         return func
+
     return decorator
 
 
@@ -24,7 +26,7 @@ def types(**kwargs):
     The kwargs are the values to set, as used by OptionParser.add_option::
       @types(port="int", delay=int)
     """
-    return add_dict('_types', **kwargs)
+    return add_dict("_types", **kwargs)
 
 
 def helps(**kwargs):
@@ -33,7 +35,7 @@ def helps(**kwargs):
     The kwargs are used to assign help::
       helps(port="The port to use.", delay="The time to wait.")
     """
-    return add_dict('_helps', **kwargs)
+    return add_dict("_helps", **kwargs)
 
 
 def get_function_parser(function):
@@ -50,8 +52,8 @@ def get_function_parser(function):
     args, ignore, ignored, defaults = inspect.getargspec(function)
     if defaults is None:
         defaults = [None] * len(args)
-    arg_types = getattr(function, '_types', {})
-    arg_helps = getattr(function, '_helps', {})
+    arg_types = getattr(function, "_types", {})
+    arg_helps = getattr(function, "_helps", {})
     for arg, default in zip(args, defaults):
         arg_type = arg_types.get(arg)
         if arg_type is None:
@@ -60,9 +62,10 @@ def get_function_parser(function):
             arg_type = type(default)
         arg_help = arg_helps.get(arg)
         if arg_help is not None:
-            arg_help += ' Default: %default.'
+            arg_help += " Default: %default."
         parser.add_option(
-            '--%s' % arg, type=arg_type, help=arg_help, default=default)
+            "--%s" % arg, type=arg_type, help=arg_help, default=default
+        )
     return parser
 
 
@@ -82,7 +85,7 @@ def parse_args(command, args):
     # have defaults, but declaring them as positional would prevent them from
     # being treated as flags.
     if len(args) != 0:
-        raise UserError('Too many arguments.')
+        raise UserError("Too many arguments.")
     return {}
 
 
@@ -107,11 +110,14 @@ def run_subcommand(subcommands, argv):
         subcommand name.
     """
     if len(argv) < 1:
-        raise UserError('Must supply a command: %s.' %
-                        ', '.join(subcommands.keys()))
+        raise UserError(
+            "Must supply a command: %s." % ", ".join(subcommands.keys())
+        )
     try:
         command = subcommands[argv[0]]
     except KeyError:
-        raise UserError('%s invalid.  Valid commands: %s.' %
-                        (argv[0], ', '.join(subcommands.keys())))
+        raise UserError(
+            "%s invalid.  Valid commands: %s."
+            % (argv[0], ", ".join(subcommands.keys()))
+        )
     run_from_args(command, argv[1:])
diff --git a/utilities/shhh.py b/utilities/shhh.py
index be6b51e..1ff3322 100755
--- a/utilities/shhh.py
+++ b/utilities/shhh.py
@@ -8,11 +8,8 @@ Run a command and suppress output unless it returns a non-zero exit status.
 """
 
 import os
-from subprocess import (
-    PIPE,
-    Popen,
-    )
 import sys
+from subprocess import PIPE, Popen
 
 
 def shhh(cmd):
@@ -90,5 +87,5 @@ def shhh(cmd):
         return process.returncode
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(shhh(sys.argv[1:]))
diff --git a/utilities/smoke-test-librarian.py b/utilities/smoke-test-librarian.py
index 4b0e269..eeb88ba 100755
--- a/utilities/smoke-test-librarian.py
+++ b/utilities/smoke-test-librarian.py
@@ -15,12 +15,11 @@ from zope.component import getUtility
 from lp.services.librarian.interfaces.client import (
     ILibrarianClient,
     IRestrictedLibrarianClient,
-    )
+)
 from lp.services.librarian.smoketest import do_smoketest
 from lp.services.scripts import execute_zcml_for_scripts
 
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     execute_zcml_for_scripts()
     restricted_client = getUtility(IRestrictedLibrarianClient)
     regular_client = getUtility(ILibrarianClient)
diff --git a/utilities/soyuz-sampledata-setup.py b/utilities/soyuz-sampledata-setup.py
index 71642cf..ed70561 100755
--- a/utilities/soyuz-sampledata-setup.py
+++ b/utilities/soyuz-sampledata-setup.py
@@ -25,8 +25,8 @@ import subprocess
 import sys
 from textwrap import dedent
 
-from storm.store import Store
 import transaction
+from storm.store import Store
 from zope.component import getUtility
 from zope.event import notify
 from zope.lifecycleevent import ObjectCreatedEvent
@@ -38,25 +38,21 @@ from lp.registry.interfaces.codeofconduct import ISignedCodeOfConductSet
 from lp.registry.interfaces.person import IPersonSet
 from lp.registry.interfaces.series import SeriesStatus
 from lp.registry.model.codeofconduct import SignedCodeOfConduct
-from lp.services.database.interfaces import (
-    IMasterStore,
-    IStandbyStore,
-    )
+from lp.services.database.interfaces import IMasterStore, IStandbyStore
 from lp.services.scripts.base import LaunchpadScript
 from lp.soyuz.enums import SourcePackageFormat
 from lp.soyuz.interfaces.component import IComponentSet
 from lp.soyuz.interfaces.section import ISectionSet
 from lp.soyuz.interfaces.sourcepackageformat import (
     ISourcePackageFormatSelectionSet,
-    )
+)
 from lp.soyuz.model.component import ComponentSelection
 from lp.soyuz.model.section import SectionSelection
 from lp.soyuz.scripts.initialize_distroseries import InitializeDistroSeries
 from lp.testing.factory import LaunchpadObjectFactory
 
-
-user_name = 'ppa-user'
-default_email = '[e-mail]' % user_name
+user_name = "ppa-user"
+default_email = "[e-mail]" % user_name
 
 
 class DoNotRunOnProduction(Exception):
@@ -82,19 +78,21 @@ def check_preconditions(options):
 
     # Just a guess, but dev systems aren't likely to have ids this high
     # in this table.  Production data does.
-    real_data = (get_max_id(store, "TranslationMessage") >= 1000000)
+    real_data = get_max_id(store, "TranslationMessage") >= 1000000
     if real_data and not options.force:
         raise DoNotRunOnProduction(
-            "Refusing to delete Ubuntu data unless you --force me.")
+            "Refusing to delete Ubuntu data unless you --force me."
+        )
 
     # For some configs it's just absolutely clear this script shouldn't
     # run.  Don't even accept --force there.
-    forbidden_configs = re.compile('(edge|lpnet|production)')
-    current_config = os.getenv('LPCONFIG', 'an unknown config')
+    forbidden_configs = re.compile("(edge|lpnet|production)")
+    current_config = os.getenv("LPCONFIG", "an unknown config")
     if forbidden_configs.match(current_config):
         raise DoNotRunOnProduction(
             "I won't delete Ubuntu data on %s and you can't --force me."
-            % current_config)
+            % current_config
+        )
 
 
 def get_person_set():
@@ -112,9 +110,11 @@ def retire_active_publishing_histories(histories, requester):
     """Retire all active publishing histories in the given collection."""
     # Avoid circular import.
     from lp.soyuz.interfaces.publishing import active_publishing_status
+
     for history in histories(status=active_publishing_status):
         history.requestDeletion(
-            requester, "Cleaned up because of missing Librarian files.")
+            requester, "Cleaned up because of missing Librarian files."
+        )
 
 
 def retire_distro_archives(distribution, culprit):
@@ -128,9 +128,11 @@ def retire_distro_archives(distribution, culprit):
 
     for archive in distribution.all_distro_archives:
         retire_active_publishing_histories(
-            archive.getPublishedSources, culprit)
+            archive.getPublishedSources, culprit
+        )
         retire_active_publishing_histories(
-            archive.getAllPublishedBinaries, culprit)
+            archive.getAllPublishedBinaries, culprit
+        )
 
 
 def retire_ppas(distribution):
@@ -146,9 +148,12 @@ def add_architecture(distroseries, architecture_name):
 
     processor = getUtility(IProcessorSet).getByName(architecture_name)
     archseries = DistroArchSeries(
-        distroseries=distroseries, processor=processor,
-        owner=distroseries.owner, official=True,
-        architecturetag=architecture_name)
+        distroseries=distroseries,
+        processor=processor,
+        owner=distroseries.owner,
+        official=True,
+        architecturetag=architecture_name,
+    )
     IMasterStore(DistroArchSeries).add(archseries)
 
 
@@ -162,26 +167,75 @@ def create_sections(distroseries):
     for it to be precisely accurate.
     """
     section_names = (
-        'admin', 'cli-mono', 'comm', 'database', 'debug', 'devel', 'doc',
-        'editors', 'education', 'electronics', 'embedded', 'fonts', 'games',
-        'gnome', 'gnu-r', 'gnustep', 'golang', 'graphics', 'hamradio',
-        'haskell', 'httpd', 'interpreters', 'java', 'javascript', 'kde',
-        'kernel', 'libdevel', 'libs', 'lisp', 'localization', 'mail',
-        'math', 'misc', 'net', 'news', 'ocaml', 'oldlibs', 'otherosfs',
-        'perl', 'php', 'python', 'raku', 'ruby', 'rust', 'science',
-        'shells', 'sound', 'tex', 'text', 'utils', 'vcs', 'video', 'web',
-        'x11', 'xfce', 'zope')
+        "admin",
+        "cli-mono",
+        "comm",
+        "database",
+        "debug",
+        "devel",
+        "doc",
+        "editors",
+        "education",
+        "electronics",
+        "embedded",
+        "fonts",
+        "games",
+        "gnome",
+        "gnu-r",
+        "gnustep",
+        "golang",
+        "graphics",
+        "hamradio",
+        "haskell",
+        "httpd",
+        "interpreters",
+        "java",
+        "javascript",
+        "kde",
+        "kernel",
+        "libdevel",
+        "libs",
+        "lisp",
+        "localization",
+        "mail",
+        "math",
+        "misc",
+        "net",
+        "news",
+        "ocaml",
+        "oldlibs",
+        "otherosfs",
+        "perl",
+        "php",
+        "python",
+        "raku",
+        "ruby",
+        "rust",
+        "science",
+        "shells",
+        "sound",
+        "tex",
+        "text",
+        "utils",
+        "vcs",
+        "video",
+        "web",
+        "x11",
+        "xfce",
+        "zope",
+    )
     store = Store.of(distroseries)
     for section_name in section_names:
         section = getUtility(ISectionSet).ensure(section_name)
         if section not in distroseries.sections:
             store.add(
-                SectionSelection(distroseries=distroseries, section=section))
+                SectionSelection(distroseries=distroseries, section=section)
+            )
 
 
 def create_components(distroseries, uploader):
     """Set up some components for `distroseries`."""
-    component_names = ('main', 'restricted', 'universe', 'multiverse')
+    component_names = ("main", "restricted", "universe", "multiverse")
     store = Store.of(distroseries)
     main_archive = distroseries.distribution.main_archive
     for component_name in component_names:
@@ -189,7 +243,9 @@ def create_components(distroseries, uploader):
         if component not in distroseries.components:
             store.add(
                 ComponentSelection(
-                    distroseries=distroseries, component=component))
+                    distroseries=distroseries, component=component
+                )
+            )
         main_archive.newComponentUploader(uploader, component)
         main_archive.newQueueAdmin(uploader, component)
 
@@ -201,10 +257,16 @@ def create_series(parent, full_name, version, status):
     name = full_name.split()[0].lower()
     title = "The " + full_name
     display_name = full_name.split()[0]
-    new_series = distribution.newSeries(name=name, title=title,
-        display_name=display_name, summary='Ubuntu %s is good.' % version,
-        description='%s is awesome.' % version, version=version,
-        previous_series=None, registrant=registrant)
+    new_series = distribution.newSeries(
+        name=name,
+        title=title,
+        display_name=display_name,
+        summary="Ubuntu %s is good." % version,
+        description="%s is awesome." % version,
+        version=version,
+        previous_series=None,
+        registrant=registrant,
+    )
     new_series.status = status
     notify(ObjectCreatedEvent(new_series))
 
@@ -222,48 +284,48 @@ def create_sample_series(original_series, log):
         and so on.
     """
     series_descriptions = [
-        ('Dapper Drake', SeriesStatus.OBSOLETE, '6.06'),
-        ('Edgy Eft', SeriesStatus.OBSOLETE, '6.10'),
-        ('Feisty Fawn', SeriesStatus.OBSOLETE, '7.04'),
-        ('Gutsy Gibbon', SeriesStatus.OBSOLETE, '7.10'),
-        ('Hardy Heron', SeriesStatus.OBSOLETE, '8.04'),
-        ('Intrepid Ibex', SeriesStatus.OBSOLETE, '8.10'),
-        ('Jaunty Jackalope', SeriesStatus.OBSOLETE, '9.04'),
-        ('Karmic Koala', SeriesStatus.OBSOLETE, '9.10'),
-        ('Lucid Lynx', SeriesStatus.OBSOLETE, '10.04'),
-        ('Maverick Meerkat', SeriesStatus.OBSOLETE, '10.10'),
-        ('Natty Narwhal', SeriesStatus.OBSOLETE, '11.04'),
-        ('Oneiric Ocelot', SeriesStatus.OBSOLETE, '11.10'),
-        ('Precise Pangolin', SeriesStatus.OBSOLETE, '12.04'),
-        ('Quantal Quetzal', SeriesStatus.OBSOLETE, '12.10'),
-        ('Raring Ringtail', SeriesStatus.OBSOLETE, '13.04'),
-        ('Saucy Salamander', SeriesStatus.OBSOLETE, '13.10'),
-        ('Trusty Tahr', SeriesStatus.SUPPORTED, '14.04'),
-        ('Utopic Unicorn', SeriesStatus.OBSOLETE, '14.10'),
-        ('Vivid Vervet', SeriesStatus.OBSOLETE, '15.04'),
-        ('Wily Werewolf', SeriesStatus.OBSOLETE, '15.10'),
-        ('Xenial Xerus', SeriesStatus.SUPPORTED, '16.04'),
-        ('Yakkety Yak', SeriesStatus.OBSOLETE, '16.10'),
-        ('Zesty Zapus', SeriesStatus.OBSOLETE, '17.04'),
-        ('Artful Aardvark', SeriesStatus.OBSOLETE, '17.10'),
-        ('Bionic Beaver', SeriesStatus.SUPPORTED, '18.04'),
-        ('Cosmic Cuttlefish', SeriesStatus.OBSOLETE, '18.10'),
-        ('Disco Dingo', SeriesStatus.OBSOLETE, '19.04'),
-        ('Eoan Ermine', SeriesStatus.OBSOLETE, '19.10'),
-        ('Focal Fossa', SeriesStatus.SUPPORTED, '20.04'),
-        ('Groovy Gorilla', SeriesStatus.OBSOLETE, '20.10'),
-        ('Hirsute Hippo', SeriesStatus.OBSOLETE, '21.04'),
-        ('Impish Indri', SeriesStatus.CURRENT, '21.10'),
-        ('Jammy Jellyfish', SeriesStatus.DEVELOPMENT, '22.04'),
-        ]
+        ("Dapper Drake", SeriesStatus.OBSOLETE, "6.06"),
+        ("Edgy Eft", SeriesStatus.OBSOLETE, "6.10"),
+        ("Feisty Fawn", SeriesStatus.OBSOLETE, "7.04"),
+        ("Gutsy Gibbon", SeriesStatus.OBSOLETE, "7.10"),
+        ("Hardy Heron", SeriesStatus.OBSOLETE, "8.04"),
+        ("Intrepid Ibex", SeriesStatus.OBSOLETE, "8.10"),
+        ("Jaunty Jackalope", SeriesStatus.OBSOLETE, "9.04"),
+        ("Karmic Koala", SeriesStatus.OBSOLETE, "9.10"),
+        ("Lucid Lynx", SeriesStatus.OBSOLETE, "10.04"),
+        ("Maverick Meerkat", SeriesStatus.OBSOLETE, "10.10"),
+        ("Natty Narwhal", SeriesStatus.OBSOLETE, "11.04"),
+        ("Oneiric Ocelot", SeriesStatus.OBSOLETE, "11.10"),
+        ("Precise Pangolin", SeriesStatus.OBSOLETE, "12.04"),
+        ("Quantal Quetzal", SeriesStatus.OBSOLETE, "12.10"),
+        ("Raring Ringtail", SeriesStatus.OBSOLETE, "13.04"),
+        ("Saucy Salamander", SeriesStatus.OBSOLETE, "13.10"),
+        ("Trusty Tahr", SeriesStatus.SUPPORTED, "14.04"),
+        ("Utopic Unicorn", SeriesStatus.OBSOLETE, "14.10"),
+        ("Vivid Vervet", SeriesStatus.OBSOLETE, "15.04"),
+        ("Wily Werewolf", SeriesStatus.OBSOLETE, "15.10"),
+        ("Xenial Xerus", SeriesStatus.SUPPORTED, "16.04"),
+        ("Yakkety Yak", SeriesStatus.OBSOLETE, "16.10"),
+        ("Zesty Zapus", SeriesStatus.OBSOLETE, "17.04"),
+        ("Artful Aardvark", SeriesStatus.OBSOLETE, "17.10"),
+        ("Bionic Beaver", SeriesStatus.SUPPORTED, "18.04"),
+        ("Cosmic Cuttlefish", SeriesStatus.OBSOLETE, "18.10"),
+        ("Disco Dingo", SeriesStatus.OBSOLETE, "19.04"),
+        ("Eoan Ermine", SeriesStatus.OBSOLETE, "19.10"),
+        ("Focal Fossa", SeriesStatus.SUPPORTED, "20.04"),
+        ("Groovy Gorilla", SeriesStatus.OBSOLETE, "20.10"),
+        ("Hirsute Hippo", SeriesStatus.OBSOLETE, "21.04"),
+        ("Impish Indri", SeriesStatus.CURRENT, "21.10"),
+        ("Jammy Jellyfish", SeriesStatus.DEVELOPMENT, "22.04"),
+    ]
 
     parent = original_series
     for full_name, status, version in series_descriptions:
-        log.info('Creating %s...' % full_name)
+        log.info("Creating %s..." % full_name)
         parent = create_series(parent, full_name, version, status)
         # Karmic is the first series in which the 3.0 formats are
         # allowed. Subsequent series will inherit them.
-        if version == '9.10':
+        if version == "9.10":
             spfss = getUtility(ISourcePackageFormatSelectionSet)
             spfss.add(parent, SourcePackageFormat.FORMAT_3_0_QUILT)
             spfss.add(parent, SourcePackageFormat.FORMAT_3_0_NATIVE)
@@ -271,9 +333,10 @@ def create_sample_series(original_series, log):
 
 def add_series_component(series):
     """Permit a component in the given series."""
-    component = getUtility(IComponentSet)['main']
+    component = getUtility(IComponentSet)["main"]
     IMasterStore(ComponentSelection).add(
-        ComponentSelection(distroseries=series, component=component))
+        ComponentSelection(distroseries=series, component=component)
+    )
 
 
 def clean_up(distribution, log):
@@ -285,7 +348,7 @@ def clean_up(distribution, log):
     # published binaries without corresponding sources.
 
     log.info("Deleting all items in official archives...")
-    retire_distro_archives(distribution, get_person_set().getByName('name16'))
+    retire_distro_archives(distribution, get_person_set().getByName("name16"))
 
     # Disable publishing of all PPAs, as they probably have broken
     # publishings too.
@@ -295,7 +358,7 @@ def clean_up(distribution, log):
     retire_series(distribution)
 
     # grumpy has no components, which upsets the publisher.
-    add_series_component(distribution['grumpy'])
+    add_series_component(distribution["grumpy"])
 
 
 def set_source_package_format(distroseries):
@@ -312,7 +375,7 @@ def populate(distribution, previous_series_name, uploader_name, options, log):
 
     log.info("Configuring sections...")
     create_sections(previous_series)
-    add_architecture(previous_series, 'amd64')
+    add_architecture(previous_series, "amd64")
 
     log.info("Configuring components and permissions...")
     uploader = get_person_set().getByName(uploader_name)
@@ -333,24 +396,28 @@ def sign_code_of_conduct(person, log):
     signedcocset = getUtility(ISignedCodeOfConductSet)
     if signedcocset.searchByUser(person).count() == 0:
         fake_gpg_key = LaunchpadObjectFactory().makeGPGKey(person)
-        Store.of(person).add(SignedCodeOfConduct(
-            owner=person, signing_key_fingerprint=fake_gpg_key.fingerprint,
-            signedcode="Normally a signed CoC would go here.", active=True))
+        Store.of(person).add(
+            SignedCodeOfConduct(
+                owner=person,
+                signing_key_fingerprint=fake_gpg_key.fingerprint,
+                signedcode="Normally a signed CoC would go here.",
+                active=True,
+            )
+        )
 
 
 def create_ppa_user(username, options, approver, log):
     """Create new user, with password "test," and sign code of conduct."""
     person = get_person_set().getByName(username)
     if person is None:
-        have_email = (options.email != default_email)
-        command_line = [
-            'utilities/make-lp-user', username, 'ubuntu-team']
+        have_email = options.email != default_email
+        command_line = ["utilities/make-lp-user", username, "ubuntu-team"]
         if have_email:
-            command_line += ['--email', options.email]
+            command_line += ["--email", options.email]
 
         pipe = subprocess.Popen(command_line, stderr=subprocess.PIPE)
         stdout, stderr = pipe.communicate()
-        if stderr != '':
+        if stderr != "":
             print(stderr)
         if pipe.returncode != 0:
             sys.exit(2)
@@ -366,11 +433,16 @@ def create_ppa_user(username, options, approver, log):
 def create_ppa(distribution, person, name):
     """Create a PPA for `person`."""
     ppa = LaunchpadObjectFactory().makeArchive(
-        distribution=distribution, owner=person, name=name, virtualized=False,
-        description="Automatically created test PPA.")
+        distribution=distribution,
+        owner=person,
+        name=name,
+        virtualized=False,
+        description="Automatically created test PPA.",
+    )
     ppa.external_dependencies = (
         "deb http://archive.ubuntu.com/ubuntu %(series)s "
-        "main restricted universe multiverse\n")
+        "main restricted universe multiverse\n"
+    )
 
 
 class SoyuzSampledataSetup(LaunchpadScript):
@@ -379,14 +451,23 @@ class SoyuzSampledataSetup(LaunchpadScript):
 
     def add_my_options(self):
         self.parser.add_option(
-            '-f', '--force', action='store_true', dest='force',
-            help="DANGEROUS: run even if the database looks production-like.")
+            "-f",
+            "--force",
+            action="store_true",
+            dest="force",
+            help="DANGEROUS: run even if the database looks production-like.",
+        )
         self.parser.add_option(
-            '-e', '--email', action='store', dest='email',
+            "-e",
+            "--email",
+            action="store",
+            dest="email",
             default=default_email,
             help=(
                 "Email address to use for %s.  Should match your GPG key."
-                % user_name))
+                % user_name
+            ),
+        )
 
     def main(self):
         check_preconditions(self.options.force)
@@ -395,26 +476,30 @@ class SoyuzSampledataSetup(LaunchpadScript):
         clean_up(ubuntu, self.logger)
 
         # Use Hoary as the root, as Breezy and Grumpy are broken.
-        populate(ubuntu, 'hoary', 'ubuntu-team', self.options, self.logger)
+        populate(ubuntu, "hoary", "ubuntu-team", self.options, self.logger)
 
-        admin = get_person_set().getByName('name16')
+        admin = get_person_set().getByName("name16")
         person = create_ppa_user(user_name, self.options, admin, self.logger)
 
-        create_ppa(ubuntu, person, 'test-ppa')
+        create_ppa(ubuntu, person, "test-ppa")
 
         transaction.commit()
         self.logger.info("Done.")
 
-        print(dedent("""
+        print(
+            dedent(
+                """
             Now start your local Launchpad with "make run_codehosting" and log
             into https://launchpad.test/ as "%(email)s" with "test" as the
             password.
             Your user name will be %(user_name)s."""
-            % {
-                'email': self.options.email,
-                'user_name': user_name,
-                }))
+                % {
+                    "email": self.options.email,
+                    "user_name": user_name,
+                }
+            )
+        )
 
 
 if __name__ == "__main__":
-    SoyuzSampledataSetup('soyuz-sampledata-setup').lock_and_run()
+    SoyuzSampledataSetup("soyuz-sampledata-setup").lock_and_run()
diff --git a/utilities/update-copyright b/utilities/update-copyright
index 2910c7e..5c4c027 100755
--- a/utilities/update-copyright
+++ b/utilities/update-copyright
@@ -10,35 +10,34 @@ notice to reflect the current year. Looks for the notice in the first three
 lines of the file and leaves the file unchanged if it finds none.
 """
 
-from datetime import date
 import os
 import re
-from subprocess import (
-    PIPE,
-    Popen,
-    )
 import sys
-
+from datetime import date
+from subprocess import PIPE, Popen
 
 # This script lives in the 'utilites' directory.
 UTILITIES_DIR = os.path.dirname(__file__)
 CURRENT_YEAR = date.today().year
 copyright_pattern = re.compile(
-    "Copyright (?P<years>(?P<yearfrom>[0-9]{4})(-[0-9]{4})?) Canonical Ltd.")
+    "Copyright (?P<years>(?P<yearfrom>[0-9]{4})(-[0-9]{4})?) Canonical Ltd."
+)
+
 
 def years_string(yearfrom):
     """Build the new years string."""
     if int(yearfrom) >= CURRENT_YEAR:
-       return yearfrom
+        return yearfrom
     return "%s-%d" % (yearfrom, CURRENT_YEAR)
 
+
 def update_copyright(lines):
     """Update the copyright notice in the given file lines."""
     for line in range(min(len(lines), 5)):
         match = copyright_pattern.search(lines[line])
         if match is not None:
-            old_years = match.group('years')
-            new_years = years_string(match.group('yearfrom'))
+            old_years = match.group("years")
+            new_years = years_string(match.group("yearfrom"))
             if old_years != new_years:
                 lines[line] = lines[line].replace(old_years, new_years)
                 return True
@@ -50,8 +49,10 @@ def update_files(filenames):
     """Open the files with the given file names and update them."""
     for filename in filenames:
         if not os.path.isfile(filename):
-            print("Skipped: %s does not exist or is not a regular file." %(
-                filename))
+            print(
+                "Skipped: %s does not exist or is not a regular file."
+                % (filename)
+            )
             continue
         if not os.access(filename, os.W_OK):
             print("Skipped: %s is not writeable." % filename)
@@ -60,28 +61,32 @@ def update_files(filenames):
             lines = f.readlines()
         changed = update_copyright(lines)
         if changed:
-            newfile = open(filename, 'w')
-            newfile.write(''.join(lines))
+            newfile = open(filename, "w")
+            newfile.write("".join(lines))
             newfile.close()
             print("Updated: %s" % filename)
         else:
             print("Unchanged: %s" % filename)
 
+
 def find_changed_files():
     """Use the find-changed-files.sh script."""
     find_changed_files_cmd = [
-        os.path.join(UTILITIES_DIR, 'find-changed-files.sh')]
+        os.path.join(UTILITIES_DIR, "find-changed-files.sh")
+    ]
     filenames = Popen(
-        find_changed_files_cmd, stdout=PIPE,
-        universal_newlines=True).communicate()[0]
+        find_changed_files_cmd, stdout=PIPE, universal_newlines=True
+    ).communicate()[0]
     return filenames.strip()
 
+
 def find_and_update():
     """Put it all together."""
     filenames = find_changed_files()
-    if filenames != '':
+    if filenames != "":
         update_files(filenames.splitlines())
 
+
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         find_and_update()
diff --git a/utilities/update-sourcecode b/utilities/update-sourcecode
index df0dac7..e1aabde 100755
--- a/utilities/update-sourcecode
+++ b/utilities/update-sourcecode
@@ -8,12 +8,10 @@
 import os
 import sys
 
-
 sys.path.insert(0,
     os.path.join(os.path.dirname(os.path.dirname(__file__)), 'lib'))
 
 from devscripts import sourcecode  # noqa: E402
 
-
 if __name__ == '__main__':
     sys.exit(sourcecode.main(sys.argv))