Merge ~dannf/canonical-server-hwe-utils:pre-commit into canonical-server-hwe-utils:master

[dann frazier]

[Alexandre Erwin Ittner (aittner)]

The python-black + pre-commit that we already agreed upon and code reformatting. Clear approval!

review: Approve

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..5f7fa9a
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,10 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: stable
+    hooks:
+      - id: black
+        language_version: python3.8
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: master
+    hooks:
+      - id: flake8
diff --git a/labkey b/labkey
index fe3f4ae..47f996b 100755
--- a/labkey
+++ b/labkey
@@ -9,8 +9,8 @@ import sys
 import yaml
 
 ProgName = "labkey"
-Config = os.path.join(os.environ['HOME'], '.config', ProgName)
-ScaleBotLocal = os.path.join(Config, 'scalebot-repo')
+Config = os.path.join(os.environ["HOME"], ".config", ProgName)
+ScaleBotLocal = os.path.join(Config, "scalebot-repo")
 
 
 def update(lpid, force):
@@ -22,34 +22,31 @@ def update(lpid, force):
         shutil.rmtree(ScaleBotLocal)
 
     ScaleBotRemote = "git+ssh://%sgit.launchpad.net/scalebot" % (user)
-    umaskSav = os.umask(int('077', 8))
+    umaskSav = os.umask(int("077", 8))
     if os.path.exists(ScaleBotLocal):
         os.chdir(ScaleBotLocal)
-        subprocess.run(['git', 'pull'], check=True)
+        subprocess.run(["git", "pull"], check=True)
     else:
-        subprocess.run(['git', 'clone',
-                        ScaleBotRemote, ScaleBotLocal],
-                       check=True)
+        subprocess.run(["git", "clone", ScaleBotRemote, ScaleBotLocal], check=True)
     os.umask(umaskSav)
 
 
 def loadLabs():
     config = []
-    labroot = os.path.join(ScaleBotLocal, 'labs')
+    labroot = os.path.join(ScaleBotLocal, "labs")
     for labdir in os.scandir(labroot):
         if not labdir.is_dir():
             continue
         lab = None
         machines = None
         for f in os.scandir(labdir):
-            if f.name == 'lab.yaml':
-                with open(f.path, 'r') as stream:
+            if f.name == "lab.yaml":
+                with open(f.path, "r") as stream:
                     lab = yaml.load(stream, Loader=yaml.SafeLoader)
-            elif f.name == 'machines.yaml':
-                with open(f.path, 'r') as stream:
+            elif f.name == "machines.yaml":
+                with open(f.path, "r") as stream:
                     machines = yaml.load(stream, Loader=yaml.SafeLoader)
-        config.append({'lab': lab,
-                       'machines': machines})
+        config.append({"lab": lab, "machines": machines})
     return config
 
 
@@ -58,96 +55,123 @@ class Machine:
         self.name = name
         labs = loadLabs()
         for lab in labs:
-            if lab['machines'] is None:
+            if lab["machines"] is None:
                 continue
-            if name in lab['machines'].keys():
-                self.data = lab['machines'][name]
-                self.labdata = lab['lab']
+            if name in lab["machines"].keys():
+                self.data = lab["machines"][name]
+                self.labdata = lab["lab"]
                 return
-        raise KeyError('Machine not found')
+        raise KeyError("Machine not found")
 
     def __repr__(self):
         return yaml.dump(self.data, default_flow_style=False)
 
     def _do_ipmitool(self, cmd):
-        bmc = self.data['bmc']
-        if bmc['type'] != "ipmi":
-            raise KeyError('Machine has unknown power type')
-        subprocess.run(['ipmitool', '-I', 'lanplus',
-                        '-H', bmc['address'],
-                        '-U', bmc['user'],
-                        '-P', bmc['password']] + cmd, check=True)
+        bmc = self.data["bmc"]
+        if bmc["type"] != "ipmi":
+            raise KeyError("Machine has unknown power type")
+        subprocess.run(
+            [
+                "ipmitool",
+                "-I",
+                "lanplus",
+                "-H",
+                bmc["address"],
+                "-U",
+                bmc["user"],
+                "-P",
+                bmc["password"],
+            ]
+            + cmd,
+            check=True,
+        )
 
     def mc_reset(self):
-        cmd = ['mc', 'reset', 'cold']
+        cmd = ["mc", "reset", "cold"]
         self._do_ipmitool(cmd)
 
     def power(self, state):
-        cmd = ['chassis', 'power', state]
+        cmd = ["chassis", "power", state]
         self._do_ipmitool(cmd)
 
     def open_console(self):
-        '''
+        """
         Open an interactive console session to the machine.
         Currently only supports conserver.
-        '''
+        """
         if self.labdata is None:
-            raise KeyError('No lab.yaml associated with %s' % (self.name))
-        if 'conserver' not in self.labdata.keys():
-            raise KeyError('No conserver defined for lab %s' %
-                           (self.labdata['name']))
-        concfg = self.labdata['conserver']
-        subprocess.run(['console', '-M%s' % (concfg['master']),
-                        '-p%s' % (concfg['port']),
-                        self.name],
-                       stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
-        subprocess.run(['console', '-M%s' % (concfg['master']),
-                        '-p%s' % (concfg['port']),
-                        self.name],
-                       capture_output=True)
-
-
-if __name__ == '__main__':
-    power_cmds = ['on', 'off', 'cycle', 'mc-reset', 'reset', 'status']
-    machine_cmds = power_cmds + ['console', 'show']
+            raise KeyError("No lab.yaml associated with %s" % (self.name))
+        if "conserver" not in self.labdata.keys():
+            raise KeyError("No conserver defined for lab %s" % (self.labdata["name"]))
+        concfg = self.labdata["conserver"]
+        subprocess.run(
+            [
+                "console",
+                "-M%s" % (concfg["master"]),
+                "-p%s" % (concfg["port"]),
+                self.name,
+            ],
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        subprocess.run(
+            [
+                "console",
+                "-M%s" % (concfg["master"]),
+                "-p%s" % (concfg["port"]),
+                self.name,
+            ],
+            capture_output=True,
+        )
+
+
+if __name__ == "__main__":
+    power_cmds = ["on", "off", "cycle", "mc-reset", "reset", "status"]
+    machine_cmds = power_cmds + ["console", "show"]
     cmd_help = {
-        'show': "Show machine configuration",
-        'on': "Power machine on",
-        'off': "Power machine off",
-        'cycle': "Power cycle machine",
-        'mc-reset': "Perform cold reset of BMC",
-        'reset': "Hard reset machine",
-        'console': "Open a console session",
-        'status': "Show machine power status",
-        'update': "Update cached machine information",
+        "show": "Show machine configuration",
+        "on": "Power machine on",
+        "off": "Power machine off",
+        "cycle": "Power cycle machine",
+        "mc-reset": "Perform cold reset of BMC",
+        "reset": "Hard reset machine",
+        "console": "Open a console session",
+        "status": "Show machine power status",
+        "update": "Update cached machine information",
     }
 
-    d = 'Do things with machines in ScaleBot labs'
+    d = "Do things with machines in ScaleBot labs"
     parser = argparse.ArgumentParser(prog=ProgName, description=d)
-    subparsers = parser.add_subparsers(help='sub-command help')
-    update_parser = subparsers.add_parser('update', help=cmd_help['update'])
-    update_parser.add_argument('-u', dest='lpid', metavar='LPID',
-                               required=False, help="Launchpad ID")
-    update_parser.add_argument('-f', dest='force', action='store_true',
-                               required=False,
-                               help="Flush machine cache before update")
-    update_parser.set_defaults(cmd='update')
+    subparsers = parser.add_subparsers(help="sub-command help")
+    update_parser = subparsers.add_parser("update", help=cmd_help["update"])
+    update_parser.add_argument(
+        "-u", dest="lpid", metavar="LPID", required=False, help="Launchpad ID"
+    )
+    update_parser.add_argument(
+        "-f",
+        dest="force",
+        action="store_true",
+        required=False,
+        help="Flush machine cache before update",
+    )
+    update_parser.set_defaults(cmd="update")
     for a in machine_cmds:
         action_parser = subparsers.add_parser(a, help=cmd_help[a])
-        action_parser.add_argument('machine', metavar='MACHINE')
+        action_parser.add_argument("machine", metavar="MACHINE")
         action_parser.set_defaults(cmd=a)
     args = parser.parse_args()
 
-    if args.cmd == 'update':
+    if args.cmd == "update":
         update(lpid=args.lpid, force=args.force)
         sys.exit(0)
 
     m = Machine(args.machine)
-    if args.cmd == 'show':
+    if args.cmd == "show":
         print(m)
-    elif args.cmd == 'mc-reset':
+    elif args.cmd == "mc-reset":
         m.mc_reset()
-    elif args.cmd == 'console':
+    elif args.cmd == "console":
         m.open_console()
     elif args.cmd in power_cmds:
         m.power(args.cmd)
diff --git a/lp-scripts/LaunchpadBugBucketer.py b/lp-scripts/LaunchpadBugBucketer.py
index 7831132..81e9e99 100644
--- a/lp-scripts/LaunchpadBugBucketer.py
+++ b/lp-scripts/LaunchpadBugBucketer.py
@@ -49,7 +49,7 @@ class LaunchpadBugBucketer(collections.UserDict):
             requiredTags (:obj:`list` of :obj:`str`): Only bucket bugs that
                 have one or more tags from this list.
         """
