Merge ~isidroas/ubuntu/+source/command-not-found:black_formatter into ubuntu/+source/command-not-found:ubuntu/devel

[isidro]

The black formatter (https://github.com/psf/black) makes your code follow the [official style recomendation](https://peps.python.org/pep-0008/). I could list some important projects that use it.

[Julian Andres Klode (juliank)]

While I appreciate format cleanups I'm not sure this is the best venue for this type of change, because I'd have to run black locally myself, and then compare the outcomes anyway, and there's no work to make sure future uploads are correctly formatted.

Ultimately it would be nice to setup the launchpad CI thingy and https://pre-commit.com/ that runs ruff to format the code and do linting of it (or alternatively the individual tools, but it seems the community is gravitating towards ruff these days) and fail if linting fails or ruff fails.

Not sure if now is the right time for this, I believe that ultimately this would improve quality for 24.04, and it's not a feature, so it should not be affected by feature freeze.

What do you think?

Unmerged commits

50b23e1... by isidro on 2024-02-27

black formatter

diff --git a/CommandNotFound/CommandNotFound.py b/CommandNotFound/CommandNotFound.py
index 74f1b89..8df73e6 100644
--- a/CommandNotFound/CommandNotFound.py
+++ b/CommandNotFound/CommandNotFound.py
@@ -24,32 +24,31 @@ else:
     _gettext_method = "ugettext"
 _ = getattr(gettext.translation("command-not-found", fallback=True), _gettext_method)
 
-    
+
 def similar_words(word):
     """
     return a set with spelling1 distance alternative spellings
 
     based on http://norvig.com/spell-correct.html
     """
-    alphabet = 'abcdefghijklmnopqrstuvwxyz-_0123456789'
+    alphabet = "abcdefghijklmnopqrstuvwxyz-_0123456789"
     s = [(word[:i], word[i:]) for i in range(len(word) + 1)]
     deletes = [a + b[1:] for a, b in s if b]
     transposes = [a + b[1] + b[0] + b[2:] for a, b in s if len(b) > 1]
     replaces = [a + c + b[1:] for a, b in s for c in alphabet if b]
-    inserts = [a + c + b     for a, b in s for c in alphabet]
+    inserts = [a + c + b for a, b in s for c in alphabet]
     return set(deletes + transposes + replaces + inserts)
 
 
 def user_can_sudo():
     try:
         groups = posix.getgroups()
-        return (grp.getgrnam("sudo")[2] in groups or
-                grp.getgrnam("admin")[2] in groups)
+        return grp.getgrnam("sudo")[2] in groups or grp.getgrnam("admin")[2] in groups
     except KeyError:
         return False
 
 
-# the new style DB - if that exists we skip the legacy DB 
+# the new style DB - if that exists we skip the legacy DB
 dbpath = "/var/lib/command-not-found/commands.db"
 
 
@@ -57,7 +56,7 @@ class CommandNotFound(object):
 
     programs_dir = "programs.d"
     max_len = 256
-    
+
     prefixes = (
         "/snap/bin",
         "/bin",
@@ -66,7 +65,8 @@ class CommandNotFound(object):
         "/sbin",
         "/usr/sbin",
         "/usr/local/sbin",
-        "/usr/games")
+        "/usr/games",
+    )
 
     snap_cmd = "/usr/bin/snap"
 
@@ -83,13 +83,13 @@ class CommandNotFound(object):
         self.euid = posix.geteuid()
 
     def spelling_suggestions(self, word, min_len=3):
-        """ try to correct the spelling """
+        """try to correct the spelling"""
         possible_alternatives = []
         if not (min_len <= len(word) <= self.max_len):
             return possible_alternatives
         for w in similar_words(word):
             packages = self.get_packages(w)
-            for (package, ver, comp) in packages:
+            for package, ver, comp in packages:
                 possible_alternatives.append((w, package, comp, ver))
         return possible_alternatives
 
@@ -105,10 +105,16 @@ class CommandNotFound(object):
         try:
             with open(os.devnull) as devnull:
                 output = subprocess.check_output(
-                    [self.snap_cmd, "advise-snap", "--format=json",
-                     "--command", command],
+                    [
+                        self.snap_cmd,
+                        "advise-snap",
+                        "--format=json",
+                        "--command",
+                        command,
+                    ],
                     stderr=devnull,
-                    universal_newlines=True)
+                    universal_newlines=True,
+                )
         except subprocess.CalledProcessError as e:
             logging.debug("calling snap advice-snap returned an error: %s" % e)
             return [], []
@@ -120,14 +126,22 @@ class CommandNotFound(object):
             return [], []
         for snap in snaps:
             if snap["Command"] == command:
-                exact_result.append((snap["Snap"], snap["Command"], snap.get("Version")))
+                exact_result.append(
+                    (snap["Snap"], snap["Command"], snap.get("Version"))
+                )
             else:
-                mispell_result.append((snap["Command"], snap["Snap"], snap.get("Version")))
+                mispell_result.append(
+                    (snap["Command"], snap["Snap"], snap.get("Version"))
+                )
         return exact_result, mispell_result
-    
+
     def getBlacklist(self):
         try:
-            with open(os.sep.join((os.getenv("HOME", "/root"), ".command-not-found.blacklist"))) as blacklist:
+            with open(
+                os.sep.join(
+                    (os.getenv("HOME", "/root"), ".command-not-found.blacklist")
+                )
+            ) as blacklist:
                 return [line.strip() for line in blacklist if line.strip() != ""]
         except IOError:
             return []
@@ -136,6 +150,7 @@ class CommandNotFound(object):
         try:
             import apt_pkg
             from aptsources.sourceslist import SourcesList
+
             apt_pkg.init()
         except (SystemError, ImportError):
             return []
@@ -158,7 +173,7 @@ class CommandNotFound(object):
             return
         if package_name:
             prompt = _("Do you want to install it? (N/y)")
-            if sys.version >= '3':
+            if sys.version >= "3":
                 answer = input(prompt)
                 raw_input = lambda x: x  # pyflakes
             else:
@@ -175,28 +190,45 @@ class CommandNotFound(object):
                 print("%s" % install_command, file=sys.stdout)
                 subprocess.call(install_command.split(), shell=False)
 
-    def print_spelling_suggestions(self, word, mispell_packages, mispell_snaps, max_alt=15):
-        """ print spelling suggestions for packages and snaps """
-        if len(mispell_packages)+len(mispell_snaps) > max_alt:
-            print(_("Command '%s' not found, but there are %s similar ones.") % (word, len(mispell_packages)), file=self.output_fd)
+    def print_spelling_suggestions(
+        self, word, mispell_packages, mispell_snaps, max_alt=15
+    ):
+        """print spelling suggestions for packages and snaps"""
+        if len(mispell_packages) + len(mispell_snaps) > max_alt:
+            print(
+                _("Command '%s' not found, but there are %s similar ones.")
+                % (word, len(mispell_packages)),
+                file=self.output_fd,
+            )
             self.output_fd.flush()
             return
