Merge ~afreiberger/charm-hw-health:blacken-20.08 into charm-hw-health:master

[Drew Freiberger]

[Xav Paice (xavpaice)]

LGTM

review: Approve

diff --git a/src/actions/actions.py b/src/actions/actions.py
index e3f04cd..734841b 100755
--- a/src/actions/actions.py
+++ b/src/actions/actions.py
@@ -21,7 +21,7 @@ import sys
 from charmhelpers.core.hookenv import action_set, action_get, action_fail, log
 
 
-IPMI_SEL = '/usr/sbin/ipmi-sel'
+IPMI_SEL = "/usr/sbin/ipmi-sel"
 
 
 def clear_sel():
@@ -30,11 +30,11 @@ def clear_sel():
     Uses ipmi-sel --post-clear, clears the SEL log and stores the cleared entries
     in action output.
     """
-    command = [IPMI_SEL, '--post-clear']
+    command = [IPMI_SEL, "--post-clear"]
     try:
         output = subprocess.check_output(command)
         log("Action clear-sel completed, sel log cleared: {}".format(output))
-        action_set({'message': output.decode('UTF-8')})
+        action_set({"message": output.decode("UTF-8")})
     except subprocess.CalledProcessError as e:
         action_fail("Action failed with {}".format(e))
 
@@ -45,23 +45,23 @@ def show_sel():
     By default, this will show all non-nominal events.  If you specify show-all,
     it will show all events.
     """
-    show_all = action_get('show-all')
-    command = [IPMI_SEL, '--output-event-state']
+    show_all = action_get("show-all")
+    command = [IPMI_SEL, "--output-event-state"]
     try:
         header, body = None, None
-        output = subprocess.check_output(command).decode('UTF-8')
+        output = subprocess.check_output(command).decode("UTF-8")
         lines = output.splitlines()
         if lines:
             header, body = lines[0], lines[1:]
             if not show_all:
                 # This is fairly naive, but it may be good enough for now
-                body = [line for line in body if 'Nominal' not in line]
+                body = [line for line in body if "Nominal" not in line]
         if body:
             final_output = "\n".join([header] + body)
         else:
             final_output = "No matching entries found"
         log("Action show-sel completed:\n{}".format(final_output))
-        action_set({'message': final_output})
+        action_set({"message": final_output})
     except subprocess.CalledProcessError as e:
         action_fail("Action failed with {}".format(e))
 
diff --git a/src/files/common/check_hw_health_cron_output.py b/src/files/common/check_hw_health_cron_output.py
index ebb63e1..92ff372 100755
--- a/src/files/common/check_hw_health_cron_output.py
+++ b/src/files/common/check_hw_health_cron_output.py
@@ -10,11 +10,13 @@
 
 from optparse import OptionParser
 
-from nagios_plugin3 import (check_file_freshness,
-                            try_check,
-                            WarnError,
-                            UnknownError,
-                            CriticalError)
+from nagios_plugin3 import (
+    check_file_freshness,
+    try_check,
+    WarnError,
+    UnknownError,
+    CriticalError,
+)
 
 
 ###############################################################################
@@ -55,17 +57,17 @@ def main():
         help="freshness time limit [default=%default]",
         metavar="SECONDS",
         default=1200,
-        type=int
+        type=int,
     )
     parser.add_option(
-        "-f", "--filename",
+        "-f",
+        "--filename",
         dest="input_file",
-        help=('file containing the output of '
-              'cron_ilorest.py [default=%default]'),
+        help=("file containing the output of cron_ilorest.py [default=%default]"),
         metavar="FILE",
         nargs=1,
         # default="/var/lib/nagios/UNSETOUTPUTFILE.out",
-        type=str
+        type=str,
     )
 
     (opts, args) = parser.parse_args()
diff --git a/src/files/common/hw_health_lib.py b/src/files/common/hw_health_lib.py
index c75a4e5..945de0d 100644
--- a/src/files/common/hw_health_lib.py
+++ b/src/files/common/hw_health_lib.py
@@ -60,25 +60,30 @@ def read_ignore_file(ignore_file):  # noqa C901
     ignores = []
     if os.path.isfile(ignore_file):
         for line in open(ignore_file).readlines():
-            d = {'matched': False, 'expired': False, 'line': line.rstrip(), 'ignore': None}
+            d = {
+                "matched": False,
+                "expired": False,
+                "line": line.rstrip(),
+                "ignore": None,
+            }
             line = line.strip()
             # special case lines starting with '*', do not disable if unmatched
             persist = False
-            if line.startswith('*'):
+            if line.startswith("*"):
                 persist = True
-                line = line.lstrip('*').strip()
+                line = line.lstrip("*").strip()
             # parse date lines
-            if line.startswith('['):
-                parts = re.split('\\[|\\]', line, maxsplit=2)
+            if line.startswith("["):
+                parts = re.split("\\[|\\]", line, maxsplit=2)
                 date = parts[1].strip()
                 ignore = parts[2].strip()
                 try:
-                    date = datetime.strptime(date, '%Y-%m-%d %H:%M')
+                    date = datetime.strptime(date, "%Y-%m-%d %H:%M")
                 except ValueError:
                     try:
-                        date = datetime.strptime(date, '%Y-%m-%d')
+                        date = datetime.strptime(date, "%Y-%m-%d")
                     except ValueError:
-                        print("Failed to parse ignore date: {}".format(d['line']))
+                        print("Failed to parse ignore date: {}".format(d["line"]))
                         date = None
                     if date:
                         # Do not alert directly at midnight UTC
@@ -88,18 +93,18 @@ def read_ignore_file(ignore_file):  # noqa C901
                 if date:
                     if datetime.now().weekday() in (5, 6):
                         # Ignore Saturday/Sunday to not annoy on-call
-                        d['ignore'] = ignore
+                        d["ignore"] = ignore
                     elif date > datetime.now():
-                        d['ignore'] = ignore
+                        d["ignore"] = ignore
                     else:
-                        d['expired'] = True
-                    if persist and not d['expired']:
+                        d["expired"] = True
+                    if persist and not d["expired"]:
                         # set matched True so will not get disabled on non-match
-                        d['matched'] = True
+                        d["matched"] = True
             # comment lines and empty lines are just added
-            elif line.startswith('#') or not line:
+            elif line.startswith("#") or not line:
                 # add with matched True so does not trigger a file rewrite
-                d['matched'] = True
+                d["matched"] = True
             # unrecognized lines left matched False so rewritten
             ignores.append(d)
     return ignores
@@ -107,22 +112,24 @@ def read_ignore_file(ignore_file):  # noqa C901
 
 def write_ignore_file(ignores, ignore_file):
     # if any ignores are not matched then write out file lines again
-    if any([not i['matched'] for i in ignores]):
+    if any([not i["matched"] for i in ignores]):
         dirname, basename = os.path.split(ignore_file)
         date = datetime.now()
         try:
             f = tempfile.NamedTemporaryFile(dir=dirname, prefix=basename, delete=False)
             for ignore in ignores:
