Reformat code using Black

As discussed over the mailing list, reformat code using Black. This is a
one-off change to reformat all our codebase. Moving forward, we
shouldn't expect such blanket reformats. Rather, we expect each change
to already comply with the Black formatting style.

7 files changed, 1099 insertions, 883 deletions

diff --git a/src/buildstream/_frontend/app.py b/src/buildstream/_frontend/app.py
index 99e164358..09610851f 100644
--- a/src/buildstream/_frontend/app.py
+++ b/src/buildstream/_frontend/app.py
@@ -56,19 +56,18 @@ INDENT = 4
 #    main_options (dict): The main CLI options of the `bst`
 #                         command, before any subcommand
 #
-class App():
-
+class App:
     def __init__(self, main_options):
 
         #
         # Public members
         #
-        self.context = None        # The Context object
-        self.stream = None         # The Stream object
-        self.project = None        # The toplevel Project object
-        self.logger = None         # The LogLine object
-        self.interactive = None    # Whether we are running in interactive mode
-        self.colors = None         # Whether to use colors in logging
+        self.context = None  # The Context object
+        self.stream = None  # The Stream object
+        self.project = None  # The toplevel Project object
+        self.logger = None  # The LogLine object
+        self.interactive = None  # Whether we are running in interactive mode
+        self.colors = None  # Whether to use colors in logging
 
         #
         # Private members
@@ -76,18 +75,18 @@ class App():
         self._session_start = datetime.datetime.now()
         self._session_name = None
         self._main_options = main_options  # Main CLI options, before any command
-        self._status = None                # The Status object
-        self._fail_messages = {}           # Failure messages by unique plugin id
+        self._status = None  # The Status object
+        self._fail_messages = {}  # Failure messages by unique plugin id
         self._interactive_failures = None  # Whether to handle failures interactively
-        self._started = False              # Whether a session has started
-        self._set_project_dir = False      # Whether -C option was used
-        self._state = None                 # Frontend reads this and registers callbacks
+        self._started = False  # Whether a session has started
+        self._set_project_dir = False  # Whether -C option was used
+        self._state = None  # Frontend reads this and registers callbacks
 
         # UI Colors Profiles
-        self._content_profile = Profile(fg='yellow')
-        self._format_profile = Profile(fg='cyan', dim=True)
-        self._success_profile = Profile(fg='green')
-        self._error_profile = Profile(fg='red', dim=True)
+        self._content_profile = Profile(fg="yellow")
+        self._format_profile = Profile(fg="cyan", dim=True)
+        self._success_profile = Profile(fg="green")
+        self._error_profile = Profile(fg="red", dim=True)
         self._detail_profile = Profile(dim=True)
 
         #
@@ -96,31 +95,31 @@ class App():
         is_a_tty = sys.stdout.isatty() and sys.stderr.isatty()
 
         # Enable interactive mode if we're attached to a tty
-        if main_options['no_interactive']:
+        if main_options["no_interactive"]:
             self.interactive = False
         else:
             self.interactive = is_a_tty
 
         # Handle errors interactively if we're in interactive mode
         # and --on-error was not specified on the command line
-        if main_options.get('on_error') is not None:
+        if main_options.get("on_error") is not None:
             self._interactive_failures = False
         else:
             self._interactive_failures = self.interactive
 
         # Use color output if we're attached to a tty, unless
         # otherwise specified on the command line
-        if main_options['colors'] is None:
+        if main_options["colors"] is None:
             self.colors = is_a_tty
-        elif main_options['colors']:
+        elif main_options["colors"]:
             self.colors = True
         else:
             self.colors = False
 
-        if main_options['directory']:
+        if main_options["directory"]:
             self._set_project_dir = True
         else:
-            main_options['directory'] = os.getcwd()
+            main_options["directory"] = os.getcwd()
 
     # create()
     #
@@ -133,9 +132,10 @@ class App():
     #
     @classmethod
     def create(cls, *args, **kwargs):
-        if sys.platform.startswith('linux'):
+        if sys.platform.startswith("linux"):
             # Use an App with linux specific features
             from .linuxapp import LinuxApp  # pylint: disable=cyclic-import
+
             return LinuxApp(*args, **kwargs)
         else:
             # The base App() class is default
@@ -163,8 +163,8 @@ class App():
     #
     @contextmanager
     def initialized(self, *, session_name=None):
-        directory = self._main_options['directory']
-        config = self._main_options['config']
+        directory = self._main_options["directory"]
+        config = self._main_options["config"]
 
         self._session_name = session_name
 
@@ -184,19 +184,19 @@ class App():
             # the command line when used, trumps the config files.
             #
             override_map = {
-                'strict': '_strict_build_plan',
-                'debug': 'log_debug',
-                'verbose': 'log_verbose',
-                'error_lines': 'log_error_lines',
-                'message_lines': 'log_message_lines',
-                'on_error': 'sched_error_action',
-                'fetchers': 'sched_fetchers',
-                'builders': 'sched_builders',
-                'pushers': 'sched_pushers',
-                'max_jobs': 'build_max_jobs',
-                'network_retries': 'sched_network_retries',
-                'pull_buildtrees': 'pull_buildtrees',
-                'cache_buildtrees': 'cache_buildtrees'
+                "strict": "_strict_build_plan",
+                "debug": "log_debug",
+                "verbose": "log_verbose",
+                "error_lines": "log_error_lines",
+                "message_lines": "log_message_lines",
+                "on_error": "sched_error_action",
+                "fetchers": "sched_fetchers",
+                "builders": "sched_builders",
+                "pushers": "sched_pushers",
+                "max_jobs": "build_max_jobs",
+                "network_retries": "sched_network_retries",
+                "pull_buildtrees": "pull_buildtrees",
+                "cache_buildtrees": "cache_buildtrees",
             }
             for cli_option, context_attr in override_map.items():
                 option_value = self._main_options.get(cli_option)
@@ -208,10 +208,13 @@ class App():
                 self._error_exit(e, "Error instantiating platform")
 
             # Create the stream right away, we'll need to pass it around.
-            self.stream = Stream(self.context, self._session_start,
-                                 session_start_callback=self.session_start_cb,
-                                 interrupt_callback=self._interrupt_handler,
-                                 ticker_callback=self._tick)
+            self.stream = Stream(
+                self.context,
+                self._session_start,
+                session_start_callback=self.session_start_cb,
+                interrupt_callback=self._interrupt_handler,
+                ticker_callback=self._tick,
+            )
 
             self._state = self.stream.get_state()
 
@@ -219,13 +222,16 @@ class App():
             self._state.register_task_failed_callback(self._job_failed)
 
             # Create the logger right before setting the message handler
-            self.logger = LogLine(self.context, self._state,
-                                  self._content_profile,
-                                  self._format_profile,
-                                  self._success_profile,
-                                  self._error_profile,
-                                  self._detail_profile,
-                                  indent=INDENT)
+            self.logger = LogLine(
+                self.context,
+                self._state,
+                self._content_profile,
+                self._format_profile,
+                self._success_profile,
+                self._error_profile,
+                self._detail_profile,
+                indent=INDENT,
+            )
 
             # Propagate pipeline feedback to the user
             self.context.messenger.set_message_handler(self._message_handler)
@@ -248,10 +254,15 @@ class App():
             self.stream.init()
 
             # Create our status printer, only available in interactive
-            self._status = Status(self.context, self._state,
-                                  self._content_profile, self._format_profile,
-                                  self._success_profile, self._error_profile,
-                                  self.stream)
+            self._status = Status(
+                self.context,
+                self._state,
+                self._content_profile,
+                self._format_profile,
+                self._success_profile,
+                self._error_profile,
+                self.stream,
+            )
 
             # Mark the beginning of the session
             if session_name:
@@ -261,9 +272,13 @@ class App():
             # Load the Project
             #
             try:
-                self.project = Project(directory, self.context, cli_options=self._main_options['option'],
-                                       default_mirror=self._main_options.get('default_mirror'),
-                                       fetch_subprojects=self.stream.fetch_subprojects)
+                self.project = Project(
+                    directory,
+                    self.context,
+                    cli_options=self._main_options["option"],
+                    default_mirror=self._main_options.get("default_mirror"),
+                    fetch_subprojects=self.stream.fetch_subprojects,
+                )
 
                 self.stream.set_project(self.project)
             except LoadError as e:
@@ -291,7 +306,7 @@ class App():
                     elapsed = self.stream.elapsed_time
 
                     if isinstance(e, StreamError) and e.terminated:  # pylint: disable=no-member
-                        self._message(MessageType.WARN, session_name + ' Terminated', elapsed=elapsed)
+                        self._message(MessageType.WARN, session_name + " Terminated", elapsed=elapsed)
                     else:
                         self._message(MessageType.FAIL, session_name, elapsed=elapsed)
 
@@ -304,8 +319,9 @@ class App():
                 # Exit with the error
                 self._error_exit(e)
             except RecursionError:
-                click.echo("RecursionError: Dependency depth is too large. Maximum recursion depth exceeded.",
-                           err=True)
+                click.echo(
+                    "RecursionError: Dependency depth is too large. Maximum recursion depth exceeded.", err=True
+                )
                 sys.exit(-1)
 
             else:
@@ -331,41 +347,51 @@ class App():
     #    force (bool): Allow overwriting an existing project.conf
     #    target_directory (str): The target directory the project should be initialized in
     #
-    def init_project(self, project_name, format_version=BST_FORMAT_VERSION, element_path='elements',
-                     force=False, target_directory=None):
+    def init_project(
+        self,
+        project_name,
+        format_version=BST_FORMAT_VERSION,
+        element_path="elements",
+        force=False,
+        target_directory=None,
+    ):
         if target_directory:
             directory = os.path.abspath(target_directory)
         else:
-            directory = self._main_options['directory']
+            directory = self._main_options["directory"]
             directory = os.path.abspath(directory)
 
-        project_path = os.path.join(directory, 'project.conf')
+        project_path = os.path.join(directory, "project.conf")
 
         try:
             if self._set_project_dir:
-                raise AppError("Attempted to use -C or --directory with init.",
-                               reason='init-with-set-directory',
-                               detail="Please use 'bst init {}' instead.".format(directory))
+                raise AppError(
+                    "Attempted to use -C or --directory with init.",
+                    reason="init-with-set-directory",
+                    detail="Please use 'bst init {}' instead.".format(directory),
+                )
 
             # Abort if the project.conf already exists, unless `--force` was specified in `bst init`
             if not force and os.path.exists(project_path):
-                raise AppError("A project.conf already exists at: {}".format(project_path),
-                               reason='project-exists')
+                raise AppError("A project.conf already exists at: {}".format(project_path), reason="project-exists")
 
             if project_name:
                 # If project name was specified, user interaction is not desired, just
                 # perform some validation and write the project.conf
-                node._assert_symbol_name(project_name, 'project name')
+                node._assert_symbol_name(project_name, "project name")
                 self._assert_format_version(format_version)
                 self._assert_element_path(element_path)
 
             elif not self.interactive:
-                raise AppError("Cannot initialize a new project without specifying the project name",
-                               reason='unspecified-project-name')
+                raise AppError(
+                    "Cannot initialize a new project without specifying the project name",
+                    reason="unspecified-project-name",
+                )
             else:
                 # Collect the parameters using an interactive session
-                project_name, format_version, element_path = \
-                    self._init_project_interactive(project_name, format_version, element_path)
+                project_name, format_version, element_path = self._init_project_interactive(
+                    project_name, format_version, element_path
+                )
 
             # Create the directory if it doesnt exist
             try:
@@ -378,20 +404,21 @@ class App():
             try:
                 os.makedirs(elements_path, exist_ok=True)
             except IOError as e:
-                raise AppError("Error creating elements sub-directory {}: {}"
-                               .format(elements_path, e)) from e
+                raise AppError("Error creating elements sub-directory {}: {}".format(elements_path, e)) from e
 
             # Dont use ruamel.yaml here, because it doesnt let
             # us programatically insert comments or whitespace at
             # the toplevel.
             try:
-                with open(project_path, 'w') as f:
-                    f.write("# Unique project name\n" +
-                            "name: {}\n\n".format(project_name) +
-                            "# Required BuildStream format version\n" +
-                            "format-version: {}\n\n".format(format_version) +
-                            "# Subdirectory where elements are stored\n" +
-                            "element-path: {}\n".format(element_path))
+                with open(project_path, "w") as f:
+                    f.write(
+                        "# Unique project name\n"
+                        + "name: {}\n\n".format(project_name)
+                        + "# Required BuildStream format version\n"
+                        + "format-version: {}\n\n".format(format_version)
+                        + "# Subdirectory where elements are stored\n"
+                        + "element-path: {}\n".format(element_path)
+                    )
             except IOError as e:
                 raise AppError("Error writing {}: {}".format(project_path, e)) from e
 
@@ -419,15 +446,18 @@ class App():
         _, key, dim = element_key
 
         if self.colors:
-            prompt = self._format_profile.fmt('[') + \
-                self._content_profile.fmt(key, dim=dim) + \
-                self._format_profile.fmt('@') + \
-                self._content_profile.fmt(element_name) + \
-                self._format_profile.fmt(':') + \
-                self._content_profile.fmt('$PWD') + \
-                self._format_profile.fmt(']$') + ' '
+            prompt = (
+                self._format_profile.fmt("[")
+                + self._content_profile.fmt(key, dim=dim)
+                + self._format_profile.fmt("@")
+                + self._content_profile.fmt(element_name)
+                + self._format_profile.fmt(":")
+                + self._content_profile.fmt("$PWD")
+                + self._format_profile.fmt("]$")
+                + " "
+            )
         else:
-            prompt = '[{}@{}:${{PWD}}]$ '.format(key, element_name)
+            prompt = "[{}@{}:${{PWD}}]$ ".format(key, element_name)
 
         return prompt
 
@@ -473,8 +503,7 @@ class App():
     #
     def _message(self, message_type, message, **kwargs):
         args = dict(kwargs)
-        self.context.messenger.message(
-            Message(message_type, message, **args))
+        self.context.messenger.message(Message(message_type, message, **args))
 
     # Exception handler
     #
@@ -482,8 +511,7 @@ class App():
 
         # Print the regular BUG message
         formatted = "".join(traceback.format_exception(etype, value, tb))
-        self._message(MessageType.BUG, str(value),
-                      detail=formatted)
+        self._message(MessageType.BUG, str(value), detail=formatted)
 
         # If the scheduler has started, try to terminate all jobs gracefully,
         # otherwise exit immediately.
@@ -498,8 +526,7 @@ class App():
     def _maybe_render_status(self):
 
         # If we're suspended or terminating, then dont render the status area
-        if self._status and self.stream and \
-           not (self.stream.suspended or self.stream.terminated):
+        if self._status and self.stream and not (self.stream.suspended or self.stream.terminated):
             self._status.render()
 
     #
@@ -518,36 +545,40 @@ class App():
         # the currently ongoing tasks. We can also print something more
         # intelligent, like how many tasks remain to complete overall.
         with self._interrupted():
-            click.echo("\nUser interrupted with ^C\n" +
-                       "\n"
-                       "Choose one of the following options:\n" +
-                       "  (c)ontinue  - Continue queueing jobs as much as possible\n" +
-                       "  (q)uit      - Exit after all ongoing jobs complete\n" +
-                       "  (t)erminate - Terminate any ongoing jobs and exit\n" +
-                       "\n" +
-                       "Pressing ^C again will terminate jobs and exit\n",
-                       err=True)
+            click.echo(
+                "\nUser interrupted with ^C\n" + "\n"
+                "Choose one of the following options:\n"
+                + "  (c)ontinue  - Continue queueing jobs as much as possible\n"
+                + "  (q)uit      - Exit after all ongoing jobs complete\n"
+                + "  (t)erminate - Terminate any ongoing jobs and exit\n"
+                + "\n"
+                + "Pressing ^C again will terminate jobs and exit\n",
+                err=True,
+            )
 
             try:
-                choice = click.prompt("Choice:",
-                                      value_proc=_prefix_choice_value_proc(['continue', 'quit', 'terminate']),
-                                      default='continue', err=True)
+                choice = click.prompt(
+                    "Choice:",
+                    value_proc=_prefix_choice_value_proc(["continue", "quit", "terminate"]),
+                    default="continue",
+                    err=True,
+                )
             except (click.Abort, SystemError):
                 # In some cases, the readline buffer underlying the prompt gets corrupted on the second CTRL+C
                 # This throws a SystemError, which doesn't seem to be problematic for the rest of the program
 
                 # Ensure a newline after automatically printed '^C'
                 click.echo("", err=True)
-                choice = 'terminate'
+                choice = "terminate"
 