-        elif len(mispell_packages)+len(mispell_snaps) > 0:
-            print(_("Command '%s' not found, did you mean:") % word, file=self.output_fd)
-            for (command, snap, ver) in mispell_snaps:
+        elif len(mispell_packages) + len(mispell_snaps) > 0:
+            print(
+                _("Command '%s' not found, did you mean:") % word, file=self.output_fd
+            )
+            for command, snap, ver in mispell_snaps:
                 if ver:
                     ver = " (%s)" % ver
                 else:
                     ver = ""
-                print(_("  command '%s' from snap %s%s") % (command, snap, ver), file=self.output_fd)
-            for (command, package, comp, ver) in mispell_packages:
+                print(
+                    _("  command '%s' from snap %s%s") % (command, snap, ver),
+                    file=self.output_fd,
+                )
+            for command, package, comp, ver in mispell_packages:
                 if ver:
                     ver = " (%s)" % ver
                 else:
                     ver = ""
-                print(_("  command '%s' from deb %s%s") % (command, package, ver), file=self.output_fd)
+                print(
+                    _("  command '%s' from deb %s%s") % (command, package, ver),
+                    file=self.output_fd,
+                )
         if len(mispell_snaps) > 0:
-            print(_("See 'snap info <snapname>' for additional versions."), file=self.output_fd)
+            print(
+                _("See 'snap info <snapname>' for additional versions."),
+                file=self.output_fd,
+            )
         elif len(mispell_packages) > 0:
             if self.user_can_sudo:
                 print(_("Try: %s <deb name>") % "sudo apt install", file=self.output_fd)
@@ -205,8 +237,11 @@ class CommandNotFound(object):
         self.output_fd.flush()
 
     def _print_exact_header(self, command):
-        print(_("Command '%(command)s' not found, but can be installed with:") % {
-            'command': command}, file=self.output_fd)
+        print(
+            _("Command '%(command)s' not found, but can be installed with:")
+            % {"command": command},
+            file=self.output_fd,
+        )
 
     def advice_single_snap_package(self, command, packages, snaps):
         self._print_exact_header(command)
@@ -219,7 +254,7 @@ class CommandNotFound(object):
             print("snap install %s" % snap[0], file=self.output_fd)
             print(_("Please ask your administrator."))
         self.output_fd.flush()
-        
+
     def advice_single_deb_package(self, command, packages, snaps):
         self._print_exact_header(command)
         if self.euid == 0:
@@ -232,17 +267,21 @@ class CommandNotFound(object):
             print("apt install %s" % packages[0][0], file=self.output_fd)
             print(_("Please ask your administrator."))
             if not packages[0][2] in self.sources_list:
-                print(_("You will have to enable the component called '%s'") % packages[0][2], file=self.output_fd)
+                print(
+                    _("You will have to enable the component called '%s'")
+                    % packages[0][2],
+                    file=self.output_fd,
+                )
         self.output_fd.flush()
 
     def sudo(self):
         if self.euid != 0 and self.user_can_sudo:
             return "sudo "
-        return "" 
+        return ""
 
     def advice_multi_deb_package(self, command, packages, snaps):
         self._print_exact_header(command)
-        pad = max([len(s[0]) for s in snaps+packages])
+        pad = max([len(s[0]) for s in snaps + packages])
         for i, package in enumerate(packages):
             ver = ""
             if package[1]:
@@ -251,16 +290,27 @@ class CommandNotFound(object):
                 else:
                     ver = "  # version %s" % (package[1])
             if package[2] in self.sources_list:
-                print("%sapt install %-*s%s" % (self.sudo(), pad, package[0], ver), file=self.output_fd)
+                print(
+                    "%sapt install %-*s%s" % (self.sudo(), pad, package[0], ver),
+                    file=self.output_fd,
+                )
             else:
-                print("%sapt install %-*s%s" % (self.sudo(), pad, package[0], ver) + " (" + _("You will have to enable component called '%s'") % package[2] + ")", file=self.output_fd)
+                print(
+                    "%sapt install %-*s%s" % (self.sudo(), pad, package[0], ver)
+                    + " ("
+                    + _("You will have to enable component called '%s'") % package[2]
+                    + ")",
+                    file=self.output_fd,
+                )
         if self.euid != 0 and not self.user_can_sudo:
-            print(_("Ask your administrator to install one of them."), file=self.output_fd)
+            print(
+                _("Ask your administrator to install one of them."), file=self.output_fd
+            )
         self.output_fd.flush()
 
     def advice_multi_snap_packages(self, command, packages, snaps):
         self._print_exact_header(command)
-        pad = max([len(s[0]) for s in snaps+packages])
+        pad = max([len(s[0]) for s in snaps + packages])
         for i, snap in enumerate(snaps):
             ver = ""
             if snap[2]:
@@ -268,69 +318,109 @@ class CommandNotFound(object):
                     ver = "  # version %s, or" % snap[2]
                 else:
                     ver = "  # version %s" % snap[2]
-            print("%ssnap install %-*s%s" % (self.sudo(), pad, snap[0], ver), file=self.output_fd)
-        print(_("See 'snap info <snapname>' for additional versions."), file=self.output_fd)
+            print(
+                "%ssnap install %-*s%s" % (self.sudo(), pad, snap[0], ver),
+                file=self.output_fd,
+            )
+        print(
+            _("See 'snap info <snapname>' for additional versions."),
+            file=self.output_fd,
+        )
         self.output_fd.flush()
 
     def advice_multi_mixed_packages(self, command, packages, snaps):
         self._print_exact_header(command)
-        pad = max([len(s[0]) for s in snaps+packages])
+        pad = max([len(s[0]) for s in snaps + packages])
         for i, snap in enumerate(snaps):
-            ver=""
+            ver = ""
             if snap[2]:
                 if i == 0:
                     ver = "  # version %s, or" % snap[2]
                 else:
                     ver = "  # version %s" % snap[2]
-            print("%ssnap install %-*s%s" % (self.sudo(), pad, snap[0], ver), file=self.output_fd)
+            print(
+                "%ssnap install %-*s%s" % (self.sudo(), pad, snap[0], ver),
+                file=self.output_fd,
+            )
         for package in packages:
-            ver=""
+            ver = ""
             if package[1]:
                 ver = "  # version %s" % package[1]