-        self.lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+        self.lp = Launchpad.login_with("lpbugs", "production", version="devel")
         self.project = self.lp.projects[project]
         self.series = series
         self.requiredTags = requiredTags
@@ -57,8 +57,8 @@ class LaunchpadBugBucketer(collections.UserDict):
         collections.UserDict.__init__(self, self.buckets)
 
     def taskToBug(self, task):
-        bugid = int(task.self_link.split('/')[-1])
-        return(self.lp.bugs[bugid])
+        bugid = int(task.self_link.split("/")[-1])
+        return self.lp.bugs[bugid]
 
     def _doBucketing(self):
         methods = inspect.getmembers(self, predicate=inspect.ismethod)
@@ -72,10 +72,10 @@ class LaunchpadBugBucketer(collections.UserDict):
                 if not set(self.requiredTags) & set(bug.tags):
                     continue
                 for mName, mFunc in methods:
-                    if not mName.startswith('is_'):
+                    if not mName.startswith("is_"):
                         continue
                     if mFunc(task):
-                        b = mName[len('is_'):]
+                        b = mName[len("is_") :]
                         if b not in self.buckets.keys():
                             self.buckets[b] = []
                         self.buckets[b].append(task)
diff --git a/lp-scripts/bandera-bug-csv-summary.py b/lp-scripts/bandera-bug-csv-summary.py
index 1fae696..05f84aa 100755
--- a/lp-scripts/bandera-bug-csv-summary.py
+++ b/lp-scripts/bandera-bug-csv-summary.py
@@ -7,18 +7,19 @@ from LaunchpadBugBucketer import LaunchpadBugBucketer
 
 class BanderaBugBucketer(LaunchpadBugBucketer):
     def __init__(self):
-        LaunchpadBugBucketer.__init__(self, 'bandera', 'ubuntu-16.04',
-                                      requiredTags=['patchset'])
+        LaunchpadBugBucketer.__init__(
+            self, "bandera", "ubuntu-16.04", requiredTags=["patchset"]
+        )
 
     def is_green(self, task):
-        if task.status in ['Fix Committed', 'Fix Released']:
+        if task.status in ["Fix Committed", "Fix Released"]:
             return True
         return False
 
     def is_amber(self, task):
         if self.is_green(task):
             return False
-        elif task.milestone and task.milestone.name == 'ubuntu-16.04.3':
+        elif task.milestone and task.milestone.name == "ubuntu-16.04.3":
             return True
         return False
 
@@ -28,16 +29,16 @@ class BanderaBugBucketer(LaunchpadBugBucketer):
         return True
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile")
     args = parser.parse_args()
 
     s = BanderaBugBucketer()
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(['Title', 'Bug ID', 'Importance', 'Status', 'RAG Risk'])
+        c.writerow(["Title", "Bug ID", "Importance", "Status", "RAG Risk"])
         for bucket in s.keys():
             for task in s[bucket]:
                 bug = s.taskToBug(task)
diff --git a/lp-scripts/bugreport/bugreport.py b/lp-scripts/bugreport/bugreport.py
index bc347b9..ca9b5b1 100755
--- a/lp-scripts/bugreport/bugreport.py
+++ b/lp-scripts/bugreport/bugreport.py
@@ -3,7 +3,6 @@
 # License: GPLv3
 from launchpadlib.launchpad import Launchpad
 from launchpadlib.uris import LPNET_SERVICE_ROOT
-from launchpadlib.credentials import Credentials
 from optparse import OptionParser
 from re import compile
 from datetime import datetime as dt
@@ -16,7 +15,7 @@ import sys
 def gen_bug_report(lp, lp_bugs, project, verbose):
     bug_summary_info = coldict(dict)
     bug_details_info = coldict(dict)
-    url = compile('https://api.launchpad.net/1.0/~|/')
+    url = compile("https://api.launchpad.net/1.0/~|/")
 
     for task in lp_bugs:
         bug_info = {}
@@ -27,13 +26,13 @@ def gen_bug_report(lp, lp_bugs, project, verbose):
         else:
             bug_summary_info[task.importance][task.status] = 1
 
-        if '#Bugs Processed' in bug_summary_info[task.importance]:
-            bug_summary_info[task.importance]['#Bugs Processed'] += 1
+        if "#Bugs Processed" in bug_summary_info[task.importance]:
+            bug_summary_info[task.importance]["#Bugs Processed"] += 1
         else:
-            bug_summary_info[task.importance]['#Bugs Processed'] = 1
+            bug_summary_info[task.importance]["#Bugs Processed"] = 1
 
-        if '#Bugs Closed' not in bug_summary_info[task.importance]:
-            bug_summary_info[task.importance]['#Bugs Closed'] = 0
+        if "#Bugs Closed" not in bug_summary_info[task.importance]:
+            bug_summary_info[task.importance]["#Bugs Closed"] = 0
 
         # A bug could affect multiple projects, we care only whether
         # the project we are tracking is complete.
@@ -42,33 +41,40 @@ def gen_bug_report(lp, lp_bugs, project, verbose):
             if bugtask.bug_target_name in project:
                 bug_is_complete = bugtask.is_complete
             if verbose is True:
-                bug_subtask.append(
-                    '%s: %s' % (bugtask.bug_target_name, bugtask.status))
+                bug_subtask.append("%s: %s" % (bugtask.bug_target_name, bugtask.status))
 
         if bug_is_complete is True:
-            if '#Bugs Closed' in bug_summary_info[task.importance]:
-                bug_summary_info[task.importance]['#Bugs Closed'] += 1
+            if "#Bugs Closed" in bug_summary_info[task.importance]:
+                bug_summary_info[task.importance]["#Bugs Closed"] += 1
 
         if verbose is True:
             inactive_days = 0
             if bug_is_complete is not True:
                 inactive_days = np.busday_count(
                     task.bug.date_last_updated.strftime("%Y-%m-%d"),
-                        dt.now().strftime("%Y-%m-%d"))
+                    dt.now().strftime("%Y-%m-%d"),
+                )
 
             active_days = np.busday_count(
                 task.bug.date_created.strftime("%Y-%m-%d"),
-                    task.bug.date_last_updated.strftime("%Y-%m-%d"))
+                task.bug.date_last_updated.strftime("%Y-%m-%d"),
+            )
 
-            assignee = 'Unassigned' if task.assignee_link is None \
-                else url.sub('', task.assignee_link)
+            assignee = (
+                "Unassigned"
+                if task.assignee_link is None
+                else url.sub("", task.assignee_link)
+            )
 
             bug_info[task.bug.id] = [
                 task.bug.date_created.strftime("%Y-%m-%d"),
-                    task.bug.date_last_updated.strftime("%Y-%m-%d"),
-                    active_days,
-                    inactive_days, task.bug.message_count, assignee,
-                    "''<br>''".join(bug_subtask)]
+                task.bug.date_last_updated.strftime("%Y-%m-%d"),
+                active_days,
+                inactive_days,
+                task.bug.message_count,
+                assignee,
+                "''<br>''".join(bug_subtask),
+            ]
 
             bug_details_info[task.importance].update(bug_info)
 
@@ -76,95 +82,151 @@ def gen_bug_report(lp, lp_bugs, project, verbose):
 
 
 def main():
