Adopt Black and isort (SC-700) (#1157)

Applied Black and isort, fixed any linting issues, updated tox.ini
and CI.

7 files changed, 355 insertions, 229 deletions

diff --git a/cloudinit/cmd/devel/__init__.py b/cloudinit/cmd/devel/__init__.py
index 3ae28b69..ead5f7a9 100644
--- a/cloudinit/cmd/devel/__init__.py
+++ b/cloudinit/cmd/devel/__init__.py
@@ -11,7 +11,7 @@ from cloudinit.stages import Init
 
 def addLogHandlerCLI(logger, log_level):
     """Add a commandline logging handler to emit messages to stderr."""
-    formatter = logging.Formatter('%(levelname)s: %(message)s')
+    formatter = logging.Formatter("%(levelname)s: %(message)s")
     log.setupBasicLogging(log_level, formatter=formatter)
     return logger
 
@@ -22,4 +22,5 @@ def read_cfg_paths():
     init.read_cfg()
     return init.paths
 
+
 # vi: ts=4 expandtab
diff --git a/cloudinit/cmd/devel/hotplug_hook.py b/cloudinit/cmd/devel/hotplug_hook.py
index f6f36a00..a9be0379 100644
--- a/cloudinit/cmd/devel/hotplug_hook.py
+++ b/cloudinit/cmd/devel/hotplug_hook.py
@@ -6,20 +6,17 @@ import os
 import sys
 import time
 
-from cloudinit import log
-from cloudinit import reporting
-from cloudinit import stages
+from cloudinit import log, reporting, stages
 from cloudinit.event import EventScope, EventType
 from cloudinit.net import activators, read_sys_net_safe
 from cloudinit.net.network_state import parse_net_config_data
 from cloudinit.reporting import events
-from cloudinit.stages import Init
 from cloudinit.sources import DataSource  # noqa: F401
 from cloudinit.sources import DataSourceNotFoundException
-
+from cloudinit.stages import Init
 
 LOG = log.getLogger(__name__)
-NAME = 'hotplug-hook'
+NAME = "hotplug-hook"
 
 
 def get_parser(parser=None):
@@ -35,33 +32,38 @@ def get_parser(parser=None):
 
     parser.description = __doc__
     parser.add_argument(
-        "-s", "--subsystem", required=True,
+        "-s",
+        "--subsystem",
+        required=True,
         help="subsystem to act on",
-        choices=['net']
+        choices=["net"],
     )
 
     subparsers = parser.add_subparsers(
-        title='Hotplug Action',
-        dest='hotplug_action'
+        title="Hotplug Action", dest="hotplug_action"
     )
     subparsers.required = True
 
     subparsers.add_parser(
-        'query',
-        help='query if hotplug is enabled for given subsystem'
+        "query", help="query if hotplug is enabled for given subsystem"
     )
 
     parser_handle = subparsers.add_parser(
-        'handle', help='handle the hotplug event')
+        "handle", help="handle the hotplug event"
+    )
     parser_handle.add_argument(
-        "-d", "--devpath", required=True,
+        "-d",
+        "--devpath",
+        required=True,
         metavar="PATH",
-        help="sysfs path to hotplugged device"
+        help="sysfs path to hotplugged device",
     )
     parser_handle.add_argument(
-        "-u", "--udevaction", required=True,
+        "-u",
+        "--udevaction",
+        required=True,
         help="action to take",
-        choices=['add', 'remove']
+        choices=["add", "remove"],
     )
 
     return parser
@@ -90,27 +92,29 @@ class UeventHandler(abc.ABC):
 
     def detect_hotplugged_device(self):
         detect_presence = None
-        if self.action == 'add':
+        if self.action == "add":
             detect_presence = True
-        elif self.action == 'remove':
+        elif self.action == "remove":
             detect_presence = False
         else:
-            raise ValueError('Unknown action: %s' % self.action)
+            raise ValueError("Unknown action: %s" % self.action)
 
         if detect_presence != self.device_detected():
             raise RuntimeError(
-                'Failed to detect %s in updated metadata' % self.id)
+                "Failed to detect %s in updated metadata" % self.id
+            )
 
     def success(self):
         return self.success_fn()
 
     def update_metadata(self):
-        result = self.datasource.update_metadata_if_supported([
-            EventType.HOTPLUG])
+        result = self.datasource.update_metadata_if_supported(
+            [EventType.HOTPLUG]
+        )
         if not result:
             raise RuntimeError(
-                'Datasource %s not updated for '
-                'event %s' % (self.datasource, EventType.HOTPLUG)
+                "Datasource %s not updated for event %s"
+                % (self.datasource, EventType.HOTPLUG)
             )
         return result
 