-                if not ignore['matched'] and ignore['ignore']:
-                    ignore['line'] = "# not matched at {} #{}".format(
-                        date.strftime("%Y-%m-%dT%H:%M:%S"), ignore['line']
+                if not ignore["matched"] and ignore["ignore"]:
+                    ignore["line"] = "# not matched at {} #{}".format(
+                        date.strftime("%Y-%m-%dT%H:%M:%S"), ignore["line"]
                     )
-                elif ignore['expired']:
+                elif ignore["expired"]:
                     # this won't get updated unless the alert has cleared
-                    ignore['line'] = "# expired #{}".format(ignore['line'])
-                elif not ignore['matched']:
-                    ignore['line'] = "# unknown or bad format #{}".format(ignore['line'])
-                f.write(ignore['line'] + '\n')
+                    ignore["line"] = "# expired #{}".format(ignore["line"])
+                elif not ignore["matched"]:
+                    ignore["line"] = "# unknown or bad format #{}".format(
+                        ignore["line"]
+                    )
+                f.write(ignore["line"] + "\n")
             f.flush()
             os.fsync(f.fileno())
             f.close()
@@ -137,11 +144,11 @@ def write_ignore_file(ignores, ignore_file):
 def ignore(line, ignores):
     # check if each ignore is in line
     for ignore in ignores:
-        if ignore['ignore'] and ignore['ignore'] in line:
+        if ignore["ignore"] and ignore["ignore"] in line:
             ignoring_output.append("Ignoring: {}".format(line))
             # note: ignores can be updated since it is passed by reference
             # matched=True to keep using this ignore (see write_ignore_file)
-            ignore['matched'] = True
+            ignore["matched"] = True
             return True
     return False
 
@@ -153,102 +160,96 @@ def get_hp_controller_slots():
     Use the utility to determine the current controller slot(s) available for probing
     """
     slots = []
-    cmd = ['/usr/sbin/hpssacli', 'ctrl', 'all', 'show']
+    cmd = ["/usr/sbin/hpssacli", "ctrl", "all", "show"]
     try:
-        results = subprocess.check_output(cmd).decode('UTF-8')
+        results = subprocess.check_output(cmd).decode("UTF-8")
     except subprocess.CalledProcessError:
         return slots
     for line in results.splitlines():
-        if 'in Slot' in line:
+        if "in Slot" in line:
             slots.append(line.split()[5])
     return slots
 
 
 class HWCronArgumentParser(argparse.ArgumentParser):
-    def __init__(
-        self,
-        def_write_file=None,
-        *args,
-        **kwargs
-    ):
+    def __init__(self, def_write_file=None, *args, **kwargs):
         super().__init__(
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-            *args,
-            **kwargs
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter, *args, **kwargs
         )
         # self.prog is populated by ArgumentParser
-        self._def_write_file = \
-            def_write_file or '/var/lib/nagios/{}.out'.format(self.prog)
+        self._def_write_file = def_write_file or "/var/lib/nagios/{}.out".format(
+            self.prog
+        )
 
     def parse_args(self, *args, **kwargs):
         self.add_argument(
-            '-w', '--write', dest='write', type=str,
+            "-w",
+            "--write",
+            dest="write",
+            type=str,
             default=self._def_write_file,
-            help='cache tool output in this file',
+            help="cache tool output in this file",
         )
         super().parse_args(*args, **kwargs)
 
 
 class HWCheckArgumentParser(argparse.ArgumentParser):
-    def __init__(
-        self,
-        def_input_file=None,
-        *args,
-        **kwargs
-    ):
+    def __init__(self, def_input_file=None, *args, **kwargs):
         super().__init__(
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-            *args,
-            **kwargs
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter, *args, **kwargs
         )
         # self.prog is populated by ArgumentParser
-        self._def_input_file = \
-            def_input_file or '/var/lib/nagios/{}.out'.format(self.prog)
+        self._def_input_file = def_input_file or "/var/lib/nagios/{}.out".format(
+            self.prog
+        )
 
     def parse_args(self, *args, **kwargs):
         self.add_argument(
-            '-i', '--input', dest='input_file', type=str,
+            "-i",
+            "--input",
+            dest="input_file",
+            type=str,
             default=self._def_input_file,
-            help='read cached tool output from this file',
+            help="read cached tool output from this file",
         )
         super().parse_args(*args, **kwargs)
 
 
 class HPArgumentParser(HWCronArgumentParser):
-    def __init__(
-        self,
-        def_exclude_file=None,
-        *args,
-        **kwargs
-    ):
+    def __init__(self, def_exclude_file=None, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._def_exclude_file = \
-            def_exclude_file or '/etc/nagios/{}.exclude.yaml'.format(self.prog)
+        self._def_exclude_file = (
+            def_exclude_file or "/etc/nagios/{}.exclude.yaml".format(self.prog)
+        )
 
     def _expired(self, exclusion):
-        return 'expires' in exclusion and exclusion['expires'] < datetime.now()
+        return "expires" in exclusion and exclusion["expires"] < datetime.now()
 
     def parse_args(self, *args, **kwargs):
         self.add_argument(
-            '--debug', dest='debug', action='store_true',
-            help='Extra debugging',
+            "--debug", dest="debug", action="store_true", help="Extra debugging",
         )
 
         self.add_argument(
-            '--exclude', dest='exclude', type=str, action='append',
-            help='Errors to ignore (multiple)',
+            "--exclude",
+            dest="exclude",
+            type=str,
+            action="append",
+            help="Errors to ignore (multiple)",
         )
 
         self.add_argument(
-            '--exclude-file', dest='exclude_file', type=str,
+            "--exclude-file",
+            dest="exclude_file",
+            type=str,
             default=self._def_exclude_file,
-            help='YAML file with errors to ignore',
+            help="YAML file with errors to ignore",
         )
 
         # Ensure we initialize a namespace if needed,
         # and have a reference to it
-        namespace = kwargs.get('namespace') or argparse.Namespace()
-        kwargs['namespace'] = namespace
+        namespace = kwargs.get("namespace") or argparse.Namespace()
+        kwargs["namespace"] = namespace
         # now parse args and put them in the namespace
         super().parse_args(*args, **kwargs)
 
@@ -258,6 +259,6 @@ class HPArgumentParser(HWCronArgumentParser):
             with open(namespace.exclude_file) as f:
                 for i in yaml.safe_load(f):
                     if not self._expired(i):
-                        namespace.exclude.append(i['error'])
+                        namespace.exclude.append(i["error"])
 
         return namespace
diff --git a/src/files/hplog/cron_hplog.py b/src/files/hplog/cron_hplog.py
index d2b21cf..57b52e2 100755
--- a/src/files/hplog/cron_hplog.py
+++ b/src/files/hplog/cron_hplog.py
@@ -25,7 +25,7 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
@@ -37,35 +37,43 @@ except ImportError:
     )
 
 FLAG_PROCESSOR = {
-    't': 'parse_temperature',
-    'f': 'parse_fans',
-    'p': 'parse_power',
-    'v': 'save_log',
+    "t": "parse_temperature",
+    "f": "parse_fans",
+    "p": "parse_power",
+    "v": "save_log",
 }
-OUTPUT_FILE = '/var/lib/nagios/hplog.out'
-EXCLUDE_FILE = '/etc/nagios/hplog.exclude.yaml'
-DEBUG_FILE = '/var/lib/nagios/hplog.debug'
+OUTPUT_FILE = "/var/lib/nagios/hplog.out"
+EXCLUDE_FILE = "/etc/nagios/hplog.exclude.yaml"
+DEBUG_FILE = "/var/lib/nagios/hplog.debug"
 
 
 def parse_args(argv=None):
     parser = HPArgumentParser(
-        prog='cron_hplog',
-        def_write_file=OUTPUT_FILE,
-        def_exclude_file=EXCLUDE_FILE
+        prog="cron_hplog", def_write_file=OUTPUT_FILE, def_exclude_file=EXCLUDE_FILE
     )
     parser.add_argument(
-        '-f', '--hplog_flags', dest='hplog_flags', type=str,
-        default=','.join(FLAG_PROCESSOR.keys()),
-        help='Flags to call hplog with',
+        "-f",
+        "--hplog_flags",
+        dest="hplog_flags",
+        type=str,
+        default=",".join(FLAG_PROCESSOR.keys()),
+        help="Flags to call hplog with",
     )
     parser.add_argument(
-        '-l', '--log_path', dest='log_path', type=str,
+        "-l",
+        "--log_path",
+        dest="log_path",
+        type=str,
         default=DEBUG_FILE,
-        help='Where to write hplog -v output for troubleshooting',
+        help="Where to write hplog -v output for troubleshooting",
     )
     parser.add_argument(
-        '-s', '--single_psu', dest='single_psu', action='store_true',
-        help='Do not alert on lack of PSU redundancy', default=False,
+        "-s",
+        "--single_psu",
+        dest="single_psu",
+        action="store_true",
+        help="Do not alert on lack of PSU redundancy",
+        default=False,
     )
     return parser.parse_args(args=argv)
 
@@ -77,15 +85,16 @@ def call_hplog(flag):
     The output of this cron script will be checked by
     nagios via check_hplog.py.  The
     """
-    env = 'export PATH=$PATH:/usr/sbin:/sbin'
+    env = "export PATH=$PATH:/usr/sbin:/sbin"
 
-    cmd = 'hplog -{}'.format(flag)
+    cmd = "hplog -{}".format(flag)
     try:
-        cmdline = '{}; {}'.format(env, cmd)
-        output = subprocess.check_output(cmdline, shell=True).decode('UTF-8')
+        cmdline = "{}; {}".format(env, cmd)
+        output = subprocess.check_output(cmdline, shell=True).decode("UTF-8")
     except subprocess.CalledProcessError as e:
-        return ('Failed running command "{}" Return Code {}: {}'
-                ''.format(cmd, e.returncode, e.output))
+        return 'Failed running command "{}" Return Code {}: {}' "".format(
+            cmd, e.returncode, e.output
+        )
 
     funcname = FLAG_PROCESSOR[flag]
     return globals()[funcname](output)
@@ -106,10 +115,12 @@ def parse_temperature(result):
      7  Basic Sensor CPU (2)         Normal   ---F/---C 260F/127C
     """
     input_file = result.splitlines()
-    if os.path.isfile('/etc/nagios/skip-cat-hp-temperature.txt'):
+    if os.path.isfile("/etc/nagios/skip-cat-hp-temperature.txt"):
         return
     header_line = input_file.pop(0).strip()
-    if header_line != "ID     TYPE        LOCATION      STATUS    CURRENT  THRESHOLD":  # noqa E501
+    if (
+        header_line != "ID     TYPE        LOCATION      STATUS    CURRENT  THRESHOLD"
+    ):  # noqa E501
         return "UNKNOWN Unrecognised header line in 'hplog -t' output"
     for line in input_file:
         line = line.rstrip()
@@ -123,11 +134,11 @@ def parse_temperature(result):
         temp_current = line[42:51].split("/")[1].strip()
         temp_threshold = line[52:].split("/")[1].strip()
         if temp_status not in ["Normal", "Nominal", "Absent"]:
-            return (
-                "%s: temperature is '%s' (%s / %s)" % (temp_location,
-                                                       temp_status,
-                                                       temp_current,
-                                                       temp_threshold)
+            return "%s: temperature is '%s' (%s / %s)" % (
+                temp_location,
+                temp_status,
+                temp_current,
+                temp_threshold,
             )
 
     return
@@ -147,13 +158,15 @@ def parse_fans(result):
      6  Var. Speed   Processor Zone  Normal     Yes     Low    ( 36)
     """
     input_file = result.splitlines()
-    if os.path.isfile('/etc/nagios/skip-cat-hp-fans.txt'):
+    if os.path.isfile("/etc/nagios/skip-cat-hp-fans.txt"):
         return
     header_line = input_file.pop(0).strip()
-    if header_line != "ID     TYPE        LOCATION      STATUS  REDUNDANT FAN SPEED":  # noqa E501
+    if (
+        header_line != "ID     TYPE        LOCATION      STATUS  REDUNDANT FAN SPEED"
+    ):  # noqa E501
         return "UNKNOWN Unrecognised header line in 'hplog -f' output"
 
-    ignore_file = '/etc/nagios/ignores/ignores-cat-hp-fans.txt'
+    ignore_file = "/etc/nagios/ignores/ignores-cat-hp-fans.txt"
     ignores = read_ignore_file(ignore_file)
     for line in input_file:
         line = line.rstrip()
@@ -168,12 +181,7 @@ def parse_fans(result):
         fan_speed = line[51:].strip()
 
         (return_now, msg) = process_fan_line(
-            fan_type,
-            fan_location,
-            fan_status,
-            fan_speed,
-            fan_redundant,
-            ignores
+            fan_type, fan_location, fan_status, fan_speed, fan_redundant, ignores
         )
         if return_now:
             return msg
@@ -182,36 +190,37 @@ def parse_fans(result):
 
 
 def process_fan_line(
-    fan_type,
-    fan_location,
-    fan_status,
-    fan_speed,
-    fan_redundant,
-    ignores
+    fan_type, fan_location, fan_status, fan_speed, fan_redundant, ignores
 ):
     if fan_type == "Basic Fan":
-        return(False, None)
+        return (False, None)
 
     if fan_type not in ["Var. Speed", "Pwr. Supply", "Auto. Speed"]:
-        return(True, "UNKNOWN %s: Unrecognised fan type '%s'" % (fan_location,
-                                                                 fan_type))
+        return (
+            True,
+            "UNKNOWN %s: Unrecognised fan type '%s'" % (fan_location, fan_type),
+        )
 
     if fan_status not in ["Normal", "Nominal"]:
-        err = "%s: fans are '%s' (%s / Redundant: %s)" % (fan_location,
-                                                          fan_status,
-                                                          fan_speed,
-                                                          fan_redundant)
+        err = "%s: fans are '%s' (%s / Redundant: %s)" % (
+            fan_location,
+            fan_status,
+            fan_speed,
+            fan_redundant,
+        )
         if not ignore(err, ignores):
-            return(True, err)
+            return (True, err)
 
     if fan_redundant not in ["Yes", "N/A"] and fan_type == "Var. Speed":
-        err = "%s: fans are not redundant (%s / Status: %s)" % (fan_location,
-                                                                fan_speed,
-                                                                fan_redundant)
+        err = "%s: fans are not redundant (%s / Status: %s)" % (
+            fan_location,
+            fan_speed,
+            fan_redundant,
+        )
         if not ignore(err, ignores):
-            return(True, err)
+            return (True, err)
 
-    return(False, None)
+    return (False, None)
 
 
 def parse_power(result):
@@ -224,13 +233,13 @@ def parse_power(result):
      2  Standard     Pwr. Supply Bay Normal     Yes
     """
     input_file = result.splitlines()
-    if os.path.isfile('/etc/nagios/skip-cat-hp-power.txt'):
+    if os.path.isfile("/etc/nagios/skip-cat-hp-power.txt"):
         return
     header_line = input_file.pop(0).strip()
     if header_line != "ID     TYPE        LOCATION      STATUS  REDUNDANT":
         return "UNKNOWN Unrecognised header line in 'hplog -p' output"
 
-    ignore_file = '/etc/nagios/ignores/ignores-cat-hp-power.txt'
+    ignore_file = "/etc/nagios/ignores/ignores-cat-hp-power.txt"
     ignores = read_ignore_file(ignore_file)
 
     for line in input_file:
@@ -244,10 +253,9 @@ def parse_power(result):
         power_status = line[33:40].strip()
         # power_redundant = line[41:50].strip()
         if power_type != "Standard":
-            err = "%s: Unrecognised power type '%s'" % (power_location,
-                                                        power_type)
+            err = "%s: Unrecognised power type '%s'" % (power_location, power_type)
             if not ignore(err, ignores):
-                return 'UNKNOWN {}'.format(err)
+                return "UNKNOWN {}".format(err)
         if not ARGS.single_psu and power_status not in ["Normal", "Nominal"]:
             err = "%s: power supply is '%s'" % (power_location, power_status)
             if not ignore(err, ignores):
@@ -259,7 +267,7 @@ def save_log(result):
     """
     Save full hplog -v output for troubleshooting after alert
     """
-    with open(ARGS.log_path, 'w') as f:
+    with open(ARGS.log_path, "w") as f:
         f.write(result)
     return
 
@@ -270,35 +278,34 @@ def main():
 
     try:
         # This matches hpasmlited on latest packages for bionic on <= gen9
-        subprocess.check_call('ps -ef | grep -q hp[a]sm', shell=True)
+        subprocess.check_call("ps -ef | grep -q hp[a]sm", shell=True)
     except subprocess.CalledProcessError as e:
         msg = (
-            'UNKNOWN hp[a]sm daemon not found running, cannot run hplog: '
-            '{}'.format(e.output)
+            "UNKNOWN hp[a]sm daemon not found running, cannot run hplog: "
+            "{}".format(e.output)
         )
         exit = 3
     else:
         errors = []
-        for flag in ARGS.hplog_flags.split(','):
+        for flag in ARGS.hplog_flags.split(","):
             log_output = call_hplog(flag)
             if log_output:
                 errors.append(log_output)
 
         if len(errors) > 0:
-            msg = ('CRIT {} error(s): {}'
-                   ''.format(len(errors), ' - '.join(errors)))
+            msg = "CRIT {} error(s): {}".format(len(errors), " - ".join(errors))
             exit = 2
         else:
-            msg = 'OK No errors found'
+            msg = "OK No errors found"
             exit = 0
 
     if ARGS.write:
-        with open(ARGS.write, 'w') as f:
+        with open(ARGS.write, "w") as f:
             f.write(msg)
     else:
         print(msg)
     sys.exit(exit)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/files/ilorest/check_ilorest.py b/src/files/ilorest/check_ilorest.py
index 430c632..8b477c8 100755
--- a/src/files/ilorest/check_ilorest.py
+++ b/src/files/ilorest/check_ilorest.py
@@ -10,10 +10,7 @@
 
 from optparse import OptionParser
 
-from nagios_plugin3 import (check_file_freshness,
-                            try_check,
-                            WarnError,
-                            CriticalError)
+from nagios_plugin3 import check_file_freshness, try_check, WarnError, CriticalError
 
 
 ###############################################################################
@@ -52,16 +49,16 @@ def main():
         help="freshness time limit [default=%default]",
         metavar="SECONDS",
         default=1200,
-        type=int
+        type=int,
     )
     parser.add_option(
-        "-f", "--filename",
+        "-f",
+        "--filename",
         dest="input_file",
-        help=('file containing the output of '
-              'cron_ilorest.py [default=%default]'),
+        help=("file containing the output of cron_ilorest.py [default=%default]"),
         metavar="FILE",
         default="/var/lib/nagios/ilorest.nagios",
-        type=str
+        type=str,
     )
 
     (opts, args) = parser.parse_args()
diff --git a/src/files/ilorest/cron_ilorest.py b/src/files/ilorest/cron_ilorest.py
index 739438d..561d0aa 100755
--- a/src/files/ilorest/cron_ilorest.py
+++ b/src/files/ilorest/cron_ilorest.py
@@ -18,7 +18,7 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
@@ -26,16 +26,16 @@ except ImportError:
 
 
 DEFAULT_SELECTORS = [
-    'Chassis',
-    'HpeSmartStorage',
-    'Memory',
-    'Power',
-    'Processor',
-    'Thermal',
+    "Chassis",
+    "HpeSmartStorage",
+    "Memory",
+    "Power",
+    "Processor",
+    "Thermal",
 ]
 
-EXCLUDE_FILE = '/etc/nagios/cron_ilorest.exclude.yaml'
-OUTPUT_FILE = '/var/lib/nagios/ilorest.nagios'
+EXCLUDE_FILE = "/etc/nagios/cron_ilorest.exclude.yaml"
+OUTPUT_FILE = "/var/lib/nagios/ilorest.nagios"
 
 
 class CronILOrest:
@@ -44,62 +44,64 @@ class CronILOrest:
 
     def parse_args(self, argv=None):
         parser = HPArgumentParser(
-            prog='cron_ilorest',
-            description=('Convert the output of ilorest into an appropriate '
-                         'Nagios status line'),
+            prog="cron_ilorest",
+            description=(
+                "Convert the output of ilorest into an appropriate "
+                "Nagios status line"
+            ),
             def_write_file=OUTPUT_FILE,
-            def_exclude_file=EXCLUDE_FILE
+            def_exclude_file=EXCLUDE_FILE,
         )
 
         parser.add_argument(
-            '--selectors', dest='selectors', type=str, nargs='+',
+            "--selectors",
+            dest="selectors",
+            type=str,
+            nargs="+",
             default=DEFAULT_SELECTORS,
-            help='iLO selectors to run',
+            help="iLO selectors to run",
         )
 
         return parser.parse_args(args=argv)
 
     def check_selector(self, selector):
         if self.args.debug:
-            print('Checking selector {}'.format(selector), file=sys.stderr)
+            print("Checking selector {}".format(selector), file=sys.stderr)
         ilorest_output = self._get_json_ilorest_output(selector)
 
         errors = []
         jsonidx = -1
         # Disregard the first chunk of data, it's banner/debug/etc
-        for jsondata in ilorest_output.split('\n{\n')[1:]:
+        for jsondata in ilorest_output.split("\n{\n")[1:]:
             # The output will be one or more JSON defs
             jsonidx += 1
-            j = json.loads('{' + jsondata)
+            j = json.loads("{" + jsondata)
             errors += self._walk_selector(j, [selector, str(jsonidx)])
         return errors
 
     def _get_json_ilorest_output(self, selector):
-        cmd = ['ilorest', 'list', '-j', '--selector={}'.format(selector)]
-        return check_output(cmd).decode('UTF-8')
+        cmd = ["ilorest", "list", "-j", "--selector={}".format(selector)]
+        return check_output(cmd).decode("UTF-8")
 
     def _get_health_status_message(self, j, crumb_trail=[]):
-        desc = j['Name']
-        if 'SerialNumber' in j:
-            desc += ' ({})'.format(j['SerialNumber'])
-        state = j.get('Status', 'null').get('State', 'unknown')
-        health = j.get('Status', 'null').get('Health', 'unknown')
-        msg = '{} ({}): {} health {}'.format(' '.join(crumb_trail),
-                                             desc,
-                                             state,
-                                             health)
+        desc = j["Name"]
+        if "SerialNumber" in j:
+            desc += " ({})".format(j["SerialNumber"])
+        state = j.get("Status", "null").get("State", "unknown")
+        health = j.get("Status", "null").get("Health", "unknown")
+        msg = "{} ({}): {} health {}".format(" ".join(crumb_trail), desc, state, health)
         if self.args.debug:
             print(msg, file=sys.stderr)
 
         if msg in self.args.exclude and self.args.debug:
-            print('Ignoring excluded error: {}'.format(msg), file=sys.stderr)
+            print("Ignoring excluded error: {}".format(msg), file=sys.stderr)
             return []
         else:
             return [msg]
 
     def _walk_selector(self, j, crumb_trail=[]):
         errors = []
-        if j.get('Status') and j.get('Status').get('Health') != 'OK':
+        if j.get("Status") and j.get("Status").get("Health") != "OK":
             errors.extend(self._get_health_status_message(j, crumb_trail))
 
         for keyname in j.keys():
@@ -110,31 +112,31 @@ class CronILOrest:
             for i in range(len(j[keyname])):
                 if type(j[keyname][i]) != dict:
                     continue
-                if 'Status' not in j[keyname][i]:
+                if "Status" not in j[keyname][i]:
                     continue
-                self._walk_selector(j[keyname][i],
-                                    (crumb_trail + [keyname, str(i)]))
+                self._walk_selector(j[keyname][i], (crumb_trail + [keyname, str(i)]))
         return errors
 
 
 def main(argv=None):
     cronilorest = CronILOrest(argv)
 
-    errors = [cronilorest.check_selector(selector)
-              for selector in cronilorest.args.selectors]
+    errors = [
+        cronilorest.check_selector(selector) for selector in cronilorest.args.selectors
+    ]
 
     if len(errors) > 0:
-        msg = 'CRIT {} error(s): {}'.format(len(errors), ' - '.join(errors))
+        msg = "CRIT {} error(s): {}".format(len(errors), " - ".join(errors))
         exit = 2
     else:
-        msg = 'OK No errors found'
+        msg = "OK No errors found"
         exit = 0
 
     if cronilorest.args.write:
-        if cronilorest.args.write == '-':
+        if cronilorest.args.write == "-":
             print(msg)
         else:
-            with open(cronilorest.args.write, 'w') as f:
+            with open(cronilorest.args.write, "w") as f:
                 f.write(msg)
     else:
         # This should never happen since 'write' has a default value
@@ -142,5 +144,5 @@ def main(argv=None):
     sys.exit(exit)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/ipmi/check_ipmi.py b/src/files/ipmi/check_ipmi.py
index fafd774..1fbe34c 100644
--- a/src/files/ipmi/check_ipmi.py
+++ b/src/files/ipmi/check_ipmi.py
@@ -3,36 +3,42 @@
 
 import os
 
-from nagios_plugin3 import CriticalError, UnknownError, WarnError, check_file_freshness, try_check
-
-OUTPUT_FILE = '/var/lib/nagios/ipmi_sensors.out'
+from nagios_plugin3 import (
+    CriticalError,
+    UnknownError,
+    WarnError,
+    check_file_freshness,
+    try_check,
+)
+
+OUTPUT_FILE = "/var/lib/nagios/ipmi_sensors.out"
 NAGIOS_ERRORS = {
-    'CRITICAL': CriticalError,
-    'UNKNOWN': UnknownError,
-    'WARNING': WarnError,
+    "CRITICAL": CriticalError,
+    "UNKNOWN": UnknownError,
+    "WARNING": WarnError,
 }
 
 
 def parse_output():
     if not os.path.exists(OUTPUT_FILE):
-        raise UnknownError('UNKNOWN: {} does not exist (yet?)'.format(OUTPUT_FILE))
+        raise UnknownError("UNKNOWN: {} does not exist (yet?)".format(OUTPUT_FILE))
 
     # Check if file is newer than 10min
     try_check(check_file_freshness, OUTPUT_FILE)
 
     try:
-        with open(OUTPUT_FILE, 'r') as fd:
+        with open(OUTPUT_FILE, "r") as fd:
             output = fd.read()
     except PermissionError as error:
         raise UnknownError(error)
 
     for startline in NAGIOS_ERRORS:
-        if output.startswith('{}: '.format(startline)):
+        if output.startswith("{}: ".format(startline)):
             func = NAGIOS_ERRORS[startline]
             raise func(output)
 
-    print('OK: {}'.format(output))
+    print("OK: {}".format(output))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     try_check(parse_output)
diff --git a/src/files/ipmi/cron_ipmi_sensors.py b/src/files/ipmi/cron_ipmi_sensors.py
index 2b6cdd5..aa3430d 100644
--- a/src/files/ipmi/cron_ipmi_sensors.py
+++ b/src/files/ipmi/cron_ipmi_sensors.py
@@ -4,20 +4,20 @@ import os
 import subprocess
 import sys
 
-CHECK_IPMI_PID = '/var/run/nagios/check_ipmi_sensors.pid'
-OUTPUT_FILE = '/var/lib/nagios/ipmi_sensors.out'
-TMP_OUTPUT_FILE = OUTPUT_FILE + '.tmp'
-CMD = '/usr/local/lib/nagios/plugins/check_ipmi_sensor'
+CHECK_IPMI_PID = "/var/run/nagios/check_ipmi_sensors.pid"
+OUTPUT_FILE = "/var/lib/nagios/ipmi_sensors.out"
+TMP_OUTPUT_FILE = OUTPUT_FILE + ".tmp"
+CMD = "/usr/local/lib/nagios/plugins/check_ipmi_sensor"
 NAGIOS_ERRORS = {
-    1: 'WARNING',
-    2: 'CRITICAL',
-    3: 'UNKNOWN',
+    1: "WARNING",
+    2: "CRITICAL",
+    3: "UNKNOWN",
 }
 
 
 def write_output_file(output):
     try:
-        with open(TMP_OUTPUT_FILE, 'w') as fd:
+        with open(TMP_OUTPUT_FILE, "w") as fd:
             fd.write(output)
     except IOError as e:
         print("Cannot write output file {}, error {}".format(TMP_OUTPUT_FILE, e))
@@ -29,16 +29,16 @@ def gather_metrics():
     # Check if a PID file exists
     if os.path.exists(CHECK_IPMI_PID):
         # is the PID valid?
-        with open(CHECK_IPMI_PID, 'r') as fd:
+        with open(CHECK_IPMI_PID, "r") as fd:
             PID = fd.read()
-        if PID not in os.listdir('/proc'):
+        if PID not in os.listdir("/proc"):
             # PID file is invalid, remove it
             os.remove(CHECK_IPMI_PID)
         else:
             return
 
     try:
-        with open(CHECK_IPMI_PID, 'w') as fd:
+        with open(CHECK_IPMI_PID, "w") as fd:
             fd.write(str(os.getpid()))
     except IOError as e:
         # unable to write PID file, can't lock
@@ -49,17 +49,17 @@ def gather_metrics():
     if len(sys.argv) > 1:
         cmdline.extend(sys.argv[1:])
     try:
-        output = subprocess.check_output(cmdline).decode('utf8')
+        output = subprocess.check_output(cmdline).decode("utf8")
         write_output_file(output)
     except subprocess.CalledProcessError as error:
-        output = error.stdout.decode(errors='ignore')
-        write_output_file('{}: {}'.format(NAGIOS_ERRORS[error.returncode], output))
+        output = error.stdout.decode(errors="ignore")
+        write_output_file("{}: {}".format(NAGIOS_ERRORS[error.returncode], output))
     except PermissionError as error:
-        write_output_file('UNKNOWN: {}'.format(error))
+        write_output_file("UNKNOWN: {}".format(error))
 
     # remove pid reference
     os.remove(CHECK_IPMI_PID)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     gather_metrics()
diff --git a/src/files/mdadm/check_mdadm.py b/src/files/mdadm/check_mdadm.py
index 29a82c6..c602877 100755
--- a/src/files/mdadm/check_mdadm.py
+++ b/src/files/mdadm/check_mdadm.py
@@ -12,38 +12,33 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
     from hw_health_lib import HWCheckArgumentParser
 
-INPUT_FILE = '/var/lib/nagios/mdadm.out'
+INPUT_FILE = "/var/lib/nagios/mdadm.out"
 ARGS = argparse.Namespace()
 
 
 def parse_output():
     if not os.path.exists(ARGS.input_file):
-        raise UnknownError(
-            'UNKNOWN: file not found ({})'.format(ARGS.input_file)
-        )
+        raise UnknownError("UNKNOWN: file not found ({})".format(ARGS.input_file))
 
-    with open(ARGS.input_file, 'r') as fd:
+    with open(ARGS.input_file, "r") as fd:
         for line in fd.readlines():
             line = line.strip()
-            if line.startswith('CRITICAL: '):
+            if line.startswith("CRITICAL: "):
                 raise CriticalError(line)
-            elif line.startswith('WARNING: '):
+            elif line.startswith("WARNING: "):
                 raise WarnError(line)
             else:
                 print(line)
 
 
 def parse_args(argv=None):
-    parser = HWCheckArgumentParser(
-        prog='check_mdadm',
-        def_input_file=INPUT_FILE,
-    )
+    parser = HWCheckArgumentParser(prog="check_mdadm", def_input_file=INPUT_FILE)
     return parser.parse_args(args=argv, namespace=ARGS)
 
 
@@ -52,5 +47,5 @@ def main(argv):
     try_check(parse_output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/mdadm/cron_mdadm.py b/src/files/mdadm/cron_mdadm.py
index 3e7e8e9..fed9ea8 100755
--- a/src/files/mdadm/cron_mdadm.py
+++ b/src/files/mdadm/cron_mdadm.py
@@ -13,7 +13,7 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
@@ -25,22 +25,20 @@ ARGS = argparse.Namespace()
 
 
 def get_devices():
-    if os.path.exists('/sbin/mdadm'):
+    if os.path.exists("/sbin/mdadm"):
         try:
             cmd = ["/sbin/mdadm", "--detail", "--scan"]
             devices_raw = subprocess.check_output(cmd)
             devices_re = re.compile(r"^ARRAY\s+([^ ]+) ")
             devices = set()
-            for line in devices_raw.decode().split('\n'):
+            for line in devices_raw.decode().split("\n"):
                 line = line.strip()
                 device_re = devices_re.match(line)
                 if device_re is not None:
                     devices.add(device_re.group(1))
             return devices
         except subprocess.CalledProcessError as error:
-            rc = generate_output(
-                "CRITICAL: get_devices error - {}".format(error)
-            )
+            rc = generate_output("CRITICAL: get_devices error - {}".format(error))
             if rc:
                 sys.exit(0)
     return set()
@@ -48,28 +46,28 @@ def get_devices():
 
 def generate_output(msg):
     try:
-        with open(TEMP_FILE, 'w') as fd:
+        with open(TEMP_FILE, "w") as fd:
             fd.write(msg)
         shutil.move(TEMP_FILE, ARGS.write)
         return True
     except Exception as error:
-        print('Unable to generate output file:', error)
+        print("Unable to generate output file:", error)
         return False
 
 
 def get_devices_stats(devices):
-    mdadm_detail = ['/sbin/mdadm', '--detail']
+    mdadm_detail = ["/sbin/mdadm", "--detail"]
     mdadm_detail.extend(sorted(devices))
 
     devices_details_raw = subprocess.check_output(mdadm_detail)
 
-    devices_re = r'^(/\S+):$'
-    state_re = r'^\s*State\s+:\s+(.+)\s*$'
-    status_re = r'^\s*(Active|Working|Failed|Spare) Devices\s+:\s+(\d+)$'
-    rebuild_status_re = r'^\s*Rebuild Status\s+:\s+(\d+%\s+\S+)$'
-    removed_re = r'^\s*-\s+0\s+0\s+(\d+)\s+removed$'
+    devices_re = r"^(/\S+):$"
+    state_re = r"^\s*State\s+:\s+(.+)\s*$"
+    status_re = r"^\s*(Active|Working|Failed|Spare) Devices\s+:\s+(\d+)$"
+    rebuild_status_re = r"^\s*Rebuild Status\s+:\s+(\d+%\s+\S+)$"
+    removed_re = r"^\s*-\s+0\s+0\s+(\d+)\s+removed$"
     #        4 8 162 3 spare rebuilding /dev/sdk2
-    rebuilding_re = r'^\s*\d+\s+\d+\s+\d+\s+\d+\s+\S+\s+rebuilding\s+(\S+)$'
+    rebuilding_re = r"^\s*\d+\s+\d+\s+\d+\s+\d+\s+\S+\s+rebuilding\s+(\S+)$"
 
     devices_cre = re.compile(devices_re)
     state_cre = re.compile(state_re)
@@ -80,54 +78,50 @@ def get_devices_stats(devices):
 
     device = None
     devices_stats = {}
-    for line in devices_details_raw.decode().split('\n'):
+    for line in devices_details_raw.decode().split("\n"):
         line = line.rstrip()
         m = devices_cre.match(line)
         if m:
             device = m.group(1)
             devices_stats[device] = {
-                'stats': {
-                    'Active': 0,
-                    'Working': 0,
-                    'Failed': 0,
-                    'Spare': 0,
-                },
-                'rebuild_status': '',
-                'degraded': False,
-                'recovering': False,
-                'removed': [],
-                'rebuilding': [],
+                "stats": {"Active": 0, "Working": 0, "Failed": 0, "Spare": 0},
+                "rebuild_status": "",
+                "degraded": False,
+                "recovering": False,
+                "removed": [],
+                "rebuilding": [],
             }
             continue
 
         m = state_cre.match(line)
         if m:
-            # format for State line can be "clean" or "clean, degraded" or "active, degraded, rebuilding", etc.
+            # format for State line can be "clean" or "clean, degraded",
+            # or "active, degraded, rebuilding", etc.
             states = m.group(1).split(", ")
-            if 'degraded' in states and device:
-                devices_stats[device]['degraded'] = True
-            if 'recovering' in states and device:
-                devices_stats[device]['recovering'] = True
+            if "degraded" in states and device:
+                devices_stats[device]["degraded"] = True
+            if "recovering" in states and device:
+                devices_stats[device]["recovering"] = True
             continue
 
         m = status_cre.match(line)
         if m and device:
-            devices_stats[device]['stats'][m.group(1)] = int(m.group(2))
+            devices_stats[device]["stats"][m.group(1)] = int(m.group(2))
             continue
 
         m = removed_cre.match(line)
         if m and device:
-            devices_stats[device]['removed'].append(m.group(1))
+            devices_stats[device]["removed"].append(m.group(1))
             continue
 
         m = rebuild_status_cre.match(line)
         if m and device:
-            devices_stats[device]['rebuild_status'] = m.group(1)
+            devices_stats[device]["rebuild_status"] = m.group(1)
             continue
 
         m = rebuilding_cre.match(line)
         if m and device:
-            devices_stats[device]['rebuilding'].append(m.group(1))
+            devices_stats[device]["rebuilding"].append(m.group(1))
             continue
 
     return devices_stats
@@ -136,14 +130,12 @@ def get_devices_stats(devices):
 def parse_output():  # noqa:C901
     devices = get_devices()
     if len(devices) == 0:
-        return generate_output('WARNING: unexpectedly checked no devices')
+        return generate_output("WARNING: unexpectedly checked no devices")
 
     try:
         devices_stats = get_devices_stats(devices)
     except subprocess.CalledProcessError as error:
-        return generate_output(
-            "WARNING: error executing mdadm: {}".format(error)
-        )
+        return generate_output("WARNING: error executing mdadm: {}".format(error))
 
     msg = []
     critical = False
@@ -151,51 +143,50 @@ def parse_output():  # noqa:C901
     for device in devices_stats:
         parts = []
         # Is device degraded?
-        if devices_stats[device]['degraded'] and devices_stats[device]['recovering']:
+        if devices_stats[device]["degraded"] and devices_stats[device]["recovering"]:
             warning = True
-            parts = ['{} recovering'.format(device)]
-        elif devices_stats[device]['degraded']:
+            parts = ["{} recovering".format(device)]
+        elif devices_stats[device]["degraded"]:
             critical = True
-            parts = ['{} degraded'.format(device)]
+            parts = ["{} degraded".format(device)]
         else:
-            parts = ['{} ok'.format(device)]
+            parts = ["{} ok".format(device)]
 
         # If Failed drives are found, list counters (how many?)
-        failed_cnt = devices_stats[device]['stats'].get('Failed', 0)
+        failed_cnt = devices_stats[device]["stats"].get("Failed", 0)
         if failed_cnt > 0:
             critical = True
             dev_stats = [
-                '{}[{}]'.format(status, devices_stats[device]['stats'][status])
-                for status in sorted(devices_stats[device]['stats'])
+                "{}[{}]".format(status, devices_stats[device]["stats"][status])
+                for status in sorted(devices_stats[device]["stats"])
             ]
             parts.extend(dev_stats)
 
-        if len(devices_stats[device]['removed']) != 0:
+        if len(devices_stats[device]["removed"]) != 0:
             critical = True
-            members = " and ".join(devices_stats[device]['removed'])
-            parts.append('RaidDevice(s) {} marked removed'.format(members))
-
-        if len(devices_stats[device]['rebuilding']) != 0:
-            rebuilding_members = " ".join(devices_stats[device]['rebuilding'])
-            rebuild_status = devices_stats[device]['rebuild_status']
-            parts.append('{} rebuilding ({})'.format(rebuilding_members, rebuild_status))
+            members = " and ".join(devices_stats[device]["removed"])
+            parts.append("RaidDevice(s) {} marked removed".format(members))
+
+        if len(devices_stats[device]["rebuilding"]) != 0:
+            rebuilding_members = " ".join(devices_stats[device]["rebuilding"])
+            rebuild_status = devices_stats[device]["rebuild_status"]
+            parts.append(
+                "{} rebuilding ({})".format(rebuilding_members, rebuild_status)
+            )
 
-        msg.append(', '.join(parts))
+        msg.append(", ".join(parts))
 
     if critical:
-        msg = 'CRITICAL: {}'.format('; '.join(msg))
+        msg = "CRITICAL: {}".format("; ".join(msg))
     elif warning:
-        msg = 'WARNING: {}'.format('; '.join(msg))
+        msg = "WARNING: {}".format("; ".join(msg))
     else:
-        msg = 'OK: {}'.format('; '.join(msg))
+        msg = "OK: {}".format("; ".join(msg))
     return generate_output(msg)
 
 
 def parse_args(argv=None):
-    parser = HWCronArgumentParser(
-        prog='cron_mdadm',
-        def_write_file=OUTPUT_FILE,
-    )
+    parser = HWCronArgumentParser(prog="cron_mdadm", def_write_file=OUTPUT_FILE)
     return parser.parse_args(args=argv, namespace=ARGS)
 
 
diff --git a/src/files/megacli/check_megacli.py b/src/files/megacli/check_megacli.py
index b587d10..03d3a5d 100755
--- a/src/files/megacli/check_megacli.py
+++ b/src/files/megacli/check_megacli.py
@@ -13,55 +13,54 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
     from hw_health_lib import HWCheckArgumentParser
 
-INPUT_FILE = '/var/lib/nagios/megacli.out'
+INPUT_FILE = "/var/lib/nagios/megacli.out"
 ARGS = argparse.Namespace()
 
 
-def handle_results(
-    nlines, match, critical, errors, num_ldrive, num_pdrive, policy
-):
+def handle_results(nlines, match, critical, errors, num_ldrive, num_pdrive, policy):
     if nlines == 0:
-        raise WarnError('WARNING: controller not found')
+        raise WarnError("WARNING: controller not found")
     elif not match:
-        raise WarnError('WARNING: error parsing megacli output')
+        raise WarnError("WARNING: error parsing megacli output")
     elif critical:
         if len(errors) > 0:
-            msg = ', '.join([
-                '{}({})'.format(cnt, vars()[cnt])
-                for cnt in ('failed_ld', 'wrg_policy_ld')
-                if vars().get(cnt, 0) > 0
-            ])
-            msg += '; '.join(errors)
+            msg = ", ".join(
+                [
+                    "{}({})".format(cnt, vars()[cnt])
+                    for cnt in ("failed_ld", "wrg_policy_ld")
+                    if vars().get(cnt, 0) > 0
+                ]
+            )
+            msg += "; ".join(errors)
         else:
-            msg = 'failure caught but no output available'
-        raise CriticalError('CRITICAL: {}'.format(msg))
+            msg = "failure caught but no output available"
+        raise CriticalError("CRITICAL: {}".format(msg))
     elif len(errors) > 0:
-        raise WarnError('WARNING: {}'.format('; '.join(errors)))
+        raise WarnError("WARNING: {}".format("; ".join(errors)))
 
     else:
         if num_ldrive == 0:
-            msg = 'OK: no disks configured for RAID'
+            msg = "OK: no disks configured for RAID"
         else:
-            msg = ('OK: Optimal, ldrives[{}], pdrives[{}]'
-                   ''.format(num_ldrive, num_pdrive))
+            msg = "OK: Optimal, ldrives[{}], pdrives[{}]".format(num_ldrive, num_pdrive)
             if policy:
-                msg += ', policy[{}]'.format(policy)
+                msg += ", policy[{}]".format(policy)
         print(msg)
 
 
 def parse_output(policy=False):  # noqa:C901
-    noadapter_re = r'^Adapter \d+: No Virtual Drive Configured'
-    adapter_re = r'^Adapter (\d+) -- Virtual Drive Information:'
-    ldrive_re = r'^Virtual Drive\s*:\s+(\d+)'
-    state_re = r'^State\s*:\s+([^\n]+)'
-    npdrives_re = r'^Number Of Drives(?: per span)?\s*:\s+(\d+)'
-    w_policy_re = r'^Current Cache Policy\s*:\s+([^,]+)'
+    noadapter_re = r"^Adapter \d+: No Virtual Drive Configured"
+    adapter_re = r"^Adapter (\d+) -- Virtual Drive Information:"
+    ldrive_re = r"^Virtual Drive\s*:\s+(\d+)"
+    state_re = r"^State\s*:\s+([^\n]+)"
+    npdrives_re = r"^Number Of Drives(?: per span)?\s*:\s+(\d+)"
+    w_policy_re = r"^Current Cache Policy\s*:\s+([^,]+)"
 
     noadapter_cre = re.compile(noadapter_re)
     adapter_cre = re.compile(adapter_re)
@@ -78,7 +77,7 @@ def parse_output(policy=False):  # noqa:C901
 
     with open(ARGS.input_file) as devices_raw:
         for line in devices_raw.readlines():
-            if len(line.strip()) and not line.startswith('Exit Code'):
+            if len(line.strip()) and not line.startswith("Exit Code"):
                 nlines += 1
 
             if noadapter_cre.match(line):
@@ -101,10 +100,11 @@ def parse_output(policy=False):  # noqa:C901
             if m:
                 num_ldrive += 1
                 state = m.group(1)
-                if state != 'Optimal':
+                if state != "Optimal":
                     failed_ld += 1
-                    msg = 'adapter({}):ld({}):state({})'.format(
-                        adapter_id, ldrive_id, state)
+                    msg = "adapter({}):ld({}):state({})".format(
+                        adapter_id, ldrive_id, state
+                    )
                     errors.append(msg)
                     critical = True
                 continue
@@ -120,22 +120,18 @@ def parse_output(policy=False):  # noqa:C901
                     w_policy = m.group(1)
                     if w_policy != policy:
                         wrg_policy_ld += 1
-                        msg = 'adp({}):ld({}):policy({})'.format(
-                            adapter_id, ldrive_id, w_policy)
+                        msg = "adp({}):ld({}):policy({})".format(
+                            adapter_id, ldrive_id, w_policy
+                        )
                         errors.append(msg)
                         critical = True
                     continue
 
-    handle_results(
-        nlines, match, critical, errors, num_ldrive, num_pdrive, policy
-    )
+    handle_results(nlines, match, critical, errors, num_ldrive, num_pdrive, policy)
 
 
 def parse_args(argv=None):
-    parser = HWCheckArgumentParser(
-        prog='check_megacli',
-        def_input_file=INPUT_FILE,
-    )
+    parser = HWCheckArgumentParser(prog="check_megacli", def_input_file=INPUT_FILE)
     return parser.parse_args(args=argv, namespace=ARGS)
 
 
@@ -144,5 +140,5 @@ def main(argv, policy=False):
     try_check(parse_output, policy)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/nvme/check_nvme.py b/src/files/nvme/check_nvme.py
index d4117c9..701bc9c 100755
--- a/src/files/nvme/check_nvme.py
+++ b/src/files/nvme/check_nvme.py
@@ -8,55 +8,64 @@ import re
 import subprocess
 from nagios_plugin3 import CriticalError, try_check, UnknownError
 
-NVME_RE = re.compile(r'^/dev/nvme\d+$')
+NVME_RE = re.compile(r"^/dev/nvme\d+$")
 
 
 def parse_output():
     keymap = {}
     critical = False
     alloutputs = []
-    for device in glob.glob('/dev/nvme*'):
+    for device in glob.glob("/dev/nvme*"):
         if not NVME_RE.match(device):
             continue
         try:
-            output = subprocess.check_output(['sudo', '/usr/sbin/nvme',
-                                              'smart-log', device])
+            output = subprocess.check_output(
+                ["sudo", "/usr/sbin/nvme", "smart-log", device]
+            )
         except subprocess.CalledProcessError as error:
-            print('nvme check error: {}'.format(error))
+            print("nvme check error: {}".format(error))
             return
 
-        for line in output.decode(errors='ignore').splitlines():
-            datavalues_re = re.match(r'^(\w+)\s+:\s+([\d.]+)', line.strip())
+        for line in output.decode(errors="ignore").splitlines():
+            datavalues_re = re.match(r"^(\w+)\s+:\s+([\d.]+)", line.strip())
             if not datavalues_re:
                 continue
             key, value = datavalues_re.groups()
-            keymap[key] = value.replace('.', '')
+            keymap[key] = value.replace(".", "")
 
-        if int(keymap['critical_warning']) != 0:
-            status = ('CRITICAL: {} critical_warning is {}'
-                      '').format(device, keymap['critical_warning'])
+        if int(keymap["critical_warning"]) != 0:
+            status = ("CRITICAL: {} critical_warning is {}").format(
+                device, keymap["critical_warning"]
+            )
             critical = True
         else:
-            status = 'OK: no errors on {}'.format(device)
+            status = "OK: no errors on {}".format(device)
 
-        alloutputs.append('{} | {}'.format(
-            status, ' '.join(['{}={}'.format(repr(key), value)
-                              for key, value in keymap.items()])))
+        alloutputs.append(
+            "{} | {}".format(
+                status,
+                " ".join(
+                    ["{}={}".format(repr(key), value) for key, value in keymap.items()]
+                ),
+            )
+        )
 
     if critical:
-        raise CriticalError('\n'.join(alloutputs))
+        raise CriticalError("\n".join(alloutputs))
 
     if not alloutputs:
-        raise UnknownError('no nvme devices found')
+        raise UnknownError("no nvme devices found")
 
-    print('\n'.join(alloutputs))
+    print("\n".join(alloutputs))
 
 
 def parse_args(argv=None):
     parser = argparse.ArgumentParser(
-        prog='check_nvme',
-        description=('this program reads the nvme smart-log and outputs an '
-                     'appropriate Nagios status line'),
+        prog="check_nvme",
+        description=(
+            "this program reads the nvme smart-log and outputs an "
+            "appropriate Nagios status line"
+        ),
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     return parser.parse_args(argv)
@@ -67,5 +76,5 @@ def main(argv):
     try_check(parse_output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/sas2ircu/check_sas2ircu.py b/src/files/sas2ircu/check_sas2ircu.py
index b38e131..9628893 100755
--- a/src/files/sas2ircu/check_sas2ircu.py
+++ b/src/files/sas2ircu/check_sas2ircu.py
@@ -13,20 +13,20 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
     from hw_health_lib import HWCheckArgumentParser
 
-INPUT_FILE = '/var/lib/nagios/sas2ircu.out'
+INPUT_FILE = "/var/lib/nagios/sas2ircu.out"
 ARGS = argparse.Namespace()
 
 
 def parse_output():
-    enclosure_re = r'^\s+Enclosure #\s+:\s+(\d+)'
-    slot_re = r'^\s+Slot #\s+:\s+(\d+)'
-    state_re = r'^\s+State\s+:\s+(\S+)'
+    enclosure_re = r"^\s+Enclosure #\s+:\s+(\d+)"
+    slot_re = r"^\s+Slot #\s+:\s+(\d+)"
+    state_re = r"^\s+State\s+:\s+(\S+)"
 
     encl_slot_state_cre = [
         re.compile(enclosure_re),
@@ -47,28 +47,25 @@ def parse_output():
 
             if len(device) == 3:
                 tmpdev = devices.get(device[2], [])
-                tmpdev.append('{}:{}'.format(device[0], device[1]))
+                tmpdev.append("{}:{}".format(device[0], device[1]))
                 devices[device[2]] = tmpdev
-                if not ('Ready' in device or 'Optimal' in device):
+                if not ("Ready" in device or "Optimal" in device):
                     critical = True
                 device = []
 
-    msg = '; '.join([
-        '{}[{}]'.format(state, ','.join(devices[state])) for state in devices
-    ])
-    if msg == '':
-        raise WarnError('WARNING: no output')
+    msg = "; ".join(
+        ["{}[{}]".format(state, ",".join(devices[state])) for state in devices]
+    )
+    if msg == "":
+        raise WarnError("WARNING: no output")
     elif critical:
-        raise CriticalError('CRITICAL: {}'.format(msg))
+        raise CriticalError("CRITICAL: {}".format(msg))
     else:
-        print('OK: {}'.format(msg))
+        print("OK: {}".format(msg))
 
 
 def parse_args(argv=None):
-    parser = HWCheckArgumentParser(
-        prog='check_sas2ircu',
-        def_input_file=INPUT_FILE,
-    )
+    parser = HWCheckArgumentParser(prog="check_sas2ircu", def_input_file=INPUT_FILE)
     return parser.parse_args(args=argv, namespace=ARGS)
 
 
@@ -77,5 +74,5 @@ def main(argv):
     try_check(parse_output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/sas3ircu/check_sas3ircu.py b/src/files/sas3ircu/check_sas3ircu.py
index d62a90f..8b62679 100755
--- a/src/files/sas3ircu/check_sas3ircu.py
+++ b/src/files/sas3ircu/check_sas3ircu.py
@@ -14,182 +14,174 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
     from hw_health_lib import HWCheckArgumentParser
 
-INPUT_FILE = '/var/lib/nagios/sas3ircu.out'
+INPUT_FILE = "/var/lib/nagios/sas3ircu.out"
 ARGS = argparse.Namespace()
 
 
 def parse_output(input_file):
-    '''
+    """
     Turn the whole sas3ircu output into a dictionary
-    '''
+    """
     sections_re = re.compile(
-        r'(?<=^Controller information\n)'
-        r'-+\n'
-        r'(?P<ctrl>(?:.|\n)*)'
-        r'^-+\n'
-        r'^IR Volume information\n'
-        r'-+\n'
-        r'(?P<vols>(?:.|\n)*)'
-        r'^-+\n'
-        r'^Physical device information\n'
-        r'-+\n'
-        r'(?P<disks>(?:.|\n)*)'
-        r'^-+\n'
-        r'^Enclosure information\n'
-        r'-+\n'
-        r'(?P<encl>(?:.|\n)*)'
-        r'^-+\n',
-        re.MULTILINE
+        r"(?<=^Controller information\n)"
+        r"-+\n"
+        r"(?P<ctrl>(?:.|\n)*)"
+        r"^-+\n"
+        r"^IR Volume information\n"
+        r"-+\n"
+        r"(?P<vols>(?:.|\n)*)"
+        r"^-+\n"
+        r"^Physical device information\n"
+        r"-+\n"
+        r"(?P<disks>(?:.|\n)*)"
+        r"^-+\n"
+        r"^Enclosure information\n"
+        r"-+\n"
+        r"(?P<encl>(?:.|\n)*)"
+        r"^-+\n",
+        re.MULTILINE,
     )
     disks_re = re.compile(
-        r'(?<=^Device is a Hard disk\n)(?P<kv_data>(?:.|\n)*?)(?=^$)',
-        re.MULTILINE
+        r"(?<=^Device is a Hard disk\n)(?P<kv_data>(?:.|\n)*?)(?=^$)", re.MULTILINE
     )
 
     with open(input_file) as devices_raw:
         sections = sections_re.search(devices_raw.read()).groupdict()
-        controller = _kv_parse(sections['ctrl'])
-        volumes = _vols_parse(sections['vols'])
+        controller = _kv_parse(sections["ctrl"])
+        volumes = _vols_parse(sections["vols"])
         # This collects disk level information in a structure simulating the
         # physical encl/slot arrangement
         topology = defaultdict(dict)
-        for match in disks_re.findall(sections['disks']):
+        for match in disks_re.findall(sections["disks"]):
             disk = _kv_parse(match)
-            encl = disk['Enclosure #']
-            slot = disk['Slot #']
+            encl = disk["Enclosure #"]
+            slot = disk["Slot #"]
             topology[encl][slot] = disk
-        enclosure = _kv_parse(sections['encl'])
+        enclosure = _kv_parse(sections["encl"])
 
     return {
-        'controller': controller,
-        'volumes': volumes,
-        'disks': topology,
-        'enclosure': enclosure,
+        "controller": controller,
+        "volumes": volumes,
+        "disks": topology,
+        "enclosure": enclosure,
     }
 
 
 def _vols_parse(text):
     vols_re = re.compile(
-        r'^IR volume (?P<n>\d+)\n'
-        r'(?P<kv_data>(?:.|\n)*?)'
-        r'\s+Physical hard disks\s+:.*\n'
-        r'(?P<topology>(?:^\s+PHY.*\n)+)',
-        re.MULTILINE
+        r"^IR volume (?P<n>\d+)\n"
+        r"(?P<kv_data>(?:.|\n)*?)"
+        r"\s+Physical hard disks\s+:.*\n"
+        r"(?P<topology>(?:^\s+PHY.*\n)+)",
+        re.MULTILINE,
     )
     vol_topology_re = re.compile(
-        r'\s+PHY\[(?P<n>\d+)\]\s+Enclosure#\/Slot#\s+'
-        r':\s+(?P<enc>\d+):(?P<slot>\d+)'
+        r"\s+PHY\[(?P<n>\d+)\]\s+Enclosure#\/Slot#\s+" r":\s+(?P<enc>\d+):(?P<slot>\d+)"
     )
     volumes = {}
     for (vol_n, kv_data, vol_topology) in vols_re.findall(text):
         topology = {}
         for (member_n, enc, slot) in vol_topology_re.findall(vol_topology):
-            topology[member_n] = {'enc': enc, 'slot': slot}
-        volumes[vol_n] = {**_kv_parse(kv_data), 'topology': topology}
+            topology[member_n] = {"enc": enc, "slot": slot}
+        volumes[vol_n] = {**_kv_parse(kv_data), "topology": topology}
 
     return volumes
 
 
 def _kv_parse(text):
-    '''
+    """
     Build a dict by parsing text like:
 
       key1     : value1
       key2     : value2
-    '''
-    key_value_re = re.compile(
-        r'^\s*(?P<key>.*?)\s+:\s+(?P<value>.*)'
-    )
+    """
+    key_value_re = re.compile(r"^\s*(?P<key>.*?)\s+:\s+(?P<value>.*)")
     text = text.strip()
     return {
-        m.group('key'): m.group('value')
-        for m in map(key_value_re.search, text.split('\n'))
+        m.group("key"): m.group("value")
+        for m in map(key_value_re.search, text.split("\n"))
     }
 
 
 def eval_status(data):
-    '''
+    """
     Given a dictionary and a set of rules, determine the state of the storage
     subsystem
-    '''
-    OK = 'Okay (OKY)'
-    READY = 'Ready (RDY)'
-    OPTIMAL = 'Optimal (OPT)'
+    """
+    OK = "Okay (OKY)"
+    READY = "Ready (RDY)"
+    OPTIMAL = "Optimal (OPT)"
     status = Status()
 
     # 1. Volumes must be in Okay state
-    for volume in data['volumes'].values():
-        vol_id = volume['Volume ID']
-        vol_status = volume['Status of volume']
+    for volume in data["volumes"].values():
+        vol_id = volume["Volume ID"]
+        vol_status = volume["Status of volume"]
         if vol_status != OK:
             status.crit("Volume {}: {}".format(vol_id, vol_status))
         else:
             # 2. Volume members must be in Optimal state
-            for member in volume['topology'].values():
-                disk = data['disks'][member['enc']][member['slot']]
-                if disk['State'] != OPTIMAL:
+            for member in volume["topology"].values():
+                disk = data["disks"][member["enc"]][member["slot"]]
+                if disk["State"] != OPTIMAL:
                     msg = "Disk {}:{} {}".format(
-                        member['enc'],
-                        member['slot'],
-                        disk['State']
+                        member["enc"], member["slot"], disk["State"]
                     )
-                    if disk['State'] == READY:
+                    if disk["State"] == READY:
                         status.warn(msg)
                     else:
                         status.crit(msg)
     # 3. Disks can be in Optimal or Ready state ("ready" is ok for non-RAID
     # members)
-    for enclosure_id, enclosure in data['disks'].items():
+    for enclosure_id, enclosure in data["disks"].items():
         for slot_id, slot in enclosure.items():
-            if slot['State'] not in [OPTIMAL, READY]:
-                status.crit("Disk {}:{} {}".format(
-                    enclosure_id,
-                    slot_id,
-                    slot['State']
-                ))
+            if slot["State"] not in [OPTIMAL, READY]:
+                status.crit(
+                    "Disk {}:{} {}".format(enclosure_id, slot_id, slot["State"])
+                )
     status.get_status()
 
 
 class Status:
-    '''
+    """
     Class hiding the whole "CRIT >> WARN >> OK" priority scheme
-    '''
-    def __init__(self, status='OK'):
+    """
+
+    def __init__(self, status="OK"):
         self._status = status
         self._msgs = set()
 
     def crit(self, msg):
-        self._status = 'CRITICAL'
+        self._status = "CRITICAL"
         self._msgs.add(msg)
 
     def warn(self, msg):
-        if self._status != 'CRITICAL':
-            self._status = 'WARNING'
+        if self._status != "CRITICAL":
+            self._status = "WARNING"
         self._msgs.add(msg)
 
     def ok(self, msg):
         self._msgs.add(msg)
 
     def get_status(self):
-        '''
+        """
         Render the current status, rasing nagios_plugin3 exceptions if things
         are not OK
-        '''
-        if self._status == 'OK':
-            msg = '{}: no errors'.format(self._status)
+        """
+        if self._status == "OK":
+            msg = "{}: no errors".format(self._status)
             print(msg)
         else:
-            msg = '{}: {}'.format(self._status,
-                                  ' | '.join(self._msgs))
-            if self._status == 'CRITICAL':
+            msg = "{}: {}".format(self._status, " | ".join(self._msgs))
+            if self._status == "CRITICAL":
                 raise CriticalError(msg)
-            elif self._status == 'WARNING':
+            elif self._status == "WARNING":
                 raise WarnError(msg)
             else:
                 # this really shouldn't be happening
@@ -200,10 +192,7 @@ class Status:
 
 
 def parse_args(argv=None):
-    parser = HWCheckArgumentParser(
-        prog='check_sas3ircu',
-        def_input_file=INPUT_FILE,
-    )
+    parser = HWCheckArgumentParser(prog="check_sas3ircu", def_input_file=INPUT_FILE)
     return parser.parse_args(args=argv, namespace=ARGS)
 
 
@@ -213,5 +202,5 @@ def main(argv=None):
     try_check(eval_status, data)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1:])