-            if choice == 'terminate':
+            if choice == "terminate":
                 click.echo("\nTerminating all jobs at user request\n", err=True)
                 self.stream.terminate()
             else:
-                if choice == 'quit':
+                if choice == "quit":
                     click.echo("\nCompleting ongoing tasks before quitting\n", err=True)
                     self.stream.quit()
-                elif choice == 'continue':
+                elif choice == "continue":
                     click.echo("\nContinuing\n", err=True)
 
     def _tick(self):
@@ -577,9 +608,11 @@ class App():
                 # the failure message reaches us ??
                 if not failure:
                     self._status.clear()
-                    click.echo("\n\n\nBUG: Message handling out of sync, " +
-                               "unable to retrieve failure message for element {}\n\n\n\n\n"
-                               .format(full_name), err=True)
+                    click.echo(
+                        "\n\n\nBUG: Message handling out of sync, "
+                        + "unable to retrieve failure message for element {}\n\n\n\n\n".format(full_name),
+                        err=True,
+                    )
                 else:
                     self._handle_failure(element, action_name, failure, full_name)
 
@@ -604,69 +637,72 @@ class App():
         # Interactive mode for element failures
         with self._interrupted():
 
-            summary = ("\n{} failure on element: {}\n".format(failure.action_name, full_name) +
-                       "\n" +
-                       "Choose one of the following options:\n" +
-                       "  (c)ontinue  - Continue queueing jobs as much as possible\n" +
-                       "  (q)uit      - Exit after all ongoing jobs complete\n" +
-                       "  (t)erminate - Terminate any ongoing jobs and exit\n" +
-                       "  (r)etry     - Retry this job\n")
+            summary = (
+                "\n{} failure on element: {}\n".format(failure.action_name, full_name)
+                + "\n"
+                + "Choose one of the following options:\n"
+                + "  (c)ontinue  - Continue queueing jobs as much as possible\n"
+                + "  (q)uit      - Exit after all ongoing jobs complete\n"
+                + "  (t)erminate - Terminate any ongoing jobs and exit\n"
+                + "  (r)etry     - Retry this job\n"
+            )
             if failure.logfile:
                 summary += "  (l)og       - View the full log file\n"
             if failure.sandbox:
                 summary += "  (s)hell     - Drop into a shell in the failed build sandbox\n"
             summary += "\nPressing ^C will terminate jobs and exit\n"
 
-            choices = ['continue', 'quit', 'terminate', 'retry']
+            choices = ["continue", "quit", "terminate", "retry"]
             if failure.logfile:
-                choices += ['log']
+                choices += ["log"]
             if failure.sandbox:
-                choices += ['shell']
+                choices += ["shell"]
 
-            choice = ''
-            while choice not in ['continue', 'quit', 'terminate', 'retry']:
+            choice = ""
+            while choice not in ["continue", "quit", "terminate", "retry"]:
                 click.echo(summary, err=True)
 
-                self._notify("BuildStream failure", "{} on element {}"
-                             .format(failure.action_name, full_name))
+                self._notify("BuildStream failure", "{} on element {}".format(failure.action_name, full_name))
 
                 try:
-                    choice = click.prompt("Choice:", default='continue', err=True,
-                                          value_proc=_prefix_choice_value_proc(choices))
+                    choice = click.prompt(
+                        "Choice:", default="continue", err=True, value_proc=_prefix_choice_value_proc(choices)
+                    )
                 except (click.Abort, SystemError):
                     # In some cases, the readline buffer underlying the prompt gets corrupted on the second CTRL+C
                     # This throws a SystemError, which doesn't seem to be problematic for the rest of the program
 
                     # Ensure a newline after automatically printed '^C'
                     click.echo("", err=True)
-                    choice = 'terminate'
+                    choice = "terminate"
 
                 # Handle choices which you can come back from
                 #
-                if choice == 'shell':
+                if choice == "shell":
                     click.echo("\nDropping into an interactive shell in the failed build sandbox\n", err=True)
                     try:
                         unique_id, element_key = element
                         prompt = self.shell_prompt(full_name, element_key)
-                        self.stream.shell(None, Scope.BUILD, prompt, isolate=True,
-                                          usebuildtree='always', unique_id=unique_id)
+                        self.stream.shell(
+                            None, Scope.BUILD, prompt, isolate=True, usebuildtree="always", unique_id=unique_id
+                        )
                     except BstError as e:
                         click.echo("Error while attempting to create interactive shell: {}".format(e), err=True)
-                elif choice == 'log':
-                    with open(failure.logfile, 'r') as logfile:
+                elif choice == "log":
+                    with open(failure.logfile, "r") as logfile:
                         content = logfile.read()
                         click.echo_via_pager(content)
 
-            if choice == 'terminate':
+            if choice == "terminate":
                 click.echo("\nTerminating all jobs\n", err=True)
                 self.stream.terminate()
             else:
-                if choice == 'quit':
+                if choice == "quit":
                     click.echo("\nCompleting ongoing tasks before quitting\n", err=True)
                     self.stream.quit()
-                elif choice == 'continue':
+                elif choice == "continue":
                     click.echo("\nContinuing with other non failing elements\n", err=True)
-                elif choice == 'retry':
+                elif choice == "retry":
                     click.echo("\nRetrying failed job\n", err=True)
                     unique_id = element[0]
                     self.stream._failure_retry(action_name, unique_id)
@@ -678,17 +714,14 @@ class App():
     def session_start_cb(self):
         self._started = True
         if self._session_name:
-            self.logger.print_heading(self.project,
-                                      self.stream,
-                                      log_file=self._main_options['log_file'])
+            self.logger.print_heading(self.project, self.stream, log_file=self._main_options["log_file"])
 
     #
     # Print a summary of the queues
     #
     def _print_summary(self):
         click.echo("", err=True)
-        self.logger.print_summary(self.stream,
-                                  self._main_options['log_file'])
+        self.logger.print_summary(self.stream, self._main_options["log_file"])
 
     # _error_exit()
     #
@@ -720,7 +753,7 @@ class App():
         click.echo(main_error, err=True)
         if error.detail:
             indent = " " * INDENT
-            detail = '\n' + indent + indent.join(error.detail.splitlines(True))
+            detail = "\n" + indent + indent.join(error.detail.splitlines(True))
             click.echo(detail, err=True)
 
         sys.exit(-1)
@@ -753,8 +786,8 @@ class App():
         self._maybe_render_status()
 
         # Additionally log to a file
-        if self._main_options['log_file']:
-            click.echo(text, file=self._main_options['log_file'], color=False, nl=False)
+        if self._main_options["log_file"]:
+            click.echo(text, file=self._main_options["log_file"], color=False, nl=False)
 
     @contextmanager
     def _interrupted(self):
@@ -768,25 +801,26 @@ class App():
     # Some validation routines for project initialization
     #
     def _assert_format_version(self, format_version):
-        message = "The version must be supported by this " + \
-                  "version of buildstream (0 - {})\n".format(BST_FORMAT_VERSION)
+        message = "The version must be supported by this " + "version of buildstream (0 - {})\n".format(
+            BST_FORMAT_VERSION
+        )
 
         # Validate that it is an integer
         try:
             number = int(format_version)
         except ValueError as e:
-            raise AppError(message, reason='invalid-format-version') from e
+            raise AppError(message, reason="invalid-format-version") from e
 
         # Validate that the specified version is supported
         if number < 0 or number > BST_FORMAT_VERSION:
-            raise AppError(message, reason='invalid-format-version')
+            raise AppError(message, reason="invalid-format-version")
 
     def _assert_element_path(self, element_path):
         message = "The element path cannot be an absolute path or contain any '..' components\n"
 
         # Validate the path is not absolute
         if os.path.isabs(element_path):
-            raise AppError(message, reason='invalid-element-path')
+            raise AppError(message, reason="invalid-element-path")
 
         # Validate that the path does not contain any '..' components
         path = element_path
@@ -794,8 +828,8 @@ class App():
             split = os.path.split(path)
             path = split[0]
             basename = split[1]
-            if basename == '..':
-                raise AppError(message, reason='invalid-element-path')
+            if basename == "..":
+                raise AppError(message, reason="invalid-element-path")
 
     # _init_project_interactive()
     #
@@ -811,11 +845,10 @@ class App():
     #    format_version (int): The user selected format version
     #    element_path (str): The user selected element path
     #
-    def _init_project_interactive(self, project_name, format_version=BST_FORMAT_VERSION, element_path='elements'):
-
+    def _init_project_interactive(self, project_name, format_version=BST_FORMAT_VERSION, element_path="elements"):
         def project_name_proc(user_input):
             try:
-                node._assert_symbol_name(user_input, 'project name')
+                node._assert_symbol_name(user_input, "project name")
             except LoadError as e:
                 message = "{}\n\n{}\n".format(e, e.detail)
                 raise UsageError(message) from e
@@ -835,63 +868,101 @@ class App():
                 raise UsageError(str(e)) from e
             return user_input
 
-        w = TextWrapper(initial_indent='  ', subsequent_indent='  ', width=79)
+        w = TextWrapper(initial_indent="  ", subsequent_indent="  ", width=79)
 
         # Collect project name
         click.echo("", err=True)
         click.echo(self._content_profile.fmt("Choose a unique name for your project"), err=True)
         click.echo(self._format_profile.fmt("-------------------------------------"), err=True)
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("The project name is a unique symbol for your project and will be used "
-                   "to distinguish your project from others in user preferences, namspaceing "
-                   "of your project's artifacts in shared artifact caches, and in any case where "
-                   "BuildStream needs to distinguish between multiple projects.")), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "The project name is a unique symbol for your project and will be used "
+                    "to distinguish your project from others in user preferences, namspaceing "
+                    "of your project's artifacts in shared artifact caches, and in any case where "
+                    "BuildStream needs to distinguish between multiple projects."
+                )
+            ),
+            err=True,
+        )
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("The project name must contain only alphanumeric characters, "
-                   "may not start with a digit, and may contain dashes or underscores.")), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "The project name must contain only alphanumeric characters, "
+                    "may not start with a digit, and may contain dashes or underscores."
+                )
+            ),
+            err=True,
+        )
         click.echo("", err=True)
-        project_name = click.prompt(self._content_profile.fmt("Project name"),
-                                    value_proc=project_name_proc, err=True)
+        project_name = click.prompt(self._content_profile.fmt("Project name"), value_proc=project_name_proc, err=True)
         click.echo("", err=True)
 
         # Collect format version
         click.echo(self._content_profile.fmt("Select the minimum required format version for your project"), err=True)
         click.echo(self._format_profile.fmt("-----------------------------------------------------------"), err=True)
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("The format version is used to provide users who build your project "
-                   "with a helpful error message in the case that they do not have a recent "
-                   "enough version of BuildStream supporting all the features which your "
-                   "project might use.")), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "The format version is used to provide users who build your project "
+                    "with a helpful error message in the case that they do not have a recent "
+                    "enough version of BuildStream supporting all the features which your "
+                    "project might use."
+                )
+            ),
+            err=True,
+        )
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("The lowest version allowed is 0, the currently installed version of BuildStream "
-                   "supports up to format version {}.".format(BST_FORMAT_VERSION))), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "The lowest version allowed is 0, the currently installed version of BuildStream "
+                    "supports up to format version {}.".format(BST_FORMAT_VERSION)
+                )
+            ),
+            err=True,
+        )
 
         click.echo("", err=True)
-        format_version = click.prompt(self._content_profile.fmt("Format version"),
-                                      value_proc=format_version_proc,
-                                      default=format_version, err=True)
+        format_version = click.prompt(
+            self._content_profile.fmt("Format version"),
+            value_proc=format_version_proc,
+            default=format_version,
+            err=True,
+        )
         click.echo("", err=True)
 
         # Collect element path
         click.echo(self._content_profile.fmt("Select the element path"), err=True)
         click.echo(self._format_profile.fmt("-----------------------"), err=True)
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("The element path is a project subdirectory where element .bst files are stored "
-                   "within your project.")), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "The element path is a project subdirectory where element .bst files are stored "
+                    "within your project."
+                )
+            ),
+            err=True,
+        )
         click.echo("", err=True)
-        click.echo(self._detail_profile.fmt(
-            w.fill("Elements will be displayed in logs as filenames relative to "
-                   "the element path, and similarly, dependencies must be expressed as filenames "
-                   "relative to the element path.")), err=True)
+        click.echo(
+            self._detail_profile.fmt(
+                w.fill(
+                    "Elements will be displayed in logs as filenames relative to "
+                    "the element path, and similarly, dependencies must be expressed as filenames "
+                    "relative to the element path."
+                )
+            ),
+            err=True,
+        )
         click.echo("", err=True)
-        element_path = click.prompt(self._content_profile.fmt("Element path"),
-                                    value_proc=element_path_proc,
-                                    default=element_path, err=True)
+        element_path = click.prompt(
+            self._content_profile.fmt("Element path"), value_proc=element_path_proc, default=element_path, err=True
+        )
 
         return (project_name, format_version, element_path)
 
@@ -909,7 +980,6 @@ class App():
 # ask for a new input.
 #
 def _prefix_choice_value_proc(choices):
-
     def value_proc(user_input):
         remaining_candidate = [choice for choice in choices if choice.startswith(user_input)]
 
diff --git a/src/buildstream/_frontend/cli.py b/src/buildstream/_frontend/cli.py
index 5c0293589..935a492d9 100644
--- a/src/buildstream/_frontend/cli.py
+++ b/src/buildstream/_frontend/cli.py
@@ -17,8 +17,8 @@ from ..utils import _get_compression, UtilError
 #              Helper classes and methods for Click              #
 ##################################################################
 
-class FastEnumType(click.Choice):
 
+class FastEnumType(click.Choice):
     def __init__(self, enum):
         self._enum = enum
         super().__init__(enum.values())
@@ -45,7 +45,7 @@ class FastEnumType(click.Choice):
 #
 def search_command(args, *, context=None):
     if context is None:
-        context = cli.make_context('bst', args, resilient_parsing=True)
+        context = cli.make_context("bst", args, resilient_parsing=True)
 
     # Loop into the deepest command
     command = cli
@@ -54,9 +54,7 @@ def search_command(args, *, context=None):
         command = command_ctx.command.get_command(command_ctx, cmd)
         if command is None:
             return None
-        command_ctx = command.make_context(command.name, [command.name],
-                                           parent=command_ctx,
-                                           resilient_parsing=True)
+        command_ctx = command.make_context(command.name, [command.name], parent=command_ctx, resilient_parsing=True)
 
     return command_ctx
 
@@ -65,8 +63,11 @@ def search_command(args, *, context=None):
 def complete_commands(cmd, args, incomplete):
     command_ctx = search_command(args[1:])
     if command_ctx and command_ctx.command and isinstance(command_ctx.command, click.MultiCommand):
-        return [subcommand + " " for subcommand in command_ctx.command.list_commands(command_ctx)
-                if not command_ctx.command.get_command(command_ctx, subcommand).hidden]
+        return [
+            subcommand + " "
+            for subcommand in command_ctx.command.list_commands(command_ctx)
+            if not command_ctx.command.get_command(command_ctx, subcommand).hidden
+        ]
 
     return []
 
@@ -80,18 +81,19 @@ def complete_target(args, incomplete):
     """
 
     from .. import utils
-    project_conf = 'project.conf'
+
+    project_conf = "project.conf"
 
     # First resolve the directory, in case there is an
     # active --directory/-C option
     #
-    base_directory = '.'
+    base_directory = "."
     idx = -1
     try:
-        idx = args.index('-C')
+        idx = args.index("-C")
     except ValueError:
         try:
-            idx = args.index('--directory')
+            idx = args.index("--directory")
         except ValueError:
             pass
 
@@ -116,7 +118,7 @@ def complete_target(args, incomplete):
             return []
 
     # The project is not required to have an element-path
-    element_directory = project.get_str('element-path', default='')
+    element_directory = project.get_str("element-path", default="")
 
     # If a project was loaded, use its element-path to
     # adjust our completion's base directory
@@ -132,19 +134,20 @@ def complete_target(args, incomplete):
 
 def complete_artifact(orig_args, args, incomplete):
     from .._context import Context
+
     with Context(use_casd=False) as ctx:
 
         config = None
         if orig_args:
             for i, arg in enumerate(orig_args):
-                if arg in ('-c', '--config'):
+                if arg in ("-c", "--config"):
                     try:
                         config = orig_args[i + 1]
                     except IndexError:
                         pass
         if args:
             for i, arg in enumerate(args):
-                if arg in ('-c', '--config'):
+                if arg in ("-c", "--config"):
                     try:
                         config = args[i + 1]
                     except IndexError:
@@ -167,38 +170,40 @@ def override_completions(orig_args, cmd, cmd_param, args, incomplete):
     :return: all the possible user-specified completions for the param
     """
 