-    parser = OptionParser(usage='usage: %prog [options]', version='%prog 1.0')
-    parser.add_option('-d', '--date', dest='start_date', action='store',
-                      default='2017-01-01',
-                      type='string', help='start date for bug search')
-    parser.add_option('-p', '--project', dest='project', action='store',
-                      default='ubuntu-power-systems',
-                      type='string', help='name of the launchpad project')
-    parser.add_option('-s', '--status', dest='bug_status', action='store',
-                      default=('New,Opinion,Invalid,Won\'t Fix,Expired,'
-                               'Confirmed,Triaged,In Progress,Fix Committed,'
-                               'Fix Released,Incomplete'),
-                      type='string',
-                      help='bug status (or quoted and comma seperated list)')
-    parser.add_option('-i', '--importance', dest='bug_importance',
-                      default=(
-                          'Unknown,Undecided,Critical,High,Medium,Low,Wishlist'),
-                      type='string',
-                      help='bug importance (or comma seperated list, no spaces)')
-    parser.add_option('-t', '--tag', dest='bug_tag', default=None,
-                      help='bug tag (or quoted and comma seperated list)')
-    parser.add_option('-m', '--modify', dest='bug_tag_modify', default='Any',
-                      help='search any or all tags (valid args: any or all)')
-    parser.add_option('-v', '--verbose', dest='verbose', action='store_true',
-                      help='verbose output with bug details')
-    parser.add_option('-a', '--author', dest='author',
-                      default='Manoj Iyer [e-mail]',
-                      help='"Firstname Lastname [e-mail]"')
-    parser.add_option('-o', '--outfile', dest='outfile',
-                      help='filename to store output (default stdout)')
+    parser = OptionParser(usage="usage: %prog [options]", version="%prog 1.0")
+    parser.add_option(
+        "-d",
+        "--date",
+        dest="start_date",
+        action="store",
+        default="2017-01-01",
+        type="string",
+        help="start date for bug search",
+    )
+    parser.add_option(
+        "-p",
+        "--project",
+        dest="project",
+        action="store",
+        default="ubuntu-power-systems",
+        type="string",
+        help="name of the launchpad project",
+    )
+    parser.add_option(
+        "-s",
+        "--status",
+        dest="bug_status",
+        action="store",
+        default=(
+            "New,Opinion,Invalid,Won't Fix,Expired,"
+            "Confirmed,Triaged,In Progress,Fix Committed,"
+            "Fix Released,Incomplete"
+        ),
+        type="string",
+        help="bug status (or quoted and comma seperated list)",
+    )
+    parser.add_option(
+        "-i",
+        "--importance",
+        dest="bug_importance",
+        default=("Unknown,Undecided,Critical,High,Medium,Low,Wishlist"),
+        type="string",
+        help="bug importance (or comma seperated list, no spaces)",
+    )
+    parser.add_option(
+        "-t",
+        "--tag",
+        dest="bug_tag",
+        default=None,
+        help="bug tag (or quoted and comma seperated list)",
+    )
+    parser.add_option(
+        "-m",
+        "--modify",
+        dest="bug_tag_modify",
+        default="Any",
+        help="search any or all tags (valid args: any or all)",
+    )
+    parser.add_option(
+        "-v",
+        "--verbose",
+        dest="verbose",
+        action="store_true",
+        help="verbose output with bug details",
+    )
+    parser.add_option(
+        "-a",
+        "--author",
+        dest="author",
+        default="Manoj Iyer [e-mail]",
+        help='"Firstname Lastname [e-mail]"',
+    )
+    parser.add_option(
+        "-o",
+        "--outfile",
+        dest="outfile",
+        help="filename to store output (default stdout)",
+    )
 
     (options, args) = parser.parse_args()
 
     if len(args) is None:
         parser.error("No arguments found!")
 
-    script_name = sys.argv[0].split("/")[-1].split('.')[0]
-    cachedir = os.path.expanduser('~/.launchpadlib/cache')
+    script_name = sys.argv[0].split("/")[-1].split(".")[0]
+    cachedir = os.path.expanduser("~/.launchpadlib/cache")
 
     launchpad = Launchpad.login_with(script_name, LPNET_SERVICE_ROOT, cachedir)
     lp_project = launchpad.projects[options.project]
 
     lp_bugs = [
-        task for task in lp_project.searchTasks(
-            created_since=None if options.start_date is None else
-                        dt.strptime(options.start_date,
-                                    '%Y-%m-%d').isoformat(),
-                status=options.bug_status.split(','),
-                importance=options.bug_importance.title().replace(
-                    ' ', '').split(','),
-                tags=None if options.bug_tag is None else
-                        options.bug_tag.split(','),
-                tags_combinator=options.bug_tag_modify.title())]
-
-    with (open(options.outfile, 'w') if options.outfile else sys.stdout) as f:
-        f.write("Bug activity in %s project since %s\n\n\n" % (options.project,
-                options.start_date))
-        f.write(" || {:<35} | {:<20} |\n".format('Created By', 'Date'))
+        task
+        for task in lp_project.searchTasks(
+            created_since=None
+            if options.start_date is None
+            else dt.strptime(options.start_date, "%Y-%m-%d").isoformat(),
+            status=options.bug_status.split(","),
+            importance=options.bug_importance.title().replace(" ", "").split(","),
+            tags=None if options.bug_tag is None else options.bug_tag.split(","),
+            tags_combinator=options.bug_tag_modify.title(),
+        )
+    ]
+
+    with (open(options.outfile, "w") if options.outfile else sys.stdout) as f:
+        f.write(
+            "Bug activity in %s project since %s\n\n\n"
+            % (options.project, options.start_date)
+        )
+        f.write(" || {:<35} | {:<20} |\n".format("Created By", "Date"))
         f.write("  | [%s]" % (options.author) + " | %%mtime(%A %B %d, %Y) |\n")
 
         if f is not sys.stdout and options.verbose is True:
-            sys.stdout.write("Bug activity in %s project since %s\n" %
-                             (options.project, options.start_date))
-            sys.stdout.write("Generating detailed report in %s \n" %
-                             options.outfile)
+            sys.stdout.write(
+                "Bug activity in %s project since %s\n"
+                % (options.project, options.start_date)
+            )
+            sys.stdout.write("Generating detailed report in %s \n" % options.outfile)
             sys.stdout.write("Please wait...\n")
             sys.stdout.flush()
 
-        summary_report, detailed_report = gen_bug_report(launchpad, lp_bugs,
-                                                         options.project,
-                                                         options.verbose)
+        summary_report, detailed_report = gen_bug_report(
+            launchpad, lp_bugs, options.project, options.verbose
+        )
 
         for k, v in sorted(summary_report.iteritems()):
             f.write("\n= Summary of %s bugs =\n" % k)
-            f.write("|| {:<14} | {:<8} |\n".format('Status', 'Count'))
+            f.write("|| {:<14} | {:<8} |\n".format("Status", "Count"))
             for x, y in sorted(v.iteritems()):
                 f.write("| {:<15} | {:<8} |\n".format(x, y))
             if options.verbose is True:
                 f.write("== Details on %s bugs ==\n" % k)
-                f.write("|| Bug# | Created | Last Updated | Active Period "
-                        "| Dormant Period | #Comments | Assignee | Status |\n")
-
-                for a, b in sorted(detailed_report[k].iteritems(),
-                                   key=lambda item: item[1][1], reverse=True):
-                    f.write("| [%s https://launchpad.net/bugs/%s] | %s |\n" %
-                            (a, a, ' | '.join(map(str, b))))
+                f.write(
+                    "|| Bug# | Created | Last Updated | Active Period "
+                    "| Dormant Period | #Comments | Assignee | Status |\n"
+                )
+
+                for a, b in sorted(
+                    detailed_report[k].iteritems(),
+                    key=lambda item: item[1][1],
+                    reverse=True,
+                ):
+                    f.write(
+                        "| [%s https://launchpad.net/bugs/%s] | %s |\n"
+                        % (a, a, " | ".join(map(str, b)))
+                    )
 
         if f is not sys.stdout:
             f.close()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/lp-scripts/clone-project-milestones.py b/lp-scripts/clone-project-milestones.py
index b0783d2..39099ab 100755
--- a/lp-scripts/clone-project-milestones.py
+++ b/lp-scripts/clone-project-milestones.py
@@ -10,11 +10,11 @@ from launchpadlib.launchpad import Launchpad
 
 
 # These may contain proprietary content, skip them
-IgnoredSeries = ['firmware', 'ppa-uose', 'silicon', 'trunk']
+IgnoredSeries = ["firmware", "ppa-uose", "silicon", "trunk"]
 
 
 def clone_project_milestones(src, dest, dry_run):
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
     src_project = lp.projects[src]
     dest_project = lp.projects[dest]
     for src_series in src_project.series:
@@ -22,46 +22,49 @@ def clone_project_milestones(src, dest, dry_run):
             continue
         dest_series = dest_project.getSeries(name=src_series.name)
         if dest_series:
-            logger.warning("Series %s already exists, skipping\n" %
-                           (dest_series))
+            logger.warning("Series %s already exists, skipping\n" % (dest_series))
         else:
             logger.info("Creating series %s" % (src_series.name))
             if not dry_run:
                 dest_series = dest_project.newSeries(
-                    name=src_series.name,
-                    summary=src_series.summary)
+                    name=src_series.name, summary=src_series.summary
+                )
         for src_milestone in src_series.all_milestones:
             dest_milestone = dest_project.getMilestone(name=src_milestone.name)
             if dest_milestone:
                 logger.warning(
-                    "Project already has milestone %s, skipping\n" %
-                    (dest_milestone.name))
+                    "Project already has milestone %s, skipping\n"
+                    % (dest_milestone.name)
+                )
             else:
                 logger.info("Creating milestone %s" % (src_milestone.name))
                 if not dry_run:
                     dest_milestone = dest_series.newMilestone(
                         name=src_milestone.name,
-                        date_targeted=src_milestone.date_targeted)
+                        date_targeted=src_milestone.date_targeted,
+                    )
                     dest_milestone.is_active = src_milestone.is_active
                     dest_milestone.lp_save()
                 src_release = src_milestone.release
                 if src_release:
-                    logger.info("Releasing milestone %s on %s " %
-                                (src_milestone.name,
-                                 src_milestone.release.date_released))
+                    logger.info(
+                        "Releasing milestone %s on %s "
+                        % (src_milestone.name, src_milestone.release.date_released)
+                    )
                     if not dry_run:
                         dest_milestone.createProductRelease(
-                            date_released=src_milestone.release.date_released)
+                            date_released=src_milestone.release.date_released
+                        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument('-s', '--source', required=True)
-    parser.add_argument('-d', '--dest', required=True)
-    parser.add_argument('--dry-run', action='store_true')
+    parser.add_argument("-s", "--source", required=True)
+    parser.add_argument("-d", "--dest", required=True)
+    parser.add_argument("--dry-run", action="store_true")
     args = parser.parse_args()
 
-    logger = logging.getLogger('clone-project-milestones')
+    logger = logging.getLogger("clone-project-milestones")
     logger.setLevel(logging.INFO)
     ch = logging.StreamHandler()
     formatter = logging.Formatter("%(levelname)s - %(message)s")
diff --git a/lp-scripts/dump-bug-subscribers.py b/lp-scripts/dump-bug-subscribers.py
index 061c539..70f8c72 100755
--- a/lp-scripts/dump-bug-subscribers.py
+++ b/lp-scripts/dump-bug-subscribers.py
@@ -8,42 +8,54 @@ import csv
 from launchpadlib.launchpad import Launchpad
 
 
-bugStatuses = ["New", "Opinion", "Invalid", "Won't Fix", "Expired",
-               "Confirmed", "Triaged", "In Progress", "Fix Committed",
-               "Fix Released", "Incomplete"]
+bugStatuses = [
+    "New",
+    "Opinion",
+    "Invalid",
+    "Won't Fix",
+    "Expired",
+    "Confirmed",
+    "Triaged",
+    "In Progress",
+    "Fix Committed",
+    "Fix Released",
+    "Incomplete",
+]
 
 
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
 
 
 def getSubscriptionId(subscription_url):
     lpString = str(subscription_url)
-    lpPath = lpString.rsplit('/', 1)
+    lpPath = lpString.rsplit("/", 1)
     return lpPath[-1]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("project", help="Launchpad project from which \
-                         subscribers will be dumped")
+    parser.add_argument(
+        "project",
+        help="Launchpad project from which \
+                         subscribers will be dumped",
+    )
     parser.add_argument("-o", "--outfile", help="Output file", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
     project = lp.projects[args.project]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
         c.writerow(["Bug", "Title", "Subscribers"])
-# no way to list all open/closed bugs, so iterate through bug states
+        # no way to list all open/closed bugs, so iterate through bug states
         for bugStatus in bugStatuses:
             for task in project.searchTasks(status=bugStatus):
                 output = []
                 bug = taskToBug(task)
-                output.append('=HYPERLINK("%s", "LP: #%d")' %
-                              (task.web_link, bug.id))
+                output.append('=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id))
                 output.append(bug.title)
                 for subscription in bug.subscriptions:
                     output.append(getSubscriptionId(subscription))
diff --git a/lp-scripts/lp-bulk-action.py b/lp-scripts/lp-bulk-action.py
index be1b047..acada01 100755
--- a/lp-scripts/lp-bulk-action.py
+++ b/lp-scripts/lp-bulk-action.py
@@ -5,14 +5,14 @@ import sys
 from launchpadlib.launchpad import Launchpad
 
 Projects = [
-    'bandera',
-    'kunpeng920',
-    'pearl',
-    'pearl2',
-    'ubuntu-power-systems',
-    'ubuntu-z-systems',
-    'yarmouth',
-    'yarmouth2',
+    "bandera",
+    "kunpeng920",
+    "pearl",
+    "pearl2",
+    "ubuntu-power-systems",
+    "ubuntu-z-systems",
+    "yarmouth",
+    "yarmouth2",
 ]
 
 
@@ -20,13 +20,15 @@ def createMilestone(lp, project, series, milestone, date):
     p = lp.projects[project]
     s = p.getSeries(name=series)
     if not s:
-        sys.stderr.write("Warning: Project %s has no series %s, skipping\n" %
-                         (project, series))
+        sys.stderr.write(
+            "Warning: Project %s has no series %s, skipping\n" % (project, series)
+        )
         return
     if p.getMilestone(name=milestone):
         sys.stderr.write(
-            "Warning: Project %s already has milestone %s, skipping\n" %
-            (project, milestone))
+            "Warning: Project %s already has milestone %s, skipping\n"
+            % (project, milestone)
+        )
         return
     s.newMilestone(name=milestone, date_targeted=date)
 
@@ -36,13 +38,14 @@ def releaseMilestone(lp, project, milestone, date):
     m = p.getMilestone(name=milestone)
     if not m:
         sys.stderr.write(
-            "Warning: Project %s has no milestone %s, skipping\n" %
-            (project, milestone))
+            "Warning: Project %s has no milestone %s, skipping\n" % (project, milestone)
+        )
         return
     if m.release:
         sys.stderr.write(
-            "Warning: Milestone %s in project %s is already released\n" %
-            (milestone, project))
+            "Warning: Milestone %s in project %s is already released\n"
+            % (milestone, project)
+        )
         return
     m.createProductRelease(date_released=date)
 
@@ -52,8 +55,9 @@ def updateMilestone(lp, project, milestone, date):
     m = p.getMilestone(name=milestone)
     if not m:
         sys.stderr.write(
-            "Warning: Project %s does not have milestone %s, skipping\n" %
-            (project, milestone))
+            "Warning: Project %s does not have milestone %s, skipping\n"
+            % (project, milestone)
+        )
         return
     m.date_targeted = date
     m.lp_save()
@@ -63,51 +67,52 @@ def createSeries(lp, project, series, summary):
     p = lp.projects[project]
     if p.getSeries(name=series):
         sys.stderr.write(
-            "Warning: Project %s already has series %s, skipping\n" %
-            (project, series))
+            "Warning: Project %s already has series %s, skipping\n" % (project, series)
+        )
         return
     p.newSeries(name=series, summary=summary)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(dest='cmd')
+    subparsers = parser.add_subparsers(dest="cmd")
     subparsers.required = True
-    createMilestoneParser = subparsers.add_parser('create-milestone',
-                                                  help="Create Milestone")
+    createMilestoneParser = subparsers.add_parser(
+        "create-milestone", help="Create Milestone"
+    )
     createMilestoneParser.add_argument("-s", "--series", required=True)
     createMilestoneParser.add_argument("-d", "--date", required=True)
     createMilestoneParser.add_argument("milestone")
-    createMilestoneParser.set_defaults(cmd='create-milestone')
+    createMilestoneParser.set_defaults(cmd="create-milestone")
 
-    releaseMilestoneParser = subparsers.add_parser('release-milestone',
-                                                   help="Release Milestone")
+    releaseMilestoneParser = subparsers.add_parser(
+        "release-milestone", help="Release Milestone"
+    )
     releaseMilestoneParser.add_argument("-d", "--date", required=True)
     releaseMilestoneParser.add_argument("milestone")
-    releaseMilestoneParser.set_defaults(cmd='release-milestone')
+    releaseMilestoneParser.set_defaults(cmd="release-milestone")
 
-    releaseMilestoneParser = subparsers.add_parser('update-milestone',
-                                                   help="Update Milestone")
+    releaseMilestoneParser = subparsers.add_parser(
+        "update-milestone", help="Update Milestone"
+    )
     releaseMilestoneParser.add_argument("-d", "--date", required=True)
     releaseMilestoneParser.add_argument("milestone")
-    releaseMilestoneParser.set_defaults(cmd='update-milestone')
+    releaseMilestoneParser.set_defaults(cmd="update-milestone")
 
-    createSeriesParser = subparsers.add_parser('create-series',
-                                               help="Create Series")
+    createSeriesParser = subparsers.add_parser("create-series", help="Create Series")
     createSeriesParser.add_argument("-s", "--summary", required=True)
     createSeriesParser.add_argument("series")