diff --git a/src/files/ssacli/cron_ssacli.py b/src/files/ssacli/cron_ssacli.py
index 94c7ef7..eadd711 100755
--- a/src/files/ssacli/cron_ssacli.py
+++ b/src/files/ssacli/cron_ssacli.py
@@ -25,7 +25,7 @@ try:
 except ImportError:
     # shared lib will be under $CHARM_SOURCE_DIR/files/common during unit tests
     common_libs_dir = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), '..', 'common')
+        os.path.join(os.path.dirname(__file__), "..", "common")
     )
     if common_libs_dir not in sys.path:
         sys.path.append(common_libs_dir)
@@ -37,16 +37,14 @@ except ImportError:
         HPArgumentParser,
     )
 
-SSACLI_BIN = '/opt/smartstorageadmin/ssacli/bin/ssacli'
-OUTPUT_FILE = '/var/lib/nagios/ssacli.out'
-EXCLUDE_FILE = '/etc/nagios/ssacli.exclude.yaml'
+SSACLI_BIN = "/opt/smartstorageadmin/ssacli/bin/ssacli"
+OUTPUT_FILE = "/var/lib/nagios/ssacli.out"
+EXCLUDE_FILE = "/etc/nagios/ssacli.exclude.yaml"
 
 
 def parse_args(argv=None):
     parser = HPArgumentParser(
-        prog='cron_ssacli',
-        def_write_file=OUTPUT_FILE,
-        def_exclude_file=EXCLUDE_FILE
+        prog="cron_ssacli", def_write_file=OUTPUT_FILE, def_exclude_file=EXCLUDE_FILE
     )
     return parser.parse_args(args=argv)
 
@@ -60,38 +58,46 @@ def check_array(slot):
     physicaldrive 1:1 (box 1:bay 1, 72 GB): OK
     physicaldrive 1:2 (box 1:bay 2, 72 GB): OK
     """
-    if os.path.isfile('/etc/nagios/skip-cat-hp-array.txt'):
+    if os.path.isfile("/etc/nagios/skip-cat-hp-array.txt"):
         return
 
     cmd = (
-        '{ssacli} ctrl slot={slot} ld all show status; '
-        '{ssacli} ctrl slot={slot} pd all show status'.format(ssacli=SSACLI_BIN, slot=slot)
+        "{ssacli} ctrl slot={slot} ld all show status; "
+        "{ssacli} ctrl slot={slot} pd all show status".format(
+            ssacli=SSACLI_BIN, slot=slot
+        )
     )
     try:
-        result = subprocess.check_output(cmd, shell=True).decode('UTF-8')
+        result = subprocess.check_output(cmd, shell=True).decode("UTF-8")
         return _parse_array_output(result)
     except subprocess.CalledProcessError as e:
         return (
-            'UNKNOWN Call to ssacli to show ld/pd info failed. '
-            'Array Slot {} - Return Code {} - {}'
-            ''.format(slot, e.returncode, e.output)
+            "UNKNOWN Call to ssacli to show ld/pd info failed. "
+            "Array Slot {} - Return Code {} - {}"
+            "".format(slot, e.returncode, e.output)
         )
 
 
 def _parse_array_output(output):
-    innocuous_errors = re.compile(r'^Error: The specified (device|controller) '
-                                  'does not have any (logical|physical)')
-    drive_status_line = re.compile(r'^\s*(logicaldrive|physicaldrive)')
-    ignore_file = '/etc/nagios/ignores/ignores-cat-hp-array.txt'
+    innocuous_errors = re.compile(
+        r"^Error: The specified (device|controller) "
+        "does not have any (logical|physical)"
+    )
+    drive_status_line = re.compile(r"^\s*(logicaldrive|physicaldrive)")
+    ignore_file = "/etc/nagios/ignores/ignores-cat-hp-array.txt"
     ignores = read_ignore_file(ignore_file)
 
     for line in output.splitlines():
         line = line.strip()
-        if not line or innocuous_errors.search(line) or not drive_status_line.search(line):
+        if (
+            not line
+            or innocuous_errors.search(line)
+            or not drive_status_line.search(line)
+        ):
             continue
         (drivetype, number) = line.split()[:2]
-        status = line.split('):')[1].lstrip().upper()
-        if status != 'OK':
+        status = line.split("):")[1].lstrip().upper()
+        if status != "OK":
             err = '{} {} is "{}"'.format(drivetype, number, status)
             if not ignore(err, ignores):
                 return err
@@ -107,24 +113,24 @@ def check_controller(slot):
       Cache Status: OK
       Battery Status: Failed (Replace Batteries)
     """