@@ -118,7 +122,7 @@ class UeventHandler(abc.ABC):
 class NetHandler(UeventHandler):
     def __init__(self, datasource, devpath, action, success_fn):
         # convert devpath to mac address
-        id = read_sys_net_safe(os.path.basename(devpath), 'address')
+        id = read_sys_net_safe(os.path.basename(devpath), "address")
         super().__init__(id, datasource, devpath, action, success_fn)
 
     def apply(self):
@@ -128,14 +132,16 @@ class NetHandler(UeventHandler):
         )
         interface_name = os.path.basename(self.devpath)
         activator = activators.select_activator()
-        if self.action == 'add':
+        if self.action == "add":
             if not activator.bring_up_interface(interface_name):
                 raise RuntimeError(
-                    'Failed to bring up device: {}'.format(self.devpath))
-        elif self.action == 'remove':
+                    "Failed to bring up device: {}".format(self.devpath)
+                )
+        elif self.action == "remove":
             if not activator.bring_down_interface(interface_name):
                 raise RuntimeError(
-                    'Failed to bring down device: {}'.format(self.devpath))
+                    "Failed to bring down device: {}".format(self.devpath)
+                )
 
     @property
     def config(self):
@@ -144,15 +150,16 @@ class NetHandler(UeventHandler):
     def device_detected(self) -> bool:
         netstate = parse_net_config_data(self.config)
         found = [
-            iface for iface in netstate.iter_interfaces()
-            if iface.get('mac_address') == self.id
+            iface
+            for iface in netstate.iter_interfaces()
+            if iface.get("mac_address") == self.id
         ]
-        LOG.debug('Ifaces with ID=%s : %s', self.id, found)
+        LOG.debug("Ifaces with ID=%s : %s", self.id, found)
         return len(found) > 0
 
 
 SUBSYSTEM_PROPERTES_MAP = {
-    'net': (NetHandler, EventScope.NETWORK),
+    "net": (NetHandler, EventScope.NETWORK),
 }
 
 
@@ -161,66 +168,65 @@ def is_enabled(hotplug_init, subsystem):
         scope = SUBSYSTEM_PROPERTES_MAP[subsystem][1]
     except KeyError as e:
         raise Exception(
-            'hotplug-hook: cannot handle events for subsystem: {}'.format(
-                subsystem)
+            "hotplug-hook: cannot handle events for subsystem: {}".format(
+                subsystem
+            )
         ) from e
 
     return stages.update_event_enabled(
         datasource=hotplug_init.datasource,
         cfg=hotplug_init.cfg,
         event_source_type=EventType.HOTPLUG,
-        scope=scope
+        scope=scope,
     )
 
 
 def initialize_datasource(hotplug_init, subsystem):
-    LOG.debug('Fetching datasource')
+    LOG.debug("Fetching datasource")
     datasource = hotplug_init.fetch(existing="trust")
 
     if not datasource.get_supported_events([EventType.HOTPLUG]):
-        LOG.debug('hotplug not supported for event of type %s', subsystem)
+        LOG.debug("hotplug not supported for event of type %s", subsystem)
         return
 
     if not is_enabled(hotplug_init, subsystem):
-        LOG.debug('hotplug not enabled for event of type %s', subsystem)
+        LOG.debug("hotplug not enabled for event of type %s", subsystem)
         return
     return datasource
 
 
-def handle_hotplug(
-    hotplug_init: Init, devpath, subsystem, udevaction
-):
+def handle_hotplug(hotplug_init: Init, devpath, subsystem, udevaction):
     datasource = initialize_datasource(hotplug_init, subsystem)
     if not datasource:
         return
     handler_cls = SUBSYSTEM_PROPERTES_MAP[subsystem][0]
-    LOG.debug('Creating %s event handler', subsystem)
+    LOG.debug("Creating %s event handler", subsystem)
     event_handler = handler_cls(
         datasource=datasource,
         devpath=devpath,
         action=udevaction,
-        success_fn=hotplug_init._write_to_cache
+        success_fn=hotplug_init._write_to_cache,
     )  # type: UeventHandler
     wait_times = [1, 3, 5, 10, 30]
     for attempt, wait in enumerate(wait_times):
         LOG.debug(
-            'subsystem=%s update attempt %s/%s',
+            "subsystem=%s update attempt %s/%s",
             subsystem,
             attempt,
-            len(wait_times)
+            len(wait_times),
         )
         try:
-            LOG.debug('Refreshing metadata')
+            LOG.debug("Refreshing metadata")
             event_handler.update_metadata()
-            LOG.debug('Detecting device in updated metadata')
+            LOG.debug("Detecting device in updated metadata")
             event_handler.detect_hotplugged_device()
-            LOG.debug('Applying config change')
+            LOG.debug("Applying config change")
             event_handler.apply()