-            print("%sapt  install %-*s%s" % (self.sudo(), pad, package[0], ver), file=self.output_fd)
+            print(
+                "%sapt  install %-*s%s" % (self.sudo(), pad, package[0], ver),
+                file=self.output_fd,
+            )
         if len(snaps) == 1:
-            print(_("See 'snap info %s' for additional versions.") % snaps[0][0], file=self.output_fd)
+            print(
+                _("See 'snap info %s' for additional versions.") % snaps[0][0],
+                file=self.output_fd,
+            )
         else:
-            print(_("See 'snap info <snapname>' for additional versions."), file=self.output_fd)
+            print(
+                _("See 'snap info <snapname>' for additional versions."),
+                file=self.output_fd,
+            )
         self.output_fd.flush()
-        
+
     def advise(self, command, ignore_installed=False):
-        " give advice where to find the given command to stderr "
+        "give advice where to find the given command to stderr"
+
         def _in_prefix(prefix, command):
-            " helper that returns if a command is found in the given prefix "
-            return (os.path.exists(os.path.join(prefix, command))
-                    and not os.path.isdir(os.path.join(prefix, command)))
+            "helper that returns if a command is found in the given prefix"
+            return os.path.exists(os.path.join(prefix, command)) and not os.path.isdir(
+                os.path.join(prefix, command)
+            )
 
         if len(command) > self.max_len:
             return False
-        
+
         if command.startswith("/"):
             if os.path.exists(command):
                 prefixes = [os.path.dirname(command)]
             else:
                 prefixes = []
         else:
-            prefixes = [prefix for prefix in self.prefixes if _in_prefix(prefix, command)]
+            prefixes = [
+                prefix for prefix in self.prefixes if _in_prefix(prefix, command)
+            ]
 
         # check if we have it in a common prefix that may not be in the PATH
         if prefixes and not ignore_installed:
             if len(prefixes) == 1:
-                print(_("Command '%(command)s' is available in '%(place)s'") % {"command": command, "place": os.path.join(prefixes[0], command)}, file=self.output_fd)
+                print(
+                    _("Command '%(command)s' is available in '%(place)s'")
+                    % {"command": command, "place": os.path.join(prefixes[0], command)},
+                    file=self.output_fd,
+                )
             else:
-                print(_("Command '%(command)s' is available in the following places") % {"command": command}, file=self.output_fd)
+                print(
+                    _("Command '%(command)s' is available in the following places")
+                    % {"command": command},
+                    file=self.output_fd,
+                )
                 for prefix in prefixes:
                     print(" * %s" % os.path.join(prefix, command), file=self.output_fd)
             missing = list(set(prefixes) - set(os.getenv("PATH", "").split(":")))
             if len(missing) > 0:
-                print(_("The command could not be located because '%s' is not included in the PATH environment variable.") % ":".join(missing), file=self.output_fd)
+                print(
+                    _(
+                        "The command could not be located because '%s' is not included in the PATH environment variable."
+                    )
+                    % ":".join(missing),
+                    file=self.output_fd,
+                )
                 if "sbin" in ":".join(missing):
-                    print(_("This is most likely caused by the lack of administrative privileges associated with your user account."), file=self.output_fd)
+                    print(
+                        _(
+                            "This is most likely caused by the lack of administrative privileges associated with your user account."
+                        ),
+                        file=self.output_fd,
+                    )
             return False
 
         # do not give advice if we are in a situation where apt
         # or aptitude are not available (LP: #394843)
-        if not (os.path.exists("/usr/bin/apt") or
-                os.path.exists("/usr/bin/aptitude")):
+        if not (os.path.exists("/usr/bin/apt") or os.path.exists("/usr/bin/aptitude")):
             return False
 
         if command in self.getBlacklist():
@@ -340,18 +430,29 @@ class CommandNotFound(object):
         # people to use python3 only, and command-not-found depends on
         # python3, so must be available
         if command == "python":
-            print(_("Command '%s' not found, did you mean:") % command, file=self.output_fd)
-            print(_("  command '%s' from deb %s%s") % ("python3", "python3", ""), file=self.output_fd)
-            print(_("  command '%s' from deb %s%s") % ("python", "python-is-python3", ""), file=self.output_fd)
+            print(
+                _("Command '%s' not found, did you mean:") % command,
+                file=self.output_fd,
+            )
+            print(
+                _("  command '%s' from deb %s%s") % ("python3", "python3", ""),
+                file=self.output_fd,
+            )
+            print(
+                _("  command '%s' from deb %s%s") % ("python", "python-is-python3", ""),
+                file=self.output_fd,
+            )
             return True
-        
+
         packages = self.get_packages(command)
         snaps, mispell_snaps = self.get_snaps(command)
         logging.debug("got debs: %s snaps: %s" % (packages, snaps))
         if len(packages) == 0 and len(snaps) == 0:
             mispell_packages = self.spelling_suggestions(command)
             if len(mispell_packages) > 0 or len(mispell_snaps) > 0:
-                self.print_spelling_suggestions(command, mispell_packages, mispell_snaps)
+                self.print_spelling_suggestions(
+                    command, mispell_packages, mispell_snaps
+                )
         elif len(packages) == 0 and len(snaps) == 1:
             self.advice_single_snap_package(command, packages, snaps)
         elif len(snaps) > 0 and len(packages) == 0:
@@ -363,5 +464,9 @@ class CommandNotFound(object):
         elif len(packages) > 0 and len(snaps) > 0:
             self.advice_multi_mixed_packages(command, packages, snaps)
 
-        return (len(packages) > 0 or len(snaps) > 0 or
-                len(mispell_snaps) > 0 or len(mispell_packages) > 0)
+        return (
+            len(packages) > 0
+            or len(snaps) > 0
+            or len(mispell_snaps) > 0
+            or len(mispell_packages) > 0
+        )
diff --git a/CommandNotFound/__init__.py b/CommandNotFound/__init__.py
index 66b6508..c396168 100644
--- a/CommandNotFound/__init__.py
+++ b/CommandNotFound/__init__.py
@@ -1,2 +1 @@
 from __future__ import absolute_import
-
diff --git a/CommandNotFound/db/creator.py b/CommandNotFound/db/creator.py
index 8b86375..de82b0b 100755
--- a/CommandNotFound/db/creator.py
+++ b/CommandNotFound/db/creator.py
@@ -10,6 +10,7 @@ import sys
 import time
 
 import apt_pkg
+
 apt_pkg.init()
 
 # TODO:
@@ -17,19 +18,19 @@ apt_pkg.init()
 # - add apt::update::post-invoke-success handler
 
 component_priorities = {
-    'main': 120,
-    'universe': 100,
-    'contrib': 80,
-    'non-free-firmware': 60,
-    'restricted': 60,
-    'non-free': 40,
-    'multiverse': 20,
+    "main": 120,
+    "universe": 100,
+    "contrib": 80,
+    "non-free-firmware": 60,
+    "restricted": 60,
+    "non-free": 40,
+    "multiverse": 20,
 }
 
 # pkgnames in here are blacklisted
 
 