-    if cmd.name == 'help':
+    if cmd.name == "help":
         return complete_commands(cmd, args, incomplete)
 
     # We can't easily extend click's data structures without
     # modifying click itself, so just do some weak special casing
     # right here and select which parameters we want to handle specially.
     if isinstance(cmd_param.type, click.Path):
-        if (cmd_param.name == 'elements' or
-                cmd_param.name == 'element' or
-                cmd_param.name == 'except_' or
-                cmd_param.opts == ['--track'] or
-                cmd_param.opts == ['--track-except']):
+        if (
+            cmd_param.name == "elements"
+            or cmd_param.name == "element"
+            or cmd_param.name == "except_"
+            or cmd_param.opts == ["--track"]
+            or cmd_param.opts == ["--track-except"]
+        ):
             return complete_target(args, incomplete)
-        if cmd_param.name == 'artifacts' or cmd_param.name == 'target':
+        if cmd_param.name == "artifacts" or cmd_param.name == "target":
             return complete_artifact(orig_args, args, incomplete)
 
     raise CompleteUnhandled()
 
 
 def validate_output_streams():
-    if sys.platform == 'win32':
+    if sys.platform == "win32":
         # Windows does not support 'fcntl', the module is unavailable there as
         # of Python 3.7, therefore early-out here.
         return
 
     import fcntl
+
     for stream in (sys.stdout, sys.stderr):
         fileno = stream.fileno()
         flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
         if flags & os.O_NONBLOCK:
-            click.echo("{} is currently set to O_NONBLOCK, try opening a new shell"
-                       .format(stream.name), err=True)
+            click.echo("{} is currently set to O_NONBLOCK, try opening a new shell".format(stream.name), err=True)
             sys.exit(-1)
 
 
@@ -237,8 +242,7 @@ def handle_bst_force_start_method_env():
             sys.exit(-1)
 
 
-def override_main(self, args=None, prog_name=None, complete_var=None,
-                  standalone_mode=True, **extra):
+def override_main(self, args=None, prog_name=None, complete_var=None, standalone_mode=True, **extra):
 
     # Hook for the Bash completion.  This only activates if the Bash
     # completion is actually enabled, otherwise this is quite a fast