-    if os.path.isfile('/etc/nagios/skip-cat-hp-controller.txt'):
+    if os.path.isfile("/etc/nagios/skip-cat-hp-controller.txt"):
         return
 
-    cmd = '{ssacli} ctrl slot={slot} show status'.format(ssacli=SSACLI_BIN, slot=slot)
+    cmd = "{ssacli} ctrl slot={slot} show status".format(ssacli=SSACLI_BIN, slot=slot)
     try:
-        result = subprocess.check_output(cmd, shell=True).decode('UTF-8')
+        result = subprocess.check_output(cmd, shell=True).decode("UTF-8")
         return _parse_controller_output(result)
     except subprocess.CalledProcessError as e:
         return (
-            'UNKNOWN Call to ssacli to show ld/pd info failed. '
-            'Array Slot {} - Return Code {} - {}'
-            ''.format(slot, e.returncode, e.output)
+            "UNKNOWN Call to ssacli to show ld/pd info failed. "
+            "Array Slot {} - Return Code {} - {}"
+            "".format(slot, e.returncode, e.output)
         )
 
 
 def _parse_controller_output(output):
     controller = "Unknown"
-    ignore_file = '/etc/nagios/ignores/ignores-cat-hp-controller.txt'
+    ignore_file = "/etc/nagios/ignores/ignores-cat-hp-controller.txt"
     ignores = read_ignore_file(ignore_file)
     for line in output.splitlines():
         line = line.strip()
@@ -151,7 +157,7 @@ def main():
 
     slots = get_hp_controller_slots()
     if not slots:
-        msg = 'OK: no controller/array found to check'
+        msg = "OK: no controller/array found to check"
         exit = 0
 
     errors = []
@@ -160,19 +166,19 @@ def main():
         errors += check_array(slot)
 
     if len(errors) > 0:
-        msg = 'CRIT {} error(s): {}'.format(len(errors), ' - '.join(errors))
+        msg = "CRIT {} error(s): {}".format(len(errors), " - ".join(errors))
         exit = 2
     else:
-        msg = 'OK No errors found'
+        msg = "OK No errors found"
         exit = 0
 
     if ARGS.write:
-        with open(ARGS.write, 'w') as f:
+        with open(ARGS.write, "w") as f:
             f.write(msg)
     else:
         print(msg)
     sys.exit(exit)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/lib/hwhealth/discovery/lshw.py b/src/lib/hwhealth/discovery/lshw.py
index c2f6653..1e52304 100644
--- a/src/lib/hwhealth/discovery/lshw.py
+++ b/src/lib/hwhealth/discovery/lshw.py
@@ -7,48 +7,45 @@ from charmhelpers.core import hookenv
 
 
 class Hardware(object):
-    def __init__(self, filename='/var/run/hw_health_lshw.json'):
+    def __init__(self, filename="/var/run/hw_health_lshw.json"):
         self.__filename = filename
         self._lshw = self.__load_hwinfo()
 
     def __load_hwinfo(self):
         try:
             if os.path.exists(self.__filename):
-                with open(self.__filename, 'r') as fd:
+                with open(self.__filename, "r") as fd:
                     hwinfo = json.load(fd)
             else:
-                output = subprocess.check_output(['lshw', '-json'])
+                output = subprocess.check_output(["lshw", "-json"])
                 # Note(aluria): py35 does not support extra args on
                 # subprocess.check_output
-                output_str = output.decode(errors='ignore')
+                output_str = output.decode(errors="ignore")
                 hwinfo = json.loads(output_str)
-                with open(self.__filename, 'w') as fd:
+                with open(self.__filename, "w") as fd:
                     fd.write(output_str)
 
             return hwinfo
         except PermissionError as error:
-            hookenv.log('lshw io error: {}'.format(error),
-                        hookenv.ERROR)
+            hookenv.log("lshw io error: {}".format(error), hookenv.ERROR)
             return {}
         except subprocess.CalledProcessError as error:
-            hookenv.log('lshw subprocess error: {}'.format(error),
-                        hookenv.ERROR)
+            hookenv.log("lshw subprocess error: {}".format(error), hookenv.ERROR)
             return {}
         except json.JSONDecodeError as error:
-            hookenv.log('lshw json error: {}'.format(error),
-                        hookenv.ERROR)
+            hookenv.log("lshw json error: {}".format(error), hookenv.ERROR)
             return {}
 
     @property
     def get_system(self):
         """Helper to get vendor info retrieved via actions
         """
-        keys = 'id description vendor product version serial'.split()
+        keys = "id description vendor product version serial".split()
         sysinfo = {}
         for k in keys:
             v = self._lshw.get(k)
-            if k == 'id':
-                k = 'hostname'
+            if k == "id":
+                k = "hostname"
             sysinfo.update({k: v})
         return sysinfo
 
@@ -56,22 +53,20 @@ class Hardware(object):
     def get_motherboard(self):
         """Helper to get vendor info retrieved via actions
         """
-        keys = 'description vendor product version serial'.split()
+        keys = "description vendor product version serial".split()
         buses = []
-        for child in self._lshw.get('children', [{}]):
-            if child.get('class') != 'bus':
+        for child in self._lshw.get("children", [{}]):
+            if child.get("class") != "bus":
                 continue
             buses.append(dict([(k, child.get(k)) for k in keys]))
         return buses
 
-    def _get_inspect_bridges(self, bridge_item, bridge_class='storage'):
+    def _get_inspect_bridges(self, bridge_item, bridge_class="storage"):
         bridge_class_items = []
-        for item in bridge_item.get('children', [{}]):
-            if item.get('class', '') == 'bridge':
-                bridge_class_items.extend(
-                    self._get_inspect_bridges(item, bridge_class)
-                )
-            elif item.get('class', '') == bridge_class:
+        for item in bridge_item.get("children", [{}]):
+            if item.get("class", "") == "bridge":
+                bridge_class_items.extend(self._get_inspect_bridges(item, bridge_class))
+            elif item.get("class", "") == bridge_class:
                 bridge_class_items.append(item)
         return bridge_class_items
 
@@ -85,18 +80,16 @@ class Hardware(object):
         """
         storage = []
         # system -> bus -> bridge -> storage
-        for bus in self._lshw.get('children', [{}]):
-            if bus.get('class', '') != 'bus':
+        for bus in self._lshw.get("children", [{}]):
+            if bus.get("class", "") != "bus":
                 continue
-            for bridge in bus.get('children', [{}]):
-                if bridge.get('class', '') != 'bridge':
+            for bridge in bus.get("children", [{}]):
+                if bridge.get("class", "") != "bridge":
                     continue
-                for item in bridge.get('children', [{}]):
-                    if item.get('class', '') == 'bridge':
-                        storage.extend(
-                            self._get_inspect_bridges(item, 'storage')
-                        )
-                    elif item.get('class', '') == 'storage':
+                for item in bridge.get("children", [{}]):
+                    if item.get("class", "") == "bridge":
+                        storage.extend(self._get_inspect_bridges(item, "storage"))
+                    elif item.get("class", "") == "storage":
                         storage.append(item)
         return storage
 
@@ -108,15 +101,15 @@ class Hardware(object):
         businfo and linux driver The aim of the function is to easily parse
         products to detect which tool(s) need to be used.
         """
-        keys = 'vendor product businfo'.split()
-        config_keys = ['driver']
+        keys = "vendor product businfo".split()
+        config_keys = ["driver"]
         storage = []
         for item in self._get_storage_class:
             storage_item = dict([(k, item.get(k)) for k in keys])
             storage_item.update(
-                dict([(k, item.get('configuration', {}).get(k))
-                      for k in config_keys]))
-            storage_item.update({'has_children': 'children' in item})
+                dict([(k, item.get("configuration", {}).get(k)) for k in config_keys])
+            )
+            storage_item.update({"has_children": "children" in item})
             storage.append(storage_item)
 
         return storage
@@ -133,14 +126,14 @@ class Hardware(object):
         The aim of the function is to easily parse products to detect which
         tool(s) need to be used.
         """
-        keys = 'product serial businfo physid dev size logicalname'.split()
+        keys = "product serial businfo physid dev size logicalname".split()
         disks = []
         for item in self._get_storage_class:
-            for child in item.get('children', [{}]):
-                if child.get('class', '') != 'disk':
+            for child in item.get("children", [{}]):
+                if child.get("class", "") != "disk":
                     continue
                 disk = dict([(k, child.get(k)) for k in keys])
-                disk.update({'storage_parent': item.get('product')})
+                disk.update({"storage_parent": item.get("product")})
                 disks.append(disk)
         return disks
 
@@ -153,28 +146,28 @@ class Hardware(object):
         The aim of the function is to easily parse products to detect which
         tool(s) need to be used.
         """
-        keys = 'vendor product businfo logicalname serial'.split()
-        config_keys = 'driver driverversion firmware speed'.split()
+        keys = "vendor product businfo logicalname serial".split()
+        config_keys = "driver driverversion firmware speed".split()
         nics = []
         # system -> bus -> bridge -> network
-        for bus in self._lshw.get('children', [{}]):
-            if bus.get('class', '') != 'bus':
+        for bus in self._lshw.get("children", [{}]):
+            if bus.get("class", "") != "bus":
                 continue
-            for bridge in bus.get('children', [{}]):
-                if bridge.get('class', '') != 'bridge':
+            for bridge in bus.get("children", [{}]):
+                if bridge.get("class", "") != "bridge":
                     continue
-                for item in bridge.get('children', [{}]):
-                    if item.get('class', '') == 'bridge':
-                        nics.extend(self._get_inspect_bridges(item, 'network'))
-                    elif item.get('class', '') == 'network':
+                for item in bridge.get("children", [{}]):
+                    if item.get("class", "") == "bridge":
+                        nics.extend(self._get_inspect_bridges(item, "network"))
+                    elif item.get("class", "") == "network":
                         nics.append(item)
 
         nics_filtered = []
         for nic in nics:
             nic_item = dict([(k, nic.get(k)) for k in keys])
             nic_item.update(
-                dict([(k, nic.get('configuration', {}).get(k))
-                     for k in config_keys]))
+                dict([(k, nic.get("configuration", {}).get(k)) for k in config_keys])
+            )
             nics_filtered.append(nic_item)
         return nics_filtered
 
@@ -182,60 +175,67 @@ class Hardware(object):
     def formatted_system_info(self):
         ctxt = self.get_system
         return (
-            '{description}: vendor[{vendor}], product_name[{product}], '
-            'version[{version}], serial[{serial}], hostname[{hostname}]'
+            "{description}: vendor[{vendor}], product_name[{product}], "
+            "version[{version}], serial[{serial}], hostname[{hostname}]"
         ).format(**ctxt)
 
     @property
     def formatted_motherboard_info(self):
-        return '\n'.join([
-            '{description}: vendor[{vendor}], product_name[{product}], '
-            'version[{version}], serial[{serial}]'.format(**ctxt)
-            for ctxt in self.get_motherboard])
+        return "\n".join(
+            [
+                "{description}: vendor[{vendor}], product_name[{product}], "
+                "version[{version}], serial[{serial}]".format(**ctxt)
+                for ctxt in self.get_motherboard
+            ]
+        )
 
     @property
     def formatted_storage_class_info(self):
-        LINE = ('driver[{driver}], businfo[{businfo}], '
-                'has_children[{has_children}]')
+        LINE = "driver[{driver}], businfo[{businfo}], has_children[{has_children}]"
         ctxts = []
         for ctxt in self.get_storage_class_info:
-            if ctxt.get('vendor') and ctxt.get('product'):
-                tmpl = ('Storage class: vendor[{vendor}],'
-                        'product_name[{product}], ') + LINE
+            if ctxt.get("vendor") and ctxt.get("product"):
+                tmpl = (
+                    "Storage class: vendor[{vendor}],product_name[{product}], "
+                ) + LINE
             else:
-                tmpl = 'Storage class: {}'.format(LINE)
+                tmpl = "Storage class: {}".format(LINE)
             ctxts.append(tmpl.format(**ctxt))
 
         if ctxts:
-            return '\n'.join(ctxts)
+            return "\n".join(ctxts)
 
     @property
     def formatted_disk_class_info(self):
-        return '\n'.join([
-            'Disk class: ld[{logicalname}], dev[{dev}], physid[{physid}], '
-            'businfo[{businfo}], product_name[{product}], serial[{serial}], '
-            'size[{size}], storage_parent[{storage_parent}]'.format(**ctxt)
-            for ctxt in self.get_disk_class_info
-        ])
+        return "\n".join(
+            [
+                "Disk class: ld[{logicalname}], dev[{dev}], physid[{physid}], "
+                "businfo[{businfo}], product_name[{product}], serial[{serial}], "
+                "size[{size}], storage_parent[{storage_parent}]".format(**ctxt)
+                for ctxt in self.get_disk_class_info
+            ]
+        )
 
     @property
     def formatted_network_class_info(self):
-        return '\n'.join([
-            'NIC: iface[{logicalname}], businfo[{businfo}], vendor[{vendor}]'
-            ', product_name[{product}], firmware[{firmware}], driver[{driver}'
-            ', {driverversion}], serial[{serial}]'
-            ', speed[{speed}]'.format(**ctxt)
-            for ctxt in self.get_network_class_info
-        ])
-
-
-if __name__ == '__main__':
+        return "\n".join(
+            [
+                "NIC: iface[{logicalname}], businfo[{businfo}], vendor[{vendor}]"
+                ", product_name[{product}], firmware[{firmware}], driver[{driver}"
+                ", {driverversion}], serial[{serial}]"
+                ", speed[{speed}]".format(**ctxt)
+                for ctxt in self.get_network_class_info
+            ]
+        )
+
+
+if __name__ == "__main__":
     hw = Hardware()
     print(hw.formatted_system_info)
     print(hw.formatted_motherboard_info)
-    print('\n== get_storage_classes')
+    print("\n== get_storage_classes")
     print(hw.formatted_storage_class_info)
-    print('== get_disk_classes')
+    print("== get_disk_classes")
     print(hw.formatted_disk_class_info)
-    print('\n== get_network_class_info')
+    print("\n== get_network_class_info")
     print(hw.formatted_network_class_info)