-    createSeriesParser.set_defaults(cmd='create-series')
+    createSeriesParser.set_defaults(cmd="create-series")
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
     for project in Projects:
-        if args.cmd == 'create-milestone':
-            createMilestone(lp, project, args.series,
-                            args.milestone, args.date)
-        elif args.cmd == 'create-series':
+        if args.cmd == "create-milestone":
+            createMilestone(lp, project, args.series, args.milestone, args.date)
+        elif args.cmd == "create-series":
             createSeries(lp, project, args.series, args.summary)
-        elif args.cmd == 'release-milestone':
+        elif args.cmd == "release-milestone":
             releaseMilestone(lp, project, args.milestone, args.date)
-        elif args.cmd == 'update-milestone':
+        elif args.cmd == "update-milestone":
             updateMilestone(lp, project, args.milestone, args.date)
diff --git a/lp-scripts/pearl-biweekly-bug-report-csv4.py b/lp-scripts/pearl-biweekly-bug-report-csv4.py
index 6590ecf..1295c43 100755
--- a/lp-scripts/pearl-biweekly-bug-report-csv4.py
+++ b/lp-scripts/pearl-biweekly-bug-report-csv4.py
@@ -1,74 +1,93 @@
+#!/usr/bin/python3
 # Change History
 # Modify encode utf_8 to byte code in Rationale/Comment
-# Add Date_created column for creating date for bug 
+# Add Date_created column for creating date for bug
 # Add Scope column for showing impact for all arc or arch-arm64 or D05 Boad only
 
-#!/usr/bin/python3
-
 import argparse
 import csv
 from launchpadlib.launchpad import Launchpad
 
-rationaleSectionHeader="[16.04.3 Risk Comments]"
-rationaleBoilerplate="Still under investigation, not yet root-caused."
+rationaleSectionHeader = "[16.04.3 Risk Comments]"
+rationaleBoilerplate = "Still under investigation, not yet root-caused."
+
 
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
+
 
 def ownerFromStatus(status):
-    if 'Incomplete' in status:
-        owner='Huawei'
+    if "Incomplete" in status:
+        owner = "Huawei"
     else:
-        owner='Canonical'
-    return(owner)
+        owner = "Canonical"
+    return owner
+
 
 def rationaleFromDescription(des):
-    export_rationale_flag=0     # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    rationale=""
-    for des_line in des.splitlines():    # Loop through the bug description line-by-line looking for sections to export
+    export_rationale_flag = (
+        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
+    )
+    rationale = ""
+    for (
+        des_line
+    ) in (
+        des.splitlines()
+    ):  # Loop through the bug description line-by-line looking for sections to export
         if des_line == rationaleSectionHeader:
-            export_rationale_flag=1
+            export_rationale_flag = 1
         else:
-            if export_rationale_flag==1:
-                if des_line=="":
-                    export_rationale_flag=0
+            if export_rationale_flag == 1:
+                if des_line == "":
+                    export_rationale_flag = 0
                 else:
-                    rationale+=des_line
-    return(rationale)
+                    rationale += des_line
+    return rationale
 
 
 def checkScopeTags(tags):
-    scopeTags = ['scope-arch-all', 'scope-arch-arm64', 'scope-d05-only']
+    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
     scope = set(scopeTags).intersection(tags)
     for i in scope:
-    	return(i)
+        return i
 
-    return('Unknown')
+    return "Unknown"
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl']
+    pearl = lp.projects["pearl"]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(["Title", "Link", "Status", "Milestone", "Scope","Rationale/Comment", "Owner", "DateCreated"])
-# First pass: patchset bugs
+        c.writerow(
+            [
+                "Title",
+                "Link",
+                "Status",
+                "Milestone",
+                "Scope",
+                "Rationale/Comment",
+                "Owner",
+                "DateCreated",
+            ]
+        )
+        # First pass: patchset bugs
         for series in pearl.series:
-            if series.name not in ['ubuntu-16.04']:
+            if series.name not in ["ubuntu-16.04"]:
                 continue
-# First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():         
+            # First pass, phase one: search for the 'open' bugs
+            for task in series.searchTasks():
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if 'upstream-risky' not in bug.tags:
-#                   continue
+                #                if 'upstream-risky' not in bug.tags:
+                #                   continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -76,18 +95,29 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
-	        scope = checkScopeTags(bug.tags)
-	        owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, scope, rationale.encode('utf_8'), owner, date_created])
-
-# First pass, phase two: Fix Released bugs
+                    rationale = rationaleBoilerplate
+                scope = checkScopeTags(bug.tags)
+                owner = ownerFromStatus(task.status)
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        scope,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
+
+            # First pass, phase two: Fix Released bugs
             for task in series.searchTasks(status="Fix Released"):
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if not 'upstream-risky' not in bug.tags:
-#                    continue
+                #                if not 'upstream-risky' not in bug.tags:
+                #                    continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -95,9 +125,19 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
+                    rationale = rationaleBoilerplate
                 scope = checkScopeTags(bug.tags)
                 owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, scope, rationale.encode('utf_8'), owner, date_created])
-
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        scope,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
diff --git a/lp-scripts/pearl-biweekly-report-csv.py b/lp-scripts/pearl-biweekly-report-csv.py
index 2006490..5da289d 100755
--- a/lp-scripts/pearl-biweekly-report-csv.py
+++ b/lp-scripts/pearl-biweekly-report-csv.py
@@ -4,57 +4,76 @@ import argparse
 import csv
 from launchpadlib.launchpad import Launchpad
 
-rationaleSectionHeader="[16.04.3 Risk Comments]"
-rationaleBoilerplate="Still under investigation, not yet root-caused."
+rationaleSectionHeader = "[16.04.3 Risk Comments]"
+rationaleBoilerplate = "Still under investigation, not yet root-caused."
+
 
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
+
 
 def ownerFromStatus(status):
-    if 'Incomplete' in status:
-        owner='Huawei'
+    if "Incomplete" in status:
+        owner = "Huawei"
     else:
-        owner='Canonical'
-    return(owner)
+        owner = "Canonical"
+    return owner
+
 
 def rationaleFromDescription(des):
-    export_rationale_flag=0     # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    rationale=""
-    for des_line in des.splitlines():    # Loop through the bug description line-by-line looking for sections to export
+    export_rationale_flag = (
+        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
+    )
+    rationale = ""
+    for (
+        des_line
+    ) in (
+        des.splitlines()
+    ):  # Loop through the bug description line-by-line looking for sections to export
         if des_line == rationaleSectionHeader:
-            export_rationale_flag=1
+            export_rationale_flag = 1
         else:
-            if export_rationale_flag==1:
-                if des_line=="":
-                    export_rationale_flag=0
+            if export_rationale_flag == 1:
+                if des_line == "":
+                    export_rationale_flag = 0
                 else:
-                    rationale+=des_line
-    return(rationale)
+                    rationale += des_line
+    return rationale
 
-    
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl']
+    pearl = lp.projects["pearl"]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(["Title", "Link", "Status", "Milestone", "Rationale/Comment", "Owner", "DateCreated"])
-# First pass: patchset bugs
+        c.writerow(
+            [
+                "Title",
+                "Link",
+                "Status",
+                "Milestone",
+                "Rationale/Comment",
+                "Owner",
+                "DateCreated",
+            ]
+        )
+        # First pass: patchset bugs
         for series in pearl.series:
-            if series.name not in ['ubuntu-16.04']:
+            if series.name not in ["ubuntu-16.04"]:
                 continue
-# First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():         
+            # First pass, phase one: search for the 'open' bugs
+            for task in series.searchTasks():
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if 'upstream-risky' not in bug.tags:
-#                   continue
+                #                if 'upstream-risky' not in bug.tags:
+                #                   continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -62,17 +81,27 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
+                    rationale = rationaleBoilerplate
                 owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, rationale.encode('utf_8'), owner, date_created])
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
 
-# First pass, phase two: Fix Released bugs
-            for task in series.searchTasks(status="Fix Released"):         
+            # First pass, phase two: Fix Released bugs
+            for task in series.searchTasks(status="Fix Released"):
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if not 'upstream-risky' not in bug.tags:
-#                    continue
+                #                if not 'upstream-risky' not in bug.tags:
+                #                    continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -80,8 +109,17 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
+                    rationale = rationaleBoilerplate
                 owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, rationale.encode('utf_8'), owner, date_created])
-
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
diff --git a/lp-scripts/pearl-biweekly-report.csv.py b/lp-scripts/pearl-biweekly-report.csv.py
index 454c993..bfebacc 100644
--- a/lp-scripts/pearl-biweekly-report.csv.py
+++ b/lp-scripts/pearl-biweekly-report.csv.py
@@ -1,80 +1,99 @@
+#!/usr/bin/python3
 # Change History
 # Modify encode utf_8 to byte code in Rationale/Comment