-            LOG.debug('Updating cache')
+            LOG.debug("Updating cache")
             event_handler.success()
             break
         except Exception as e:
-            LOG.debug('Exception while processing hotplug event. %s', e)
+            LOG.debug("Exception while processing hotplug event. %s", e)
             time.sleep(wait)
             last_exception = e
     else:
@@ -238,31 +244,33 @@ def handle_args(name, args):
     hotplug_init.read_cfg()
 
     log.setupLogging(hotplug_init.cfg)
-    if 'reporting' in hotplug_init.cfg:
-        reporting.update_configuration(hotplug_init.cfg.get('reporting'))
+    if "reporting" in hotplug_init.cfg:
+        reporting.update_configuration(hotplug_init.cfg.get("reporting"))
     # Logging isn't going to be setup until now
     LOG.debug(
-        '%s called with the following arguments: {'
-        'hotplug_action: %s, subsystem: %s, udevaction: %s, devpath: %s}',
+        "%s called with the following arguments: {"
+        "hotplug_action: %s, subsystem: %s, udevaction: %s, devpath: %s}",
         name,
         args.hotplug_action,
         args.subsystem,
-        args.udevaction if 'udevaction' in args else None,
-        args.devpath if 'devpath' in args else None,
+        args.udevaction if "udevaction" in args else None,
+        args.devpath if "devpath" in args else None,
     )
 
     with hotplug_reporter:
         try:
-            if args.hotplug_action == 'query':
+            if args.hotplug_action == "query":
                 try:
                     datasource = initialize_datasource(
-                        hotplug_init, args.subsystem)
+                        hotplug_init, args.subsystem
+                    )
                 except DataSourceNotFoundException:
                     print(
                         "Unable to determine hotplug state. No datasource "
-                        "detected")
+                        "detected"
+                    )
                     sys.exit(1)
-                print('enabled' if datasource else 'disabled')
+                print("enabled" if datasource else "disabled")
             else:
                 handle_hotplug(
                     hotplug_init=hotplug_init,
@@ -271,13 +279,13 @@ def handle_args(name, args):
                     udevaction=args.udevaction,
                 )
         except Exception:
-            LOG.exception('Received fatal exception handling hotplug!')
+            LOG.exception("Received fatal exception handling hotplug!")
             raise
 
-    LOG.debug('Exiting hotplug handler')
+    LOG.debug("Exiting hotplug handler")
     reporting.flush_events()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = get_parser().parse_args()
     handle_args(NAME, args)
diff --git a/cloudinit/cmd/devel/logs.py b/cloudinit/cmd/devel/logs.py
index 31ade73d..d54b809a 100644
--- a/cloudinit/cmd/devel/logs.py
+++ b/cloudinit/cmd/devel/logs.py
@@ -5,20 +5,19 @@
 """Define 'collect-logs' utility and handler to include in cloud-init cmd."""
 
 import argparse
-from datetime import datetime
 import os
 import shutil
 import sys
+from datetime import datetime
 
 from cloudinit.sources import INSTANCE_JSON_SENSITIVE_FILE
+from cloudinit.subp import ProcessExecutionError, subp
 from cloudinit.temp_utils import tempdir
-from cloudinit.subp import (ProcessExecutionError, subp)
-from cloudinit.util import (chdir, copy, ensure_dir, write_file)
+from cloudinit.util import chdir, copy, ensure_dir, write_file
 
-
-CLOUDINIT_LOGS = ['/var/log/cloud-init.log', '/var/log/cloud-init-output.log']
-CLOUDINIT_RUN_DIR = '/run/cloud-init'
-USER_DATA_FILE = '/var/lib/cloud/instance/user-data.txt'  # Optional
+CLOUDINIT_LOGS = ["/var/log/cloud-init.log", "/var/log/cloud-init-output.log"]
+CLOUDINIT_RUN_DIR = "/run/cloud-init"
+USER_DATA_FILE = "/var/lib/cloud/instance/user-data.txt"  # Optional
 
 
 def get_parser(parser=None):