diff --git a/src/lib/hwhealth/discovery/supported_vendors.py b/src/lib/hwhealth/discovery/supported_vendors.py
index ef37a5a..459f078 100644
--- a/src/lib/hwhealth/discovery/supported_vendors.py
+++ b/src/lib/hwhealth/discovery/supported_vendors.py
@@ -2,37 +2,32 @@
 from hwhealth import tools
 
 SUPPORTED_STORAGE = {
-    'LSI Logic / Symbios Logic': {
-        'SAS2308 PCI-Express Fusion-MPT SAS-2': tools.Sas2Ircu,
-        'SAS3008 PCI-Express Fusion-MPT SAS-3': tools.Sas3Ircu,
-        'MegaRAID SAS-3 3108 [Invader]': tools.MegaCLI,
+    "LSI Logic / Symbios Logic": {
+        "SAS2308 PCI-Express Fusion-MPT SAS-2": tools.Sas2Ircu,
+        "SAS3008 PCI-Express Fusion-MPT SAS-3": tools.Sas3Ircu,
+        "MegaRAID SAS-3 3108 [Invader]": tools.MegaCLI,
     },
     # 'Mellanox Technologies': {
     #     'MT27710 Family [ConnectX-4 Lx]': lambda: 'mlxconfig',
     #     'MT27700 Family [ConnectX-4]': lambda: 'mlxconfig',
     # },
-    'Intel Corporation': {
-        'PCIe Data Center SSD': tools.Nvme,
+    "Intel Corporation": {"PCIe Data Center SSD": tools.Nvme},
+    "Samsung Electronics Co Ltd": {
+        "NVMe SSD Controller SM961/PM961": tools.Nvme,
+        "NVMe SSD Controller 172Xa/172Xb": tools.Nvme,
     },
-    'Samsung Electronics Co Ltd': {
-        'NVMe SSD Controller SM961/PM961': tools.Nvme,
-        'NVMe SSD Controller 172Xa/172Xb': tools.Nvme,
-    },
-    'Hewlett-Packard Company': {
-        'Smart Array Gen9 Controllers': tools.SsaCli,
-        'Smart Storage PQI 12G SAS/PCIe 3': tools.ILOrest,
+    "Hewlett-Packard Company": {
+        "Smart Array Gen9 Controllers": tools.SsaCli,
+        "Smart Storage PQI 12G SAS/PCIe 3": tools.ILOrest,
     },
 }
 
 SUPPORTED_SYSTEMS = {
-    'HPE': {
+    "HPE": {
         # tools.HpLog,  # not sure if this works on gen10+
         tools.ILOrest,
     },
-    'HP': {
-        tools.HpLog,
-        tools.SsaCli,
-    }
+    "HP": {tools.HpLog, tools.SsaCli},
 }
 
 SUPPORTED_DRIVERS = {
@@ -41,5 +36,5 @@ SUPPORTED_DRIVERS = {
     #     'apt': 'hioa',
     #     'tool': lambda: 'hio_info',
     # },
-    'nvme': tools.Nvme,
+    "nvme": tools.Nvme,
 }
diff --git a/src/lib/hwhealth/hwdiscovery.py b/src/lib/hwhealth/hwdiscovery.py
index c23ee13..fe27403 100644
--- a/src/lib/hwhealth/hwdiscovery.py
+++ b/src/lib/hwhealth/hwdiscovery.py
@@ -10,23 +10,23 @@ from hwhealth.discovery.lshw import Hardware
 from hwhealth.discovery.supported_vendors import (
     SUPPORTED_STORAGE,
     SUPPORTED_DRIVERS,
-    SUPPORTED_SYSTEMS
+    SUPPORTED_SYSTEMS,
 )
 
 from charmhelpers.core import hookenv
 
 
-def get_tools(manufacturer='auto'):
+def get_tools(manufacturer="auto"):
     """Return list of tool classes relevent for the current hardware.
 
     In testing, we set manufacturer = test in order to test all tools classes.
     Filtering added for known bad tools that don't work on all series combinations.
     """
-    if manufacturer == 'test':
+    if manufacturer == "test":
         # Return all possible tools to aid testing
-        storage_tools = {tool
-                         for vendor in SUPPORTED_STORAGE.values()
-                         for tool in vendor.values()}
+        storage_tools = {
+            tool for vendor in SUPPORTED_STORAGE.values() for tool in vendor.values()
+        }
         # Some system vendors have multiple tools, have to iterate sets
         system_tools = set(chain.from_iterable(SUPPORTED_SYSTEMS.values()))
         driver_tools = set(SUPPORTED_DRIVERS.values())
@@ -35,7 +35,7 @@ def get_tools(manufacturer='auto'):
             tool for tool in all_tools if tool.is_series_supported()
         )
         return series_filtered_tools
-    elif manufacturer == 'auto':
+    elif manufacturer == "auto":
         return _get_tools()
     else:
         raise NotImplementedError
@@ -46,41 +46,43 @@ def _get_tools():
     hwinfo = Hardware()
     toolset = set()
     for storage in hwinfo.get_storage_class_info:
-        vendor = storage.get('vendor')
-        product = storage.get('product')
+        vendor = storage.get("vendor")
+        product = storage.get("product")
         tool = SUPPORTED_STORAGE.get(vendor, {}).get(product)
         if isinstance(tool, list) or isinstance(tool, set):
             toolset.update(tool)
         elif tool:
             toolset.add(tool)
         else:
-            hookenv.log('Product not supported: [{}][{}]'
-                        ''.format(vendor, product), hookenv.DEBUG)
+            hookenv.log(
+                "Product not supported: [{}][{}]".format(vendor, product),
+                hookenv.DEBUG,
+            )
 
-        driver = storage.get('driver')
+        driver = storage.get("driver")
         if driver:
             if driver in SUPPORTED_DRIVERS:
                 toolset.add(SUPPORTED_DRIVERS[driver])
                 continue
-            hookenv.log('Driver not supported: {}'.format(driver),
-                        hookenv.DEBUG)
+            hookenv.log("Driver not supported: {}".format(driver), hookenv.DEBUG)
 
     # SW RAID?
     if _supports_mdadm():
         toolset.add(tools.Mdadm)
 
-    if hookenv.config('enable_ipmi'):
+    if hookenv.config("enable_ipmi"):
         toolset.add(tools.Ipmi)
 
-    system_vendor = hwinfo.get_system.get('vendor')
+    system_vendor = hwinfo.get_system.get("vendor")
     tool = SUPPORTED_SYSTEMS.get(system_vendor)
     if isinstance(tool, list) or isinstance(tool, set):
         toolset.update(tool)
     elif tool:
         toolset.add(tool)
     else:
-        hookenv.log('System vendor not supported: {}'.format(system_vendor),
-                    hookenv.DEBUG)
+        hookenv.log(
+            "System vendor not supported: {}".format(system_vendor), hookenv.DEBUG
+        )
 
     executed_toolset = set([tool() for tool in toolset if tool.is_series_supported])
     return executed_toolset
@@ -91,27 +93,24 @@ def _supports_mdadm():
 
     Returns True when the first one is found; otherwise, it returns False)
     """
-    if os.path.exists('/sbin/mdadm'):
+    if os.path.exists("/sbin/mdadm"):
         try:
-            devices_raw = subprocess.check_output(
-                ['/sbin/mdadm', '--detail', '--scan']
-            )
-            devices_re = re.compile(r'^ARRAY\s+(\S+) ')
+            devices_raw = subprocess.check_output(["/sbin/mdadm", "--detail", "--scan"])
+            devices_re = re.compile(r"^ARRAY\s+(\S+) ")
             for line in devices_raw.splitlines():
                 line = line.decode().strip()
                 raid_dev = devices_re.search(line)
                 if raid_dev:
-                    hookenv.log("Found md raid array {}"
-                                "".format(raid_dev.group(1)))
+                    hookenv.log("Found md raid array {}".format(raid_dev.group(1)))
                     return True
         except Exception as e:
             hookenv.log("mdadm scan failed with {}".format(e))
     return False
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     toolset = get_tools()
     if not toolset:
-        print('No RAID')
+        print("No RAID")
     else:
         print(toolset)
diff --git a/src/lib/hwhealth/tools.py b/src/lib/hwhealth/tools.py
index e90cb6b..da3615d 100644
--- a/src/lib/hwhealth/tools.py
+++ b/src/lib/hwhealth/tools.py
@@ -24,12 +24,14 @@ from charms import apt
 class JujuResourceNotFound(Exception):
     """Resource needed but not attached
     """
+
     pass
 
 
 class ToolError(Exception):
     """Allows a dict to be shared with try-except
     """
+
     def __init__(self, keymap):
         self._keymap = keymap
 
@@ -41,16 +43,18 @@ class ToolError(Exception):
 class ToolChecksumError(ToolError):
     """Resource does not match a whitelisted checksum
     """
+
     pass
 
 
 class ToolNotFound(ToolError):
     """Resource found (zipfile) but does not contain a needed binary
     """
+
     pass
 
 
-class Tool():
+class Tool:
     """An abstract class representing a "tool".
 
     The idea is to delegate install/configure duties to specific per-tool
@@ -59,21 +63,22 @@ class Tool():
     Every tool should implement its own internal logic regarding how to be
     installed, configured, and removed.
     """
-    CROND_DIR = '/etc/cron.d'
+
+    CROND_DIR = "/etc/cron.d"
     CRONJOB_SCRIPT_MODE = 0o100755
     CRONJOB_SCRIPT_UID = 0
     CRONJOB_SCRIPT_GID = 0
-    CRONJOB_OUTPUT_DIR = '/var/lib/nagios'
-    NRPE_PLUGINS_DIR = '/usr/local/lib/nagios/plugins'
+    CRONJOB_OUTPUT_DIR = "/var/lib/nagios"
+    NRPE_PLUGINS_DIR = "/usr/local/lib/nagios/plugins"
     NRPE_PLUGINS_MODE = 0o100755
     NRPE_PLUGINS_UID = 0
     NRPE_PLUGINS_GID = 0
-    SUDOERS_DIR = '/etc/sudoers.d'
+    SUDOERS_DIR = "/etc/sudoers.d"
     SUDOERS_MODE = 0o100440
     SUDOERS_UID = 0
     SUDOERS_GID = 0
-    SUPPORTED_SERIES = ['xenial', 'bionic', 'focal']
-    TOOLS_DIR = '/usr/local/bin'
+    SUPPORTED_SERIES = ["xenial", "bionic", "focal"]
+    TOOLS_DIR = "/usr/local/bin"
     TOOLS_MODE = 0o100755
     TOOLS_UID = 0
     TOOLS_GID = 0
@@ -81,7 +86,7 @@ class Tool():
     def __init__(
         self,
         shortname=None,
-        nrpe_opts='',
+        nrpe_opts="",
         nrpe_script=None,
         nrpe_script_dir=None,
         cron_script=None,
@@ -90,25 +95,21 @@ class Tool():
     ):
         self._nagios_hostname = nrpe.get_nagios_hostname()
         self._nrpe_opts = nrpe_opts
-        self._shortname = (shortname if shortname
-                           else self.__class__.__name__.lower())
-        self._files_dir = os.path.join(hookenv.charm_dir(),
-                                       'files',
-                                       self._shortname)
-        self._nrpe_script = (nrpe_script if nrpe_script
-                             else 'check_{}.py'.format(self._shortname))
-        self._nrpe_script_dir = (nrpe_script_dir if nrpe_script_dir
-                                 else self._files_dir)
-        self._cron_script = (cron_script if cron_script
-                             else 'cron_{}.py'.format(self._shortname))
-        self._cron_script_dir = (cron_script_dir if cron_script_dir
-                                 else self._files_dir)
-        self._templates_dir = os.path.join(hookenv.charm_dir(),
-                                           'templates',
-                                           self._shortname)
-        self._common_libs_dir = os.path.join(hookenv.charm_dir(),
-                                             'files/common')
-        self._common_libs = ['hw_health_lib.py']
+        self._shortname = shortname if shortname else self.__class__.__name__.lower()
+        self._files_dir = os.path.join(hookenv.charm_dir(), "files", self._shortname)
+        self._nrpe_script = (
+            nrpe_script if nrpe_script else "check_{}.py".format(self._shortname)
+        )
+        self._nrpe_script_dir = nrpe_script_dir if nrpe_script_dir else self._files_dir
+        self._cron_script = (
+            cron_script if cron_script else "cron_{}.py".format(self._shortname)
+        )
+        self._cron_script_dir = cron_script_dir if cron_script_dir else self._files_dir
+        self._templates_dir = os.path.join(
+            hookenv.charm_dir(), "templates", self._shortname
+        )
+        self._common_libs_dir = os.path.join(hookenv.charm_dir(), "files/common")
+        self._common_libs = ["hw_health_lib.py"]
         self._cron_script_args = cron_script_args
 
     def _install_nrpe_plugin(self):
@@ -117,9 +118,9 @@ class Tool():
         os.chmod(dst, self.NRPE_PLUGINS_MODE)
         os.chown(dst, uid=self.NRPE_PLUGINS_UID, gid=self.NRPE_PLUGINS_GID)
         hookenv.log(
-            'NRPE script for tool [{}] installed at as {}'
-            ''.format(self._shortname, dst),
-            hookenv.DEBUG
+            "NRPE script for tool [{}] installed at as {}"
+            "".format(self._shortname, dst),
+            hookenv.DEBUG,
         )
         return dst
 
@@ -131,9 +132,9 @@ class Tool():
             os.chmod(dst, self.NRPE_PLUGINS_MODE)
             os.chown(dst, uid=self.NRPE_PLUGINS_UID, gid=self.NRPE_PLUGINS_GID)
             hookenv.log(
-                'Common Library {} for tool [{}] installed at as {}'
-                ''.format(lib, self._shortname, dst),
-                hookenv.DEBUG
+                "Common Library {} for tool [{}] installed at as {}"
+                "".format(lib, self._shortname, dst),
+                hookenv.DEBUG,
             )
             dsts.append(dst)
         return dsts
@@ -144,48 +145,42 @@ class Tool():
             return
         os.remove(plugin_path)
         hookenv.log(
-            'deleted NRPE script for tool [{}]'.format(self._shortname),
-            hookenv.DEBUG
+            "deleted NRPE script for tool [{}]".format(self._shortname), hookenv.DEBUG
         )
 
     def configure_nrpe_check(self, nrpe_setup):
-        cmd = ' '.join([os.path.basename(self._nrpe_script), self._nrpe_opts])
+        cmd = " ".join([os.path.basename(self._nrpe_script), self._nrpe_opts])
         nrpe_setup.add_check(
             shortname=self._shortname,
-            description='{} Hardware Health'.format(self._shortname),
+            description="{} Hardware Health".format(self._shortname),
             check_cmd=cmd,
         )
         hookenv.log(
-            'configured NRPE check for tool [{}]'.format(self._shortname),
-            hookenv.DEBUG
+            "configured NRPE check for tool [{}]".format(self._shortname), hookenv.DEBUG
         )
 
     def remove_nrpe_check(self):
         nrpe_setup = nrpe.NRPE(hostname=self._nagios_hostname, primary=False)
-        cmd = ' '.join([self._nrpe_script, self._nrpe_opts])
-        nrpe_setup.remove_check(
-            shortname=self._shortname,
-            check_cmd=cmd
-        )
+        cmd = " ".join([self._nrpe_script, self._nrpe_opts])
+        nrpe_setup.remove_check(shortname=self._shortname, check_cmd=cmd)
         nrpe_setup.write()
         hookenv.log(
-            'removed NRPE check for tool [{}]'.format(self._shortname),
-            hookenv.DEBUG
+            "removed NRPE check for tool [{}]".format(self._shortname), hookenv.DEBUG
         )
 
     def install(self):
         self._install_common_libs()
         self._install_nrpe_plugin()
-        hookenv.log('Installed tool [{}]'.format(self._shortname))
+        hookenv.log("Installed tool [{}]".format(self._shortname))
 
     def remove(self):
         self.remove_nrpe_check()
         self._remove_nrpe_plugin()
-        hookenv.log('Removed tool [{}]'.format(self._shortname))
+        hookenv.log("Removed tool [{}]".format(self._shortname))
 
     @classmethod
     def is_series_supported(cls):
-        series = lsb_release()['DISTRIB_CODENAME']
+        series = lsb_release()["DISTRIB_CODENAME"]
 
         # BUG(lp#1890652) The following works around xenial layer-apt bug during test
         if (
@@ -197,7 +192,7 @@ class Tool():
 
         return series in cls.SUPPORTED_SERIES
 
-    def _install_cronjob(self, cron_user='root'):
+    def _install_cronjob(self, cron_user="root"):
         assert self._cron_script is not None
 
         # Copy the cronjob script to the nagios plugins directory
@@ -206,17 +201,15 @@ class Tool():
         os.chmod(dst, self.CRONJOB_SCRIPT_MODE)
         os.chown(dst, uid=self.CRONJOB_SCRIPT_UID, gid=self.CRONJOB_SCRIPT_GID)
         hookenv.log(
-            'Cronjob script [{}] copied to {}'
-            ''.format(self._cron_script, self.NRPE_PLUGINS_DIR),
-            hookenv.DEBUG
+            "Cronjob script [{}] copied to {}"
+            "".format(self._cron_script, self.NRPE_PLUGINS_DIR),
+            hookenv.DEBUG,
         )
 
         cmdline = [dst]
-        if self._cron_script_args \
-                and isinstance(self._cron_script_args, str):
-            cmdline.extend([shlex.quote(arg)
-                            for arg in self._cron_script_args.split()])
-        elif hookenv.config('manufacturer') != 'test':
+        if self._cron_script_args and isinstance(self._cron_script_args, str):
+            cmdline.extend([shlex.quote(arg) for arg in self._cron_script_args.split()])
+        elif hookenv.config("manufacturer") != "test":
             # Run it once to generate the temp file unless we're on a test
             # container, otherwise the nrpe check # might fail at first.
             # For security reasons, cronjobs that allow parameters shared
@@ -227,39 +220,32 @@ class Tool():
         # Generate random cronjob execution (internal in minutes)
         cron_interval = 5
         minutes_offsets = []
-        minute_num = binascii.crc_hqx(
-            ''.join(cmdline).encode(), 0) % cron_interval
+        minute_num = binascii.crc_hqx("".join(cmdline).encode(), 0) % cron_interval
         while minute_num < 60:
             minutes_offsets.append(str(minute_num))
             minute_num += cron_interval
-        cronjob_line = '{minutes} * * * * {user} {cmd}\n'.format(
-            minutes=','.join(minutes_offsets), user=cron_user,
-            cmd=' '.join(cmdline))
+        cronjob_line = "{minutes} * * * * {user} {cmd}\n".format(
+            minutes=",".join(minutes_offsets), user=cron_user, cmd=" ".join(cmdline)
+        )
 
-        crond_file = os.path.join(self.CROND_DIR,
-                                  'hwhealth_{}'.format(self._shortname))
-        with open(crond_file, 'w') as crond_fd:
+        crond_file = os.path.join(self.CROND_DIR, "hwhealth_{}".format(self._shortname))
+        with open(crond_file, "w") as crond_fd:
             crond_fd.write(cronjob_line)
-            hookenv.log(
-                'Cronjob configured at {}'.format(crond_file),
-                hookenv.DEBUG
-            )
+            hookenv.log("Cronjob configured at {}".format(crond_file), hookenv.DEBUG)
         return dst
 
     def _remove_cronjob(self):
         assert self._cron_script is not None
 
-        crond_file = os.path.join(self.CROND_DIR,
-                                  'hwhealth_{}'.format(self._shortname))
+        crond_file = os.path.join(self.CROND_DIR, "hwhealth_{}".format(self._shortname))
         cron_script = os.path.join(self.NRPE_PLUGINS_DIR, self._cron_script)
         for filename in (crond_file, cron_script):
             if not os.path.exists(filename):
                 continue
             os.remove(filename)
         hookenv.log(
-            'Removed cronjob files [{}, {}]'
-            ''.format(crond_file, cron_script),
-            hookenv.DEBUG
+            "Removed cronjob files [{}, {}]".format(crond_file, cron_script),
+            hookenv.DEBUG,
         )
 
     def _remove_sudoer(self):
@@ -267,8 +253,7 @@ class Tool():
         if not sudoer_path.exists():
             return
         sudoer_path.unlink()
-        hookenv.log('deleted sudoer file: {}'.format(sudoer_path),
-                    hookenv.DEBUG)
+        hookenv.log("deleted sudoer file: {}".format(sudoer_path), hookenv.DEBUG)
 
 
 class VendorTool(Tool):
@@ -279,6 +264,7 @@ class VendorTool(Tool):
     cronjob that runs as root and saves the tool output in a temporary file
     that nrpe can read (as nagios user).
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.checksums = []
@@ -294,30 +280,32 @@ class VendorTool(Tool):
         super().remove()
 
     def _install_from_resource(self):
-        resource = hookenv.resource_get('tools')
+        resource = hookenv.resource_get("tools")
         if not resource:
-            raise JujuResourceNotFound('tools')
+            raise JujuResourceNotFound("tools")
         else:
             hookenv.log(
-                'Installing tool [{}] from resource'.format(self._shortname),
-                hookenv.DEBUG
+                "Installing tool [{}] from resource".format(self._shortname),
+                hookenv.DEBUG,
             )
             # Move in from a temp directory to be atomic
             with TemporaryDirectory() as tmpdir:
                 try:
-                    with ZipFile(resource, 'r') as zipfile:
+                    with ZipFile(resource, "r") as zipfile:
                         tmpfile = zipfile.extract(self._shortname, tmpdir)
                         # Verify checksum
                         checksum = hashlib.sha256()
-                        with open(tmpfile, 'rb') as fd:
+                        with open(tmpfile, "rb") as fd:
                             checksum.update(fd.read())
                         if checksum.hexdigest() not in self.checksums:
-                            checksums_string = ', '.join(self.checksums)
-                            raise ToolChecksumError({
-                                'shortname': self._shortname,
-                                'checksum': checksum.hexdigest(),
-                                'expected_checksums': checksums_string
-                            })
+                            checksums_string = ", ".join(self.checksums)
+                            raise ToolChecksumError(
+                                {
+                                    "shortname": self._shortname,
+                                    "checksum": checksum.hexdigest(),
+                                    "expected_checksums": checksums_string,
+                                }
+                            )
                         # We could just use self.TOOLS_DIR as a destination
                         # here, but shutil.move refuses to overwrite the
                         # destination file unless it receives a full path
@@ -327,28 +315,24 @@ class VendorTool(Tool):
                         os.chown(dst, uid=self.TOOLS_UID, gid=self.TOOLS_GID)
 
                 except BadZipFile as error:
-                    hookenv.log('BadZipFile: {}'.format(error), hookenv.ERROR)
+                    hookenv.log("BadZipFile: {}".format(error), hookenv.ERROR)
 
                 except PermissionError as error:
                     hookenv.log(
-                        'Unable to unzip tool {} '
-                        'from the provided resource: {}'
-                        ''.format(self._shortname, error),
-                        hookenv.ERROR
+                        "Unable to unzip tool {} "
+                        "from the provided resource: {}"
+                        "".format(self._shortname, error),
+                        hookenv.ERROR,
                     )
                 except KeyError as error:
-                    raise ToolNotFound({'shortname': self._shortname,
-                                        'error': error})
+                    raise ToolNotFound({"shortname": self._shortname, "error": error})
 
     def _remove_binary(self):
         binary_path = Path(self.TOOLS_DIR) / self._shortname
         if not binary_path.exists():
             return
         binary_path.unlink()
-        hookenv.log(
-            'Removed binary tool {}'.format(binary_path),
-            hookenv.DEBUG
-        )
+        hookenv.log("Removed binary tool {}".format(binary_path), hookenv.DEBUG)
 
 
 class AptVendorTool(Tool):
@@ -402,51 +386,42 @@ class AptVendorTool(Tool):
     -----END PGP PUBLIC KEY BLOCK-----"""
 
     HPE_MCP_REPO_TMPL = (
-        'deb http://downloads.linux.hpe.com/SDR/repo/mcp {series}/current-gen9 non-free'
+        "deb http://downloads.linux.hpe.com/SDR/repo/mcp {series}/current-gen9 non-free"
     )
     HPE_ILOREST_REPO_TMPL = (
-        'deb http://downloads.linux.hpe.com/SDR/repo/ilorest {series}/current non-free'
+        "deb http://downloads.linux.hpe.com/SDR/repo/ilorest {series}/current non-free"
     )
 
     # HP doesn't have focal APT sources as of yet
     APT_SOURCES = {
-        'ssacli': {
-            'xenial': HPE_MCP_REPO_TMPL.format(series='xenial'),
-            'bionic': HPE_MCP_REPO_TMPL.format(series='bionic'),
+        "ssacli": {
+            "xenial": HPE_MCP_REPO_TMPL.format(series="xenial"),
+            "bionic": HPE_MCP_REPO_TMPL.format(series="bionic"),
         },
-        'ilorest': {
-            'xenial': HPE_ILOREST_REPO_TMPL.format(series='xenial'),
-            'bionic': HPE_ILOREST_REPO_TMPL.format(series='bionic'),
+        "ilorest": {
+            "xenial": HPE_ILOREST_REPO_TMPL.format(series="xenial"),
+            "bionic": HPE_ILOREST_REPO_TMPL.format(series="bionic"),
         },
-        'hplog': {
-            'xenial': HPE_MCP_REPO_TMPL.format(series='xenial'),
-            'bionic': HPE_MCP_REPO_TMPL.format(series='bionic'),
+        "hplog": {
+            "xenial": HPE_MCP_REPO_TMPL.format(series="xenial"),
+            "bionic": HPE_MCP_REPO_TMPL.format(series="bionic"),
         },
     }
     APT_KEYS = {
-        'ssacli': {
-            'xenial': HPE_MCP_KEY,
-            'bionic': HPE_MCP_KEY,
-        },
-        'ilorest': {
-            'xenial': HPE_ILOREST_KEY,
-            'bionic': HPE_ILOREST_KEY,
-        },
-        'hplog': {
-            'xenial': HPE_MCP_KEY,
-            'bionic': HPE_MCP_KEY,
-        },
+        "ssacli": {"xenial": HPE_MCP_KEY, "bionic": HPE_MCP_KEY},
+        "ilorest": {"xenial": HPE_ILOREST_KEY, "bionic": HPE_ILOREST_KEY},
+        "hplog": {"xenial": HPE_MCP_KEY, "bionic": HPE_MCP_KEY},
     }
 
     def __init__(self, shortname=None, apt_packages=[]):
         super().__init__(
             shortname=shortname,
-            nrpe_script='check_hw_health_cron_output.py',
-            nrpe_opts='--filename {}/{}.out'.format(self.CRONJOB_OUTPUT_DIR,
-                                                    shortname)
+            nrpe_script="check_hw_health_cron_output.py",
+            nrpe_opts="--filename {}/{}.out".format(self.CRONJOB_OUTPUT_DIR, shortname),
+        )
+        self.apt_packages = (
+            apt_packages if apt_packages else [self.__class__.__name__.lower()]
         )
-        self.apt_packages = (apt_packages if apt_packages
-                             else [self.__class__.__name__.lower()])
         self._nrpe_script_dir = self._common_libs_dir
 
     def install(self):
@@ -471,38 +446,45 @@ class AptVendorTool(Tool):
         hardware present on the system.
         """
         self._add_apt_source()
-        if hookenv.config('manufacturer') == 'test':
+        if hookenv.config("manufacturer") == "test":
             # If we are forcing install on a container for functional tests,
             # we should only download and not install the packages, as some
             # vendor tools depend on hardware to be preset to complete postinst
             # need one option added per package
-            apt.queue_install(self.apt_packages, options=["--download-only" for _ in self.apt_packages])
+            apt.queue_install(
+                self.apt_packages,
+                options=["--download-only" for _ in self.apt_packages],
+            )
         else:
             apt.queue_install(self.apt_packages)
 
     def _add_apt_source(self):
-        series = lsb_release()['DISTRIB_CODENAME']
-        if self._shortname not in self.APT_SOURCES and self._shortname not in self.APT_KEYS:
+        series = lsb_release()["DISTRIB_CODENAME"]
+        if (
+            self._shortname not in self.APT_SOURCES
+            and self._shortname not in self.APT_KEYS
+        ):
             return
         if series in self.APT_SOURCES[self._shortname]:
-            apt.add_source(self.APT_SOURCES[self._shortname][series],
-                           key=self.APT_KEYS[self._shortname][series])
+            apt.add_source(
+                self.APT_SOURCES[self._shortname][series],
+                key=self.APT_KEYS[self._shortname][series],
+            )
 
     def _remove_packages(self):
         apt.purge(self.apt_packages)
 
     def install_cronjob(self):
         hookenv.log(
-            'Attempting AptVendorTool cronjob script install [{}]'
-            ''.format(self._cron_script),
-            hookenv.DEBUG
+            "Attempting AptVendorTool cronjob script install [{}]"
+            "".format(self._cron_script),
+            hookenv.DEBUG,
         )
         # Don't install a cronjob until the tools are installed
         if self.is_apt_installed():
             hookenv.log(
-                'calling _install_cronjob for {}'
-                ''.format(self._cron_script),
-                hookenv.DEBUG
+                "calling _install_cronjob for {}".format(self._cron_script),
+                hookenv.DEBUG,
             )
             self._install_cronjob()
 
@@ -521,7 +503,7 @@ class AptVendorTool(Tool):
         allows the reactive layer to know when the apt packages have finished
         installing so that it may go on to configure the nrpe layer of tools
         """
-        if hookenv.config('manufacturer') == 'test':
+        if hookenv.config("manufacturer") == "test":
             # it is okay to skip this part in testing as layer-apt will block
             # if the package is not downloadable from sources
             return True
@@ -537,11 +519,12 @@ class Sas3Ircu(VendorTool):
 
     This is a tool supporting the LSI SAS 12Gb/s controllers
     """
+
     def __init__(self):
-        super().__init__(cron_script='cron_sas3ircu.sh')
+        super().__init__(cron_script="cron_sas3ircu.sh")
         self.checksums = [
-            'f150eb37bb332668949a3eccf9636e0e03f874aecd17a39d586082c6be1386bd',
-            'd69967057992134df1b136f83bc775a641e32c4efc741def3ef6f6a25a9a14b5',
+            "f150eb37bb332668949a3eccf9636e0e03f874aecd17a39d586082c6be1386bd",
+            "d69967057992134df1b136f83bc775a641e32c4efc741def3ef6f6a25a9a14b5",
         ]
 
 
@@ -550,9 +533,12 @@ class Sas2Ircu(VendorTool):
 
     This is a tool supporting the LSI SAS 6Gb/s controllers
     """
+
     def __init__(self):
-        super().__init__(cron_script='cron_sas2ircu.sh')
-        self.checksums = ['37467826d0b22aad47287efe70bb34e47f475d70e9b1b64cbd63f57607701e73']  # noqa: E501
+        super().__init__(cron_script="cron_sas2ircu.sh")
+        self.checksums = [
+            "37467826d0b22aad47287efe70bb34e47f475d70e9b1b64cbd63f57607701e73"
+        ]  # noqa: E501
 
 
 class MegaCLI(VendorTool):
@@ -560,12 +546,13 @@ class MegaCLI(VendorTool):
 
     This is a tool supporting the LSI MegaRAID SAS controllers
     """
+
     def __init__(self):
-        super().__init__(cron_script='cron_megacli.sh')
+        super().__init__(cron_script="cron_megacli.sh")
         self.checksums = [
-            '34f1a235543662615ee35f458317380b3f89fac0e415dee755e0dbc7c4cf6f92',
-            '1c4effe33ee5db82227e05925dd629771fd49c7d2be2382d48c48a864452cdec',
-            '1a68e6646d1e3dfb7039f581be994500d0ed02de2f928e57399e86473d4c8662',
+            "34f1a235543662615ee35f458317380b3f89fac0e415dee755e0dbc7c4cf6f92",
+            "1c4effe33ee5db82227e05925dd629771fd49c7d2be2382d48c48a864452cdec",
+            "1a68e6646d1e3dfb7039f581be994500d0ed02de2f928e57399e86473d4c8662",
         ]
 
 
@@ -575,10 +562,10 @@ class HpLog(AptVendorTool):
     This is a tool supporting the LSI MegaRAID SAS controllers
     """
 
-    SUPPORTED_SERIES = ['xenial', 'bionic']
+    SUPPORTED_SERIES = ["xenial", "bionic"]
 
     def __init__(self):
-        super().__init__(apt_packages=['hp-health'])
+        super().__init__(apt_packages=["hp-health"])
 
 
 class SsaCli(AptVendorTool):
@@ -587,7 +574,7 @@ class SsaCli(AptVendorTool):
     This is a tool supporting the HP Smart Array controllers
     """
 
-    SUPPORTED_SERIES = ['xenial', 'bionic']
+    SUPPORTED_SERIES = ["xenial", "bionic"]
 
     def __init__(self):
         super().__init__()
@@ -597,7 +584,7 @@ class ILOrest(AptVendorTool):
     """A class representing the ILOrest vendor tool (HPE hardware (Gen 10+)
     """
 
-    SUPPORTED_SERIES = ['xenial', 'bionic']
+    SUPPORTED_SERIES = ["xenial", "bionic"]
 
     def __init__(self):
         super().__init__()
@@ -609,12 +596,13 @@ class Mdadm(VendorTool):
     Our mdadm check kind of behaves like a VendorTool for the purpose of
     installation as it has a cronjob + check script
     """
+
     def __init__(self):
         super().__init__()
 
     def install(self):
         # mdadm should already be installed, but let's check
-        fetch.apt_install(['mdadm'], fatal=True)
+        fetch.apt_install(["mdadm"], fatal=True)
         self._install_cronjob()
         # No vendor binary to install
         Tool.install(self)
@@ -634,12 +622,13 @@ class Ipmi(Tool):
     install; the plugin relies only on freeipmi, a few perl modules, and the
     actual nrpe check, which is imported as a git submodule
     """
-    def __init__(self, nrpe_opts=''):
+
+    def __init__(self, nrpe_opts=""):
         super().__init__(
-            cron_script='cron_ipmi_sensors.py',
-            cron_script_args=hookenv.config('ipmi_check_options')
+            cron_script="cron_ipmi_sensors.py",
+            cron_script_args=hookenv.config("ipmi_check_options"),
         )
-        self._sudoer_file = '99-check_ipmi_sensor'
+        self._sudoer_file = "99-check_ipmi_sensor"
 
     def configure_nrpe_check(self, nrpe_setup):
         # extra options for check_ipmi_sensors Perl script are configured in
@@ -652,7 +641,7 @@ class Ipmi(Tool):
         self._install_sudoer()
         # Install Perl script called by the (Python) cronjob
         self._install_nrpe_helper_plugin()
-        self._install_cronjob(cron_user='nagios')
+        self._install_cronjob(cron_user="nagios")
 
         # Install the Python script called by check_nrpe
         super().install()
@@ -665,13 +654,13 @@ class Ipmi(Tool):
 
     def _install_nrpe_helper_plugin(self):
         original_nrpe_script = self._nrpe_script
-        self._nrpe_script = 'check_ipmi_sensor'
+        self._nrpe_script = "check_ipmi_sensor"
         super()._install_nrpe_plugin()
         self._nrpe_script = original_nrpe_script
 
     def _remove_nrpe_helper_plugin(self):
         original_nrpe_script = self._nrpe_script
-        self._nrpe_script = 'check_ipmi_sensor'
+        self._nrpe_script = "check_ipmi_sensor"
         super()._remove_nrpe_plugin()
         self._nrpe_script = original_nrpe_script
 
@@ -683,9 +672,8 @@ class Ipmi(Tool):
         os.chmod(dst, self.SUDOERS_MODE)
         os.chown(dst, uid=self.SUDOERS_UID, gid=self.SUDOERS_GID)
         hookenv.log(
-            'sudoer file for tool [{}] installed at {}'
-            ''.format(self._shortname, dst),
-            hookenv.DEBUG
+            "sudoer file for tool [{}] installed at {}".format(self._shortname, dst),
+            hookenv.DEBUG,
         )
         return dst
 
@@ -696,15 +684,16 @@ class Nvme(Tool):
     This is a direct subclass of Tool because unlike a VendorTool we are not
     using a cronjob script
     """
+
     def __init__(self):
         super().__init__()
-        self._sudoer_template = '99-check_nvme.tmpl'
-        self._sudoer_file = '99-check_nvme'
+        self._sudoer_template = "99-check_nvme.tmpl"
+        self._sudoer_file = "99-check_nvme"
         self._cron_script = None
 
     def install(self):
         # mdadm should already be installed, but let's check
-        fetch.apt_install(['nvme-cli'], fatal=True)
+        fetch.apt_install(["nvme-cli"], fatal=True)
         self._render_sudoer()
         super().install()
 
@@ -722,24 +711,29 @@ class Nvme(Tool):
         if not devices:
             return
 
-        devices = dict([('CHECK{}'.format(dev.replace('/', '_').upper()), dev)
-                        for dev in devices])
-        ctxt = {'devices': devices}
-        ctxt['devices_cmnd_aliases'] = ', '.join(devices.keys())
-
-        render(source=src, target=dst, context=ctxt, perms=self.SUDOERS_MODE,
-               templates_dir=None)
+        devices = dict(
+            [("CHECK{}".format(dev.replace("/", "_").upper()), dev) for dev in devices]
+        )
+        ctxt = {"devices": devices}
+        ctxt["devices_cmnd_aliases"] = ", ".join(devices.keys())
+
+        render(
+            source=src,
+            target=dst,
+            context=ctxt,
+            perms=self.SUDOERS_MODE,
+            templates_dir=None,
+        )
         hookenv.log(
-            'sudoer file for tool [{}] installed at {}'.format(self._shortname,
-                                                               dst),
-            hookenv.DEBUG
+            "sudoer file for tool [{}] installed at {}".format(self._shortname, dst),
+            hookenv.DEBUG,
         )
         return dst
 
     def __get_nvme_devices(self):
         devices = []
-        for device in glob.glob('/dev/nvme*'):
-            nvme_re = re.match(r'^/dev/nvme\d+$', device)
+        for device in glob.glob("/dev/nvme*"):
+            nvme_re = re.match(r"^/dev/nvme\d+$", device)
             if not nvme_re:
                 continue
             devices.append(nvme_re.group())
diff --git a/src/reactive/hw_health.py b/src/reactive/hw_health.py
index a04f790..ff72e85 100644
--- a/src/reactive/hw_health.py
+++ b/src/reactive/hw_health.py
@@ -12,167 +12,176 @@ from hwhealth import tools
 
 def _set_install_status(tool):
     if isinstance(tool, tools.VendorTool) and not isinstance(tool, tools.Mdadm):
-        status.maintenance('Installing from attached resource')
+        status.maintenance("Installing from attached resource")
     elif isinstance(tool, tools.AptVendorTool):
-        status.maintenance('Installing vendor tools via apt')
-        set_flag('hw-health.wait-for-vendor-apt')
+        status.maintenance("Installing vendor tools via apt")
+        set_flag("hw-health.wait-for-vendor-apt")
 
 
-@when_none('hw-health.installed', 'hw-health.unsupported')
-@when('nrpe-external-master.available')
-@when('general-info.connected')
+@when_none("hw-health.installed", "hw-health.unsupported")
+@when("nrpe-external-master.available")
+@when("general-info.connected")
 def install():
-    manufacturer = hookenv.config('manufacturer')
-    if host.is_container() and manufacturer != 'test':
-        status.blocked('Containers are not supported')
-        set_flag('hw-health.unsupported')
+    manufacturer = hookenv.config("manufacturer")
+    if host.is_container() and manufacturer != "test":
+        status.blocked("Containers are not supported")
+        set_flag("hw-health.unsupported")
         return
 
-    if manufacturer not in ['auto', 'test']:
-        status.blocked('manufacturer needs to be set to auto')
+    if manufacturer not in ["auto", "test"]:
+        status.blocked("manufacturer needs to be set to auto")
         return
 
     # Detect hardware and return a list of tools we need to use
-    status.maintenance('Autodiscovering hardware')
+    status.maintenance("Autodiscovering hardware")
     toolset = get_tools(manufacturer)
     if not toolset:
-        status.blocked('Hardware not supported')
-        set_flag('hw-health.unsupported')
+        status.blocked("Hardware not supported")
+        set_flag("hw-health.unsupported")
     else:
         try:
             tool_list = list()
             for toolClass in toolset:
                 tool = toolClass()
                 _set_install_status(tool)
-                status.maintenance('Installing tool {}'.format(type(tool).__name__))
+                status.maintenance("Installing tool {}".format(type(tool).__name__))
                 tool.install()
                 # Save the class name in the unit kv db. This will be reused when
                 # reconfiguring or removing the checks
                 tool_list.append(type(tool).__name__)
             unitdb = unitdata.kv()
-            unitdb.set('toolset', tool_list)
-            set_flag('hw-health.installed')
+            unitdb.set("toolset", tool_list)
+            set_flag("hw-health.installed")
         except tools.JujuResourceNotFound as error:
-            hookenv.log('Missing Juju resource: {} - alternative method is not '
-                        ' available yet'.format(error), hookenv.ERROR)
-            status.blocked('Missing Juju resource: {}'.format(error))
-            set_flag('hw-health.unsupported')
+            hookenv.log(
+                "Missing Juju resource: {} - alternative method is not "
+                " available yet".format(error),
+                hookenv.ERROR,
+            )
+            status.blocked("Missing Juju resource: {}".format(error))
+            set_flag("hw-health.unsupported")
         except tools.ToolChecksumError as error:
             msg = error.message
-            hookenv.log('checksum error: tool [{shortname}], checksum[{checksum}],'
-                        ' expected[{expected_checksums}]'.format(**msg), hookenv.ERROR)
-            status.blocked('Tool {shortname} - checksum error'.format(**msg))
-            set_flag('hw-health.unsupported')
+            hookenv.log(
+                "checksum error: tool [{shortname}], checksum[{checksum}],"
+                " expected[{expected_checksums}]".format(**msg),
+                hookenv.ERROR,
+            )
+            status.blocked("Tool {shortname} - checksum error".format(**msg))
+            set_flag("hw-health.unsupported")
         except tools.ToolNotFound as error:
             msg = error.message
-            hookenv.log('Tool {shortname} not found in the provided resource: '
-                        '{error}'.format(**msg), hookenv.ERROR)
-            status.blocked('Tool {shortname} not found'.format(**msg))
-            set_flag('hw-health.unsupported')
+            hookenv.log(
+                "Tool {shortname} not found in the provided resource: "
+                "{error}".format(**msg),
+                hookenv.ERROR,
+            )
+            status.blocked("Tool {shortname} not found".format(**msg))
+            set_flag("hw-health.unsupported")
 
 
-@hook('upgrade-charm')
+@hook("upgrade-charm")
 def upgrade():
-    clear_flag('hw-health.installed')
-    clear_flag('hw-health.unsupported')
-    clear_flag('hw-health.configured')
-    status.maintenance('Charm upgrade in progress')
+    clear_flag("hw-health.installed")
+    clear_flag("hw-health.unsupported")
+    clear_flag("hw-health.configured")
+    status.maintenance("Charm upgrade in progress")
 
 
-@when('hw-health.installed')
-@when_not('general-info.available')
+@when("hw-health.installed")
+@when_not("general-info.available")
 def remove_tools():
     # If general-info is unavailable, the subordinate relationship towards the
     # principal charm has been broken, so we need to remove the installed tools
     unitdb = unitdata.kv()
-    for tool_class_name in unitdb.get('toolset', set()):
+    for tool_class_name in unitdb.get("toolset", set()):
         # Re-instantiate the tool from the saved class name
         tool_class = getattr(tools, tool_class_name)
         tool_class().remove()
-    clear_flag('hw-health.installed')
-    clear_flag('hw-health.unsupported')
-    clear_flag('hw-health.configured')
+    clear_flag("hw-health.installed")
+    clear_flag("hw-health.unsupported")
+    clear_flag("hw-health.configured")
 
 
-@when('hw-health.wait-for-vendor-apt')
+@when("hw-health.wait-for-vendor-apt")
 def wait_for_vendor_apt():
     # cycle through any vendor tools that are of type AptVendorTool and
     # check if all packages needed are installed.  If not, eject and wait
     unitdb = unitdata.kv()
-    for tool_class_name in unitdb.get('toolset', set()):
+    for tool_class_name in unitdb.get("toolset", set()):
         # Re-instantiate the tool from the saved class name
         tool_class = getattr(tools, tool_class_name)
         if isinstance(tool_class, tools.AptVendorTool):
             if tool_class.is_apt_installed():
                 tool_class.install_cronjob()
             else:
-                status.maintenance('Waiting for vendor tools to install via apt')
+                status.maintenance("Waiting for vendor tools to install via apt")
                 return
-    clear_flag('hw-health.wait-for-vendor-apt')
-    clear_flag('hw-health.configured')
+    clear_flag("hw-health.wait-for-vendor-apt")
+    clear_flag("hw-health.configured")
 
 
-@when('config.changed')
-@when_not('config.changed.manufacturer')
+@when("config.changed")
+@when_not("config.changed.manufacturer")
 def config_changed():
-    clear_flag('hw-health.configured')
+    clear_flag("hw-health.configured")
 
 
-@when('config.changed.manufacturer')
+@when("config.changed.manufacturer")
 def toolset_changed():
-    if not is_flag_set('hw-health.installed'):
+    if not is_flag_set("hw-health.installed"):
         # Note(aluria): useful for testing purposes
-        clear_flag('hw-health.unsupported')
+        clear_flag("hw-health.unsupported")
         return
 
     # Changing the manufacturer option will trigger a reinstallation of the
     # tools
     remove_tools()
-    status.maintenance('Reinstallation of tools in progress')
+    status.maintenance("Reinstallation of tools in progress")
 
 
-@when('hw-health.installed')
-@when_not('nrpe-external-master.available')
-@when_not('hw-health.configured')
+@when("hw-health.installed")
+@when_not("nrpe-external-master.available")
+@when_not("hw-health.configured")
 def blocked_on_nrpe():
-    status.blocked('Missing relations: nrpe-external-master')
+    status.blocked("Missing relations: nrpe-external-master")
 
 
-@when('hw-health.installed')
-@when('nrpe-external-master.available')
-@when_not('hw-health.configured')
+@when("hw-health.installed")
+@when("nrpe-external-master.available")
+@when_not("hw-health.configured")
 def configure_nrpe():
-    if not os.path.exists('/var/lib/nagios'):
-        status.waiting('Waiting for nrpe package installation')
+    if not os.path.exists("/var/lib/nagios"):
+        status.waiting("Waiting for nrpe package installation")
         return
 
-    status.maintenance('Configuring nrpe checks')
+    status.maintenance("Configuring nrpe checks")
 
     nrpe_setup = nrpe.NRPE(primary=False)
     unitdb = unitdata.kv()
-    for tool_class_name in unitdb.get('toolset', set()):
+    for tool_class_name in unitdb.get("toolset", set()):
         # Re-instantiate the tool from the saved class name
         tool_class = getattr(tools, tool_class_name)
         tool_class().configure_nrpe_check(nrpe_setup)
 
-    if unitdb.get('toolset'):
+    if unitdb.get("toolset"):
         # Note(aluria): This needs to be run outside of
         # tool_class().configure_nrpe_check or shared dictionary with the
         # nagios unit will list the last added check (LP#1821602)
         nrpe_setup.write()
 
-    status.active('ready')
-    set_flag('hw-health.configured')
+    status.active("ready")
+    set_flag("hw-health.configured")
 
 
-@when('hw-health.installed')
-@when_not('nrpe-external-master.available')
-@when('hw-health.configured')
+@when("hw-health.installed")
+@when_not("nrpe-external-master.available")
+@when("hw-health.configured")
 def remove_nrpe_checks():
-    status.maintenance('Removing nrpe checks')
+    status.maintenance("Removing nrpe checks")
     unitdb = unitdata.kv()
-    for tool_class_name in unitdb.get('toolset', set()):
+    for tool_class_name in unitdb.get("toolset", set()):
         # Re-instantiate the tool from the saved class name
         tool_class = getattr(tools, tool_class_name)
         tool_class().remove_nrpe_check()
-    clear_flag('hw-health.configured')
+    clear_flag("hw-health.configured")
diff --git a/src/tests/download_nagios_plugin3.py b/src/tests/download_nagios_plugin3.py
index b454caf..ded2851 100755
--- a/src/tests/download_nagios_plugin3.py
+++ b/src/tests/download_nagios_plugin3.py
@@ -3,9 +3,10 @@ from glob import glob
 import os.path
 import urllib.request
 
-MODULE_NAME = 'nagios_plugin3.py'
-MODULE_URL = os.path.join('https://git.launchpad.net/nrpe-charm/plain/files',
-                          MODULE_NAME)
+MODULE_NAME = "nagios_plugin3.py"
+MODULE_URL = os.path.join(
+    "https://git.launchpad.net/nrpe-charm/plain/files", MODULE_NAME
+)
 _cache = None
 
 
@@ -18,11 +19,11 @@ def content():
 
 
 def main():
-    for i in glob('.tox/unit/lib/python3*/site-packages'):
+    for i in glob(".tox/unit/lib/python3*/site-packages"):
         mod_path = os.path.join(i, MODULE_NAME)
         if os.path.isdir(i) and not os.path.exists(mod_path):
-            open(mod_path, 'wb').write(content())
+            open(mod_path, "wb").write(content())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/tests/functional/conftest.py b/src/tests/functional/conftest.py
index 9a65e83..5734800 100644
--- a/src/tests/functional/conftest.py
+++ b/src/tests/functional/conftest.py
@@ -1,5 +1,5 @@
 #!/usr/bin/python3
-'''
+"""
 Reusable pytest fixtures for functional testing
 
 Environment variables
@@ -7,7 +7,7 @@ Environment variables
 
 test_preserve_model:
 if set, the testing model won't be torn down at the end of the testing session
-'''
+"""
 
 import asyncio
 import json
@@ -18,7 +18,7 @@ import juju
 from juju.controller import Controller
 from juju.errors import JujuError
 
-STAT_CMD = '''python3 - <<EOF
+STAT_CMD = """python3 - <<EOF
 import json
 import os
 
@@ -33,13 +33,13 @@ stat_json = json.dumps(stat_hash)
 print(stat_json)
 
 EOF
-'''
+"""
 
 
[e-mail]_fixture(scope='module')
[e-mail]_fixture(scope="module")
 def event_loop():
-    '''Override the default pytest event loop to allow for fixtures using a
-    broader scope'''
+    """Override the default pytest event loop to allow for fixtures using a
+    broader scope"""
     loop = asyncio.get_event_loop_policy().new_event_loop()
     asyncio.set_event_loop(loop)
     loop.set_debug(True)
@@ -48,23 +48,23 @@ def event_loop():
     asyncio.set_event_loop(None)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def controller():
-    '''Connect to the current controller'''
+    """Connect to the current controller"""
     _controller = Controller()
     await _controller.connect_current()
     yield _controller
     await _controller.disconnect()
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def model(controller):  # pylint: disable=redefined-outer-name
-    '''This model lives only for the duration of the test'''
+    """This model lives only for the duration of the test"""
     model_name = "functest-{}".format(uuid.uuid4())
     _model = await controller.add_model(model_name)
     yield _model
     await _model.disconnect()
-    if not os.getenv('test_preserve_model'):
+    if not os.getenv("test_preserve_model"):
         await controller.destroy_model(model_name)
         while model_name in await controller.list_models():
             await asyncio.sleep(1)
@@ -72,30 +72,35 @@ async def model(controller):  # pylint: disable=redefined-outer-name
 
 @pytest.fixture()
 async def get_app(model):  # pylint: disable=redefined-outer-name
-    '''Returns the application requested'''
+    """Returns the application requested"""
+
     async def _get_app(name):
         try:
             return model.applications[name]
         except KeyError:
             raise JujuError("Cannot find application {}".format(name))
+
     return _get_app
 
 
 @pytest.fixture()
 async def get_unit(model):  # pylint: disable=redefined-outer-name
-    '''Returns the requested <app_name>/<unit_number> unit'''
+    """Returns the requested <app_name>/<unit_number> unit"""
+
     async def _get_unit(name):
         try:
-            (app_name, unit_number) = name.split('/')
+            (app_name, unit_number) = name.split("/")
             return model.applications[app_name].units[unit_number]
         except (KeyError, ValueError):
             raise JujuError("Cannot find unit {}".format(name))
+
     return _get_unit
 
 
 @pytest.fixture()
 async def get_entity(get_unit, get_app):  # pylint: disable=redefined-outer-name
-    '''Returns a unit or an application'''
+    """Returns a unit or an application"""
+
     async def _get_entity(name):
         try:
             return await get_unit(name)
@@ -104,69 +109,72 @@ async def get_entity(get_unit, get_app):  # pylint: disable=redefined-outer-name
                 return await get_app(name)
             except JujuError:
                 raise JujuError("Cannot find entity {}".format(name))
+
     return _get_entity
 
 
 @pytest.fixture
 async def run_command(get_unit):  # pylint: disable=redefined-outer-name
-    '''
+    """
     Runs a command on a unit.
 
     :param cmd: Command to be run
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _run_command(cmd, target):
-        unit = (
-            target
-            if isinstance(target, juju.unit.Unit)
-            else await get_unit(target)
-        )
+        unit = target if isinstance(target, juju.unit.Unit) else await get_unit(target)
         action = await unit.run(cmd)
         return action.results
+
     return _run_command
 
 
 @pytest.fixture
 async def file_stat(run_command):  # pylint: disable=redefined-outer-name
-    '''
+    """
     Runs stat on a file
 
     :param path: File path
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _file_stat(path, target):
         cmd = STAT_CMD % path
         results = await run_command(cmd, target)
-        if results['Code'] != '0':
+        if results["Code"] != "0":
             # A common possible error is simply ENOENT, the file ain't there.
             # A better solution would be to retrieve the exception that the
             # remote python code raised, but that would probably require a real
             # RPC setup
-            raise RuntimeError('Stat failed: {}'.format(results))
+            raise RuntimeError("Stat failed: {}".format(results))
         else:
-            return json.loads(results['Stdout'])
+            return json.loads(results["Stdout"])
 
     return _file_stat
 
 
 @pytest.fixture
 async def file_contents(run_command):  # pylint: disable=redefined-outer-name
-    '''
+    """
     Returns the contents of a file
 
     :param path: File path
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _file_contents(path, target):
-        cmd = 'cat {}'.format(path)
+        cmd = "cat {}".format(path)
         results = await run_command(cmd, target)
-        return results['Stdout']
+        return results["Stdout"]
+
     return _file_contents
 
 
 @pytest.fixture
 async def reconfigure_app(get_app, model):  # pylint: disable=redefined-outer-name
-    '''Applies a different config to the requested app'''
+    """Applies a different config to the requested app"""
+
     async def _reconfigure_app(cfg, target):
         application = (
             target
@@ -175,5 +183,6 @@ async def reconfigure_app(get_app, model):  # pylint: disable=redefined-outer-na
         )
         await application.set_config(cfg)
         await application.get_config()
-        await model.block_until(lambda: application.status == 'active')
+        await model.block_until(lambda: application.status == "active")
+
     return _reconfigure_app
diff --git a/src/tests/functional/test_hwhealth.py b/src/tests/functional/test_hwhealth.py
index cae8fd4..d17aae7 100644
--- a/src/tests/functional/test_hwhealth.py
+++ b/src/tests/functional/test_hwhealth.py
@@ -5,22 +5,22 @@ import subprocess
 import asyncio
 from os.path import abspath, dirname
 
-sys.path.append('lib')
+sys.path.append("lib")
 
 from hwhealth import hwdiscovery  # noqa: E402
-from hwhealth import tools        # noqa: E402
+from hwhealth import tools  # noqa: E402
 
 
 # Treat all tests as coroutines
 pytestmark = pytest.mark.asyncio
 SERIES = [
-    'focal',
-    'bionic',
-    'xenial',
+    "focal",
+    "bionic",
+    "xenial",
 ]
 CHARM_DIR = dirname(dirname(dirname(abspath(__file__))))
 CHARM_BUILD_DIR = dirname(CHARM_DIR)
-NRPECFG_DIR = '/etc/nagios/nrpe.d'
+NRPECFG_DIR = "/etc/nagios/nrpe.d"
 DEF_TIMEOUT = 600
 # These go along with the hpe repos for the hp* tools
 
@@ -33,46 +33,50 @@ async def deploy_hwhealth_res(model, app_name, res_filename):
     # Attaching resources is not implemented yet in libjuju
     # see https://github.com/juju/python-libjuju/issues/294
     tools_res_path = os.path.join(CHARM_BUILD_DIR, res_filename)
-    subprocess.check_call([
-        'juju',
-        'deploy',
-        '-m',
-        model.info.name,
-        os.path.join(CHARM_BUILD_DIR, 'hw-health'),
-        app_name,
-        '--resource',
-        'tools={}'.format(tools_res_path),
-    ])
+    subprocess.check_call(
+        [
+            "juju",
+            "deploy",
+            "-m",
+            model.info.name,
+            os.path.join(CHARM_BUILD_DIR, "hw-health"),
+            app_name,
+            "--resource",
+            "tools={}".format(tools_res_path),
+        ]
+    )
 
 
 async def update_hwhealth_res(model, app_name, res_filename):
     tools_res_path = os.path.join(CHARM_BUILD_DIR, res_filename)
-    subprocess.check_call([
-        'juju',
-        'attach-resource',
-        '-m',
-        model.info.name,
-        app_name,
-        'tools={}'.format(tools_res_path),
-    ])
+    subprocess.check_call(
+        [
+            "juju",
+            "attach-resource",
+            "-m",
+            model.info.name,
+            app_name,
+            "tools={}".format(tools_res_path),
+        ]
+    )
+
 
 ###################
 # Custom fixtures #
 ###################
 
 
[e-mail](scope='module',
-                params=SERIES)
[e-mail](scope="module", params=SERIES)
 async def deploy_app(request, model):
-    '''Deploys the hw-health charm as a subordinate of ubuntu'''
+    """Deploys the hw-health charm as a subordinate of ubuntu"""
     # TODO: this might look nicer if we deployed a bundle instead. It could be
     # a jinja template to handle the parametrization
     release = request.param
-    channel = 'stable'
-    hw_health_app_name = 'hw-health-{}'.format(release)
-    hw_health_checksum_app_name = 'hw-health-checksum-{}'.format(release)
+    channel = "stable"
+    hw_health_app_name = "hw-health-{}".format(release)
+    hw_health_checksum_app_name = "hw-health-checksum-{}".format(release)
 
-    for principal_app in ['ubuntu', 'nagios']:
+    for principal_app in ["ubuntu", "nagios"]:
         relname = series = release
         if principal_app == "nagios" and release == "focal":
             # NOTE(aluria): cs:nagios was not available in focal
@@ -82,97 +86,90 @@ async def deploy_app(request, model):
             series = "bionic"
         await model.deploy(
             principal_app,
-            application_name='{}-{}'.format(principal_app, relname),
+            application_name="{}-{}".format(principal_app, relname),
             series=series,
             channel=channel,
         )
     await model.deploy(
-        'ubuntu',
-        application_name='ubuntu-checksum-{}'.format(release),
+        "ubuntu",
+        application_name="ubuntu-checksum-{}".format(release),
         series=release,
-        channel=channel
+        channel=channel,
     )
     nrpe_app = await model.deploy(
-        'nrpe',
-        application_name='nrpe-{}'.format(release),
+        "nrpe",
+        application_name="nrpe-{}".format(release),
         series=release,
         num_units=0,
         channel=channel,
     )
-    for ubuntu_unit in ['ubuntu', 'ubuntu-checksum']:
+    for ubuntu_unit in ["ubuntu", "ubuntu-checksum"]:
         await nrpe_app.add_relation(
-            'general-info',
-            '{}-{}:juju-info'.format(ubuntu_unit, release)
+            "general-info", "{}-{}:juju-info".format(ubuntu_unit, release)
         )
-    await nrpe_app.add_relation(
-        'monitors',
-        'nagios-{}:monitors'.format(relname)
-    )
+    await nrpe_app.add_relation("monitors", "nagios-{}:monitors".format(relname))
 
     # Attaching resources is not implemented yet in libjuju
     # see https://github.com/juju/python-libjuju/issues/294
-    await deploy_hwhealth_res(model, hw_health_app_name, 'tools.zip')
-    await deploy_hwhealth_res(model, hw_health_checksum_app_name,
-                              'tools-checksum.zip')
+    await deploy_hwhealth_res(model, hw_health_app_name, "tools.zip")
+    await deploy_hwhealth_res(model, hw_health_checksum_app_name, "tools-checksum.zip")
 
     # This is pretty horrible, but we can't deploy via libjuju
     while True:
         try:
             hw_health_app = model.applications[hw_health_app_name]
-            hw_health_checksum_app = \
-                model.applications[hw_health_checksum_app_name]
+            hw_health_checksum_app = model.applications[hw_health_checksum_app_name]
             break
         except KeyError:
             await asyncio.sleep(5)
 
     await hw_health_app.add_relation(
-        'general-info',
-        'ubuntu-{}:juju-info'.format(release)
+        "general-info", "ubuntu-{}:juju-info".format(release)
     )
     await hw_health_app.add_relation(
-        'nrpe-external-master',
-        '{}:nrpe-external-master'.format(nrpe_app.name)
+        "nrpe-external-master", "{}:nrpe-external-master".format(nrpe_app.name)
     )
 
     await hw_health_checksum_app.add_relation(
-        'general-info',
-        'ubuntu-checksum-{}:juju-info'.format(release)
+        "general-info", "ubuntu-checksum-{}:juju-info".format(release)
     )
     await hw_health_checksum_app.add_relation(
-        'nrpe-external-master',
-        '{}:nrpe-external-master'.format(nrpe_app.name)
+        "nrpe-external-master", "{}:nrpe-external-master".format(nrpe_app.name)
     )
 
     # The app will initially be in blocked state because it's running in a
     # container
     await model.block_until(
-        lambda: (hw_health_app.status == 'blocked' and  # noqa:W504
-                 hw_health_checksum_app.status == 'blocked'),
-        timeout=DEF_TIMEOUT
+        lambda: (
+            hw_health_app.status == "blocked"
+            and hw_health_checksum_app.status == "blocked"  # noqa:W504
+        ),
+        timeout=DEF_TIMEOUT,
     )
     yield hw_health_app
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def deployed_unit(deploy_app):
-    '''Returns the hw-health unit we've deployed'''
+    """Returns the hw-health unit we've deployed"""
     return deploy_app.units[0]
 
 
[e-mail](scope='function')
[e-mail](scope="function")
 async def toolset(monkeypatch):
     # All tool classes know which files should be installed and how, so we can
     # use them to read the expected stat results. Monkeypatching is however
     # required as the classes code is not expected to be run outside of a
     # deployed charm
     with monkeypatch.context() as m:
-        m.setattr('charmhelpers.core.hookenv.charm_dir',
-                  lambda: CHARM_BUILD_DIR)
-        m.setattr('charmhelpers.core.hookenv.config',
-                  lambda x=None: dict())
-        m.setattr('charmhelpers.contrib.charmsupport.nrpe.get_nagios_hostname',
-                  lambda: 'pytest')
-        return [tool() for tool in hwdiscovery.get_tools('test')]
+        m.setattr("charmhelpers.core.hookenv.charm_dir", lambda: CHARM_BUILD_DIR)
+        m.setattr("charmhelpers.core.hookenv.config", lambda x=None: dict())
+        m.setattr(
+            "charmhelpers.contrib.charmsupport.nrpe.get_nagios_hostname",
+            lambda: "pytest",
+        )
+        return [tool() for tool in hwdiscovery.get_tools("test")]
+
 
 #########
 # Tests #
@@ -180,69 +177,69 @@ async def toolset(monkeypatch):
 
 
 async def test_cannot_run_in_container(deploy_app):
-    assert deploy_app.status == 'blocked'
+    assert deploy_app.status == "blocked"
 
 
 async def test_forced_deploy(deploy_app, model, run_command):
     # Create a fake NVMe device for the cronjob to be configured
     CREATE_FAKE_NVME = "/bin/bash -c 'touch /dev/nvme0'"
-    series = deploy_app.name.split('-')[-1]
+    series = deploy_app.name.split("-")[-1]
     for unit in model.units.values():
-        if unit.entity_id.startswith('ubuntu-{}'.format(series)):
+        if unit.entity_id.startswith("ubuntu-{}".format(series)):
             ubuntu_unit = unit
             await model.block_until(
-                lambda: ubuntu_unit.workload_status == 'active',
-                timeout=DEF_TIMEOUT
+                lambda: ubuntu_unit.workload_status == "active", timeout=DEF_TIMEOUT
             )
             await run_command(CREATE_FAKE_NVME, ubuntu_unit)
             break
 
-    await deploy_app.set_config({'manufacturer': 'test'})
-    await model.block_until(
-        lambda: deploy_app.status == 'active',
-        timeout=DEF_TIMEOUT
-    )
-    assert deploy_app.status == 'active'
+    await deploy_app.set_config({"manufacturer": "test"})
+    await model.block_until(lambda: deploy_app.status == "active", timeout=DEF_TIMEOUT)
+    assert deploy_app.status == "active"
 
 
 async def test_checksum_forced_deploy(deploy_app, model, run_command):
     # Create a fake NVMe device for the cronjob to be configured
     CREATE_FAKE_NVME = "/bin/bash -c 'touch /dev/nvme0'"
-    series = deploy_app.name.split('-')[-1]
-    checksum_app_name = 'hw-health-checksum-{}'.format(series)
+    series = deploy_app.name.split("-")[-1]
+    checksum_app_name = "hw-health-checksum-{}".format(series)
     checksum_app = model.applications[checksum_app_name]
     for unit in model.units.values():
-        if unit.entity_id.startswith('ubuntu-checksum-{}'.format(series)):
+        if unit.entity_id.startswith("ubuntu-checksum-{}".format(series)):
             ubuntu_unit = unit
             await model.block_until(
-                lambda: ubuntu_unit.workload_status == 'active',
-                timeout=DEF_TIMEOUT
+                lambda: ubuntu_unit.workload_status == "active", timeout=DEF_TIMEOUT
             )
             await run_command(CREATE_FAKE_NVME, ubuntu_unit)
         elif unit.entity_id.startswith(checksum_app_name):
             checksum_unit = unit
 
-    await checksum_app.set_config({'manufacturer': 'test'})
+    await checksum_app.set_config({"manufacturer": "test"})
     try:
         await model.block_until(
             lambda: (
-                checksum_app.status == 'blocked' and checksum_unit.workload_status_message == 'Tool megacli - checksum error'  # noqa E501
+                checksum_app.status == "blocked"
+                and checksum_unit.workload_status_message
+                == "Tool megacli - checksum error"  # noqa E501
             ),
-            timeout=DEF_TIMEOUT)
+            timeout=DEF_TIMEOUT,
+        )
     except asyncio.exceptions.TimeoutError:
         print(
             "failed to get expected state 'blocked:Tool megacli - checksum error', "
-            "witnessed '{}:{}'".format(checksum_app.status, checksum_unit.workload_status_message)
+            "witnessed '{}:{}'".format(
+                checksum_app.status, checksum_unit.workload_status_message
+            )
         )
-        assert checksum_app.status == 'blocked'
-        assert checksum_unit.workload_status_message == 'Tool megacli - checksum error'
+        assert checksum_app.status == "blocked"
+        assert checksum_unit.workload_status_message == "Tool megacli - checksum error"
 
 
 async def test_checksum_updated_resource_missing(deploy_app, model):
-    series = deploy_app.name.split('-')[-1]
-    checksum_app_name = 'hw-health-checksum-{}'.format(series)
+    series = deploy_app.name.split("-")[-1]
+    checksum_app_name = "hw-health-checksum-{}".format(series)
     checksum_app = model.applications[checksum_app_name]
-    await update_hwhealth_res(model, checksum_app_name, 'tools-missing.zip')
+    await update_hwhealth_res(model, checksum_app_name, "tools-missing.zip")
     for unit in model.units.values():
         if unit.entity_id.startswith(checksum_app_name):
             checksum_unit = unit
@@ -250,209 +247,242 @@ async def test_checksum_updated_resource_missing(deploy_app, model):
 
     await model.block_until(
         lambda: (
-            checksum_app.status == 'blocked' and checksum_unit.workload_status_message == 'Tool megacli not found'  # noqa E501
+            checksum_app.status == "blocked"
+            and checksum_unit.workload_status_message
+            == "Tool megacli not found"  # noqa E501
         ),
-        timeout=DEF_TIMEOUT
+        timeout=DEF_TIMEOUT,
     )
 
 
 async def test_checksum_updated_resource_ok(deploy_app, model):
-    series = deploy_app.name.split('-')[-1]
-    checksum_app_name = 'hw-health-checksum-{}'.format(series)
+    series = deploy_app.name.split("-")[-1]
+    checksum_app_name = "hw-health-checksum-{}".format(series)
     checksum_app = model.applications[checksum_app_name]
-    await update_hwhealth_res(model, checksum_app_name, 'tools.zip')
+    await update_hwhealth_res(model, checksum_app_name, "tools.zip")
     for unit in model.units.values():
         if unit.entity_id.startswith(checksum_app_name):
             checksum_unit = unit
             break
 
     await model.block_until(
-        lambda: (checksum_app.status == 'active' and  # noqa:W504
-                 checksum_unit.workload_status_message == 'ready'),
-        timeout=DEF_TIMEOUT
+        lambda: (
+            checksum_app.status == "active"
+            and checksum_unit.workload_status_message == "ready"  # noqa:W504
+        ),
+        timeout=DEF_TIMEOUT,
     )
 
 
-async def test_deployed_file_stats(monkeypatch, toolset, deploy_app, deployed_unit, file_stat):
+async def test_deployed_file_stats(
+    monkeypatch, toolset, deploy_app, deployed_unit, file_stat
+):
     # This should really be a parametrized test, but fixtures cannot be used as
     # params value as if they were iterators
     # It should also check for other installed files and differentiate between
     # tool types (e.g. tools.Ipmi does not use a vendor binary)
-    series = deploy_app.name.split('-')[-1]
+    series = deploy_app.name.split("-")[-1]
     for tool in toolset:
         # Skip tools that are out of series for the currently deployed application
         with monkeypatch.context() as m:
-            m.setattr('hwhealth.tools.lsb_release',
-                      lambda x=None: {'DISTRIB_CODENAME': series})
-            m.setattr('charmhelpers.core.hookenv.config',
-                      lambda x=None: {'manufacturer': 'test'})
+            m.setattr(
+                "hwhealth.tools.lsb_release",
+                lambda x=None: {"DISTRIB_CODENAME": series},
+            )
+            m.setattr(
+                "charmhelpers.core.hookenv.config",
+                lambda x=None: {"manufacturer": "test"},
+            )
             if not tool.is_series_supported():
-                print('Skipping tool {}.  Distribution {} not supported.'.format(tool, series))
+                print(
+                    "Skipping tool {}.  Distribution {} not supported.".format(
+                        tool, series
+                    )
+                )
                 continue
         # Have we rendered the nrpe check cfg?
-        nrpecfg_path = os.path.join(NRPECFG_DIR,
-                                    'check_{}.cfg'.format(tool._shortname))
-        print('Checking {}'.format(nrpecfg_path))
+        nrpecfg_path = os.path.join(NRPECFG_DIR, "check_{}.cfg".format(tool._shortname))
+        print("Checking {}".format(nrpecfg_path))
         test_stat = await file_stat(nrpecfg_path, deployed_unit)
-        assert test_stat['size'] > 0
+        assert test_stat["size"] > 0
 
         # Have we installed the nrpe check script?
-        nrpescript_path = os.path.join(tool.NRPE_PLUGINS_DIR,
-                                       os.path.basename(tool._nrpe_script))
-        print('Checking {}'.format(nrpescript_path))
+        nrpescript_path = os.path.join(
+            tool.NRPE_PLUGINS_DIR, os.path.basename(tool._nrpe_script)
+        )
+        print("Checking {}".format(nrpescript_path))
         test_stat = await file_stat(nrpescript_path, deployed_unit)
-        assert test_stat['size'] > 0
-        assert test_stat['gid'] == tool.NRPE_PLUGINS_GID
-        assert test_stat['uid'] == tool.NRPE_PLUGINS_UID
-        assert test_stat['mode'] == oct(tool.NRPE_PLUGINS_MODE)
+        assert test_stat["size"] > 0
+        assert test_stat["gid"] == tool.NRPE_PLUGINS_GID
+        assert test_stat["uid"] == tool.NRPE_PLUGINS_UID
+        assert test_stat["mode"] == oct(tool.NRPE_PLUGINS_MODE)
 
         # Have we installed any common libs?
         for lib in tool._common_libs:
-            lib_path = os.path.join(tool.NRPE_PLUGINS_DIR,
-                                    os.path.basename(lib))
-            print('Checking {}'.format(nrpescript_path))
+            lib_path = os.path.join(tool.NRPE_PLUGINS_DIR, os.path.basename(lib))
+            print("Checking {}".format(nrpescript_path))
             test_stat = await file_stat(lib_path, deployed_unit)
-            assert test_stat['size'] > 0
-            assert test_stat['gid'] == tool.NRPE_PLUGINS_GID
-            assert test_stat['uid'] == tool.NRPE_PLUGINS_UID
-            assert test_stat['mode'] == oct(tool.NRPE_PLUGINS_MODE)
+            assert test_stat["size"] > 0
+            assert test_stat["gid"] == tool.NRPE_PLUGINS_GID
+            assert test_stat["uid"] == tool.NRPE_PLUGINS_UID
+            assert test_stat["mode"] == oct(tool.NRPE_PLUGINS_MODE)
 
         if isinstance(tool, tools.Ipmi) or isinstance(tool, tools.Nvme):
             # Have we added sudo rights for running freeipmi commands?
             sudoer_path = os.path.join(tool.SUDOERS_DIR, tool._sudoer_file)
-            print('Checking {}'.format(sudoer_path))
+            print("Checking {}".format(sudoer_path))
             test_stat = await file_stat(sudoer_path, deployed_unit)
-            assert test_stat['size'] > 0
-            assert test_stat['gid'] == tool.SUDOERS_GID
-            assert test_stat['uid'] == tool.SUDOERS_UID
-            assert test_stat['mode'] == oct(tool.SUDOERS_MODE)
+            assert test_stat["size"] > 0
+            assert test_stat["gid"] == tool.SUDOERS_GID
+            assert test_stat["uid"] == tool.SUDOERS_UID
+            assert test_stat["mode"] == oct(tool.SUDOERS_MODE)
 
         if isinstance(tool, tools.Ipmi) or isinstance(tool, tools.VendorTool):
             # Have we installed the cronjob script helper?
-            cron_script_path = os.path.join(tool.NRPE_PLUGINS_DIR,
-                                            tool._cron_script)
-            print('Checking {}'.format(cron_script_path))
+            cron_script_path = os.path.join(tool.NRPE_PLUGINS_DIR, tool._cron_script)
+            print("Checking {}".format(cron_script_path))
             test_stat = await file_stat(cron_script_path, deployed_unit)
-            assert test_stat['size'] > 0
-            assert test_stat['gid'] == tool.CRONJOB_SCRIPT_GID
-            assert test_stat['uid'] == tool.CRONJOB_SCRIPT_UID
-            assert test_stat['mode'] == oct(tool.CRONJOB_SCRIPT_MODE)
+            assert test_stat["size"] > 0
+            assert test_stat["gid"] == tool.CRONJOB_SCRIPT_GID
+            assert test_stat["uid"] == tool.CRONJOB_SCRIPT_UID
+            assert test_stat["mode"] == oct(tool.CRONJOB_SCRIPT_MODE)
 
             # Have we installed the cronjob itself?
-            cronjob_path = os.path.join(tool.CROND_DIR,
-                                        'hwhealth_{}'.format(tool._shortname))
-            print('Checking {}'.format(cronjob_path))
+            cronjob_path = os.path.join(
+                tool.CROND_DIR, "hwhealth_{}".format(tool._shortname)
+            )
+            print("Checking {}".format(cronjob_path))
             test_stat = await file_stat(cronjob_path, deployed_unit)
-            assert test_stat['size'] > 0
+            assert test_stat["size"] > 0
 
         if isinstance(tool, tools.VendorTool):
             # Have we installed the vendor binary?
             if isinstance(tool, tools.Mdadm):
-                bin_path = os.path.join('/sbin', tool._shortname)
+                bin_path = os.path.join("/sbin", tool._shortname)
             else:
                 bin_path = os.path.join(tool.TOOLS_DIR, tool._shortname)
-            print('Checking {}'.format(bin_path))
+            print("Checking {}".format(bin_path))
             test_stat = await file_stat(bin_path, deployed_unit)
-            assert test_stat['size'] > 0
-            assert test_stat['gid'] == tool.TOOLS_GID
-            assert test_stat['uid'] == tool.TOOLS_UID
-            assert test_stat['mode'] == oct(tool.TOOLS_MODE)
-
-
[e-mail]('script_type', ['_nrpe_script', '_cron_script'])
-async def test_imports(script_type, monkeypatch, toolset, deploy_app, deployed_unit, run_command):
-    '''Dry run all auxiliary files to ensure we have all needed dependecies'''
-    series = deploy_app.name.split('-')[-1]
+            assert test_stat["size"] > 0
+            assert test_stat["gid"] == tool.TOOLS_GID
+            assert test_stat["uid"] == tool.TOOLS_UID
+            assert test_stat["mode"] == oct(tool.TOOLS_MODE)
+
+
[e-mail]("script_type", ["_nrpe_script", "_cron_script"])
+async def test_imports(
+    script_type, monkeypatch, toolset, deploy_app, deployed_unit, run_command
+):
+    """Dry run all auxiliary files to ensure we have all needed dependecies"""
+    series = deploy_app.name.split("-")[-1]
     for tool in toolset:
         # Skip tools that are out of series for the currently deployed application
         with monkeypatch.context() as m:
-            m.setattr('hwhealth.tools.lsb_release',
-                      lambda x=None: {'DISTRIB_CODENAME': series})
-            m.setattr('charmhelpers.core.hookenv.config',
-                      lambda x=None: {'manufacturer': 'test'})
+            m.setattr(
+                "hwhealth.tools.lsb_release",
+                lambda x=None: {"DISTRIB_CODENAME": series},
+            )
+            m.setattr(
+                "charmhelpers.core.hookenv.config",
+                lambda x=None: {"manufacturer": "test"},
+            )
             if not tool.is_series_supported():
-                print('Skipping tool {}.  Distribution {} not supported.'.format(tool, series))
+                print(
+                    "Skipping tool {}.  Distribution {} not supported.".format(
+                        tool, series
+                    )
+                )
                 continue
         script_name = getattr(tool, script_type)
         tool_name = tool.__class__.__name__
         if not script_name:
             # Cannot pytest.skip because it would break out of the loop
-            print('Skipping test as {} does not have a {}'
-                  ''.format(tool_name, script_type))
+            print(
+                "Skipping test as {} does not have a {}"
+                "".format(tool_name, script_type)
+            )
         else:
-            print('Checking {}: {}'.format(tool_name, script_name))
+            print("Checking {}: {}".format(tool_name, script_name))
             path = os.path.join(tool.NRPE_PLUGINS_DIR, script_name)
             cmd = path + " --help"
             results = await run_command(cmd, deployed_unit)
-            rc = results['Code']
-            assert rc == '0', ('{}, {}. RC is non-zero. results={}'
-                               ''.format(tool_name, script_name, results))
+            rc = results["Code"]
+            assert rc == "0", "{}, {}. RC is non-zero. results={}".format(
+                tool_name, script_name, results
+            )
 
 
 async def test_removal(monkeypatch, toolset, model, deploy_app, file_stat):
-    '''Remove the unit, test that all files have been cleaned up'''
+    """Remove the unit, test that all files have been cleaned up"""
     hw_health_app_name = deploy_app.name
-    series = deploy_app.name.split('-')[-1]
+    series = deploy_app.name.split("-")[-1]
     await deploy_app.remove()
     await model.block_until(
-        lambda: hw_health_app_name not in model.applications,
-        timeout=DEF_TIMEOUT
+        lambda: hw_health_app_name not in model.applications, timeout=DEF_TIMEOUT
     )
     # Since we've removed the hw-health app, we can't target it anymore, we
     # need to find the principal unit
     for unit in model.units.values():
-        if unit.entity_id.startswith('ubuntu-{}'.format(series)):
+        if unit.entity_id.startswith("ubuntu-{}".format(series)):
             ubuntu_unit = unit
     for tool in toolset:
         # Skip tools that are out of series for the currently deployed application
         with monkeypatch.context() as m:
-            m.setattr('hwhealth.tools.lsb_release',
-                      lambda x=None: {'DISTRIB_CODENAME': series})
-            m.setattr('charmhelpers.core.hookenv.config',
-                      lambda x=None: {'manufacturer': 'test'})
+            m.setattr(
+                "hwhealth.tools.lsb_release",
+                lambda x=None: {"DISTRIB_CODENAME": series},
+            )
+            m.setattr(
+                "charmhelpers.core.hookenv.config",
+                lambda x=None: {"manufacturer": "test"},
+            )
             if not tool.is_series_supported():
-                print('Skipping tool {}.  Distribution {} not supported.'.format(tool, series))
+                print(
+                    "Skipping tool {}.  Distribution {} not supported.".format(
+                        tool, series
+                    )
+                )
                 continue
         # Have we removed the nrpe check cfg?
-        nrpecfg_path = os.path.join(NRPECFG_DIR,
-                                    'check_{}.cfg'.format(tool._shortname))
-        print('Checking {}'.format(nrpecfg_path))
+        nrpecfg_path = os.path.join(NRPECFG_DIR, "check_{}.cfg".format(tool._shortname))
+        print("Checking {}".format(nrpecfg_path))
         with pytest.raises(RuntimeError):
             await file_stat(nrpecfg_path, ubuntu_unit)
 
         # Have we removed the nrpe check script?
-        nrpescript_path = os.path.join(tool.NRPE_PLUGINS_DIR,
-                                       tool._nrpe_script)
-        print('Checking {}'.format(nrpescript_path))
+        nrpescript_path = os.path.join(tool.NRPE_PLUGINS_DIR, tool._nrpe_script)
+        print("Checking {}".format(nrpescript_path))
         with pytest.raises(RuntimeError):
             await file_stat(nrpescript_path, ubuntu_unit)
 
         if isinstance(tool, tools.Ipmi) or isinstance(tool, tools.Nvme):
             # Have we removed sudo rights for running freeipmi commands?
             sudoer_path = os.path.join(tool.SUDOERS_DIR, tool._sudoer_file)
-            print('Checking {}'.format(sudoer_path))
+            print("Checking {}".format(sudoer_path))
             with pytest.raises(RuntimeError):
                 await file_stat(sudoer_path, ubuntu_unit)
 
         if isinstance(tool, tools.Ipmi) or isinstance(tool, tools.VendorTool):
             # Have we removed the cronjob script helper?
-            cronjob_path = os.path.join(tool.NRPE_PLUGINS_DIR,
-                                        tool._cron_script)
-            print('Checking {}'.format(cronjob_path))
+            cronjob_path = os.path.join(tool.NRPE_PLUGINS_DIR, tool._cron_script)
+            print("Checking {}".format(cronjob_path))
             with pytest.raises(RuntimeError):
                 await file_stat(cronjob_path, ubuntu_unit)
 
             # Have we removed the cronjob itself?
-            cronjob_path = os.path.join(tool.CROND_DIR,
-                                        'hwhealth_{}'.format(tool._shortname))
-            print('Checking {}'.format(cronjob_path))
+            cronjob_path = os.path.join(
+                tool.CROND_DIR, "hwhealth_{}".format(tool._shortname)
+            )
+            print("Checking {}".format(cronjob_path))
             with pytest.raises(RuntimeError):
                 await file_stat(cronjob_path, ubuntu_unit)
 
-        if isinstance(tool, tools.VendorTool) and not isinstance(tool, tools.Mdadm):  # noqa E501
+        if isinstance(tool, tools.VendorTool) and not isinstance(
+            tool, tools.Mdadm
+        ):  # noqa E501
             # /sbin/mdadm will not be removed, but the vendor binaries
             # should have been
             bin_path = os.path.join(tool.TOOLS_DIR, tool._shortname)
-            print('Checking {}'.format(bin_path))
+            print("Checking {}".format(bin_path))
             with pytest.raises(RuntimeError):
                 await file_stat(bin_path, ubuntu_unit)
diff --git a/src/tests/unit/lib/samples.py b/src/tests/unit/lib/samples.py
index a0790ee..db34828 100644
--- a/src/tests/unit/lib/samples.py
+++ b/src/tests/unit/lib/samples.py
@@ -1,12 +1,7 @@
 import os
 import glob
 
-SAMPLES_DIR = os.path.join(
-    os.path.dirname(__file__),
-    '..',
-    '..',
-    'hw-health-samples'
-)
+SAMPLES_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "hw-health-samples")
 
 
 def get_sample(name):
diff --git a/src/tests/unit/test_actions.py b/src/tests/unit/test_actions.py
index dfa7323..3a3f4f2 100644
--- a/src/tests/unit/test_actions.py
+++ b/src/tests/unit/test_actions.py
@@ -17,110 +17,149 @@ import sys
 import unittest
 import unittest.mock as mock
 
-sys.path.append('.')
+sys.path.append(".")
 from actions.actions import clear_sel, show_sel  # noqa:E402
 
 
 class ClearSelTestCase(unittest.TestCase):
-
-    @mock.patch('actions.actions.log')
-    @mock.patch('subprocess.check_output')
-    @mock.patch('subprocess.check_call')
+    @mock.patch("actions.actions.log")
+    @mock.patch("subprocess.check_output")
+    @mock.patch("subprocess.check_call")
     def test_clear_sel(self, mock_check_call, mock_subprocess, mock_log):
         sel_output = "Unittest system event log output".encode()
         mock_subprocess.return_value = sel_output
         mock_check_call.return_value = None
         clear_sel()
-        mock_check_call.assert_called_once_with(['action-set', "message={}".format(sel_output.decode())])
+        mock_check_call.assert_called_once_with(
+            ["action-set", "message={}".format(sel_output.decode())]
+        )
 
 
 class ShowSelTestCase(unittest.TestCase):
-
-    @mock.patch('actions.actions.log')
-    @mock.patch('actions.actions.action_set')
-    @mock.patch('actions.actions.action_get')
-    @mock.patch('subprocess.check_output')
+    @mock.patch("actions.actions.log")
+    @mock.patch("actions.actions.action_set")
+    @mock.patch("actions.actions.action_get")
+    @mock.patch("subprocess.check_output")
     def test_empty_output_from_ipmi_sel(
-            self, mock_check_output, mock_action_get, mock_action_set, mock_log):
+        self, mock_check_output, mock_action_get, mock_action_set, mock_log
+    ):
         show_all_flag = False
         output_body = ""
         expected_output = "No matching entries found"
-        self._test_valid_show_sel_call(show_all_flag, output_body, expected_output,
-                                       mock_check_output, mock_action_get, mock_action_set)
+        self._test_valid_show_sel_call(
+            show_all_flag,
+            output_body,
+            expected_output,
+            mock_check_output,
+            mock_action_get,
+            mock_action_set,
+        )
 
-    @mock.patch('actions.actions.log')
-    @mock.patch('actions.actions.action_set')
-    @mock.patch('actions.actions.action_get')
-    @mock.patch('subprocess.check_output')
+    @mock.patch("actions.actions.log")
+    @mock.patch("actions.actions.action_set")
+    @mock.patch("actions.actions.action_get")
+    @mock.patch("subprocess.check_output")
     def test_only_nominal_entries_with_show_all_false(
-            self, mock_check_output, mock_action_get, mock_action_set, mock_log):
+        self, mock_check_output, mock_action_get, mock_action_set, mock_log
+    ):
         show_all_flag = False
-        output_body = "\n".join([
-            "Header line",
-            "Nominal body line #1",
-            "Nominal body line #2",
-            "Nominal body line #3",
-        ])
+        output_body = "\n".join(
+            [
+                "Header line",
+                "Nominal body line #1",
+                "Nominal body line #2",
+                "Nominal body line #3",
+            ]
+        )
         expected_output = "No matching entries found"
-        self._test_valid_show_sel_call(show_all_flag, output_body, expected_output,
-                                       mock_check_output, mock_action_get, mock_action_set)
+        self._test_valid_show_sel_call(
+            show_all_flag,
+            output_body,
+            expected_output,
+            mock_check_output,
+            mock_action_get,
+            mock_action_set,
+        )
 
-    @mock.patch('actions.actions.log')
-    @mock.patch('actions.actions.action_set')
-    @mock.patch('actions.actions.action_get')
-    @mock.patch('subprocess.check_output')
+    @mock.patch("actions.actions.log")
+    @mock.patch("actions.actions.action_set")
+    @mock.patch("actions.actions.action_get")
+    @mock.patch("subprocess.check_output")
     def test_only_nominal_entries_with_show_all_true(
-            self, mock_check_output, mock_action_get, mock_action_set, mock_log):
+        self, mock_check_output, mock_action_get, mock_action_set, mock_log
+    ):
         show_all_flag = True
-        output_body = "\n".join([
-            "Header line",
-            "Nominal body line #1",
-            "Nominal body line #2",
-            "Nominal body line #3",
-        ])
+        output_body = "\n".join(
+            [
+                "Header line",
+                "Nominal body line #1",
+                "Nominal body line #2",
+                "Nominal body line #3",
+            ]
+        )
         expected_output = output_body
-        self._test_valid_show_sel_call(show_all_flag, output_body, expected_output,
-                                       mock_check_output, mock_action_get, mock_action_set)
+        self._test_valid_show_sel_call(
+            show_all_flag,
+            output_body,
+            expected_output,
+            mock_check_output,
+            mock_action_get,
+            mock_action_set,
+        )
 
-    @mock.patch('actions.actions.log')
-    @mock.patch('actions.actions.action_set')
-    @mock.patch('actions.actions.action_get')
-    @mock.patch('subprocess.check_output')
+    @mock.patch("actions.actions.log")
+    @mock.patch("actions.actions.action_set")
+    @mock.patch("actions.actions.action_get")
+    @mock.patch("subprocess.check_output")
     def test_non_nominal_entries_present_with_show_all_false(
-            self, mock_check_output, mock_action_get, mock_action_set, mock_log):
+        self, mock_check_output, mock_action_get, mock_action_set, mock_log
+    ):
         show_all_flag = False
-        output_body = "\n".join([
-            "Header line",
-            "Nominal body line #1",
-            "Warning line #1",
-            "Critical line #1",
-            "Nominal body line #2",
-            "Nominal body line #3",
-            "Warning line #2",
-        ])
-        expected_output = "\n".join([
-            "Header line",
-            "Warning line #1",
-            "Critical line #1",
-            "Warning line #2",
-        ])
-        self._test_valid_show_sel_call(show_all_flag, output_body, expected_output,
-                                       mock_check_output, mock_action_get, mock_action_set)
+        output_body = "\n".join(
+            [
+                "Header line",
+                "Nominal body line #1",
+                "Warning line #1",
+                "Critical line #1",
+                "Nominal body line #2",
+                "Nominal body line #3",
+                "Warning line #2",
+            ]
+        )
+        expected_output = "\n".join(
+            ["Header line", "Warning line #1", "Critical line #1", "Warning line #2"]
+        )
+        self._test_valid_show_sel_call(
+            show_all_flag,
+            output_body,
+            expected_output,
+            mock_check_output,
+            mock_action_get,
+            mock_action_set,
+        )
 
-    def _test_valid_show_sel_call(self, show_all_flag, output_body, expected_output,
-                                  mock_check_output, mock_action_get, mock_action_set):
+    def _test_valid_show_sel_call(
+        self,
+        show_all_flag,
+        output_body,
+        expected_output,
+        mock_check_output,
+        mock_action_get,
+        mock_action_set,
+    ):
         mock_action_get.return_value = show_all_flag
         mock_check_output.return_value = output_body.encode()
         show_sel()
-        self.assertEqual(mock_action_set.call_args[0][0]['message'],
-                         expected_output)
+        self.assertEqual(mock_action_set.call_args[0][0]["message"], expected_output)
 
-    @mock.patch('actions.actions.action_fail')
-    @mock.patch('actions.actions.action_get')
-    @mock.patch('subprocess.check_output')
-    def test_subprocess_error(self, mock_check_output, mock_action_get, mock_action_fail):
+    @mock.patch("actions.actions.action_fail")
+    @mock.patch("actions.actions.action_get")
+    @mock.patch("subprocess.check_output")
+    def test_subprocess_error(
+        self, mock_check_output, mock_action_get, mock_action_fail
+    ):
         def raise_error(*args, **kwargs):
-            raise subprocess.CalledProcessError(1, ['bogus-cmd'])
+            raise subprocess.CalledProcessError(1, ["bogus-cmd"])
 
         show_all_flag = False
         mock_action_get.return_value = show_all_flag
@@ -128,4 +167,6 @@ class ShowSelTestCase(unittest.TestCase):
         show_sel()
         self.assertEqual(
             mock_action_fail.call_args[0][0],
-            "Action failed with Command '['bogus-cmd']' returned non-zero exit status 1.")
+            "Action failed with Command '['bogus-cmd']' "
+            "returned non-zero exit status 1.",
+        )
diff --git a/src/tests/unit/test_check_mdadm.py b/src/tests/unit/test_check_mdadm.py
index ca20633..fe7e357 100644
--- a/src/tests/unit/test_check_mdadm.py
+++ b/src/tests/unit/test_check_mdadm.py
@@ -6,67 +6,56 @@ import unittest.mock as mock
 
 import nagios_plugin3
 
-sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
 from samples import get_sample  # noqa: E402
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '../../files/mdadm'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "../../files/mdadm"))
 import check_mdadm  # noqa: E402
 
 
 class TestCheckMdadm(unittest.TestCase):
     def setUp(self):
-        self.samples_dir = os.path.join(
-            os.getcwd(),
-            'tests',
-            'hw-health-samples'
-        )
+        self.samples_dir = os.path.join(os.getcwd(), "tests", "hw-health-samples")
 
     def test_parse_output_crit(self):
-        check_mdadm.ARGS.input_file = get_sample('mdadm.output.nrpe.critical')
-        expected = 'CRITICAL: critical msg'
+        check_mdadm.ARGS.input_file = get_sample("mdadm.output.nrpe.critical")
+        expected = "CRITICAL: critical msg"
         with self.assertRaises(nagios_plugin3.CriticalError) as context:
             check_mdadm.parse_output()
         self.assertTrue(expected in str(context.exception))
 
     def test_parse_output_warn(self):
-        check_mdadm.ARGS.input_file = get_sample('mdadm.output.nrpe.warning')
-        expected = 'WARNING: warning msg'
+        check_mdadm.ARGS.input_file = get_sample("mdadm.output.nrpe.warning")
+        expected = "WARNING: warning msg"
         with self.assertRaises(nagios_plugin3.WarnError) as context:
             check_mdadm.parse_output()
         self.assertTrue(expected in str(context.exception))
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_ok(self, mock_print):
-        check_mdadm.ARGS.input_file = get_sample('mdadm.output.nrpe.ok')
+        check_mdadm.ARGS.input_file = get_sample("mdadm.output.nrpe.ok")
         check_mdadm.parse_output()
         self.assertEqual(
             mock_print.getvalue(),
-            'OK: /dev/md0 ok; /dev/md1 ok; /dev/md3 ok; /dev/md2 ok\n'
+            "OK: /dev/md0 ok; /dev/md1 ok; /dev/md3 ok; /dev/md2 ok\n",
         )
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_unknown_filenotfound(self, mock_print):
-        check_mdadm.ARGS.input_file = get_sample('thisfiledoesnotexist')
-        expected = 'UNKNOWN: file not found ({})'.format(
-            check_mdadm.ARGS.input_file)
+        check_mdadm.ARGS.input_file = get_sample("thisfiledoesnotexist")
+        expected = "UNKNOWN: file not found ({})".format(check_mdadm.ARGS.input_file)
         with self.assertRaises(nagios_plugin3.UnknownError) as context:
             check_mdadm.parse_output()
         self.assertTrue(expected in str(context.exception))
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_unknown1(self, mock_print):
-        check_mdadm.ARGS.input_file = get_sample('mdadm.output.nrpe.unknown.1')
+        check_mdadm.ARGS.input_file = get_sample("mdadm.output.nrpe.unknown.1")
         check_mdadm.parse_output()