-create_db_sql="""
+create_db_sql = """
            CREATE TABLE IF NOT EXISTS "commands" 
            (
             [cmdID] INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
@@ -58,12 +59,15 @@ create_db_sql="""
 # - add "last-mtime" into the DB, then we can skip all packages files
 #   where the mtime is older and we only need to update the DB
 
+
 class measure:
     def __init__(self, what, stats):
         self.what = what
         self.stats = stats
+
     def __enter__(self):
         self.now = time.time()
+
     def __exit__(self, *args):
         if not self.what in self.stats:
             self.stats[self.what] = 0
@@ -82,14 +86,14 @@ class DbCreator:
     def __init__(self, files):
         self.files = files
         self.primary_arch = apt_pkg.get_architectures()[0]
-        self.stats = {"total": 0,"total_time": time.time()}
+        self.stats = {"total": 0, "total_time": time.time()}
+
     def create(self, dbname):
-        metadata_file = dbname+".metadata"
+        metadata_file = dbname + ".metadata"
         if not self._db_update_needed(metadata_file):
-            logging.info(
-                "%s does not require an update (inputs unchanged)", dbname)
+            logging.info("%s does not require an update (inputs unchanged)", dbname)
             return
-        tmpdb = dbname+".tmp"
+        tmpdb = dbname + ".tmp"
         with sqlite3.connect(tmpdb) as con:
             try:
                 con.executescript(create_db_sql)
@@ -99,8 +103,7 @@ class DbCreator:
                 # tmpdb. Just stop execution in this case, as the other process
                 # should produce the correct result.
                 if str(e) == "database is locked":
-                    logging.warning(
-                        "%s is locked by another process. Ignoring.", tmpdb)
+                    logging.warning("%s is locked by another process. Ignoring.", tmpdb)
                     sys.exit(0)
                 else:
                     raise e
@@ -111,6 +114,7 @@ class DbCreator:
         # add new metadata
         with open(metadata_file, "w") as fp:
             json.dump(self._calc_input_metadata(), fp)
+
     def _db_update_needed(self, metadata_file):
         if not os.path.exists(metadata_file):
             return True
@@ -121,33 +125,42 @@ class DbCreator:
         except Exception as e:
             logging.warning("cannot read %s: %s", metadata_file, e)
             return True
+
     def _calc_input_metadata(self):
         meta = {}
         for p in self.files:
             st = os.stat(p)
             meta[p] = {
-                'st_ino': st.st_ino,
-                'st_dev': st.st_dev,
-                'st_uid': st.st_uid,
-                'st_gid': st.st_gid,
-                'st_size': st.st_size,
-                'st_mtime': st.st_mtime,
+                "st_ino": st.st_ino,
+                "st_dev": st.st_dev,
+                "st_uid": st.st_uid,
+                "st_gid": st.st_gid,
+                "st_size": st.st_size,
+                "st_mtime": st.st_mtime,
             }
         return meta
+
     def _fill_commands(self, con):
         for f in self.files:
-            with subprocess.Popen(["/usr/lib/apt/apt-helper", "cat-file", f], stdout=subprocess.PIPE) as sub:
+            with subprocess.Popen(
+                ["/usr/lib/apt/apt-helper", "cat-file", f], stdout=subprocess.PIPE
+            ) as sub:
                 if "Contents" in f:
                     self._parse_single_contents_file(con, f, sub.stdout)
                 else:
                     self._parse_single_commands_file(con, sub.stdout)
                 if sub.wait() != 0:
-                    raise subprocess.CalledProcessError(returncode=sub.returncode,
-                                                         cmd="/usr/lib/apt/apt-helper cat-file {}".format(f))
+                    raise subprocess.CalledProcessError(
+                        returncode=sub.returncode,
+                        cmd="/usr/lib/apt/apt-helper cat-file {}".format(f),
+                    )
 
         self.stats["total_time"] = time.time() - self.stats["total_time"]
-        logging.info("processed %i packages in %.2fs" % (
-            self.stats["total"], self.stats["total_time"]))
+        logging.info(
+            "processed %i packages in %.2fs"
+            % (self.stats["total"], self.stats["total_time"])
+        )
+
     def _in_db(self, con, command, pkgname):
         already_in_db = con.execute(
             """
@@ -155,73 +168,95 @@ class DbCreator:
             FROM commands 
             INNER JOIN packages on packages.pkgID = commands.pkgID
             WHERE commands.command=? AND packages.name=?;
-            """, (command, pkgname)).fetchone()
+            """,
+            (command, pkgname),
+        ).fetchone()
         return already_in_db
+
     def _delete_pkgid(self, con, pkgid):
-        con.execute("DELETE FROM packages WHERE pkgID=?", (pkgid,) )
-        con.execute("DELETE FROM commands WHERE pkgID=?", (pkgid,) )
+        con.execute("DELETE FROM packages WHERE pkgID=?", (pkgid,))
+        con.execute("DELETE FROM commands WHERE pkgID=?", (pkgid,))
+
     def _get_pkgid(self, con, pkgname):
         have_pkg = con.execute(
-            "SELECT pkgID from packages WHERE name=?", (pkgname,)).fetchone()
+            "SELECT pkgID from packages WHERE name=?", (pkgname,)
+        ).fetchone()
         if have_pkg:
             return have_pkg[0]
         return None
+
     def _insert_package(self, con, pkgname, version, component, priority):
-        cur=con.execute("""
+        cur = con.execute(
+            """
             INSERT INTO packages (name, version, component, priority)
             VALUES (?, ?, ?, ?);
-            """, (pkgname, version, component, priority))
+            """,
+            (pkgname, version, component, priority),
+        )
         return cur.lastrowid
+
     def _insert_command(self, con, command, pkg_id):
-        con.execute("""
+        con.execute(
+            """
         INSERT INTO commands (command, pkgID) VALUES (?, ?);
-        """, (command, pkg_id))
+        """,
+            (command, pkg_id),
+        )
+
     def _parse_single_commands_file(self, con, fp):
         tagf = apt_pkg.TagFile(fp)
         # file empty
         if not tagf.step():
             return
         # read header
-        suite=tagf.section["suite"]
+        suite = tagf.section["suite"]
         # FIXME: support backports
         if suite.endswith("-backports"):
             return