@@ -250,7 +254,7 @@ def override_main(self, args=None, prog_name=None, complete_var=None,
         #
         # The below is a quicker exit path for the sake
         # of making completions respond faster.
-        if 'BST_TEST_SUITE' not in os.environ:
+        if "BST_TEST_SUITE" not in os.environ:
             sys.stdout.flush()
             sys.stderr.flush()
             os._exit(0)
@@ -269,14 +273,13 @@ def override_main(self, args=None, prog_name=None, complete_var=None,
     # case of testing, our tests preceed our entrypoint, so we do our best.
     handle_bst_force_start_method_env()
 
-    original_main(self, args=args, prog_name=prog_name, complete_var=None,
-                  standalone_mode=standalone_mode, **extra)
+    original_main(self, args=args, prog_name=prog_name, complete_var=None, standalone_mode=standalone_mode, **extra)
 
 
 original_main = click.BaseCommand.main
 # Disable type checking since mypy doesn't support assigning to a method.
 # See https://github.com/python/mypy/issues/2427.
-click.BaseCommand.main = override_main      # type: ignore
+click.BaseCommand.main = override_main  # type: ignore
 
 
 ##################################################################
@@ -287,58 +290,78 @@ def print_version(ctx, param, value):
         return
 
     from .. import __version__
+
     click.echo(__version__)
     ctx.exit()
 
 
-@click.group(context_settings=dict(help_option_names=['-h', '--help']))
-@click.option('--version', is_flag=True, callback=print_version,
-              expose_value=False, is_eager=True)
-@click.option('--config', '-c',
-              type=click.Path(exists=True, dir_okay=False, readable=True),
-              help="Configuration file to use")
-@click.option('--directory', '-C', default=None,  # Set to os.getcwd() later.
-              type=click.Path(file_okay=False, readable=True),
-              help="Project directory (default: current directory)")
-@click.option('--on-error', default=None,
-              type=FastEnumType(_SchedulerErrorAction),
-              help="What to do when an error is encountered")
-@click.option('--fetchers', type=click.INT, default=None,
-              help="Maximum simultaneous download tasks")
-@click.option('--builders', type=click.INT, default=None,
-              help="Maximum simultaneous build tasks")
-@click.option('--pushers', type=click.INT, default=None,
-              help="Maximum simultaneous upload tasks")
-@click.option('--max-jobs', type=click.INT, default=None,
-              help="Number of parallel jobs allowed for a given build task")
-@click.option('--network-retries', type=click.INT, default=None,
-              help="Maximum retries for network tasks")
-@click.option('--no-interactive', is_flag=True,
-              help="Force non interactive mode, otherwise this is automatically decided")
-@click.option('--verbose/--no-verbose', default=None,
-              help="Be extra verbose")
-@click.option('--debug/--no-debug', default=None,
-              help="Print debugging output")
-@click.option('--error-lines', type=click.INT, default=None,
-              help="Maximum number of lines to show from a task log")
-@click.option('--message-lines', type=click.INT, default=None,
-              help="Maximum number of lines to show in a detailed message")
-@click.option('--log-file',
-              type=click.File(mode='w', encoding='UTF-8'),
-              help="A file to store the main log (allows storing the main log while in interactive mode)")
-@click.option('--colors/--no-colors', default=None,
-              help="Force enable/disable ANSI color codes in output")
-@click.option('--strict/--no-strict', default=None, is_flag=True,
-              help="Elements must be rebuilt when their dependencies have changed")
-@click.option('--option', '-o', type=click.Tuple([str, str]), multiple=True, metavar='OPTION VALUE',
-              help="Specify a project option")
-@click.option('--default-mirror', default=None,
-              help="The mirror to fetch from first, before attempting other mirrors")
-@click.option('--pull-buildtrees', is_flag=True, default=None,
-              help="Include an element's build tree when pulling remote element artifacts")
-@click.option('--cache-buildtrees', default=None,
-              type=FastEnumType(_CacheBuildTrees),
-              help="Cache artifact build tree content on creation")
+@click.group(context_settings=dict(help_option_names=["-h", "--help"]))
+@click.option("--version", is_flag=True, callback=print_version, expose_value=False, is_eager=True)
+@click.option(
+    "--config", "-c", type=click.Path(exists=True, dir_okay=False, readable=True), help="Configuration file to use"
+)
+@click.option(
+    "--directory",
+    "-C",
+    default=None,  # Set to os.getcwd() later.
+    type=click.Path(file_okay=False, readable=True),
+    help="Project directory (default: current directory)",
+)
+@click.option(
+    "--on-error",
+    default=None,
+    type=FastEnumType(_SchedulerErrorAction),
+    help="What to do when an error is encountered",
+)
+@click.option("--fetchers", type=click.INT, default=None, help="Maximum simultaneous download tasks")
+@click.option("--builders", type=click.INT, default=None, help="Maximum simultaneous build tasks")
+@click.option("--pushers", type=click.INT, default=None, help="Maximum simultaneous upload tasks")
+@click.option(
+    "--max-jobs", type=click.INT, default=None, help="Number of parallel jobs allowed for a given build task"
+)
+@click.option("--network-retries", type=click.INT, default=None, help="Maximum retries for network tasks")
+@click.option(
+    "--no-interactive", is_flag=True, help="Force non interactive mode, otherwise this is automatically decided"
+)
+@click.option("--verbose/--no-verbose", default=None, help="Be extra verbose")
+@click.option("--debug/--no-debug", default=None, help="Print debugging output")
+@click.option("--error-lines", type=click.INT, default=None, help="Maximum number of lines to show from a task log")
+@click.option(
+    "--message-lines", type=click.INT, default=None, help="Maximum number of lines to show in a detailed message"
+)
+@click.option(
+    "--log-file",
+    type=click.File(mode="w", encoding="UTF-8"),
+    help="A file to store the main log (allows storing the main log while in interactive mode)",
+)
+@click.option("--colors/--no-colors", default=None, help="Force enable/disable ANSI color codes in output")
+@click.option(
+    "--strict/--no-strict",
+    default=None,
+    is_flag=True,
+    help="Elements must be rebuilt when their dependencies have changed",
+)
+@click.option(
+    "--option",
+    "-o",
+    type=click.Tuple([str, str]),
+    multiple=True,
+    metavar="OPTION VALUE",
+    help="Specify a project option",
+)
+@click.option("--default-mirror", default=None, help="The mirror to fetch from first, before attempting other mirrors")
+@click.option(
+    "--pull-buildtrees",
+    is_flag=True,
+    default=None,
+    help="Include an element's build tree when pulling remote element artifacts",
+)
+@click.option(
+    "--cache-buildtrees",
+    default=None,
+    type=FastEnumType(_CacheBuildTrees),
+    help="Cache artifact build tree content on creation",
+)
 @click.pass_context
 def cli(context, **kwargs):
     """Build and manipulate BuildStream projects
@@ -360,17 +383,15 @@ def cli(context, **kwargs):
 ##################################################################
 #                           Help Command                         #
 ##################################################################
-@cli.command(name="help", short_help="Print usage information",
-             context_settings={"help_option_names": []})
-@click.argument("command", nargs=-1, metavar='COMMAND')
+@cli.command(name="help", short_help="Print usage information", context_settings={"help_option_names": []})
+@click.argument("command", nargs=-1, metavar="COMMAND")
 @click.pass_context
 def help_command(ctx, command):
     """Print usage information about a given command
     """
     command_ctx = search_command(command, context=ctx.parent)
     if not command_ctx:
-        click.echo("Not a valid command: '{} {}'"
-                   .format(ctx.parent.info_name, " ".join(command)), err=True)
+        click.echo("Not a valid command: '{} {}'".format(ctx.parent.info_name, " ".join(command)), err=True)
         sys.exit(-1)
 
     click.echo(command_ctx.command.get_help(command_ctx), err=True)
@@ -380,24 +401,32 @@ def help_command(ctx, command):
         detail = " "
         if command:
             detail = " {} ".format(" ".join(command))
-        click.echo("\nFor usage on a specific command: {} help{}COMMAND"
-                   .format(ctx.parent.info_name, detail), err=True)
+        click.echo(
+            "\nFor usage on a specific command: {} help{}COMMAND".format(ctx.parent.info_name, detail), err=True
+        )
 
 
 ##################################################################
 #                           Init Command                         #
 ##################################################################
 @cli.command(short_help="Initialize a new BuildStream project")
-@click.option('--project-name', type=click.STRING,
-              help="The project name to use")
-@click.option('--format-version', type=click.INT, default=BST_FORMAT_VERSION, show_default=True,
-              help="The required format version")
-@click.option('--element-path', type=click.Path(), default="elements", show_default=True,
-              help="The subdirectory to store elements in")
-@click.option('--force', '-f', is_flag=True,
-              help="Allow overwriting an existing project.conf")
-@click.argument('target-directory', nargs=1, required=False,
-                type=click.Path(file_okay=False, writable=True))
+@click.option("--project-name", type=click.STRING, help="The project name to use")
+@click.option(
+    "--format-version",
+    type=click.INT,
+    default=BST_FORMAT_VERSION,
+    show_default=True,
+    help="The required format version",
+)
+@click.option(
+    "--element-path",
+    type=click.Path(),
+    default="elements",
+    show_default=True,
+    help="The subdirectory to store elements in",
+)
+@click.option("--force", "-f", is_flag=True, help="Allow overwriting an existing project.conf")
+@click.argument("target-directory", nargs=1, required=False, type=click.Path(file_okay=False, writable=True))
 @click.pass_obj
 def init(app, project_name, format_version, element_path, force, target_directory):
     """Initialize a new BuildStream project
@@ -415,13 +444,11 @@ def init(app, project_name, format_version, element_path, force, target_director
 #                          Build Command                         #
 ##################################################################
 @cli.command(short_help="Build elements in a pipeline")
-@click.option('--deps', '-d', default=None,
-              type=click.Choice(['plan', 'all']),
-              help='The dependencies to build')
-@click.option('--remote', '-r', default=None,
-              help="The URL of the remote cache (defaults to the first configured cache)")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option("--deps", "-d", default=None, type=click.Choice(["plan", "all"]), help="The dependencies to build")
+@click.option(
+    "--remote", "-r", default=None, help="The URL of the remote cache (defaults to the first configured cache)"
+)
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def build(app, elements, deps, remote):
     """Build elements in a pipeline
@@ -450,30 +477,41 @@ def build(app, elements, deps, remote):
             # Junction elements cannot be built, exclude them from default targets
             ignore_junction_targets = True
 
-        app.stream.build(elements,
-                         selection=deps,
-                         ignore_junction_targets=ignore_junction_targets,
-                         remote=remote)
+        app.stream.build(elements, selection=deps, ignore_junction_targets=ignore_junction_targets, remote=remote)
 
 
 ##################################################################
 #                           Show Command                         #
 ##################################################################
 @cli.command(short_help="Show elements in the pipeline")
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies")
-@click.option('--deps', '-d', default='all', show_default=True,
-              type=click.Choice(['none', 'plan', 'run', 'build', 'all']),
-              help='The dependencies to show')
-@click.option('--order', default="stage", show_default=True,
-              type=click.Choice(['stage', 'alpha']),
-              help='Staging or alphabetic ordering of dependencies')
-@click.option('--format', '-f', 'format_', metavar='FORMAT', default=None,
-              type=click.STRING,
-              help='Format string for each element')
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--except", "except_", multiple=True, type=click.Path(readable=False), help="Except certain dependencies"
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="all",
+    show_default=True,
+    type=click.Choice(["none", "plan", "run", "build", "all"]),
+    help="The dependencies to show",
+)
+@click.option(
+    "--order",
+    default="stage",
+    show_default=True,
+    type=click.Choice(["stage", "alpha"]),
+    help="Staging or alphabetic ordering of dependencies",
+)
+@click.option(
+    "--format",
+    "-f",
+    "format_",
+    metavar="FORMAT",
+    default=None,
+    type=click.STRING,
+    help="Format string for each element",
+)
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def show(app, elements, deps, except_, order, format_):
     """Show elements in the pipeline
@@ -536,9 +574,7 @@ def show(app, elements, deps, except_, order, format_):
         if not elements:
             elements = app.project.get_default_targets()
 
-        dependencies = app.stream.load_selection(elements,
-                                                 selection=deps,
-                                                 except_targets=except_)
+        dependencies = app.stream.load_selection(elements, selection=deps, except_targets=except_)
 
         if order == "alpha":
             dependencies = sorted(dependencies)
@@ -554,25 +590,34 @@ def show(app, elements, deps, except_, order, format_):
 #                          Shell Command                         #
 ##################################################################
 @cli.command(short_help="Shell into an element's sandbox environment")
-@click.option('--build', '-b', 'build_', is_flag=True,
-              help='Stage dependencies and sources to build')
-@click.option('--sysroot', '-s', default=None,
-              type=click.Path(exists=True, file_okay=False, readable=True),
-              help="An existing sysroot")
-@click.option('--mount', type=click.Tuple([click.Path(exists=True), str]), multiple=True,
-              metavar='HOSTPATH PATH',
-              help="Mount a file or directory into the sandbox")
-@click.option('--isolate', is_flag=True,
-              help='Create an isolated build sandbox')
-@click.option('--use-buildtree', '-t', 'cli_buildtree', type=click.Choice(['ask', 'try', 'always', 'never']),
-              default='ask', show_default=True,
-              help=('Use a buildtree. If `always` is set, will always fail to '
-                    'build if a buildtree is not available.'))
-@click.option('--pull', 'pull_', is_flag=True,
-              help='Attempt to pull missing or incomplete artifacts')
-@click.argument('element', required=False,
-                type=click.Path(readable=False))
-@click.argument('command', type=click.STRING, nargs=-1)
+@click.option("--build", "-b", "build_", is_flag=True, help="Stage dependencies and sources to build")
+@click.option(
+    "--sysroot",
+    "-s",
+    default=None,
+    type=click.Path(exists=True, file_okay=False, readable=True),
+    help="An existing sysroot",
+)
+@click.option(
+    "--mount",
+    type=click.Tuple([click.Path(exists=True), str]),
+    multiple=True,
+    metavar="HOSTPATH PATH",
+    help="Mount a file or directory into the sandbox",
+)
+@click.option("--isolate", is_flag=True, help="Create an isolated build sandbox")
+@click.option(
+    "--use-buildtree",
+    "-t",
+    "cli_buildtree",
+    type=click.Choice(["ask", "try", "always", "never"]),
+    default="ask",
+    show_default=True,
+    help=("Use a buildtree. If `always` is set, will always fail to " "build if a buildtree is not available."),
+)
+@click.option("--pull", "pull_", is_flag=True, help="Attempt to pull missing or incomplete artifacts")
+@click.argument("element", required=False, type=click.Path(readable=False))
+@click.argument("command", type=click.STRING, nargs=-1)
 @click.pass_obj
 def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, pull_, command):
     """Run a command in the target element's sandbox environment
@@ -616,8 +661,7 @@ def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, pull_, c
             if not element:
                 raise AppError('Missing argument "ELEMENT".')
 
-        elements = app.stream.load_selection((element,), selection=selection,
-                                             use_artifact_config=True)
+        elements = app.stream.load_selection((element,), selection=selection, use_artifact_config=True)
 
         # last one will be the element we want to stage, previous ones are
         # elements to try and pull
@@ -628,10 +672,7 @@ def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, pull_, c
         element_key = element._get_display_key()
 
         prompt = app.shell_prompt(element_name, element_key)
-        mounts = [
-            HostMount(path, host_path)
-            for host_path, path in mount
-        ]
+        mounts = [HostMount(path, host_path) for host_path, path in mount]
 
         cached = element._cached_buildtree()
         buildtree_exists = element._buildtree_exists()
@@ -640,27 +681,31 @@ def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, pull_, c
             if buildtree_exists or pull_:
                 use_buildtree = cli_buildtree
                 if not cached and use_buildtree == "always":
-                    click.echo("WARNING: buildtree is not cached locally, will attempt to pull from available remotes",
-                               err=True)
+                    click.echo(
+                        "WARNING: buildtree is not cached locally, will attempt to pull from available remotes",
+                        err=True,
+                    )
             else:
                 if cli_buildtree == "always":
                     # Exit early if it won't be possible to even fetch a buildtree with always option
                     raise AppError("Artifact was created without buildtree, unable to launch shell with it")
-                click.echo("WARNING: Artifact created without buildtree, shell will be loaded without it",
-                           err=True)
+                click.echo("WARNING: Artifact created without buildtree, shell will be loaded without it", err=True)
         else:
             # If the value has defaulted to ask and in non interactive mode, don't consider the buildtree, this
             # being the default behaviour of the command
             if app.interactive and cli_buildtree == "ask":
-                if cached and bool(click.confirm('Do you want to use the cached buildtree?')):
+                if cached and bool(click.confirm("Do you want to use the cached buildtree?")):
                     use_buildtree = "always"
                 elif buildtree_exists:
                     try:
-                        choice = click.prompt("Do you want to pull & use a cached buildtree?",
-                                              type=click.Choice(['try', 'always', 'never']),
-                                              err=True, show_choices=True)
+                        choice = click.prompt(
+                            "Do you want to pull & use a cached buildtree?",
+                            type=click.Choice(["try", "always", "never"]),
+                            err=True,
+                            show_choices=True,
+                        )
                     except click.Abort:
-                        click.echo('Aborting', err=True)
+                        click.echo("Aborting", err=True)
                         sys.exit(-1)
 
                     if choice != "never":
@@ -671,13 +716,17 @@ def shell(app, element, sysroot, mount, isolate, build_, cli_buildtree, pull_, c
             click.echo("WARNING: using a buildtree from a failed build.", err=True)
 
         try:
-            exitcode = app.stream.shell(element, scope, prompt,
-                                        directory=sysroot,
-                                        mounts=mounts,
-                                        isolate=isolate,
-                                        command=command,
-                                        usebuildtree=use_buildtree,
-                                        pull_dependencies=pull_dependencies)
+            exitcode = app.stream.shell(
+                element,
+                scope,
+                prompt,
+                directory=sysroot,
+                mounts=mounts,
+                isolate=isolate,
+                command=command,
+                usebuildtree=use_buildtree,
+                pull_dependencies=pull_dependencies,
+            )
         except BstError as e:
             raise AppError("Error launching shell: {}".format(e), detail=e.detail) from e
 
@@ -697,20 +746,27 @@ def source():
 #                     Source Fetch Command                       #
 ##################################################################
 @source.command(name="fetch", short_help="Fetch sources in a pipeline")
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies from fetching")
-@click.option('--deps', '-d', default='plan', show_default=True,
-              type=click.Choice(['none', 'plan', 'all']),
-              help='The dependencies to fetch')
-@click.option('--track', 'track_', is_flag=True,
-              help="Track new source references before fetching")
-@click.option('--track-cross-junctions', '-J', is_flag=True,
-              help="Allow tracking to cross junction boundaries")
-@click.option('--remote', '-r', default=None,
-              help="The URL of the remote source cache (defaults to the first configured cache)")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--except",
+    "except_",
+    multiple=True,
+    type=click.Path(readable=False),
+    help="Except certain dependencies from fetching",
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="plan",
+    show_default=True,
+    type=click.Choice(["none", "plan", "all"]),
+    help="The dependencies to fetch",
+)
+@click.option("--track", "track_", is_flag=True, help="Track new source references before fetching")
+@click.option("--track-cross-junctions", "-J", is_flag=True, help="Allow tracking to cross junction boundaries")
+@click.option(
+    "--remote", "-r", default=None, help="The URL of the remote source cache (defaults to the first configured cache)"
+)
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def source_fetch(app, elements, deps, track_, except_, track_cross_junctions, remote):
     """Fetch sources required to build the pipeline
@@ -741,36 +797,48 @@ def source_fetch(app, elements, deps, track_, except_, track_cross_junctions, re
         sys.exit(-1)
 
     if track_ and deps == PipelineSelection.PLAN:
-        click.echo("WARNING: --track specified for tracking of a build plan\n\n"
-                   "Since tracking modifies the build plan, all elements will be tracked.", err=True)
+        click.echo(
+            "WARNING: --track specified for tracking of a build plan\n\n"
+            "Since tracking modifies the build plan, all elements will be tracked.",
+            err=True,
+        )
         deps = PipelineSelection.ALL
 
     with app.initialized(session_name="Fetch"):
         if not elements:
             elements = app.project.get_default_targets()
 
-        app.stream.fetch(elements,
-                         selection=deps,
-                         except_targets=except_,
-                         track_targets=track_,
-                         track_cross_junctions=track_cross_junctions,
-                         remote=remote)
+        app.stream.fetch(
+            elements,
+            selection=deps,
+            except_targets=except_,
+            track_targets=track_,
+            track_cross_junctions=track_cross_junctions,
+            remote=remote,
+        )
 
 
 ##################################################################
 #                     Source Track Command                       #
 ##################################################################
 @source.command(name="track", short_help="Track new source references")
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies from tracking")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependencies to track')
-@click.option('--cross-junctions', '-J', is_flag=True,
-              help="Allow crossing junction boundaries")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--except",
+    "except_",
+    multiple=True,
+    type=click.Path(readable=False),
+    help="Except certain dependencies from tracking",
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependencies to track",
+)
+@click.option("--cross-junctions", "-J", is_flag=True, help="Allow crossing junction boundaries")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def source_track(app, elements, deps, except_, cross_junctions):
     """Consults the specified tracking branches for new versions available
@@ -800,41 +868,50 @@ def source_track(app, elements, deps, except_, cross_junctions):
 
         # Substitute 'none' for 'redirect' so that element redirections
         # will be done
-        if deps == 'none':
-            deps = 'redirect'
-        app.stream.track(elements,
-                         selection=deps,
-                         except_targets=except_,
-                         cross_junctions=cross_junctions)
+        if deps == "none":
+            deps = "redirect"
+        app.stream.track(elements, selection=deps, except_targets=except_, cross_junctions=cross_junctions)
 
 
 ##################################################################
 #                  Source Checkout Command                      #
 ##################################################################
-@source.command(name='checkout', short_help='Checkout sources of an element')
-@click.option('--force', '-f', is_flag=True,
-              help="Allow files to be overwritten")
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['build', 'none', 'run', 'all']),
-              help='The dependencies whose sources to checkout')
-@click.option('--tar', default=None, metavar='LOCATION',
-              type=click.Path(),
-              help="Create a tarball containing the sources instead "
-                   "of a file tree.")
-@click.option('--compression', default=None,
-              type=click.Choice(['gz', 'xz', 'bz2']),
-              help="The compression option of the tarball created.")
-@click.option('--include-build-scripts', 'build_scripts', is_flag=True)
-@click.option('--directory', default='source-checkout',
-              type=click.Path(file_okay=False),
-              help="The directory to checkout the sources to")
-@click.argument('element', required=False, type=click.Path(readable=False))
+@source.command(name="checkout", short_help="Checkout sources of an element")
+@click.option("--force", "-f", is_flag=True, help="Allow files to be overwritten")
+@click.option(
+    "--except", "except_", multiple=True, type=click.Path(readable=False), help="Except certain dependencies"
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["build", "none", "run", "all"]),
+    help="The dependencies whose sources to checkout",
+)
+@click.option(
+    "--tar",
+    default=None,
+    metavar="LOCATION",
+    type=click.Path(),
+    help="Create a tarball containing the sources instead " "of a file tree.",
+)
+@click.option(
+    "--compression",
+    default=None,
+    type=click.Choice(["gz", "xz", "bz2"]),
+    help="The compression option of the tarball created.",
+)
+@click.option("--include-build-scripts", "build_scripts", is_flag=True)
+@click.option(
+    "--directory",
+    default="source-checkout",
+    type=click.Path(file_okay=False),
+    help="The directory to checkout the sources to",
+)
+@click.argument("element", required=False, type=click.Path(readable=False))
 @click.pass_obj
-def source_checkout(app, element, directory, force, deps, except_,
-                    tar, compression, build_scripts):
+def source_checkout(app, element, directory, force, deps, except_, tar, compression, build_scripts):
     """Checkout sources of an element to the specified location
 
     When this command is executed from a workspace directory, the default
@@ -859,14 +936,16 @@ def source_checkout(app, element, directory, force, deps, except_,
             if not element:
                 raise AppError('Missing argument "ELEMENT".')
 
-        app.stream.source_checkout(element,
-                                   location=location,
-                                   force=force,
-                                   deps=deps,
-                                   except_targets=except_,
-                                   tar=bool(tar),
-                                   compression=compression,
-                                   include_build_scripts=build_scripts)
+        app.stream.source_checkout(
+            element,
+            location=location,
+            force=force,
+            deps=deps,
+            except_targets=except_,
+            tar=bool(tar),
+            compression=compression,
+            include_build_scripts=build_scripts,
+        )
 
 
 ##################################################################
@@ -880,39 +959,42 @@ def workspace():
 ##################################################################
 #                     Workspace Open Command                     #
 ##################################################################
-@workspace.command(name='open', short_help="Open a new workspace")
-@click.option('--no-checkout', is_flag=True,
-              help="Do not checkout the source, only link to the given directory")
-@click.option('--force', '-f', is_flag=True,
-              help="The workspace will be created even if the directory in which it will be created is not empty " +
-              "or if a workspace for that element already exists")
-@click.option('--track', 'track_', is_flag=True,
-              help="Track and fetch new source references before checking out the workspace")
-@click.option('--directory', type=click.Path(file_okay=False), default=None,
-              help="Only for use when a single Element is given: Set the directory to use to create the workspace")
-@click.argument('elements', nargs=-1, type=click.Path(readable=False), required=True)
+@workspace.command(name="open", short_help="Open a new workspace")
+@click.option("--no-checkout", is_flag=True, help="Do not checkout the source, only link to the given directory")
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    help="The workspace will be created even if the directory in which it will be created is not empty "
+    + "or if a workspace for that element already exists",
+)
+@click.option(
+    "--track", "track_", is_flag=True, help="Track and fetch new source references before checking out the workspace"
+)
+@click.option(
+    "--directory",
+    type=click.Path(file_okay=False),
+    default=None,
+    help="Only for use when a single Element is given: Set the directory to use to create the workspace",
+)
+@click.argument("elements", nargs=-1, type=click.Path(readable=False), required=True)
 @click.pass_obj
 def workspace_open(app, no_checkout, force, track_, directory, elements):
     """Open a workspace for manual source modification"""
 
     with app.initialized():
-        app.stream.workspace_open(elements,
-                                  no_checkout=no_checkout,
-                                  track_first=track_,
-                                  force=force,
-                                  custom_dir=directory)
+        app.stream.workspace_open(
+            elements, no_checkout=no_checkout, track_first=track_, force=force, custom_dir=directory
+        )
 
 
 ##################################################################
 #                     Workspace Close Command                    #
 ##################################################################
-@workspace.command(name='close', short_help="Close workspaces")
-@click.option('--remove-dir', is_flag=True,
-              help="Remove the path that contains the closed workspace")
-@click.option('--all', '-a', 'all_', is_flag=True,
-              help="Close all open workspaces")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@workspace.command(name="close", short_help="Close workspaces")
+@click.option("--remove-dir", is_flag=True, help="Remove the path that contains the closed workspace")
+@click.option("--all", "-a", "all_", is_flag=True, help="Close all open workspaces")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def workspace_close(app, remove_dir, all_, elements):
     """Close a workspace"""
@@ -927,11 +1009,11 @@ def workspace_close(app, remove_dir, all_, elements):
             if element:
                 elements = (element,)
             else:
-                raise AppError('No elements specified')
+                raise AppError("No elements specified")
 
         # Early exit if we specified `all` and there are no workspaces
         if all_ and not app.stream.workspace_exists():
-            click.echo('No open workspaces to close', err=True)
+            click.echo("No open workspaces to close", err=True)
             sys.exit(0)
 
         if all_:
@@ -958,21 +1040,19 @@ def workspace_close(app, remove_dir, all_, elements):
     if removed_required_element:
         click.echo(
             "Removed '{}', therefore you can no longer run BuildStream "
-            "commands from the current directory.".format(element_name), err=True)
+            "commands from the current directory.".format(element_name),
+            err=True,
+        )
 
 
 ##################################################################
 #                     Workspace Reset Command                    #
 ##################################################################
-@workspace.command(name='reset', short_help="Reset a workspace to its original state")
-@click.option('--soft', is_flag=True,
-              help="Reset workspace state without affecting its contents")
-@click.option('--track', 'track_', is_flag=True,
-              help="Track and fetch the latest source before resetting")
-@click.option('--all', '-a', 'all_', is_flag=True,
-              help="Reset all open workspaces")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@workspace.command(name="reset", short_help="Reset a workspace to its original state")
+@click.option("--soft", is_flag=True, help="Reset workspace state without affecting its contents")
+@click.option("--track", "track_", is_flag=True, help="Track and fetch the latest source before resetting")
+@click.option("--all", "-a", "all_", is_flag=True, help="Reset all open workspaces")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def workspace_reset(app, soft, track_, all_, elements):
     """Reset a workspace to its original state"""
@@ -985,7 +1065,7 @@ def workspace_reset(app, soft, track_, all_, elements):
             if element:
                 elements = (element,)
             else:
-                raise AppError('No elements specified to reset')
+                raise AppError("No elements specified to reset")
 
         if all_ and not app.stream.workspace_exists():
             raise AppError("No open workspaces to reset")
@@ -999,7 +1079,7 @@ def workspace_reset(app, soft, track_, all_, elements):
 ##################################################################
 #                     Workspace List Command                     #
 ##################################################################
-@workspace.command(name='list', short_help="List open workspaces")
+@workspace.command(name="list", short_help="List open workspaces")
 @click.pass_obj
 def workspace_list(app):
     """List open workspaces"""
@@ -1044,11 +1124,16 @@ def artifact():
 #############################################################
 #                    Artifact show Command                  #
 #############################################################
-@artifact.command(name='show', short_help="Show the cached state of artifacts")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['build', 'run', 'all', 'none']),
-              help='The dependencies we also want to show')
-@click.argument('artifacts', type=click.Path(), nargs=-1)
+@artifact.command(name="show", short_help="Show the cached state of artifacts")
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["build", "run", "all", "none"]),
+    help="The dependencies we also want to show",
+)
+@click.argument("artifacts", type=click.Path(), nargs=-1)
 @click.pass_obj
 def artifact_show(app, deps, artifacts):
     """show the cached state of artifacts"""
@@ -1061,31 +1146,38 @@ def artifact_show(app, deps, artifacts):
 #####################################################################
 #                     Artifact Checkout Command                     #
 #####################################################################