-# Add Date_created column for creating date for bug 
+# Add Date_created column for creating date for bug
 # Add Scope column for showing impact for all arc or arch-arm64 or D05 Boad only
 
-#!/usr/bin/python3
-
 import argparse
 import csv
 from launchpadlib.launchpad import Launchpad
 
-rationaleSectionHeader="[16.04.3 Risk Comments]"
-rationaleBoilerplate="Still under investigation, not yet root-caused."
+rationaleSectionHeader = "[16.04.3 Risk Comments]"
+rationaleBoilerplate = "Still under investigation, not yet root-caused."
+
 
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
+
 
 def ownerFromStatus(status):
-    if 'Incomplete' in status:
-        owner='Huawei'
+    if "Incomplete" in status:
+        owner = "Huawei"
     else:
-        owner='Canonical'
-    return(owner)
+        owner = "Canonical"
+    return owner
+
 
 def rationaleFromDescription(des):
-    export_rationale_flag=0     # Flag to detect the start of the "[16.04.3 Risk Comments]" section
-    rationale=""
-    for des_line in des.splitlines():    # Loop through the bug description line-by-line looking for sections to export
+    export_rationale_flag = (
+        0  # Flag to detect the start of the "[16.04.3 Risk Comments]" section
+    )
+    rationale = ""
+    for (
+        des_line
+    ) in (
+        des.splitlines()
+    ):  # Loop through the bug description line-by-line looking for sections to export
         if des_line == rationaleSectionHeader:
-            export_rationale_flag=1
+            export_rationale_flag = 1
         else:
-            if export_rationale_flag==1:
-                if des_line=="":
-                    export_rationale_flag=0
+            if export_rationale_flag == 1:
+                if des_line == "":
+                    export_rationale_flag = 0
                 else:
-                    rationale+=des_line
-    return(rationale)
+                    rationale += des_line
+    return rationale
 
 
 def checkScopeTags(tags):
-    scopeTags = ['scope-arch-all', 'scope-arch-arm64', 'scope-d05-only']
+    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
     scope = set(scopeTags).intersection(tags)
     for i in scope:
-        if i == 'scope-arch-all':
-		i = 'Generic'
-	elif i == 'scope-arch-arm64':
-		i = 'ARM64 generic'
-	elif i == 'scope-d05-only':
-		i = 'D05 only'
-    	return(i)
+        if i == "scope-arch-all":
+            i = "Generic"
+        elif i == "scope-arch-arm64":
+            i = "ARM64 generic"
+        elif i == "scope-d05-only":
+            i = "D05 only"
+        return i
 
-    return('Unknown')
+    return "Unknown"
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl']
+    pearl = lp.projects["pearl"]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(["Title", "Link", "Status", "Milestone", "Scope","Rationale/Comment", "Owner", "DateCreated"])
-# First pass: patchset bugs
+        c.writerow(
+            [
+                "Title",
+                "Link",
+                "Status",
+                "Milestone",
+                "Scope",
+                "Rationale/Comment",
+                "Owner",
+                "DateCreated",
+            ]
+        )
+        # First pass: patchset bugs
         for series in pearl.series:
-            if series.name not in ['ubuntu-16.04']:
+            if series.name not in ["ubuntu-16.04"]:
                 continue
-# First pass, phase one: search for the 'open' bugs
-            for task in series.searchTasks():         
+            # First pass, phase one: search for the 'open' bugs
+            for task in series.searchTasks():
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if 'upstream-risky' not in bug.tags:
-#                   continue
+                #                if 'upstream-risky' not in bug.tags:
+                #                   continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -82,18 +101,29 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
-	        scope = checkScopeTags(bug.tags)
-	        owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, scope, rationale.encode('utf_8'), owner, date_created])
-
-# First pass, phase two: Fix Released bugs
+                    rationale = rationaleBoilerplate
+                scope = checkScopeTags(bug.tags)
+                owner = ownerFromStatus(task.status)
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        scope,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
+
+            # First pass, phase two: Fix Released bugs
             for task in series.searchTasks(status="Fix Released"):
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged 'upstream-risky'
-#                if not 'upstream-risky' not in bug.tags:
-#                    continue
+                #                if not 'upstream-risky' not in bug.tags:
+                #                    continue
                 if task.milestone is None:
                     milestone = "TBD"
                 else:
@@ -101,9 +131,19 @@ if __name__ == '__main__':
                 link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
                 rationale = rationaleFromDescription(bug.description)
                 if (not rationale) and (task.milestone is None):
-                    rationale=rationaleBoilerplate
+                    rationale = rationaleBoilerplate
                 scope = checkScopeTags(bug.tags)
                 owner = ownerFromStatus(task.status)
-		date_created = bug.date_created.strftime("%Y/%m/%d")
-                c.writerow([bug.title, link, task.status, milestone, scope, rationale.encode('utf_8'), owner, date_created])
-
+                date_created = bug.date_created.strftime("%Y/%m/%d")
+                c.writerow(
+                    [
+                        bug.title,
+                        link,
+                        task.status,
+                        milestone,
+                        scope,
+                        rationale.encode("utf_8"),
+                        owner,
+                        date_created,
+                    ]
+                )
diff --git a/lp-scripts/pearl-bug-csv-summary.py b/lp-scripts/pearl-bug-csv-summary.py
index a1a0b35..ad4a049 100755
--- a/lp-scripts/pearl-bug-csv-summary.py
+++ b/lp-scripts/pearl-bug-csv-summary.py
@@ -7,18 +7,19 @@ from LaunchpadBugBucketer import LaunchpadBugBucketer
 
 class PearlBugBucketer(LaunchpadBugBucketer):
     def __init__(self):
-        LaunchpadBugBucketer.__init__(self, 'pearl', 'ubuntu-16.04',
-                                      requiredTags=['upstream-risky'])
+        LaunchpadBugBucketer.__init__(
+            self, "pearl", "ubuntu-16.04", requiredTags=["upstream-risky"]
+        )
 
     def is_green(self, task):
-        if task.status in ['Fix Committed', 'Fix Released']:
+        if task.status in ["Fix Committed", "Fix Released"]:
             return True
         return False
 
     def is_amber(self, task):
         if self.is_green(task):
             return False
-        elif task.milestone and task.milestone.name == 'ubuntu-16.04.3':
+        elif task.milestone and task.milestone.name == "ubuntu-16.04.3":
             return True
         return False
 
@@ -28,16 +29,16 @@ class PearlBugBucketer(LaunchpadBugBucketer):
         return True
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile")
     args = parser.parse_args()
 
     s = PearlBugBucketer()
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(['Title', 'Bug ID', 'Importance', 'Status', 'RAG Risk'])
+        c.writerow(["Title", "Bug ID", "Importance", "Status", "RAG Risk"])
         for bucket in s.keys():
             for task in s[bucket]:
                 bug = s.taskToBug(task)
diff --git a/lp-scripts/pearl-risky-patch-schedule.py b/lp-scripts/pearl-risky-patch-schedule.py
index a22f493..01d546e 100755
--- a/lp-scripts/pearl-risky-patch-schedule.py
+++ b/lp-scripts/pearl-risky-patch-schedule.py
@@ -4,29 +4,31 @@ import argparse
 import csv
 from launchpadlib.launchpad import Launchpad
 
+
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
-    
-if __name__ == '__main__':
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
+
+
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl']
+    pearl = lp.projects["pearl"]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
         for series in pearl.series:
-            if series.name not in ['ubuntu-17.04']:
+            if series.name not in ["ubuntu-17.04"]:
                 continue
-            for task in series.searchTasks():         
+            for task in series.searchTasks():
                 bug = taskToBug(task)
                 # All kernel patchset bugs in the pearl project are tagged
                 # 'upstream-risky'
-                if 'upstream-risky' not in bug.tags:
+                if "upstream-risky" not in bug.tags:
                     continue
                 if task.milestone is None:
                     date = "TBD"
diff --git a/lp-scripts/pearl2-biweekly-report.csv.py b/lp-scripts/pearl2-biweekly-report.csv.py
index b005620..a5a75d9 100755
--- a/lp-scripts/pearl2-biweekly-report.csv.py
+++ b/lp-scripts/pearl2-biweekly-report.csv.py
@@ -10,94 +10,110 @@ import argparse
 import csv
 from launchpadlib.launchpad import Launchpad
 
-rationaleSectionHeader="[18.04.1 Risk Comments]"
-rationaleBoilerplate="Still under investigation, not yet root-caused."
+rationaleSectionHeader = "[18.04.1 Risk Comments]"
+rationaleBoilerplate = "Still under investigation, not yet root-caused."
+
 
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
+
 
 def ownerFromStatus(status):