-        component=tagf.section["component"]
-        arch=tagf.section["arch"]
+        component = tagf.section["component"]
+        arch = tagf.section["arch"]
         # FIXME: add code for secondary arch handling!
         if arch != "all" and arch != self.primary_arch:
             return
         # step over the pkgs
         while tagf.step():
             self.stats["total"] += 1
-            pkgname=tagf.section["name"]
+            pkgname = tagf.section["name"]
             # allow to override the viisble pkgname to accomodate for
             # cases like "python2.7" which is part of python2.7-minimal
             # but users should just install python2.7
             if tagf.section.get("visible-pkgname"):
                 pkgname = tagf.section["visible-pkgname"]
-            version=tagf.section.get("version", "")
-            ignore_commands=set()
+            version = tagf.section.get("version", "")
+            ignore_commands = set()
             if tagf.section.get("ignore-commands", ""):
-                ignore_commands=set(tagf.section.get("ignore-commands", "").split(","))
+                ignore_commands = set(
+                    tagf.section.get("ignore-commands", "").split(",")
+                )
             for command in tagf.section["commands"].split(","):
                 if command in ignore_commands:
                     continue
                 # see if we have the command already
                 with measure("sql_already_db", self.stats):
-                    already_in_db=self._in_db(con, command, pkgname)
+                    already_in_db = self._in_db(con, command, pkgname)
                 if already_in_db:
                     # we found a version that is higher what we have
                     # in the DB -> remove current, insert higher
                     if apt_pkg.version_compare(version, already_in_db[2]) > 0:
-                        logging.debug("replacing exiting %s in DB (higher version)" % command)
+                        logging.debug(
+                            "replacing exiting %s in DB (higher version)" % command
+                        )
                         with measure("sql_delete_already_in_db", self.stats):
                             self._delete_pkgid(con, already_in_db[0])
                     else:
-                        logging.debug("skipping %s from %s (lower/same version)" % (command, suite))
+                        logging.debug(
+                            "skipping %s from %s (lower/same version)"
+                            % (command, suite)
+                        )
                         continue
-                logging.debug("adding %s from %s/%s (%s)" % (
-                    command, pkgname, version, suite))
+                logging.debug(
+                    "adding %s from %s/%s (%s)" % (command, pkgname, version, suite)
+                )
                 # insert new data
                 with measure("sql_have_pkg", self.stats):
                     pkg_id = self._get_pkgid(con, pkgname)
@@ -229,18 +264,24 @@ class DbCreator:
                     priority = component_priorities.get(component, 0)
                     priority += int(tagf.section.get("priority-bonus", "0"))
                     with measure("sql_insert_pkg", self.stats):
-                        pkg_id = self._insert_package(con, pkgname, version, component, priority)
+                        pkg_id = self._insert_package(
+                            con, pkgname, version, component, priority
+                        )
                 with measure("sql_insert_cmd", self.stats):
                     self._insert_command(con, command, pkg_id)
 
     def _parse_single_contents_file(self, con, f, fp):
         # read header
-        suite=None      # FIXME
+        suite = None  # FIXME
 
         for l in fp:
             l = l.decode("utf-8")
-            if not (l.startswith('usr/sbin') or l.startswith('usr/bin') or
-                    l.startswith('bin') or l.startswith('sbin')):
+            if not (
+                l.startswith("usr/sbin")
+                or l.startswith("usr/bin")
+                or l.startswith("bin")
+                or l.startswith("sbin")
+            ):
                 continue
             try:
                 command, pkgnames = l.split(None, 1)
@@ -249,41 +290,49 @@ class DbCreator:
 
             command = os.path.basename(command)
 
-            for pkgname in pkgnames.split(','):
+            for pkgname in pkgnames.split(","):
                 try:
-                    section, pkgname = pkgname.strip().rsplit('/', 1)
+                    section, pkgname = pkgname.strip().rsplit("/", 1)
                 except ValueError:
                     pkgname = pkgname.strip()
                     section = "unknown"
-                if len(section.split('/')) == 2:
-                    component, section = section.split('/')
+                if len(section.split("/")) == 2:
+                    component, section = section.split("/")
                 else:
-                    component = 'main'
+                    component = "main"
 
                 # FIXME - Don't really know how.
                 version = None
                 # see if we have the command already
                 with measure("sql_already_db", self.stats):
-                    already_in_db=self._in_db(con, command, pkgname)
+                    already_in_db = self._in_db(con, command, pkgname)
                 if already_in_db:
                     # we found a version that is higher what we have
                     # in the DB -> remove current, insert higher
                     if False and apt_pkg.version_compare(version, already_in_db[2]) > 0:
-                        logging.debug("replacing exiting %s in DB (higher version)" % command)
+                        logging.debug(
+                            "replacing exiting %s in DB (higher version)" % command
+                        )
                         with measure("sql_delete_already_in_db", self.stats):
                             self._delete_pkgid(con, already_in_db[0])
                     else:
-                        logging.debug("skipping %s from %s (lower/same version)" % (command, suite))
+                        logging.debug(
+                            "skipping %s from %s (lower/same version)"
+                            % (command, suite)
+                        )
                         continue
-                logging.debug("adding %s from %s/%s (%s)" % (
-                    command, pkgname, version, suite))
+                logging.debug(
+                    "adding %s from %s/%s (%s)" % (command, pkgname, version, suite)
+                )
                 # insert new data
                 with measure("sql_have_pkg", self.stats):
                     pkg_id = self._get_pkgid(con, pkgname)
                 if not pkg_id:
                     priority = component_priorities.get(component, 0)
                     with measure("sql_insert_pkg", self.stats):
-                        pkg_id = self._insert_package(con, pkgname, version, component, priority)
+                        pkg_id = self._insert_package(
+                            con, pkgname, version, component, priority
+                        )
                 with measure("sql_insert_cmd", self.stats):
                     self._insert_command(con, command, pkg_id)
 
@@ -293,10 +342,12 @@ if __name__ == "__main__":
     if len(sys.argv) < 3:
         print("usage: %s <output-db-path> <files...>" % sys.argv[0])
         print(" e.g.: %s commands.db ./dists/*/*/*/Commands-*" % sys.argv[0])
-        print(" e.g.: %s /var/lib/command-not-found/commands.db  /var/lib/apt/lists/*Commands-*", sys.argv[0])
+        print(
+            " e.g.: %s /var/lib/command-not-found/commands.db  /var/lib/apt/lists/*Commands-*",
+            sys.argv[0],
+        )
         sys.exit(1)
     col = DbCreator(sys.argv[2:])
     col.create(sys.argv[1])
     for stat, amount in col.stats.items():
         logging.debug("%s: %s" % (stat, amount))