-@artifact.command(name='checkout', short_help="Checkout contents of an artifact")
-@click.option('--force', '-f', is_flag=True,
-              help="Allow files to be overwritten")
-@click.option('--deps', '-d', default='run', show_default=True,
-              type=click.Choice(['run', 'build', 'none', 'all']),
-              help='The dependencies to checkout')
-@click.option('--integrate/--no-integrate', default=None, is_flag=True,
-              help="Whether to run integration commands")
-@click.option('--hardlinks', is_flag=True,
-              help="Checkout hardlinks instead of copying if possible")
-@click.option('--tar', default=None, metavar='LOCATION',
-              type=click.Path(),
-              help="Create a tarball from the artifact contents instead "
-                   "of a file tree. If LOCATION is '-', the tarball "
-                   "will be dumped to the standard output.")
-@click.option('--compression', default=None,
-              type=click.Choice(['gz', 'xz', 'bz2']),
-              help="The compression option of the tarball created.")
-@click.option('--pull', 'pull_', is_flag=True,
-              help="Pull the artifact if it's missing or incomplete.")
-@click.option('--directory', default=None,
-              type=click.Path(file_okay=False),
-              help="The directory to checkout the artifact to")
-@click.argument('target', required=False,
-                type=click.Path(readable=False))
+@artifact.command(name="checkout", short_help="Checkout contents of an artifact")
+@click.option("--force", "-f", is_flag=True, help="Allow files to be overwritten")
+@click.option(
+    "--deps",
+    "-d",
+    default="run",
+    show_default=True,
+    type=click.Choice(["run", "build", "none", "all"]),
+    help="The dependencies to checkout",
+)
+@click.option("--integrate/--no-integrate", default=None, is_flag=True, help="Whether to run integration commands")
+@click.option("--hardlinks", is_flag=True, help="Checkout hardlinks instead of copying if possible")
+@click.option(
+    "--tar",
+    default=None,
+    metavar="LOCATION",
+    type=click.Path(),
+    help="Create a tarball from the artifact contents instead "
+    "of a file tree. If LOCATION is '-', the tarball "
+    "will be dumped to the standard output.",
+)
+@click.option(
+    "--compression",
+    default=None,
+    type=click.Choice(["gz", "xz", "bz2"]),
+    help="The compression option of the tarball created.",
+)
+@click.option("--pull", "pull_", is_flag=True, help="Pull the artifact if it's missing or incomplete.")
+@click.option(
+    "--directory", default=None, type=click.Path(file_okay=False), help="The directory to checkout the artifact to"
+)
+@click.argument("target", required=False, type=click.Path(readable=False))
 @click.pass_obj
 def artifact_checkout(app, force, deps, integrate, hardlinks, tar, compression, pull_, directory, target):
     """Checkout contents of an artifact
@@ -1110,7 +1202,7 @@ def artifact_checkout(app, force, deps, integrate, hardlinks, tar, compression,
                 location = os.path.abspath(os.path.join(os.getcwd(), target))
             else:
                 location = directory
-            if location[-4:] == '.bst':
+            if location[-4:] == ".bst":
                 location = location[:-4]
             tar = False
     else:
@@ -1120,9 +1212,12 @@ def artifact_checkout(app, force, deps, integrate, hardlinks, tar, compression,
         except UtilError as e:
             click.echo("ERROR: Invalid file extension given with '--tar': {}".format(e), err=True)
             sys.exit(-1)
-        if compression and inferred_compression != '' and inferred_compression != compression:
-            click.echo("WARNING: File extension and compression differ."
-                       "File extension has been overridden by --compression", err=True)
+        if compression and inferred_compression != "" and inferred_compression != compression:
+            click.echo(
+                "WARNING: File extension and compression differ."
+                "File extension has been overridden by --compression",
+                err=True,
+            )
         if not compression:
             compression = inferred_compression
 
@@ -1132,28 +1227,35 @@ def artifact_checkout(app, force, deps, integrate, hardlinks, tar, compression,
             if not target:
                 raise AppError('Missing argument "ELEMENT".')
 
-        app.stream.checkout(target,
-                            location=location,
-                            force=force,
-                            selection=deps,
-                            integrate=True if integrate is None else integrate,
-                            hardlinks=hardlinks,
-                            pull=pull_,
-                            compression=compression,
-                            tar=bool(tar))
+        app.stream.checkout(
+            target,
+            location=location,
+            force=force,
+            selection=deps,
+            integrate=True if integrate is None else integrate,
+            hardlinks=hardlinks,
+            pull=pull_,
+            compression=compression,
+            tar=bool(tar),
+        )
 
 
 ################################################################
 #                     Artifact Pull Command                    #
 ################################################################
 @artifact.command(name="pull", short_help="Pull a built artifact")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependency artifacts to pull')
-@click.option('--remote', '-r', default=None,
-              help="The URL of the remote cache (defaults to the first configured cache)")
-@click.argument('artifacts', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependency artifacts to pull",
+)
+@click.option(
+    "--remote", "-r", default=None, help="The URL of the remote cache (defaults to the first configured cache)"
+)
+@click.argument("artifacts", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def artifact_pull(app, artifacts, deps, remote):
     """Pull a built artifact from the configured remote artifact cache.
@@ -1184,21 +1286,25 @@ def artifact_pull(app, artifacts, deps, remote):
             # Junction elements cannot be pulled, exclude them from default targets
             ignore_junction_targets = True
 
-        app.stream.pull(artifacts, selection=deps, remote=remote,
-                        ignore_junction_targets=ignore_junction_targets)
+        app.stream.pull(artifacts, selection=deps, remote=remote, ignore_junction_targets=ignore_junction_targets)
 
 
 ##################################################################
 #                     Artifact Push Command                      #
 ##################################################################
 @artifact.command(name="push", short_help="Push a built artifact")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependencies to push')
-@click.option('--remote', '-r', default=None,
-              help="The URL of the remote cache (defaults to the first configured cache)")
-@click.argument('artifacts', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependencies to push",
+)
+@click.option(
+    "--remote", "-r", default=None, help="The URL of the remote cache (defaults to the first configured cache)"
+)
+@click.argument("artifacts", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def artifact_push(app, artifacts, deps, remote):
     """Push a built artifact to a remote artifact cache.
@@ -1231,18 +1337,19 @@ def artifact_push(app, artifacts, deps, remote):
             # Junction elements cannot be pushed, exclude them from default targets
             ignore_junction_targets = True
 
-        app.stream.push(artifacts, selection=deps, remote=remote,
-                        ignore_junction_targets=ignore_junction_targets)
+        app.stream.push(artifacts, selection=deps, remote=remote, ignore_junction_targets=ignore_junction_targets)
 
 
 ################################################################
 #                     Artifact Log Command                     #
 ################################################################
-@artifact.command(name='log', short_help="Show logs of artifacts")
-@click.option('--out',
-              type=click.Path(file_okay=True, writable=True),
-              help="Output logs to individual files in the specified path. If absent, logs are written to stdout.")
-@click.argument('artifacts', type=click.Path(), nargs=-1)
+@artifact.command(name="log", short_help="Show logs of artifacts")
+@click.option(
+    "--out",
+    type=click.Path(file_okay=True, writable=True),
+    help="Output logs to individual files in the specified path. If absent, logs are written to stdout.",
+)
+@click.argument("artifacts", type=click.Path(), nargs=-1)
 @click.pass_obj
 def artifact_log(app, artifacts, out):
     """Show build logs of artifacts"""
@@ -1252,7 +1359,7 @@ def artifact_log(app, artifacts, out):
         if not out:
             try:
                 for log in list(artifact_logs.values()):
-                    with open(log[0], 'r') as f:
+                    with open(log[0], "r") as f:
                         data = f.read()
                     click.echo_via_pager(data)
             except (OSError, FileNotFoundError):
@@ -1274,7 +1381,7 @@ def artifact_log(app, artifacts, out):
                         shutil.copy(log, dest)
                     # make a dir and write in log files
                 else:
-                    log_name = os.path.splitext(name)[0] + '.log'
+                    log_name = os.path.splitext(name)[0] + ".log"
                     dest = os.path.join(out, log_name)
                     shutil.copy(log_files[0], dest)
                     # write a log file
@@ -1283,10 +1390,11 @@ def artifact_log(app, artifacts, out):
 ################################################################
 #                Artifact List-Contents Command                #
 ################################################################
-@artifact.command(name='list-contents', short_help="List the contents of an artifact")
-@click.option('--long', '-l', 'long_', is_flag=True,
-              help="Provide more information about the contents of the artifact.")
-@click.argument('artifacts', type=click.Path(), nargs=-1)
+@artifact.command(name="list-contents", short_help="List the contents of an artifact")
+@click.option(
+    "--long", "-l", "long_", is_flag=True, help="Provide more information about the contents of the artifact."
+)
+@click.argument("artifacts", type=click.Path(), nargs=-1)
 @click.pass_obj
 def artifact_list_contents(app, artifacts, long_):
     """List the contents of an artifact.
@@ -1308,11 +1416,16 @@ def artifact_list_contents(app, artifacts, long_):
 ###################################################################
 #                     Artifact Delete Command                     #
 ###################################################################
-@artifact.command(name='delete', short_help="Remove artifacts from the local cache")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'run', 'build', 'all']),
-              help="The dependencies to delete")
-@click.argument('artifacts', type=click.Path(), nargs=-1)
+@artifact.command(name="delete", short_help="Remove artifacts from the local cache")
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "run", "build", "all"]),
+    help="The dependencies to delete",
+)
+@click.argument("artifacts", type=click.Path(), nargs=-1)
 @click.pass_obj
 def artifact_delete(app, artifacts, deps):
     """Remove artifacts from the local cache"""
@@ -1333,18 +1446,24 @@ def artifact_delete(app, artifacts, deps):
 #                          Fetch Command                         #
 ##################################################################
 @cli.command(short_help="COMMAND OBSOLETE - Fetch sources in a pipeline", hidden=True)
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies from fetching")
-@click.option('--deps', '-d', default='plan', show_default=True,
-              type=click.Choice(['none', 'plan', 'all']),
-              help='The dependencies to fetch')
-@click.option('--track', 'track_', is_flag=True,
-              help="Track new source references before fetching")
-@click.option('--track-cross-junctions', '-J', is_flag=True,
-              help="Allow tracking to cross junction boundaries")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--except",
+    "except_",
+    multiple=True,
+    type=click.Path(readable=False),
+    help="Except certain dependencies from fetching",
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="plan",
+    show_default=True,
+    type=click.Choice(["none", "plan", "all"]),
+    help="The dependencies to fetch",
+)
+@click.option("--track", "track_", is_flag=True, help="Track new source references before fetching")
+@click.option("--track-cross-junctions", "-J", is_flag=True, help="Allow tracking to cross junction boundaries")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def fetch(app, elements, deps, track_, except_, track_cross_junctions):
     click.echo("This command is now obsolete. Use `bst source fetch` instead.", err=True)
@@ -1355,16 +1474,23 @@ def fetch(app, elements, deps, track_, except_, track_cross_junctions):
 #                          Track Command                         #
 ##################################################################
 @cli.command(short_help="COMMAND OBSOLETE - Track new source references", hidden=True)
-@click.option('--except', 'except_', multiple=True,
-              type=click.Path(readable=False),
-              help="Except certain dependencies from tracking")
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependencies to track')
-@click.option('--cross-junctions', '-J', is_flag=True,
-              help="Allow crossing junction boundaries")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--except",
+    "except_",
+    multiple=True,
+    type=click.Path(readable=False),
+    help="Except certain dependencies from tracking",
+)
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependencies to track",
+)
+@click.option("--cross-junctions", "-J", is_flag=True, help="Allow crossing junction boundaries")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def track(app, elements, deps, except_, cross_junctions):
     click.echo("This command is now obsolete. Use `bst source track` instead.", err=True)
@@ -1375,26 +1501,33 @@ def track(app, elements, deps, except_, cross_junctions):
 #                        Checkout Command                        #
 ##################################################################
 @cli.command(short_help="COMMAND OBSOLETE - Checkout a built artifact", hidden=True)
-@click.option('--force', '-f', is_flag=True,
-              help="Allow files to be overwritten")
-@click.option('--deps', '-d', default='run', show_default=True,
-              type=click.Choice(['run', 'build', 'none']),
-              help='The dependencies to checkout')
-@click.option('--integrate/--no-integrate', default=True,
-              help="Run integration commands (default is to run commands)")
-@click.option('--hardlinks', is_flag=True,
-              help="Checkout hardlinks instead of copies (handle with care)")
-@click.option('--tar', is_flag=True,
-              help="Create a tarball from the artifact contents instead "
-                   "of a file tree. If LOCATION is '-', the tarball "
-                   "will be dumped to the standard output.")
-@click.argument('element', required=False,
-                type=click.Path(readable=False))
-@click.argument('location', type=click.Path(), required=False)
+@click.option("--force", "-f", is_flag=True, help="Allow files to be overwritten")
+@click.option(
+    "--deps",
+    "-d",
+    default="run",
+    show_default=True,
+    type=click.Choice(["run", "build", "none"]),
+    help="The dependencies to checkout",
+)
+@click.option("--integrate/--no-integrate", default=True, help="Run integration commands (default is to run commands)")
+@click.option("--hardlinks", is_flag=True, help="Checkout hardlinks instead of copies (handle with care)")
+@click.option(
+    "--tar",
+    is_flag=True,
+    help="Create a tarball from the artifact contents instead "
+    "of a file tree. If LOCATION is '-', the tarball "
+    "will be dumped to the standard output.",
+)
+@click.argument("element", required=False, type=click.Path(readable=False))
+@click.argument("location", type=click.Path(), required=False)
 @click.pass_obj
 def checkout(app, element, location, force, deps, integrate, hardlinks, tar):
-    click.echo("This command is now obsolete. Use `bst artifact checkout` instead " +
-               "and use the --directory option to specify LOCATION", err=True)
+    click.echo(
+        "This command is now obsolete. Use `bst artifact checkout` instead "
+        + "and use the --directory option to specify LOCATION",
+        err=True,
+    )
     sys.exit(1)
 
 
@@ -1402,13 +1535,16 @@ def checkout(app, element, location, force, deps, integrate, hardlinks, tar):
 #                          Pull Command                        #
 ################################################################
 @cli.command(short_help="COMMAND OBSOLETE - Pull a built artifact", hidden=True)
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependency artifacts to pull')
-@click.option('--remote', '-r',
-              help="The URL of the remote cache (defaults to the first configured cache)")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependency artifacts to pull",
+)
+@click.option("--remote", "-r", help="The URL of the remote cache (defaults to the first configured cache)")
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def pull(app, elements, deps, remote):
     click.echo("This command is now obsolete. Use `bst artifact pull` instead.", err=True)
@@ -1419,13 +1555,18 @@ def pull(app, elements, deps, remote):
 #                           Push Command                         #
 ##################################################################
 @cli.command(short_help="COMMAND OBSOLETE - Push a built artifact", hidden=True)
-@click.option('--deps', '-d', default='none', show_default=True,
-              type=click.Choice(['none', 'all']),
-              help='The dependencies to push')
-@click.option('--remote', '-r', default=None,
-              help="The URL of the remote cache (defaults to the first configured cache)")
-@click.argument('elements', nargs=-1,
-                type=click.Path(readable=False))
+@click.option(
+    "--deps",
+    "-d",
+    default="none",
+    show_default=True,
+    type=click.Choice(["none", "all"]),
+    help="The dependencies to push",
+)
+@click.option(
+    "--remote", "-r", default=None, help="The URL of the remote cache (defaults to the first configured cache)"
+)
+@click.argument("elements", nargs=-1, type=click.Path(readable=False))
 @click.pass_obj
 def push(app, elements, deps, remote):
     click.echo("This command is now obsolete. Use `bst artifact push` instead.", err=True)
diff --git a/src/buildstream/_frontend/complete.py b/src/buildstream/_frontend/complete.py
index 06067f6cc..45e857e3e 100644
--- a/src/buildstream/_frontend/complete.py
+++ b/src/buildstream/_frontend/complete.py
@@ -39,9 +39,9 @@ import click
 from click.core import MultiCommand, Option, Argument
 from click.parser import split_arg_string
 
-WORDBREAK = '='
+WORDBREAK = "="
 
-COMPLETION_SCRIPT = '''
+COMPLETION_SCRIPT = """
 %(complete_func)s() {
     local IFS=$'\n'
     COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
@@ -51,7 +51,7 @@ COMPLETION_SCRIPT = '''
 }
 
 complete -F %(complete_func)s -o nospace %(script_names)s