-        self.assertEqual(
-            mock_print.getvalue(),
-            'UNKNOWN: unknown msg\n'
-        )
+        self.assertEqual(mock_print.getvalue(), "UNKNOWN: unknown msg\n")
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_unknown2(self, mock_print):
-        check_mdadm.ARGS.input_file = get_sample('mdadm.output.nrpe.unknown.2')
+        check_mdadm.ARGS.input_file = get_sample("mdadm.output.nrpe.unknown.2")
         check_mdadm.parse_output()
-        self.assertEqual(
-            mock_print.getvalue(),
-            'unknown msg2\n'
-        )
+        self.assertEqual(mock_print.getvalue(), "unknown msg2\n")
diff --git a/src/tests/unit/test_check_megacli.py b/src/tests/unit/test_check_megacli.py
index 00b9f4e..a6e7501 100644
--- a/src/tests/unit/test_check_megacli.py
+++ b/src/tests/unit/test_check_megacli.py
@@ -6,42 +6,40 @@ import unittest.mock as mock
 
 import nagios_plugin3
 
-sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
 from samples import get_sample  # noqa: E402
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '../../files/megacli'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "../../files/megacli"))
 import check_megacli  # noqa: E402
 
 
 class TestCheckMegaCLI(unittest.TestCase):
     def setUp(self):