-
diff --git a/CommandNotFound/db/db.py b/CommandNotFound/db/db.py
index c776893..0b108b3 100644
--- a/CommandNotFound/db/db.py
+++ b/CommandNotFound/db/db.py
@@ -3,11 +3,11 @@
 import sqlite3
 
 import apt_pkg
+
 apt_pkg.init()
 
 
 class SqliteDatabase(object):
-
     def __init__(self, filename):
         self.con = sqlite3.connect(filename)
         self.component = ""
@@ -17,13 +17,14 @@ class SqliteDatabase(object):
         command = command.encode("utf-8", "surrogateescape").decode("utf-8", "replace")
         results = []
         for row in self.con.execute(
-                """
+            """
                 SELECT packages.name, packages.version, packages.component
                 FROM commands
                 INNER JOIN packages on packages.pkgID = commands.pkgID
                 WHERE commands.command=?
                 ORDER BY packages.priority DESC
-                """, (command,)).fetchall():
-            results.append( (row[0], row[1], row[2]) )
+                """,
+            (command,),
+        ).fetchall():
+            results.append((row[0], row[1], row[2]))
         return results
-                        
diff --git a/CommandNotFound/db/tests/test_db.py b/CommandNotFound/db/tests/test_db.py
index d743a6f..6cbb92c 100644
--- a/CommandNotFound/db/tests/test_db.py
+++ b/CommandNotFound/db/tests/test_db.py
@@ -6,6 +6,7 @@ import tempfile
 import unittest
 
 import logging
+
 logging.basicConfig(level=logging.DEBUG)
 
 from CommandNotFound.db.creator import DbCreator
@@ -75,8 +76,8 @@ version: 3.0
 commands: bzr
 """
 
-class DbTestCase(unittest.TestCase):
 
+class DbTestCase(unittest.TestCase):
     def setUp(self):
         self.tmpdir = tempfile.mkdtemp()
 
@@ -84,7 +85,14 @@ class DbTestCase(unittest.TestCase):
         shutil.rmtree(self.tmpdir)
 
     def make_mock_commands_file(self, suite, content):
-        path = os.path.join(self.tmpdir, "var", "lib", "apt", "lists", "archive.ubuntu.com_ubuntu_dists_%s_Commands-all" % suite)
+        path = os.path.join(
+            self.tmpdir,
+            "var",
+            "lib",
+            "apt",
+            "lists",
+            "archive.ubuntu.com_ubuntu_dists_%s_Commands-all" % suite,
+        )
         try:
             os.makedirs(os.path.dirname(path))
         except OSError:
@@ -92,74 +100,79 @@ class DbTestCase(unittest.TestCase):
         with open(path, "w") as fp:
             fp.write(content)
         return path
-        
+
     def test_create_trivial_db(self):
         mock_commands_file = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         cre = DbCreator([mock_commands_file])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
+        self.assertEqual(db.lookup("wall"), [("bsdutils", "1.0", "main")])
         self.assertEqual(
-            db.lookup("wall"), [("bsdutils", "1.0", "main")])
-        self.assertEqual(
-            db.lookup("removed-in-version-2.0"), [("bsdutils", "1.0", "main")])
+            db.lookup("removed-in-version-2.0"), [("bsdutils", "1.0", "main")]
+        )
 
     def test_create_multiple_dbs(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         mock_commands_2 = self.make_mock_commands_file(
-            "bionic-proposed_main", mock_commands_bionic_proposed)
+            "bionic-proposed_main", mock_commands_bionic_proposed
+        )
         cre = DbCreator([mock_commands_1, mock_commands_2])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
         # newer version 2.0 ovrride older version 1.0
-        self.assertEqual(
-            db.lookup("wall"), [("bsdutils", "2.0", "main")])
+        self.assertEqual(db.lookup("wall"), [("bsdutils", "2.0", "main")])
         # binaries from older versions do not linger around
-        self.assertEqual(
-            db.lookup("removed-in-version-2.0"), [])
+        self.assertEqual(db.lookup("removed-in-version-2.0"), [])
         # versions only from a single file are available
         self.assertEqual(
-            db.lookup("bzr"), [
+            db.lookup("bzr"),
+            [
                 ("bzr1", "1.0", "main"),
                 ("bzr2", "2.7", "main"),
-            ])
+            ],
+        )
 
     def test_create_backports_excluded_dbs(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         mock_commands_2 = self.make_mock_commands_file(
-            "bionic-backports_main", mock_commands_bionic_backports)
+            "bionic-backports_main", mock_commands_bionic_backports
+        )
         cre = DbCreator([mock_commands_1, mock_commands_2])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
-        self.assertEqual(
-            db.lookup("wall"), [("bsdutils", "1.0", "main")])
-        self.assertEqual(
-            db.lookup("new-stuff-only-in-backports"), [])
+        self.assertEqual(db.lookup("wall"), [("bsdutils", "1.0", "main")])
+        self.assertEqual(db.lookup("new-stuff-only-in-backports"), [])
 
     def test_create_no_versions_does_not_crash(self):
         mock_commands = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic.replace("version: 1.0\n", ""))
+            "bionic_main", mock_commands_bionic.replace("version: 1.0\n", "")
+        )
         cre = DbCreator([mock_commands])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
-        self.assertEqual(
-            db.lookup("wall"), [("bsdutils", "", "main")])
-        
+        self.assertEqual(db.lookup("wall"), [("bsdutils", "", "main")])
+
     def test_create_priorities_work(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         mock_commands_2 = self.make_mock_commands_file(
-            "bionic_universe", mock_commands_bionic_universe)
+            "bionic_universe", mock_commands_bionic_universe
+        )
         self.assertNotEqual(mock_commands_1, mock_commands_2)
         cre = DbCreator([mock_commands_1, mock_commands_2])
         dbpath = os.path.join(self.tmpdir, "test.db")
@@ -170,15 +183,18 @@ class DbTestCase(unittest.TestCase):
             # ensure that we always sort "main" before universe"
             # and that the same component is sorted alphabetically
             self.assertEqual(
-                db.lookup("bzr"), [
+                db.lookup("bzr"),
+                [
                     ("bzr1", "1.0", "main"),
                     ("bzr2", "2.7", "main"),
                     ("bzr-tng", "3.0", "universe"),
-                ])
+                ],
+            )
 
     def test_priorities_bonus_works(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         cre = DbCreator([mock_commands_1])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
@@ -186,33 +202,37 @@ class DbTestCase(unittest.TestCase):
         db = SqliteDatabase(dbpath)
         for i in range(100):
             self.assertEqual(
-                db.lookup("java"), [
+                db.lookup("java"),
+                [
                     ("default-jre", "8", "main"),
                     ("aaa-openjre-7", "7", "main"),
-                ])
+                ],
+            )
 
     def test_visible_pkgname_works(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         cre = DbCreator([mock_commands_1])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
         for i in range(100):
-            self.assertEqual(
-                db.lookup("python2.7"), [("python2.7", "2.7", "main")])
+            self.assertEqual(db.lookup("python2.7"), [("python2.7", "2.7", "main")])
 
     def test_create_multiple_no_unneeded_creates(self):
         mock_commands_1 = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         mock_commands_2 = self.make_mock_commands_file(
-            "bionic-proposed_main", mock_commands_bionic_proposed)
+            "bionic-proposed_main", mock_commands_bionic_proposed
+        )
         cre = DbCreator([mock_commands_1, mock_commands_2])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # ensure the metadata file was created
-        self.assertTrue(os.path.exists(dbpath+".metadata"))
+        self.assertTrue(os.path.exists(dbpath + ".metadata"))
         # ensure the caching works and the db is not created twice
         st = os.stat(dbpath)
         cre.create(dbpath)
@@ -220,13 +240,13 @@ class DbTestCase(unittest.TestCase):
 
     def test_create_honors_ignore_comamnds(self):
         mock_commands_file = self.make_mock_commands_file(
-            "bionic_main", mock_commands_bionic)
+            "bionic_main", mock_commands_bionic
+        )
         cre = DbCreator([mock_commands_file])
         dbpath = os.path.join(self.tmpdir, "test.db")
         cre.create(dbpath)
         # validate content
         db = SqliteDatabase(dbpath)
         # ignore-commands is correctly handled
-        self.assertEqual(
-            db.lookup("foo-cmd"), [("foo", "3.0", "main")])
+        self.assertEqual(db.lookup("foo-cmd"), [("foo", "3.0", "main")])
         self.assertEqual(db.lookup("igore-me"), [])
diff --git a/CommandNotFound/tests/test_command_not_found.py b/CommandNotFound/tests/test_command_not_found.py
index 809809f..c4bde59 100644
--- a/CommandNotFound/tests/test_command_not_found.py
+++ b/CommandNotFound/tests/test_command_not_found.py
@@ -1,8 +1,9 @@
 #!/usr/bin/python
 
 import json
-#import logging
-#logging.basicConfig(level=logging.DEBUG)
+
+# import logging
+# logging.basicConfig(level=logging.DEBUG)
 import os
 import shutil
 import tempfile
@@ -16,14 +17,14 @@ from CommandNotFound.CommandNotFound import (
 from CommandNotFound.db.creator import DbCreator
 
 test_specs = [
-"""
+    """
 test: single snap advise
 snaps: spotify/1.0:x-spotify
 with: x-spotify
 Command 'x-spotify' not found, but can be installed with:
 sudo snap install spotify
 """,