-'''
+"""
 
 
 # An exception for our custom completion handler to
@@ -62,7 +62,7 @@ class CompleteUnhandled(Exception):
     pass
 
 
-def complete_path(path_type, incomplete, base_directory='.'):
+def complete_path(path_type, incomplete, base_directory="."):
     """Helper method for implementing the completions() method
     for File and Path parameter types.
     """
@@ -71,7 +71,7 @@ def complete_path(path_type, incomplete, base_directory='.'):
     # specified in `incomplete` minus the last path component,
     # otherwise list files starting from the current working directory.
     entries = []
-    base_path = ''
+    base_path = ""
 
     # This is getting a bit messy
     listed_base_directory = False
@@ -128,11 +128,11 @@ def complete_path(path_type, incomplete, base_directory='.'):
 
     return [
         # Return an appropriate path for each entry
-        fix_path(e) for e in sorted(entries)
-
+        fix_path(e)
+        for e in sorted(entries)
         # Filter out non directory elements when searching for a directory,
         # the opposite is fine, however.
-        if not (path_type == 'Directory' and not entry_is_dir(e))
+        if not (path_type == "Directory" and not entry_is_dir(e))
     ]
 
 
@@ -183,7 +183,7 @@ def start_of_option(param_str):
     :param param_str: param_str to check
     :return: whether or not this is the start of an option declaration (i.e. starts "-" or "--")
     """
-    return param_str and param_str[:1] == '-'
+    return param_str and param_str[:1] == "-"
 
 
 def is_incomplete_option(all_args, cmd_param):
@@ -218,8 +218,11 @@ def is_incomplete_argument(current_params, cmd_param):
         return True
     if cmd_param.nargs == -1:
         return True
-    if isinstance(current_param_values, collections.abc.Iterable) \
-            and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
+    if (
+        isinstance(current_param_values, collections.abc.Iterable)
+        and cmd_param.nargs > 1
+        and len(current_param_values) < cmd_param.nargs
+    ):
         return True
     return False
 
@@ -237,10 +240,7 @@ def get_user_autocompletions(args, incomplete, cmd, cmd_param, override):
 
     # Use the type specific default completions unless it was overridden
     try:
-        return override(cmd=cmd,
-                        cmd_param=cmd_param,
-                        args=args,
-                        incomplete=incomplete)
+        return override(cmd=cmd, cmd_param=cmd_param, args=args, incomplete=incomplete)
     except CompleteUnhandled:
         return get_param_type_completion(cmd_param.type, incomplete) or []
 
@@ -269,7 +269,7 @@ def get_choices(cli, prog_name, args, incomplete, override):
         all_args.append(partition_incomplete[0])
         incomplete = partition_incomplete[2]
     elif incomplete == WORDBREAK:
-        incomplete = ''
+        incomplete = ""
 
     choices = []
     found_param = False
@@ -277,8 +277,13 @@ def get_choices(cli, prog_name, args, incomplete, override):
         # completions for options
         for param in ctx.command.params:
             if isinstance(param, Option):
-                choices.extend([param_opt + " " for param_opt in param.opts + param.secondary_opts
-                                if param_opt not in all_args or param.multiple])
+                choices.extend(
+                    [
+                        param_opt + " "
+                        for param_opt in param.opts + param.secondary_opts
+                        if param_opt not in all_args or param.multiple
+                    ]
+                )
         found_param = True
     if not found_param:
         # completion for option values by choices
@@ -297,14 +302,22 @@ def get_choices(cli, prog_name, args, incomplete, override):
 
     if not found_param and isinstance(ctx.command, MultiCommand):
         # completion for any subcommands
-        choices.extend([cmd + " " for cmd in ctx.command.list_commands(ctx)
-                        if not ctx.command.get_command(ctx, cmd).hidden])
-
-    if not start_of_option(incomplete) and ctx.parent is not None \
-       and isinstance(ctx.parent.command, MultiCommand) and ctx.parent.command.chain:
+        choices.extend(
+            [cmd + " " for cmd in ctx.command.list_commands(ctx) if not ctx.command.get_command(ctx, cmd).hidden]
+        )
+
+    if (
+        not start_of_option(incomplete)
+        and ctx.parent is not None
+        and isinstance(ctx.parent.command, MultiCommand)
+        and ctx.parent.command.chain
+    ):
         # completion for chained commands
-        visible_commands = [cmd for cmd in ctx.parent.command.list_commands(ctx.parent)
-                            if not ctx.parent.command.get_command(ctx.parent, cmd).hidden]
+        visible_commands = [
+            cmd
+            for cmd in ctx.parent.command.list_commands(ctx.parent)
+            if not ctx.parent.command.get_command(ctx.parent, cmd).hidden
+        ]
         remaining_commands = set(visible_commands) - set(ctx.parent.protected_args)
         choices.extend([cmd + " " for cmd in remaining_commands])
 
@@ -314,13 +327,13 @@ def get_choices(cli, prog_name, args, incomplete, override):
 
 
 def do_complete(cli, prog_name, override):
-    cwords = split_arg_string(os.environ['COMP_WORDS'])
-    cword = int(os.environ['COMP_CWORD'])
+    cwords = split_arg_string(os.environ["COMP_WORDS"])
+    cword = int(os.environ["COMP_CWORD"])
     args = cwords[1:cword]
     try:
         incomplete = cwords[cword]
     except IndexError:
-        incomplete = ''
+        incomplete = ""
 
     for item in get_choices(cli, prog_name, args, incomplete, override):
         click.echo(item)
@@ -331,7 +344,7 @@ def do_complete(cli, prog_name, override):
 def main_bashcomplete(cmd, prog_name, override):
     """Internal handler for the bash completion support."""
 
-    if '_BST_COMPLETION' in os.environ:
+    if "_BST_COMPLETION" in os.environ:
         do_complete(cmd, prog_name, override)
         return True
 
diff --git a/src/buildstream/_frontend/linuxapp.py b/src/buildstream/_frontend/linuxapp.py
index 0444dc7b4..987b023bd 100644
--- a/src/buildstream/_frontend/linuxapp.py
+++ b/src/buildstream/_frontend/linuxapp.py
@@ -28,9 +28,9 @@ from .app import App
 #
 def _osc_777_supported():
 
-    term = os.environ.get('TERM')
+    term = os.environ.get("TERM")
 
-    if term and (term.startswith('xterm') or term.startswith('vte')):
+    if term and (term.startswith("xterm") or term.startswith("vte")):
 
         # Since vte version 4600, upstream silently ignores
         # the OSC 777 without printing garbage to the terminal.
@@ -39,7 +39,7 @@ def _osc_777_supported():
         # will trigger a desktop notification and bring attention
         # to the terminal.
         #
-        vte_version = os.environ.get('VTE_VERSION')
+        vte_version = os.environ.get("VTE_VERSION")
         try:
             vte_version_int = int(vte_version)
         except (ValueError, TypeError):
@@ -54,7 +54,6 @@ def _osc_777_supported():
 # A linux specific App implementation
 #
 class LinuxApp(App):
-
     def notify(self, title, text):
 
         # Currently we only try this notification method
diff --git a/src/buildstream/_frontend/profile.py b/src/buildstream/_frontend/profile.py
index dda0f7ffe..f49be5b0a 100644
--- a/src/buildstream/_frontend/profile.py
+++ b/src/buildstream/_frontend/profile.py
@@ -28,7 +28,7 @@ import click
 # Kwargs:
 #    The same keyword arguments which can be used with click.style()
 #
-class Profile():
+class Profile:
     def __init__(self, **kwargs):
         self._kwargs = dict(kwargs)
 
@@ -64,7 +64,6 @@ class Profile():
     #    arguments
     #
     def fmt_subst(self, text, varname, value, **kwargs):
-
         def subst_callback(match):
             # Extract and format the "{(varname)...}" portion of the match
             inner_token = match.group(1)
diff --git a/src/buildstream/_frontend/status.py b/src/buildstream/_frontend/status.py
index 85fdf7451..a3f0d8aa7 100644
--- a/src/buildstream/_frontend/status.py
+++ b/src/buildstream/_frontend/status.py
@@ -43,19 +43,12 @@ from .widget import TimeCode
 #    error_profile (Profile): Formatting profile for error text
 #    stream (Stream): The Stream
 #
-class Status():
+class Status:
 
     # Table of the terminal capabilities we require and use
-    _TERM_CAPABILITIES = {
-        'move_up': 'cuu1',
-        'move_x': 'hpa',
-        'clear_eol': 'el'
-    }
+    _TERM_CAPABILITIES = {"move_up": "cuu1", "move_x": "hpa", "clear_eol": "el"}
 
-    def __init__(self, context, state,
-                 content_profile, format_profile,
-                 success_profile, error_profile,
-                 stream):
+    def __init__(self, context, state, content_profile, format_profile, success_profile, error_profile, stream):
 
         self._context = context
         self._state = state
@@ -67,10 +60,9 @@ class Status():
         self._jobs = OrderedDict()
         self._last_lines = 0  # Number of status lines we last printed to console
         self._spacing = 1
-        self._header = _StatusHeader(context, state,
-                                     content_profile, format_profile,
-                                     success_profile, error_profile,
-                                     stream)
+        self._header = _StatusHeader(
+            context, state, content_profile, format_profile, success_profile, error_profile, stream
+        )
 
         self._term_width, _ = click.get_terminal_size()
         self._alloc_lines = 0
@@ -131,7 +123,7 @@ class Status():
         # feeds for the amount of lines we intend to print first, and
         # move cursor position back to the first line
         for _ in range(self._alloc_lines + self._header.lines):
-            click.echo('', err=True)
+            click.echo("", err=True)
         for _ in range(self._alloc_lines + self._header.lines):
             self._move_up()
 
@@ -143,14 +135,14 @@ class Status():
         # alignment of each column
         n_columns = len(self._alloc_columns)
         for line in self._job_lines(n_columns):
-            text = ''
+            text = ""
             for job in line:
                 column = line.index(job)
                 text += job.render(self._alloc_columns[column] - job.size, elapsed)
 
                 # Add spacing between columns
                 if column < (n_columns - 1):
-                    text += ' ' * self._spacing
+                    text += " " * self._spacing
 
             # Print the line
             click.echo(text, err=True)
@@ -196,7 +188,7 @@ class Status():
         # Initialized terminal, curses might decide it doesnt
         # support this terminal
         try:
-            curses.setupterm(os.environ.get('TERM', 'dumb'))
+            curses.setupterm(os.environ.get("TERM", "dumb"))
         except curses.error:
             return None
 
@@ -221,7 +213,7 @@ class Status():
             # as well, and should provide better compatibility with most
             # terminals.
             #
-            term_caps[capname] = code.decode('latin1')
+            term_caps[capname] = code.decode("latin1")
 
         return term_caps
 
@@ -236,19 +228,19 @@ class Status():
 
         # Explicitly move to beginning of line, fixes things up
         # when there was a ^C or ^Z printed to the terminal.
-        move_x = curses.tparm(self._term_caps['move_x'].encode('latin1'), 0)
-        move_x = move_x.decode('latin1')
+        move_x = curses.tparm(self._term_caps["move_x"].encode("latin1"), 0)
+        move_x = move_x.decode("latin1")
 
-        move_up = curses.tparm(self._term_caps['move_up'].encode('latin1'))
-        move_up = move_up.decode('latin1')
+        move_up = curses.tparm(self._term_caps["move_up"].encode("latin1"))
+        move_up = move_up.decode("latin1")
 
         click.echo(move_x + move_up, nl=False, err=True)
 
     def _clear_line(self):
         assert self._term_caps is not None
 
-        clear_eol = curses.tparm(self._term_caps['clear_eol'].encode('latin1'))
-        clear_eol = clear_eol.decode('latin1')
+        clear_eol = curses.tparm(self._term_caps["clear_eol"].encode("latin1"))
+        clear_eol = clear_eol.decode("latin1")
         click.echo(clear_eol, nl=False, err=True)
 
     def _allocate(self):
@@ -277,7 +269,7 @@ class Status():
     def _job_lines(self, columns):
         jobs_list = list(self._jobs.values())
         for i in range(0, len(self._jobs), columns):
-            yield jobs_list[i:i + columns]
+            yield jobs_list[i : i + columns]
 
     # Returns an array of integers representing the maximum
     # length in characters for each column, given the current
@@ -307,9 +299,7 @@ class Status():
     def _add_job(self, action_name, full_name):
         task = self._state.tasks[(action_name, full_name)]
         elapsed = task.elapsed_offset
-        job = _StatusJob(self._context, action_name, full_name,
-                         self._content_profile, self._format_profile,
-                         elapsed)
+        job = _StatusJob(self._context, action_name, full_name, self._content_profile, self._format_profile, elapsed)
         self._jobs[(action_name, full_name)] = job
         self._need_alloc = True
 
@@ -338,12 +328,8 @@ class Status():
 #    error_profile (Profile): Formatting profile for error text
 #    stream (Stream): The Stream
 #
-class _StatusHeader():
-
-    def __init__(self, context, state,
-                 content_profile, format_profile,
-                 success_profile, error_profile,
-                 stream):
+class _StatusHeader:
+    def __init__(self, context, state, content_profile, format_profile, success_profile, error_profile, stream):
 
         #
         # Public members
@@ -375,19 +361,22 @@ class _StatusHeader():
         total = str(len(self._stream.total_elements))
 
         size = 0
-        text = ''
+        text = ""
         size += len(total) + len(session) + 4  # Size for (N/N) with a leading space
         size += 8  # Size of time code
         size += len(project.name) + 1
         text += self._time_code.render_time(elapsed)
-        text += ' ' + self._content_profile.fmt(project.name)
-        text += ' ' + self._format_profile.fmt('(') + \
-                self._content_profile.fmt(session) + \
-                self._format_profile.fmt('/') + \
-                self._content_profile.fmt(total) + \
-                self._format_profile.fmt(')')
-
-        line1 = self._centered(text, size, line_length, '=')
+        text += " " + self._content_profile.fmt(project.name)
+        text += (
+            " "
+            + self._format_profile.fmt("(")
+            + self._content_profile.fmt(session)
+            + self._format_profile.fmt("/")
+            + self._content_profile.fmt(total)
+            + self._format_profile.fmt(")")
+        )
+
+        line1 = self._centered(text, size, line_length, "=")
 
         #
         # Line 2: Dynamic list of queue status reports
@@ -395,7 +384,7 @@ class _StatusHeader():
         #  (Sources Fetched:0 117 0)→ (Built:4 0 0)
         #
         size = 0
-        text = ''
+        text = ""
 
         # Format and calculate size for each queue progress
         for index, task_group in enumerate(self._state.task_groups.values()):
@@ -403,13 +392,13 @@ class _StatusHeader():
             # Add spacing
             if index > 0:
                 size += 2
-                text += self._format_profile.fmt('→ ')
+                text += self._format_profile.fmt("→ ")
 
             group_text, group_size = self._render_task_group(task_group)
             size += group_size
             text += group_text
 
-        line2 = self._centered(text, size, line_length, ' ')
+        line2 = self._centered(text, size, line_length, " ")
 
         #
         # Line 3: Cache usage percentage report
@@ -423,7 +412,7 @@ class _StatusHeader():
         if usage.used_size is None:
             # Cache usage is unknown
             size = 0
-            text = ''
+            text = ""
         else:
             size = 21
             size += len(usage_string)
@@ -434,15 +423,17 @@ class _StatusHeader():
             else:
                 formatted_usage = self._success_profile.fmt(usage_string)
 
-            text = self._format_profile.fmt("~~~~~~ ") + \
-                self._content_profile.fmt('cache') + \
-                self._format_profile.fmt(': ') + \
-                formatted_usage + \
-                self._format_profile.fmt(' ~~~~~~')
+            text = (
+                self._format_profile.fmt("~~~~~~ ")
+                + self._content_profile.fmt("cache")
+                + self._format_profile.fmt(": ")
+                + formatted_usage
+                + self._format_profile.fmt(" ~~~~~~")
+            )
 
-        line3 = self._centered(text, size, line_length, ' ')
+        line3 = self._centered(text, size, line_length, " ")
 
-        return line1 + '\n' + line2 + '\n' + line3
+        return line1 + "\n" + line2 + "\n" + line3
 
     ###################################################
     #                 Private Methods                 #
@@ -455,13 +446,17 @@ class _StatusHeader():
         size = 5  # Space for the formatting '[', ':', ' ', ' ' and ']'
         size += len(group.complete_name)
         size += len(processed) + len(skipped) + len(failed)
-        text = self._format_profile.fmt("(") + \
-            self._content_profile.fmt(group.complete_name) + \
-            self._format_profile.fmt(":") + \
-            self._success_profile.fmt(processed) + ' ' + \
-            self._content_profile.fmt(skipped) + ' ' + \
-            self._error_profile.fmt(failed) + \
-            self._format_profile.fmt(")")
+        text = (
+            self._format_profile.fmt("(")
+            + self._content_profile.fmt(group.complete_name)
+            + self._format_profile.fmt(":")
+            + self._success_profile.fmt(processed)
+            + " "
+            + self._content_profile.fmt(skipped)
+            + " "
+            + self._error_profile.fmt(failed)
+            + self._format_profile.fmt(")")
+        )
 
         return (text, size)
 
@@ -469,9 +464,9 @@ class _StatusHeader():
         remaining = line_length - size
         remaining -= 2
 
-        final_text = self._format_profile.fmt(fill * (remaining // 2)) + ' '
+        final_text = self._format_profile.fmt(fill * (remaining // 2)) + " "
         final_text += text
-        final_text += ' ' + self._format_profile.fmt(fill * (remaining // 2))
+        final_text += " " + self._format_profile.fmt(fill * (remaining // 2))
 
         return final_text
 
@@ -488,14 +483,13 @@ class _StatusHeader():
 #    format_profile (Profile): Formatting profile for formatting text
 #    elapsed (datetime): The offset into the session when this job is created
 #
-class _StatusJob():
-
+class _StatusJob:
     def __init__(self, context, action_name, full_name, content_profile, format_profile, elapsed):
         #
         # Public members
         #
-        self.action_name = action_name    # The action name
-        self.size = None                  # The number of characters required to render
+        self.action_name = action_name  # The action name
+        self.size = None  # The number of characters required to render
         self.full_name = full_name
 
         #
@@ -568,24 +562,26 @@ class _StatusJob():
     #    elapsed (datetime): The session elapsed time offset
     #
     def render(self, padding, elapsed):
-        text = self._format_profile.fmt('[') + \
-            self._time_code.render_time(elapsed - self._offset) + \
-            self._format_profile.fmt(']')
-
-        text += self._format_profile.fmt('[') + \
-            self._content_profile.fmt(self.action_name) + \
-            self._format_profile.fmt(':') + \
-            self._content_profile.fmt(self.full_name)
+        text = (
+            self._format_profile.fmt("[")
+            + self._time_code.render_time(elapsed - self._offset)
+            + self._format_profile.fmt("]")
+        )
+
+        text += (
+            self._format_profile.fmt("[")
+            + self._content_profile.fmt(self.action_name)
+            + self._format_profile.fmt(":")
+            + self._content_profile.fmt(self.full_name)
+        )
 
         if self._current_progress is not None:
-            text += self._format_profile.fmt(':') + \
-                self._content_profile.fmt(str(self._current_progress))
+            text += self._format_profile.fmt(":") + self._content_profile.fmt(str(self._current_progress))
             if self._maximum_progress is not None:
-                text += self._format_profile.fmt('/') + \
-                    self._content_profile.fmt(str(self._maximum_progress))
+                text += self._format_profile.fmt("/") + self._content_profile.fmt(str(self._maximum_progress))
 
         # Add padding before terminating ']'
-        terminator = (' ' * padding) + ']'
+        terminator = (" " * padding) + "]"
         text += self._format_profile.fmt(terminator)
 
         return text
diff --git a/src/buildstream/_frontend/widget.py b/src/buildstream/_frontend/widget.py
index 0a268b717..63fbfbb7d 100644
--- a/src/buildstream/_frontend/widget.py
+++ b/src/buildstream/_frontend/widget.py
@@ -45,8 +45,7 @@ ERROR_MESSAGES = [MessageType.FAIL, MessageType.ERROR, MessageType.BUG]
 #
 # An abstract class for printing output columns in our text UI.
 #
-class Widget():
-
+class Widget:
     def __init__(self, context, content_profile, format_profile):
 
         # The context
@@ -74,7 +73,6 @@ class Widget():
 
 # Used to add fixed text between columns
 class FixedText(Widget):
-
     def __init__(self, context, text, content_profile, format_profile):
         super().__init__(context, content_profile, format_profile)
         self.text = text
@@ -91,15 +89,13 @@ class WallclockTime(Widget):
 
     def render(self, message):
 
-        fields = [self.content_profile.fmt("{:02d}".format(x)) for x in
-                  [message.creation_time.hour,
-                   message.creation_time.minute,
-                   message.creation_time.second,
-                   ]
-                  ]
+        fields = [
+            self.content_profile.fmt("{:02d}".format(x))
+            for x in [message.creation_time.hour, message.creation_time.minute, message.creation_time.second,]
+        ]
         text = self.format_profile.fmt(":").join(fields)
 
-        if self._output_format == 'us':
+        if self._output_format == "us":
             text += self.content_profile.fmt(".{:06d}".format(message.creation_time.microsecond))
 
         return text
@@ -107,11 +103,10 @@ class WallclockTime(Widget):
 
 # A widget for rendering the debugging column
 class Debug(Widget):
-
     def render(self, message):
         element_name = "n/a" if message.element_name is None else message.element_name
 
-        text = self.format_profile.fmt('pid:')
+        text = self.format_profile.fmt("pid:")
         text += self.content_profile.fmt("{: <5}".format(message.pid))
         text += self.format_profile.fmt("element name:")
         text += self.content_profile.fmt("{: <30}".format(element_name))
@@ -130,19 +125,13 @@ class TimeCode(Widget):
 
     def render_time(self, elapsed):
         if elapsed is None:
-            fields = [
-                self.content_profile.fmt('--')
-                for i in range(3)
-            ]
+            fields = [self.content_profile.fmt("--") for i in range(3)]
         else:
             hours, remainder = divmod(int(elapsed.total_seconds()), 60 * 60)
             minutes, seconds = divmod(remainder, 60)
-            fields = [
-                self.content_profile.fmt("{0:02d}".format(field))
-                for field in [hours, minutes, seconds]
-            ]
+            fields = [self.content_profile.fmt("{0:02d}".format(field)) for field in [hours, minutes, seconds]]
 
-        text = self.format_profile.fmt(':').join(fields)
+        text = self.format_profile.fmt(":").join(fields)
 
         if self._microseconds:
             if elapsed is not None:
@@ -169,41 +158,43 @@ class TypeName(Widget):
     }
 
     def render(self, message):
-        return self.content_profile.fmt("{: <7}"
-                                        .format(message.message_type.upper()),
-                                        bold=True, dim=True,
-                                        fg=self._action_colors[message.message_type])
+        return self.content_profile.fmt(
+            "{: <7}".format(message.message_type.upper()),
+            bold=True,
+            dim=True,
+            fg=self._action_colors[message.message_type],
+        )
 
 
 # A widget for displaying the Element name
 class ElementName(Widget):
-
     def render(self, message):
         action_name = message.action_name
         element_name = message.element_name
         if element_name is not None:
-            name = '{: <30}'.format(element_name)
+            name = "{: <30}".format(element_name)
         else:
-            name = 'core activity'
-            name = '{: <30}'.format(name)
+            name = "core activity"
+            name = "{: <30}".format(name)
 
         if not action_name:
             action_name = "Main"
 
-        return self.content_profile.fmt("{: >8}".format(action_name.lower())) + \
-            self.format_profile.fmt(':') + self.content_profile.fmt(name)
+        return (
+            self.content_profile.fmt("{: >8}".format(action_name.lower()))
+            + self.format_profile.fmt(":")
+            + self.content_profile.fmt(name)
+        )
 
 
 # A widget for displaying the primary message text
 class MessageText(Widget):
-
     def render(self, message):
         return message.message
 
 
 # A widget for formatting the element cache key
 class CacheKey(Widget):
-
     def __init__(self, context, content_profile, format_profile, err_profile):
         super().__init__(context, content_profile, format_profile)
 
@@ -216,10 +207,10 @@ class CacheKey(Widget):
             return ""
 
         if message.element_name is None:
-            return ' ' * self._key_length
+            return " " * self._key_length
 
         missing = False
-        key = ' ' * self._key_length
+        key = " " * self._key_length
         if message.element_key:
             _, key, missing = message.element_key
 
@@ -233,7 +224,6 @@ class CacheKey(Widget):
 
 # A widget for formatting the log file
 class LogFile(Widget):
-
     def __init__(self, context, content_profile, format_profile, err_profile):
         super().__init__(context, content_profile, format_profile)
 
@@ -248,7 +238,7 @@ class LogFile(Widget):
             logfile = message.logfile
 
             if abbrev and self._logdir != "" and logfile.startswith(self._logdir):
-                logfile = logfile[len(self._logdir):]
+                logfile = logfile[len(self._logdir) :]
                 logfile = logfile.lstrip(os.sep)
 
             if message.message_type in ERROR_MESSAGES:
@@ -256,7 +246,7 @@ class LogFile(Widget):
             else:
                 text = self.content_profile.fmt(logfile, dim=True)
         else:
-            text = ''
+            text = ""
 
         return text
 
@@ -273,8 +263,7 @@ class MessageOrLogFile(Widget):
 
     def render(self, message):
         # Show the log file only in the main start/success messages
-        if message.logfile and message.scheduler and \
-                message.message_type in [MessageType.START, MessageType.SUCCESS]:
+        if message.logfile and message.scheduler and message.message_type in [MessageType.START, MessageType.SUCCESS]:
             text = self._logfile_widget.render(message)
         else:
             text = self._message_widget.render(message)
@@ -296,14 +285,9 @@ class MessageOrLogFile(Widget):
 #    indent (int): Number of spaces to use for general indentation
 #
 class LogLine(Widget):
-
-    def __init__(self, context, state,
-                 content_profile,
-                 format_profile,
-                 success_profile,
-                 err_profile,
-                 detail_profile,
-                 indent=4):
+    def __init__(
+        self, context, state, content_profile, format_profile, success_profile, err_profile, detail_profile, indent=4
+    ):
         super().__init__(context, content_profile, format_profile)
 
         self._columns = []
@@ -311,7 +295,7 @@ class LogLine(Widget):
         self._success_profile = success_profile
         self._err_profile = err_profile
         self._detail_profile = detail_profile
-        self._indent = ' ' * indent
+        self._indent = " " * indent
         self._log_lines = context.log_error_lines
         self._message_lines = context.log_message_lines
         self._resolved_keys = None
@@ -320,19 +304,17 @@ class LogLine(Widget):
         self._logfile_widget = LogFile(context, content_profile, format_profile, err_profile)
 
         if context.log_debug:
-            self._columns.extend([
-                Debug(context, content_profile, format_profile)
-            ])
+            self._columns.extend([Debug(context, content_profile, format_profile)])
 
         self.logfile_variable_names = {
             "elapsed": TimeCode(context, content_profile, format_profile, microseconds=False),
             "elapsed-us": TimeCode(context, content_profile, format_profile, microseconds=True),
             "wallclock": WallclockTime(context, content_profile, format_profile),
-            "wallclock-us": WallclockTime(context, content_profile, format_profile, output_format='us'),
+            "wallclock-us": WallclockTime(context, content_profile, format_profile, output_format="us"),
             "key": CacheKey(context, content_profile, format_profile, err_profile),
             "element": ElementName(context, content_profile, format_profile),
             "action": TypeName(context, content_profile, format_profile),
-            "message": MessageOrLogFile(context, content_profile, format_profile, err_profile)
+            "message": MessageOrLogFile(context, content_profile, format_profile, err_profile),
         }
         logfile_tokens = self._parse_logfile_format(context.log_message_format, content_profile, format_profile)
         self._columns.extend(logfile_tokens)
@@ -352,7 +334,7 @@ class LogLine(Widget):
     #    (str): The formatted list of elements
     #
     def show_pipeline(self, dependencies, format_):
-        report = ''
+        report = ""
         p = Profile()
 
         for element in dependencies:
@@ -360,57 +342,57 @@ class LogLine(Widget):
 
             full_key, cache_key, dim_keys = element._get_display_key()
 
-            line = p.fmt_subst(line, 'name', element._get_full_name(), fg='blue', bold=True)
-            line = p.fmt_subst(line, 'key', cache_key, fg='yellow', dim=dim_keys)
-            line = p.fmt_subst(line, 'full-key', full_key, fg='yellow', dim=dim_keys)
+            line = p.fmt_subst(line, "name", element._get_full_name(), fg="blue", bold=True)
+            line = p.fmt_subst(line, "key", cache_key, fg="yellow", dim=dim_keys)
+            line = p.fmt_subst(line, "full-key", full_key, fg="yellow", dim=dim_keys)
 
             consistency = element._get_consistency()
             if consistency == Consistency.INCONSISTENT:
-                line = p.fmt_subst(line, 'state', "no reference", fg='red')
+                line = p.fmt_subst(line, "state", "no reference", fg="red")
             else:
                 if element._cached_failure():
-                    line = p.fmt_subst(line, 'state', "failed", fg='red')
+                    line = p.fmt_subst(line, "state", "failed", fg="red")
                 elif element._cached_success():
-                    line = p.fmt_subst(line, 'state', "cached", fg='magenta')
+                    line = p.fmt_subst(line, "state", "cached", fg="magenta")
                 elif consistency == Consistency.RESOLVED and not element._source_cached():
-                    line = p.fmt_subst(line, 'state', "fetch needed", fg='red')
+                    line = p.fmt_subst(line, "state", "fetch needed", fg="red")
                 elif element._buildable():
-                    line = p.fmt_subst(line, 'state', "buildable", fg='green')
+                    line = p.fmt_subst(line, "state", "buildable", fg="green")
                 else:
-                    line = p.fmt_subst(line, 'state', "waiting", fg='blue')
+                    line = p.fmt_subst(line, "state", "waiting", fg="blue")
 
             # Element configuration
             if "%{config" in format_:
                 line = p.fmt_subst(
-                    line, 'config',
-                    yaml.round_trip_dump(element._Element__config, default_flow_style=False, allow_unicode=True))
+                    line,
+                    "config",
+                    yaml.round_trip_dump(element._Element__config, default_flow_style=False, allow_unicode=True),
+                )
 
             # Variables
             if "%{vars" in format_:
                 variables = element._Element__variables.flat
                 line = p.fmt_subst(
-                    line, 'vars',
-                    yaml.round_trip_dump(variables, default_flow_style=False, allow_unicode=True))
+                    line, "vars", yaml.round_trip_dump(variables, default_flow_style=False, allow_unicode=True)
+                )
 
             # Environment
             if "%{env" in format_:
                 environment = element._Element__environment
                 line = p.fmt_subst(
-                    line, 'env',
-                    yaml.round_trip_dump(environment, default_flow_style=False, allow_unicode=True))
+                    line, "env", yaml.round_trip_dump(environment, default_flow_style=False, allow_unicode=True)
+                )
 
             # Public
             if "%{public" in format_:
                 environment = element._Element__public
                 line = p.fmt_subst(
-                    line, 'public',
-                    yaml.round_trip_dump(environment, default_flow_style=False, allow_unicode=True))
+                    line, "public", yaml.round_trip_dump(environment, default_flow_style=False, allow_unicode=True)
+                )
 
             # Workspaced
             if "%{workspaced" in format_:
-                line = p.fmt_subst(
-                    line, 'workspaced',
-                    '(workspaced)' if element._get_workspace() else '', fg='yellow')
+                line = p.fmt_subst(line, "workspaced", "(workspaced)" if element._get_workspace() else "", fg="yellow")
 
             # Workspace-dirs
             if "%{workspace-dirs" in format_:
@@ -418,36 +400,31 @@ class LogLine(Widget):
                 if workspace is not None:
                     path = workspace.get_absolute_path()
                     if path.startswith("~/"):
-                        path = os.path.join(os.getenv('HOME', '/root'), path[2:])
-                    line = p.fmt_subst(line, 'workspace-dirs', "Workspace: {}".format(path))
+                        path = os.path.join(os.getenv("HOME", "/root"), path[2:])
+                    line = p.fmt_subst(line, "workspace-dirs", "Workspace: {}".format(path))
                 else:
-                    line = p.fmt_subst(
-                        line, 'workspace-dirs', '')
+                    line = p.fmt_subst(line, "workspace-dirs", "")
 
             # Dependencies
             if "%{deps" in format_:
                 deps = [e.name for e in element.dependencies(Scope.ALL, recurse=False)]
-                line = p.fmt_subst(
-                    line, 'deps',
-                    yaml.safe_dump(deps, default_style=None).rstrip('\n'))
+                line = p.fmt_subst(line, "deps", yaml.safe_dump(deps, default_style=None).rstrip("\n"))
 
             # Build Dependencies
             if "%{build-deps" in format_:
                 build_deps = [e.name for e in element.dependencies(Scope.BUILD, recurse=False)]
-                line = p.fmt_subst(
-                    line, 'build-deps',
-                    yaml.safe_dump(build_deps, default_style=False).rstrip('\n'))
+                line = p.fmt_subst(line, "build-deps", yaml.safe_dump(build_deps, default_style=False).rstrip("\n"))
 
             # Runtime Dependencies
             if "%{runtime-deps" in format_:
                 runtime_deps = [e.name for e in element.dependencies(Scope.RUN, recurse=False)]
                 line = p.fmt_subst(
-                    line, 'runtime-deps',
-                    yaml.safe_dump(runtime_deps, default_style=False).rstrip('\n'))
+                    line, "runtime-deps", yaml.safe_dump(runtime_deps, default_style=False).rstrip("\n")
+                )
 
-            report += line + '\n'
+            report += line + "\n"
 
-        return report.rstrip('\n')
+        return report.rstrip("\n")
 
     # print_heading()
     #
@@ -463,25 +440,24 @@ class LogLine(Widget):
     def print_heading(self, project, stream, *, log_file):
         context = self.context
         starttime = datetime.datetime.now()
-        text = ''
+        text = ""
 
         self._resolved_keys = {element: element._get_cache_key() for element in stream.session_elements}
 
         # Main invocation context
-        text += '\n'
+        text += "\n"
         text += self.content_profile.fmt("BuildStream Version {}\n".format(bst_version), bold=True)
         values = OrderedDict()
-        values["Session Start"] = starttime.strftime('%A, %d-%m-%Y at %H:%M:%S')
+        values["Session Start"] = starttime.strftime("%A, %d-%m-%Y at %H:%M:%S")
         values["Project"] = "{} ({})".format(project.name, project.directory)
         values["Targets"] = ", ".join([t.name for t in stream.targets])
         text += self._format_values(values)
 
         # User configurations
-        text += '\n'
+        text += "\n"
         text += self.content_profile.fmt("User Configuration\n", bold=True)
         values = OrderedDict()
-        values["Configuration File"] = \
-            "Default Configuration" if not context.config_origin else context.config_origin
+        values["Configuration File"] = "Default Configuration" if not context.config_origin else context.config_origin
         values["Cache Directory"] = context.cachedir
         values["Log Files"] = context.logdir
         values["Source Mirrors"] = context.sourcedir
@@ -492,7 +468,7 @@ class LogLine(Widget):
         values["Maximum Push Tasks"] = context.sched_pushers
         values["Maximum Network Retries"] = context.sched_network_retries
         text += self._format_values(values)
-        text += '\n'
+        text += "\n"
 
         # Project Options
         values = OrderedDict()
@@ -500,22 +476,25 @@ class LogLine(Widget):
         if values:
             text += self.content_profile.fmt("Project Options\n", bold=True)
             text += self._format_values(values)
-            text += '\n'
+            text += "\n"
 
         # Plugins
-        text += self._format_plugins(project.first_pass_config.element_factory.loaded_dependencies,
-                                     project.first_pass_config.source_factory.loaded_dependencies)
+        text += self._format_plugins(
+            project.first_pass_config.element_factory.loaded_dependencies,
+            project.first_pass_config.source_factory.loaded_dependencies,
+        )
         if project.config.element_factory and project.config.source_factory:
-            text += self._format_plugins(project.config.element_factory.loaded_dependencies,
-                                         project.config.source_factory.loaded_dependencies)
+            text += self._format_plugins(
+                project.config.element_factory.loaded_dependencies, project.config.source_factory.loaded_dependencies
+            )
 
         # Pipeline state
         text += self.content_profile.fmt("Pipeline\n", bold=True)
         text += self.show_pipeline(stream.total_elements, context.log_element_format)
-        text += '\n'
+        text += "\n"
 
         # Separator line before following output
-        text += self.format_profile.fmt("=" * 79 + '\n')
+        text += self.format_profile.fmt("=" * 79 + "\n")
 
         click.echo(text, nl=False, err=True)
         if log_file:
@@ -537,7 +516,7 @@ class LogLine(Widget):
         if not self._state.task_groups:
             return
 
-        text = ''
+        text = ""
 
         assert self._resolved_keys is not None
         elements = sorted(e for (e, k) in self._resolved_keys.items() if k != e._get_cache_key())
@@ -554,7 +533,7 @@ class LogLine(Widget):
                     # Exclude the failure messages if the job didn't ultimately fail
                     # (e.g. succeeded on retry)
                     if element_name in group.failed_tasks:
-                        values[element_name] = ''.join(self._render(v) for v in messages)
+                        values[element_name] = "".join(self._render(v) for v in messages)
 
             if values:
                 text += self.content_profile.fmt("Failure Summary\n", bold=True)
@@ -563,8 +542,8 @@ class LogLine(Widget):
         text += self.content_profile.fmt("Pipeline Summary\n", bold=True)
         values = OrderedDict()
 
-        values['Total'] = self.content_profile.fmt(str(len(stream.total_elements)))
-        values['Session'] = self.content_profile.fmt(str(len(stream.session_elements)))
+        values["Total"] = self.content_profile.fmt(str(len(stream.total_elements)))
+        values["Session"] = self.content_profile.fmt(str(len(stream.session_elements)))
 
         processed_maxlen = 1
         skipped_maxlen = 1
@@ -579,20 +558,25 @@ class LogLine(Widget):
             skipped = str(group.skipped_tasks)
             failed = str(len(group.failed_tasks))
 
-            processed_align = ' ' * (processed_maxlen - len(processed))
-            skipped_align = ' ' * (skipped_maxlen - len(skipped))
-            failed_align = ' ' * (failed_maxlen - len(failed))
-
-            status_text = self.content_profile.fmt("processed ") + \
-                self._success_profile.fmt(processed) + \
-                self.format_profile.fmt(', ') + processed_align
-
-            status_text += self.content_profile.fmt("skipped ") + \
-                self.content_profile.fmt(skipped) + \
-                self.format_profile.fmt(', ') + skipped_align
-
-            status_text += self.content_profile.fmt("failed ") + \
-                self._err_profile.fmt(failed) + ' ' + failed_align
+            processed_align = " " * (processed_maxlen - len(processed))
+            skipped_align = " " * (skipped_maxlen - len(skipped))
+            failed_align = " " * (failed_maxlen - len(failed))
+
+            status_text = (
+                self.content_profile.fmt("processed ")
+                + self._success_profile.fmt(processed)
+                + self.format_profile.fmt(", ")
+                + processed_align
+            )
+
+            status_text += (
+                self.content_profile.fmt("skipped ")
+                + self.content_profile.fmt(skipped)
+                + self.format_profile.fmt(", ")
+                + skipped_align
+            )
+
+            status_text += self.content_profile.fmt("failed ") + self._err_profile.fmt(failed) + " " + failed_align
             values["{} Queue".format(group.name)] = status_text
 
         text += self._format_values(values, style_value=False)
@@ -627,7 +611,7 @@ class LogLine(Widget):
             m = re.search(r"^%\{([^\}]+)\}", format_string)
             if m is not None:
                 variable = m.group(1)
-                format_string = format_string[m.end(0):]
+                format_string = format_string[m.end(0) :]
                 if variable not in self.logfile_variable_names:
                     raise Exception("'{0}' is not a valid log variable name.".format(variable))
                 logfile_tokens.append(self.logfile_variable_names[variable])
@@ -635,7 +619,7 @@ class LogLine(Widget):
                 m = re.search("^[^%]+", format_string)
                 if m is not None:
                     text = FixedText(self.context, m.group(0), content_profile, format_profile)
-                    format_string = format_string[m.end(0):]
+                    format_string = format_string[m.end(0) :]
                     logfile_tokens.append(text)
                 else:
                     # No idea what to do now
@@ -645,11 +629,11 @@ class LogLine(Widget):
     def _render(self, message):
 
         # Render the column widgets first
-        text = ''
+        text = ""
         for widget in self._columns:
             text += widget.render(message)
 
-        text += '\n'
+        text += "\n"
 
         extra_nl = False
 
@@ -664,51 +648,53 @@ class LogLine(Widget):
 
             n_lines = len(lines)
             abbrev = False
-            if message.message_type not in ERROR_MESSAGES \
-               and not frontend_message and n_lines > self._message_lines:
-                lines = lines[0:self._message_lines]
+            if message.message_type not in ERROR_MESSAGES and not frontend_message and n_lines > self._message_lines:
+                lines = lines[0 : self._message_lines]
                 if self._message_lines > 0:
                     abbrev = True
             else:
-                lines[n_lines - 1] = lines[n_lines - 1].rstrip('\n')
+                lines[n_lines - 1] = lines[n_lines - 1].rstrip("\n")
 
             detail = self._indent + self._indent.join(lines)
 
-            text += '\n'
+            text += "\n"
             if message.message_type in ERROR_MESSAGES:
                 text += self._err_profile.fmt(detail, bold=True)
             else:
                 text += self._detail_profile.fmt(detail)
 
             if abbrev:
-                text += self._indent + \
-                    self.content_profile.fmt('Message contains {} additional lines'
-                                             .format(n_lines - self._message_lines), dim=True)
-            text += '\n'
+                text += self._indent + self.content_profile.fmt(
+                    "Message contains {} additional lines".format(n_lines - self._message_lines), dim=True
+                )
+            text += "\n"
 
             extra_nl = True
 
         if message.scheduler and message.message_type == MessageType.FAIL:
-            text += '\n'
+            text += "\n"
 
             if self.context is not None and not self.context.log_verbose:
                 text += self._indent + self._err_profile.fmt("Log file: ")
-                text += self._indent + self._logfile_widget.render(message) + '\n'
+                text += self._indent + self._logfile_widget.render(message) + "\n"
             elif self._log_lines > 0:
-                text += self._indent + self._err_profile.fmt("Printing the last {} lines from log file:"
-                                                             .format(self._log_lines)) + '\n'
-                text += self._indent + self._logfile_widget.render_abbrev(message, abbrev=False) + '\n'
-                text += self._indent + self._err_profile.fmt("=" * 70) + '\n'
+                text += (
+                    self._indent
+                    + self._err_profile.fmt("Printing the last {} lines from log file:".format(self._log_lines))
+                    + "\n"
+                )
+                text += self._indent + self._logfile_widget.render_abbrev(message, abbrev=False) + "\n"
+                text += self._indent + self._err_profile.fmt("=" * 70) + "\n"
 
                 log_content = self._read_last_lines(message.logfile)
                 log_content = textwrap.indent(log_content, self._indent)
                 text += self._detail_profile.fmt(log_content)
-                text += '\n'
-                text += self._indent + self._err_profile.fmt("=" * 70) + '\n'
+                text += "\n"
+                text += self._indent + self._err_profile.fmt("=" * 70) + "\n"
             extra_nl = True
 
         if extra_nl:
-            text += '\n'
+            text += "\n"
 
         return text
 
@@ -716,14 +702,14 @@ class LogLine(Widget):
         with ExitStack() as stack:
             # mmap handles low-level memory details, allowing for
             # faster searches
-            f = stack.enter_context(open(logfile, 'r+'))
+            f = stack.enter_context(open(logfile, "r+"))
             log = stack.enter_context(mmap(f.fileno(), os.path.getsize(f.name)))
 
             count = 0
             end = log.size() - 1
 
             while count < self._log_lines and end >= 0:
-                location = log.rfind(b'\n', 0, end)
+                location = log.rfind(b"\n", 0, end)
                 count += 1
 
                 # If location is -1 (none found), this will print the
@@ -735,8 +721,8 @@ class LogLine(Widget):
             # then we get the first characther. If end is a newline position,
             # we discard it and only want to print the beginning of the next
             # line.
-            lines = log[(end + 1):].splitlines()
-            return '\n'.join([line.decode('utf-8') for line in lines]).rstrip()
+            lines = log[(end + 1) :].splitlines()
+            return "\n".join([line.decode("utf-8") for line in lines]).rstrip()
 
     def _format_plugins(self, element_plugins, source_plugins):
         text = ""
@@ -756,7 +742,7 @@ class LogLine(Widget):
             for plugin in source_plugins:
                 text += self.content_profile.fmt("    - {}\n".format(plugin))
 
-        text += '\n'
+        text += "\n"
 
         return text
 
@@ -773,23 +759,23 @@ class LogLine(Widget):
     #    (str): The formatted values
     #
     def _format_values(self, values, style_value=True):
-        text = ''
+        text = ""
         max_key_len = 0
         for key, value in values.items():
             max_key_len = max(len(key), max_key_len)
 
         for key, value in values.items():
-            if isinstance(value, str) and '\n' in value:
+            if isinstance(value, str) and "\n" in value:
                 text += self.format_profile.fmt("  {}:\n".format(key))
                 text += textwrap.indent(value, self._indent)
                 continue
 
-            text += self.format_profile.fmt("  {}: {}".format(key, ' ' * (max_key_len - len(key))))
+            text += self.format_profile.fmt("  {}: {}".format(key, " " * (max_key_len - len(key))))
             if style_value:
                 text += self.content_profile.fmt(str(value))
             else:
                 text += str(value)
-            text += '\n'
+            text += "\n"
 
         return text
 
@@ -806,20 +792,20 @@ class LogLine(Widget):
     #    (str): The formatted values
     #
     def _pretty_print_dictionary(self, values, long_=False, style_value=True):
-        text = ''
+        text = ""
         max_key_len = 0
         try:
             max_key_len = max(len(key) for key in values.keys())
         except ValueError:
-            text = ''
+            text = ""
 
         for key, value in values.items():
-            if isinstance(value, str) and '\n' in value:
+            if isinstance(value, str) and "\n" in value:
                 text += self.format_profile.fmt("  {}:".format(key))
                 text += textwrap.indent(value, self._indent)
                 continue
 
-            text += self.format_profile.fmt("  {}:{}".format(key, ' ' * (max_key_len - len(key))))
+            text += self.format_profile.fmt("  {}:{}".format(key, " " * (max_key_len - len(key))))
 
             value_list = "\n\t" + "\n\t".join((self._get_filestats(v, list_long=long_) for v in value))
             if value == []:
@@ -832,7 +818,7 @@ class LogLine(Widget):
                 text += self.content_profile.fmt(value_list)
             else:
                 text += value_list
-            text += '\n'
+            text += "\n"
 
         return text
 
@@ -854,22 +840,22 @@ class LogLine(Widget):
     #                              cached status of
     #
     def show_state_of_artifacts(self, targets):
-        report = ''
+        report = ""
         p = Profile()
         for element in targets:
-            line = '%{state: >12} %{name}'
-            line = p.fmt_subst(line, 'name', element.name, fg='yellow')
+            line = "%{state: >12} %{name}"
+            line = p.fmt_subst(line, "name", element.name, fg="yellow")
 
             if element._cached_success():
-                line = p.fmt_subst(line, 'state', "cached", fg='magenta')
+                line = p.fmt_subst(line, "state", "cached", fg="magenta")
             elif element._cached():
-                line = p.fmt_subst(line, 'state', "failed", fg='red')
+                line = p.fmt_subst(line, "state", "failed", fg="red")
             elif element._cached_remotely():
-                line = p.fmt_subst(line, 'state', "available", fg='green')
+                line = p.fmt_subst(line, "state", "available", fg="green")
             else:
-                line = p.fmt_subst(line, 'state', "not cached", fg='bright_red')
+                line = p.fmt_subst(line, "state", "not cached", fg="bright_red")
 
-            report += line + '\n'
+            report += line + "\n"
 
         return report
 
@@ -890,15 +876,27 @@ class LogLine(Widget):
             # Support files up to 99G, meaning maximum characters is 11
             max_v_len = 11
             if entry["type"] == _FileType.DIRECTORY:
-                return "drwxr-xr-x  dir    {}".format(entry["size"]) +\
-                       "{} ".format(' ' * (max_v_len - len(size))) + "{}".format(entry["name"])
+                return (
+                    "drwxr-xr-x  dir    {}".format(entry["size"])
+                    + "{} ".format(" " * (max_v_len - len(size)))
+                    + "{}".format(entry["name"])
+                )
             elif entry["type"] == _FileType.SYMLINK:
-                return "lrwxrwxrwx  link   {}".format(entry["size"]) +\
-                       "{} ".format(' ' * (max_v_len - len(size))) + "{} -> {}".format(entry["name"], entry["target"])
+                return (
+                    "lrwxrwxrwx  link   {}".format(entry["size"])
+                    + "{} ".format(" " * (max_v_len - len(size)))
+                    + "{} -> {}".format(entry["name"], entry["target"])
+                )
             elif entry["executable"]:
-                return "-rwxr-xr-x  exe    {}".format(entry["size"]) +\
-                       "{} ".format(' ' * (max_v_len - len(size))) + "{}".format(entry["name"])
+                return (
+                    "-rwxr-xr-x  exe    {}".format(entry["size"])
+                    + "{} ".format(" " * (max_v_len - len(size)))
+                    + "{}".format(entry["name"])
+                )
             else:
-                return "-rw-r--r--  reg    {}".format(entry["size"]) +\
-                       "{} ".format(' ' * (max_v_len - len(size))) + "{}".format(entry["name"])
+                return (
+                    "-rw-r--r--  reg    {}".format(entry["size"])
+                    + "{} ".format(" " * (max_v_len - len(size)))
+                    + "{}".format(entry["name"])
+                )
         return entry["name"]