-    if 'Incomplete' in status:
-        owner='Huawei'
+    if "Incomplete" in status:
+        owner = "Huawei"
     else:
-        owner='Canonical'
-    return(owner)
+        owner = "Canonical"
+    return owner
+
 
 def rationaleFromDescription(des):
-    export_rationale_flag=0     # Flag to detect the start of the "[18.04.1 Risk Comments]" section
-    rationale=""
-    for des_line in des.splitlines():    # Loop through the bug description line-by-line looking for sections to export
+    export_rationale_flag = (
+        0  # Flag to detect the start of the "[18.04.1 Risk Comments]" section
+    )
+    rationale = ""
+    for (
+        des_line
+    ) in (
+        des.splitlines()
+    ):  # Loop through the bug description line-by-line looking for sections to export
         if des_line == rationaleSectionHeader:
-            export_rationale_flag=1
+            export_rationale_flag = 1
         else:
-            if export_rationale_flag==1:
-                if des_line=="":
-                    export_rationale_flag=0
+            if export_rationale_flag == 1:
+                if des_line == "":
+                    export_rationale_flag = 0
                 else:
-                    rationale+=des_line
-    return(rationale)
+                    rationale += des_line
+    return rationale
 
 
 def checkScopeTags(tags):
-    scopeTags = ['scope-arch-all', 'scope-arch-arm64', 'scope-d06-only']
+    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d06-only"]
     scope = set(scopeTags).intersection(tags)
     for i in scope:
-        if i == 'scope-arch-all':
-                i = 'Generic'
-        elif i == 'scope-arch-arm64':
-                i = 'ARM64 generic'
-        elif i == 'scope-d06-only':
-                i = 'D06 only'
-        return(i)
+        if i == "scope-arch-all":
+            i = "Generic"
+        elif i == "scope-arch-arm64":
+            i = "ARM64 generic"
+        elif i == "scope-d06-only":
+            i = "D06 only"
+        return i
+
+    return "Unknown"
 
-    return('Unknown')
 
 def getMilestones(series_array):
-    milestones=[]
+    milestones = []
     for series in series_array:
-        milestone_url=series['milestone_link']
+        milestone_url = series["milestone_link"]
         if milestone_url is not None:
-            milestone_name=milestone_url.rsplit('/',1)
+            milestone_name = milestone_url.rsplit("/", 1)
             milestones.append(milestone_name[-1])
     return milestones
 
+
 def getUoseMilestone(series_array):
-    milestones=getMilestones(series_array)
-    uose_milestone=""
+    milestones = getMilestones(series_array)
+    uose_milestone = ""
     for milestone in milestones:
         if "uose" in milestone:
-            uose_milestone=milestone
+            uose_milestone = milestone
     return uose_milestone
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl2']
+    pearl = lp.projects["pearl2"]
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
-        c.writerow(["Title", "Link", "Status", "Milestone", "Owner", "DateCreated","Comments"])
-# First pass: search for the 'open' bugs
+        c.writerow(
+            ["Title", "Link", "Status", "Milestone", "Owner", "DateCreated", "Comments"]
+        )
+        # First pass: search for the 'open' bugs
         for task in pearl.searchTasks():
-            uose_milestone=getUoseMilestone(task.related_tasks.entries)
+            uose_milestone = getUoseMilestone(task.related_tasks.entries)
             bug = taskToBug(task)
             link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
             owner = ownerFromStatus(task.status)
             date_created = bug.date_created.strftime("%Y/%m/%d")
-            c.writerow([bug.title, link, task.status, uose_milestone, owner, date_created])
+            c.writerow(
+                [bug.title, link, task.status, uose_milestone, owner, date_created]
+            )
 
-# Second pass: search for the 'Fix Released' bugs
+        # Second pass: search for the 'Fix Released' bugs
         for task in pearl.searchTasks(status="Fix Released"):
             bug = taskToBug(task)
-            uose_milestone=getUoseMilestone(task.related_tasks.entries)
+            uose_milestone = getUoseMilestone(task.related_tasks.entries)
             link = '=HYPERLINK("%s", "LP: #%d")' % (task.web_link, bug.id)
             owner = ownerFromStatus(task.status)
             date_created = bug.date_created.strftime("%Y/%m/%d")
-            c.writerow([bug.title, link, task.status, uose_milestone, owner, date_created])
-
+            c.writerow(
+                [bug.title, link, task.status, uose_milestone, owner, date_created]
+            )
diff --git a/lp-scripts/pearl2-d06-18.04-patch-status.py b/lp-scripts/pearl2-d06-18.04-patch-status.py
index 2d56d05..79316bc 100755
--- a/lp-scripts/pearl2-d06-18.04-patch-status.py
+++ b/lp-scripts/pearl2-d06-18.04-patch-status.py
@@ -2,29 +2,34 @@
 
 import argparse
 import csv
-import string
 from launchpadlib.launchpad import Launchpad
 
+
 def taskToBug(task):
-    bugid = int(task.self_link.split('/')[-1])
-    return(lp.bugs[bugid])
+    bugid = int(task.self_link.split("/")[-1])
+    return lp.bugs[bugid]
 
 
-Pre18041Milestones = ['ubuntu-18.04-ga', 'ubuntu-18.04-sru-1',
-                      'ubuntu-18.04-sru-2', 'ubuntu-18.04-sru-3',
-                      'ubuntu-18.04-sru-4', 'ubuntu-18.04.1']
+Pre18041Milestones = [
+    "ubuntu-18.04-ga",
+    "ubuntu-18.04-sru-1",
+    "ubuntu-18.04-sru-2",
+    "ubuntu-18.04-sru-3",
+    "ubuntu-18.04-sru-4",
+    "ubuntu-18.04.1",
+]
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-o", "--outfile", required=True)
     args = parser.parse_args()
 
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl = lp.projects['pearl2']
-    series = pearl.getSeries(name='ubuntu-18.04')
+    pearl = lp.projects["pearl2"]
+    series = pearl.getSeries(name="ubuntu-18.04")
 
-    with open(args.outfile, 'w') as csvfile:
+    with open(args.outfile, "w") as csvfile:
         c = csv.writer(csvfile)
         c.writerow(["Title", "Link", "Status", "Expected"])
         for task in series.searchTasks(status=[]):
@@ -34,8 +39,8 @@ if __name__ == '__main__':
             # patches will land in, or it should be tagged as risky.
             if task.status in ["Invalid", "Won't Fix"]:
                 continue
-            if task.status == 'Incomplete':
-                if 'needs-sru-justification' in bug.tags:
+            if task.status == "Incomplete":
+                if "needs-sru-justification" in bug.tags:
                     expected = "Needs SRU Justification"
                 else:
                     expected = "Need input from HiSilicon"
diff --git a/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py b/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py
index a29014e..01dc923 100755
--- a/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py
+++ b/lp-scripts/pearl2-tag-ubuntu-18.04.3-risky.py
@@ -30,7 +30,7 @@ def get_risk(bug):
     for r in RiskyTagMap.keys():
         if RiskyTagMap[r] in bug.tags:
             # Only one tag should be found
-            assert(found is None)
+            assert found is None
             found = r
     return found
 
@@ -42,8 +42,7 @@ def set_risk(bug, risk):
             continue
         rmtag = RiskyTagMap[r]
         if rmtag in bug.tags:
-            sys.stderr.write("Removing %s tag from %s\n" %
-                             (rmtag, bug.web_link))
+            sys.stderr.write("Removing %s tag from %s\n" % (rmtag, bug.web_link))
             newtags = list(bug.tags)
             newtags.remove(rmtag)
             bug.tags = newtags
@@ -55,10 +54,10 @@ def set_risk(bug, risk):
     bug.lp_save()
 
 
-if __name__ == '__main__':
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+if __name__ == "__main__":
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
 
-    pearl2 = lp.projects['pearl2']
+    pearl2 = lp.projects["pearl2"]
     target_milestone = "ubuntu-18.04.3"
     target_date = None
     # Find the target date of our milestone. We can compare this with
@@ -68,9 +67,9 @@ if __name__ == '__main__':
         if m.name in [target_milestone]:
             target_date = m.date_targeted
             break
-    assert(target_date is not None)
+    assert target_date is not None
 
-    series = pearl2.getSeries(name='ubuntu-18.04-hwe')
+    series = pearl2.getSeries(name="ubuntu-18.04-hwe")
     for task in series.searchTasks():
         if task.milestone is not None:
             tdelta = task.milestone.date_targeted - target_date
@@ -85,8 +84,13 @@ if __name__ == '__main__':
             continue
         # Now process the ones w/ no milestone set.
         # These by definition should all have milestones set.