-"""
+    """
 test: mixed advise, single snap
 debs: aws/1.0:x-aws,other-cmd
 snaps: aws-cli/2.0:x-aws
@@ -33,7 +34,7 @@ sudo snap install aws-cli  # version 2.0, or
 sudo apt  install aws      # version 1.0
 See 'snap info aws-cli' for additional versions.
 """,
-"""
+    """
 test: mixed advise, multi-snap
 debs: aws/1.0:x-aws,other-cmd
 snaps: aws-cli/2.0:x-aws;aws-cli-compat/0.1:x-aws
@@ -44,14 +45,14 @@ sudo snap install aws-cli-compat  # version 0.1
 sudo apt  install aws             # version 1.0
 See 'snap info <snapname>' for additional versions.
 """,
-"""
+    """
 test: single advise deb
 debs: pylint/1.0:x-pylint
 with: x-pylint
 Command 'x-pylint' not found, but can be installed with:
 sudo apt install pylint
 """,
-"""
+    """
 test: multi advise debs
 debs: vim/1.0:x-vi;neovim/2.0:x-vi
 with: x-vi
@@ -59,7 +60,7 @@ Command 'x-vi' not found, but can be installed with:
 sudo apt install vim     # version 1.0, or
 sudo apt install neovim  # version 2.0
 """,
-"""
+    """
 test: fuzzy advise debs only
 debs: vim/1.0:x-vi;neovim/2.0:x-vi
 with: x-via
@@ -68,14 +69,14 @@ Command 'x-via' not found, did you mean:
   command 'x-vi' from deb neovim (2.0)
 Try: sudo apt install <deb name>
 """,
-"""
+    """
 test: single advise snaps
 snaps: spotify/1.0:x-spotify
 with: x-spotify
 Command 'x-spotify' not found, but can be installed with:
 sudo snap install spotify
 """,
-"""
+    """
 test: multi advise snaps
 snaps: foo1/1.0:x-foo;foo2/2.0:x-foo
 with: x-foo
@@ -84,7 +85,7 @@ sudo snap install foo1  # version 1.0, or
 sudo snap install foo2  # version 2.0
 See 'snap info <snapname>' for additional versions.
 """,
-"""
+    """
 test: mixed fuzzy advise
 debs: aws/1.0:x-aws,other-cmd
 snaps: aws-cli/2.0:x-aws
@@ -94,24 +95,24 @@ Command 'x-awsX' not found, did you mean:
   command 'x-aws' from deb aws (1.0)
 See 'snap info <snapname>' for additional versions.
 """,