-        self.samples_dir = os.path.join(
-            os.getcwd(),
-            'tests',
-            'hw-health-samples'
-        )
+        self.samples_dir = os.path.join(os.getcwd(), "tests", "hw-health-samples")
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output(self, mock_print):
-        check_megacli.ARGS.input_file = get_sample('megacli.output.1')
+        check_megacli.ARGS.input_file = get_sample("megacli.output.1")
         check_megacli.parse_output()
         actual = mock_print.getvalue()
-        expected = 'OK: Optimal, ldrives[1], pdrives[4]\n'
+        expected = "OK: Optimal, ldrives[1], pdrives[4]\n"
         self.assertEqual(actual, expected)
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_critical_singledrive(self, mock_print):
-        check_megacli.ARGS.input_file = get_sample('megacli.output.nrpe.critical.1')
-        expected = 'CRITICAL: adapter(0):ld(0):state(Degraded)'
+        check_megacli.ARGS.input_file = get_sample("megacli.output.nrpe.critical.1")
+        expected = "CRITICAL: adapter(0):ld(0):state(Degraded)"
         with self.assertRaises(nagios_plugin3.CriticalError) as context:
             check_megacli.parse_output()
         self.assertEqual(expected, str(context.exception))
 
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_critical_multiple(self, mock_print):
-        check_megacli.ARGS.input_file = get_sample('megacli.output.nrpe.critical.2')
-        expected = ('CRITICAL: adapter(0):ld(0):state(Degraded);'
-                    ' adapter(0):ld(4):state(Degraded)')
+        check_megacli.ARGS.input_file = get_sample("megacli.output.nrpe.critical.2")
+        expected = (
+            "CRITICAL: adapter(0):ld(0):state(Degraded);"
+            " adapter(0):ld(4):state(Degraded)"
+        )
         with self.assertRaises(nagios_plugin3.CriticalError) as context:
             check_megacli.parse_output()
         self.assertEqual(expected, str(context.exception))
diff --git a/src/tests/unit/test_check_nvme.py b/src/tests/unit/test_check_nvme.py
index 097fd76..4218a85 100644
--- a/src/tests/unit/test_check_nvme.py
+++ b/src/tests/unit/test_check_nvme.py
@@ -4,21 +4,21 @@ import sys
 import unittest
 import unittest.mock as mock
 
-sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
 from samples import get_sample  # noqa: E402
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '../../files/nvme'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "../../files/nvme"))
 import check_nvme  # noqa: E402
 
 
 class TestCheckNvme(unittest.TestCase):
-    @mock.patch('check_nvme.glob.glob')
-    @mock.patch('check_nvme.subprocess.check_output')
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("check_nvme.glob.glob")
+    @mock.patch("check_nvme.subprocess.check_output")
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output(self, mock_print, mock_subprocess, mock_glob):
-        mock_glob.return_value = ['/dev/nvme0']
-        input_file = get_sample('nvme.output.1')
-        with open(input_file, 'r') as fd:
+        mock_glob.return_value = ["/dev/nvme0"]
+        input_file = get_sample("nvme.output.1")
+        with open(input_file, "r") as fd:
             mock_subprocess.return_value = fd.read().encode()
         check_nvme.parse_output()
         expected = (
diff --git a/src/tests/unit/test_check_sas2ircu.py b/src/tests/unit/test_check_sas2ircu.py
index cd5e854..e2053d7 100644
--- a/src/tests/unit/test_check_sas2ircu.py
+++ b/src/tests/unit/test_check_sas2ircu.py
@@ -4,18 +4,18 @@ import sys
 import unittest
 import unittest.mock as mock
 
-sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
 from samples import get_sample  # noqa: E402
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '../../files/sas2ircu'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "../../files/sas2ircu"))
 import check_sas2ircu  # noqa: E402
 
 
 class TestCheckMegaCLI(unittest.TestCase):
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output(self, mock_print):
-        check_sas2ircu.ARGS.input_file = get_sample('sas2ircu.huawei.output.1')
+        check_sas2ircu.ARGS.input_file = get_sample("sas2ircu.huawei.output.1")
         check_sas2ircu.parse_output()
         actual = mock_print.getvalue()
-        expected = 'OK: Ready[1:0,1:1,1:2,1:3,1:4,1:5,1:6,1:7]\n'
+        expected = "OK: Ready[1:0,1:1,1:2,1:3,1:4,1:5,1:6,1:7]\n"
         self.assertEqual(actual, expected)
diff --git a/src/tests/unit/test_check_sas3ircu.py b/src/tests/unit/test_check_sas3ircu.py
index 1379369..bb79688 100644
--- a/src/tests/unit/test_check_sas3ircu.py
+++ b/src/tests/unit/test_check_sas3ircu.py
@@ -4,19 +4,19 @@ import sys
 import unittest
 import unittest.mock as mock
 
-sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))
 from samples import get_sample  # noqa: E402
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '../../files/sas3ircu'))
+sys.path.append(os.path.join(os.path.dirname(__file__), "../../files/sas3ircu"))
 import check_sas3ircu  # noqa: E402
 
 
 class TestCheckMegaCLI(unittest.TestCase):
-    @mock.patch('sys.stdout', new_callable=io.StringIO)
+    @mock.patch("sys.stdout", new_callable=io.StringIO)
     def test_parse_output_ok(self, mock_print):
-        _filepath = get_sample('sas3ircu.supermicro.ok.output.1')
+        _filepath = get_sample("sas3ircu.supermicro.ok.output.1")
         data = check_sas3ircu.parse_output(_filepath)
         check_sas3ircu.eval_status(data)
         actual = mock_print.getvalue()
-        expected = 'OK: no errors\n'
+        expected = "OK: no errors\n"
         self.assertEqual(actual, expected)
diff --git a/src/tests/unit/test_cron_hplog.py b/src/tests/unit/test_cron_hplog.py
index 87c5034..b17904e 100644
--- a/src/tests/unit/test_cron_hplog.py
+++ b/src/tests/unit/test_cron_hplog.py
@@ -4,27 +4,30 @@ import unittest
 from argparse import Namespace
 from pathlib import Path
 
-sys.path.append('files/hplog')
+sys.path.append("files/hplog")
 import cron_hplog  # noqa: E402
 
 
 class TestCronHPlog(unittest.TestCase):
     def setUp(self):
         # Skip the v flag, it serves a different purpose
-        self.test_flags = {'t', 'f', 'p'}
+        self.test_flags = {"t", "f", "p"}
 
     def _get_no_error_sample(self, flag):
-        _filepath = os.path.join(os.getcwd(), 'tests', 'hw-health-samples',
-                                 'hplog.{}.ewah.out'.format(flag))
+        _filepath = os.path.join(
+            os.getcwd(), "tests", "hw-health-samples", "hplog.{}.ewah.out".format(flag)