-        assert(task.status not in ["Opinion", "Invalid", "Won't Fix",
-                                   "Fix Committed", "Fix Released"])
+        assert task.status not in [
+            "Opinion",
+            "Invalid",
+            "Won't Fix",
+            "Fix Committed",
+            "Fix Released",
+        ]
         if task.status == "Incomplete":
             set_risk(task.bug, Risky.HIGH)
             continue
diff --git a/lp-scripts/project-bug-lint.py b/lp-scripts/project-bug-lint.py
index 48f81db..5f62a01 100755
--- a/lp-scripts/project-bug-lint.py
+++ b/lp-scripts/project-bug-lint.py
@@ -8,33 +8,42 @@ import sys
 class BugProperty:
     def __init__(self, property):
         self.index = self.PropertyList.index(property)
-        
+
     def __eq__(self, other):
-        return(self.index == other.index)
+        return self.index == other.index
 
     def __ne__(self, other):
-        return(self.index != other.index)
+        return self.index != other.index
 
     def __lt__(self, other):
-        return(self.index < other.index)
+        return self.index < other.index
 
     def __le__(self, other):
-        return(self.index <= other.index)
+        return self.index <= other.index
 
     def __gt__(self, other):
-        return(self.index > other.index)
+        return self.index > other.index
 
     def __ge__(self, other):
-        return(self.index >= other.index)
+        return self.index >= other.index
 
     def __repr__(self):
-        return(self.PropertyList[self.index])
+        return self.PropertyList[self.index]
 
 
 class BugStatus(BugProperty):
-    PropertyList = ['New', 'Incomplete', 'Opinion', 'Invalid',
-                   'Won\'t Fix', 'Confirmed', 'Triaged', 'In Progress',
-                    'Fix Committed', 'Fix Released']
+    PropertyList = [
+        "New",
+        "Incomplete",
+        "Opinion",
+        "Invalid",
+        "Won't Fix",
+        "Confirmed",
+        "Triaged",
+        "In Progress",
+        "Fix Committed",
+        "Fix Released",
+    ]
 
     # min/max could ideally be in the baseclass, but I don't know
     # how to do that and stil refer to the correct PropertyList
@@ -45,12 +54,12 @@ class BugStatus(BugProperty):
         return BugStatus(BugStatus.PropertyList[-1])
 
     def isTerminalState(self):
-        terminalStates = ['Fix Released', 'Invalid', 'Won\'t Fix']
-        return(self.PropertyList[self.index] in terminalStates)
+        terminalStates = ["Fix Released", "Invalid", "Won't Fix"]
+        return self.PropertyList[self.index] in terminalStates
+
 
 class BugImportance(BugProperty):
-    PropertyList = ['Undecided', 'Wishlist', 'Low',
-                       'Medium', 'High', 'Critical']
+    PropertyList = ["Undecided", "Wishlist", "Low", "Medium", "High", "Critical"]
 
     # min/max could ideally be in the baseclass, but I don't know
     # how to do that and stil refer to the correct PropertyList
@@ -60,11 +69,13 @@ class BugImportance(BugProperty):
     def max():
         return BugImportance(BugImportance.PropertyList[-1])
 
+
 class BugTask:
     def __init__(self, lptask):
         self.status = BugStatus(lptask.status)
         self.importance = BugImportance(lptask.importance)
 
+
 class Bug:
     def __init__(self):
         self.defaultTask = None
@@ -80,24 +91,29 @@ class Bug:
         self.targetedTasks[series] = BugTask(task)
 
     def getTargetedTasks(self):
-        return(self.targetedTasks)
+        return self.targetedTasks
+
 
 def checkScopeTags(lpbug):
-    scopeTags = ['scope-arch-all', 'scope-arch-arm64', 'scope-d05-only']
+    scopeTags = ["scope-arch-all", "scope-arch-arm64", "scope-d05-only"]
     common = set(scopeTags).intersection(lpbug.tags)
     if len(common) == 0:
         sys.stdout.write("http://launchpad.net/bugs/%d has no scope tag\n" % (bugid))
     if len(common) > 1:
-        sys.stdout.write("http://launchpad.net/bugs/%d has multiple scope tags\n" % (bugid))
+        sys.stdout.write(
+            "http://launchpad.net/bugs/%d has multiple scope tags\n" % (bugid)
+        )
+
 
 def taskToBugId(task):
-    return(int(task.self_link.split('/')[-1]))
+    return int(task.self_link.split("/")[-1])
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-p", "--project", required=True)
     args = parser.parse_args()
-    lp = Launchpad.login_with('lpbugs', 'production', version='devel')
+    lp = Launchpad.login_with("lpbugs", "production", version="devel")
     project = lp.projects[args.project]
 
     bugs = {}
@@ -114,7 +130,10 @@ if __name__ == '__main__':
             if bugid in bugs.keys():
                 bugs[bugid].addTargetedTask(series.name, task)
             else:
-                sys.stderr.write("WARNING: http://launchpad.net/bugs/%d does not have a default task\n" % (bugid))
+                sys.stderr.write(
+                    "WARNING: http://launchpad.net/bugs/%d does not have a default task\n"
+                    % (bugid)
+                )
 
     # Now process them.
     for bugid in bugs.keys():
@@ -123,7 +142,10 @@ if __name__ == '__main__':
         if len(targetedTasks) == 0:
             defaultStatus = bug.getDefaultTask().status
             if not defaultStatus.isTerminalState():
-                sys.stderr.write("WARNING: http://launchpad.net/bugs/%d only has a default task\n" % (bugid))
+                sys.stderr.write(
+                    "WARNING: http://launchpad.net/bugs/%d only has a default task\n"
+                    % (bugid)
+                )
             continue
 
         statusList = []
@@ -144,10 +166,16 @@ if __name__ == '__main__':
         currentStatus = defaultTask.status
         currentImportance = defaultTask.importance
         if targetStatus and targetStatus != currentStatus:
-            sys.stdout.write("http://launchpad.net/bugs/%d status %s -> %s\n" % (bugid, currentStatus, targetStatus))
+            sys.stdout.write(
+                "http://launchpad.net/bugs/%d status %s -> %s\n"
+                % (bugid, currentStatus, targetStatus)
+            )
         if targetImportance != currentImportance:
-            sys.stdout.write("http://launchpad.net/bugs/%d importance %s -> %s\n" % (bugid, currentImportance, targetImportance))
+            sys.stdout.write(
+                "http://launchpad.net/bugs/%d importance %s -> %s\n"
+                % (bugid, currentImportance, targetImportance)
+            )
 
-        if args.project == 'pearl':
+        if args.project == "pearl":
             if not defaultTask.status.isTerminalState():
                 checkScopeTags(lp.bugs[bugid])
diff --git a/sysadmin-tools/gen_conserver_cf.py b/sysadmin-tools/gen_conserver_cf.py
index 065a30b..7153ed7 100755
--- a/sysadmin-tools/gen_conserver_cf.py
+++ b/sysadmin-tools/gen_conserver_cf.py
@@ -47,30 +47,30 @@ console {srv} {{
         exec ipmitool -I lanplus -H {addr} -U {user} -P {pwd} sol activate;
 }}"""
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     arg_parser = argparse.ArgumentParser()
     arg_parser.add_argument("machines_yaml", help="Lab's machines.yaml file")
-    arg_parser.add_argument("-o", "--outfile", help="Output filename",
-                            required=True)
+    arg_parser.add_argument("-o", "--outfile", help="Output filename", required=True)
     args = arg_parser.parse_args()
 
     with open(args.machines_yaml) as f:
         machines = yaml.safe_load(f)
 
-    with open(args.outfile, 'w') as outfile:
+    with open(args.outfile, "w") as outfile:
         outfile.write(header.format(progname=arg_parser.prog))
         for server in machines:
             # bmc is required for conserver to attach
-            if ("bmc" not in machines[server]):
+            if "bmc" not in machines[server]:
                 continue
             bmc_info = machines[server]["bmc"]
             # type is required so the conserver knows how to attach
-            if ("type" not in bmc_info):
+            if "type" not in bmc_info:
                 continue
-            if (bmc_info["type"] == "ipmi"):
-                addr = bmc_info["address"].replace('#', '\\#')
-                user = bmc_info["user"].replace('#', '\\#')
-                pwd = bmc_info["password"].replace('#', '\\#')
-                outfile.write(ipmi_sol_entry.format(srv=server, addr=addr,
-                              user=user, pwd=pwd))
+            if bmc_info["type"] == "ipmi":
+                addr = bmc_info["address"].replace("#", "\\#")
+                user = bmc_info["user"].replace("#", "\\#")
+                pwd = bmc_info["password"].replace("#", "\\#")
+                outfile.write(
+                    ipmi_sol_entry.format(srv=server, addr=addr, user=user, pwd=pwd)
+                )
         outfile.write(footer.format())