-"""
+    """
 test: many mispellings just prints a summary
 debs: lsa/1.0:lsa;lsb/1.0:lsb;lsc/1.0:lsc;lsd/1.0:lsd;lsd/1.0:lsd;lse/1.0:lse;lsf/1.0:lsf;lsg/1.0:lsg;lse/1.0:lsh;lse/1.0:lsh;lsi/1.0:lsi;lsj/1.0:lsj;lsk/1.0:lsk;lsl/1.0:lsl;lsm/1.0:lsm;lsn/1.0:lsn;lso/1.0:lso
 with: lsx
 Command 'lsx' not found, but there are 17 similar ones.
 """,
 ]
-        
+
 
 class MockAptDB:
     def __init__(self):
         self._db = {}
+
     def lookup(self, command):
         return self._db.get(command, [])
 
-   
-class CommandNotFoundOutputTest(unittest.TestCase):
 
+class CommandNotFoundOutputTest(unittest.TestCase):
     def setUp(self):
         self.tmpdir = tempfile.mkdtemp()
         self.mock_db()
@@ -137,17 +138,20 @@ class CommandNotFoundOutputTest(unittest.TestCase):
 
     def set_mock_snap_cmd_json(self, json):
         with open(self.cnf.snap_cmd, "w") as fp:
-            fp.write("""#!/bin/sh
+            fp.write(
+                """#!/bin/sh
 set -e
 
 echo '%s'
-""" % json)
+"""
+                % json
+            )
         os.chmod(self.cnf.snap_cmd, 0o755)
 
     def test_from_table(self):
         for i, spec in enumerate(test_specs):
             self._test_spec(spec)
-        
+
     def _test_spec(self, spec):
         # setup
         self.cnf.db = MockAptDB()
@@ -158,7 +162,7 @@ echo '%s'
         test = "unkown test"
         for i, line in enumerate(lines):
             if line.startswith("debs: "):
-                debs = line[len("debs: "):].split(";")
+                debs = line[len("debs: ") :].split(";")
                 for deb in debs:
                     l = deb.split(":")
                     name, ver = l[0].split("/")
@@ -166,9 +170,9 @@ echo '%s'
                     for cmd in cmds:
                         if not cmd in self.cnf.db._db:
                             self.cnf.db._db[cmd] = []
-                        self.cnf.db._db[cmd].append( (name, ver, "main") )
+                        self.cnf.db._db[cmd].append((name, ver, "main"))
             if line.startswith("snaps: "):
-                snaps = line[len("snaps: "):].split(";")
+                snaps = line[len("snaps: ") :].split(";")
                 mock_json = []
                 for snap in snaps:
                     l = snap.split(":")
@@ -178,11 +182,11 @@ echo '%s'
                         mock_json.append({"Snap": name, "Command": cmd, "Version": ver})
                 self.set_mock_snap_cmd_json(json.dumps(mock_json))
             if line.startswith("test: "):
-                test = line[len("test: "):]
+                test = line[len("test: ") :]
             if line.startswith("with: "):
-                cmd = line[len("with: "):]
+                cmd = line[len("with: ") :]
                 break
-        expected_output = "\n".join(lines[i+1:])
+        expected_output = "\n".join(lines[i + 1 :])
         # run test
         self.cnf.advise(cmd)
         # validate
@@ -191,10 +195,9 @@ echo '%s'
         self.assertEqual(output, expected_output, "test '%s' broken" % test)
         # cleanup
         self.cnf.output_fd.close()
-        
 
-class RegressionTestCase(unittest.TestCase):
 
+class RegressionTestCase(unittest.TestCase):
     def test_lp1130444(self):
         tmpdir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmpdir)
diff --git a/CommandNotFound/tests/test_pyflakes.py b/CommandNotFound/tests/test_pyflakes.py
index 5f97d13..a4a4a14 100755
--- a/CommandNotFound/tests/test_pyflakes.py
+++ b/CommandNotFound/tests/test_pyflakes.py
@@ -3,17 +3,18 @@ import os
 import subprocess
 import unittest
 
+
 class TestPyflakesClean(unittest.TestCase):
-    """ ensure that the tree is pyflakes clean """
+    """ensure that the tree is pyflakes clean"""
 
     def setUp(self):
         self.paths = []
         basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
         for dirpath, dirs, files in os.walk(basedir):
-            self.paths.extend(glob.glob(dirpath+"/*.py"))
+            self.paths.extend(glob.glob(dirpath + "/*.py"))
 
     def test_pyflakes3_clean(self):
-        self.assertEqual(subprocess.check_call(['pyflakes3'] +  self.paths), 0)
+        self.assertEqual(subprocess.check_call(["pyflakes3"] + self.paths), 0)
 
 
 if __name__ == "__main__":
diff --git a/CommandNotFound/util.py b/CommandNotFound/util.py
index c371423..2407f73 100644
--- a/CommandNotFound/util.py
+++ b/CommandNotFound/util.py
@@ -15,22 +15,33 @@ _ = getattr(gettext.translation("command-not-found", fallback=True), _gettext_me
 
 
 def crash_guard(callback, bug_report_url, version):
-    """ Calls callback and catches all exceptions.
+    """Calls callback and catches all exceptions.
     When something bad happens prints a long error message
     with bug report information and exits the program"""
     try:
         try:
             callback()
         except Exception as ex:
-            print(_("Sorry, command-not-found has crashed! Please file a bug report at:"), file=sys.stderr)
+            print(
+                _("Sorry, command-not-found has crashed! Please file a bug report at:"),
+                file=sys.stderr,
+            )
             print(bug_report_url, file=sys.stderr)
-            print(_("Please include the following information with the report:"), file=sys.stderr)
+            print(
+                _("Please include the following information with the report:"),
+                file=sys.stderr,
+            )
             print(file=sys.stderr)
             print(_("command-not-found version: %s") % version, file=sys.stderr)
-            print(_("Python version: %d.%d.%d %s %d") % sys.version_info, file=sys.stderr)
+            print(
+                _("Python version: %d.%d.%d %s %d") % sys.version_info, file=sys.stderr
+            )
             try:
                 import subprocess
-                subprocess.call(["lsb_release", "-i", "-d", "-r", "-c"], stdout=sys.stderr)
+
+                subprocess.call(
+                    ["lsb_release", "-i", "-d", "-r", "-c"], stdout=sys.stderr
+                )
             except (ImportError, OSError):
                 pass
             print(_("Exception information:"), file=sys.stderr)
@@ -38,6 +49,7 @@ def crash_guard(callback, bug_report_url, version):
             print(ex, file=sys.stderr)
             try:
                 import traceback
+
                 traceback.print_exc()
             except ImportError:
                 pass
diff --git a/setup.py b/setup.py
index 3ced20e..42df58d 100755
--- a/setup.py
+++ b/setup.py
@@ -1,19 +1,21 @@
 #!/usr/bin/python3
 
 from distutils.core import setup
-from DistUtilsExtra.command import (build_extra, build_i18n)
+from DistUtilsExtra.command import build_extra, build_i18n
 import glob
 
 setup(
-    name='command-not-found',
-    version='0.3',
-    packages=['CommandNotFound', 'CommandNotFound.db'],
-    scripts=['command-not-found', 'cnf-update-db'],
-    cmdclass={"build": build_extra.build_extra,
-                "build_i18n": build_i18n.build_i18n,
-                },
+    name="command-not-found",
+    version="0.3",
+    packages=["CommandNotFound", "CommandNotFound.db"],
+    scripts=["command-not-found", "cnf-update-db"],
+    cmdclass={
+        "build": build_extra.build_extra,
+        "build_i18n": build_i18n.build_i18n,
+    },
     data_files=[
-        ('share/command-not-found/', glob.glob("data/*.db")),
-        ('../etc', ['bash_command_not_found', 'zsh_command_not_found']),
-        ('../etc/apt/apt.conf.d', ['data/50command-not-found']),
-    ])
+        ("share/command-not-found/", glob.glob("data/*.db")),
+        ("../etc", ["bash_command_not_found", "zsh_command_not_found"]),
+        ("../etc/apt/apt.conf.d", ["data/50command-not-found"]),
+    ],
+)