@@ -32,26 +31,44 @@ def get_parser(parser=None):
     """
     if not parser:
         parser = argparse.ArgumentParser(
-            prog='collect-logs',
-            description='Collect and tar all cloud-init debug info')
-    parser.add_argument('--verbose', '-v', action='count', default=0,
-                        dest='verbosity', help="Be more verbose.")
+            prog="collect-logs",
+            description="Collect and tar all cloud-init debug info",
+        )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="count",
+        default=0,
+        dest="verbosity",
+        help="Be more verbose.",
+    )
     parser.add_argument(
-        "--tarfile", '-t', default='cloud-init.tar.gz',
-        help=('The tarfile to create containing all collected logs.'
-              ' Default: cloud-init.tar.gz'))
+        "--tarfile",
+        "-t",
+        default="cloud-init.tar.gz",
+        help=(
+            "The tarfile to create containing all collected logs."
+            " Default: cloud-init.tar.gz"
+        ),
+    )
     parser.add_argument(
-        "--include-userdata", '-u', default=False, action='store_true',
-        dest='userdata', help=(
-            'Optionally include user-data from {0} which could contain'
-            ' sensitive information.'.format(USER_DATA_FILE)))
+        "--include-userdata",
+        "-u",
+        default=False,
+        action="store_true",
+        dest="userdata",
+        help=(
+            "Optionally include user-data from {0} which could contain"
+            " sensitive information.".format(USER_DATA_FILE)
+        ),
+    )
     return parser
 
 
 def _copytree_rundir_ignore_files(curdir, files):
     """Return a list of files to ignore for /run/cloud-init directory"""
     ignored_files = [
-        'hook-hotplug-cmd',  # named pipe for hotplug
+        "hook-hotplug-cmd",  # named pipe for hotplug
     ]
     if os.getuid() != 0:
         # Ignore root-permissioned files
@@ -94,52 +111,67 @@ def collect_logs(tarfile, include_userdata, verbosity=0):
     if include_userdata and os.getuid() != 0:
         sys.stderr.write(
             "To include userdata, root user is required."
-            " Try sudo cloud-init collect-logs\n")
+            " Try sudo cloud-init collect-logs\n"
+        )
         return 1
     tarfile = os.path.abspath(tarfile)
-    date = datetime.utcnow().date().strftime('%Y-%m-%d')
-    log_dir = 'cloud-init-logs-{0}'.format(date)
-    with tempdir(dir='/tmp') as tmp_dir:
+    date = datetime.utcnow().date().strftime("%Y-%m-%d")
+    log_dir = "cloud-init-logs-{0}".format(date)
+    with tempdir(dir="/tmp") as tmp_dir:
         log_dir = os.path.join(tmp_dir, log_dir)
         version = _write_command_output_to_file(
-            ['cloud-init', '--version'],
-            os.path.join(log_dir, 'version'),
-            "cloud-init --version", verbosity)
+            ["cloud-init", "--version"],
+            os.path.join(log_dir, "version"),
+            "cloud-init --version",
+            verbosity,
+        )
         dpkg_ver = _write_command_output_to_file(
-            ['dpkg-query', '--show', "-f=${Version}\n", 'cloud-init'],
-            os.path.join(log_dir, 'dpkg-version'),
-            "dpkg version", verbosity)
+            ["dpkg-query", "--show", "-f=${Version}\n", "cloud-init"],
+            os.path.join(log_dir, "dpkg-version"),
+            "dpkg version",
+            verbosity,
+        )
         if not version:
             version = dpkg_ver if dpkg_ver else "not-available"
         _debug("collected cloud-init version: %s\n" % version, 1, verbosity)
         _write_command_output_to_file(
-            ['dmesg'], os.path.join(log_dir, 'dmesg.txt'),
-            "dmesg output", verbosity)
+            ["dmesg"],
+            os.path.join(log_dir, "dmesg.txt"),
+            "dmesg output",
+            verbosity,
+        )
         _write_command_output_to_file(
-            ['journalctl', '--boot=0', '-o', 'short-precise'],
-            os.path.join(log_dir, 'journal.txt'),
-            "systemd journal of current boot", verbosity)
+            ["journalctl", "--boot=0", "-o", "short-precise"],
+            os.path.join(log_dir, "journal.txt"),
+            "systemd journal of current boot",
+            verbosity,
+        )
 
         for log in CLOUDINIT_LOGS:
             _collect_file(log, log_dir, verbosity)
         if include_userdata:
             _collect_file(USER_DATA_FILE, log_dir, verbosity)
-        run_dir = os.path.join(log_dir, 'run')
+        run_dir = os.path.join(log_dir, "run")
         ensure_dir(run_dir)
         if os.path.exists(CLOUDINIT_RUN_DIR):
             try:
-                shutil.copytree(CLOUDINIT_RUN_DIR,
-                                os.path.join(run_dir, 'cloud-init'),
-                                ignore=_copytree_rundir_ignore_files)
+                shutil.copytree(
+                    CLOUDINIT_RUN_DIR,
+                    os.path.join(run_dir, "cloud-init"),
+                    ignore=_copytree_rundir_ignore_files,
+                )
             except shutil.Error as e:
                 sys.stderr.write("Failed collecting file(s) due to error:\n")
-                sys.stderr.write(str(e) + '\n')
+                sys.stderr.write(str(e) + "\n")
             _debug("collected dir %s\n" % CLOUDINIT_RUN_DIR, 1, verbosity)
         else:
-            _debug("directory '%s' did not exist\n" % CLOUDINIT_RUN_DIR, 1,
-                   verbosity)
+            _debug(
+                "directory '%s' did not exist\n" % CLOUDINIT_RUN_DIR,
+                1,
+                verbosity,
+            )
         with chdir(tmp_dir):
-            subp(['tar', 'czvf', tarfile, log_dir.replace(tmp_dir + '/', '')])
+            subp(["tar", "czvf", tarfile, log_dir.replace(tmp_dir + "/", "")])
     sys.stderr.write("Wrote %s\n" % tarfile)
     return 0
 
@@ -152,10 +184,10 @@ def handle_collect_logs_args(name, args):
 def main():
     """Tool to collect and tar all cloud-init related logs."""
     parser = get_parser()
-    return handle_collect_logs_args('collect-logs', parser.parse_args())
+    return handle_collect_logs_args("collect-logs", parser.parse_args())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
 
 # vi: ts=4 expandtab
diff --git a/cloudinit/cmd/devel/make_mime.py b/cloudinit/cmd/devel/make_mime.py
index 4e6a5778..a7493c74 100755
--- a/cloudinit/cmd/devel/make_mime.py
+++ b/cloudinit/cmd/devel/make_mime.py
@@ -9,19 +9,22 @@ from email.mime.text import MIMEText
 
 from cloudinit import log
 from cloudinit.handlers import INCLUSION_TYPES_MAP
+
 from . import addLogHandlerCLI
 
-NAME = 'make-mime'
+NAME = "make-mime"
 LOG = log.getLogger(NAME)
-EPILOG = ("Example: make-mime -a config.yaml:cloud-config "
-          "-a script.sh:x-shellscript > user-data")
+EPILOG = (
+    "Example: make-mime -a config.yaml:cloud-config "
+    "-a script.sh:x-shellscript > user-data"
+)
 
 
 def file_content_type(text):
-    """ Return file content type by reading the first line of the input. """
+    """Return file content type by reading the first line of the input."""
     try:
         filename, content_type = text.split(":", 1)
-        return (open(filename, 'r'), filename, content_type.strip())
+        return (open(filename, "r"), filename, content_type.strip())
     except ValueError as e:
         raise argparse.ArgumentError(
             text, "Invalid value for %r" % (text)
@@ -41,26 +44,43 @@ def get_parser(parser=None):
     # update the parser's doc and add an epilog to show an example
     parser.description = __doc__
     parser.epilog = EPILOG
-    parser.add_argument("-a", "--attach", dest="files", type=file_content_type,
-                        action='append', default=[],
-                        metavar="<file>:<content-type>",
-                        help=("attach the given file as the specified "
-                              "content-type"))
-    parser.add_argument('-l', '--list-types', action='store_true',
-                        default=False,
-                        help='List support cloud-init content types.')
-    parser.add_argument('-f', '--force', action='store_true',
-                        default=False,
-                        help='Ignore unknown content-type warnings')
+    parser.add_argument(
+        "-a",
+        "--attach",
+        dest="files",
+        type=file_content_type,
+        action="append",
+        default=[],
+        metavar="<file>:<content-type>",
+        help="attach the given file as the specified content-type",
+    )
+    parser.add_argument(
+        "-l",
+        "--list-types",
+        action="store_true",
+        default=False,
+        help="List support cloud-init content types.",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Ignore unknown content-type warnings",
+    )
     return parser
 
 
 def get_content_types(strip_prefix=False):
-    """ Return a list of cloud-init supported content types.  Optionally
-        strip out the leading 'text/' of the type if strip_prefix=True.
+    """Return a list of cloud-init supported content types.  Optionally
+    strip out the leading 'text/' of the type if strip_prefix=True.
     """
-    return sorted([ctype.replace("text/", "") if strip_prefix else ctype
-                   for ctype in INCLUSION_TYPES_MAP.values()])
+    return sorted(
+        [
+            ctype.replace("text/", "") if strip_prefix else ctype
+            for ctype in INCLUSION_TYPES_MAP.values()
+        ]
+    )
 
 
 def handle_args(name, args):
@@ -82,14 +102,16 @@ def handle_args(name, args):
     for i, (fh, filename, format_type) in enumerate(args.files):
         contents = fh.read()
         sub_message = MIMEText(contents, format_type, sys.getdefaultencoding())
-        sub_message.add_header('Content-Disposition',
-                               'attachment; filename="%s"' % (filename))
+        sub_message.add_header(
+            "Content-Disposition", 'attachment; filename="%s"' % (filename)
+        )
         content_type = sub_message.get_content_type().lower()
         if content_type not in get_content_types():
             level = "WARNING" if args.force else "ERROR"
-            msg = (level + ": content type %r for attachment %s "
-                   "may be incorrect!") % (content_type, i + 1)
-            sys.stderr.write(msg + '\n')
+            msg = (
+                level + ": content type %r for attachment %s may be incorrect!"
+            ) % (content_type, i + 1)
+            sys.stderr.write(msg + "\n")
             errors.append(msg)
         sub_messages.append(sub_message)
     if len(errors) and not args.force:
@@ -104,10 +126,10 @@ def handle_args(name, args):
 
 def main():
     args = get_parser().parse_args()
-    return(handle_args(NAME, args))
+    return handle_args(NAME, args)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())
 
 
diff --git a/cloudinit/cmd/devel/net_convert.py b/cloudinit/cmd/devel/net_convert.py
index f4a98e5e..18b1e7ff 100755
--- a/cloudinit/cmd/devel/net_convert.py
+++ b/cloudinit/cmd/devel/net_convert.py
@@ -6,15 +6,13 @@ import json
 import os
 import sys
 
-from cloudinit.sources.helpers import openstack
+from cloudinit import distros, log, safeyaml
+from cloudinit.net import eni, netplan, network_state, networkd, sysconfig
 from cloudinit.sources import DataSourceAzure as azure
 from cloudinit.sources import DataSourceOVF as ovf
+from cloudinit.sources.helpers import openstack
 
-from cloudinit import distros, safeyaml
-from cloudinit.net import eni, netplan, networkd, network_state, sysconfig
-from cloudinit import log
-
-NAME = 'net-convert'
+NAME = "net-convert"
 
 
 def get_parser(parser=None):
@@ -27,33 +25,59 @@ def get_parser(parser=None):
     """
     if not parser:
         parser = argparse.ArgumentParser(prog=NAME, description=__doc__)
-    parser.add_argument("-p", "--network-data", type=open,
-                        metavar="PATH", required=True,
-                        help="The network configuration to read")
-    parser.add_argument("-k", "--kind",
-                        choices=['eni', 'network_data.json', 'yaml',
-                                 'azure-imds', 'vmware-imc'],
-                        required=True,
-                        help="The format of the given network config")
-    parser.add_argument("-d", "--directory",
-                        metavar="PATH",
-                        help="directory to place output in",
-                        required=True)
-    parser.add_argument("-D", "--distro",
-                        choices=[item for sublist in
-                                 distros.OSFAMILIES.values()
-                                 for item in sublist],
-                        required=True)
-    parser.add_argument("-m", "--mac",
-                        metavar="name,mac",
-                        action='append',
-                        help="interface name to mac mapping")
-    parser.add_argument("--debug", action='store_true',
-                        help='enable debug logging to stderr.')
-    parser.add_argument("-O", "--output-kind",
-                        choices=['eni', 'netplan', 'networkd', 'sysconfig'],
-                        required=True,
-                        help="The network config format to emit")
+    parser.add_argument(
+        "-p",
+        "--network-data",
+        type=open,
+        metavar="PATH",
+        required=True,
+        help="The network configuration to read",
+    )
+    parser.add_argument(
+        "-k",
+        "--kind",
+        choices=[
+            "eni",
+            "network_data.json",
+            "yaml",
+            "azure-imds",
+            "vmware-imc",
+        ],
+        required=True,
+        help="The format of the given network config",
+    )
+    parser.add_argument(
+        "-d",
+        "--directory",
+        metavar="PATH",
+        help="directory to place output in",
+        required=True,
+    )
+    parser.add_argument(
+        "-D",
+        "--distro",
+        choices=[
+            item for sublist in distros.OSFAMILIES.values() for item in sublist
+        ],
+        required=True,
+    )
+    parser.add_argument(
+        "-m",
+        "--mac",
+        metavar="name,mac",
+        action="append",
+        help="interface name to mac mapping",
+    )
+    parser.add_argument(
+        "--debug", action="store_true", help="enable debug logging to stderr."
+    )
+    parser.add_argument(
+        "-O",
+        "--output-kind",
+        choices=["eni", "netplan", "networkd", "sysconfig"],
+        required=True,
+        help="The network config format to emit",
+    )
     return parser
 
 
@@ -81,59 +105,68 @@ def handle_args(name, args):
         pre_ns = eni.convert_eni_data(net_data)
     elif args.kind == "yaml":
         pre_ns = safeyaml.load(net_data)
-        if 'network' in pre_ns:
-            pre_ns = pre_ns.get('network')
+        if "network" in pre_ns:
+            pre_ns = pre_ns.get("network")
         if args.debug:
-            sys.stderr.write('\n'.join(
-                ["Input YAML", safeyaml.dumps(pre_ns), ""]))
-    elif args.kind == 'network_data.json':
+            sys.stderr.write(
+                "\n".join(["Input YAML", safeyaml.dumps(pre_ns), ""])
+            )
+    elif args.kind == "network_data.json":
         pre_ns = openstack.convert_net_json(
-            json.loads(net_data), known_macs=known_macs)
-    elif args.kind == 'azure-imds':
+            json.loads(net_data), known_macs=known_macs
+        )
+    elif args.kind == "azure-imds":
         pre_ns = azure.parse_network_config(json.loads(net_data))
-    elif args.kind == 'vmware-imc':
+    elif args.kind == "vmware-imc":
         config = ovf.Config(ovf.ConfigFile(args.network_data.name))
         pre_ns = ovf.get_network_config_from_conf(config, False)
 
     ns = network_state.parse_net_config_data(pre_ns)
 
     if args.debug:
-        sys.stderr.write('\n'.join(
-            ["", "Internal State", safeyaml.dumps(ns), ""]))
+        sys.stderr.write(
+            "\n".join(["", "Internal State", safeyaml.dumps(ns), ""])
+        )
     distro_cls = distros.fetch(args.distro)
     distro = distro_cls(args.distro, {}, None)
     config = {}
     if args.output_kind == "eni":
         r_cls = eni.Renderer
-        config = distro.renderer_configs.get('eni')
+        config = distro.renderer_configs.get("eni")
     elif args.output_kind == "netplan":
         r_cls = netplan.Renderer
-        config = distro.renderer_configs.get('netplan')
+        config = distro.renderer_configs.get("netplan")
         # don't run netplan generate/apply
-        config['postcmds'] = False
+        config["postcmds"] = False
         # trim leading slash
-        config['netplan_path'] = config['netplan_path'][1:]
+        config["netplan_path"] = config["netplan_path"][1:]
         # enable some netplan features
-        config['features'] = ['dhcp-use-domains', 'ipv6-mtu']
+        config["features"] = ["dhcp-use-domains", "ipv6-mtu"]
     elif args.output_kind == "networkd":
         r_cls = networkd.Renderer
-        config = distro.renderer_configs.get('networkd')
+        config = distro.renderer_configs.get("networkd")
     elif args.output_kind == "sysconfig":
         r_cls = sysconfig.Renderer
-        config = distro.renderer_configs.get('sysconfig')
+        config = distro.renderer_configs.get("sysconfig")
     else:
         raise RuntimeError("Invalid output_kind")
 
     r = r_cls(config=config)
-    sys.stderr.write(''.join([
-        "Read input format '%s' from '%s'.\n" % (
-            args.kind, args.network_data.name),
-        "Wrote output format '%s' to '%s'\n" % (
-            args.output_kind, args.directory)]) + "\n")
+    sys.stderr.write(
+        "".join(
+            [
+                "Read input format '%s' from '%s'.\n"
+                % (args.kind, args.network_data.name),
+                "Wrote output format '%s' to '%s'\n"
+                % (args.output_kind, args.directory),
+            ]
+        )
+        + "\n"
+    )
     r.render_network_state(network_state=ns, target=args.directory)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     args = get_parser().parse_args()
     handle_args(NAME, args)
 
diff --git a/cloudinit/cmd/devel/parser.py b/cloudinit/cmd/devel/parser.py
index be304630..76b16c2e 100644
--- a/cloudinit/cmd/devel/parser.py
+++ b/cloudinit/cmd/devel/parser.py
@@ -5,33 +5,47 @@
 """Define 'devel' subcommand argument parsers to include in cloud-init cmd."""
 
 import argparse
+
 from cloudinit.config import schema
 
-from . import hotplug_hook
-from . import net_convert
-from . import render
-from . import make_mime
+from . import hotplug_hook, make_mime, net_convert, render
 
 
 def get_parser(parser=None):
     if not parser:
         parser = argparse.ArgumentParser(
-            prog='cloudinit-devel',
-            description='Run development cloud-init tools')
-    subparsers = parser.add_subparsers(title='Subcommands', dest='subcommand')
+            prog="cloudinit-devel",
+            description="Run development cloud-init tools",
+        )
+    subparsers = parser.add_subparsers(title="Subcommands", dest="subcommand")
     subparsers.required = True
 
     subcmds = [
-        (hotplug_hook.NAME, hotplug_hook.__doc__,
-         hotplug_hook.get_parser, hotplug_hook.handle_args),
-        ('schema', 'Validate cloud-config files for document schema',
-         schema.get_parser, schema.handle_schema_args),
-        (net_convert.NAME, net_convert.__doc__,
-         net_convert.get_parser, net_convert.handle_args),
-        (render.NAME, render.__doc__,
-         render.get_parser, render.handle_args),
-        (make_mime.NAME, make_mime.__doc__,
-         make_mime.get_parser, make_mime.handle_args),
+        (
+            hotplug_hook.NAME,
+            hotplug_hook.__doc__,
+            hotplug_hook.get_parser,
+            hotplug_hook.handle_args,
+        ),
+        (
+            "schema",
+            "Validate cloud-config files for document schema",
+            schema.get_parser,
+            schema.handle_schema_args,
+        ),
+        (
+            net_convert.NAME,
+            net_convert.__doc__,
+            net_convert.get_parser,
+            net_convert.handle_args,
+        ),
+        (render.NAME, render.__doc__, render.get_parser, render.handle_args),
+        (
+            make_mime.NAME,
+            make_mime.__doc__,
+            make_mime.get_parser,
+            make_mime.handle_args,
+        ),
     ]
     for (subcmd, helpmsg, get_parser, handler) in subcmds:
         parser = subparsers.add_parser(subcmd, help=helpmsg)
diff --git a/cloudinit/cmd/devel/render.py b/cloudinit/cmd/devel/render.py
index 1090aa16..2f9a22a8 100755
--- a/cloudinit/cmd/devel/render.py
+++ b/cloudinit/cmd/devel/render.py
@@ -6,12 +6,13 @@ import argparse
 import os
 import sys
 
-from cloudinit.handlers.jinja_template import render_jinja_payload_from_file
 from cloudinit import log
+from cloudinit.handlers.jinja_template import render_jinja_payload_from_file
 from cloudinit.sources import INSTANCE_JSON_FILE, INSTANCE_JSON_SENSITIVE_FILE
+
 from . import addLogHandlerCLI, read_cfg_paths
 
-NAME = 'render'
+NAME = "render"
 
 LOG = log.getLogger(NAME)
 
@@ -27,13 +28,24 @@ def get_parser(parser=None):
     if not parser:
         parser = argparse.ArgumentParser(prog=NAME, description=__doc__)
     parser.add_argument(
-        'user_data', type=str, help='Path to the user-data file to render')
+        "user_data", type=str, help="Path to the user-data file to render"
+    )
+    parser.add_argument(
+        "-i",
+        "--instance-data",
+        type=str,
+        help=(
+            "Optional path to instance-data.json file. Defaults to"
+            " /run/cloud-init/instance-data.json"
+        ),
+    )
     parser.add_argument(
-        '-i', '--instance-data', type=str,
-        help=('Optional path to instance-data.json file. Defaults to'
-              ' /run/cloud-init/instance-data.json'))
-    parser.add_argument('-d', '--debug', action='store_true', default=False,
-                        help='Add verbose messages during template render')
+        "-d",
+        "--debug",
+        action="store_true",
+        default=False,
+        help="Add verbose messages during template render",
+    )
     return parser
 
 
@@ -54,34 +66,38 @@ def handle_args(name, args):
         redacted_data_fn = os.path.join(paths.run_dir, INSTANCE_JSON_FILE)
         if uid == 0:
             instance_data_fn = os.path.join(
-                paths.run_dir, INSTANCE_JSON_SENSITIVE_FILE)
+                paths.run_dir, INSTANCE_JSON_SENSITIVE_FILE
+            )
             if not os.path.exists(instance_data_fn):
                 LOG.warning(
-                    'Missing root-readable %s. Using redacted %s instead.',
-                    instance_data_fn, redacted_data_fn
+                    "Missing root-readable %s. Using redacted %s instead.",
+                    instance_data_fn,
+                    redacted_data_fn,
                 )
                 instance_data_fn = redacted_data_fn
         else:
             instance_data_fn = redacted_data_fn
     if not os.path.exists(instance_data_fn):
-        LOG.error('Missing instance-data.json file: %s', instance_data_fn)
+        LOG.error("Missing instance-data.json file: %s", instance_data_fn)
         return 1
     try:
         with open(args.user_data) as stream:
             user_data = stream.read()
     except IOError:
-        LOG.error('Missing user-data file: %s', args.user_data)
+        LOG.error("Missing user-data file: %s", args.user_data)
         return 1
     try:
         rendered_payload = render_jinja_payload_from_file(
-            payload=user_data, payload_fn=args.user_data,
+            payload=user_data,
+            payload_fn=args.user_data,
             instance_data_file=instance_data_fn,
-            debug=True if args.debug else False)
+            debug=True if args.debug else False,
+        )
     except RuntimeError as e:
-        LOG.error('Cannot render from instance data: %s', str(e))
+        LOG.error("Cannot render from instance data: %s", str(e))
         return 1
     if not rendered_payload:
-        LOG.error('Unable to render user-data file: %s', args.user_data)
+        LOG.error("Unable to render user-data file: %s", args.user_data)
         return 1
     sys.stdout.write(rendered_payload)
     return 0
@@ -89,10 +105,10 @@ def handle_args(name, args):
 
 def main():
     args = get_parser().parse_args()
-    return(handle_args(NAME, args))
+    return handle_args(NAME, args)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main())