[gentoo-commits] proj/portage:master commit in: repoman/, bin/, repoman/bin/, /

[Sam James]

commit:     9fe091668c8a1d988c02c849ac1bece6eb764d0b
Author:     John Helmert III <ajak <AT> gentoo <DOT> org>
AuthorDate: Wed Feb  9 20:52:08 2022 +0000
Commit:     Sam James <sam <AT> gentoo <DOT> org>
CommitDate: Mon Feb 21 03:50:50 2022 +0000
URL:        https://gitweb.gentoo.org/proj/portage.git/commit/?id=9fe09166

Blacken previously missed Python files

Signed-off-by: John Helmert III <ajak <AT> gentoo.org>
Signed-off-by: Sam James <sam <AT> gentoo.org>

 bin/archive-conf     |   44 +-
 bin/binhost-snapshot |  262 +++---
 bin/clean_locks      |   56 +-
 bin/dispatch-conf    |  345 ++++---
 bin/ebuild           |  512 ++++++-----
 bin/egencache        | 2435 ++++++++++++++++++++++++++-----------------------
 bin/emaint           |   43 +-
 bin/emerge           |  128 +--
 bin/emirrordist      |   18 +-
 bin/env-update       |   44 +-
 bin/fixpackages      |   40 +-
 bin/glsa-check       |  703 +++++++++------
 bin/pid-ns-init      |   42 +-
 bin/portageq         | 2447 +++++++++++++++++++++++++++-----------------------
 bin/quickpkg         |  734 ++++++++-------
 bin/regenworld       |  207 +++--
 bin/shelve-utils     |   38 +-
 repoman/bin/repoman  |    6 +-
 repoman/runtests     |  113 +--
 runtests             |  110 +--
 20 files changed, 4568 insertions(+), 3759 deletions(-)

diff --git a/bin/archive-conf b/bin/archive-conf
index 3b31ebe1a..beb4fcd23 100755
--- a/bin/archive-conf
+++ b/bin/archive-conf
@@ -12,18 +12,25 @@
 import sys
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 
 import portage.dispatch_conf
 from portage import os
 from portage.checksum import perform_md5
 
-FIND_EXTANT_CONTENTS  = "find %s -name CONTENTS"
+FIND_EXTANT_CONTENTS = "find %s -name CONTENTS"
+
+MANDATORY_OPTS = ["archive-dir"]
 
-MANDATORY_OPTS  = [ 'archive-dir' ]
 
 def archive_conf():
     args = []
@@ -35,12 +42,15 @@ def archive_conf():
     for conf in sys.argv[1:]:
         if not os.path.isabs(conf):
             conf = os.path.abspath(conf)
-        args += [ conf ]
-        md5_match_hash[conf] = ''
+        args += [conf]
+        md5_match_hash[conf] = ""
 
     # Find all the CONTENT files in VDB_PATH.
-    with os.popen(FIND_EXTANT_CONTENTS % (os.path.join(portage.settings['EROOT'], portage.VDB_PATH))) as f:
-	    content_files += f.readlines()
+    with os.popen(
+        FIND_EXTANT_CONTENTS
+        % (os.path.join(portage.settings["EROOT"], portage.VDB_PATH))
+    ) as f:
+        content_files += f.readlines()
 
     # Search for the saved md5 checksum of all the specified config files
     # and see if the current file is unmodified or not.
@@ -51,12 +61,15 @@ def archive_conf():
             try:
                 contents = open(filename, "r")
             except IOError as e:
-                print('archive-conf: Unable to open %s: %s' % (filename, e), file=sys.stderr)
+                print(
+                    "archive-conf: Unable to open %s: %s" % (filename, e),
+                    file=sys.stderr,
+                )
                 sys.exit(1)
             lines = contents.readlines()
             for line in lines:
                 items = line.split()
-                if items[0] == 'obj':
+                if items[0] == "obj":
                     for conf in args:
                         if items[1] == conf:
                             stored = items[2].lower()
@@ -70,18 +83,19 @@ def archive_conf():
         pass
 
     for conf in args:
-        archive = os.path.join(options['archive-dir'], conf.lstrip('/'))
-        if options['use-rcs'] == 'yes':
-            portage.dispatch_conf.rcs_archive(archive, conf, md5_match_hash[conf], '')
+        archive = os.path.join(options["archive-dir"], conf.lstrip("/"))
+        if options["use-rcs"] == "yes":
+            portage.dispatch_conf.rcs_archive(archive, conf, md5_match_hash[conf], "")
             if md5_match_hash[conf]:
                 portage.dispatch_conf.rcs_archive_post_process(archive)
         else:
-            portage.dispatch_conf.file_archive(archive, conf, md5_match_hash[conf], '')
+            portage.dispatch_conf.file_archive(archive, conf, md5_match_hash[conf], "")
             if md5_match_hash[conf]:
                 portage.dispatch_conf.file_archive_post_process(archive)
 
+
 # run
 if len(sys.argv) > 1:
     archive_conf()
 else:
-    print('Usage: archive-conf /CONFIG/FILE [/CONFIG/FILE...]', file=sys.stderr)
+    print("Usage: archive-conf /CONFIG/FILE [/CONFIG/FILE...]", file=sys.stderr)

diff --git a/bin/binhost-snapshot b/bin/binhost-snapshot
index 2201781d6..3461a301c 100755
--- a/bin/binhost-snapshot
+++ b/bin/binhost-snapshot
@@ -11,128 +11,156 @@ import textwrap
 from urllib.parse import urlparse
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 
+
 def parse_args(argv):
-	prog_name = os.path.basename(argv[0])
-	usage = prog_name + ' [options] ' + \
-		'<src_pkg_dir> <snapshot_dir> <snapshot_uri> <binhost_dir>'
-
-	prog_desc = "This program will copy src_pkg_dir to snapshot_dir " + \
-		"and inside binhost_dir it will create a Packages index file " + \
-		"which refers to snapshot_uri. This is intended to solve race " + \
-		"conditions on binhosts as described at http://crosbug.com/3225."
-
-	usage += "\n\n"
-	for line in textwrap.wrap(prog_desc, 70):
-		usage += line + "\n"
-
-	usage += "\n"
-	usage += "Required Arguments:\n\n"
-	usage += "  src_pkg_dir  - the source $PKGDIR\n"
-	usage += "  snapshot_dir - destination snapshot " + \
-		"directory (must not exist)\n"
-	usage += "  snapshot_uri - URI which refers to " + \
-		"snapshot_dir from the\n" + \
-		"                 client side\n"
-	usage += "  binhost_dir  - directory in which to " + \
-		"write Packages index with\n" + \
-		"                 snapshot_uri"
-
-	parser = argparse.ArgumentParser(usage=usage)
-	parser.add_argument('--hardlinks',
-		help='create hardlinks (y or n, default is y)',
-		choices=('y', 'n'),
-		default='y')
-	options, args = parser.parse_known_args(argv[1:])
-
-	if len(args) != 4:
-		parser.error("Required 4 arguments, got %d" % (len(args),))
-
-	return parser, options, args
+    prog_name = os.path.basename(argv[0])
+    usage = (
+        prog_name
+        + " [options] "
+        + "<src_pkg_dir> <snapshot_dir> <snapshot_uri> <binhost_dir>"
+    )
+
+    prog_desc = (
+        "This program will copy src_pkg_dir to snapshot_dir "
+        + "and inside binhost_dir it will create a Packages index file "
+        + "which refers to snapshot_uri. This is intended to solve race "
+        + "conditions on binhosts as described at http://crosbug.com/3225."
+    )
+
+    usage += "\n\n"
+    for line in textwrap.wrap(prog_desc, 70):
+        usage += line + "\n"
+
+    usage += "\n"
+    usage += "Required Arguments:\n\n"
+    usage += "  src_pkg_dir  - the source $PKGDIR\n"
+    usage += "  snapshot_dir - destination snapshot " + "directory (must not exist)\n"
+    usage += (
+        "  snapshot_uri - URI which refers to "
+        + "snapshot_dir from the\n"
+        + "                 client side\n"
+    )
+    usage += (
+        "  binhost_dir  - directory in which to "
+        + "write Packages index with\n"
+        + "                 snapshot_uri"
+    )
+
+    parser = argparse.ArgumentParser(usage=usage)
+    parser.add_argument(
+        "--hardlinks",
+        help="create hardlinks (y or n, default is y)",
+        choices=("y", "n"),
+        default="y",
+    )
+    options, args = parser.parse_known_args(argv[1:])
+
+    if len(args) != 4:
+        parser.error("Required 4 arguments, got %d" % (len(args),))
+
+    return parser, options, args
+
 
 def main(argv):
-	parser, options, args = parse_args(argv)
-
-	src_pkg_dir, snapshot_dir, snapshot_uri, binhost_dir = args
-	src_pkgs_index = os.path.join(src_pkg_dir, 'Packages')
-
-	if not os.path.isdir(src_pkg_dir):
-		parser.error("src_pkg_dir is not a directory: '%s'" % (src_pkg_dir,))
-
-	if not os.path.isfile(src_pkgs_index):
-		parser.error("src_pkg_dir does not contain a " + \
-			"'Packages' index: '%s'" % (src_pkg_dir,))
-
-	parse_result = urlparse(snapshot_uri)
-	if not (parse_result.scheme and parse_result.netloc and parse_result.path):
-		parser.error("snapshot_uri is not a valid URI: '%s'" % (snapshot_uri,))
-
-	if os.path.isdir(snapshot_dir):
-		parser.error("snapshot_dir already exists: '%s'" % snapshot_dir)
-
-	try:
-		os.makedirs(os.path.dirname(snapshot_dir))
-	except OSError:
-		pass
-	if not os.path.isdir(os.path.dirname(snapshot_dir)):
-		parser.error("snapshot_dir parent could not be created: '%s'" % \
-			os.path.dirname(snapshot_dir))
-
-	try:
-		os.makedirs(binhost_dir)
-	except OSError:
-		pass
-	if not os.path.isdir(binhost_dir):
-		parser.error("binhost_dir could not be created: '%s'" % binhost_dir)
-
-	cp_opts = 'RP'
-	if options.hardlinks == 'n':
-		cp_opts += 'p'
-	else:
-		cp_opts += 'l'
-
-	cp_cmd = 'cp -%s %s %s' % (
-		cp_opts,
-		portage._shell_quote(src_pkg_dir),
-		portage._shell_quote(snapshot_dir)
-	)
-
-	ret = os.system(cp_cmd)
-	if not (os.WIFEXITED(ret) and os.WEXITSTATUS(ret) == os.EX_OK):
-		return 1
-
-	infile = io.open(portage._unicode_encode(src_pkgs_index,
-		encoding=portage._encodings['fs'], errors='strict'),
-		mode='r', encoding=portage._encodings['repo.content'],
-		errors='strict')
-
-	outfile = portage.util.atomic_ofstream(
-		os.path.join(binhost_dir, "Packages"),
-		encoding=portage._encodings['repo.content'],
-		errors='strict')
-
-	for line in infile:
-		if line[:4] == 'URI:':
-			# skip existing URI line
-			pass
-		else:
-			if not line.strip():
-				# end of header
-				outfile.write("URI: %s\n\n" % snapshot_uri)
-				break
-			outfile.write(line)
-
-	for line in infile:
-		outfile.write(line)
-
-	infile.close()
-	outfile.close()
-
-	return os.EX_OK
+    parser, options, args = parse_args(argv)
+
+    src_pkg_dir, snapshot_dir, snapshot_uri, binhost_dir = args
+    src_pkgs_index = os.path.join(src_pkg_dir, "Packages")
+
+    if not os.path.isdir(src_pkg_dir):
+        parser.error("src_pkg_dir is not a directory: '%s'" % (src_pkg_dir,))
+
+    if not os.path.isfile(src_pkgs_index):
+        parser.error(
+            "src_pkg_dir does not contain a "
+            + "'Packages' index: '%s'" % (src_pkg_dir,)
+        )
+
+    parse_result = urlparse(snapshot_uri)
+    if not (parse_result.scheme and parse_result.netloc and parse_result.path):
+        parser.error("snapshot_uri is not a valid URI: '%s'" % (snapshot_uri,))
+
+    if os.path.isdir(snapshot_dir):
+        parser.error("snapshot_dir already exists: '%s'" % snapshot_dir)
+
+    try:
+        os.makedirs(os.path.dirname(snapshot_dir))
+    except OSError:
+        pass
+    if not os.path.isdir(os.path.dirname(snapshot_dir)):
+        parser.error(
+            "snapshot_dir parent could not be created: '%s'"
+            % os.path.dirname(snapshot_dir)
+        )
+
+    try:
+        os.makedirs(binhost_dir)
+    except OSError:
+        pass
+    if not os.path.isdir(binhost_dir):
+        parser.error("binhost_dir could not be created: '%s'" % binhost_dir)
+
+    cp_opts = "RP"
+    if options.hardlinks == "n":
+        cp_opts += "p"
+    else:
+        cp_opts += "l"
+
+    cp_cmd = "cp -%s %s %s" % (
+        cp_opts,
+        portage._shell_quote(src_pkg_dir),
+        portage._shell_quote(snapshot_dir),
+    )
+
+    ret = os.system(cp_cmd)
+    if not (os.WIFEXITED(ret) and os.WEXITSTATUS(ret) == os.EX_OK):
+        return 1
+
+    infile = io.open(
+        portage._unicode_encode(
+            src_pkgs_index, encoding=portage._encodings["fs"], errors="strict"
+        ),
+        mode="r",
+        encoding=portage._encodings["repo.content"],
+        errors="strict",
+    )
+
+    outfile = portage.util.atomic_ofstream(
+        os.path.join(binhost_dir, "Packages"),
+        encoding=portage._encodings["repo.content"],
+        errors="strict",
+    )
+
+    for line in infile:
+        if line[:4] == "URI:":
+            # skip existing URI line
+            pass
+        else:
+            if not line.strip():
+                # end of header
+                outfile.write("URI: %s\n\n" % snapshot_uri)
+                break
+            outfile.write(line)
+
+    for line in infile:
+        outfile.write(line)
+
+    infile.close()
+    outfile.close()
+
+    return os.EX_OK
+
 
 if __name__ == "__main__":
-	sys.exit(main(sys.argv))
+    sys.exit(main(sys.argv))

diff --git a/bin/clean_locks b/bin/clean_locks
index 6618f58da..88e1b3325 100755
--- a/bin/clean_locks
+++ b/bin/clean_locks
@@ -5,38 +5,44 @@
 import errno
 import sys
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 
 if not sys.argv[1:] or "--help" in sys.argv or "-h" in sys.argv:
-	print()
-	print("You must specify directories with hardlink-locks to clean.")
-	print("You may optionally specify --force, which will remove all")
-	print("of the locks, even if we can't establish if they are in use.")
-	print("Please attempt cleaning without force first.")
-	print()
-	print("%s %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"]))
-	print("%s --force %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"]))
-	print()
-	sys.exit(1)
+    print()
+    print("You must specify directories with hardlink-locks to clean.")
+    print("You may optionally specify --force, which will remove all")
+    print("of the locks, even if we can't establish if they are in use.")
+    print("Please attempt cleaning without force first.")
+    print()
+    print("%s %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"]))
+    print("%s --force %s/.locks" % (sys.argv[0], portage.settings["DISTDIR"]))
+    print()
+    sys.exit(1)
 
 force = False
 if "--force" in sys.argv[1:]:
-	force=True
+    force = True
 
 for x in sys.argv[1:]:
-	if x == "--force":
-		continue
-	try:
-		for y in portage.locks.hardlock_cleanup(x, remove_all_locks=force):
-			print(y)
-		print()
+    if x == "--force":
+        continue
+    try:
+        for y in portage.locks.hardlock_cleanup(x, remove_all_locks=force):
+            print(y)
+        print()
 
-	except OSError as e:
-		if e.errno in (errno.ENOENT, errno.ENOTDIR):
-			print("!!! %s is not a directory or does not exist" % x)
-		else:
-			raise
-		sys.exit(e.errno)
+    except OSError as e:
+        if e.errno in (errno.ENOENT, errno.ENOTDIR):
+            print("!!! %s is not a directory or does not exist" % x)
+        else:
+            raise
+        sys.exit(e.errno)

diff --git a/bin/dispatch-conf b/bin/dispatch-conf
index a4ca80ba9..c0e7ffc1e 100755
--- a/bin/dispatch-conf
+++ b/bin/dispatch-conf
@@ -23,28 +23,39 @@ from stat import ST_GID, ST_MODE, ST_UID
 from random import random
 
 try:
-	import curses
+    import curses
 except ImportError:
-	curses = None
+    curses = None
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os, shutil
 from portage import _encodings, _unicode_decode
-from portage.dispatch_conf import (diffstatusoutput, diff_mixed_wrapper,
-	perform_conf_update_hooks, perform_conf_update_session_hooks)
+from portage.dispatch_conf import (
+    diffstatusoutput,
+    diff_mixed_wrapper,
+    perform_conf_update_hooks,
+    perform_conf_update_session_hooks,
+)
 from portage.process import find_binary, spawn
 from portage.util import writemsg, writemsg_stdout
 
-FIND_EXTANT_CONFIGS  = "find '%s' %s -name '._cfg????_%s' ! -name '.*~' ! -iname '.*.bak' -print"
-DIFF_CONTENTS        = "diff -Nu '%s' '%s'"
+FIND_EXTANT_CONFIGS = (
+    "find '%s' %s -name '._cfg????_%s' ! -name '.*~' ! -iname '.*.bak' -print"
+)
+DIFF_CONTENTS = "diff -Nu '%s' '%s'"
 
 if "case-insensitive-fs" in portage.settings.features:
-    FIND_EXTANT_CONFIGS = FIND_EXTANT_CONFIGS.replace(
-        "-name '._cfg", "-iname '._cfg")
+    FIND_EXTANT_CONFIGS = FIND_EXTANT_CONFIGS.replace("-name '._cfg", "-iname '._cfg")
 
 # We need a secure scratch dir and python does silly verbose errors on the use of tempnam
 oldmask = os.umask(0o077)
@@ -52,13 +63,13 @@ SCRATCH_DIR = None
 while SCRATCH_DIR is None:
     try:
         mydir = "/tmp/dispatch-conf."
-        for x in range(0,8):
+        for x in range(0, 8):
             if int(random() * 3) == 0:
-                mydir += chr(int(65+random()*26.0))
+                mydir += chr(int(65 + random() * 26.0))
             elif int(random() * 2) == 0:
-                mydir += chr(int(97+random()*26.0))
+                mydir += chr(int(97 + random() * 26.0))
             else:
-                mydir += chr(int(48+random()*10.0))
+                mydir += chr(int(48 + random() * 10.0))
         if os.path.exists(mydir):
             continue
         os.mkdir(mydir)
@@ -71,9 +82,12 @@ os.umask(oldmask)
 # Ensure the scratch dir is deleted
 def cleanup(mydir=SCRATCH_DIR):
     shutil.rmtree(mydir)
+
+
 atexit.register(cleanup)
 
-MANDATORY_OPTS = [ 'archive-dir', 'diff', 'replace-cvs', 'replace-wscomments', 'merge' ]
+MANDATORY_OPTS = ["archive-dir", "diff", "replace-cvs", "replace-wscomments", "merge"]
+
 
 def cmd_var_is_valid(cmd):
     """
@@ -89,12 +103,14 @@ def cmd_var_is_valid(cmd):
 
     return find_binary(cmd[0]) is not None
 
+
 diff = diff_mixed_wrapper(diffstatusoutput, DIFF_CONTENTS)
 
+
 class dispatch:
     options = {}
 
-    def grind (self, config_paths):
+    def grind(self, config_paths):
         confs = []
         count = 0
 
@@ -105,10 +121,11 @@ class dispatch:
 
         if "log-file" in self.options:
             if os.path.isfile(self.options["log-file"]):
-                shutil.copy(self.options["log-file"], self.options["log-file"] + '.old')
-            if os.path.isfile(self.options["log-file"]) \
-               or not os.path.exists(self.options["log-file"]):
-                open(self.options["log-file"], 'w').close() # Truncate it
+                shutil.copy(self.options["log-file"], self.options["log-file"] + ".old")
+            if os.path.isfile(self.options["log-file"]) or not os.path.exists(
+                self.options["log-file"]
+            ):
+                open(self.options["log-file"], "w").close()  # Truncate it
                 os.chmod(self.options["log-file"], 0o600)
 
         pager = self.options.get("pager")
@@ -134,7 +151,8 @@ class dispatch:
 
         for path in config_paths:
             path = portage.normalize_path(
-                 os.path.join(config_root, path.lstrip(os.sep)))
+                os.path.join(config_root, path.lstrip(os.sep))
+            )
 
             # Protect files that don't exist (bug #523684). If the
             # parent directory doesn't exist, we can safely skip it.
@@ -148,32 +166,38 @@ class dispatch:
                 find_opts = "-maxdepth 1"
 
             try:
-                path_list = _unicode_decode(subprocess.check_output(
-                    portage.util.shlex_split(FIND_EXTANT_CONFIGS %
-                    (path, find_opts, basename))),
-                    errors='strict').splitlines()
+                path_list = _unicode_decode(
+                    subprocess.check_output(
+                        portage.util.shlex_split(
+                            FIND_EXTANT_CONFIGS % (path, find_opts, basename)
+                        )
+                    ),
+                    errors="strict",
+                ).splitlines()
             except subprocess.CalledProcessError:
                 pass
             else:
                 confs.extend(self.massage(path_list))
 
-        if self.options['use-rcs'] == 'yes':
+        if self.options["use-rcs"] == "yes":
             for rcs_util in ("rcs", "ci", "co", "rcsmerge"):
                 if not find_binary(rcs_util):
-                    print('dispatch-conf: Error finding all RCS utils and " + \
-                        "use-rcs=yes in config; fatal', file=sys.stderr)
+                    print(
+                        'dispatch-conf: Error finding all RCS utils and " + \
+                        "use-rcs=yes in config; fatal',
+                        file=sys.stderr,
+                    )
                     return False
 
-
         # config file freezing support
         frozen_files = set(self.options.get("frozen-files", "").split())
         auto_zapped = []
         protect_obj = portage.util.ConfigProtect(
-            config_root, config_paths,
-            portage.util.shlex_split(
-            portage.settings.get('CONFIG_PROTECT_MASK', '')),
-            case_insensitive=("case-insensitive-fs"
-            in portage.settings.features))
+            config_root,
+            config_paths,
+            portage.util.shlex_split(portage.settings.get("CONFIG_PROTECT_MASK", "")),
+            case_insensitive=("case-insensitive-fs" in portage.settings.features),
+        )
 
         #
         # Remove new configs identical to current
@@ -183,36 +207,44 @@ class dispatch:
         #                  or  c) in paths now unprotected by CONFIG_PROTECT_MASK,
         #
 
-        def f (conf):
-            mrgconf = re.sub(r'\._cfg', '._mrg', conf['new'])
-            archive = os.path.join(self.options['archive-dir'], conf['current'].lstrip('/'))
-            if self.options['use-rcs'] == 'yes':
-                mrgfail = portage.dispatch_conf.rcs_archive(archive, conf['current'], conf['new'], mrgconf)
+        def f(conf):
+            mrgconf = re.sub(r"\._cfg", "._mrg", conf["new"])
+            archive = os.path.join(
+                self.options["archive-dir"], conf["current"].lstrip("/")
+            )
+            if self.options["use-rcs"] == "yes":
+                mrgfail = portage.dispatch_conf.rcs_archive(
+                    archive, conf["current"], conf["new"], mrgconf
+                )
             else:
-                mrgfail = portage.dispatch_conf.file_archive(archive, conf['current'], conf['new'], mrgconf)
-            if os.path.lexists(archive + '.dist'):
-                unmodified = len(diff(conf['current'], archive + '.dist')[1]) == 0
+                mrgfail = portage.dispatch_conf.file_archive(
+                    archive, conf["current"], conf["new"], mrgconf
+                )
+            if os.path.lexists(archive + ".dist"):
+                unmodified = len(diff(conf["current"], archive + ".dist")[1]) == 0
             else:
                 unmodified = 0
             if os.path.exists(mrgconf):
-                if mrgfail or len(diff(conf['new'], mrgconf)[1]) == 0:
+                if mrgfail or len(diff(conf["new"], mrgconf)[1]) == 0:
                     os.unlink(mrgconf)
-                    newconf = conf['new']
+                    newconf = conf["new"]
                 else:
                     newconf = mrgconf
             else:
-                newconf = conf['new']
-
-            if newconf == mrgconf and \
-                self.options.get('ignore-previously-merged') != 'yes' and \
-                os.path.lexists(archive+'.dist') and \
-                len(diff(archive+'.dist', conf['new'])[1]) == 0:
+                newconf = conf["new"]
+
+            if (
+                newconf == mrgconf
+                and self.options.get("ignore-previously-merged") != "yes"
+                and os.path.lexists(archive + ".dist")
+                and len(diff(archive + ".dist", conf["new"])[1]) == 0
+            ):
                 # The current update is identical to the archived .dist
                 # version that has previously been merged.
                 os.unlink(mrgconf)
-                newconf = conf['new']
+                newconf = conf["new"]
 
-            mystatus, myoutput = diff(conf['current'], newconf)
+            mystatus, myoutput = diff(conf["current"], newconf)
             myoutput_len = len(myoutput)
             same_file = 0 == myoutput_len
             if mystatus >> 8 == 2:
@@ -221,49 +253,53 @@ class dispatch:
                 same_wsc = False
             else:
                 # Extract all the normal diff lines (ignore the headers).
-                mylines = re.findall('^[+-][^\n+-].*$', myoutput, re.MULTILINE)
+                mylines = re.findall("^[+-][^\n+-].*$", myoutput, re.MULTILINE)
 
                 # Filter out all the cvs headers
-                cvs_header = re.compile('# [$]Header:')
+                cvs_header = re.compile("# [$]Header:")
                 cvs_lines = list(filter(cvs_header.search, mylines))
                 same_cvs = len(mylines) == len(cvs_lines)
 
                 # Filter out comments and whitespace-only changes.
                 # Note: be nice to also ignore lines that only differ in whitespace...
                 wsc_lines = []
-                for x in [r'^[-+]\s*#', r'^[-+]\s*$']:
-                   wsc_lines += list(filter(re.compile(x).match, mylines))
+                for x in [r"^[-+]\s*#", r"^[-+]\s*$"]:
+                    wsc_lines += list(filter(re.compile(x).match, mylines))
                 same_wsc = len(mylines) == len(wsc_lines)
 
             # Do options permit?
-            same_cvs = same_cvs and self.options['replace-cvs'] == 'yes'
-            same_wsc = same_wsc and self.options['replace-wscomments'] == 'yes'
-            unmodified = unmodified and self.options['replace-unmodified'] == 'yes'
+            same_cvs = same_cvs and self.options["replace-cvs"] == "yes"
+            same_wsc = same_wsc and self.options["replace-wscomments"] == "yes"
+            unmodified = unmodified and self.options["replace-unmodified"] == "yes"
 
             if same_file:
-                os.unlink (conf ['new'])
-                self.post_process(conf['current'])
+                os.unlink(conf["new"])
+                self.post_process(conf["current"])
                 if os.path.exists(mrgconf):
                     os.unlink(mrgconf)
                 return False
-            elif conf['current'] in frozen_files:
+            elif conf["current"] in frozen_files:
                 """Frozen files are automatically zapped. The new config has
                 already been archived with a .new suffix.  When zapped, it is
                 left with the .new suffix (post_process is skipped), since it
                 hasn't been merged into the current config."""
-                auto_zapped.append(conf['current'])
-                os.unlink(conf['new'])
+                auto_zapped.append(conf["current"])
+                os.unlink(conf["new"])
                 try:
                     os.unlink(mrgconf)
                 except OSError:
                     pass
                 return False
-            elif unmodified or same_cvs or same_wsc or \
-                not protect_obj.isprotected(conf['current']):
-                self.replace(newconf, conf['current'])
-                self.post_process(conf['current'])
+            elif (
+                unmodified
+                or same_cvs
+                or same_wsc
+                or not protect_obj.isprotected(conf["current"])
+            ):
+                self.replace(newconf, conf["current"])
+                self.post_process(conf["current"])
                 if newconf == mrgconf:
-                    os.unlink(conf['new'])
+                    os.unlink(conf["new"])
                 elif os.path.exists(mrgconf):
                     os.unlink(mrgconf)
                 return False
@@ -279,7 +315,7 @@ class dispatch:
         valid_input = "qhtnmlezu"
 
         def diff_pager(file1, file2):
-            cmd = self.options['diff'] % (file1, file2)
+            cmd = self.options["diff"] % (file1, file2)
             cmd += pager
             spawn_shell(cmd)
 
@@ -288,8 +324,8 @@ class dispatch:
         for conf in confs:
             count = count + 1
 
-            newconf = conf['new']
-            mrgconf = re.sub(r'\._cfg', '._mrg', newconf)
+            newconf = conf["new"]
+            mrgconf = re.sub(r"\._cfg", "._mrg", newconf)
             if os.path.exists(mrgconf):
                 newconf = mrgconf
             show_new_diff = 0
@@ -297,14 +333,20 @@ class dispatch:
             while 1:
                 clear_screen()
                 if show_new_diff:
-                    diff_pager(conf['new'], mrgconf)
+                    diff_pager(conf["new"], mrgconf)
                     show_new_diff = 0
                 else:
-                    diff_pager(conf['current'], newconf)
+                    diff_pager(conf["current"], newconf)
 
                 print()
-                writemsg_stdout('>> (%i of %i) -- %s\n' % (count, len(confs), conf['current']), noiselevel=-1)
-                print('>> q quit, h help, n next, e edit-new, z zap-new, u use-new\n   m merge, t toggle-merge, l look-merge: ', end=' ')
+                writemsg_stdout(
+                    ">> (%i of %i) -- %s\n" % (count, len(confs), conf["current"]),
+                    noiselevel=-1,
+                )
+                print(
+                    ">> q quit, h help, n next, e edit-new, z zap-new, u use-new\n   m merge, t toggle-merge, l look-merge: ",
+                    end=" ",
+                )
 
                 # In some cases getch() will return some spurious characters
                 # that do not represent valid input. If we don't validate the
@@ -315,28 +357,30 @@ class dispatch:
                 while True:
                     c = getch()
                     if c in valid_input:
-                        sys.stdout.write('\n')
+                        sys.stdout.write("\n")
                         sys.stdout.flush()
                         break
 
-                if c == 'q':
+                if c == "q":
                     perform_conf_update_session_hooks("post-session")
-                    sys.exit (0)
-                if c == 'h':
-                    self.do_help ()
+                    sys.exit(0)
+                if c == "h":
+                    self.do_help()
                     continue
-                elif c == 't':
+                elif c == "t":
                     if newconf == mrgconf:
-                        newconf = conf['new']
+                        newconf = conf["new"]
                     elif os.path.exists(mrgconf):
                         newconf = mrgconf
                     continue
-                elif c == 'n':
+                elif c == "n":
                     break
-                elif c == 'm':
-                    merged = SCRATCH_DIR+"/"+os.path.basename(conf['current'])
+                elif c == "m":
+                    merged = SCRATCH_DIR + "/" + os.path.basename(conf["current"])
                     print()
-                    ret = os.system (self.options['merge'] % (merged, conf ['current'], newconf))
+                    ret = os.system(
+                        self.options["merge"] % (merged, conf["current"], newconf)
+                    )
                     ret = os.WEXITSTATUS(ret)
                     if ret < 2:
                         ret = 0
@@ -345,29 +389,29 @@ class dispatch:
                         continue
                     shutil.copyfile(merged, mrgconf)
                     os.remove(merged)
-                    mystat = os.lstat(conf['new'])
+                    mystat = os.lstat(conf["new"])
                     os.chmod(mrgconf, mystat[ST_MODE])
                     os.chown(mrgconf, mystat[ST_UID], mystat[ST_GID])
                     newconf = mrgconf
                     continue
-                elif c == 'l':
+                elif c == "l":
                     show_new_diff = 1
                     continue
-                elif c == 'e':
-                    if 'EDITOR' not in os.environ:
-                        os.environ['EDITOR']='nano'
-                    os.system(os.environ['EDITOR'] + ' ' + newconf)
+                elif c == "e":
+                    if "EDITOR" not in os.environ:
+                        os.environ["EDITOR"] = "nano"
+                    os.system(os.environ["EDITOR"] + " " + newconf)
                     continue
-                elif c == 'z':
-                    os.unlink(conf['new'])
+                elif c == "z":
+                    os.unlink(conf["new"])
                     if os.path.exists(mrgconf):
                         os.unlink(mrgconf)
                     break
-                elif c == 'u':
-                    self.replace(newconf, conf ['current'])
-                    self.post_process(conf['current'])
+                elif c == "u":
+                    self.replace(newconf, conf["current"])
+                    self.post_process(conf["current"])
                     if newconf == mrgconf:
-                        os.unlink(conf['new'])
+                        os.unlink(conf["new"])
                     elif os.path.exists(mrgconf):
                         os.unlink(mrgconf)
                     break
@@ -384,13 +428,14 @@ class dispatch:
 
         perform_conf_update_session_hooks("post-session")
 
-    def replace (self, newconf, curconf):
+    def replace(self, newconf, curconf):
         """Replace current config with the new/merged version.  Also logs
         the diff of what changed into the configured log file."""
         if "log-file" in self.options:
             status, output = diff(curconf, newconf)
-            with io.open(self.options["log-file"], mode="a",
-                encoding=_encodings["stdio"]) as f:
+            with io.open(
+                self.options["log-file"], mode="a", encoding=_encodings["stdio"]
+            ) as f:
                 f.write(output + "\n")
 
         perform_conf_update_hooks("pre-update", curconf)
@@ -398,22 +443,23 @@ class dispatch:
         try:
             os.rename(newconf, curconf)
         except (IOError, os.error) as why:
-            writemsg('dispatch-conf: Error renaming %s to %s: %s; fatal\n' % \
-                  (newconf, curconf, str(why)), noiselevel=-1)
+            writemsg(
+                "dispatch-conf: Error renaming %s to %s: %s; fatal\n"
+                % (newconf, curconf, str(why)),
+                noiselevel=-1,
+            )
             return
 
         perform_conf_update_hooks("post-update", curconf)
 
-
     def post_process(self, curconf):
-        archive = os.path.join(self.options['archive-dir'], curconf.lstrip('/'))
-        if self.options['use-rcs'] == 'yes':
+        archive = os.path.join(self.options["archive-dir"], curconf.lstrip("/"))
+        if self.options["use-rcs"] == "yes":
             portage.dispatch_conf.rcs_archive_post_process(archive)
         else:
             portage.dispatch_conf.file_archive_post_process(archive)
 
-
-    def massage (self, newconfigs):
+    def massage(self, newconfigs):
         """Sort, rstrip, remove old versions, break into triad hash.
 
         Triad is dictionary of current (/etc/make.conf), new (/etc/._cfg0003_make.conf)
@@ -423,25 +469,25 @@ class dispatch:
         """
         h = {}
         configs = []
-        newconfigs.sort ()
+        newconfigs.sort()
 
         for nconf in newconfigs:
             # Use strict mode here, because we want to know if it fails,
             # and portage only merges files with valid UTF-8 encoding.
-            nconf = _unicode_decode(nconf, errors='strict').rstrip()
-            conf  = re.sub (r'\._cfg\d+_', '', nconf)
-            dirname   = os.path.dirname(nconf)
-            conf_map  = {
-                'current' : conf,
-                'dir'     : dirname,
-                'new'     : nconf,
+            nconf = _unicode_decode(nconf, errors="strict").rstrip()
+            conf = re.sub(r"\._cfg\d+_", "", nconf)
+            dirname = os.path.dirname(nconf)
+            conf_map = {
+                "current": conf,
+                "dir": dirname,
+                "new": nconf,
             }
 
             if conf in h:
-                mrgconf = re.sub(r'\._cfg', '._mrg', h[conf]['new'])
+                mrgconf = re.sub(r"\._cfg", "._mrg", h[conf]["new"])
                 if os.path.exists(mrgconf):
                     os.unlink(mrgconf)
-                os.unlink(h[conf]['new'])
+                os.unlink(h[conf]["new"])
                 h[conf].update(conf_map)
             else:
                 h[conf] = conf_map
@@ -449,27 +495,27 @@ class dispatch:
 
         return configs
 
-
-    def do_help (self):
+    def do_help(self):
         print()
         print()
 
-        print('  u -- update current config with new config and continue')
-        print('  z -- zap (delete) new config and continue')
-        print('  n -- skip to next config, leave all intact')
-        print('  e -- edit new config')
-        print('  m -- interactively merge current and new configs')
-        print('  l -- look at diff between pre-merged and merged configs')
-        print('  t -- toggle new config between merged and pre-merged state')
-        print('  h -- this screen')
-        print('  q -- quit')
+        print("  u -- update current config with new config and continue")
+        print("  z -- zap (delete) new config and continue")
+        print("  n -- skip to next config, leave all intact")
+        print("  e -- edit new config")
+        print("  m -- interactively merge current and new configs")
+        print("  l -- look at diff between pre-merged and merged configs")
+        print("  t -- toggle new config between merged and pre-merged state")
+        print("  h -- this screen")
+        print("  q -- quit")
 
-        print(); print('press any key to return to diff...', end=' ')
+        print()
+        print("press any key to return to diff...", end=" ")
 
-        getch ()
+        getch()
 
 
-def getch ():
+def getch():
     # from ASPN - Danny Yoo
     #
 
@@ -482,6 +528,7 @@ def getch ():
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
     return ch
 
+
 def clear_screen():
     if curses is not None:
         try:
@@ -493,40 +540,48 @@ def clear_screen():
             pass
     os.system("clear 2>/dev/null")
 
+
 shell = os.environ.get("SHELL")
 if not shell or not os.access(shell, os.EX_OK):
     shell = find_binary("sh")
 
+
 def spawn_shell(cmd):
     if shell:
         sys.__stdout__.flush()
         sys.__stderr__.flush()
-        spawn([shell, "-c", cmd], env=os.environ,
-            fd_pipes = {  0 : portage._get_stdin().fileno(),
-                          1 : sys.__stdout__.fileno(),
-                          2 : sys.__stderr__.fileno()})
+        spawn(
+            [shell, "-c", cmd],
+            env=os.environ,
+            fd_pipes={
+                0: portage._get_stdin().fileno(),
+                1: sys.__stdout__.fileno(),
+                2: sys.__stderr__.fileno(),
+            },
+        )
     else:
         os.system(cmd)
 
+
 def usage(argv):
-    print('dispatch-conf: sane configuration file update\n')
-    print('Usage: dispatch-conf [config dirs]\n')
-    print('See the dispatch-conf(1) man page for more details')
+    print("dispatch-conf: sane configuration file update\n")
+    print("Usage: dispatch-conf [config dirs]\n")
+    print("See the dispatch-conf(1) man page for more details")
     sys.exit(os.EX_OK)
 
+
 for x in sys.argv:
-    if x in ('-h', '--help'):
+    if x in ("-h", "--help"):
         usage(sys.argv)
-    elif x in ('--version',):
+    elif x in ("--version",):
         print("Portage", portage.VERSION)
         sys.exit(os.EX_OK)
 
 # run
-d = dispatch ()
+d = dispatch()
 
 if len(sys.argv) > 1:
     # for testing
     d.grind(sys.argv[1:])
 else:
-    d.grind(portage.util.shlex_split(
-        portage.settings.get('CONFIG_PROTECT', '')))
+    d.grind(portage.util.shlex_split(portage.settings.get("CONFIG_PROTECT", "")))

diff --git a/bin/ebuild b/bin/ebuild
index 3ad589008..bdedab9cb 100755
--- a/bin/ebuild
+++ b/bin/ebuild
@@ -11,45 +11,58 @@ import textwrap
 # This block ensures that ^C interrupts are handled quietly.
 try:
 
-	def exithandler(signum, _frame):
-		signal.signal(signal.SIGINT, signal.SIG_IGN)
-		signal.signal(signal.SIGTERM, signal.SIG_IGN)
-		sys.exit(128 + signum)
+    def exithandler(signum, _frame):
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        sys.exit(128 + signum)
 
-	signal.signal(signal.SIGINT, exithandler)
-	signal.signal(signal.SIGTERM, exithandler)
-	# Prevent "[Errno 32] Broken pipe" exceptions when
-	# writing to a pipe.
-	signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    signal.signal(signal.SIGINT, exithandler)
+    signal.signal(signal.SIGTERM, exithandler)
+    # Prevent "[Errno 32] Broken pipe" exceptions when
+    # writing to a pipe.
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
 except KeyboardInterrupt:
-	sys.exit(128 + signal.SIGINT)
+    sys.exit(128 + signal.SIGINT)
+
 
 def debug_signal(_signum, _frame):
-	import pdb
-	pdb.set_trace()
+    import pdb
+
+    pdb.set_trace()
 
-if platform.python_implementation() == 'Jython':
-	debug_signum = signal.SIGUSR2 # bug #424259
+
+if platform.python_implementation() == "Jython":
+    debug_signum = signal.SIGUSR2  # bug #424259
 else:
-	debug_signum = signal.SIGUSR1
+    debug_signum = signal.SIGUSR1
 
 signal.signal(debug_signum, debug_signal)
 
 import io
 import os
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage import _encodings
 from portage import _shell_quote
 from portage import _unicode_encode
 from portage.const import VDB_PATH
-from portage.exception import PermissionDenied, PortageKeyError, \
-	PortagePackageException, UnsupportedAPIException
+from portage.exception import (
+    PermissionDenied,
+    PortageKeyError,
+    PortagePackageException,
+    UnsupportedAPIException,
+)
 from portage.localization import _
 import portage.util
 from portage.util._eventloop.global_event_loop import global_event_loop
@@ -63,65 +76,73 @@ description = "See the ebuild(1) man page for more info"
 usage = "Usage: ebuild <ebuild file> <command> [command] ..."
 parser = argparse.ArgumentParser(description=description, usage=usage)
 
-force_help = "When used together with the digest or manifest " + \
-	"command, this option forces regeneration of digests for all " + \
-	"distfiles associated with the current ebuild. Any distfiles " + \
-	"that do not already exist in ${DISTDIR} will be automatically fetched."
+force_help = (
+    "When used together with the digest or manifest "
+    + "command, this option forces regeneration of digests for all "
+    + "distfiles associated with the current ebuild. Any distfiles "
+    + "that do not already exist in ${DISTDIR} will be automatically fetched."
+)
 
 parser.add_argument("--force", help=force_help, action="store_true")
-parser.add_argument("--color", help="enable or disable color output",
-	choices=("y", "n"))
-parser.add_argument("--debug", help="show debug output",
-	action="store_true")
-parser.add_argument("--version", help="show version and exit",
-	action="store_true")
-parser.add_argument("--ignore-default-opts",
-	action="store_true",
-	help="do not use the EBUILD_DEFAULT_OPTS environment variable")
-parser.add_argument("--skip-manifest", help="skip all manifest checks",
-	action="store_true")
+parser.add_argument(
+    "--color", help="enable or disable color output", choices=("y", "n")
+)
+parser.add_argument("--debug", help="show debug output", action="store_true")
+parser.add_argument("--version", help="show version and exit", action="store_true")
+parser.add_argument(
+    "--ignore-default-opts",
+    action="store_true",
+    help="do not use the EBUILD_DEFAULT_OPTS environment variable",
+)
+parser.add_argument(
+    "--skip-manifest", help="skip all manifest checks", action="store_true"
+)
 
 opts, pargs = parser.parse_known_args(args=sys.argv[1:])
 
+
 def err(txt):
-	portage.writemsg('ebuild: %s\n' % (txt,), noiselevel=-1)
-	sys.exit(1)
+    portage.writemsg("ebuild: %s\n" % (txt,), noiselevel=-1)
+    sys.exit(1)
+
 
 if opts.version:
-	print("Portage", portage.VERSION)
-	sys.exit(os.EX_OK)
+    print("Portage", portage.VERSION)
+    sys.exit(os.EX_OK)
 
 if len(pargs) < 2:
-	parser.error("missing required args")
+    parser.error("missing required args")
 
 if not opts.ignore_default_opts:
-	default_opts = portage.util.shlex_split(
-		portage.settings.get("EBUILD_DEFAULT_OPTS", ""))
-	opts, pargs = parser.parse_known_args(default_opts + sys.argv[1:])
+    default_opts = portage.util.shlex_split(
+        portage.settings.get("EBUILD_DEFAULT_OPTS", "")
+    )
+    opts, pargs = parser.parse_known_args(default_opts + sys.argv[1:])
 
 debug = opts.debug
 force = opts.force
 
 if debug:
-	# Ensure that all config instances have this setting,
-	# including the one that's used by portdbapi for aux_get.
-	os.environ['PORTAGE_DEBUG'] = '1'
-	portage._reset_legacy_globals()
+    # Ensure that all config instances have this setting,
+    # including the one that's used by portdbapi for aux_get.
+    os.environ["PORTAGE_DEBUG"] = "1"
+    portage._reset_legacy_globals()
 
 # do this _after_ 'import portage' to prevent unnecessary tracing
 if debug and "python-trace" in portage.features:
-	portage.debug.set_trace(True)
-
-if not opts.color == 'y' and \
-	(opts.color == 'n' or \
-	portage.settings.get('NOCOLOR') in ('yes', 'true') or \
-	portage.settings.get('TERM') == 'dumb' or \
-	not sys.stdout.isatty()):
-	portage.output.nocolor()
-	portage.settings.unlock()
-	portage.settings['NOCOLOR'] = 'true'
-	portage.settings.backup_changes('NOCOLOR')
-	portage.settings.lock()
+    portage.debug.set_trace(True)
+
+if not opts.color == "y" and (
+    opts.color == "n"
+    or portage.settings.get("NOCOLOR") in ("yes", "true")
+    or portage.settings.get("TERM") == "dumb"
+    or not sys.stdout.isatty()
+):
+    portage.output.nocolor()
+    portage.settings.unlock()
+    portage.settings["NOCOLOR"] = "true"
+    portage.settings.backup_changes("NOCOLOR")
+    portage.settings.lock()
 
 apply_priorities(portage.settings)
 
@@ -129,118 +150,140 @@ ebuild = pargs.pop(0)
 
 pf = None
 if ebuild.endswith(".ebuild"):
-	pf = os.path.basename(ebuild)[:-7]
+    pf = os.path.basename(ebuild)[:-7]
 
 if pf is None:
-	err("%s: does not end with '.ebuild'" % (ebuild,))
+    err("%s: does not end with '.ebuild'" % (ebuild,))
 
 if not os.path.isabs(ebuild):
-	mycwd = os.getcwd()
-	# Try to get the non-canonical path from the PWD evironment variable, since
-	# the canonical path returned from os.getcwd() may may be unusable in
-	# cases where the directory stucture is built from symlinks.
-	pwd = os.environ.get('PWD', '')
-	if pwd and pwd != mycwd and \
-		os.path.realpath(pwd) == mycwd:
-		mycwd = portage.normalize_path(pwd)
-	ebuild = os.path.join(mycwd, ebuild)
+    mycwd = os.getcwd()
+    # Try to get the non-canonical path from the PWD evironment variable, since
+    # the canonical path returned from os.getcwd() may may be unusable in
+    # cases where the directory stucture is built from symlinks.
+    pwd = os.environ.get("PWD", "")
+    if pwd and pwd != mycwd and os.path.realpath(pwd) == mycwd:
+        mycwd = portage.normalize_path(pwd)
+    ebuild = os.path.join(mycwd, ebuild)
 ebuild = portage.normalize_path(ebuild)
 # portdbapi uses the canonical path for the base of the ebuild repository, but
 # subdirectories of the base can be built from symlinks (like crossdev does).
 ebuild_portdir = os.path.realpath(
-	os.path.dirname(os.path.dirname(os.path.dirname(ebuild))))
+    os.path.dirname(os.path.dirname(os.path.dirname(ebuild)))
+)
 ebuild = os.path.join(ebuild_portdir, *ebuild.split(os.path.sep)[-3:])
-vdb_path = os.path.realpath(os.path.join(portage.settings['EROOT'], VDB_PATH))
+vdb_path = os.path.realpath(os.path.join(portage.settings["EROOT"], VDB_PATH))
 
 # Make sure that portdb.findname() returns the correct ebuild.
-if ebuild_portdir != vdb_path and \
-	ebuild_portdir not in portage.portdb.porttrees:
-	portdir_overlay = portage.settings.get("PORTDIR_OVERLAY", "")
-	os.environ["PORTDIR_OVERLAY"] = (
-		portdir_overlay + " " + _shell_quote(ebuild_portdir))
+if ebuild_portdir != vdb_path and ebuild_portdir not in portage.portdb.porttrees:
+    portdir_overlay = portage.settings.get("PORTDIR_OVERLAY", "")
+    os.environ["PORTDIR_OVERLAY"] = portdir_overlay + " " + _shell_quote(ebuild_portdir)
 
-	print("Appending %s to PORTDIR_OVERLAY..." % ebuild_portdir)
-	portage._reset_legacy_globals()
+    print("Appending %s to PORTDIR_OVERLAY..." % ebuild_portdir)
+    portage._reset_legacy_globals()
 
 myrepo = None
 if ebuild_portdir != vdb_path:
-	myrepo = portage.portdb.getRepositoryName(ebuild_portdir)
+    myrepo = portage.portdb.getRepositoryName(ebuild_portdir)
 
 if not os.path.exists(ebuild):
-	err('%s: does not exist' % (ebuild,))
+    err("%s: does not exist" % (ebuild,))
 
 ebuild_split = ebuild.split("/")
 cpv = "%s/%s" % (ebuild_split[-3], pf)
 
-with io.open(_unicode_encode(ebuild, encoding=_encodings['fs'], errors='strict'),
-	mode='r', encoding=_encodings['repo.content'], errors='replace') as f:
-	eapi = portage._parse_eapi_ebuild_head(f)[0]
+with io.open(
+    _unicode_encode(ebuild, encoding=_encodings["fs"], errors="strict"),
+    mode="r",
+    encoding=_encodings["repo.content"],
+    errors="replace",
+) as f:
+    eapi = portage._parse_eapi_ebuild_head(f)[0]
 if eapi is None:
-	eapi = "0"
+    eapi = "0"
 if not portage.catpkgsplit(cpv, eapi=eapi):
-	err('%s: %s: does not follow correct package syntax' % (ebuild, cpv))
+    err("%s: %s: does not follow correct package syntax" % (ebuild, cpv))
 
 if ebuild.startswith(vdb_path):
-	mytree = "vartree"
-	pkg_type = "installed"
+    mytree = "vartree"
+    pkg_type = "installed"
 
-	portage_ebuild = portage.db[portage.root][mytree].dbapi.findname(cpv, myrepo=myrepo)
+    portage_ebuild = portage.db[portage.root][mytree].dbapi.findname(cpv, myrepo=myrepo)
 
-	if os.path.realpath(portage_ebuild) != ebuild:
-		err('Portage seems to think that %s is at %s' % (cpv, portage_ebuild))
+    if os.path.realpath(portage_ebuild) != ebuild:
+        err("Portage seems to think that %s is at %s" % (cpv, portage_ebuild))
 
 else:
-	mytree = "porttree"
-	pkg_type = "ebuild"
+    mytree = "porttree"
+    pkg_type = "ebuild"
 
-	portage_ebuild = portage.portdb.findname(cpv, myrepo=myrepo)
+    portage_ebuild = portage.portdb.findname(cpv, myrepo=myrepo)
 
-	if not portage_ebuild or portage_ebuild != ebuild:
-		err('%s: does not seem to have a valid PORTDIR structure' % (ebuild,))
+    if not portage_ebuild or portage_ebuild != ebuild:
+        err("%s: does not seem to have a valid PORTDIR structure" % (ebuild,))
 
 if len(pargs) > 1 and "config" in pargs:
-	other_phases = set(pargs)
-	other_phases.difference_update(
-		("clean", "config", "digest", "manifest"))
-	if other_phases:
-		err('"config" must not be called with any other phase')
+    other_phases = set(pargs)
+    other_phases.difference_update(("clean", "config", "digest", "manifest"))
+    if other_phases:
+        err('"config" must not be called with any other phase')
+
 
 def discard_digests(myebuild, mysettings, mydbapi):
-	"""Discard all distfiles digests for the given ebuild.  This is useful when
-	upstream has changed the identity of the distfiles and the user would
-	otherwise have to manually remove the Manifest and files/digest-* files in
-	order to ensure correct results."""
-	try:
-		portage._doebuild_manifest_exempt_depend += 1
-		pkgdir = os.path.dirname(myebuild)
-		fetchlist_dict = portage.FetchlistDict(pkgdir, mysettings, mydbapi)
-		mf = mysettings.repositories.get_repo_for_location(
-			os.path.dirname(os.path.dirname(pkgdir)))
-		mf = mf.load_manifest(pkgdir, mysettings["DISTDIR"],
-			fetchlist_dict=fetchlist_dict)
-		mf.create(requiredDistfiles=None,
-			assumeDistHashesSometimes=True, assumeDistHashesAlways=True)
-		distfiles = fetchlist_dict[cpv]
-		for myfile in distfiles:
-			try:
-				del mf.fhashdict["DIST"][myfile]
-			except KeyError:
-				pass
-		mf.write()
-	finally:
-		portage._doebuild_manifest_exempt_depend -= 1
-
-portage.settings.validate() # generate warning messages if necessary
-
-build_dir_phases = set(["setup", "unpack", "prepare", "configure", "compile",
-	"test", "install", "package", "rpm", "merge", "qmerge"])
+    """Discard all distfiles digests for the given ebuild.  This is useful when
+    upstream has changed the identity of the distfiles and the user would
+    otherwise have to manually remove the Manifest and files/digest-* files in
+    order to ensure correct results."""
+    try:
+        portage._doebuild_manifest_exempt_depend += 1
+        pkgdir = os.path.dirname(myebuild)
+        fetchlist_dict = portage.FetchlistDict(pkgdir, mysettings, mydbapi)
+        mf = mysettings.repositories.get_repo_for_location(
+            os.path.dirname(os.path.dirname(pkgdir))
+        )
+        mf = mf.load_manifest(
+            pkgdir, mysettings["DISTDIR"], fetchlist_dict=fetchlist_dict
+        )
+        mf.create(
+            requiredDistfiles=None,
+            assumeDistHashesSometimes=True,
+            assumeDistHashesAlways=True,
+        )
+        distfiles = fetchlist_dict[cpv]
+        for myfile in distfiles:
+            try:
+                del mf.fhashdict["DIST"][myfile]
+            except KeyError:
+                pass
+        mf.write()
+    finally:
+        portage._doebuild_manifest_exempt_depend -= 1
+
+
+portage.settings.validate()  # generate warning messages if necessary
+
+build_dir_phases = set(
+    [
+        "setup",
+        "unpack",
+        "prepare",
+        "configure",
+        "compile",
+        "test",
+        "install",
+        "package",
+        "rpm",
+        "merge",
+        "qmerge",
+    ]
+)
 
 # If the current metadata is invalid then force the ebuild to be
 # sourced again even if $T/environment already exists.
 ebuild_changed = False
 if mytree == "porttree" and build_dir_phases.intersection(pargs):
-	ebuild_changed = \
-		portage.portdb._pull_valid_cache(cpv, ebuild, ebuild_portdir)[0] is None
+    ebuild_changed = (
+        portage.portdb._pull_valid_cache(cpv, ebuild, ebuild_portdir)[0] is None
+    )
 
 # Make configuration adjustments to portage.portdb.doebuild_settings,
 # in order to enforce consistency for EBUILD_FORCE_TEST support
@@ -251,35 +294,37 @@ tmpsettings["PORTAGE_VERBOSE"] = "1"
 tmpsettings.backup_changes("PORTAGE_VERBOSE")
 
 if opts.skip_manifest:
-	tmpsettings["EBUILD_SKIP_MANIFEST"] = "1"
-	tmpsettings.backup_changes("EBUILD_SKIP_MANIFEST")
+    tmpsettings["EBUILD_SKIP_MANIFEST"] = "1"
+    tmpsettings.backup_changes("EBUILD_SKIP_MANIFEST")
 
-if opts.skip_manifest or \
-	"digest" in tmpsettings.features or \
-	"digest" in pargs or \
-	"manifest" in pargs:
-	portage._doebuild_manifest_exempt_depend += 1
+if (
+    opts.skip_manifest
+    or "digest" in tmpsettings.features
+    or "digest" in pargs
+    or "manifest" in pargs
+):
+    portage._doebuild_manifest_exempt_depend += 1
 
 if "test" in pargs:
-	# This variable is a signal to config.regenerate() to
-	# indicate that the test phase should be enabled regardless
-	# of problems such as masked "test" USE flag.
-	tmpsettings["EBUILD_FORCE_TEST"] = "1"
-	tmpsettings.backup_changes("EBUILD_FORCE_TEST")
-	tmpsettings.features.add("test")
-	portage.writemsg(_("Forcing test.\n"), noiselevel=-1)
+    # This variable is a signal to config.regenerate() to
+    # indicate that the test phase should be enabled regardless
+    # of problems such as masked "test" USE flag.
+    tmpsettings["EBUILD_FORCE_TEST"] = "1"
+    tmpsettings.backup_changes("EBUILD_FORCE_TEST")
+    tmpsettings.features.add("test")
+    portage.writemsg(_("Forcing test.\n"), noiselevel=-1)
 
 tmpsettings.features.discard("fail-clean")
 
 if "merge" in pargs and "noauto" in tmpsettings.features:
-	print("Disabling noauto in features... merge disables it. (qmerge doesn't)")
-	tmpsettings.features.discard("noauto")
+    print("Disabling noauto in features... merge disables it. (qmerge doesn't)")
+    tmpsettings.features.discard("noauto")
 
-if 'digest' in tmpsettings.features:
-	if pargs and pargs[0] not in ("digest", "manifest"):
-		pargs = ['digest'] + pargs
-	# We only need to build digests on the first pass.
-	tmpsettings.features.discard('digest')
+if "digest" in tmpsettings.features:
+    if pargs and pargs[0] not in ("digest", "manifest"):
+        pargs = ["digest"] + pargs
+    # We only need to build digests on the first pass.
+    tmpsettings.features.discard("digest")
 
 # Now that configuration adjustments are complete, create a clone of
 # tmpsettings. The current instance refers to portdb.doebuild_settings,
@@ -287,25 +332,35 @@ if 'digest' in tmpsettings.features:
 tmpsettings = portage.config(clone=tmpsettings)
 
 try:
-	metadata = dict(zip(Package.metadata_keys,
-		portage.db[portage.settings['EROOT']][mytree].dbapi.aux_get(
-		cpv, Package.metadata_keys, myrepo=myrepo)))
+    metadata = dict(
+        zip(
+            Package.metadata_keys,
+            portage.db[portage.settings["EROOT"]][mytree].dbapi.aux_get(
+                cpv, Package.metadata_keys, myrepo=myrepo
+            ),
+        )
+    )
 except PortageKeyError:
-	# aux_get failure, message should have been shown on stderr.
-	sys.exit(1)
-
-root_config = RootConfig(portage.settings,
-	portage.db[portage.settings['EROOT']], None)
-
-cpv = portage.versions._pkg_str(cpv,
-	metadata=metadata,
-	settings=portage.settings,
-	db=portage.db[portage.settings['EROOT']][mytree].dbapi)
-
-pkg = Package(built=(pkg_type != "ebuild"), cpv=cpv,
-	installed=(pkg_type=="installed"),
-	metadata=metadata, root_config=root_config,
-	type_name=pkg_type)
+    # aux_get failure, message should have been shown on stderr.
+    sys.exit(1)
+
+root_config = RootConfig(portage.settings, portage.db[portage.settings["EROOT"]], None)
+
+cpv = portage.versions._pkg_str(
+    cpv,
+    metadata=metadata,
+    settings=portage.settings,
+    db=portage.db[portage.settings["EROOT"]][mytree].dbapi,
+)
+
+pkg = Package(
+    built=(pkg_type != "ebuild"),
+    cpv=cpv,
+    installed=(pkg_type == "installed"),
+    metadata=metadata,
+    root_config=root_config,
+    type_name=pkg_type,
+)
 
 # Apply package.env and repo-level settings. This allows per-package
 # FEATURES and other variables (possibly PORTAGE_TMPDIR) to be
@@ -315,63 +370,76 @@ pkg = Package(built=(pkg_type != "ebuild"), cpv=cpv,
 # portdb.porttrees in order to accomplish this).
 tmpsettings.setcpv(pkg)
 
+
 def stale_env_warning():
-	if "clean" not in pargs and \
-		"noauto" not in tmpsettings.features and \
-		build_dir_phases.intersection(pargs):
-		portage.doebuild_environment(ebuild, "setup", portage.root,
-			tmpsettings, debug, 1, portage.portdb)
-		env_filename = os.path.join(tmpsettings["T"], "environment")
-		if os.path.exists(env_filename):
-			msg = ("Existing ${T}/environment for '%s' will be sourced. " + \
-				"Run 'clean' to start with a fresh environment.") % \
-				(tmpsettings["PF"], )
-			msg = textwrap.wrap(msg, 70)
-			for x in msg:
-				portage.writemsg(">>> %s\n" % x)
-
-			if ebuild_changed:
-				open(os.path.join(tmpsettings['PORTAGE_BUILDDIR'],
-					'.ebuild_changed'), 'w').close()
+    if (
+        "clean" not in pargs
+        and "noauto" not in tmpsettings.features
+        and build_dir_phases.intersection(pargs)
+    ):
+        portage.doebuild_environment(
+            ebuild, "setup", portage.root, tmpsettings, debug, 1, portage.portdb
+        )
+        env_filename = os.path.join(tmpsettings["T"], "environment")
+        if os.path.exists(env_filename):
+            msg = (
+                "Existing ${T}/environment for '%s' will be sourced. "
+                + "Run 'clean' to start with a fresh environment."
+            ) % (tmpsettings["PF"],)
+            msg = textwrap.wrap(msg, 70)
+            for x in msg:
+                portage.writemsg(">>> %s\n" % x)
+
+            if ebuild_changed:
+                open(
+                    os.path.join(tmpsettings["PORTAGE_BUILDDIR"], ".ebuild_changed"),
+                    "w",
+                ).close()
+
 
 checked_for_stale_env = False
 
 for arg in pargs:
-	try:
-		if not checked_for_stale_env and arg not in ("digest","manifest"):
-			# This has to go after manifest generation since otherwise
-			# aux_get() might fail due to invalid ebuild digests.
-			stale_env_warning()
-			checked_for_stale_env = True
-
-		if arg in ("digest", "manifest") and force:
-			discard_digests(ebuild, tmpsettings, portage.portdb)
-		a = portage.doebuild(ebuild, arg, settings=tmpsettings,
-			debug=debug, tree=mytree,
-			vartree=portage.db[portage.root]['vartree'])
-	except KeyboardInterrupt:
-		print("Interrupted.")
-		a = 1
-	except PortageKeyError:
-		# aux_get error
-		a = 1
-	except UnsupportedAPIException as e:
-		msg = textwrap.wrap(str(e), 70)
-		del e
-		for x in msg:
-			portage.writemsg("!!! %s\n" % x, noiselevel=-1)
-		a = 1
-	except PortagePackageException as e:
-		portage.writemsg("!!! %s\n" % (e,), noiselevel=-1)
-		a = 1
-	except PermissionDenied as e:
-		portage.writemsg("!!! Permission Denied: %s\n" % (e,), noiselevel=-1)
-		a = 1
-	if a == None:
-		print("Could not run the required binary?")
-		a = 127
-	if a:
-		global_event_loop().close()
-		sys.exit(a)
+    try:
+        if not checked_for_stale_env and arg not in ("digest", "manifest"):
+            # This has to go after manifest generation since otherwise
+            # aux_get() might fail due to invalid ebuild digests.
+            stale_env_warning()
+            checked_for_stale_env = True
+
+        if arg in ("digest", "manifest") and force:
+            discard_digests(ebuild, tmpsettings, portage.portdb)
+        a = portage.doebuild(
+            ebuild,
+            arg,
+            settings=tmpsettings,
+            debug=debug,
+            tree=mytree,
+            vartree=portage.db[portage.root]["vartree"],
+        )
+    except KeyboardInterrupt:
+        print("Interrupted.")
+        a = 1
+    except PortageKeyError:
+        # aux_get error
+        a = 1
+    except UnsupportedAPIException as e:
+        msg = textwrap.wrap(str(e), 70)
+        del e
+        for x in msg:
+            portage.writemsg("!!! %s\n" % x, noiselevel=-1)
+        a = 1
+    except PortagePackageException as e:
+        portage.writemsg("!!! %s\n" % (e,), noiselevel=-1)
+        a = 1
+    except PermissionDenied as e:
+        portage.writemsg("!!! Permission Denied: %s\n" % (e,), noiselevel=-1)
+        a = 1
+    if a == None:
+        print("Could not run the required binary?")
+        a = 127
+    if a:
+        global_event_loop().close()
+        sys.exit(a)
 
 global_event_loop().close()

diff --git a/bin/egencache b/bin/egencache
index b590a5529..2b523c7b3 100755
--- a/bin/egencache
+++ b/bin/egencache
@@ -11,25 +11,28 @@ import sys
 # This block ensures that ^C interrupts are handled quietly.
 try:
 
-	def exithandler(signum, _frame):
-		signal.signal(signal.SIGINT, signal.SIG_IGN)
-		signal.signal(signal.SIGTERM, signal.SIG_IGN)
-		sys.exit(128 + signum)
+    def exithandler(signum, _frame):
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        sys.exit(128 + signum)
 
-	signal.signal(signal.SIGINT, exithandler)
-	signal.signal(signal.SIGTERM, exithandler)
+    signal.signal(signal.SIGINT, exithandler)
+    signal.signal(signal.SIGTERM, exithandler)
 
 except KeyboardInterrupt:
-	sys.exit(128 + signal.SIGINT)
+    sys.exit(128 + signal.SIGINT)
+
 
 def debug_signal(_signum, _frame):
-	import pdb
-	pdb.set_trace()
+    import pdb
+
+    pdb.set_trace()
+
 
-if platform.python_implementation() == 'Jython':
-	debug_signum = signal.SIGUSR2 # bug #424259
+if platform.python_implementation() == "Jython":
+    debug_signum = signal.SIGUSR2  # bug #424259
 else:
-	debug_signum = signal.SIGUSR1
+    debug_signum = signal.SIGUSR1
 
 signal.signal(debug_signum, debug_signal)
 
@@ -42,17 +45,28 @@ import textwrap
 import re
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os, _encodings, _unicode_encode, _unicode_decode
 from portage.cache.cache_errors import CacheError, StatCollision
-from portage.cache.index.pkg_desc_index import pkg_desc_index_line_format, pkg_desc_index_line_read
+from portage.cache.index.pkg_desc_index import (
+    pkg_desc_index_line_format,
+    pkg_desc_index_line_read,
+)
 from portage.const import TIMESTAMP_FORMAT
 from portage.dep import _repo_separator
 from portage.output import colorize, EOutput
-from portage.package.ebuild._parallel_manifest.ManifestScheduler import ManifestScheduler
+from portage.package.ebuild._parallel_manifest.ManifestScheduler import (
+    ManifestScheduler,
+)
 from portage.util import cmp_sort_key, writemsg_level
 from portage.util._async.AsyncFunction import AsyncFunction
 from portage.util._async.run_main_scheduler import run_main_scheduler
@@ -65,1125 +79,1326 @@ from portage.versions import vercmp
 from _emerge.MetadataRegen import MetadataRegen
 
 try:
-	from xml.etree import ElementTree
+    from xml.etree import ElementTree
 except ImportError:
-	pass
+    pass
 else:
-	try:
-		from xml.parsers.expat import ExpatError
-	except ImportError:
-		pass
-	else:
-		from portage.xml.metadata import parse_metadata_use # pylint: disable=ungrouped-imports
+    try:
+        from xml.parsers.expat import ExpatError
+    except ImportError:
+        pass
+    else:
+        from portage.xml.metadata import (  # pylint: disable=ungrouped-imports
+            parse_metadata_use,
+        )
 
 
 def parse_args(args):
-	usage = "egencache [options] <action> ... [atom] ..."
-	parser = argparse.ArgumentParser(usage=usage)
-
-	actions = parser.add_argument_group('Actions')
-	actions.add_argument("--update",
-		action="store_true",
-		help="update metadata/md5-cache/ (generate as necessary)")
-	actions.add_argument("--update-use-local-desc",
-		action="store_true",
-		help="update the use.local.desc file from metadata.xml")
-	actions.add_argument("--update-changelogs",
-		action="store_true",
-		help="update the ChangeLog files from SCM logs")
-	actions.add_argument("--update-pkg-desc-index",
-		action="store_true",
-		help="update package description index")
-	actions.add_argument("--update-manifests",
-		action="store_true",
-		help="update manifests")
-
-	common = parser.add_argument_group('Common options')
-	common.add_argument("--repo",
-		action="store",
-		help="name of repo to operate on")
-	common.add_argument("--config-root",
-		help="location of portage config files",
-		dest="portage_configroot")
-	common.add_argument("--external-cache-only",
-		action="store_true",
-		help="Output only to the external cache (not the repository itself)")
-	common.add_argument("--gpg-dir",
-		help="override the PORTAGE_GPG_DIR variable",
-		dest="gpg_dir")
-	common.add_argument("--gpg-key",
-		help="override the PORTAGE_GPG_KEY variable",
-		dest="gpg_key")
-	common.add_argument("--repositories-configuration",
-		help="override configuration of repositories (in format of repos.conf)",
-		dest="repositories_configuration")
-	common.add_argument("--sign-manifests",
-		choices=('y', 'n'),
-		metavar="<y|n>",
-		help="manually override layout.conf sign-manifests setting")
-	common.add_argument("--strict-manifests",
-		choices=('y', 'n'),
-		metavar="<y|n>",
-		help="manually override \"strict\" FEATURES setting")
-	common.add_argument("--thin-manifests",
-		choices=('y', 'n'),
-		metavar="<y|n>",
-		help="manually override layout.conf thin-manifests setting")
-	common.add_argument("--tolerant",
-		action="store_true",
-		help="exit successfully if only minor errors occurred")
-	common.add_argument("--ignore-default-opts",
-		action="store_true",
-		help="do not use the EGENCACHE_DEFAULT_OPTS environment variable")
-	common.add_argument("-v", "--verbose",
-		action="count", default=0,
-		help="increase verbosity")
-	common.add_argument("--write-timestamp",
-		action="store_true",
-		help="write metadata/timestamp.chk as required for rsync repositories")
-
-	update = parser.add_argument_group('--update options')
-	update.add_argument("--cache-dir",
-		help="location of the metadata cache",
-		dest="cache_dir")
-	update.add_argument("-j", "--jobs",
-		type=int,
-		action="store",
-		help="max ebuild processes to spawn")
-	update.add_argument("--load-average",
-		type=float,
-		action="store",
-		help="max load allowed when spawning multiple jobs",
-		dest="load_average")
-	update.add_argument("--rsync",
-		action="store_true",
-		help="enable rsync stat collision workaround " + \
-			"for bug 139134 (use with --update)")
-
-	uld = parser.add_argument_group('--update-use-local-desc options')
-	uld.add_argument("--preserve-comments",
-		action="store_true",
-		help="preserve the comments from the existing use.local.desc file")
-	uld.add_argument("--use-local-desc-output",
-		help="output file for use.local.desc data (or '-' for stdout)",
-		dest="uld_output")
-
-	uc = parser.add_argument_group('--update-changelogs options')
-	uc.add_argument("--changelog-reversed",
-		action="store_true",
-		help="log commits in reverse order (oldest first)")
-	uc.add_argument("--changelog-output",
-		help="output filename for change logs",
-		dest="changelog_output",
-		default="ChangeLog")
-
-	options, args = parser.parse_known_args(args)
-
-	if options.jobs:
-		jobs = None
-		try:
-			jobs = int(options.jobs)
-		except ValueError:
-			jobs = -1
-
-		if jobs < 1:
-			parser.error("Invalid: --jobs='%s'" % \
-				(options.jobs,))
-
-		options.jobs = jobs
-
-	else:
-		options.jobs = None
-
-	if options.load_average:
-		try:
-			load_average = float(options.load_average)
-		except ValueError:
-			load_average = 0.0
-
-		if load_average <= 0.0:
-			parser.error("Invalid: --load-average='%s'" % \
-				(options.load_average,))
-
-		options.load_average = load_average
-
-	else:
-		options.load_average = None
-
-	options.config_root = options.portage_configroot
-	if options.config_root is not None and \
-		not os.path.isdir(options.config_root):
-		parser.error("Not a directory: --config-root='%s'" % \
-			(options.config_root,))
-
-	if options.cache_dir is not None:
-		if not os.path.isdir(options.cache_dir):
-			parser.error("Not a directory: --cache-dir='%s'" % \
-				(options.cache_dir,))
-		if not os.access(options.cache_dir, os.W_OK):
-			parser.error("Write access denied: --cache-dir='%s'" % \
-				(options.cache_dir,))
-
-	for atom in args:
-		try:
-			atom = portage.dep.Atom(atom)
-		except portage.exception.InvalidAtom:
-			parser.error('Invalid atom: %s' % (atom,))
-
-		if not isjustname(atom):
-			parser.error('Atom is too specific: %s' % (atom,))
-
-	if options.update_use_local_desc:
-		try:
-			ElementTree
-			ExpatError
-		except NameError:
-			parser.error('--update-use-local-desc requires python with USE=xml!')
-
-	if options.uld_output == '-' and options.preserve_comments:
-		parser.error('--preserve-comments can not be used when outputting to stdout')
-
-	return parser, options, args
+    usage = "egencache [options] <action> ... [atom] ..."
+    parser = argparse.ArgumentParser(usage=usage)
+
+    actions = parser.add_argument_group("Actions")
+    actions.add_argument(
+        "--update",
+        action="store_true",
+        help="update metadata/md5-cache/ (generate as necessary)",
+    )
+    actions.add_argument(
+        "--update-use-local-desc",
+        action="store_true",
+        help="update the use.local.desc file from metadata.xml",
+    )
+    actions.add_argument(
+        "--update-changelogs",
+        action="store_true",
+        help="update the ChangeLog files from SCM logs",
+    )
+    actions.add_argument(
+        "--update-pkg-desc-index",
+        action="store_true",
+        help="update package description index",
+    )
+    actions.add_argument(
+        "--update-manifests", action="store_true", help="update manifests"
+    )
+
+    common = parser.add_argument_group("Common options")
+    common.add_argument("--repo", action="store", help="name of repo to operate on")
+    common.add_argument(
+        "--config-root",
+        help="location of portage config files",
+        dest="portage_configroot",
+    )
+    common.add_argument(
+        "--external-cache-only",
+        action="store_true",
+        help="Output only to the external cache (not the repository itself)",
+    )
+    common.add_argument(
+        "--gpg-dir", help="override the PORTAGE_GPG_DIR variable", dest="gpg_dir"
+    )
+    common.add_argument(
+        "--gpg-key", help="override the PORTAGE_GPG_KEY variable", dest="gpg_key"
+    )
+    common.add_argument(
+        "--repositories-configuration",
+        help="override configuration of repositories (in format of repos.conf)",
+        dest="repositories_configuration",
+    )
+    common.add_argument(
+        "--sign-manifests",
+        choices=("y", "n"),
+        metavar="<y|n>",
+        help="manually override layout.conf sign-manifests setting",
+    )
+    common.add_argument(
+        "--strict-manifests",
+        choices=("y", "n"),
+        metavar="<y|n>",
+        help='manually override "strict" FEATURES setting',
+    )
+    common.add_argument(
+        "--thin-manifests",
+        choices=("y", "n"),
+        metavar="<y|n>",
+        help="manually override layout.conf thin-manifests setting",
+    )
+    common.add_argument(
+        "--tolerant",
+        action="store_true",
+        help="exit successfully if only minor errors occurred",
+    )
+    common.add_argument(
+        "--ignore-default-opts",
+        action="store_true",
+        help="do not use the EGENCACHE_DEFAULT_OPTS environment variable",
+    )
+    common.add_argument(
+        "-v", "--verbose", action="count", default=0, help="increase verbosity"
+    )
+    common.add_argument(
+        "--write-timestamp",
+        action="store_true",
+        help="write metadata/timestamp.chk as required for rsync repositories",
+    )
+
+    update = parser.add_argument_group("--update options")
+    update.add_argument(
+        "--cache-dir", help="location of the metadata cache", dest="cache_dir"
+    )
+    update.add_argument(
+        "-j", "--jobs", type=int, action="store", help="max ebuild processes to spawn"
+    )
+    update.add_argument(
+        "--load-average",
+        type=float,
+        action="store",
+        help="max load allowed when spawning multiple jobs",
+        dest="load_average",
+    )
+    update.add_argument(
+        "--rsync",
+        action="store_true",
+        help="enable rsync stat collision workaround "
+        + "for bug 139134 (use with --update)",
+    )
+
+    uld = parser.add_argument_group("--update-use-local-desc options")
+    uld.add_argument(
+        "--preserve-comments",
+        action="store_true",
+        help="preserve the comments from the existing use.local.desc file",
+    )
+    uld.add_argument(
+        "--use-local-desc-output",
+        help="output file for use.local.desc data (or '-' for stdout)",
+        dest="uld_output",
+    )
+
+    uc = parser.add_argument_group("--update-changelogs options")
+    uc.add_argument(
+        "--changelog-reversed",
+        action="store_true",
+        help="log commits in reverse order (oldest first)",
+    )
+    uc.add_argument(
+        "--changelog-output",
+        help="output filename for change logs",
+        dest="changelog_output",
+        default="ChangeLog",
+    )
+
+    options, args = parser.parse_known_args(args)
+
+    if options.jobs:
+        jobs = None
+        try:
+            jobs = int(options.jobs)
+        except ValueError:
+            jobs = -1
+
+        if jobs < 1:
+            parser.error("Invalid: --jobs='%s'" % (options.jobs,))
+
+        options.jobs = jobs
+
+    else:
+        options.jobs = None
+
+    if options.load_average:
+        try:
+            load_average = float(options.load_average)
+        except ValueError:
+            load_average = 0.0
+
+        if load_average <= 0.0:
+            parser.error("Invalid: --load-average='%s'" % (options.load_average,))
+
+        options.load_average = load_average
+
+    else:
+        options.load_average = None
+
+    options.config_root = options.portage_configroot
+    if options.config_root is not None and not os.path.isdir(options.config_root):
+        parser.error("Not a directory: --config-root='%s'" % (options.config_root,))
+
+    if options.cache_dir is not None:
+        if not os.path.isdir(options.cache_dir):
+            parser.error("Not a directory: --cache-dir='%s'" % (options.cache_dir,))
+        if not os.access(options.cache_dir, os.W_OK):
+            parser.error("Write access denied: --cache-dir='%s'" % (options.cache_dir,))
+
+    for atom in args:
+        try:
+            atom = portage.dep.Atom(atom)
+        except portage.exception.InvalidAtom:
+            parser.error("Invalid atom: %s" % (atom,))
+
+        if not isjustname(atom):
+            parser.error("Atom is too specific: %s" % (atom,))
+
+    if options.update_use_local_desc:
+        try:
+            ElementTree
+            ExpatError
+        except NameError:
+            parser.error("--update-use-local-desc requires python with USE=xml!")
+
+    if options.uld_output == "-" and options.preserve_comments:
+        parser.error("--preserve-comments can not be used when outputting to stdout")
+
+    return parser, options, args
+
 
 class GenCache:
-	def __init__(self, portdb, cp_iter=None, max_jobs=None, max_load=None,
-		rsync=False, external_cache_only=False):
-		# The caller must set portdb.porttrees in order to constrain
-		# findname, cp_list, and cpv_list to the desired tree.
-		tree = portdb.porttrees[0]
-		self._portdb = portdb
-		self._eclass_db = portdb.repositories.get_repo_for_location(tree).eclass_db
-		self._auxdbkeys = portdb._known_keys
-		# We can globally cleanse stale cache only if we
-		# iterate over every single cp.
-		self._global_cleanse = cp_iter is None
-		if cp_iter is not None:
-			self._cp_set = set(cp_iter)
-			cp_iter = iter(self._cp_set)
-			self._cp_missing = self._cp_set.copy()
-		else:
-			self._cp_set = None
-			self._cp_missing = set()
-		write_auxdb = external_cache_only or "metadata-transfer" in portdb.settings.features
-		self._regen = MetadataRegen(portdb, cp_iter=cp_iter,
-			consumer=self._metadata_callback,
-			max_jobs=max_jobs, max_load=max_load,
-			write_auxdb=write_auxdb, main=True)
-		self.returncode = os.EX_OK
-		conf = portdb.repositories.get_repo_for_location(tree)
-		if external_cache_only:
-			self._trg_caches = ()
-		else:
-			self._trg_caches = tuple(conf.iter_pregenerated_caches(
-				self._auxdbkeys, force=True, readonly=False))
-			if not self._trg_caches:
-				raise Exception("cache formats '%s' aren't supported" %
-					(" ".join(conf.cache_formats),))
-
-		if rsync:
-			for trg_cache in self._trg_caches:
-				if hasattr(trg_cache, 'raise_stat_collision'):
-					trg_cache.raise_stat_collision = True
-					# Make _metadata_callback write this cache first, in case
-					# it raises a StatCollision and triggers mtime
-					# modification.
-					self._trg_caches = tuple([trg_cache] +
-						[x for x in self._trg_caches if x is not trg_cache])
-
-		self._existing_nodes = set()
-
-	def _metadata_callback(self, cpv, repo_path, metadata,
-		ebuild_hash, eapi_supported):
-		self._existing_nodes.add(cpv)
-		self._cp_missing.discard(cpv_getkey(cpv))
-
-		# Since we're supposed to be able to efficiently obtain the
-		# EAPI from _parse_eapi_ebuild_head, we don't write cache
-		# entries for unsupported EAPIs.
-		if metadata is not None and eapi_supported:
-			for trg_cache in self._trg_caches:
-				self._write_cache(trg_cache,
-					cpv, repo_path, metadata, ebuild_hash)
-
-	def _write_cache(self, trg_cache, cpv, repo_path, metadata, ebuild_hash):
-
-		if not hasattr(trg_cache, 'raise_stat_collision'):
-			# This cache does not avoid redundant writes automatically,
-			# so check for an identical existing entry before writing.
-			# This prevents unnecessary disk writes and can also prevent
-			# unnecessary rsync transfers.
-			try:
-				dest = trg_cache[cpv]
-			except (KeyError, CacheError):
-				pass
-			else:
-				if trg_cache.validate_entry(dest,
-					ebuild_hash, self._eclass_db):
-					identical = True
-					for k in self._auxdbkeys:
-						if dest.get(k, '') != metadata.get(k, ''):
-							identical = False
-							break
-					if identical:
-						return
-
-		try:
-			chf = trg_cache.validation_chf
-			metadata['_%s_' % chf] = getattr(ebuild_hash, chf)
-			try:
-				trg_cache[cpv] = metadata
-			except StatCollision as sc:
-				# If the content of a cache entry changes and neither the
-				# file mtime nor size changes, it will prevent rsync from
-				# detecting changes. Cache backends may raise this
-				# exception from _setitem() if they detect this type of stat
-				# collision. These exceptions are handled by bumping the
-				# mtime on the ebuild (and the corresponding cache entry).
-				# See bug #139134. It is convenient to include checks for
-				# redundant writes along with the internal StatCollision
-				# detection code, so for caches with the
-				# raise_stat_collision attribute, we do not need to
-				# explicitly check for redundant writes like we do for the
-				# other cache types above.
-				max_mtime = sc.mtime
-				for _ec, ec_hash in metadata['_eclasses_'].items():
-					if max_mtime < ec_hash.mtime:
-						max_mtime = ec_hash.mtime
-				if max_mtime == sc.mtime:
-					max_mtime += 1
-				max_mtime = int(max_mtime)
-				try:
-					os.utime(ebuild_hash.location, (max_mtime, max_mtime))
-				except OSError as e:
-					self.returncode |= 1
-					writemsg_level(
-						"%s writing target: %s\n" % (cpv, e),
-						level=logging.ERROR, noiselevel=-1)
-				else:
-					ebuild_hash.mtime = max_mtime
-					metadata['_mtime_'] = max_mtime
-					trg_cache[cpv] = metadata
-					self._portdb.auxdb[repo_path][cpv] = metadata
-
-		except CacheError as ce:
-			self.returncode |= 1
-			writemsg_level(
-				"%s writing target: %s\n" % (cpv, ce),
-				level=logging.ERROR, noiselevel=-1)
-
-	def run(self):
-		signum = run_main_scheduler(self._regen)
-		if signum is not None:
-			sys.exit(128 + signum)
-
-		self.returncode |= self._regen.returncode
-
-		for trg_cache in self._trg_caches:
-			self._cleanse_cache(trg_cache)
-
-	def _cleanse_cache(self, trg_cache):
-		cp_missing = self._cp_missing
-		dead_nodes = set()
-		if self._global_cleanse:
-			try:
-				for cpv in trg_cache:
-					cp = cpv_getkey(cpv)
-					if cp is None:
-						self.returncode |= 1
-						writemsg_level(
-							"Unable to parse cp for '%s'\n"  % (cpv,),
-							level=logging.ERROR, noiselevel=-1)
-					else:
-						dead_nodes.add(cpv)
-			except CacheError as ce:
-				self.returncode |= 1
-				writemsg_level(
-					"Error listing cache entries for " + \
-					"'%s': %s, continuing...\n" % \
-					(trg_cache.location, ce),
-					level=logging.ERROR, noiselevel=-1)
-
-		else:
-			cp_set = self._cp_set
-			try:
-				for cpv in trg_cache:
-					cp = cpv_getkey(cpv)
-					if cp is None:
-						self.returncode |= 1
-						writemsg_level(
-							"Unable to parse cp for '%s'\n"  % (cpv,),
-							level=logging.ERROR, noiselevel=-1)
-					else:
-						cp_missing.discard(cp)
-						if cp in cp_set:
-							dead_nodes.add(cpv)
-			except CacheError as ce:
-				self.returncode |= 1
-				writemsg_level(
-					"Error listing cache entries for " + \
-					"'%s': %s, continuing...\n" % \
-					(trg_cache.location, ce),
-					level=logging.ERROR, noiselevel=-1)
-
-		if cp_missing:
-			self.returncode |= 1
-			for cp in sorted(cp_missing):
-				writemsg_level(
-					"No ebuilds or cache entries found for '%s'\n"  % (cp,),
-					level=logging.ERROR, noiselevel=-1)
-
-		if dead_nodes:
-			dead_nodes.difference_update(self._existing_nodes)
-			for k in dead_nodes:
-				try:
-					del trg_cache[k]
-				except KeyError:
-					pass
-				except CacheError as ce:
-					self.returncode |= 1
-					writemsg_level(
-						"%s deleting stale cache: %s\n" % (k, ce),
-						level=logging.ERROR, noiselevel=-1)
-
-		if not trg_cache.autocommits:
-			try:
-				trg_cache.commit()
-			except CacheError as ce:
-				self.returncode |= 1
-				writemsg_level(
-					"committing target: %s\n" % (ce,),
-					level=logging.ERROR, noiselevel=-1)
-
-		if hasattr(trg_cache, '_prune_empty_dirs'):
-			trg_cache._prune_empty_dirs()
+    def __init__(
+        self,
+        portdb,
+        cp_iter=None,
+        max_jobs=None,
+        max_load=None,
+        rsync=False,
+        external_cache_only=False,
+    ):
+        # The caller must set portdb.porttrees in order to constrain
+        # findname, cp_list, and cpv_list to the desired tree.
+        tree = portdb.porttrees[0]
+        self._portdb = portdb
+        self._eclass_db = portdb.repositories.get_repo_for_location(tree).eclass_db
+        self._auxdbkeys = portdb._known_keys
+        # We can globally cleanse stale cache only if we
+        # iterate over every single cp.
+        self._global_cleanse = cp_iter is None
+        if cp_iter is not None:
+            self._cp_set = set(cp_iter)
+            cp_iter = iter(self._cp_set)
+            self._cp_missing = self._cp_set.copy()
+        else:
+            self._cp_set = None
+            self._cp_missing = set()
+        write_auxdb = (
+            external_cache_only or "metadata-transfer" in portdb.settings.features
+        )
+        self._regen = MetadataRegen(
+            portdb,
+            cp_iter=cp_iter,
+            consumer=self._metadata_callback,
+            max_jobs=max_jobs,
+            max_load=max_load,
+            write_auxdb=write_auxdb,
+            main=True,
+        )
+        self.returncode = os.EX_OK
+        conf = portdb.repositories.get_repo_for_location(tree)
+        if external_cache_only:
+            self._trg_caches = ()
+        else:
+            self._trg_caches = tuple(
+                conf.iter_pregenerated_caches(
+                    self._auxdbkeys, force=True, readonly=False
+                )
+            )
+            if not self._trg_caches:
+                raise Exception(
+                    "cache formats '%s' aren't supported"
+                    % (" ".join(conf.cache_formats),)
+                )
+
+        if rsync:
+            for trg_cache in self._trg_caches:
+                if hasattr(trg_cache, "raise_stat_collision"):
+                    trg_cache.raise_stat_collision = True
+                    # Make _metadata_callback write this cache first, in case
+                    # it raises a StatCollision and triggers mtime
+                    # modification.
+                    self._trg_caches = tuple(
+                        [trg_cache]
+                        + [x for x in self._trg_caches if x is not trg_cache]
+                    )
+
+        self._existing_nodes = set()
+
+    def _metadata_callback(self, cpv, repo_path, metadata, ebuild_hash, eapi_supported):
+        self._existing_nodes.add(cpv)
+        self._cp_missing.discard(cpv_getkey(cpv))
+
+        # Since we're supposed to be able to efficiently obtain the
+        # EAPI from _parse_eapi_ebuild_head, we don't write cache
+        # entries for unsupported EAPIs.
+        if metadata is not None and eapi_supported:
+            for trg_cache in self._trg_caches:
+                self._write_cache(trg_cache, cpv, repo_path, metadata, ebuild_hash)
+
+    def _write_cache(self, trg_cache, cpv, repo_path, metadata, ebuild_hash):
+
+        if not hasattr(trg_cache, "raise_stat_collision"):
+            # This cache does not avoid redundant writes automatically,
+            # so check for an identical existing entry before writing.
+            # This prevents unnecessary disk writes and can also prevent
+            # unnecessary rsync transfers.
+            try:
+                dest = trg_cache[cpv]
+            except (KeyError, CacheError):
+                pass
+            else:
+                if trg_cache.validate_entry(dest, ebuild_hash, self._eclass_db):
+                    identical = True
+                    for k in self._auxdbkeys:
+                        if dest.get(k, "") != metadata.get(k, ""):
+                            identical = False
+                            break
+                    if identical:
+                        return
+
+        try:
+            chf = trg_cache.validation_chf
+            metadata["_%s_" % chf] = getattr(ebuild_hash, chf)
+            try:
+                trg_cache[cpv] = metadata
+            except StatCollision as sc:
+                # If the content of a cache entry changes and neither the
+                # file mtime nor size changes, it will prevent rsync from
+                # detecting changes. Cache backends may raise this
+                # exception from _setitem() if they detect this type of stat
+                # collision. These exceptions are handled by bumping the
+                # mtime on the ebuild (and the corresponding cache entry).
+                # See bug #139134. It is convenient to include checks for
+                # redundant writes along with the internal StatCollision
+                # detection code, so for caches with the
+                # raise_stat_collision attribute, we do not need to
+                # explicitly check for redundant writes like we do for the
+                # other cache types above.
+                max_mtime = sc.mtime
+                for _ec, ec_hash in metadata["_eclasses_"].items():
+                    if max_mtime < ec_hash.mtime:
+                        max_mtime = ec_hash.mtime
+                if max_mtime == sc.mtime:
+                    max_mtime += 1
+                max_mtime = int(max_mtime)
+                try:
+                    os.utime(ebuild_hash.location, (max_mtime, max_mtime))
+                except OSError as e:
+                    self.returncode |= 1
+                    writemsg_level(
+                        "%s writing target: %s\n" % (cpv, e),
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+                else:
+                    ebuild_hash.mtime = max_mtime
+                    metadata["_mtime_"] = max_mtime
+                    trg_cache[cpv] = metadata
+                    self._portdb.auxdb[repo_path][cpv] = metadata
+
+        except CacheError as ce:
+            self.returncode |= 1
+            writemsg_level(
+                "%s writing target: %s\n" % (cpv, ce),
+                level=logging.ERROR,
+                noiselevel=-1,
+            )
+
+    def run(self):
+        signum = run_main_scheduler(self._regen)
+        if signum is not None:
+            sys.exit(128 + signum)
+
+        self.returncode |= self._regen.returncode
+
+        for trg_cache in self._trg_caches:
+            self._cleanse_cache(trg_cache)
+
+    def _cleanse_cache(self, trg_cache):
+        cp_missing = self._cp_missing
+        dead_nodes = set()
+        if self._global_cleanse:
+            try:
+                for cpv in trg_cache:
+                    cp = cpv_getkey(cpv)
+                    if cp is None:
+                        self.returncode |= 1
+                        writemsg_level(
+                            "Unable to parse cp for '%s'\n" % (cpv,),
+                            level=logging.ERROR,
+                            noiselevel=-1,
+                        )
+                    else:
+                        dead_nodes.add(cpv)
+            except CacheError as ce:
+                self.returncode |= 1
+                writemsg_level(
+                    "Error listing cache entries for "
+                    + "'%s': %s, continuing...\n" % (trg_cache.location, ce),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+
+        else:
+            cp_set = self._cp_set
+            try:
+                for cpv in trg_cache:
+                    cp = cpv_getkey(cpv)
+                    if cp is None:
+                        self.returncode |= 1
+                        writemsg_level(
+                            "Unable to parse cp for '%s'\n" % (cpv,),
+                            level=logging.ERROR,
+                            noiselevel=-1,
+                        )
+                    else:
+                        cp_missing.discard(cp)
+                        if cp in cp_set:
+                            dead_nodes.add(cpv)
+            except CacheError as ce:
+                self.returncode |= 1
+                writemsg_level(
+                    "Error listing cache entries for "
+                    + "'%s': %s, continuing...\n" % (trg_cache.location, ce),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+
+        if cp_missing:
+            self.returncode |= 1
+            for cp in sorted(cp_missing):
+                writemsg_level(
+                    "No ebuilds or cache entries found for '%s'\n" % (cp,),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+
+        if dead_nodes:
+            dead_nodes.difference_update(self._existing_nodes)
+            for k in dead_nodes:
+                try:
+                    del trg_cache[k]
+                except KeyError:
+                    pass
+                except CacheError as ce:
+                    self.returncode |= 1
+                    writemsg_level(
+                        "%s deleting stale cache: %s\n" % (k, ce),
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+
+        if not trg_cache.autocommits:
+            try:
+                trg_cache.commit()
+            except CacheError as ce:
+                self.returncode |= 1
+                writemsg_level(
+                    "committing target: %s\n" % (ce,),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+
+        if hasattr(trg_cache, "_prune_empty_dirs"):
+            trg_cache._prune_empty_dirs()
+
 
 class GenPkgDescIndex:
-	def __init__(self, repo_config, portdb, output_file, verbose=False):
-		self.returncode = os.EX_OK
-		self._repo_config = repo_config
-		self._portdb = portdb
-		self._output_file = output_file
-		self._verbose = verbose
-
-	def run(self):
-
-		display_updates = self._verbose > 0
-		old = {}
-		new = {}
-		if display_updates:
-			try:
-				with open(self._output_file, 'rt', encoding=_encodings["repo.content"]) as f:
-					for line in f:
-						pkg_desc = pkg_desc_index_line_read(line)
-						old[pkg_desc.cp] = pkg_desc
-			except FileNotFoundError:
-				pass
-
-		portage.util.ensure_dirs(os.path.dirname(self._output_file))
-		f = portage.util.atomic_ofstream(self._output_file,
-			encoding=_encodings["repo.content"])
-
-		portdb = self._portdb
-		for cp in portdb.cp_all():
-			pkgs = portdb.cp_list(cp)
-			if not pkgs:
-				continue
-			desc, = portdb.aux_get(pkgs[-1], ["DESCRIPTION"])
-
-			line = pkg_desc_index_line_format(cp, pkgs, desc)
-			f.write(line)
-			if display_updates:
-				new[cp] = pkg_desc_index_line_read(line)
-
-		f.close()
-
-		if display_updates:
-			out = EOutput()
-			out.einfo("Searching for changes")
-			print("")
-			items = sorted(new.values(), key=lambda pkg_desc: pkg_desc.cp)
-			haspkgs = False
-			for pkg_desc in items:
-				masked = False
-				version = self._portdb.xmatch("bestmatch-visible",
-					Atom("{}{}{}".format(pkg_desc.cp, _repo_separator, self._repo_config.name)))
-				if not version:
-					version = pkg_desc.cpv_list[-1]
-					masked = True
-				old_versions = old.get(pkg_desc.cp)
-				if old_versions is None or version not in old_versions.cpv_list:
-					prefix0 = " "
-					prefix1 = " "
-
-					if old_versions is None:
-						color = functools.partial(colorize, "darkgreen")
-						prefix1 = "N"
-					else:
-						color = functools.partial(colorize, "turquoise")
-						prefix1 = "U"
-
-					if masked:
-						prefix0 = "M"
-
-					print(" [%s%s] %s (%s):  %s" % (
-						colorize("red", prefix0),
-						color(prefix1),
-						colorize("bold", pkg_desc.cp),
-						color(version[len(pkg_desc.cp)+1:]),
-						pkg_desc.desc))
-					haspkgs = True
-
-			if not haspkgs:
-				out.einfo("No updates found")
+    def __init__(self, repo_config, portdb, output_file, verbose=False):
+        self.returncode = os.EX_OK
+        self._repo_config = repo_config
+        self._portdb = portdb
+        self._output_file = output_file
+        self._verbose = verbose
+
+    def run(self):
+
+        display_updates = self._verbose > 0
+        old = {}
+        new = {}
+        if display_updates:
+            try:
+                with open(
+                    self._output_file, "rt", encoding=_encodings["repo.content"]
+                ) as f:
+                    for line in f:
+                        pkg_desc = pkg_desc_index_line_read(line)
+                        old[pkg_desc.cp] = pkg_desc
+            except FileNotFoundError:
+                pass
+
+        portage.util.ensure_dirs(os.path.dirname(self._output_file))
+        f = portage.util.atomic_ofstream(
+            self._output_file, encoding=_encodings["repo.content"]
+        )
+
+        portdb = self._portdb
+        for cp in portdb.cp_all():
+            pkgs = portdb.cp_list(cp)
+            if not pkgs:
+                continue
+            (desc,) = portdb.aux_get(pkgs[-1], ["DESCRIPTION"])
+
+            line = pkg_desc_index_line_format(cp, pkgs, desc)
+            f.write(line)
+            if display_updates:
+                new[cp] = pkg_desc_index_line_read(line)
+
+        f.close()
+
+        if display_updates:
+            out = EOutput()
+            out.einfo("Searching for changes")
+            print("")
+            items = sorted(new.values(), key=lambda pkg_desc: pkg_desc.cp)
+            haspkgs = False
+            for pkg_desc in items:
+                masked = False
+                version = self._portdb.xmatch(
+                    "bestmatch-visible",
+                    Atom(
+                        "{}{}{}".format(
+                            pkg_desc.cp, _repo_separator, self._repo_config.name
+                        )
+                    ),
+                )
+                if not version:
+                    version = pkg_desc.cpv_list[-1]
+                    masked = True
+                old_versions = old.get(pkg_desc.cp)
+                if old_versions is None or version not in old_versions.cpv_list:
+                    prefix0 = " "
+                    prefix1 = " "
+
+                    if old_versions is None:
+                        color = functools.partial(colorize, "darkgreen")
+                        prefix1 = "N"
+                    else:
+                        color = functools.partial(colorize, "turquoise")
+                        prefix1 = "U"
+
+                    if masked:
+                        prefix0 = "M"
+
+                    print(
+                        " [%s%s] %s (%s):  %s"
+                        % (
+                            colorize("red", prefix0),
+                            color(prefix1),
+                            colorize("bold", pkg_desc.cp),
+                            color(version[len(pkg_desc.cp) + 1 :]),
+                            pkg_desc.desc,
+                        )
+                    )
+                    haspkgs = True
+
+            if not haspkgs:
+                out.einfo("No updates found")
+
 
 class GenUseLocalDesc:
-	def __init__(self, portdb, output=None,
-			preserve_comments=False):
-		self.returncode = os.EX_OK
-		self._portdb = portdb
-		self._output = output
-		self._preserve_comments = preserve_comments
-
-	def run(self):
-		repo_path = self._portdb.porttrees[0]
-		ops = {'<':0, '<=':1, '=':2, '>=':3, '>':4}
-		prev_mtime = None
-		prev_md5 = None
-
-		if self._output is None or self._output != '-':
-			if self._output is None:
-				prof_path = os.path.join(repo_path, 'profiles')
-				desc_path = os.path.join(prof_path, 'use.local.desc')
-				try:
-					os.mkdir(prof_path)
-				except OSError:
-					pass
-			else:
-				desc_path = self._output
-
-			try:
-				prev_md5 = portage.checksum.perform_md5(desc_path)
-				prev_mtime = os.stat(desc_path)[stat.ST_MTIME]
-			except (portage.exception.FileNotFound, OSError):
-				pass
-
-			try:
-				if self._preserve_comments:
-					# Probe in binary mode, in order to avoid
-					# potential character encoding issues.
-					output = open(_unicode_encode(desc_path,
-						encoding=_encodings['fs'], errors='strict'), 'r+b')
-				else:
-					output = io.open(_unicode_encode(desc_path,
-						encoding=_encodings['fs'], errors='strict'),
-						mode='w', encoding=_encodings['repo.content'],
-						errors='backslashreplace')
-			except IOError as e:
-				if not self._preserve_comments or \
-					os.path.isfile(desc_path):
-					writemsg_level(
-						"ERROR: failed to open output file %s: %s\n" \
-						% (desc_path, e), level=logging.ERROR, noiselevel=-1)
-					self.returncode |= 2
-					return
-
-				# Open in r+b mode failed because the file doesn't
-				# exist yet. We can probably recover if we disable
-				# preserve_comments mode now.
-				writemsg_level(
-					"WARNING: --preserve-comments enabled, but " + \
-					"output file not found: %s\n" % (desc_path,),
-					level=logging.WARNING, noiselevel=-1)
-				self._preserve_comments = False
-				try:
-					output = io.open(_unicode_encode(desc_path,
-						encoding=_encodings['fs'], errors='strict'),
-						mode='w', encoding=_encodings['repo.content'],
-						errors='backslashreplace')
-				except IOError as e:
-					writemsg_level(
-						"ERROR: failed to open output file %s: %s\n" \
-						% (desc_path, e), level=logging.ERROR, noiselevel=-1)
-					self.returncode |= 2
-					return
-		else:
-			output = sys.stdout
-
-		if self._preserve_comments:
-			while True:
-				pos = output.tell()
-				if not output.readline().startswith(b'#'):
-					break
-			output.seek(pos)
-			output.truncate()
-			output.close()
-
-			# Finished probing comments in binary mode, now append
-			# in text mode.
-			output = io.open(_unicode_encode(desc_path,
-				encoding=_encodings['fs'], errors='strict'),
-				mode='a', encoding=_encodings['repo.content'],
-				errors='backslashreplace')
-			output.write('\n')
-		else:
-			output.write(textwrap.dedent('''\
+    def __init__(self, portdb, output=None, preserve_comments=False):
+        self.returncode = os.EX_OK
+        self._portdb = portdb
+        self._output = output
+        self._preserve_comments = preserve_comments
+
+    def run(self):
+        repo_path = self._portdb.porttrees[0]
+        ops = {"<": 0, "<=": 1, "=": 2, ">=": 3, ">": 4}
+        prev_mtime = None
+        prev_md5 = None
+
+        if self._output is None or self._output != "-":
+            if self._output is None:
+                prof_path = os.path.join(repo_path, "profiles")
+                desc_path = os.path.join(prof_path, "use.local.desc")
+                try:
+                    os.mkdir(prof_path)
+                except OSError:
+                    pass
+            else:
+                desc_path = self._output
+
+            try:
+                prev_md5 = portage.checksum.perform_md5(desc_path)
+                prev_mtime = os.stat(desc_path)[stat.ST_MTIME]
+            except (portage.exception.FileNotFound, OSError):
+                pass
+
+            try:
+                if self._preserve_comments:
+                    # Probe in binary mode, in order to avoid
+                    # potential character encoding issues.
+                    output = open(
+                        _unicode_encode(
+                            desc_path, encoding=_encodings["fs"], errors="strict"
+                        ),
+                        "r+b",
+                    )
+                else:
+                    output = io.open(
+                        _unicode_encode(
+                            desc_path, encoding=_encodings["fs"], errors="strict"
+                        ),
+                        mode="w",
+                        encoding=_encodings["repo.content"],
+                        errors="backslashreplace",
+                    )
+            except IOError as e:
+                if not self._preserve_comments or os.path.isfile(desc_path):
+                    writemsg_level(
+                        "ERROR: failed to open output file %s: %s\n" % (desc_path, e),
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+                    self.returncode |= 2
+                    return
+
+                # Open in r+b mode failed because the file doesn't
+                # exist yet. We can probably recover if we disable
+                # preserve_comments mode now.
+                writemsg_level(
+                    "WARNING: --preserve-comments enabled, but "
+                    + "output file not found: %s\n" % (desc_path,),
+                    level=logging.WARNING,
+                    noiselevel=-1,
+                )
+                self._preserve_comments = False
+                try:
+                    output = io.open(
+                        _unicode_encode(
+                            desc_path, encoding=_encodings["fs"], errors="strict"
+                        ),
+                        mode="w",
+                        encoding=_encodings["repo.content"],
+                        errors="backslashreplace",
+                    )
+                except IOError as e:
+                    writemsg_level(
+                        "ERROR: failed to open output file %s: %s\n" % (desc_path, e),
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+                    self.returncode |= 2
+                    return
+        else:
+            output = sys.stdout
+
+        if self._preserve_comments:
+            while True:
+                pos = output.tell()
+                if not output.readline().startswith(b"#"):
+                    break
+            output.seek(pos)
+            output.truncate()
+            output.close()
+
+            # Finished probing comments in binary mode, now append
+            # in text mode.
+            output = io.open(
+                _unicode_encode(desc_path, encoding=_encodings["fs"], errors="strict"),
+                mode="a",
+                encoding=_encodings["repo.content"],
+                errors="backslashreplace",
+            )
+            output.write("\n")
+        else:
+            output.write(
+                textwrap.dedent(
+                    """\
 				# This file is deprecated as per GLEP 56 in favor of metadata.xml. Please add
 				# your descriptions to your package's metadata.xml ONLY.
 				# * generated automatically using egencache *
 
-				'''))
-
-		# The cmp function no longer exists in python3, so we'll
-		# implement our own here under a slightly different name
-		# since we don't want any confusion given that we never
-		# want to rely on the builtin cmp function.
-		def cmp_func(a, b):
-			if a is None or b is None:
-				# None can't be compared with other types in python3.
-				if a is None and b is None:
-					return 0
-				elif a is None:
-					return -1
-				else:
-					return 1
-			return (a > b) - (a < b)
-
-		class _MetadataTreeBuilder(ElementTree.TreeBuilder):
-			"""
-			Implements doctype() as required to avoid deprecation warnings
-			since Python >=2.7
-			"""
-			def doctype(self, name, pubid, system):
-				pass
-
-		for cp in self._portdb.cp_all():
-			metadata_path = os.path.join(repo_path, cp, 'metadata.xml')
-			try:
-				metadata = ElementTree.parse(_unicode_encode(metadata_path,
-					encoding=_encodings['fs'], errors='strict'),
-					parser=ElementTree.XMLParser(
-					target=_MetadataTreeBuilder()))
-			except IOError:
-				pass
-			except (ExpatError, EnvironmentError) as e:
-				writemsg_level(
-					"ERROR: failed parsing %s/metadata.xml: %s\n" % (cp, e),
-					level=logging.ERROR, noiselevel=-1)
-				self.returncode |= 1
-			else:
-				try:
-					usedict = parse_metadata_use(metadata)
-				except portage.exception.ParseError as e:
-					writemsg_level(
-						"ERROR: failed parsing %s/metadata.xml: %s\n" % (cp, e),
-						level=logging.ERROR, noiselevel=-1)
-					self.returncode |= 1
-				else:
-					for flag in sorted(usedict):
-						def atomcmp(atoma, atomb):
-							# None is better than an atom, that's why we reverse the args
-							if atoma is None or atomb is None:
-								return cmp_func(atomb, atoma)
-							# Same for plain PNs (.operator is None then)
-							elif atoma.operator is None or atomb.operator is None:
-								return cmp_func(atomb.operator, atoma.operator)
-							# Version matching
-							elif atoma.cpv != atomb.cpv:
-								return vercmp(atoma.version, atomb.version)
-							# Versions match, let's fallback to operator matching
-							else:
-								return cmp_func(ops.get(atoma.operator, -1),
-									ops.get(atomb.operator, -1))
-
-						def _Atom(key):
-							if key is not None:
-								return Atom(key)
-							return None
-
-						resdict = usedict[flag]
-						if len(resdict) == 1:
-							resdesc = next(iter(resdict.items()))[1]
-						else:
-							try:
-								reskeys = dict((_Atom(k), k) for k in resdict)
-							except portage.exception.InvalidAtom as e:
-								writemsg_level(
-									"ERROR: failed parsing %s/metadata.xml: %s\n" % (cp, e),
-									level=logging.ERROR, noiselevel=-1)
-								self.returncode |= 1
-								resdesc = next(iter(resdict.items()))[1]
-							else:
-								resatoms = sorted(reskeys, key=cmp_sort_key(atomcmp))
-								resdesc = resdict[reskeys[resatoms[-1]]]
-
-						output.write('%s:%s - %s\n' % (cp, flag, resdesc))
-
-		output.close()
-		if (prev_mtime is not None and
-			prev_md5 == portage.checksum.perform_md5(desc_path)):
-			# Preserve mtime for rsync.
-			mtime = prev_mtime
-		else:
-			# For portability, and consistency with the mtime preservation
-			# code, set mtime to an exact integer value.
-			mtime = int(time.time())
-
-		os.utime(desc_path, (mtime, mtime))
+				"""
+                )
+            )
+
+        # The cmp function no longer exists in python3, so we'll
+        # implement our own here under a slightly different name
+        # since we don't want any confusion given that we never
+        # want to rely on the builtin cmp function.
+        def cmp_func(a, b):
+            if a is None or b is None:
+                # None can't be compared with other types in python3.
+                if a is None and b is None:
+                    return 0
+                elif a is None:
+                    return -1
+                else:
+                    return 1
+            return (a > b) - (a < b)
+
+        class _MetadataTreeBuilder(ElementTree.TreeBuilder):
+            """
+            Implements doctype() as required to avoid deprecation warnings
+            since Python >=2.7
+            """
+
+            def doctype(self, name, pubid, system):
+                pass
+
+        for cp in self._portdb.cp_all():
+            metadata_path = os.path.join(repo_path, cp, "metadata.xml")
+            try:
+                metadata = ElementTree.parse(
+                    _unicode_encode(
+                        metadata_path, encoding=_encodings["fs"], errors="strict"
+                    ),
+                    parser=ElementTree.XMLParser(target=_MetadataTreeBuilder()),
+                )
+            except IOError:
+                pass
+            except (ExpatError, EnvironmentError) as e:
+                writemsg_level(
+                    "ERROR: failed parsing %s/metadata.xml: %s\n" % (cp, e),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+                self.returncode |= 1
+            else:
+                try:
+                    usedict = parse_metadata_use(metadata)
+                except portage.exception.ParseError as e:
+                    writemsg_level(
+                        "ERROR: failed parsing %s/metadata.xml: %s\n" % (cp, e),
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+                    self.returncode |= 1
+                else:
+                    for flag in sorted(usedict):
+
+                        def atomcmp(atoma, atomb):
+                            # None is better than an atom, that's why we reverse the args
+                            if atoma is None or atomb is None:
+                                return cmp_func(atomb, atoma)
+                            # Same for plain PNs (.operator is None then)
+                            elif atoma.operator is None or atomb.operator is None:
+                                return cmp_func(atomb.operator, atoma.operator)
+                            # Version matching
+                            elif atoma.cpv != atomb.cpv:
+                                return vercmp(atoma.version, atomb.version)
+                            # Versions match, let's fallback to operator matching
+                            else:
+                                return cmp_func(
+                                    ops.get(atoma.operator, -1),
+                                    ops.get(atomb.operator, -1),
+                                )
+
+                        def _Atom(key):
+                            if key is not None:
+                                return Atom(key)
+                            return None
+
+                        resdict = usedict[flag]
+                        if len(resdict) == 1:
+                            resdesc = next(iter(resdict.items()))[1]
+                        else:
+                            try:
+                                reskeys = dict((_Atom(k), k) for k in resdict)
+                            except portage.exception.InvalidAtom as e:
+                                writemsg_level(
+                                    "ERROR: failed parsing %s/metadata.xml: %s\n"
+                                    % (cp, e),
+                                    level=logging.ERROR,
+                                    noiselevel=-1,
+                                )
+                                self.returncode |= 1
+                                resdesc = next(iter(resdict.items()))[1]
+                            else:
+                                resatoms = sorted(reskeys, key=cmp_sort_key(atomcmp))
+                                resdesc = resdict[reskeys[resatoms[-1]]]
+
+                        output.write("%s:%s - %s\n" % (cp, flag, resdesc))
+
+        output.close()
+        if prev_mtime is not None and prev_md5 == portage.checksum.perform_md5(
+            desc_path
+        ):
+            # Preserve mtime for rsync.
+            mtime = prev_mtime
+        else:
+            # For portability, and consistency with the mtime preservation
+            # code, set mtime to an exact integer value.
+            mtime = int(time.time())
+
+        os.utime(desc_path, (mtime, mtime))
 
 
 class GenChangeLogs:
-	def __init__(self, portdb, changelog_output, changelog_reversed,
-		max_jobs=None, max_load=None):
-		self.returncode = os.EX_OK
-		self._portdb = portdb
-		self._wrapper = textwrap.TextWrapper(
-				width = 78,
-				initial_indent = '  ',
-				subsequent_indent = '  '
-			)
-		self._changelog_output = changelog_output
-		self._changelog_reversed = changelog_reversed
-		self._max_jobs = max_jobs
-		self._max_load = max_load
-		self._repo_path = self._portdb.porttrees[0]
-		# --work-tree=... must be passed to Git if GIT_DIR is used
-		# and GIT_DIR is not a child of the root of the checkout
-		# eg:
-		# GIT_DIR=$parent/work/.git/
-		# work-tree=$parent/staging/
-		# If work-tree is not passed, Git tries to use the shared
-		# parent of the current directory and the $GIT_DIR, which can
-		# be outside the root of the checkout.
-		self._work_tree = '--work-tree=%s' % self._repo_path
-
-	@staticmethod
-	def grab(cmd):
-		p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
-		return _unicode_decode(p.communicate()[0],
-				encoding=_encodings['stdio'], errors='strict')
-
-	def generate_changelog(self, cp):
-
-		os.chdir(os.path.join(self._repo_path, cp))
-		# Determine whether ChangeLog is up-to-date by comparing
-		# the newest commit timestamp with the ChangeLog timestamp.
-		lmod = self.grab(['git', self._work_tree, 'log', '--format=%ct', '-1', '.'])
-		if not lmod:
-			# This cp has not been added to the repo.
-			return
-
-		lmod = int(lmod)
-
-		try:
-			cmod = os.stat('ChangeLog')[stat.ST_MTIME]
-		except OSError:
-			cmod = 0
-
-		# Use exact comparison, since commit times are
-		# not necessarily ordered.
-		if cmod == lmod:
-			return
-
-		try:
-			output = io.open(self._changelog_output,
-				mode='w', encoding=_encodings['repo.content'],
-				errors='backslashreplace')
-		except IOError as e:
-			writemsg_level(
-				"ERROR: failed to open ChangeLog for %s: %s\n" % (cp,e,),
-				level=logging.ERROR, noiselevel=-1)
-			self.returncode |= 2
-			return
-
-		output.write(textwrap.dedent('''\
+    def __init__(
+        self, portdb, changelog_output, changelog_reversed, max_jobs=None, max_load=None
+    ):
+        self.returncode = os.EX_OK
+        self._portdb = portdb
+        self._wrapper = textwrap.TextWrapper(
+            width=78, initial_indent="  ", subsequent_indent="  "
+        )
+        self._changelog_output = changelog_output
+        self._changelog_reversed = changelog_reversed
+        self._max_jobs = max_jobs
+        self._max_load = max_load
+        self._repo_path = self._portdb.porttrees[0]
+        # --work-tree=... must be passed to Git if GIT_DIR is used
+        # and GIT_DIR is not a child of the root of the checkout
+        # eg:
+        # GIT_DIR=$parent/work/.git/
+        # work-tree=$parent/staging/
+        # If work-tree is not passed, Git tries to use the shared
+        # parent of the current directory and the $GIT_DIR, which can
+        # be outside the root of the checkout.
+        self._work_tree = "--work-tree=%s" % self._repo_path
+
+    @staticmethod
+    def grab(cmd):
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+        return _unicode_decode(
+            p.communicate()[0], encoding=_encodings["stdio"], errors="strict"
+        )
+
+    def generate_changelog(self, cp):
+
+        os.chdir(os.path.join(self._repo_path, cp))
+        # Determine whether ChangeLog is up-to-date by comparing
+        # the newest commit timestamp with the ChangeLog timestamp.
+        lmod = self.grab(["git", self._work_tree, "log", "--format=%ct", "-1", "."])
+        if not lmod:
+            # This cp has not been added to the repo.
+            return
+
+        lmod = int(lmod)
+
+        try:
+            cmod = os.stat("ChangeLog")[stat.ST_MTIME]
+        except OSError:
+            cmod = 0
+
+        # Use exact comparison, since commit times are
+        # not necessarily ordered.
+        if cmod == lmod:
+            return
+
+        try:
+            output = io.open(
+                self._changelog_output,
+                mode="w",
+                encoding=_encodings["repo.content"],
+                errors="backslashreplace",
+            )
+        except IOError as e:
+            writemsg_level(
+                "ERROR: failed to open ChangeLog for %s: %s\n"
+                % (
+                    cp,
+                    e,
+                ),
+                level=logging.ERROR,
+                noiselevel=-1,
+            )
+            self.returncode |= 2
+            return
+
+        output.write(
+            textwrap.dedent(
+                """\
 			# ChangeLog for %s
 			# Copyright 1999-%s Gentoo Foundation; Distributed under the GPL v2
 			# (auto-generated from git log)
 
-			''' % (cp, time.strftime('%Y'))))
-
-		# now grab all the commits
-		revlist_cmd = ['git', self._work_tree, 'rev-list']
-		if self._changelog_reversed:
-			revlist_cmd.append('--reverse')
-		revlist_cmd.extend(['HEAD', '--', '.'])
-		commits = self.grab(revlist_cmd).split()
-
-		for c in commits:
-			# Explaining the arguments:
-			# --name-status to get a list of added/removed files
-			# --no-renames to avoid getting more complex records on the list
-			# --format to get the timestamp, author and commit description
-			# --root to make it work fine even with the initial commit
-			# --relative=$cp to get paths relative to ebuilddir
-			# -r (recursive) to get per-file changes
-			# then the commit-id and path.
-
-			cinfo = self.grab(['git', self._work_tree, 'diff-tree',
-					'--name-status',
-					'--no-renames',
-					'--format=%ct %cN <%cE>%n%B',
-					'--root',
-					'--relative=%s' % (cp, ),
-					'-r',
-					c, '--', '.']).rstrip('\n').split('\n')
-
-			# Expected output:
-			# timestamp Author Name <author@email>
-			# commit message l1
-			# ...
-			# commit message ln
-			#
-			# status1	filename1
-			# ...
-			# statusn	filenamen
-
-			changed = []
-			for n, l in enumerate(reversed(cinfo)):
-				if not l:
-					body = cinfo[1:-n-1]
-					break
-				else:
-					f = l.split()
-					if f[1] == 'Manifest':
-						pass # XXX: remanifest commits?
-					elif f[1].startswith('ChangeLog'):
-						pass
-					elif f[0].startswith('A'):
-						changed.append(ChangeLogTypeSort("+", f[1]))
-					elif f[0].startswith('D'):
-						changed.append(ChangeLogTypeSort("-", f[1]))
-					elif f[0].startswith('M'):
-						changed.append(ChangeLogTypeSort("", f[1]))
-					else:
-						writemsg_level(
-							"ERROR: unexpected git file status for %s: %s\n" % (cp,f,),
-							level=logging.ERROR, noiselevel=-1)
-						self.returncode |= 1
-
-			if not changed:
-				continue
-
-			(ts, author) = cinfo[0].split(' ', 1)
-			date = time.strftime('%d %b %Y', time.gmtime(float(ts)))
-
-			changed = [str(x) for x in sorted(changed)]
-
-			wroteheader = False
-			# Reverse the sort order for headers.
-			for c in reversed(changed):
-				if c.startswith('+') and c.endswith('.ebuild'):
-					output.write('*%s (%s)\n' % (c[1:-7], date))
-					wroteheader = True
-			if wroteheader:
-				output.write('\n')
-
-			# strip '<cp>: ', '[<cp>] ', and similar
-			body[0] = re.sub(r'^\W*' + re.escape(cp) + r'\W+', '', body[0])
-			# strip trailing newline
-			if not body[-1]:
-				body = body[:-1]
-			# strip git-svn id
-			if body[-1].startswith('git-svn-id:') and not body[-2]:
-				body = body[:-2]
-			# strip the repoman version/manifest note
-			if body[-1] == ' (Signed Manifest commit)' or body[-1] == ' (Unsigned Manifest commit)':
-				body = body[:-1]
-			if body[-1].startswith('(Portage version:') and body[-1].endswith(')'):
-				body = body[:-1]
-				if not body[-1]:
-					body = body[:-1]
-
-			# don't break filenames on hyphens
-			self._wrapper.break_on_hyphens = False
-			output.write(self._wrapper.fill(
-				'%s; %s %s:' % (date, author, ', '.join(changed))))
-			# but feel free to break commit messages there
-			self._wrapper.break_on_hyphens = True
-			output.write(
-				'\n%s\n\n' % '\n'.join(self._wrapper.fill(x) for x in body))
-
-		output.close()
-		os.utime(self._changelog_output, (lmod, lmod))
-
-	def _task_iter(self):
-		if not os.path.isdir(os.environ.get('GIT_DIR', os.path.join(self._repo_path, '.git'))):
-			writemsg_level(
-				"ERROR: --update-changelogs supported only in git repos\n",
-				level=logging.ERROR, noiselevel=-1)
-			self.returncode = 127
-			return
-
-		for cp in self._portdb.cp_all():
-			yield AsyncFunction(target=self.generate_changelog, args=[cp])
-
-	def run(self):
-		return run_main_scheduler(
-			TaskScheduler(self._task_iter(), event_loop=global_event_loop(),
-				max_jobs=self._max_jobs, max_load=self._max_load))
+			"""
+                % (cp, time.strftime("%Y"))
+            )
+        )
+
+        # now grab all the commits
+        revlist_cmd = ["git", self._work_tree, "rev-list"]
+        if self._changelog_reversed:
+            revlist_cmd.append("--reverse")
+        revlist_cmd.extend(["HEAD", "--", "."])
+        commits = self.grab(revlist_cmd).split()
+
+        for c in commits:
+            # Explaining the arguments:
+            # --name-status to get a list of added/removed files
+            # --no-renames to avoid getting more complex records on the list
+            # --format to get the timestamp, author and commit description
+            # --root to make it work fine even with the initial commit
+            # --relative=$cp to get paths relative to ebuilddir
+            # -r (recursive) to get per-file changes
+            # then the commit-id and path.
+
+            cinfo = (
+                self.grab(
+                    [
+                        "git",
+                        self._work_tree,
+                        "diff-tree",
+                        "--name-status",
+                        "--no-renames",
+                        "--format=%ct %cN <%cE>%n%B",
+                        "--root",
+                        "--relative=%s" % (cp,),
+                        "-r",
+                        c,
+                        "--",
+                        ".",
+                    ]
+                )
+                .rstrip("\n")
+                .split("\n")
+            )
+
+            # Expected output:
+            # timestamp Author Name <author@email>
+            # commit message l1
+            # ...
+            # commit message ln
+            #
+            # status1	filename1
+            # ...
+            # statusn	filenamen
+
+            changed = []
+            for n, l in enumerate(reversed(cinfo)):
+                if not l:
+                    body = cinfo[1 : -n - 1]
+                    break
+                else:
+                    f = l.split()
+                    if f[1] == "Manifest":
+                        pass  # XXX: remanifest commits?
+                    elif f[1].startswith("ChangeLog"):
+                        pass
+                    elif f[0].startswith("A"):
+                        changed.append(ChangeLogTypeSort("+", f[1]))
+                    elif f[0].startswith("D"):
+                        changed.append(ChangeLogTypeSort("-", f[1]))
+                    elif f[0].startswith("M"):
+                        changed.append(ChangeLogTypeSort("", f[1]))
+                    else:
+                        writemsg_level(
+                            "ERROR: unexpected git file status for %s: %s\n"
+                            % (
+                                cp,
+                                f,
+                            ),
+                            level=logging.ERROR,
+                            noiselevel=-1,
+                        )
+                        self.returncode |= 1
+
+            if not changed:
+                continue
+
+            (ts, author) = cinfo[0].split(" ", 1)
+            date = time.strftime("%d %b %Y", time.gmtime(float(ts)))
+
+            changed = [str(x) for x in sorted(changed)]
+
+            wroteheader = False
+            # Reverse the sort order for headers.
+            for c in reversed(changed):
+                if c.startswith("+") and c.endswith(".ebuild"):
+                    output.write("*%s (%s)\n" % (c[1:-7], date))
+                    wroteheader = True
+            if wroteheader:
+                output.write("\n")
+
+            # strip '<cp>: ', '[<cp>] ', and similar
+            body[0] = re.sub(r"^\W*" + re.escape(cp) + r"\W+", "", body[0])
+            # strip trailing newline
+            if not body[-1]:
+                body = body[:-1]
+            # strip git-svn id
+            if body[-1].startswith("git-svn-id:") and not body[-2]:
+                body = body[:-2]
+            # strip the repoman version/manifest note
+            if (
+                body[-1] == " (Signed Manifest commit)"
+                or body[-1] == " (Unsigned Manifest commit)"
+            ):
+                body = body[:-1]
+            if body[-1].startswith("(Portage version:") and body[-1].endswith(")"):
+                body = body[:-1]
+                if not body[-1]:
+                    body = body[:-1]
+
+            # don't break filenames on hyphens
+            self._wrapper.break_on_hyphens = False
+            output.write(
+                self._wrapper.fill("%s; %s %s:" % (date, author, ", ".join(changed)))
+            )
+            # but feel free to break commit messages there
+            self._wrapper.break_on_hyphens = True
+            output.write("\n%s\n\n" % "\n".join(self._wrapper.fill(x) for x in body))
+
+        output.close()
+        os.utime(self._changelog_output, (lmod, lmod))
+
+    def _task_iter(self):
+        if not os.path.isdir(
+            os.environ.get("GIT_DIR", os.path.join(self._repo_path, ".git"))
+        ):
+            writemsg_level(
+                "ERROR: --update-changelogs supported only in git repos\n",
+                level=logging.ERROR,
+                noiselevel=-1,
+            )
+            self.returncode = 127
+            return
+
+        for cp in self._portdb.cp_all():
+            yield AsyncFunction(target=self.generate_changelog, args=[cp])
+
+    def run(self):
+        return run_main_scheduler(
+            TaskScheduler(
+                self._task_iter(),
+                event_loop=global_event_loop(),
+                max_jobs=self._max_jobs,
+                max_load=self._max_load,
+            )
+        )
+
 
 def egencache_main(args):
 
-	# The calling environment is ignored, so the program is
-	# completely controlled by commandline arguments.
-	env = {}
-
-	if (not sys.stdout.isatty() or
-		os.environ.get('NOCOLOR', '').lower() in ('yes', 'true')):
-		portage.output.nocolor()
-		env['NOCOLOR'] = 'true'
+    # The calling environment is ignored, so the program is
+    # completely controlled by commandline arguments.
+    env = {}
+
+    if not sys.stdout.isatty() or os.environ.get("NOCOLOR", "").lower() in (
+        "yes",
+        "true",
+    ):
+        portage.output.nocolor()
+        env["NOCOLOR"] = "true"
+
+    parser, options, atoms = parse_args(args)
+
+    config_root = options.config_root
+
+    if options.repositories_configuration is not None:
+        env["PORTAGE_REPOSITORIES"] = options.repositories_configuration
+
+    if options.cache_dir is not None:
+        env["PORTAGE_DEPCACHEDIR"] = options.cache_dir
+
+    settings = portage.config(config_root=config_root, local_config=False, env=env)
+
+    default_opts = None
+    if not options.ignore_default_opts:
+        default_opts = portage.util.shlex_split(
+            settings.get("EGENCACHE_DEFAULT_OPTS", "")
+        )
+
+    if default_opts:
+        parser, options, args = parse_args(default_opts + args)
+
+        if options.cache_dir is not None:
+            env["PORTAGE_DEPCACHEDIR"] = options.cache_dir
+
+        settings = portage.config(config_root=config_root, local_config=False, env=env)
+
+    if not (
+        options.update
+        or options.update_use_local_desc
+        or options.update_changelogs
+        or options.update_manifests
+        or options.update_pkg_desc_index
+    ):
+        parser.error("No action specified")
+        return 1
+
+    if options.repo is None:
+        if len(settings.repositories.prepos) == 2:
+            for repo in settings.repositories:
+                if repo.name != "DEFAULT":
+                    options.repo = repo.name
+                    break
+
+        if options.repo is None:
+            parser.error("--repo option is required")
+
+    repo_path = settings.repositories.treemap.get(options.repo)
+    if repo_path is None:
+        parser.error("Unable to locate repository named '%s'" % (options.repo,))
+        return 1
+
+    repo_config = settings.repositories.get_repo_for_location(repo_path)
+
+    if options.strict_manifests is not None:
+        if options.strict_manifests == "y":
+            settings.features.add("strict")
+        else:
+            settings.features.discard("strict")
+
+    if options.update and "metadata-transfer" not in settings.features:
+        # Forcibly enable metadata-transfer if portdbapi has a pregenerated
+        # cache that does not support eclass validation.
+        cache = repo_config.get_pregenerated_cache(
+            portage.dbapi.dbapi._known_keys, readonly=True
+        )
+        if cache is not None and not cache.complete_eclass_entries:
+            settings.features.add("metadata-transfer")
+        cache = None
+
+    settings.lock()
+
+    portdb = portage.portdbapi(mysettings=settings)
+
+    # Limit ebuilds to the specified repo.
+    portdb.porttrees = [repo_path]
+
+    if options.update:
+        if options.cache_dir is not None:
+            # already validated earlier
+            pass
+        else:
+            # We check write access after the portdbapi constructor
+            # has had an opportunity to create it. This ensures that
+            # we don't use the cache in the "volatile" mode which is
+            # undesirable for egencache.
+            if not os.access(settings["PORTAGE_DEPCACHEDIR"], os.W_OK):
+                writemsg_level(
+                    "ecachegen: error: "
+                    + "write access denied: %s\n" % (settings["PORTAGE_DEPCACHEDIR"],),
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+                return 1
+
+    if options.sign_manifests is not None:
+        repo_config.sign_manifest = options.sign_manifests == "y"
+
+    if options.thin_manifests is not None:
+        repo_config.thin_manifest = options.thin_manifests == "y"
+
+    gpg_cmd = None
+    gpg_vars = None
+    force_sign_key = None
+
+    if options.update_manifests:
+        if repo_config.sign_manifest:
+
+            sign_problem = False
+            gpg_dir = None
+            gpg_cmd = settings.get("PORTAGE_GPG_SIGNING_COMMAND")
+            if gpg_cmd is None:
+                writemsg_level(
+                    "egencache: error: "
+                    "PORTAGE_GPG_SIGNING_COMMAND is unset! "
+                    "Is make.globals missing?\n",
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+                sign_problem = True
+            elif (
+                "${PORTAGE_GPG_KEY}" in gpg_cmd
+                and options.gpg_key is None
+                and "PORTAGE_GPG_KEY" not in settings
+            ):
+                writemsg_level(
+                    "egencache: error: " "PORTAGE_GPG_KEY is unset!\n",
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+                sign_problem = True
+            elif "${PORTAGE_GPG_DIR}" in gpg_cmd:
+                if options.gpg_dir is not None:
+                    gpg_dir = options.gpg_dir
+                elif "PORTAGE_GPG_DIR" not in settings:
+                    gpg_dir = os.path.expanduser("~/.gnupg")
+                else:
+                    gpg_dir = os.path.expanduser(settings["PORTAGE_GPG_DIR"])
+                if not os.access(gpg_dir, os.X_OK):
+                    writemsg_level(
+                        (
+                            "egencache: error: "
+                            "Unable to access directory: "
+                            "PORTAGE_GPG_DIR='%s'\n"
+                        )
+                        % gpg_dir,
+                        level=logging.ERROR,
+                        noiselevel=-1,
+                    )
+                    sign_problem = True
+
+            if sign_problem:
+                writemsg_level(
+                    "egencache: You may disable manifest "
+                    "signatures with --sign-manifests=n or by setting "
+                    '"sign-manifests = false" in metadata/layout.conf\n',
+                    level=logging.ERROR,
+                    noiselevel=-1,
+                )
+                return 1
+
+            gpg_vars = {}
+            if gpg_dir is not None:
+                gpg_vars["PORTAGE_GPG_DIR"] = gpg_dir
+            gpg_var_names = []
+            if options.gpg_key is None:
+                gpg_var_names.append("PORTAGE_GPG_KEY")
+            else:
+                gpg_vars["PORTAGE_GPG_KEY"] = options.gpg_key
+
+            for k in gpg_var_names:
+                v = settings.get(k)
+                if v is not None:
+                    gpg_vars[k] = v
+
+            force_sign_key = gpg_vars.get("PORTAGE_GPG_KEY")
+
+    ret = [os.EX_OK]
+
+    if options.update:
+        cp_iter = None
+        if atoms:
+            cp_iter = iter(atoms)
+
+        gen_cache = GenCache(
+            portdb,
+            cp_iter=cp_iter,
+            max_jobs=options.jobs,
+            max_load=options.load_average,
+            rsync=options.rsync,
+            external_cache_only=options.external_cache_only,
+        )
+        gen_cache.run()
+        if options.tolerant:
+            ret.append(os.EX_OK)
+        else:
+            ret.append(gen_cache.returncode)
+
+    if options.update_pkg_desc_index:
+        if not options.external_cache_only and repo_config.writable:
+            writable_location = repo_config.location
+        else:
+            writable_location = os.path.join(
+                portdb.depcachedir, repo_config.location.lstrip(os.sep)
+            )
+            if not options.external_cache_only:
+                msg = [
+                    "WARNING: Repository is not writable: %s" % (repo_config.location,),
+                    "         Using cache directory instead: %s" % (writable_location,),
+                ]
+                msg = "".join(line + "\n" for line in msg)
+                writemsg_level(msg, level=logging.WARNING, noiselevel=-1)
+
+        gen_index = GenPkgDescIndex(
+            repo_config,
+            portdb,
+            os.path.join(writable_location, "metadata", "pkg_desc_index"),
+            verbose=options.verbose,
+        )
+        gen_index.run()
+        ret.append(gen_index.returncode)
+
+    if options.update_use_local_desc:
+        gen_desc = GenUseLocalDesc(
+            portdb,
+            output=options.uld_output,
+            preserve_comments=options.preserve_comments,
+        )
+        gen_desc.run()
+        ret.append(gen_desc.returncode)
+
+    if options.update_changelogs:
+        gen_clogs = GenChangeLogs(
+            portdb,
+            changelog_output=options.changelog_output,
+            changelog_reversed=options.changelog_reversed,
+            max_jobs=options.jobs,
+            max_load=options.load_average,
+        )
+        signum = gen_clogs.run()
+        if signum is not None:
+            sys.exit(128 + signum)
+        ret.append(gen_clogs.returncode)
+
+    if options.update_manifests:
+
+        cp_iter = None
+        if atoms:
+            cp_iter = iter(atoms)
+
+        event_loop = global_event_loop()
+        scheduler = ManifestScheduler(
+            portdb,
+            cp_iter=cp_iter,
+            gpg_cmd=gpg_cmd,
+            gpg_vars=gpg_vars,
+            force_sign_key=force_sign_key,
+            max_jobs=options.jobs,
+            max_load=options.load_average,
+            event_loop=event_loop,
+        )
+
+        signum = run_main_scheduler(scheduler)
+        if signum is not None:
+            sys.exit(128 + signum)
+
+        if options.tolerant:
+            ret.append(os.EX_OK)
+        else:
+            ret.append(scheduler.returncode)
+
+    if options.write_timestamp:
+        timestamp_path = os.path.join(repo_path, "metadata", "timestamp.chk")
+        try:
+            portage.util.write_atomic(
+                timestamp_path, time.strftime("%s\n" % TIMESTAMP_FORMAT, time.gmtime())
+            )
+        except (EnvironmentError, portage.exception.PortageException):
+            ret.append(os.EX_IOERR)
+        else:
+            ret.append(os.EX_OK)
+
+    return max(ret)
 
-	parser, options, atoms = parse_args(args)
-
-	config_root = options.config_root
-
-	if options.repositories_configuration is not None:
-		env['PORTAGE_REPOSITORIES'] = options.repositories_configuration
-
-	if options.cache_dir is not None:
-		env['PORTAGE_DEPCACHEDIR'] = options.cache_dir
-
-	settings = portage.config(config_root=config_root,
-		local_config=False, env=env)
-
-	default_opts = None
-	if not options.ignore_default_opts:
-		default_opts = portage.util.shlex_split(
-			settings.get('EGENCACHE_DEFAULT_OPTS', ''))
-
-	if default_opts:
-		parser, options, args = parse_args(default_opts + args)
-
-		if options.cache_dir is not None:
-			env['PORTAGE_DEPCACHEDIR'] = options.cache_dir
-
-		settings = portage.config(config_root=config_root,
-			local_config=False, env=env)
-
-	if not (options.update or options.update_use_local_desc or
-			options.update_changelogs or options.update_manifests or
-			options.update_pkg_desc_index):
-		parser.error('No action specified')
-		return 1
-
-	if options.repo is None:
-		if len(settings.repositories.prepos) == 2:
-			for repo in settings.repositories:
-				if repo.name != "DEFAULT":
-					options.repo = repo.name
-					break
-
-		if options.repo is None:
-			parser.error("--repo option is required")
-
-	repo_path = settings.repositories.treemap.get(options.repo)
-	if repo_path is None:
-		parser.error("Unable to locate repository named '%s'" % (options.repo,))
-		return 1
-
-	repo_config = settings.repositories.get_repo_for_location(repo_path)
-
-	if options.strict_manifests is not None:
-		if options.strict_manifests == "y":
-			settings.features.add("strict")
-		else:
-			settings.features.discard("strict")
-
-	if options.update and 'metadata-transfer' not in settings.features:
-		# Forcibly enable metadata-transfer if portdbapi has a pregenerated
-		# cache that does not support eclass validation.
-		cache = repo_config.get_pregenerated_cache(
-			portage.dbapi.dbapi._known_keys, readonly=True)
-		if cache is not None and not cache.complete_eclass_entries:
-			settings.features.add('metadata-transfer')
-		cache = None
-
-	settings.lock()
-
-	portdb = portage.portdbapi(mysettings=settings)
-
-	# Limit ebuilds to the specified repo.
-	portdb.porttrees = [repo_path]
-
-	if options.update:
-		if options.cache_dir is not None:
-			# already validated earlier
-			pass
-		else:
-			# We check write access after the portdbapi constructor
-			# has had an opportunity to create it. This ensures that
-			# we don't use the cache in the "volatile" mode which is
-			# undesirable for egencache.
-			if not os.access(settings["PORTAGE_DEPCACHEDIR"], os.W_OK):
-				writemsg_level("ecachegen: error: " + \
-					"write access denied: %s\n" % (settings["PORTAGE_DEPCACHEDIR"],),
-					level=logging.ERROR, noiselevel=-1)
-				return 1
-
-	if options.sign_manifests is not None:
-		repo_config.sign_manifest = options.sign_manifests == 'y'
-
-	if options.thin_manifests is not None:
-		repo_config.thin_manifest = options.thin_manifests == 'y'
-
-	gpg_cmd = None
-	gpg_vars = None
-	force_sign_key = None
-
-	if options.update_manifests:
-		if repo_config.sign_manifest:
-
-			sign_problem = False
-			gpg_dir = None
-			gpg_cmd = settings.get("PORTAGE_GPG_SIGNING_COMMAND")
-			if gpg_cmd is None:
-				writemsg_level("egencache: error: "
-					"PORTAGE_GPG_SIGNING_COMMAND is unset! "
-					"Is make.globals missing?\n",
-					level=logging.ERROR, noiselevel=-1)
-				sign_problem = True
-			elif "${PORTAGE_GPG_KEY}" in gpg_cmd and \
-				options.gpg_key is None and \
-				"PORTAGE_GPG_KEY" not in settings:
-				writemsg_level("egencache: error: "
-					"PORTAGE_GPG_KEY is unset!\n",
-					level=logging.ERROR, noiselevel=-1)
-				sign_problem = True
-			elif "${PORTAGE_GPG_DIR}" in gpg_cmd:
-				if options.gpg_dir is not None:
-					gpg_dir = options.gpg_dir
-				elif "PORTAGE_GPG_DIR" not in settings:
-					gpg_dir = os.path.expanduser("~/.gnupg")
-				else:
-					gpg_dir = os.path.expanduser(settings["PORTAGE_GPG_DIR"])
-				if not os.access(gpg_dir, os.X_OK):
-					writemsg_level(("egencache: error: "
-						"Unable to access directory: "
-						"PORTAGE_GPG_DIR='%s'\n") % gpg_dir,
-						level=logging.ERROR, noiselevel=-1)
-					sign_problem = True
-
-			if sign_problem:
-				writemsg_level("egencache: You may disable manifest "
-					"signatures with --sign-manifests=n or by setting "
-					"\"sign-manifests = false\" in metadata/layout.conf\n",
-					level=logging.ERROR, noiselevel=-1)
-				return 1
-
-			gpg_vars = {}
-			if gpg_dir is not None:
-				gpg_vars["PORTAGE_GPG_DIR"] = gpg_dir
-			gpg_var_names = []
-			if options.gpg_key is None:
-				gpg_var_names.append("PORTAGE_GPG_KEY")
-			else:
-				gpg_vars["PORTAGE_GPG_KEY"] = options.gpg_key
-
-			for k in gpg_var_names:
-				v = settings.get(k)
-				if v is not None:
-					gpg_vars[k] = v
-
-			force_sign_key = gpg_vars.get("PORTAGE_GPG_KEY")
-
-	ret = [os.EX_OK]
-
-	if options.update:
-		cp_iter = None
-		if atoms:
-			cp_iter = iter(atoms)
-
-		gen_cache = GenCache(portdb, cp_iter=cp_iter,
-			max_jobs=options.jobs,
-			max_load=options.load_average,
-			rsync=options.rsync,
-			external_cache_only=options.external_cache_only)
-		gen_cache.run()
-		if options.tolerant:
-			ret.append(os.EX_OK)
-		else:
-			ret.append(gen_cache.returncode)
-
-	if options.update_pkg_desc_index:
-		if not options.external_cache_only and repo_config.writable:
-			writable_location = repo_config.location
-		else:
-			writable_location = os.path.join(portdb.depcachedir,
-				repo_config.location.lstrip(os.sep))
-			if not options.external_cache_only:
-				msg = [
-					"WARNING: Repository is not writable: %s" % (
-					repo_config.location,),
-					"         Using cache directory instead: %s" % (
-					writable_location,)
-				]
-				msg = "".join(line + '\n' for line in msg)
-				writemsg_level(msg,
-					level=logging.WARNING, noiselevel=-1)
-
-		gen_index = GenPkgDescIndex(repo_config, portdb, os.path.join(
-			writable_location, "metadata", "pkg_desc_index"),
-			verbose=options.verbose)
-		gen_index.run()
-		ret.append(gen_index.returncode)
-
-	if options.update_use_local_desc:
-		gen_desc = GenUseLocalDesc(portdb,
-			output=options.uld_output,
-			preserve_comments=options.preserve_comments)
-		gen_desc.run()
-		ret.append(gen_desc.returncode)
-
-	if options.update_changelogs:
-		gen_clogs = GenChangeLogs(portdb,
-			changelog_output=options.changelog_output,
-			changelog_reversed=options.changelog_reversed,
-			max_jobs=options.jobs,
-			max_load=options.load_average)
-		signum = gen_clogs.run()
-		if signum is not None:
-			sys.exit(128 + signum)
-		ret.append(gen_clogs.returncode)
-
-	if options.update_manifests:
-
-		cp_iter = None
-		if atoms:
-			cp_iter = iter(atoms)
-
-		event_loop = global_event_loop()
-		scheduler = ManifestScheduler(portdb, cp_iter=cp_iter,
-			gpg_cmd=gpg_cmd, gpg_vars=gpg_vars,
-			force_sign_key=force_sign_key,
-			max_jobs=options.jobs,
-			max_load=options.load_average,
-			event_loop=event_loop)
-
-		signum = run_main_scheduler(scheduler)
-		if signum is not None:
-			sys.exit(128 + signum)
-
-		if options.tolerant:
-			ret.append(os.EX_OK)
-		else:
-			ret.append(scheduler.returncode)
-
-	if options.write_timestamp:
-		timestamp_path = os.path.join(repo_path, 'metadata', 'timestamp.chk')
-		try:
-			portage.util.write_atomic(timestamp_path,
-				time.strftime('%s\n' % TIMESTAMP_FORMAT, time.gmtime()))
-		except (EnvironmentError, portage.exception.PortageException):
-			ret.append(os.EX_IOERR)
-		else:
-			ret.append(os.EX_OK)
-
-	return max(ret)
 
 if __name__ == "__main__":
-	portage._disable_legacy_globals()
-	portage.util.noiselimit = -1
-	try:
-		sys.exit(egencache_main(sys.argv[1:]))
-	finally:
-		global_event_loop().close()
+    portage._disable_legacy_globals()
+    portage.util.noiselimit = -1
+    try:
+        sys.exit(egencache_main(sys.argv[1:]))
+    finally:
+        global_event_loop().close()

diff --git a/bin/emaint b/bin/emaint
index feef8d7e8..bd7b9083c 100755
--- a/bin/emaint
+++ b/bin/emaint
@@ -7,37 +7,44 @@
 
 import sys
 import errno
+
 # This block ensures that ^C interrupts are handled quietly.
 try:
-	import signal
+    import signal
 
-	def exithandler(signum, _frame):
-		signal.signal(signal.SIGINT, signal.SIG_IGN)
-		signal.signal(signal.SIGTERM, signal.SIG_IGN)
-		sys.exit(128 + signum)
+    def exithandler(signum, _frame):
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        sys.exit(128 + signum)
 
-	signal.signal(signal.SIGINT, exithandler)
-	signal.signal(signal.SIGTERM, exithandler)
-	signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    signal.signal(signal.SIGINT, exithandler)
+    signal.signal(signal.SIGTERM, exithandler)
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
 except KeyboardInterrupt:
-	sys.exit(1)
+    sys.exit(1)
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage.emaint.main import emaint_main
 from portage.util._eventloop.global_event_loop import global_event_loop
 
 try:
-	emaint_main(sys.argv[1:])
+    emaint_main(sys.argv[1:])
 except IOError as e:
-	if e.errno == errno.EACCES:
-		print("\nemaint: Need superuser access")
-		sys.exit(1)
-	else:
-		raise
+    if e.errno == errno.EACCES:
+        print("\nemaint: Need superuser access")
+        sys.exit(1)
+    else:
+        raise
 finally:
-	global_event_loop().close()
+    global_event_loop().close()

diff --git a/bin/emerge b/bin/emerge
index 33ece427c..a407b9d6c 100755
--- a/bin/emerge
+++ b/bin/emerge
@@ -14,71 +14,81 @@ import sys
 global_event_loop = None
 try:
 
-	def exithandler(signum, _frame):
-		signal.signal(signal.SIGTERM, signal.SIG_IGN)
-		sys.exit(128 + signum)
+    def exithandler(signum, _frame):
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        sys.exit(128 + signum)
 
-	signal.signal(signal.SIGTERM, exithandler)
-	# Prevent "[Errno 32] Broken pipe" exceptions when
-	# writing to a pipe.
-	signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+    signal.signal(signal.SIGTERM, exithandler)
+    # Prevent "[Errno 32] Broken pipe" exceptions when
+    # writing to a pipe.
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
-	def debug_signal(_signum, _frame):
-		import pdb
-		pdb.set_trace()
+    def debug_signal(_signum, _frame):
+        import pdb
 
-	if platform.python_implementation() == 'Jython':
-		debug_signum = signal.SIGUSR2 # bug #424259
-	else:
-		debug_signum = signal.SIGUSR1
+        pdb.set_trace()
 
-	signal.signal(debug_signum, debug_signal)
+    if platform.python_implementation() == "Jython":
+        debug_signum = signal.SIGUSR2  # bug #424259
+    else:
+        debug_signum = signal.SIGUSR1
 
-	from os import path as osp
-	if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-		sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
-	import portage
-	portage._internal_caller = True
-	portage._disable_legacy_globals()
-	from portage.elog import mod_echo
-	from portage.exception import IsADirectory, ParseError, PermissionDenied
-	from portage.util._eventloop.global_event_loop import global_event_loop
-	from _emerge.main import emerge_main
+    signal.signal(debug_signum, debug_signal)
 
-	if __name__ == "__main__":
-		portage.process.sanitize_fds()
-		try:
-			retval = emerge_main()
-		except PermissionDenied as e:
-			sys.stderr.write("Permission denied: '%s'\n" % str(e))
-			sys.exit(e.errno)
-		except IsADirectory as e:
-			sys.stderr.write("'%s' is a directory, but should be a file!\n"
-					"See portage man page for information on "
-					"which files may be directories.\n" %
-					str(e))
-			sys.exit(e.errno)
-		except ParseError as e:
-			sys.stderr.write("%s\n" % str(e))
-			sys.exit(1)
-		except (KeyboardInterrupt, SystemExit):
-			raise
-		except Exception:
-			# If an unexpected exception occurs then we don't want the
-			# mod_echo output to obscure the traceback, so dump the
-			# mod_echo output before showing the traceback.
-			import traceback
-			tb_str = traceback.format_exc()
-			mod_echo.finalize()
-			sys.stderr.write(tb_str)
-			sys.exit(1)
-		sys.exit(retval)
+    from os import path as osp
+
+    if osp.isfile(
+        osp.join(
+            osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed"
+        )
+    ):
+        sys.path.insert(
+            0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+        )
+    import portage
+
+    portage._internal_caller = True
+    portage._disable_legacy_globals()
+    from portage.elog import mod_echo
+    from portage.exception import IsADirectory, ParseError, PermissionDenied
+    from portage.util._eventloop.global_event_loop import global_event_loop
+    from _emerge.main import emerge_main
+
+    if __name__ == "__main__":
+        portage.process.sanitize_fds()
+        try:
+            retval = emerge_main()
+        except PermissionDenied as e:
+            sys.stderr.write("Permission denied: '%s'\n" % str(e))
+            sys.exit(e.errno)
+        except IsADirectory as e:
+            sys.stderr.write(
+                "'%s' is a directory, but should be a file!\n"
+                "See portage man page for information on "
+                "which files may be directories.\n" % str(e)
+            )
+            sys.exit(e.errno)
+        except ParseError as e:
+            sys.stderr.write("%s\n" % str(e))
+            sys.exit(1)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            # If an unexpected exception occurs then we don't want the
+            # mod_echo output to obscure the traceback, so dump the
+            # mod_echo output before showing the traceback.
+            import traceback
+
+            tb_str = traceback.format_exc()
+            mod_echo.finalize()
+            sys.stderr.write(tb_str)
+            sys.exit(1)
+        sys.exit(retval)
 
 except KeyboardInterrupt:
-	sys.stderr.write("\n\nExiting on signal %(signal)s\n" %
-		{"signal": signal.SIGINT})
-	sys.stderr.flush()
-	sys.exit(128 + signal.SIGINT)
+    sys.stderr.write("\n\nExiting on signal %(signal)s\n" % {"signal": signal.SIGINT})
+    sys.stderr.flush()
+    sys.exit(128 + signal.SIGINT)
 finally:
-	if global_event_loop is not None:
-		global_event_loop().close()
+    if global_event_loop is not None:
+        global_event_loop().close()

diff --git a/bin/emirrordist b/bin/emirrordist
index 626a055e7..35060213f 100755
--- a/bin/emirrordist
+++ b/bin/emirrordist
@@ -6,6 +6,7 @@ import signal
 import sys
 
 import portage
+
 portage._internal_caller = True
 portage._disable_legacy_globals()
 from portage._emirrordist.main import emirrordist_main
@@ -13,13 +14,14 @@ from portage.util._eventloop.global_event_loop import global_event_loop
 
 if __name__ == "__main__":
 
-	def debug_signal(_signum, _frame):
-		import pdb
-		pdb.set_trace()
+    def debug_signal(_signum, _frame):
+        import pdb
+
+        pdb.set_trace()
 
-	signal.signal(signal.SIGUSR1, debug_signal)
+    signal.signal(signal.SIGUSR1, debug_signal)
 
-	try:
-		sys.exit(emirrordist_main(sys.argv[1:]))
-	finally:
-		global_event_loop().close()
+    try:
+        sys.exit(emirrordist_main(sys.argv[1:]))
+    finally:
+        global_event_loop().close()

diff --git a/bin/env-update b/bin/env-update
index f3851afaf..c0de199e6 100755
--- a/bin/env-update
+++ b/bin/env-update
@@ -5,35 +5,43 @@
 import errno
 import sys
 
+
 def usage(status):
-	print("Usage: env-update [--no-ldconfig]")
-	print("")
-	print("See the env-update(1) man page for more info")
-	sys.exit(status)
+    print("Usage: env-update [--no-ldconfig]")
+    print("")
+    print("See the env-update(1) man page for more info")
+    sys.exit(status)
+
 
 if "-h" in sys.argv or "--help" in sys.argv:
-	usage(0)
+    usage(0)
 
-makelinks=1
+makelinks = 1
 if "--no-ldconfig" in sys.argv:
-	makelinks=0
-	sys.argv.pop(sys.argv.index("--no-ldconfig"))
+    makelinks = 0
+    sys.argv.pop(sys.argv.index("--no-ldconfig"))
 
 if len(sys.argv) > 1:
-	print("!!! Invalid command line options!\n")
-	usage(1)
+    print("!!! Invalid command line options!\n")
+    usage(1)
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 
 try:
-	portage.env_update(makelinks)
+    portage.env_update(makelinks)
 except IOError as e:
-	if e.errno == errno.EACCES:
-		print("env-update: Need superuser access")
-		sys.exit(1)
-	else:
-		raise
+    if e.errno == errno.EACCES:
+        print("env-update: Need superuser access")
+        sys.exit(1)
+    else:
+        raise

diff --git a/bin/fixpackages b/bin/fixpackages
index eab4b3959..34aaa786e 100755
--- a/bin/fixpackages
+++ b/bin/fixpackages
@@ -7,14 +7,21 @@ import os
 import sys
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage.output import EOutput
 from textwrap import wrap
 from portage._global_updates import _global_updates
+
 mysettings = portage.settings
 mytrees = portage.db
 mtimedb = portage.mtimedb
@@ -26,22 +33,25 @@ description = " ".join(description.split())
 parser = argparse.ArgumentParser(description=description)
 parser.parse_args()
 
-if mysettings['ROOT'] != "/":
-	out = EOutput()
-	msg = "The fixpackages program is not intended for use with " + \
-		"ROOT != \"/\". Instead use `emaint --fix movebin` and/or " + \
-		"`emaint --fix moveinst."
-	for line in wrap(msg, 72):
-		out.eerror(line)
-	sys.exit(1)
+if mysettings["ROOT"] != "/":
+    out = EOutput()
+    msg = (
+        "The fixpackages program is not intended for use with "
+        + 'ROOT != "/". Instead use `emaint --fix movebin` and/or '
+        + "`emaint --fix moveinst."
+    )
+    for line in wrap(msg, 72):
+        out.eerror(line)
+    sys.exit(1)
 
 try:
-	os.nice(int(mysettings.get("PORTAGE_NICENESS", "0")))
+    os.nice(int(mysettings.get("PORTAGE_NICENESS", "0")))
 except (OSError, ValueError) as e:
-	portage.writemsg("!!! Failed to change nice value to '%s'\n" % \
-		mysettings["PORTAGE_NICENESS"])
-	portage.writemsg("!!! %s\n" % str(e))
-	del e
+    portage.writemsg(
+        "!!! Failed to change nice value to '%s'\n" % mysettings["PORTAGE_NICENESS"]
+    )
+    portage.writemsg("!!! %s\n" % str(e))
+    del e
 
 _global_updates(mytrees, mtimedb["updates"], if_mtime_changed=False)
 

diff --git a/bin/glsa-check b/bin/glsa-check
index 165123fd0..93d9efe18 100755
--- a/bin/glsa-check
+++ b/bin/glsa-check
@@ -10,9 +10,15 @@ from functools import reduce
 import operator
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage.glsa import match
@@ -23,62 +29,123 @@ __author__ = "Marius Mauch <genone@g.o>"
 __version__ = "1.0.1"
 
 # option parsing
-epilog = "glsa-list can contain an arbitrary number of GLSA ids," \
-		" filenames containing GLSAs or the special identifiers" \
-		" 'all' and 'affected'"
-parser = argparse.ArgumentParser(usage=__program__ + " <option> [glsa-id | all | new | affected]",
-	epilog=epilog)
+epilog = (
+    "glsa-list can contain an arbitrary number of GLSA ids,"
+    " filenames containing GLSAs or the special identifiers"
+    " 'all' and 'affected'"
+)
+parser = argparse.ArgumentParser(
+    usage=__program__ + " <option> [glsa-id | all | new | affected]", epilog=epilog
+)
 
 modes = parser.add_argument_group("Modes")
-modes.add_argument("-l", "--list", action="store_const",
-		const="list", dest="mode",
-		help="List a summary for the given GLSA(s) or set and whether they affect the system")
-modes.add_argument("-d", "--dump", action="store_const",
-		const="dump", dest="mode",
-		help="Show all information about the GLSA(s) or set")
-modes.add_argument("--print", action="store_const",
-		const="dump", dest="mode",
-		help="Alias for --dump")
-modes.add_argument("-t", "--test", action="store_const",
-		const="test", dest="mode",
-		help="Test if this system is affected by the GLSA(s) or set and output the GLSA ID(s)")
-modes.add_argument("-p", "--pretend", action="store_const",
-		const="pretend", dest="mode",
-		help="Show the necessary steps to remediate the system")
-modes.add_argument("-f", "--fix", action="store_const",
-		const="fix", dest="mode",
-		help="(experimental) Attempt to remediate the system based on the instructions given in the GLSA(s) or set. This will only upgrade (when an upgrade path exists) or remove packages")
-modes.add_argument("-i", "--inject", action="store_const",
-		const="inject", dest="mode",
-		help="Inject the given GLSA(s) into the glsa_injected file")
-modes.add_argument("-m", "--mail", action="store_const",
-		const="mail", dest="mode",
-		help="Send a mail with the given GLSAs to the administrator")
-parser.add_argument("-V", "--version", action="store_true",
-		help="Show information about glsa-check")
-parser.add_argument("-q", "--quiet", action="store_true", dest="quiet",
-		help="Be less verbose and do not send empty mail")
-parser.add_argument("-v", "--verbose", action="store_true", dest="verbose",
-		help="Print more messages")
-parser.add_argument("-n", "--nocolor", action="store_true",
-		help="Removes color from output")
-parser.add_argument("-e", "--emergelike", action="store_false", dest="least_change",
-		help="Upgrade to latest version (not least-change)")
-parser.add_argument("-c", "--cve", action="store_true", dest="list_cve",
-		help="Show CVE IDs in listing mode")
-parser.add_argument("-r", "--reverse", action="store_true", dest="reverse",
-		help="List GLSAs in reverse order")
+modes.add_argument(
+    "-l",
+    "--list",
+    action="store_const",
+    const="list",
+    dest="mode",
+    help="List a summary for the given GLSA(s) or set and whether they affect the system",
+)
+modes.add_argument(
+    "-d",
+    "--dump",
+    action="store_const",
+    const="dump",
+    dest="mode",
+    help="Show all information about the GLSA(s) or set",
+)
+modes.add_argument(
+    "--print", action="store_const", const="dump", dest="mode", help="Alias for --dump"
+)
+modes.add_argument(
+    "-t",
+    "--test",
+    action="store_const",
+    const="test",
+    dest="mode",
+    help="Test if this system is affected by the GLSA(s) or set and output the GLSA ID(s)",
+)
+modes.add_argument(
+    "-p",
+    "--pretend",
+    action="store_const",
+    const="pretend",
+    dest="mode",
+    help="Show the necessary steps to remediate the system",
+)
+modes.add_argument(
+    "-f",
+    "--fix",
+    action="store_const",
+    const="fix",
+    dest="mode",
+    help="(experimental) Attempt to remediate the system based on the instructions given in the GLSA(s) or set. This will only upgrade (when an upgrade path exists) or remove packages",
+)
+modes.add_argument(
+    "-i",
+    "--inject",
+    action="store_const",
+    const="inject",
+    dest="mode",
+    help="Inject the given GLSA(s) into the glsa_injected file",
+)
+modes.add_argument(
+    "-m",
+    "--mail",
+    action="store_const",
+    const="mail",
+    dest="mode",
+    help="Send a mail with the given GLSAs to the administrator",
+)
+parser.add_argument(
+    "-V", "--version", action="store_true", help="Show information about glsa-check"
+)
+parser.add_argument(
+    "-q",
+    "--quiet",
+    action="store_true",
+    dest="quiet",
+    help="Be less verbose and do not send empty mail",
+)
+parser.add_argument(
+    "-v", "--verbose", action="store_true", dest="verbose", help="Print more messages"
+)
+parser.add_argument(
+    "-n", "--nocolor", action="store_true", help="Removes color from output"
+)
+parser.add_argument(
+    "-e",
+    "--emergelike",
+    action="store_false",
+    dest="least_change",
+    help="Upgrade to latest version (not least-change)",
+)
+parser.add_argument(
+    "-c",
+    "--cve",
+    action="store_true",
+    dest="list_cve",
+    help="Show CVE IDs in listing mode",
+)
+parser.add_argument(
+    "-r",
+    "--reverse",
+    action="store_true",
+    dest="reverse",
+    help="List GLSAs in reverse order",
+)
 
 options, params = parser.parse_known_args()
 
 if options.nocolor:
-	nocolor()
+    nocolor()
 
 if options.version:
-	sys.stderr.write("\n"+ __program__ + ", version " + __version__ + "\n")
-	sys.stderr.write("Author: " + __author__ + "\n")
-	sys.stderr.write("This program is licensed under the GPL, version 2\n\n")
-	sys.exit(0)
+    sys.stderr.write("\n" + __program__ + ", version " + __version__ + "\n")
+    sys.stderr.write("Author: " + __author__ + "\n")
+    sys.stderr.write("This program is licensed under the GPL, version 2\n\n")
+    sys.exit(0)
 
 mode = options.mode
 least_change = options.least_change
@@ -88,27 +155,34 @@ verbose = options.verbose
 
 # Sanity checking
 if mode is None:
-	sys.stderr.write("No mode given: what should I do?\n")
-	parser.print_help()
-	sys.exit(1)
+    sys.stderr.write("No mode given: what should I do?\n")
+    parser.print_help()
+    sys.exit(1)
 elif mode != "list" and not params:
-	sys.stderr.write("\nno GLSA given, so we'll do nothing for now. \n")
-	sys.stderr.write("If you want to run on all GLSA please tell me so \n")
-	sys.stderr.write("(specify \"all\" as parameter)\n\n")
-	parser.print_help()
-	sys.exit(1)
+    sys.stderr.write("\nno GLSA given, so we'll do nothing for now. \n")
+    sys.stderr.write("If you want to run on all GLSA please tell me so \n")
+    sys.stderr.write('(specify "all" as parameter)\n\n')
+    parser.print_help()
+    sys.exit(1)
 elif mode in ["fix", "inject"] and os.geteuid() != 0:
-	# we need root privileges for write access
-	sys.stderr.write("\nThis tool needs root access to "+options.mode+" this GLSA\n\n")
-	sys.exit(2)
+    # we need root privileges for write access
+    sys.stderr.write(
+        "\nThis tool needs root access to " + options.mode + " this GLSA\n\n"
+    )
+    sys.exit(2)
 elif mode == "list" and not params:
-	params.append("affected")
+    params.append("affected")
 
 # delay this for speed increase
-from portage.glsa import (Glsa, GlsaTypeException, GlsaFormatException,
-	get_applied_glsas, get_glsa_list)
-
-eroot = portage.settings['EROOT']
+from portage.glsa import (
+    Glsa,
+    GlsaTypeException,
+    GlsaFormatException,
+    get_applied_glsas,
+    get_glsa_list,
+)
+
+eroot = portage.settings["EROOT"]
 vardb = portage.db[eroot]["vartree"].dbapi
 portdb = portage.db[eroot]["porttree"].dbapi
 
@@ -120,254 +194,299 @@ todolist = [e for e in completelist if e not in checklist]
 
 glsalist = []
 if "new" in params:
-	params.remove("new")
-	sys.stderr.write("Warning: The 'new' glsa-list target has been removed, using 'affected'.\n")
-	params.append("affected")
+    params.remove("new")
+    sys.stderr.write(
+        "Warning: The 'new' glsa-list target has been removed, using 'affected'.\n"
+    )
+    params.append("affected")
 
 if "all" in params:
-	glsalist = completelist
-	params.remove("all")
+    glsalist = completelist
+    params.remove("all")
 
 if "affected" in params:
-	for x in todolist:
-		try:
-			myglsa = Glsa(x, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException) as e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (x, e)))
-			continue
-		if myglsa.isVulnerable():
-			glsalist.append(x)
-	params.remove("affected")
+    for x in todolist:
+        try:
+            myglsa = Glsa(x, portage.settings, vardb, portdb)
+        except (GlsaTypeException, GlsaFormatException) as e:
+            if verbose:
+                sys.stderr.write(
+                    ("invalid GLSA: %s (error message was: %s)\n" % (x, e))
+                )
+            continue
+        if myglsa.isVulnerable():
+            glsalist.append(x)
+    params.remove("affected")
 
 # remove invalid parameters
 for p in params[:]:
-	if not (p in completelist or os.path.exists(p)):
-		sys.stderr.write(("(removing %s from parameter list as it isn't a valid GLSA specification)\n" % p))
-		params.remove(p)
+    if not (p in completelist or os.path.exists(p)):
+        sys.stderr.write(
+            (
+                "(removing %s from parameter list as it isn't a valid GLSA specification)\n"
+                % p
+            )
+        )
+        params.remove(p)
 
 glsalist.extend([g for g in params if g not in glsalist])
 
+
 def summarylist(myglsalist, fd1=sys.stdout, fd2=sys.stderr, encoding="utf-8"):
-	# Get to the raw streams in py3k before wrapping them with an encoded writer
-	# to avoid writing bytes to a text stream (stdout/stderr are text streams
-	# by default in py3k)
-	if hasattr(fd1, "buffer"):
-		fd1 = fd1.buffer
-	if hasattr(fd2, "buffer"):
-		fd2 = fd2.buffer
-	fd1 = codecs.getwriter(encoding)(fd1)
-	fd2 = codecs.getwriter(encoding)(fd2)
-	if not quiet:
-		fd2.write(white("[A]")+" means this GLSA was marked as applied (injected),\n")
-		fd2.write(green("[U]")+" means the system is not affected and\n")
-		fd2.write(red("[N]")+" indicates that the system might be affected.\n\n")
-
-	for myid in sorted(myglsalist, reverse=options.reverse):
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException) as e:
-			if verbose:
-				fd2.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if myglsa.isInjected():
-			status = "[A]"
-			color = white
-		elif myglsa.isVulnerable():
-			status = "[N]"
-			color = red
-		else:
-			status = "[U]"
-			color = green
-
-		if verbose:
-			access = ("[%-8s] " % myglsa.access)
-		else:
-			access = ""
-
-		fd1.write(color(myglsa.nr) + " " + color(status) + " " + color(access) + myglsa.title + " (")
-		if not verbose:
-			for pkg in list(myglsa.packages)[:3]:
-				fd1.write(" " + pkg + " ")
-			if len(myglsa.packages) > 3:
-				fd1.write("... ")
-		else:
-			for cpv in myglsa.packages.keys():
-				pkg = myglsa.packages[cpv]
-				for path in pkg:
-					v_installed = reduce(operator.add, [match(v, vardb) for v in path["vul_atoms"]], [])
-					u_installed = reduce(operator.add, [match(u, vardb) for u in path["unaff_atoms"]], [])
-				mylist = sorted(set(v_installed).difference(set(u_installed)))
-				if len(mylist) > 0:
-					cpv = color(" ".join(mylist))
-				fd1.write(" " + cpv + " ")
-
-		fd1.write(")")
-		if list_cve:
-			cve_ids = []
-			for r in myglsa.references:
-				m = re.search(r'(CAN|CVE)-[\d-]+', r)
-				if m is not None:
-					cve_ids.append(m.group(0))
-			if cve_ids:
-				fd1.write(" "+(",".join(cve_ids)))
-		fd1.write("\n")
-	return 0
+    # Get to the raw streams in py3k before wrapping them with an encoded writer
+    # to avoid writing bytes to a text stream (stdout/stderr are text streams
+    # by default in py3k)
+    if hasattr(fd1, "buffer"):
+        fd1 = fd1.buffer
+    if hasattr(fd2, "buffer"):
+        fd2 = fd2.buffer
+    fd1 = codecs.getwriter(encoding)(fd1)
+    fd2 = codecs.getwriter(encoding)(fd2)
+    if not quiet:
+        fd2.write(white("[A]") + " means this GLSA was marked as applied (injected),\n")
+        fd2.write(green("[U]") + " means the system is not affected and\n")
+        fd2.write(red("[N]") + " indicates that the system might be affected.\n\n")
+
+    for myid in sorted(myglsalist, reverse=options.reverse):
+        try:
+            myglsa = Glsa(myid, portage.settings, vardb, portdb)
+        except (GlsaTypeException, GlsaFormatException) as e:
+            if verbose:
+                fd2.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
+            continue
+        if myglsa.isInjected():
+            status = "[A]"
+            color = white
+        elif myglsa.isVulnerable():
+            status = "[N]"
+            color = red
+        else:
+            status = "[U]"
+            color = green
+
+        if verbose:
+            access = "[%-8s] " % myglsa.access
+        else:
+            access = ""
+
+        fd1.write(
+            color(myglsa.nr)
+            + " "
+            + color(status)
+            + " "
+            + color(access)
+            + myglsa.title
+            + " ("
+        )
+        if not verbose:
+            for pkg in list(myglsa.packages)[:3]:
+                fd1.write(" " + pkg + " ")
+            if len(myglsa.packages) > 3:
+                fd1.write("... ")
+        else:
+            for cpv in myglsa.packages.keys():
+                pkg = myglsa.packages[cpv]
+                for path in pkg:
+                    v_installed = reduce(
+                        operator.add, [match(v, vardb) for v in path["vul_atoms"]], []
+                    )
+                    u_installed = reduce(
+                        operator.add, [match(u, vardb) for u in path["unaff_atoms"]], []
+                    )
+                mylist = sorted(set(v_installed).difference(set(u_installed)))
+                if len(mylist) > 0:
+                    cpv = color(" ".join(mylist))
+                fd1.write(" " + cpv + " ")
+
+        fd1.write(")")
+        if list_cve:
+            cve_ids = []
+            for r in myglsa.references:
+                m = re.search(r"(CAN|CVE)-[\d-]+", r)
+                if m is not None:
+                    cve_ids.append(m.group(0))
+            if cve_ids:
+                fd1.write(" " + (",".join(cve_ids)))
+        fd1.write("\n")
+    return 0
+
 
 if mode == "list":
-	sys.exit(summarylist(glsalist))
+    sys.exit(summarylist(glsalist))
 
 # dump, fix, inject and fix are nearly the same code, only the glsa method call differs
 if mode in ["dump", "fix", "inject", "pretend"]:
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException) as e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if mode == "dump":
-			myglsa.dump()
-		elif mode == "fix":
-			if not quiet:
-				sys.stdout.write("Fixing GLSA "+myid+"\n")
-			if not myglsa.isVulnerable():
-				if not quiet:
-					sys.stdout.write(">>> no vulnerable packages installed\n")
-			else:
-				if quiet:
-					sys.stdout.write("Fixing GLSA "+myid+"\n")
-				mergelist = myglsa.getMergeList(least_change=least_change)
-				if mergelist == []:
-					sys.stdout.write(">>> cannot fix GLSA, no unaffected packages available\n")
-					sys.exit(2)
-				for pkg in mergelist:
-					sys.stdout.write(">>> merging "+pkg+"\n")
-					# using emerge for the actual merging as it contains the dependency
-					# code and we want to be consistent in behaviour. Also this functionality
-					# will be integrated in emerge later, so it shouldn't hurt much.
-					emergecmd = "emerge --oneshot" + (" --quiet" if quiet else "") + " =" + pkg
-					if verbose:
-						sys.stderr.write(emergecmd+"\n")
-					exitcode = os.system(emergecmd)
-					# system() returns the exitcode in the high byte of a 16bit integer
-					if exitcode >= 1 << 8:
-						exitcode >>= 8
-					if exitcode:
-						sys.exit(exitcode)
-				if len(mergelist):
-					sys.stdout.write("\n")
-		elif mode == "pretend":
-			if not quiet:
-				sys.stdout.write("Checking GLSA "+myid+"\n")
-			if not myglsa.isVulnerable():
-				if not quiet:
-					sys.stdout.write(">>> no vulnerable packages installed\n")
-			else:
-				if quiet:
-					sys.stdout.write("Checking GLSA "+myid+"\n")
-				mergedict = {}
-				for (vuln, update) in myglsa.getAffectionTable(least_change=least_change):
-					mergedict.setdefault(update, []).append(vuln)
-
-				# first, extract the atoms that cannot be upgraded (where key == "")
-				no_upgrades = []
-				sys.stdout.write(">>> The following updates will be performed for this GLSA:\n")
-				if "" in mergedict:
-					no_upgrades = mergedict[""]
-					del mergedict[""]
-
-				# see if anything is left that can be upgraded
-				if mergedict:
-					sys.stdout.write(">>> Updates that will be performed:\n")
-					for (upd, vuln) in mergedict.items():
-						sys.stdout.write("     " + green(upd) + " (vulnerable: " + red(", ".join(vuln)) + ")\n")
-
-				if no_upgrades:
-					sys.stdout.write(">>> No upgrade path exists for these packages:\n")
-					sys.stdout.write("     " + red(", ".join(no_upgrades)) + "\n")
-			sys.stdout.write("\n")
-		elif mode == "inject":
-			sys.stdout.write("injecting " + myid + "\n")
-			myglsa.inject()
-		if not quiet:
-			sys.stdout.write("\n")
-	sys.exit(0)
+    for myid in glsalist:
+        try:
+            myglsa = Glsa(myid, portage.settings, vardb, portdb)
+        except (GlsaTypeException, GlsaFormatException) as e:
+            if verbose:
+                sys.stderr.write(
+                    ("invalid GLSA: %s (error message was: %s)\n" % (myid, e))
+                )
+            continue
+        if mode == "dump":
+            myglsa.dump()
+        elif mode == "fix":
+            if not quiet:
+                sys.stdout.write("Fixing GLSA " + myid + "\n")
+            if not myglsa.isVulnerable():
+                if not quiet:
+                    sys.stdout.write(">>> no vulnerable packages installed\n")
+            else:
+                if quiet:
+                    sys.stdout.write("Fixing GLSA " + myid + "\n")
+                mergelist = myglsa.getMergeList(least_change=least_change)
+                if mergelist == []:
+                    sys.stdout.write(
+                        ">>> cannot fix GLSA, no unaffected packages available\n"
+                    )
+                    sys.exit(2)
+                for pkg in mergelist:
+                    sys.stdout.write(">>> merging " + pkg + "\n")
+                    # using emerge for the actual merging as it contains the dependency
+                    # code and we want to be consistent in behaviour. Also this functionality
+                    # will be integrated in emerge later, so it shouldn't hurt much.
+                    emergecmd = (
+                        "emerge --oneshot" + (" --quiet" if quiet else "") + " =" + pkg
+                    )
+                    if verbose:
+                        sys.stderr.write(emergecmd + "\n")
+                    exitcode = os.system(emergecmd)
+                    # system() returns the exitcode in the high byte of a 16bit integer
+                    if exitcode >= 1 << 8:
+                        exitcode >>= 8
+                    if exitcode:
+                        sys.exit(exitcode)
+                if len(mergelist):
+                    sys.stdout.write("\n")
+        elif mode == "pretend":
+            if not quiet:
+                sys.stdout.write("Checking GLSA " + myid + "\n")
+            if not myglsa.isVulnerable():
+                if not quiet:
+                    sys.stdout.write(">>> no vulnerable packages installed\n")
+            else:
+                if quiet:
+                    sys.stdout.write("Checking GLSA " + myid + "\n")
+                mergedict = {}
+                for (vuln, update) in myglsa.getAffectionTable(
+                    least_change=least_change
+                ):
+                    mergedict.setdefault(update, []).append(vuln)
+
+                # first, extract the atoms that cannot be upgraded (where key == "")
+                no_upgrades = []
+                sys.stdout.write(
+                    ">>> The following updates will be performed for this GLSA:\n"
+                )
+                if "" in mergedict:
+                    no_upgrades = mergedict[""]
+                    del mergedict[""]
+
+                # see if anything is left that can be upgraded
+                if mergedict:
+                    sys.stdout.write(">>> Updates that will be performed:\n")
+                    for (upd, vuln) in mergedict.items():
+                        sys.stdout.write(
+                            "     "
+                            + green(upd)
+                            + " (vulnerable: "
+                            + red(", ".join(vuln))
+                            + ")\n"
+                        )
+
+                if no_upgrades:
+                    sys.stdout.write(">>> No upgrade path exists for these packages:\n")
+                    sys.stdout.write("     " + red(", ".join(no_upgrades)) + "\n")
+            sys.stdout.write("\n")
+        elif mode == "inject":
+            sys.stdout.write("injecting " + myid + "\n")
+            myglsa.inject()
+        if not quiet:
+            sys.stdout.write("\n")
+    sys.exit(0)
 
 # test is a bit different as Glsa.test() produces no output
 if mode == "test":
-	outputlist = []
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException) as e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if myglsa.isVulnerable():
-			outputlist.append(str(myglsa.nr))
-	if len(outputlist) > 0:
-		sys.stderr.write("This system is affected by the following GLSAs:\n")
-		if verbose:
-			summarylist(outputlist)
-		else:
-			sys.stdout.write("\n".join(outputlist)+"\n")
-			sys.exit(6)
-	else:
-		sys.stderr.write("This system is not affected by any of the listed GLSAs\n")
-	sys.exit(0)
+    outputlist = []
+    for myid in glsalist:
+        try:
+            myglsa = Glsa(myid, portage.settings, vardb, portdb)
+        except (GlsaTypeException, GlsaFormatException) as e:
+            if verbose:
+                sys.stderr.write(
+                    ("invalid GLSA: %s (error message was: %s)\n" % (myid, e))
+                )
+            continue
+        if myglsa.isVulnerable():
+            outputlist.append(str(myglsa.nr))
+    if len(outputlist) > 0:
+        sys.stderr.write("This system is affected by the following GLSAs:\n")
+        if verbose:
+            summarylist(outputlist)
+        else:
+            sys.stdout.write("\n".join(outputlist) + "\n")
+            sys.exit(6)
+    else:
+        sys.stderr.write("This system is not affected by any of the listed GLSAs\n")
+    sys.exit(0)
 
 # mail mode as requested by solar
 if mode == "mail":
-	import socket
-	from io import BytesIO
-	from email.mime.text import MIMEText
-	import portage.mail
-
-	# color doesn't make any sense for mail
-	nocolor()
-
-	if "PORTAGE_ELOG_MAILURI" in portage.settings:
-		myrecipient = portage.settings["PORTAGE_ELOG_MAILURI"].split()[0]
-	else:
-		myrecipient = "root@localhost"
-
-	if "PORTAGE_ELOG_MAILFROM" in portage.settings:
-		myfrom = portage.settings["PORTAGE_ELOG_MAILFROM"]
-	else:
-		myfrom = "glsa-check"
-
-	mysubject = "[glsa-check] Summary for %s" % socket.getfqdn()
-
-	# need a file object for summarylist()
-	myfd = BytesIO()
-	line = "GLSA Summary report for host %s\n" % socket.getfqdn()
-	myfd.write(line.encode("utf-8"))
-	line = "(Command was: %s)\n\n" % " ".join(sys.argv)
-	myfd.write(line.encode("utf-8"))
-	summarylist(glsalist, fd1=myfd, fd2=myfd)
-	summary = myfd.getvalue().decode("utf-8")
-	myfd.close()
-
-	myattachments = []
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException) as e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		myfd = BytesIO()
-		myglsa.dump(outstream=myfd)
-		attachment = myfd.getvalue().decode("utf-8")
-		myattachments.append(MIMEText(attachment, _charset="utf8"))
-		myfd.close()
-
-	if glsalist or not quiet:
-		mymessage = portage.mail.create_message(myfrom, myrecipient, mysubject, summary, myattachments)
-		portage.mail.send_mail(portage.settings, mymessage)
-
-	sys.exit(0)
+    import socket
+    from io import BytesIO
+    from email.mime.text import MIMEText
+    import portage.mail
+
+    # color doesn't make any sense for mail
+    nocolor()
+
+    if "PORTAGE_ELOG_MAILURI" in portage.settings:
+        myrecipient = portage.settings["PORTAGE_ELOG_MAILURI"].split()[0]
+    else:
+        myrecipient = "root@localhost"
+
+    if "PORTAGE_ELOG_MAILFROM" in portage.settings:
+        myfrom = portage.settings["PORTAGE_ELOG_MAILFROM"]
+    else:
+        myfrom = "glsa-check"
+
+    mysubject = "[glsa-check] Summary for %s" % socket.getfqdn()
+
+    # need a file object for summarylist()
+    myfd = BytesIO()
+    line = "GLSA Summary report for host %s\n" % socket.getfqdn()
+    myfd.write(line.encode("utf-8"))
+    line = "(Command was: %s)\n\n" % " ".join(sys.argv)
+    myfd.write(line.encode("utf-8"))
+    summarylist(glsalist, fd1=myfd, fd2=myfd)
+    summary = myfd.getvalue().decode("utf-8")
+    myfd.close()
+
+    myattachments = []
+    for myid in glsalist:
+        try:
+            myglsa = Glsa(myid, portage.settings, vardb, portdb)
+        except (GlsaTypeException, GlsaFormatException) as e:
+            if verbose:
+                sys.stderr.write(
+                    ("invalid GLSA: %s (error message was: %s)\n" % (myid, e))
+                )
+            continue
+        myfd = BytesIO()
+        myglsa.dump(outstream=myfd)
+        attachment = myfd.getvalue().decode("utf-8")
+        myattachments.append(MIMEText(attachment, _charset="utf8"))
+        myfd.close()
+
+    if glsalist or not quiet:
+        mymessage = portage.mail.create_message(
+            myfrom, myrecipient, mysubject, summary, myattachments
+        )
+        portage.mail.send_mail(portage.settings, mymessage)
+
+    sys.exit(0)
 
 # something wrong here, all valid paths are covered with sys.exit()
 sys.stderr.write("nothing more to do\n")

diff --git a/bin/pid-ns-init b/bin/pid-ns-init
index b9bf56a7b..6bac5961c 100644
--- a/bin/pid-ns-init
+++ b/bin/pid-ns-init
@@ -57,20 +57,22 @@ def preexec_fn(uid, gid, groups, umask):
         os.umask(umask)
 
     # CPython >= 3 subprocess.Popen handles this internally.
-    if platform.python_implementation() != 'CPython':
+    if platform.python_implementation() != "CPython":
         for signum in (
-                signal.SIGHUP,
-                signal.SIGINT,
-                signal.SIGPIPE,
-                signal.SIGQUIT,
-                signal.SIGTERM,
+            signal.SIGHUP,
+            signal.SIGINT,
+            signal.SIGPIPE,
+            signal.SIGQUIT,
+            signal.SIGTERM,
         ):
             signal.signal(signum, signal.SIG_DFL)
 
 
 def main(argv):
     if len(argv) < 2:
-        return 'Usage: {} <main-child-pid> or <uid> <gid> <groups> <umask> <pass_fds> <binary> <argv0> [arg]..'.format(argv[0])
+        return "Usage: {} <main-child-pid> or <uid> <gid> <groups> <umask> <pass_fds> <binary> <argv0> [arg]..".format(
+            argv[0]
+        )
 
     if len(argv) == 2:
         # The child process is init (pid 1) in a child pid namespace, and
@@ -82,15 +84,23 @@ def main(argv):
         proc = None
     else:
         # The current process is init (pid 1) in a child pid namespace.
-        uid, gid, groups, umask, pass_fds, binary, args = argv[1], argv[2], argv[3], argv[4], tuple(int(fd) for fd in argv[5].split(',')), argv[6], argv[7:]
+        uid, gid, groups, umask, pass_fds, binary, args = (
+            argv[1],
+            argv[2],
+            argv[3],
+            argv[4],
+            tuple(int(fd) for fd in argv[5].split(",")),
+            argv[6],
+            argv[7:],
+        )
         uid = int(uid) if uid else None
         gid = int(gid) if gid else None
-        groups = tuple(int(group) for group in groups.split(',')) if groups else None
+        groups = tuple(int(group) for group in groups.split(",")) if groups else None
         umask = int(umask) if umask else None
 
         popen_kwargs = {
-            'preexec_fn': functools.partial(preexec_fn, uid, gid, groups, umask),
-            'pass_fds': pass_fds,
+            "preexec_fn": functools.partial(preexec_fn, uid, gid, groups, umask),
+            "pass_fds": pass_fds,
         }
 
         # Obtain the current nice value, which will be potentially be
@@ -128,12 +138,16 @@ def main(argv):
 
     # If setsid has been called, use kill(0, signum) to
     # forward signals to the entire process group.
-    sig_handler = functools.partial(forward_kill_signal, 0 if setsid else main_child_pid)
+    sig_handler = functools.partial(
+        forward_kill_signal, 0 if setsid else main_child_pid
+    )
     for signum in KILL_SIGNALS:
         signal.signal(signum, sig_handler)
 
     # For correct operation of Ctrl+Z, forward SIGTSTP and SIGCONT.
-    sigtstp_sigcont_handler = functools.partial(forward_sigtstp_sigcont, 0 if setsid else main_child_pid)
+    sigtstp_sigcont_handler = functools.partial(
+        forward_sigtstp_sigcont, 0 if setsid else main_child_pid
+    )
     for signum in SIGTSTP_SIGCONT:
         signal.signal(signum, sigtstp_sigcont_handler)
 
@@ -163,5 +177,5 @@ def main(argv):
     return 127
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv))

diff --git a/bin/portageq b/bin/portageq
index 1c7e27a99..8338d4e14 100755
--- a/bin/portageq
+++ b/bin/portageq
@@ -5,79 +5,95 @@
 import argparse
 import signal
 import sys
+
 # This block ensures that ^C interrupts are handled quietly.
 try:
 
-	def exithandler(signum, _frame):
-		signal.signal(signal.SIGINT, signal.SIG_IGN)
-		signal.signal(signal.SIGTERM, signal.SIG_IGN)
-		sys.exit(128 + signum)
+    def exithandler(signum, _frame):
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        sys.exit(128 + signum)
 
-	signal.signal(signal.SIGINT, exithandler)
-	signal.signal(signal.SIGTERM, exithandler)
+    signal.signal(signal.SIGINT, exithandler)
+    signal.signal(signal.SIGTERM, exithandler)
 
 except KeyboardInterrupt:
-	sys.exit(128 + signal.SIGINT)
+    sys.exit(128 + signal.SIGINT)
 
 import os
 import types
 
-if os.path.isfile(os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), ".portage_not_installed")):
-	pym_paths = [os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "lib")]
-	sys.path.insert(0, pym_paths[0])
+if os.path.isfile(
+    os.path.join(
+        os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
+        ".portage_not_installed",
+    )
+):
+    pym_paths = [
+        os.path.join(
+            os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "lib"
+        )
+    ]
+    sys.path.insert(0, pym_paths[0])
 else:
-	import sysconfig
-	pym_paths = [
-		os.path.join(sysconfig.get_path("purelib"), x) for x in ("_emerge", "portage")
-	]
+    import sysconfig
+
+    pym_paths = [
+        os.path.join(sysconfig.get_path("purelib"), x) for x in ("_emerge", "portage")
+    ]
 # Avoid sandbox violations after Python upgrade.
 if os.environ.get("SANDBOX_ON") == "1":
-	sandbox_write = os.environ.get("SANDBOX_WRITE", "").split(":")
-	for pym_path in pym_paths:
-		if pym_path not in sandbox_write:
-			sandbox_write.append(pym_path)
-			os.environ["SANDBOX_WRITE"] = ":".join(filter(None, sandbox_write))
-	del pym_path, sandbox_write
+    sandbox_write = os.environ.get("SANDBOX_WRITE", "").split(":")
+    for pym_path in pym_paths:
+        if pym_path not in sandbox_write:
+            sandbox_write.append(pym_path)
+            os.environ["SANDBOX_WRITE"] = ":".join(filter(None, sandbox_write))
+    del pym_path, sandbox_write
 del pym_paths
 
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage.eapi import eapi_has_repo_deps
 from portage.util import writemsg, writemsg_stdout
-portage.proxy.lazyimport.lazyimport(globals(),
-	're',
-	'subprocess',
-	'_emerge.Package:Package',
-	'_emerge.RootConfig:RootConfig',
-	'_emerge.is_valid_package_atom:insert_category_into_atom',
-	'portage.dbapi._expand_new_virt:expand_new_virt',
-	'portage._sets.base:InternalPackageSet',
-	'portage.util._eventloop.global_event_loop:global_event_loop',
-	'portage.xml.metadata:MetaDataXML'
+
+portage.proxy.lazyimport.lazyimport(
+    globals(),
+    "re",
+    "subprocess",
+    "_emerge.Package:Package",
+    "_emerge.RootConfig:RootConfig",
+    "_emerge.is_valid_package_atom:insert_category_into_atom",
+    "portage.dbapi._expand_new_virt:expand_new_virt",
+    "portage._sets.base:InternalPackageSet",
+    "portage.util._eventloop.global_event_loop:global_event_loop",
+    "portage.xml.metadata:MetaDataXML",
 )
 
+
 def eval_atom_use(atom):
-	if 'USE' in os.environ:
-		use = frozenset(os.environ['USE'].split())
-		atom = atom.evaluate_conditionals(use)
-	return atom
+    if "USE" in os.environ:
+        use = frozenset(os.environ["USE"].split())
+        atom = atom.evaluate_conditionals(use)
+    return atom
 
 
 def uses_configroot(function):
-	function.uses_configroot = True
-	return function
+    function.uses_configroot = True
+    return function
 
 
 def uses_eroot(function):
-	function.uses_eroot = True
-	return function
+    function.uses_eroot = True
+    return function
+
 
 # global to hold all function docstrings to be used for argparse help.
 # Avoids python compilation level 2 optimization troubles.
 docstrings = {}
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #
 # To add functionality to this tool, add a function below.
 #
@@ -100,573 +116,615 @@ docstrings = {}
 # and will automaticly add a command by the same name as the function!
 #
 
+
 @uses_eroot
 def has_version(argv):
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!")
-		return 3
-
-	warnings = []
-
-	allow_repo = atom_validate_strict is False or eapi_has_repo_deps(eapi)
-	try:
-		atom = portage.dep.Atom(argv[1], allow_repo=allow_repo)
-	except portage.exception.InvalidAtom:
-		if atom_validate_strict:
-			portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1],
-				noiselevel=-1)
-			return 2
-		else:
-			atom = argv[1]
-	else:
-		if atom_validate_strict:
-			try:
-				atom = portage.dep.Atom(argv[1], allow_repo=allow_repo, eapi=eapi)
-			except portage.exception.InvalidAtom as e:
-				warnings.append("QA Notice: %s: %s" % ('has_version', e))
-		atom = eval_atom_use(atom)
-
-	if warnings:
-		elog('eqawarn', warnings)
-
-	try:
-		mylist = portage.db[argv[0]]["vartree"].dbapi.match(atom)
-		if mylist:
-			return 0
-		else:
-			return 1
-	except KeyError:
-		return 1
-	except portage.exception.InvalidAtom:
-		portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1],
-			noiselevel=-1)
-		return 2
-
-docstrings['has_version'] = """<eroot> <category/package>
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!")
+        return 3
+
+    warnings = []
+
+    allow_repo = atom_validate_strict is False or eapi_has_repo_deps(eapi)
+    try:
+        atom = portage.dep.Atom(argv[1], allow_repo=allow_repo)
+    except portage.exception.InvalidAtom:
+        if atom_validate_strict:
+            portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1], noiselevel=-1)
+            return 2
+        else:
+            atom = argv[1]
+    else:
+        if atom_validate_strict:
+            try:
+                atom = portage.dep.Atom(argv[1], allow_repo=allow_repo, eapi=eapi)
+            except portage.exception.InvalidAtom as e:
+                warnings.append("QA Notice: %s: %s" % ("has_version", e))
+        atom = eval_atom_use(atom)
+
+    if warnings:
+        elog("eqawarn", warnings)
+
+    try:
+        mylist = portage.db[argv[0]]["vartree"].dbapi.match(atom)
+        if mylist:
+            return 0
+        else:
+            return 1
+    except KeyError:
+        return 1
+    except portage.exception.InvalidAtom:
+        portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1], noiselevel=-1)
+        return 2
+
+
+docstrings[
+    "has_version"
+] = """<eroot> <category/package>
 	Return code 0 if it's available, 1 otherwise.
 	"""
-has_version.__doc__ = docstrings['has_version']
+has_version.__doc__ = docstrings["has_version"]
 
 
 @uses_eroot
 def best_version(argv):
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!")
-		return 3
-
-	warnings = []
-
-	allow_repo = atom_validate_strict is False or eapi_has_repo_deps(eapi)
-	try:
-		atom = portage.dep.Atom(argv[1], allow_repo=allow_repo)
-	except portage.exception.InvalidAtom:
-		if atom_validate_strict:
-			portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1],
-				noiselevel=-1)
-			return 2
-		else:
-			atom = argv[1]
-	else:
-		if atom_validate_strict:
-			try:
-				atom = portage.dep.Atom(argv[1], allow_repo=allow_repo, eapi=eapi)
-			except portage.exception.InvalidAtom as e:
-				warnings.append("QA Notice: %s: %s" % ('best_version', e))
-		atom = eval_atom_use(atom)
-
-	if warnings:
-		elog('eqawarn', warnings)
-
-	try:
-		mylist = portage.db[argv[0]]["vartree"].dbapi.match(atom)
-		print(portage.best(mylist))
-	except KeyError:
-		return 1
-
-docstrings['best_version'] = """<eroot> <category/package>
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!")
+        return 3
+
+    warnings = []
+
+    allow_repo = atom_validate_strict is False or eapi_has_repo_deps(eapi)
+    try:
+        atom = portage.dep.Atom(argv[1], allow_repo=allow_repo)
+    except portage.exception.InvalidAtom:
+        if atom_validate_strict:
+            portage.writemsg("ERROR: Invalid atom: '%s'\n" % argv[1], noiselevel=-1)
+            return 2
+        else:
+            atom = argv[1]
+    else:
+        if atom_validate_strict:
+            try:
+                atom = portage.dep.Atom(argv[1], allow_repo=allow_repo, eapi=eapi)
+            except portage.exception.InvalidAtom as e:
+                warnings.append("QA Notice: %s: %s" % ("best_version", e))
+        atom = eval_atom_use(atom)
+
+    if warnings:
+        elog("eqawarn", warnings)
+
+    try:
+        mylist = portage.db[argv[0]]["vartree"].dbapi.match(atom)
+        print(portage.best(mylist))
+    except KeyError:
+        return 1
+
+
+docstrings[
+    "best_version"
+] = """<eroot> <category/package>
 	Returns highest installed matching category/package-version (without .ebuild).
 	"""
-best_version.__doc__ = docstrings['best_version']
+best_version.__doc__ = docstrings["best_version"]
 
 
 @uses_eroot
 def mass_best_version(argv):
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!")
-		return 2
-	try:
-		for pack in argv[1:]:
-			mylist = portage.db[argv[0]]['vartree'].dbapi.match(pack)
-			print('%s:%s' % (pack, portage.best(mylist)))
-	except KeyError:
-		return 1
-
-docstrings['mass_best_version'] = """<eroot> [<category/package>]+
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!")
+        return 2
+    try:
+        for pack in argv[1:]:
+            mylist = portage.db[argv[0]]["vartree"].dbapi.match(pack)
+            print("%s:%s" % (pack, portage.best(mylist)))
+    except KeyError:
+        return 1
+
+
+docstrings[
+    "mass_best_version"
+] = """<eroot> [<category/package>]+
 	Returns category/package-version (without .ebuild).
 	"""
-mass_best_version.__doc__ = docstrings['mass_best_version']
+mass_best_version.__doc__ = docstrings["mass_best_version"]
 
 
 @uses_eroot
 def metadata(argv):
-	if len(argv) < 4:
-		print('ERROR: insufficient parameters!', file=sys.stderr)
-		return 2
-
-	eroot, pkgtype, pkgspec = argv[0:3]
-	metakeys = argv[3:]
-	type_map = {
-		'ebuild': 'porttree',
-		'binary': 'bintree',
-		'installed': 'vartree'
-	}
-	if pkgtype not in type_map:
-		print("Unrecognized package type: '%s'" % pkgtype, file=sys.stderr)
-		return 1
-	trees = portage.db
-	repo = portage.dep.dep_getrepo(pkgspec)
-	pkgspec = portage.dep.remove_slot(pkgspec)
-	try:
-		values = trees[eroot][type_map[pkgtype]].dbapi.aux_get(
-			pkgspec, metakeys, myrepo=repo)
-		writemsg_stdout(''.join('%s\n' % x for x in values), noiselevel=-1)
-	except KeyError:
-		print("Package not found: '%s'" % pkgspec, file=sys.stderr)
-		return 1
-
-docstrings['metadata'] = """
+    if len(argv) < 4:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 2
+
+    eroot, pkgtype, pkgspec = argv[0:3]
+    metakeys = argv[3:]
+    type_map = {"ebuild": "porttree", "binary": "bintree", "installed": "vartree"}
+    if pkgtype not in type_map:
+        print("Unrecognized package type: '%s'" % pkgtype, file=sys.stderr)
+        return 1
+    trees = portage.db
+    repo = portage.dep.dep_getrepo(pkgspec)
+    pkgspec = portage.dep.remove_slot(pkgspec)
+    try:
+        values = trees[eroot][type_map[pkgtype]].dbapi.aux_get(
+            pkgspec, metakeys, myrepo=repo
+        )
+        writemsg_stdout("".join("%s\n" % x for x in values), noiselevel=-1)
+    except KeyError:
+        print("Package not found: '%s'" % pkgspec, file=sys.stderr)
+        return 1
+
+
+docstrings[
+    "metadata"
+] = """
 <eroot> <pkgtype> <category/package> [<key>]+
 Returns metadata values for the specified package.
 Available keys: %s
-"""  % ','.join(sorted(x for x in portage.auxdbkeys))
-metadata.__doc__ = docstrings['metadata']
+""" % ",".join(
+    sorted(x for x in portage.auxdbkeys)
+)
+metadata.__doc__ = docstrings["metadata"]
 
 
 @uses_eroot
 def contents(argv):
-	if len(argv) != 2:
-		print("ERROR: expected 2 parameters, got %d!" % len(argv))
-		return 2
-
-	root, cpv = argv
-	vartree = portage.db[root]["vartree"]
-	if not vartree.dbapi.cpv_exists(cpv):
-		sys.stderr.write("Package not found: '%s'\n" % cpv)
-		return 1
-	cat, pkg = portage.catsplit(cpv)
-	db = portage.dblink(cat, pkg, root, vartree.settings,
-		treetype="vartree", vartree=vartree)
-	writemsg_stdout(''.join('%s\n' % x for x in sorted(db.getcontents())),
-		noiselevel=-1)
-
-docstrings['contents'] = """<eroot> <category/package>
+    if len(argv) != 2:
+        print("ERROR: expected 2 parameters, got %d!" % len(argv))
+        return 2
+
+    root, cpv = argv
+    vartree = portage.db[root]["vartree"]
+    if not vartree.dbapi.cpv_exists(cpv):
+        sys.stderr.write("Package not found: '%s'\n" % cpv)
+        return 1
+    cat, pkg = portage.catsplit(cpv)
+    db = portage.dblink(
+        cat, pkg, root, vartree.settings, treetype="vartree", vartree=vartree
+    )
+    writemsg_stdout(
+        "".join("%s\n" % x for x in sorted(db.getcontents())), noiselevel=-1
+    )
+
+
+docstrings[
+    "contents"
+] = """<eroot> <category/package>
 	List the files that are installed for a given package, with
 	one file listed on each line. All file names will begin with
 	<eroot>.
 	"""
-contents.__doc__ = docstrings['contents']
+contents.__doc__ = docstrings["contents"]
 
 
 @uses_eroot
 def owners(argv):
-	if len(argv) < 2:
-		sys.stderr.write("ERROR: insufficient parameters!\n")
-		sys.stderr.flush()
-		return 2
-
-	eroot = argv[0]
-	vardb = portage.db[eroot]["vartree"].dbapi
-	root = portage.settings['ROOT']
-
-	cwd = None
-	try:
-		cwd = os.getcwd()
-	except OSError:
-		pass
-
-	files = []
-	orphan_abs_paths = set()
-	orphan_basenames = set()
-	for f in argv[1:]:
-		f = portage.normalize_path(f)
-		is_basename = os.sep not in f
-		if not is_basename and f[:1] != os.sep:
-			if cwd is None:
-				sys.stderr.write("ERROR: cwd does not exist!\n")
-				sys.stderr.flush()
-				return 2
-			f = os.path.join(cwd, f)
-			f = portage.normalize_path(f)
-		if not is_basename and not f.startswith(eroot):
-			sys.stderr.write("ERROR: file paths must begin with <eroot>!\n")
-			sys.stderr.flush()
-			return 2
-		if is_basename:
-			files.append(f)
-			orphan_basenames.add(f)
-		else:
-			files.append(f[len(root)-1:])
-			orphan_abs_paths.add(f)
-
-	owners = vardb._owners.get_owners(files)
-
-	msg = []
-	for pkg, owned_files in owners.items():
-		cpv = pkg.mycpv
-		msg.append("%s\n" % cpv)
-		for f in sorted(owned_files):
-			f_abs = os.path.join(root, f.lstrip(os.path.sep))
-			msg.append("\t%s\n" % (f_abs,))
-			orphan_abs_paths.discard(f_abs)
-			if orphan_basenames:
-				orphan_basenames.discard(os.path.basename(f_abs))
-
-	writemsg_stdout(''.join(msg), noiselevel=-1)
-
-	if orphan_abs_paths or orphan_basenames:
-		orphans = []
-		orphans.extend(orphan_abs_paths)
-		orphans.extend(orphan_basenames)
-		orphans.sort()
-		msg = []
-		msg.append("None of the installed packages claim these files:\n")
-		for f in orphans:
-			msg.append("\t%s\n" % (f,))
-		sys.stderr.write("".join(msg))
-		sys.stderr.flush()
-
-	if owners:
-		return 0
-	return 1
-
-docstrings['owners'] = """<eroot> [<filename>]+
+    if len(argv) < 2:
+        sys.stderr.write("ERROR: insufficient parameters!\n")
+        sys.stderr.flush()
+        return 2
+
+    eroot = argv[0]
+    vardb = portage.db[eroot]["vartree"].dbapi
+    root = portage.settings["ROOT"]
+
+    cwd = None
+    try:
+        cwd = os.getcwd()
+    except OSError:
+        pass
+
+    files = []
+    orphan_abs_paths = set()
+    orphan_basenames = set()
+    for f in argv[1:]:
+        f = portage.normalize_path(f)
+        is_basename = os.sep not in f
+        if not is_basename and f[:1] != os.sep:
+            if cwd is None:
+                sys.stderr.write("ERROR: cwd does not exist!\n")
+                sys.stderr.flush()
+                return 2
+            f = os.path.join(cwd, f)
+            f = portage.normalize_path(f)
+        if not is_basename and not f.startswith(eroot):
+            sys.stderr.write("ERROR: file paths must begin with <eroot>!\n")
+            sys.stderr.flush()
+            return 2
+        if is_basename:
+            files.append(f)
+            orphan_basenames.add(f)
+        else:
+            files.append(f[len(root) - 1 :])
+            orphan_abs_paths.add(f)
+
+    owners = vardb._owners.get_owners(files)
+
+    msg = []
+    for pkg, owned_files in owners.items():
+        cpv = pkg.mycpv
+        msg.append("%s\n" % cpv)
+        for f in sorted(owned_files):
+            f_abs = os.path.join(root, f.lstrip(os.path.sep))
+            msg.append("\t%s\n" % (f_abs,))
+            orphan_abs_paths.discard(f_abs)
+            if orphan_basenames:
+                orphan_basenames.discard(os.path.basename(f_abs))
+
+    writemsg_stdout("".join(msg), noiselevel=-1)
+
+    if orphan_abs_paths or orphan_basenames:
+        orphans = []
+        orphans.extend(orphan_abs_paths)
+        orphans.extend(orphan_basenames)
+        orphans.sort()
+        msg = []
+        msg.append("None of the installed packages claim these files:\n")
+        for f in orphans:
+            msg.append("\t%s\n" % (f,))
+        sys.stderr.write("".join(msg))
+        sys.stderr.flush()
+
+    if owners:
+        return 0
+    return 1
+
+
+docstrings[
+    "owners"
+] = """<eroot> [<filename>]+
 	Given a list of files, print the packages that own the files and which
 	files belong to each package. Files owned by a package are listed on
 	the lines below it, indented by a single tab character (\\t). All file
 	paths must either start with <eroot> or be a basename alone.
 	Returns 1 if no owners could be found, and 0 otherwise.
 	"""
-owners.__doc__ = docstrings['owners']
+owners.__doc__ = docstrings["owners"]
 
 
 @uses_eroot
 def is_protected(argv):
-	if len(argv) != 2:
-		sys.stderr.write("ERROR: expected 2 parameters, got %d!\n" % len(argv))
-		sys.stderr.flush()
-		return 2
-
-	root, filename = argv
-
-	err = sys.stderr
-	cwd = None
-	try:
-		cwd = os.getcwd()
-	except OSError:
-		pass
-
-	f = portage.normalize_path(filename)
-	if not f.startswith(os.path.sep):
-		if cwd is None:
-			err.write("ERROR: cwd does not exist!\n")
-			err.flush()
-			return 2
-		f = os.path.join(cwd, f)
-		f = portage.normalize_path(f)
-
-	if not f.startswith(root):
-		err.write("ERROR: file paths must begin with <eroot>!\n")
-		err.flush()
-		return 2
-
-	from portage.util import ConfigProtect
-
-	settings = portage.settings
-	protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
-	protect_mask = portage.util.shlex_split(
-		settings.get("CONFIG_PROTECT_MASK", ""))
-	protect_obj = ConfigProtect(root, protect, protect_mask,
-		case_insensitive=("case-insensitive-fs" in settings.features))
-	if protect_obj.isprotected(f):
-		return 0
-	return 1
-
-docstrings['is_protected'] = """<eroot> <filename>
+    if len(argv) != 2:
+        sys.stderr.write("ERROR: expected 2 parameters, got %d!\n" % len(argv))
+        sys.stderr.flush()
+        return 2
+
+    root, filename = argv
+
+    err = sys.stderr
+    cwd = None
+    try:
+        cwd = os.getcwd()
+    except OSError:
+        pass
+
+    f = portage.normalize_path(filename)
+    if not f.startswith(os.path.sep):
+        if cwd is None:
+            err.write("ERROR: cwd does not exist!\n")
+            err.flush()
+            return 2
+        f = os.path.join(cwd, f)
+        f = portage.normalize_path(f)
+
+    if not f.startswith(root):
+        err.write("ERROR: file paths must begin with <eroot>!\n")
+        err.flush()
+        return 2
+
+    from portage.util import ConfigProtect
+
+    settings = portage.settings
+    protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
+    protect_mask = portage.util.shlex_split(settings.get("CONFIG_PROTECT_MASK", ""))
+    protect_obj = ConfigProtect(
+        root,
+        protect,
+        protect_mask,
+        case_insensitive=("case-insensitive-fs" in settings.features),
+    )
+    if protect_obj.isprotected(f):
+        return 0
+    return 1
+
+
+docstrings[
+    "is_protected"
+] = """<eroot> <filename>
 	Given a single filename, return code 0 if it's protected, 1 otherwise.
 	The filename must begin with <eroot>.
 	"""
-is_protected.__doc__ = docstrings['is_protected']
+is_protected.__doc__ = docstrings["is_protected"]
 
 
 @uses_eroot
 def filter_protected(argv):
-	if len(argv) != 1:
-		sys.stderr.write("ERROR: expected 1 parameter, got %d!\n" % len(argv))
-		sys.stderr.flush()
-		return 2
-
-	root, = argv
-	out = sys.stdout
-	err = sys.stderr
-	cwd = None
-	try:
-		cwd = os.getcwd()
-	except OSError:
-		pass
-
-	from portage.util import ConfigProtect
-
-	settings = portage.settings
-	protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
-	protect_mask = portage.util.shlex_split(
-		settings.get("CONFIG_PROTECT_MASK", ""))
-	protect_obj = ConfigProtect(root, protect, protect_mask,
-		case_insensitive=("case-insensitive-fs" in settings.features))
-
-	errors = 0
-
-	for line in sys.stdin:
-		filename = line.rstrip("\n")
-		f = portage.normalize_path(filename)
-		if not f.startswith(os.path.sep):
-			if cwd is None:
-				err.write("ERROR: cwd does not exist!\n")
-				err.flush()
-				errors += 1
-				continue
-			f = os.path.join(cwd, f)
-			f = portage.normalize_path(f)
-
-		if not f.startswith(root):
-			err.write("ERROR: file paths must begin with <eroot>!\n")
-			err.flush()
-			errors += 1
-			continue
-
-		if protect_obj.isprotected(f):
-			out.write("%s\n" % filename)
-	out.flush()
-
-	if errors:
-		return 2
-
-	return 0
-
-docstrings['filter_protected'] = """<eroot>
+    if len(argv) != 1:
+        sys.stderr.write("ERROR: expected 1 parameter, got %d!\n" % len(argv))
+        sys.stderr.flush()
+        return 2
+
+    (root,) = argv
+    out = sys.stdout
+    err = sys.stderr
+    cwd = None
+    try:
+        cwd = os.getcwd()
+    except OSError:
+        pass
+
+    from portage.util import ConfigProtect
+
+    settings = portage.settings
+    protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
+    protect_mask = portage.util.shlex_split(settings.get("CONFIG_PROTECT_MASK", ""))
+    protect_obj = ConfigProtect(
+        root,
+        protect,
+        protect_mask,
+        case_insensitive=("case-insensitive-fs" in settings.features),
+    )
+
+    errors = 0
+
+    for line in sys.stdin:
+        filename = line.rstrip("\n")
+        f = portage.normalize_path(filename)
+        if not f.startswith(os.path.sep):
+            if cwd is None:
+                err.write("ERROR: cwd does not exist!\n")
+                err.flush()
+                errors += 1
+                continue
+            f = os.path.join(cwd, f)
+            f = portage.normalize_path(f)
+
+        if not f.startswith(root):
+            err.write("ERROR: file paths must begin with <eroot>!\n")
+            err.flush()
+            errors += 1
+            continue
+
+        if protect_obj.isprotected(f):
+            out.write("%s\n" % filename)
+    out.flush()
+
+    if errors:
+        return 2
+
+    return 0
+
+
+docstrings[
+    "filter_protected"
+] = """<eroot>
 	Read filenames from stdin and write them to stdout if they are protected.
 	All filenames are delimited by \\n and must begin with <eroot>.
 	"""
-filter_protected.__doc__ = docstrings['filter_protected']
+filter_protected.__doc__ = docstrings["filter_protected"]
 
 
 @uses_eroot
 def best_visible(argv):
-	if len(argv) < 2:
-		writemsg("ERROR: insufficient parameters!\n", noiselevel=-1)
-		return 2
-
-	pkgtype = "ebuild"
-	if len(argv) > 2:
-		pkgtype = argv[1]
-		atom = argv[2]
-	else:
-		atom = argv[1]
-
-	type_map = {
-		"ebuild":"porttree",
-		"binary":"bintree",
-		"installed":"vartree"}
-
-	if pkgtype not in type_map:
-		writemsg("Unrecognized package type: '%s'\n" % pkgtype,
-			noiselevel=-1)
-		return 2
-
-	eroot = argv[0]
-	db = portage.db[eroot][type_map[pkgtype]].dbapi
-
-	try:
-		atom = portage.dep_expand(atom, mydb=db, settings=portage.settings)
-	except portage.exception.InvalidAtom:
-		writemsg("ERROR: Invalid atom: '%s'\n" % atom,
-			noiselevel=-1)
-		return 2
-
-	root_config = RootConfig(portage.settings, portage.db[eroot], None)
-
-	if hasattr(db, "xmatch"):
-		cpv_list = db.xmatch("match-all-cpv-only", atom)
-	else:
-		cpv_list = db.match(atom)
-
-	if cpv_list:
-		# reversed, for descending order
-		cpv_list.reverse()
-		# verify match, since the atom may match the package
-		# for a given cpv from one repo but not another, and
-		# we can use match-all-cpv-only to avoid redundant
-		# metadata access.
-		atom_set = InternalPackageSet(initial_atoms=(atom,))
-
-		if atom.repo is None and hasattr(db, "getRepositories"):
-			repo_list = db.getRepositories()
-		else:
-			repo_list = [atom.repo]
-
-		for cpv in cpv_list:
-			for repo in repo_list:
-				try:
-					metadata = dict(zip(Package.metadata_keys,
-						db.aux_get(cpv, Package.metadata_keys, myrepo=repo)))
-				except KeyError:
-					continue
-				pkg = Package(built=(pkgtype != "ebuild"), cpv=cpv,
-					installed=(pkgtype=="installed"), metadata=metadata,
-					root_config=root_config, type_name=pkgtype)
-				if not atom_set.findAtomForPackage(pkg):
-					continue
-
-				if pkg.visible:
-					writemsg_stdout("%s\n" % (pkg.cpv,), noiselevel=-1)
-					return os.EX_OK
-
-	# No package found, write out an empty line.
-	writemsg_stdout("\n", noiselevel=-1)
-
-	return 1
-
-docstrings['best_visible'] = """<eroot> [pkgtype] <atom>
+    if len(argv) < 2:
+        writemsg("ERROR: insufficient parameters!\n", noiselevel=-1)
+        return 2
+
+    pkgtype = "ebuild"
+    if len(argv) > 2:
+        pkgtype = argv[1]
+        atom = argv[2]
+    else:
+        atom = argv[1]
+
+    type_map = {"ebuild": "porttree", "binary": "bintree", "installed": "vartree"}
+
+    if pkgtype not in type_map:
+        writemsg("Unrecognized package type: '%s'\n" % pkgtype, noiselevel=-1)
+        return 2
+
+    eroot = argv[0]
+    db = portage.db[eroot][type_map[pkgtype]].dbapi
+
+    try:
+        atom = portage.dep_expand(atom, mydb=db, settings=portage.settings)
+    except portage.exception.InvalidAtom:
+        writemsg("ERROR: Invalid atom: '%s'\n" % atom, noiselevel=-1)
+        return 2
+
+    root_config = RootConfig(portage.settings, portage.db[eroot], None)
+
+    if hasattr(db, "xmatch"):
+        cpv_list = db.xmatch("match-all-cpv-only", atom)
+    else:
+        cpv_list = db.match(atom)
+
+    if cpv_list:
+        # reversed, for descending order
+        cpv_list.reverse()
+        # verify match, since the atom may match the package
+        # for a given cpv from one repo but not another, and
+        # we can use match-all-cpv-only to avoid redundant
+        # metadata access.
+        atom_set = InternalPackageSet(initial_atoms=(atom,))
+
+        if atom.repo is None and hasattr(db, "getRepositories"):
+            repo_list = db.getRepositories()
+        else:
+            repo_list = [atom.repo]
+
+        for cpv in cpv_list:
+            for repo in repo_list:
+                try:
+                    metadata = dict(
+                        zip(
+                            Package.metadata_keys,
+                            db.aux_get(cpv, Package.metadata_keys, myrepo=repo),
+                        )
+                    )
+                except KeyError:
+                    continue
+                pkg = Package(
+                    built=(pkgtype != "ebuild"),
+                    cpv=cpv,
+                    installed=(pkgtype == "installed"),
+                    metadata=metadata,
+                    root_config=root_config,
+                    type_name=pkgtype,
+                )
+                if not atom_set.findAtomForPackage(pkg):
+                    continue
+
+                if pkg.visible:
+                    writemsg_stdout("%s\n" % (pkg.cpv,), noiselevel=-1)
+                    return os.EX_OK
+
+    # No package found, write out an empty line.
+    writemsg_stdout("\n", noiselevel=-1)
+
+    return 1
+
+
+docstrings[
+    "best_visible"
+] = """<eroot> [pkgtype] <atom>
 	Returns category/package-version (without .ebuild).
 	The pkgtype argument defaults to "ebuild" if unspecified,
 	otherwise it must be one of ebuild, binary, or installed.
 	"""
-best_visible.__doc__ = docstrings['best_visible']
+best_visible.__doc__ = docstrings["best_visible"]
 
 
 @uses_eroot
 def mass_best_visible(argv):
-	type_map = {
-		"ebuild":"porttree",
-		"binary":"bintree",
-		"installed":"vartree"}
-
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!")
-		return 2
-	try:
-		root = argv.pop(0)
-		pkgtype = "ebuild"
-		if argv[0] in type_map:
-			pkgtype = argv.pop(0)
-		for pack in argv:
-			writemsg_stdout("%s:" % pack, noiselevel=-1)
-			best_visible([root, pkgtype, pack])
-	except KeyError:
-		return 1
-
-docstrings['mass_best_visible'] = """<eroot> [<type>] [<category/package>]+
+    type_map = {"ebuild": "porttree", "binary": "bintree", "installed": "vartree"}
+
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!")
+        return 2
+    try:
+        root = argv.pop(0)
+        pkgtype = "ebuild"
+        if argv[0] in type_map:
+            pkgtype = argv.pop(0)
+        for pack in argv:
+            writemsg_stdout("%s:" % pack, noiselevel=-1)
+            best_visible([root, pkgtype, pack])
+    except KeyError:
+        return 1
+
+
+docstrings[
+    "mass_best_visible"
+] = """<eroot> [<type>] [<category/package>]+
 	Returns category/package-version (without .ebuild).
 	The pkgtype argument defaults to "ebuild" if unspecified,
 	otherwise it must be one of ebuild, binary, or installed.
 	"""
-mass_best_visible.__doc__ = docstrings['mass_best_visible']
+mass_best_visible.__doc__ = docstrings["mass_best_visible"]
 
 
 @uses_eroot
 def all_best_visible(argv):
-	if len(argv) < 1:
-		sys.stderr.write("ERROR: insufficient parameters!\n")
-		sys.stderr.flush()
-		return 2
-
-	#print portage.db[argv[0]]["porttree"].dbapi.cp_all()
-	for pkg in portage.db[argv[0]]["porttree"].dbapi.cp_all():
-		mybest=portage.best(portage.db[argv[0]]["porttree"].dbapi.match(pkg))
-		if mybest:
-			print(mybest)
-
-docstrings['all_best_visible'] = """<eroot>
+    if len(argv) < 1:
+        sys.stderr.write("ERROR: insufficient parameters!\n")
+        sys.stderr.flush()
+        return 2
+
+    # print portage.db[argv[0]]["porttree"].dbapi.cp_all()
+    for pkg in portage.db[argv[0]]["porttree"].dbapi.cp_all():
+        mybest = portage.best(portage.db[argv[0]]["porttree"].dbapi.match(pkg))
+        if mybest:
+            print(mybest)
+
+
+docstrings[
+    "all_best_visible"
+] = """<eroot>
 	Returns all best_visible packages (without .ebuild).
 	"""
-all_best_visible.__doc__ = docstrings['all_best_visible']
+all_best_visible.__doc__ = docstrings["all_best_visible"]
 
 
 @uses_eroot
 def match(argv):
-	if len(argv) != 2:
-		print("ERROR: expected 2 parameters, got %d!" % len(argv))
-		return 2
-	root, atom = argv
-	if not atom:
-		atom = "*/*"
-
-	vardb = portage.db[root]["vartree"].dbapi
-	try:
-		atom = portage.dep.Atom(atom, allow_wildcard=True, allow_repo=True)
-	except portage.exception.InvalidAtom:
-		# maybe it's valid but missing category
-		atom = portage.dep_expand(atom, mydb=vardb, settings=vardb.settings)
-
-	if atom.extended_syntax:
-		if atom == "*/*":
-			results = vardb.cpv_all()
-		else:
-			results = []
-			require_metadata = atom.slot or atom.repo
-			for cpv in vardb.cpv_all():
-
-				if not portage.match_from_list(atom, [cpv]):
-					continue
-
-				if require_metadata:
-					try:
-						cpv = vardb._pkg_str(cpv, atom.repo)
-					except (KeyError, portage.exception.InvalidData):
-						continue
-					if not portage.match_from_list(atom, [cpv]):
-						continue
-
-				results.append(cpv)
-
-		results.sort()
-	else:
-		results = vardb.match(atom)
-	for cpv in results:
-		print(cpv)
-
-docstrings['match'] = """<eroot> <atom>
+    if len(argv) != 2:
+        print("ERROR: expected 2 parameters, got %d!" % len(argv))
+        return 2
+    root, atom = argv
+    if not atom:
+        atom = "*/*"
+
+    vardb = portage.db[root]["vartree"].dbapi
+    try:
+        atom = portage.dep.Atom(atom, allow_wildcard=True, allow_repo=True)
+    except portage.exception.InvalidAtom:
+        # maybe it's valid but missing category
+        atom = portage.dep_expand(atom, mydb=vardb, settings=vardb.settings)
+
+    if atom.extended_syntax:
+        if atom == "*/*":
+            results = vardb.cpv_all()
+        else:
+            results = []
+            require_metadata = atom.slot or atom.repo
+            for cpv in vardb.cpv_all():
+
+                if not portage.match_from_list(atom, [cpv]):
+                    continue
+
+                if require_metadata:
+                    try:
+                        cpv = vardb._pkg_str(cpv, atom.repo)
+                    except (KeyError, portage.exception.InvalidData):
+                        continue
+                    if not portage.match_from_list(atom, [cpv]):
+                        continue
+
+                results.append(cpv)
+
+        results.sort()
+    else:
+        results = vardb.match(atom)
+    for cpv in results:
+        print(cpv)
+
+
+docstrings[
+    "match"
+] = """<eroot> <atom>
 	Returns a \\n separated list of category/package-version.
 	When given an empty string, all installed packages will
 	be listed.
 	"""
-match.__doc__ = docstrings['match']
+match.__doc__ = docstrings["match"]
 
 
 @uses_eroot
 def expand_virtual(argv):
-	if len(argv) != 2:
-		writemsg("ERROR: expected 2 parameters, got %d!\n" % len(argv),
-			noiselevel=-1)
-		return 2
+    if len(argv) != 2:
+        writemsg("ERROR: expected 2 parameters, got %d!\n" % len(argv), noiselevel=-1)
+        return 2
+
+    root, atom = argv
 
-	root, atom = argv
+    try:
+        results = list(expand_new_virt(portage.db[root]["vartree"].dbapi, atom))
+    except portage.exception.InvalidAtom:
+        writemsg("ERROR: Invalid atom: '%s'\n" % atom, noiselevel=-1)
+        return 2
 
-	try:
-		results = list(expand_new_virt(
-			portage.db[root]["vartree"].dbapi, atom))
-	except portage.exception.InvalidAtom:
-		writemsg("ERROR: Invalid atom: '%s'\n" % atom,
-			noiselevel=-1)
-		return 2
+    results.sort()
+    for x in results:
+        if not x.blocker:
+            writemsg_stdout("%s\n" % (x,))
 
-	results.sort()
-	for x in results:
-		if not x.blocker:
-			writemsg_stdout("%s\n" % (x,))
+    return os.EX_OK
 
-	return os.EX_OK
 
-docstrings['expand_virtual'] = """<eroot> <atom>
+docstrings[
+    "expand_virtual"
+] = """<eroot> <atom>
 	Returns a \\n separated list of atoms expanded from a
 	given virtual atom (GLEP 37 virtuals only),
 	excluding blocker atoms. Satisfied
@@ -677,802 +735,911 @@ docstrings['expand_virtual'] = """<eroot> <atom>
 	resolve the returned atoms to specific installed
 	packages.
 	"""
-expand_virtual.__doc__ = docstrings['expand_virtual']
+expand_virtual.__doc__ = docstrings["expand_virtual"]
 
 
 def vdb_path(_argv):
-	out = sys.stdout
-	out.write(os.path.join(portage.settings["EROOT"], portage.VDB_PATH) + "\n")
-	out.flush()
-	return os.EX_OK
+    out = sys.stdout
+    out.write(os.path.join(portage.settings["EROOT"], portage.VDB_PATH) + "\n")
+    out.flush()
+    return os.EX_OK
 
-docstrings['vdb_path'] = """
+
+docstrings[
+    "vdb_path"
+] = """
 	Returns the path used for the var(installed) package database for the
 	set environment/configuration options.
 	"""
-vdb_path.__doc__ = docstrings['vdb_path']
+vdb_path.__doc__ = docstrings["vdb_path"]
 
 
 def gentoo_mirrors(_argv):
-	print(portage.settings["GENTOO_MIRRORS"])
+    print(portage.settings["GENTOO_MIRRORS"])
+
 
-docstrings['gentoo_mirrors'] = """
+docstrings[
+    "gentoo_mirrors"
+] = """
 	Returns the mirrors set to use in the portage configuration.
 	"""
-gentoo_mirrors.__doc__ = docstrings['gentoo_mirrors']
+gentoo_mirrors.__doc__ = docstrings["gentoo_mirrors"]
 
 
 @uses_configroot
 @uses_eroot
 def repositories_configuration(argv):
-	if len(argv) < 1:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	sys.stdout.write(portage.db[argv[0]]["vartree"].settings.repositories.config_string())
-	sys.stdout.flush()
-
-docstrings['repositories_configuration'] = """<eroot>
+    if len(argv) < 1:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    sys.stdout.write(
+        portage.db[argv[0]]["vartree"].settings.repositories.config_string()
+    )
+    sys.stdout.flush()
+
+
+docstrings[
+    "repositories_configuration"
+] = """<eroot>
 	Returns the configuration of repositories.
 	"""
-repositories_configuration.__doc__ = docstrings['repositories_configuration']
+repositories_configuration.__doc__ = docstrings["repositories_configuration"]
 
 
 @uses_configroot
 @uses_eroot
 def repos_config(argv):
-	return repositories_configuration(argv)
+    return repositories_configuration(argv)
+
 
-docstrings['repos_config'] = """
+docstrings[
+    "repos_config"
+] = """
 	<eroot>
 	This is an alias for the repositories_configuration command.
 	"""
-repos_config.__doc__ = docstrings['repos_config']
+repos_config.__doc__ = docstrings["repos_config"]
 
 
 def portdir(_argv):
-	print("WARNING: 'portageq portdir' is deprecated. Use the get_repo_path "
-		"command instead. eg: "
-		"'portageq get_repo_path / gentoo' instead.", file=sys.stderr)
-	print(portage.settings["PORTDIR"])
-
-docstrings['portdir'] = """
+    print(
+        "WARNING: 'portageq portdir' is deprecated. Use the get_repo_path "
+        "command instead. eg: "
+        "'portageq get_repo_path / gentoo' instead.",
+        file=sys.stderr,
+    )
+    print(portage.settings["PORTDIR"])
+
+
+docstrings[
+    "portdir"
+] = """
 	Returns the PORTDIR path.
 	Deprecated in favor of get_repo_path command.
 	"""
-portdir.__doc__ = docstrings['portdir']
+portdir.__doc__ = docstrings["portdir"]
 
 
 def config_protect(_argv):
-	print(portage.settings["CONFIG_PROTECT"])
+    print(portage.settings["CONFIG_PROTECT"])
+
 
-docstrings['config_protect'] = """
+docstrings[
+    "config_protect"
+] = """
 	Returns the CONFIG_PROTECT paths.
 	"""
-config_protect.__doc__ = docstrings['config_protect']
+config_protect.__doc__ = docstrings["config_protect"]
 
 
 def config_protect_mask(_argv):
-	print(portage.settings["CONFIG_PROTECT_MASK"])
+    print(portage.settings["CONFIG_PROTECT_MASK"])
 
-docstrings['config_protect_mask'] = """
+
+docstrings[
+    "config_protect_mask"
+] = """
 	Returns the CONFIG_PROTECT_MASK paths.
 	"""
-config_protect_mask.__doc__ = docstrings['config_protect_mask']
+config_protect_mask.__doc__ = docstrings["config_protect_mask"]
 
-def portdir_overlay(_argv):
-	print("WARNING: 'portageq portdir_overlay' is deprecated. Use the get_repos"
-		" and get_repo_path commands or the repos_config command instead. eg: "
-		"'portageq repos_config /'", file=sys.stderr)
-	print(portage.settings["PORTDIR_OVERLAY"])
 
-docstrings['portdir_overlay'] = """
+def portdir_overlay(_argv):
+    print(
+        "WARNING: 'portageq portdir_overlay' is deprecated. Use the get_repos"
+        " and get_repo_path commands or the repos_config command instead. eg: "
+        "'portageq repos_config /'",
+        file=sys.stderr,
+    )
+    print(portage.settings["PORTDIR_OVERLAY"])
+
+
+docstrings[
+    "portdir_overlay"
+] = """
 	Returns the PORTDIR_OVERLAY path.
 	Deprecated in favor of get_repos & get_repo_path or repos_config commands.
 	"""
-portdir_overlay.__doc__ = docstrings['portdir_overlay']
+portdir_overlay.__doc__ = docstrings["portdir_overlay"]
 
 
 def pkgdir(_argv):
-	print(portage.settings["PKGDIR"])
+    print(portage.settings["PKGDIR"])
 
-docstrings['pkgdir'] = """
+
+docstrings[
+    "pkgdir"
+] = """
 	Returns the PKGDIR path.
 	"""
-pkgdir.__doc__ = docstrings['pkgdir']
+pkgdir.__doc__ = docstrings["pkgdir"]
 
 
 def distdir(_argv):
-	print(portage.settings["DISTDIR"])
+    print(portage.settings["DISTDIR"])
+
 
-docstrings['distdir'] = """
+docstrings[
+    "distdir"
+] = """
 	Returns the DISTDIR path.
 	"""
-distdir.__doc__ = docstrings['distdir']
+distdir.__doc__ = docstrings["distdir"]
 
 
 def colormap(_argv):
-	print(portage.output.colormap())
+    print(portage.output.colormap())
 
-docstrings['colormap'] = """
+
+docstrings[
+    "colormap"
+] = """
 	Display the color.map as environment variables.
 	"""
-colormap.__doc__ = docstrings['colormap']
+colormap.__doc__ = docstrings["colormap"]
 
 
 def envvar(argv):
-	verbose = "-v" in argv
-	if verbose:
-		argv.pop(argv.index("-v"))
+    verbose = "-v" in argv
+    if verbose:
+        argv.pop(argv.index("-v"))
+
+    if len(argv) == 0:
+        print("ERROR: insufficient parameters!")
+        return 2
 
-	if len(argv) == 0:
-		print("ERROR: insufficient parameters!")
-		return 2
+    exit_status = 0
 
-	exit_status = 0
+    for arg in argv:
+        if arg in ("PORTDIR", "PORTDIR_OVERLAY", "SYNC"):
+            print(
+                "WARNING: 'portageq envvar %s' is deprecated. Use any of "
+                "'get_repos, get_repo_path, repos_config' instead." % arg,
+                file=sys.stderr,
+            )
 
-	for arg in argv:
-		if arg in ("PORTDIR", "PORTDIR_OVERLAY", "SYNC"):
-			print("WARNING: 'portageq envvar %s' is deprecated. Use any of "
-				"'get_repos, get_repo_path, repos_config' instead."
-				% arg, file=sys.stderr)
+        value = portage.settings.get(arg)
+        if value is None:
+            value = ""
+            exit_status = 1
 
-		value = portage.settings.get(arg)
-		if value is None:
-			value = ""
-			exit_status = 1
+        if verbose:
+            print(arg + "=" + portage._shell_quote(value))
+        else:
+            print(value)
 
-		if verbose:
-			print(arg + "=" + portage._shell_quote(value))
-		else:
-			print(value)
+    return exit_status
 
-	return exit_status
 
-docstrings['envvar'] = """<variable>+
+docstrings[
+    "envvar"
+] = """<variable>+
 	Returns a specific environment variable as exists prior to ebuild.sh.
 	Similar to: emerge --verbose --info | egrep '^<variable>='
 	"""
-envvar.__doc__ = docstrings['envvar']
+envvar.__doc__ = docstrings["envvar"]
 
 
 @uses_configroot
 @uses_eroot
 def get_repos(argv):
-	if len(argv) < 1:
-		print("ERROR: insufficient parameters!")
-		return 2
-	print(" ".join(reversed(portage.db[argv[0]]["vartree"].settings.repositories.prepos_order)))
-
-docstrings['get_repos'] = """<eroot>
+    if len(argv) < 1:
+        print("ERROR: insufficient parameters!")
+        return 2
+    print(
+        " ".join(
+            reversed(portage.db[argv[0]]["vartree"].settings.repositories.prepos_order)
+        )
+    )
+
+
+docstrings[
+    "get_repos"
+] = """<eroot>
 	Returns all repos with names (repo_name file) argv[0] = $EROOT
 	"""
-get_repos.__doc__ = docstrings['get_repos']
+get_repos.__doc__ = docstrings["get_repos"]
 
 
 @uses_configroot
 @uses_eroot
 def master_repositories(argv):
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	for arg in argv[1:]:
-		if portage.dep._repo_name_re.match(arg) is None:
-			print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
-			return 2
-		try:
-			repo = portage.db[argv[0]]["vartree"].settings.repositories[arg]
-		except KeyError:
-			print("")
-			return 1
-		else:
-			print(" ".join(x.name for x in repo.masters))
-
-docstrings['master_repositories'] = """<eroot> <repo_id>+
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    for arg in argv[1:]:
+        if portage.dep._repo_name_re.match(arg) is None:
+            print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
+            return 2
+        try:
+            repo = portage.db[argv[0]]["vartree"].settings.repositories[arg]
+        except KeyError:
+            print("")
+            return 1
+        else:
+            print(" ".join(x.name for x in repo.masters))
+
+
+docstrings[
+    "master_repositories"
+] = """<eroot> <repo_id>+
 	Returns space-separated list of master repositories for specified repository.
 	"""
-master_repositories.__doc__ = docstrings['master_repositories']
+master_repositories.__doc__ = docstrings["master_repositories"]
 
 
 @uses_configroot
 @uses_eroot
 def master_repos(argv):
-	return master_repositories(argv)
+    return master_repositories(argv)
+
 
-docstrings['master_repos'] = """<eroot> <repo_id>+
+docstrings[
+    "master_repos"
+] = """<eroot> <repo_id>+
 	This is an alias for the master_repositories command.
 	"""
-master_repos.__doc__ = docstrings['master_repos']
+master_repos.__doc__ = docstrings["master_repos"]
 
 
 @uses_configroot
 @uses_eroot
 def get_repo_path(argv):
 
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	for arg in argv[1:]:
-		if portage.dep._repo_name_re.match(arg) is None:
-			print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
-			return 2
-		path = portage.db[argv[0]]["vartree"].settings.repositories.treemap.get(arg)
-		if path is None:
-			print("")
-			return 1
-		print(path)
-
-docstrings['get_repo_path'] = """<eroot> <repo_id>+
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    for arg in argv[1:]:
+        if portage.dep._repo_name_re.match(arg) is None:
+            print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
+            return 2
+        path = portage.db[argv[0]]["vartree"].settings.repositories.treemap.get(arg)
+        if path is None:
+            print("")
+            return 1
+        print(path)
+
+
+docstrings[
+    "get_repo_path"
+] = """<eroot> <repo_id>+
 	Returns the path to the repo named argv[1], argv[0] = $EROOT
 	"""
-get_repo_path.__doc__ = docstrings['get_repo_path']
+get_repo_path.__doc__ = docstrings["get_repo_path"]
 
 
 @uses_eroot
 def available_eclasses(argv):
-	if len(argv) < 2:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	for arg in argv[1:]:
-		if portage.dep._repo_name_re.match(arg) is None:
-			print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
-			return 2
-		try:
-			repo = portage.db[argv[0]]["vartree"].settings.repositories[arg]
-		except KeyError:
-			print("")
-			return 1
-		else:
-			print(" ".join(sorted(repo.eclass_db.eclasses)))
-
-docstrings['available_eclasses'] = """<eroot> <repo_id>+
+    if len(argv) < 2:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    for arg in argv[1:]:
+        if portage.dep._repo_name_re.match(arg) is None:
+            print("ERROR: invalid repository: %s" % arg, file=sys.stderr)
+            return 2
+        try:
+            repo = portage.db[argv[0]]["vartree"].settings.repositories[arg]
+        except KeyError:
+            print("")
+            return 1
+        else:
+            print(" ".join(sorted(repo.eclass_db.eclasses)))
+
+
+docstrings[
+    "available_eclasses"
+] = """<eroot> <repo_id>+
 	Returns space-separated list of available eclasses for specified repository.
 	"""
-available_eclasses.__doc__ = docstrings['available_eclasses']
+available_eclasses.__doc__ = docstrings["available_eclasses"]
 
 
 @uses_eroot
 def eclass_path(argv):
-	if len(argv) < 3:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	if portage.dep._repo_name_re.match(argv[1]) is None:
-		print("ERROR: invalid repository: %s" % argv[1], file=sys.stderr)
-		return 2
-	try:
-		repo = portage.db[argv[0]]["vartree"].settings.repositories[argv[1]]
-	except KeyError:
-		print("")
-		return 1
-	else:
-		retval = 0
-		for arg in argv[2:]:
-			try:
-				eclass = repo.eclass_db.eclasses[arg]
-			except KeyError:
-				print("")
-				retval = 1
-			else:
-				print(eclass.location)
-		return retval
-
-docstrings['eclass_path'] = """<eroot> <repo_id> <eclass>+
+    if len(argv) < 3:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    if portage.dep._repo_name_re.match(argv[1]) is None:
+        print("ERROR: invalid repository: %s" % argv[1], file=sys.stderr)
+        return 2
+    try:
+        repo = portage.db[argv[0]]["vartree"].settings.repositories[argv[1]]
+    except KeyError:
+        print("")
+        return 1
+    else:
+        retval = 0
+        for arg in argv[2:]:
+            try:
+                eclass = repo.eclass_db.eclasses[arg]
+            except KeyError:
+                print("")
+                retval = 1
+            else:
+                print(eclass.location)
+        return retval
+
+
+docstrings[
+    "eclass_path"
+] = """<eroot> <repo_id> <eclass>+
 	Returns the path to specified eclass for specified repository.
 	"""
-eclass_path.__doc__ = docstrings['eclass_path']
+eclass_path.__doc__ = docstrings["eclass_path"]
 
 
 @uses_eroot
 def license_path(argv):
-	if len(argv) < 3:
-		print("ERROR: insufficient parameters!", file=sys.stderr)
-		return 3
-	if portage.dep._repo_name_re.match(argv[1]) is None:
-		print("ERROR: invalid repository: %s" % argv[1], file=sys.stderr)
-		return 2
-	try:
-		repo = portage.db[argv[0]]["vartree"].settings.repositories[argv[1]]
-	except KeyError:
-		print("")
-		return 1
-	else:
-		retval = 0
-		for arg in argv[2:]:
-			eclass_path = ""
-			paths = reversed([os.path.join(x.location, 'licenses', arg) for x in list(repo.masters) + [repo]])
-			for path in paths:
-				if os.path.exists(path):
-					eclass_path = path
-					break
-			if eclass_path == "":
-				retval = 1
-			print(eclass_path)
-		return retval
-
-docstrings['license_path'] = """<eroot> <repo_id> <license>+
+    if len(argv) < 3:
+        print("ERROR: insufficient parameters!", file=sys.stderr)
+        return 3
+    if portage.dep._repo_name_re.match(argv[1]) is None:
+        print("ERROR: invalid repository: %s" % argv[1], file=sys.stderr)
+        return 2
+    try:
+        repo = portage.db[argv[0]]["vartree"].settings.repositories[argv[1]]
+    except KeyError:
+        print("")
+        return 1
+    else:
+        retval = 0
+        for arg in argv[2:]:
+            eclass_path = ""
+            paths = reversed(
+                [
+                    os.path.join(x.location, "licenses", arg)
+                    for x in list(repo.masters) + [repo]
+                ]
+            )
+            for path in paths:
+                if os.path.exists(path):
+                    eclass_path = path
+                    break
+            if eclass_path == "":
+                retval = 1
+            print(eclass_path)
+        return retval
+
+
+docstrings[
+    "license_path"
+] = """<eroot> <repo_id> <license>+
 	Returns the path to specified license for specified repository.
 	"""
-license_path.__doc__ = docstrings['license_path']
+license_path.__doc__ = docstrings["license_path"]
 
 
 @uses_eroot
 def list_preserved_libs(argv):
-	if len(argv) != 1:
-		print("ERROR: wrong number of arguments")
-		return 2
-	mylibs = portage.db[argv[0]]["vartree"].dbapi._plib_registry.getPreservedLibs()
-	rValue = 1
-	msg = []
-	for cpv in sorted(mylibs):
-		msg.append(cpv)
-		for path in mylibs[cpv]:
-			msg.append(' ' + path)
-			rValue = 0
-		msg.append('\n')
-	writemsg_stdout(''.join(msg), noiselevel=-1)
-	return rValue
-
-docstrings['list_preserved_libs'] = """<eroot>
+    if len(argv) != 1:
+        print("ERROR: wrong number of arguments")
+        return 2
+    mylibs = portage.db[argv[0]]["vartree"].dbapi._plib_registry.getPreservedLibs()
+    rValue = 1
+    msg = []
+    for cpv in sorted(mylibs):
+        msg.append(cpv)
+        for path in mylibs[cpv]:
+            msg.append(" " + path)
+            rValue = 0
+        msg.append("\n")
+    writemsg_stdout("".join(msg), noiselevel=-1)
+    return rValue
+
+
+docstrings[
+    "list_preserved_libs"
+] = """<eroot>
 	Print a list of libraries preserved during a package update in the form
 	package: path. Returns 1 if no preserved libraries could be found,
 	0 otherwise.
 	"""
-list_preserved_libs.__doc__ = docstrings['list_preserved_libs']
+list_preserved_libs.__doc__ = docstrings["list_preserved_libs"]
 
 
 class MaintainerEmailMatcher:
-	def __init__(self, maintainer_emails):
-		self._re = re.compile("^(%s)$" % "|".join(maintainer_emails), re.I)
-
-	def __call__(self, metadata_xml):
-		match = False
-		matcher = self._re.match
-		for x in metadata_xml.maintainers():
-			if x.email is not None and matcher(x.email) is not None:
-				match = True
-				break
-		return match
+    def __init__(self, maintainer_emails):
+        self._re = re.compile("^(%s)$" % "|".join(maintainer_emails), re.I)
+
+    def __call__(self, metadata_xml):
+        match = False
+        matcher = self._re.match
+        for x in metadata_xml.maintainers():
+            if x.email is not None and matcher(x.email) is not None:
+                match = True
+                break
+        return match
+
 
 # Match if metadata.xml contains no maintainer (orphaned package)
 def match_orphaned(metadata_xml):
-	if not metadata_xml.maintainers():
-		return True
-	else:
-		return False
+    if not metadata_xml.maintainers():
+        return True
+    else:
+        return False
+
 
 def pquery(parser, opts, args):
-	portdb = portage.db[portage.root]['porttree'].dbapi
-	root_config = RootConfig(portdb.settings,
-		portage.db[portage.root], None)
-
-	def _pkg(cpv, repo_name):
-		try:
-			metadata = dict(zip(
-				Package.metadata_keys,
-				portdb.aux_get(cpv,
-				Package.metadata_keys,
-				myrepo=repo_name)))
-		except KeyError:
-			raise portage.exception.PackageNotFound(cpv)
-		return Package(built=False, cpv=cpv,
-			installed=False, metadata=metadata,
-			root_config=root_config,
-			type_name="ebuild")
-
-	need_metadata = False
-	atoms = []
-	for arg in args:
-		if "/" not in arg.split(":")[0]:
-			atom = insert_category_into_atom(arg, '*')
-			if atom is None:
-				writemsg("ERROR: Invalid atom: '%s'\n" % arg,
-					noiselevel=-1)
-				return 2
-		else:
-			atom = arg
-
-		try:
-			atom = portage.dep.Atom(atom, allow_wildcard=True, allow_repo=True)
-		except portage.exception.InvalidAtom:
-			writemsg("ERROR: Invalid atom: '%s'\n" % arg,
-				noiselevel=-1)
-			return 2
-
-		if atom.slot is not None:
-			need_metadata = True
-
-		atoms.append(atom)
-
-	if "*/*" in atoms:
-		del atoms[:]
-		need_metadata = False
-
-	if not opts.no_filters:
-		need_metadata = True
-
-	xml_matchers = []
-	if opts.maintainer_email:
-		maintainer_emails = []
-		for x in opts.maintainer_email:
-			maintainer_emails.extend(x.split(","))
-		if opts.no_regex: # Escape regex-special characters for an exact match
-			maintainer_emails = [re.escape(x) for x in maintainer_emails]
-		xml_matchers.append(MaintainerEmailMatcher(maintainer_emails))
-	if opts.orphaned:
-		xml_matchers.append(match_orphaned)
-
-	if opts.repo is not None:
-		repos = [portdb.repositories[opts.repo]]
-	else:
-		repos = list(portdb.repositories)
-
-	if not atoms:
-		names = None
-		categories = list(portdb.categories)
-	else:
-		category_wildcard = False
-		name_wildcard = False
-		categories = []
-		names = []
-		for atom in atoms:
-			category, name = portage.catsplit(atom.cp)
-			categories.append(category)
-			names.append(name)
-			if "*" in category:
-				category_wildcard = True
-			if "*" in name:
-				name_wildcard = True
-
-		if category_wildcard:
-			categories = list(portdb.categories)
-		else:
-			categories = list(set(categories))
-
-		if name_wildcard:
-			names = None
-		else:
-			names = sorted(set(names))
-
-	no_version = opts.no_version
-	categories.sort()
-
-	for category in categories:
-		if names is None:
-			cp_list = portdb.cp_all(categories=(category,))
-		else:
-			cp_list = [category + "/" + name for name in names]
-		for cp in cp_list:
-			matches = []
-			for repo in repos:
-				match = True
-				if xml_matchers:
-					metadata_xml_path = os.path.join(
-						repo.location, cp, 'metadata.xml')
-					try:
-						metadata_xml = MetaDataXML(metadata_xml_path, None)
-					except (EnvironmentError, SyntaxError):
-						match = False
-					else:
-						for matcher in xml_matchers:
-							if not matcher(metadata_xml):
-								match = False
-								break
-				if not match:
-					continue
-				cpv_list = portdb.cp_list(cp, mytree=[repo.location])
-				if atoms:
-					for cpv in cpv_list:
-						pkg = None
-						for atom in atoms:
-							if atom.repo is not None and \
-								atom.repo != repo.name:
-								continue
-							if not portage.match_from_list(atom, [cpv]):
-								continue
-							if need_metadata:
-								if pkg is None:
-									try:
-										pkg = _pkg(cpv, repo.name)
-									except portage.exception.PackageNotFound:
-										continue
-
-								if not (opts.no_filters or pkg.visible):
-									continue
-								if not portage.match_from_list(atom, [pkg]):
-									continue
-							matches.append(cpv)
-							break
-						if no_version and matches:
-							break
-				elif opts.no_filters:
-					matches.extend(cpv_list)
-				else:
-					for cpv in cpv_list:
-						try:
-							pkg = _pkg(cpv, repo.name)
-						except portage.exception.PackageNotFound:
-							continue
-						else:
-							if pkg.visible:
-								matches.append(cpv)
-								if no_version:
-									break
-
-				if no_version and matches:
-					break
-
-			if not matches:
-				continue
-
-			if no_version:
-				writemsg_stdout("%s\n" % (cp,), noiselevel=-1)
-			else:
-				matches = list(set(matches))
-				portdb._cpv_sort_ascending(matches)
-				for cpv in matches:
-					writemsg_stdout("%s\n" % (cpv,), noiselevel=-1)
-
-	return os.EX_OK
-
-docstrings['pquery'] = """[options] [atom]+
+    portdb = portage.db[portage.root]["porttree"].dbapi
+    root_config = RootConfig(portdb.settings, portage.db[portage.root], None)
+
+    def _pkg(cpv, repo_name):
+        try:
+            metadata = dict(
+                zip(
+                    Package.metadata_keys,
+                    portdb.aux_get(cpv, Package.metadata_keys, myrepo=repo_name),
+                )
+            )
+        except KeyError:
+            raise portage.exception.PackageNotFound(cpv)
+        return Package(
+            built=False,
+            cpv=cpv,
+            installed=False,
+            metadata=metadata,
+            root_config=root_config,
+            type_name="ebuild",
+        )
+
+    need_metadata = False
+    atoms = []
+    for arg in args:
+        if "/" not in arg.split(":")[0]:
+            atom = insert_category_into_atom(arg, "*")
+            if atom is None:
+                writemsg("ERROR: Invalid atom: '%s'\n" % arg, noiselevel=-1)
+                return 2
+        else:
+            atom = arg
+
+        try:
+            atom = portage.dep.Atom(atom, allow_wildcard=True, allow_repo=True)
+        except portage.exception.InvalidAtom:
+            writemsg("ERROR: Invalid atom: '%s'\n" % arg, noiselevel=-1)
+            return 2
+
+        if atom.slot is not None:
+            need_metadata = True
+
+        atoms.append(atom)
+
+    if "*/*" in atoms:
+        del atoms[:]
+        need_metadata = False
+
+    if not opts.no_filters:
+        need_metadata = True
+
+    xml_matchers = []
+    if opts.maintainer_email:
+        maintainer_emails = []
+        for x in opts.maintainer_email:
+            maintainer_emails.extend(x.split(","))
+        if opts.no_regex:  # Escape regex-special characters for an exact match
+            maintainer_emails = [re.escape(x) for x in maintainer_emails]
+        xml_matchers.append(MaintainerEmailMatcher(maintainer_emails))
+    if opts.orphaned:
+        xml_matchers.append(match_orphaned)
+
+    if opts.repo is not None:
+        repos = [portdb.repositories[opts.repo]]
+    else:
+        repos = list(portdb.repositories)
+
+    if not atoms:
+        names = None
+        categories = list(portdb.categories)
+    else:
+        category_wildcard = False
+        name_wildcard = False
+        categories = []
+        names = []
+        for atom in atoms:
+            category, name = portage.catsplit(atom.cp)
+            categories.append(category)
+            names.append(name)
+            if "*" in category:
+                category_wildcard = True
+            if "*" in name:
+                name_wildcard = True
+
+        if category_wildcard:
+            categories = list(portdb.categories)
+        else:
+            categories = list(set(categories))
+
+        if name_wildcard:
+            names = None
+        else:
+            names = sorted(set(names))
+
+    no_version = opts.no_version
+    categories.sort()
+
+    for category in categories:
+        if names is None:
+            cp_list = portdb.cp_all(categories=(category,))
+        else:
+            cp_list = [category + "/" + name for name in names]
+        for cp in cp_list:
+            matches = []
+            for repo in repos:
+                match = True
+                if xml_matchers:
+                    metadata_xml_path = os.path.join(repo.location, cp, "metadata.xml")
+                    try:
+                        metadata_xml = MetaDataXML(metadata_xml_path, None)
+                    except (EnvironmentError, SyntaxError):
+                        match = False
+                    else:
+                        for matcher in xml_matchers:
+                            if not matcher(metadata_xml):
+                                match = False
+                                break
+                if not match:
+                    continue
+                cpv_list = portdb.cp_list(cp, mytree=[repo.location])
+                if atoms:
+                    for cpv in cpv_list:
+                        pkg = None
+                        for atom in atoms:
+                            if atom.repo is not None and atom.repo != repo.name:
+                                continue
+                            if not portage.match_from_list(atom, [cpv]):
+                                continue
+                            if need_metadata:
+                                if pkg is None:
+                                    try:
+                                        pkg = _pkg(cpv, repo.name)
+                                    except portage.exception.PackageNotFound:
+                                        continue
+
+                                if not (opts.no_filters or pkg.visible):
+                                    continue
+                                if not portage.match_from_list(atom, [pkg]):
+                                    continue
+                            matches.append(cpv)
+                            break
+                        if no_version and matches:
+                            break
+                elif opts.no_filters:
+                    matches.extend(cpv_list)
+                else:
+                    for cpv in cpv_list:
+                        try:
+                            pkg = _pkg(cpv, repo.name)
+                        except portage.exception.PackageNotFound:
+                            continue
+                        else:
+                            if pkg.visible:
+                                matches.append(cpv)
+                                if no_version:
+                                    break
+
+                if no_version and matches:
+                    break
+
+            if not matches:
+                continue
+
+            if no_version:
+                writemsg_stdout("%s\n" % (cp,), noiselevel=-1)
+            else:
+                matches = list(set(matches))
+                portdb._cpv_sort_ascending(matches)
+                for cpv in matches:
+                    writemsg_stdout("%s\n" % (cpv,), noiselevel=-1)
+
+    return os.EX_OK
+
+
+docstrings[
+    "pquery"
+] = """[options] [atom]+
 	Emulates a subset of Pkgcore's pquery tool.
 	"""
-pquery.__doc__ = docstrings['pquery']
+pquery.__doc__ = docstrings["pquery"]
 
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #
 # DO NOT CHANGE CODE BEYOND THIS POINT - IT'S NOT NEEDED!
 #
 
-non_commands = frozenset(['elog', 'eval_atom_use', 'exithandler', 'match_orphaned', 'main', 'usage', 'uses_eroot'])
-commands = sorted(k for k, v in globals().items() \
-	if k not in non_commands and isinstance(v, types.FunctionType) and v.__module__ == "__main__")
+non_commands = frozenset(
+    [
+        "elog",
+        "eval_atom_use",
+        "exithandler",
+        "match_orphaned",
+        "main",
+        "usage",
+        "uses_eroot",
+    ]
+)
+commands = sorted(
+    k
+    for k, v in globals().items()
+    if k not in non_commands
+    and isinstance(v, types.FunctionType)
+    and v.__module__ == "__main__"
+)
 
 
 def add_pquery_arguments(parser):
-	pquery_option_groups = (
-		(
-			'Repository matching options',
-			(
-				{
-					"longopt": "--no-filters",
-					"action": "store_true",
-					"help": "no visibility filters (ACCEPT_KEYWORDS, package masking, etc)"
-				},
-				{
-					"longopt": "--repo",
-					"help": "repository to use (all repositories are used by default)"
-				},
-			)
-		),
-		(
-			'Package matching options',
-			(
-				{
-					"longopt": "--maintainer-email",
-					"action": "append",
-					"help": "comma-separated list of maintainer email regexes to search for"
-				},
-				{
-					"longopt": "--no-regex",
-					"action": "store_true",
-					"help": "Use exact matching instead of regex matching for --maintainer-email"
-				},
-				{
-					"longopt": "--orphaned",
-					"action": "store_true",
-					"help": "match only orphaned (maintainer-needed) packages"
-				}
-			)
-		),
-		(
-			'Output formatting',
-			(
-				{
-					"shortopt": "-n",
-					"longopt": "--no-version",
-					"action": "store_true",
-					"help": "collapse multiple matching versions together"
-				},
-			)
-		),
-	)
-
-	for group_title, opt_data in pquery_option_groups:
-		arg_group = parser.add_argument_group(group_title)
-		for opt_info in opt_data:
-			pargs = []
-			try:
-				pargs.append(opt_info["shortopt"])
-			except KeyError:
-				pass
-			try:
-				pargs.append(opt_info["longopt"])
-			except KeyError:
-				pass
-
-			kwargs = {}
-			try:
-				kwargs["action"] = opt_info["action"]
-			except KeyError:
-				pass
-			try:
-				kwargs["help"] = opt_info["help"]
-			except KeyError:
-				pass
-			arg_group.add_argument(*pargs, **kwargs)
+    pquery_option_groups = (
+        (
+            "Repository matching options",
+            (
+                {
+                    "longopt": "--no-filters",
+                    "action": "store_true",
+                    "help": "no visibility filters (ACCEPT_KEYWORDS, package masking, etc)",
+                },
+                {
+                    "longopt": "--repo",
+                    "help": "repository to use (all repositories are used by default)",
+                },
+            ),
+        ),
+        (
+            "Package matching options",
+            (
+                {
+                    "longopt": "--maintainer-email",
+                    "action": "append",
+                    "help": "comma-separated list of maintainer email regexes to search for",
+                },
+                {
+                    "longopt": "--no-regex",
+                    "action": "store_true",
+                    "help": "Use exact matching instead of regex matching for --maintainer-email",
+                },
+                {
+                    "longopt": "--orphaned",
+                    "action": "store_true",
+                    "help": "match only orphaned (maintainer-needed) packages",
+                },
+            ),
+        ),
+        (
+            "Output formatting",
+            (
+                {
+                    "shortopt": "-n",
+                    "longopt": "--no-version",
+                    "action": "store_true",
+                    "help": "collapse multiple matching versions together",
+                },
+            ),
+        ),
+    )
+
+    for group_title, opt_data in pquery_option_groups:
+        arg_group = parser.add_argument_group(group_title)
+        for opt_info in opt_data:
+            pargs = []
+            try:
+                pargs.append(opt_info["shortopt"])
+            except KeyError:
+                pass
+            try:
+                pargs.append(opt_info["longopt"])
+            except KeyError:
+                pass
+
+            kwargs = {}
+            try:
+                kwargs["action"] = opt_info["action"]
+            except KeyError:
+                pass
+            try:
+                kwargs["help"] = opt_info["help"]
+            except KeyError:
+                pass
+            arg_group.add_argument(*pargs, **kwargs)
 
 
 def usage(argv):
-	print(">>> Portage information query tool")
-	print(">>> %s" % portage.VERSION)
-	print(">>> Usage: portageq <command> [<option> ...]")
-	print("")
-	print("Available commands:")
-
-	#
-	# Show our commands -- we do this by scanning the functions in this
-	# file, and formatting each functions documentation.
-	#
-	help_mode = '--help' in argv
-	for name in commands:
-		doc = docstrings.get(name)
-		if doc == None:
-			print("   " + name)
-			print("      MISSING DOCUMENTATION!")
-			print("")
-			continue
-
-		lines = doc.lstrip("\n").split("\n")
-		print("   " + name + " " + lines[0].strip())
-		if len(argv) > 1:
-			if not help_mode:
-				lines = lines[:-1]
-			for line in lines[1:]:
-				print("      " + line.strip())
-
-	print()
-	print('Pkgcore pquery compatible options:')
-	print()
-	parser = argparse.ArgumentParser(add_help=False,
-		usage='portageq pquery [options] [atom ...]')
-	add_pquery_arguments(parser)
-	parser.print_help()
-
-	if len(argv) == 1:
-		print("\nRun portageq with --help for info")
+    print(">>> Portage information query tool")
+    print(">>> %s" % portage.VERSION)
+    print(">>> Usage: portageq <command> [<option> ...]")
+    print("")
+    print("Available commands:")
+
+    #
+    # Show our commands -- we do this by scanning the functions in this
+    # file, and formatting each functions documentation.
+    #
+    help_mode = "--help" in argv
+    for name in commands:
+        doc = docstrings.get(name)
+        if doc == None:
+            print("   " + name)
+            print("      MISSING DOCUMENTATION!")
+            print("")
+            continue
+
+        lines = doc.lstrip("\n").split("\n")
+        print("   " + name + " " + lines[0].strip())
+        if len(argv) > 1:
+            if not help_mode:
+                lines = lines[:-1]
+            for line in lines[1:]:
+                print("      " + line.strip())
+
+    print()
+    print("Pkgcore pquery compatible options:")
+    print()
+    parser = argparse.ArgumentParser(
+        add_help=False, usage="portageq pquery [options] [atom ...]"
+    )
+    add_pquery_arguments(parser)
+    parser.print_help()
+
+    if len(argv) == 1:
+        print("\nRun portageq with --help for info")
+
 
 atom_validate_strict = "EBUILD_PHASE" in os.environ
 eapi = None
 if atom_validate_strict:
-	eapi = os.environ.get('EAPI')
+    eapi = os.environ.get("EAPI")
 
-	def elog(elog_funcname, lines):
-		cmd = "source '%s/isolated-functions.sh' ; " % \
-			os.environ["PORTAGE_BIN_PATH"]
-		for line in lines:
-			cmd += "%s %s ; " % (elog_funcname, portage._shell_quote(line))
-		subprocess.call([portage.const.BASH_BINARY, "-c", cmd])
+    def elog(elog_funcname, lines):
+        cmd = "source '%s/isolated-functions.sh' ; " % os.environ["PORTAGE_BIN_PATH"]
+        for line in lines:
+            cmd += "%s %s ; " % (elog_funcname, portage._shell_quote(line))
+        subprocess.call([portage.const.BASH_BINARY, "-c", cmd])
 
 else:
-	def elog(elog_funcname, lines):
-		pass
+
+    def elog(elog_funcname, lines):
+        pass
+
 
 def main(argv):
 
-	argv = portage._decode_argv(argv)
-
-	nocolor = os.environ.get('NOCOLOR')
-	if nocolor in ('yes', 'true'):
-		portage.output.nocolor()
-
-	parser = argparse.ArgumentParser(add_help=False)
-
-	# used by envvar
-	parser.add_argument("-v", dest="verbose", action="store_true")
-
-	actions = parser.add_argument_group('Actions')
-	actions.add_argument("-h", "--help", action="store_true")
-	actions.add_argument("--version", action="store_true")
-
-	add_pquery_arguments(parser)
-
-	opts, args = parser.parse_known_args(argv[1:])
-
-	if opts.help:
-		usage(argv)
-		return os.EX_OK
-	elif opts.version:
-		print("Portage", portage.VERSION)
-		return os.EX_OK
-
-	cmd = None
-	if args and args[0] in commands:
-		cmd = args[0]
-
-	if cmd == 'pquery':
-		cmd = None
-		args = args[1:]
-
-	if cmd is None:
-		return pquery(parser, opts, args)
-
-	if opts.verbose:
-		# used by envvar
-		args.append("-v")
-
-	argv = argv[:1] + args
-
-	if len(argv) < 2:
-		usage(argv)
-		sys.exit(os.EX_USAGE)
-
-	function = globals()[cmd]
-	uses_eroot = getattr(function, "uses_eroot", False) and len(argv) > 2
-	if uses_eroot:
-		if not os.path.isdir(argv[2]):
-			sys.stderr.write("Not a directory: '%s'\n" % argv[2])
-			sys.stderr.write("Run portageq with --help for info\n")
-			sys.stderr.flush()
-			sys.exit(os.EX_USAGE)
-		# Calculate EPREFIX and ROOT that will be used to construct
-		# portage.settings later. It's tempting to use
-		# portage.settings["EPREFIX"] here, but that would force
-		# instantiation of portage.settings, which we don't want to do
-		# until after we've calculated ROOT (see bug #529200).
-		eprefix = portage.data._target_eprefix()
-		eroot = portage.util.normalize_path(argv[2])
-
-		if eprefix:
-			if not eroot.endswith(eprefix):
-				sys.stderr.write("ERROR: This version of portageq"
-						 " only supports <eroot>s ending in"
-						 " '%s'. The provided <eroot>, '%s',"
-						 " doesn't.\n" % (eprefix, eroot))
-				sys.stderr.flush()
-				sys.exit(os.EX_USAGE)
-			root = eroot[:1 - len(eprefix)]
-		else:
-			root = eroot
-
-		os.environ["ROOT"] = root
-
-		if getattr(function, "uses_configroot", False):
-			os.environ["PORTAGE_CONFIGROOT"] = eroot
-			# Disable RepoConfigLoader location validation, allowing raw
-			# configuration to pass through, since repo locations are not
-			# necessarily expected to exist if the configuration comes
-			# from a chroot.
-			portage._sync_mode = True
-
-	args = argv[2:]
-
-	try:
-		if uses_eroot:
-			args[0] = portage.settings['EROOT']
-		retval = function(args)
-		if retval:
-			sys.exit(retval)
-	except portage.exception.PermissionDenied as e:
-		sys.stderr.write("Permission denied: '%s'\n" % str(e))
-		sys.exit(e.errno)
-	except portage.exception.ParseError as e:
-		sys.stderr.write("%s\n" % str(e))
-		sys.exit(1)
-	except portage.exception.AmbiguousPackageName as e:
-		# Multiple matches thrown from cpv_expand
-		pkgs = e.args[0]
-		# An error has occurred so we writemsg to stderr and exit nonzero.
-		portage.writemsg("You specified an unqualified atom that matched multiple packages:\n", noiselevel=-1)
-		for pkg in pkgs:
-			portage.writemsg("* %s\n" % pkg, noiselevel=-1)
-		portage.writemsg("\nPlease use a more specific atom.\n", noiselevel=-1)
-		sys.exit(1)
-
-if __name__ == '__main__':
-	try:
-		sys.exit(main(sys.argv))
-	finally:
-		global_event_loop().close()
-
-#-----------------------------------------------------------------------------
+    argv = portage._decode_argv(argv)
+
+    nocolor = os.environ.get("NOCOLOR")
+    if nocolor in ("yes", "true"):
+        portage.output.nocolor()
+
+    parser = argparse.ArgumentParser(add_help=False)
+
+    # used by envvar
+    parser.add_argument("-v", dest="verbose", action="store_true")
+
+    actions = parser.add_argument_group("Actions")
+    actions.add_argument("-h", "--help", action="store_true")
+    actions.add_argument("--version", action="store_true")
+
+    add_pquery_arguments(parser)
+
+    opts, args = parser.parse_known_args(argv[1:])
+
+    if opts.help:
+        usage(argv)
+        return os.EX_OK
+    elif opts.version:
+        print("Portage", portage.VERSION)
+        return os.EX_OK
+
+    cmd = None
+    if args and args[0] in commands:
+        cmd = args[0]
+
+    if cmd == "pquery":
+        cmd = None
+        args = args[1:]
+
+    if cmd is None:
+        return pquery(parser, opts, args)
+
+    if opts.verbose:
+        # used by envvar
+        args.append("-v")
+
+    argv = argv[:1] + args
+
+    if len(argv) < 2:
+        usage(argv)
+        sys.exit(os.EX_USAGE)
+
+    function = globals()[cmd]
+    uses_eroot = getattr(function, "uses_eroot", False) and len(argv) > 2
+    if uses_eroot:
+        if not os.path.isdir(argv[2]):
+            sys.stderr.write("Not a directory: '%s'\n" % argv[2])
+            sys.stderr.write("Run portageq with --help for info\n")
+            sys.stderr.flush()
+            sys.exit(os.EX_USAGE)
+        # Calculate EPREFIX and ROOT that will be used to construct
+        # portage.settings later. It's tempting to use
+        # portage.settings["EPREFIX"] here, but that would force
+        # instantiation of portage.settings, which we don't want to do
+        # until after we've calculated ROOT (see bug #529200).
+        eprefix = portage.data._target_eprefix()
+        eroot = portage.util.normalize_path(argv[2])
+
+        if eprefix:
+            if not eroot.endswith(eprefix):
+                sys.stderr.write(
+                    "ERROR: This version of portageq"
+                    " only supports <eroot>s ending in"
+                    " '%s'. The provided <eroot>, '%s',"
+                    " doesn't.\n" % (eprefix, eroot)
+                )
+                sys.stderr.flush()
+                sys.exit(os.EX_USAGE)
+            root = eroot[: 1 - len(eprefix)]
+        else:
+            root = eroot
+
+        os.environ["ROOT"] = root
+
+        if getattr(function, "uses_configroot", False):
+            os.environ["PORTAGE_CONFIGROOT"] = eroot
+            # Disable RepoConfigLoader location validation, allowing raw
+            # configuration to pass through, since repo locations are not
+            # necessarily expected to exist if the configuration comes
+            # from a chroot.
+            portage._sync_mode = True
+
+    args = argv[2:]
+
+    try:
+        if uses_eroot:
+            args[0] = portage.settings["EROOT"]
+        retval = function(args)
+        if retval:
+            sys.exit(retval)
+    except portage.exception.PermissionDenied as e:
+        sys.stderr.write("Permission denied: '%s'\n" % str(e))
+        sys.exit(e.errno)
+    except portage.exception.ParseError as e:
+        sys.stderr.write("%s\n" % str(e))
+        sys.exit(1)
+    except portage.exception.AmbiguousPackageName as e:
+        # Multiple matches thrown from cpv_expand
+        pkgs = e.args[0]
+        # An error has occurred so we writemsg to stderr and exit nonzero.
+        portage.writemsg(
+            "You specified an unqualified atom that matched multiple packages:\n",
+            noiselevel=-1,
+        )
+        for pkg in pkgs:
+            portage.writemsg("* %s\n" % pkg, noiselevel=-1)
+        portage.writemsg("\nPlease use a more specific atom.\n", noiselevel=-1)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main(sys.argv))
+    finally:
+        global_event_loop().close()
+
+# -----------------------------------------------------------------------------

diff --git a/bin/quickpkg b/bin/quickpkg
index 7a3304ca4..a4a3584da 100755
--- a/bin/quickpkg
+++ b/bin/quickpkg
@@ -10,19 +10,32 @@ import subprocess
 import sys
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage import xpak, gpkg
 from portage.const import SUPPORTED_GENTOO_BINPKG_FORMATS
 from portage.dbapi.dep_expand import dep_expand
 from portage.dep import Atom, use_reduce
-from portage.exception import (AmbiguousPackageName, InvalidAtom, InvalidData,
-	InvalidBinaryPackageFormat, InvalidDependString, PackageSetNotFound,
-	PermissionDenied)
+from portage.exception import (
+    AmbiguousPackageName,
+    InvalidAtom,
+    InvalidData,
+    InvalidBinaryPackageFormat,
+    InvalidDependString,
+    PackageSetNotFound,
+    PermissionDenied,
+)
 from portage.util import ensure_dirs, shlex_split, varexpand, _xattr
+
 xattr = _xattr.xattr
 from portage._sets import load_default_config, SETPREFIX
 from portage.process import find_binary
@@ -32,358 +45,391 @@ from portage.gpg import GPG
 
 
 def quickpkg_atom(options, infos, arg, eout):
-	settings = portage.settings
-	eroot = portage.settings['EROOT']
-	trees = portage.db[eroot]
-	vartree = trees["vartree"]
-	vardb = vartree.dbapi
-	bintree = trees["bintree"]
-
-	include_config = options.include_config == "y"
-	include_unmodified_config = options.include_unmodified_config == "y"
-	fix_metadata_keys = ["PF", "CATEGORY"]
-
-	try:
-		atom = dep_expand(arg, mydb=vardb, settings=vartree.settings)
-	except AmbiguousPackageName as e:
-		# Multiple matches thrown from cpv_expand
-		eout.eerror("Please use a more specific atom: %s" % \
-			" ".join(e.args[0]))
-		del e
-		infos["missing"].append(arg)
-		return 1
-	except (InvalidAtom, InvalidData):
-		eout.eerror("Invalid atom: %s" % (arg,))
-		infos["missing"].append(arg)
-		return 1
-	if atom[:1] == '=' and arg[:1] != '=':
-		# dep_expand() allows missing '=' but it's really invalid
-		eout.eerror("Invalid atom: %s" % (arg,))
-		infos["missing"].append(arg)
-		return 1
-
-	matches = vardb.match(atom)
-	pkgs_for_arg = 0
-	retval = 0
-	for cpv in matches:
-		excluded_config_files = []
-		dblnk = vardb._dblink(cpv)
-		have_lock = False
-
-		if "__PORTAGE_INHERIT_VARDB_LOCK" not in settings:
-			try:
-				dblnk.lockdb()
-				have_lock = True
-			except PermissionDenied:
-				pass
-
-		try:
-			if not dblnk.exists():
-				# unmerged by a concurrent process
-				continue
-			iuse, use, restrict = vardb.aux_get(cpv,
-				["IUSE","USE","RESTRICT"])
-			iuse = [ x.lstrip("+-") for x in iuse.split() ]
-			use = use.split()
-			try:
-				restrict = use_reduce(restrict, uselist=use, flat=True)
-			except InvalidDependString as e:
-				eout.eerror("Invalid RESTRICT metadata " + \
-					"for '%s': %s; skipping" % (cpv, str(e)))
-				del e
-				continue
-			if "bindist" in iuse and "bindist" not in use:
-				eout.ewarn("%s: package was emerged with USE=-bindist!" % cpv)
-				eout.ewarn("%s: it might not be legal to redistribute this." % cpv)
-			elif "bindist" in restrict:
-				eout.ewarn("%s: package has RESTRICT=bindist!" % cpv)
-				eout.ewarn("%s: it might not be legal to redistribute this." % cpv)
-			eout.ebegin("Building package for %s" % cpv)
-			pkgs_for_arg += 1
-			existing_metadata = dict(zip(fix_metadata_keys,
-				vardb.aux_get(cpv, fix_metadata_keys)))
-			category, pf = portage.catsplit(cpv)
-			required_metadata = {}
-			required_metadata["CATEGORY"] = category
-			required_metadata["PF"] = pf
-			update_metadata = {}
-			for k, v in required_metadata.items():
-				if v != existing_metadata[k]:
-					update_metadata[k] = v
-			if update_metadata:
-				vardb.aux_update(cpv, update_metadata)
-
-			binpkg_format = settings.get("BINPKG_FORMAT", SUPPORTED_GENTOO_BINPKG_FORMATS[0])
-			if binpkg_format == "xpak":
-				xpdata = xpak.xpak(dblnk.dbdir)
-				binpkg_tmpfile = os.path.join(bintree.pkgdir,
-					cpv + ".tbz2." + str(portage.getpid()))
-				ensure_dirs(os.path.dirname(binpkg_tmpfile))
-				binpkg_compression = settings.get("BINPKG_COMPRESS", "bzip2")
-				try:
-					compression = _compressors[binpkg_compression]
-				except KeyError as e:
-					if binpkg_compression:
-						eout.eerror("Invalid or unsupported compression method: %s" % e.args[0])
-						return 1
-					# Empty BINPKG_COMPRESS disables compression.
-					binpkg_compression = 'none'
-					compression = {
-						'compress': 'cat',
-						'package': 'sys-apps/coreutils',
-					}
-				try:
-					compression_binary = shlex_split(varexpand(compression["compress"], mydict=settings))[0]
-				except IndexError as e:
-					eout.eerror("Invalid or unsupported compression method: %s" % e.args[0])
-					return 1
-				if find_binary(compression_binary) is None:
-					missing_package = compression["package"]
-					eout.eerror("File compression unsupported %s. Missing package: %s" % (binpkg_compression, missing_package))
-					return 1
-				cmd = [varexpand(x, mydict=settings) for x in shlex_split(compression["compress"])]
-				# Filter empty elements that make Popen fail
-				cmd = [x for x in cmd if x != ""]
-				with open(binpkg_tmpfile, "wb") as fobj:
-					proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=fobj)
-					excluded_config_files = dblnk.quickpkg(proc.stdin,
-						include_config=include_config,
-						include_unmodified_config=include_unmodified_config)
-					proc.stdin.close()
-					if proc.wait() != os.EX_OK:
-						eout.eend(1)
-						eout.eerror("Compressor failed for package %s" % cpv)
-						retval |= 1
-						try:
-							os.unlink(binpkg_tmpfile)
-						except OSError as e:
-							if e.errno not in (errno.ENOENT, errno.ESTALE):
-								raise
-						continue
-				xpak.tbz2(binpkg_tmpfile).recompose_mem(xpdata)
-			elif binpkg_format == "gpkg":
-				metadata = gpkg.gpkg(settings)._generate_metadata_from_dir(dblnk.dbdir)
-				binpkg_tmpfile = os.path.join(bintree.pkgdir,
-					cpv + ".gpkg.tar." + str(os.getpid()))
-				ensure_dirs(os.path.dirname(binpkg_tmpfile))
-				excluded_config_files = dblnk.quickpkg(binpkg_tmpfile,
-					metadata,
-					include_config=include_config,
-					include_unmodified_config=include_unmodified_config)
-			else:
-				raise InvalidBinaryPackageFormat(binpkg_format)
-		finally:
-			if have_lock:
-				dblnk.unlockdb()
-		pkg_info = bintree.inject(cpv, filename=binpkg_tmpfile)
-		# The pkg_info value ensures that the following getname call
-		# returns the correct path when FEATURES=binpkg-multi-instance
-		# is enabled, but fallback to cpv in case the inject call
-		# returned None due to some kind of failure.
-		binpkg_path = bintree.getname(pkg_info or cpv)
-		try:
-			s = os.stat(binpkg_path)
-		except OSError:
-			s = None
-
-		if s is None or pkg_info is None:
-			# Sanity check, shouldn't happen normally.
-			eout.eend(1)
-			eout.eerror("Failed to create package: '%s'" % binpkg_path)
-			retval |= 1
-		else:
-			eout.eend(0)
-			infos["successes"].append((cpv, s.st_size))
-			infos["config_files_excluded"] += len(excluded_config_files)
-			for filename in excluded_config_files:
-				eout.ewarn("Excluded config: '%s'" % filename)
-	if not pkgs_for_arg:
-		eout.eerror("Could not find anything " + \
-			"to match '%s'; skipping" % arg)
-		infos["missing"].append(arg)
-		retval |= 1
-	return retval
+    settings = portage.settings
+    eroot = portage.settings["EROOT"]
+    trees = portage.db[eroot]
+    vartree = trees["vartree"]
+    vardb = vartree.dbapi
+    bintree = trees["bintree"]
+
+    include_config = options.include_config == "y"
+    include_unmodified_config = options.include_unmodified_config == "y"
+    fix_metadata_keys = ["PF", "CATEGORY"]
+
+    try:
+        atom = dep_expand(arg, mydb=vardb, settings=vartree.settings)
+    except AmbiguousPackageName as e:
+        # Multiple matches thrown from cpv_expand
+        eout.eerror("Please use a more specific atom: %s" % " ".join(e.args[0]))
+        del e
+        infos["missing"].append(arg)
+        return 1
+    except (InvalidAtom, InvalidData):
+        eout.eerror("Invalid atom: %s" % (arg,))
+        infos["missing"].append(arg)
+        return 1
+    if atom[:1] == "=" and arg[:1] != "=":
+        # dep_expand() allows missing '=' but it's really invalid
+        eout.eerror("Invalid atom: %s" % (arg,))
+        infos["missing"].append(arg)
+        return 1
+
+    matches = vardb.match(atom)
+    pkgs_for_arg = 0
+    retval = 0
+    for cpv in matches:
+        excluded_config_files = []
+        dblnk = vardb._dblink(cpv)
+        have_lock = False
+
+        if "__PORTAGE_INHERIT_VARDB_LOCK" not in settings:
+            try:
+                dblnk.lockdb()
+                have_lock = True
+            except PermissionDenied:
+                pass
+
+        try:
+            if not dblnk.exists():
+                # unmerged by a concurrent process
+                continue
+            iuse, use, restrict = vardb.aux_get(cpv, ["IUSE", "USE", "RESTRICT"])
+            iuse = [x.lstrip("+-") for x in iuse.split()]
+            use = use.split()
+            try:
+                restrict = use_reduce(restrict, uselist=use, flat=True)
+            except InvalidDependString as e:
+                eout.eerror(
+                    "Invalid RESTRICT metadata "
+                    + "for '%s': %s; skipping" % (cpv, str(e))
+                )
+                del e
+                continue
+            if "bindist" in iuse and "bindist" not in use:
+                eout.ewarn("%s: package was emerged with USE=-bindist!" % cpv)
+                eout.ewarn("%s: it might not be legal to redistribute this." % cpv)
+            elif "bindist" in restrict:
+                eout.ewarn("%s: package has RESTRICT=bindist!" % cpv)
+                eout.ewarn("%s: it might not be legal to redistribute this." % cpv)
+            eout.ebegin("Building package for %s" % cpv)
+            pkgs_for_arg += 1
+            existing_metadata = dict(
+                zip(fix_metadata_keys, vardb.aux_get(cpv, fix_metadata_keys))
+            )
+            category, pf = portage.catsplit(cpv)
+            required_metadata = {}
+            required_metadata["CATEGORY"] = category
+            required_metadata["PF"] = pf
+            update_metadata = {}
+            for k, v in required_metadata.items():
+                if v != existing_metadata[k]:
+                    update_metadata[k] = v
+            if update_metadata:
+                vardb.aux_update(cpv, update_metadata)
+
+            binpkg_format = settings.get(
+                "BINPKG_FORMAT", SUPPORTED_GENTOO_BINPKG_FORMATS[0]
+            )
+            if binpkg_format == "xpak":
+                xpdata = xpak.xpak(dblnk.dbdir)
+                binpkg_tmpfile = os.path.join(
+                    bintree.pkgdir, cpv + ".tbz2." + str(portage.getpid())
+                )
+                ensure_dirs(os.path.dirname(binpkg_tmpfile))
+                binpkg_compression = settings.get("BINPKG_COMPRESS", "bzip2")
+                try:
+                    compression = _compressors[binpkg_compression]
+                except KeyError as e:
+                    if binpkg_compression:
+                        eout.eerror(
+                            "Invalid or unsupported compression method: %s" % e.args[0]
+                        )
+                        return 1
+                    # Empty BINPKG_COMPRESS disables compression.
+                    binpkg_compression = "none"
+                    compression = {
+                        "compress": "cat",
+                        "package": "sys-apps/coreutils",
+                    }
+                try:
+                    compression_binary = shlex_split(
+                        varexpand(compression["compress"], mydict=settings)
+                    )[0]
+                except IndexError as e:
+                    eout.eerror(
+                        "Invalid or unsupported compression method: %s" % e.args[0]
+                    )
+                    return 1
+                if find_binary(compression_binary) is None:
+                    missing_package = compression["package"]
+                    eout.eerror(
+                        "File compression unsupported %s. Missing package: %s"
+                        % (binpkg_compression, missing_package)
+                    )
+                    return 1
+                cmd = [
+                    varexpand(x, mydict=settings)
+                    for x in shlex_split(compression["compress"])
+                ]
+                # Filter empty elements that make Popen fail
+                cmd = [x for x in cmd if x != ""]
+                with open(binpkg_tmpfile, "wb") as fobj:
+                    proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=fobj)
+                    excluded_config_files = dblnk.quickpkg(
+                        proc.stdin,
+                        include_config=include_config,
+                        include_unmodified_config=include_unmodified_config,
+                    )
+                    proc.stdin.close()
+                    if proc.wait() != os.EX_OK:
+                        eout.eend(1)
+                        eout.eerror("Compressor failed for package %s" % cpv)
+                        retval |= 1
+                        try:
+                            os.unlink(binpkg_tmpfile)
+                        except OSError as e:
+                            if e.errno not in (errno.ENOENT, errno.ESTALE):
+                                raise
+                        continue
+                xpak.tbz2(binpkg_tmpfile).recompose_mem(xpdata)
+            elif binpkg_format == "gpkg":
+                metadata = gpkg.gpkg(settings)._generate_metadata_from_dir(dblnk.dbdir)
+                binpkg_tmpfile = os.path.join(
+                    bintree.pkgdir, cpv + ".gpkg.tar." + str(os.getpid())
+                )
+                ensure_dirs(os.path.dirname(binpkg_tmpfile))
+                excluded_config_files = dblnk.quickpkg(
+                    binpkg_tmpfile,
+                    metadata,
+                    include_config=include_config,
+                    include_unmodified_config=include_unmodified_config,
+                )
+            else:
+                raise InvalidBinaryPackageFormat(binpkg_format)
+        finally:
+            if have_lock:
+                dblnk.unlockdb()
+        pkg_info = bintree.inject(cpv, filename=binpkg_tmpfile)
+        # The pkg_info value ensures that the following getname call
+        # returns the correct path when FEATURES=binpkg-multi-instance
+        # is enabled, but fallback to cpv in case the inject call
+        # returned None due to some kind of failure.
+        binpkg_path = bintree.getname(pkg_info or cpv)
+        try:
+            s = os.stat(binpkg_path)
+        except OSError:
+            s = None
+
+        if s is None or pkg_info is None:
+            # Sanity check, shouldn't happen normally.
+            eout.eend(1)
+            eout.eerror("Failed to create package: '%s'" % binpkg_path)
+            retval |= 1
+        else:
+            eout.eend(0)
+            infos["successes"].append((cpv, s.st_size))
+            infos["config_files_excluded"] += len(excluded_config_files)
+            for filename in excluded_config_files:
+                eout.ewarn("Excluded config: '%s'" % filename)
+    if not pkgs_for_arg:
+        eout.eerror("Could not find anything " + "to match '%s'; skipping" % arg)
+        infos["missing"].append(arg)
+        retval |= 1
+    return retval
+
 
 def quickpkg_set(options, infos, arg, eout):
-	eroot = portage.settings['EROOT']
-	trees = portage.db[eroot]
-	vartree = trees["vartree"]
-
-	settings = vartree.settings
-	settings._init_dirs()
-	setconfig = load_default_config(settings, trees)
-	sets = setconfig.getSets()
-
-	set_name = arg[1:]
-	if not set_name in sets:
-		eout.eerror("Package set not found: '%s'; skipping" % (arg,))
-		infos["missing"].append(arg)
-		return 1
-
-	try:
-		atoms = setconfig.getSetAtoms(set_name)
-	except PackageSetNotFound as e:
-		eout.eerror("Failed to process package set '%s' because " % set_name +
-			"it contains the non-existent package set '%s'; skipping" % e)
-		infos["missing"].append(arg)
-		return 1
-	retval = os.EX_OK
-	for atom in atoms:
-		retval |= quickpkg_atom(options, infos, atom, eout)
-	return retval
+    eroot = portage.settings["EROOT"]
+    trees = portage.db[eroot]
+    vartree = trees["vartree"]
+
+    settings = vartree.settings
+    settings._init_dirs()
+    setconfig = load_default_config(settings, trees)
+    sets = setconfig.getSets()
+
+    set_name = arg[1:]
+    if not set_name in sets:
+        eout.eerror("Package set not found: '%s'; skipping" % (arg,))
+        infos["missing"].append(arg)
+        return 1
+
+    try:
+        atoms = setconfig.getSetAtoms(set_name)
+    except PackageSetNotFound as e:
+        eout.eerror(
+            "Failed to process package set '%s' because " % set_name
+            + "it contains the non-existent package set '%s'; skipping" % e
+        )
+        infos["missing"].append(arg)
+        return 1
+    retval = os.EX_OK
+    for atom in atoms:
+        retval |= quickpkg_atom(options, infos, atom, eout)
+    return retval
 
 
 def quickpkg_extended_atom(options, infos, atom, eout):
-	eroot = portage.settings['EROOT']
-	trees = portage.db[eroot]
-	vartree = trees["vartree"]
-	vardb = vartree.dbapi
+    eroot = portage.settings["EROOT"]
+    trees = portage.db[eroot]
+    vartree = trees["vartree"]
+    vardb = vartree.dbapi
 
-	require_metadata = atom.slot or atom.repo
-	atoms = []
-	for cpv in vardb.cpv_all():
-		cpv_atom = Atom("=%s" % cpv)
+    require_metadata = atom.slot or atom.repo
+    atoms = []
+    for cpv in vardb.cpv_all():
+        cpv_atom = Atom("=%s" % cpv)
 
-		if atom == "*/*":
-			atoms.append(cpv_atom)
-			continue
+        if atom == "*/*":
+            atoms.append(cpv_atom)
+            continue
 
-		if not portage.match_from_list(atom, [cpv]):
-			continue
+        if not portage.match_from_list(atom, [cpv]):
+            continue
 
-		if require_metadata:
-			try:
-				cpv = vardb._pkg_str(cpv, atom.repo)
-			except (KeyError, InvalidData):
-				continue
-			if not portage.match_from_list(atom, [cpv]):
-				continue
+        if require_metadata:
+            try:
+                cpv = vardb._pkg_str(cpv, atom.repo)
+            except (KeyError, InvalidData):
+                continue
+            if not portage.match_from_list(atom, [cpv]):
+                continue
 
-		atoms.append(cpv_atom)
+        atoms.append(cpv_atom)
 
-	for atom in atoms:
-		quickpkg_atom(options, infos, atom, eout)
+    for atom in atoms:
+        quickpkg_atom(options, infos, atom, eout)
 
 
 def quickpkg_main(options, args, eout):
-	eroot = portage.settings['EROOT']
-	trees = portage.db[eroot]
-	bintree = trees["bintree"]
-
-	try:
-		ensure_dirs(bintree.pkgdir)
-	except portage.exception.PortageException:
-		pass
-	if not os.access(bintree.pkgdir, os.W_OK):
-		eout.eerror("No write access to '%s'" % bintree.pkgdir)
-		return errno.EACCES
-
-	if 'xattr' in portage.settings.features and not _xattr.XATTRS_WORKS:
-		eout.eerror("No xattr support library was found, "
-			"so xattrs will not be preserved!")
-		portage.settings.unlock()
-		portage.settings.features.remove('xattr')
-		portage.settings.lock()
-
-	if portage.settings.get("BINPKG_GPG_SIGNING_KEY", None):
-		gpg = GPG(portage.settings)
-		gpg.unlock()
-
-	infos = {}
-	infos["successes"] = []
-	infos["missing"] = []
-	infos["config_files_excluded"] = 0
-	for arg in args:
-		if arg[0] == SETPREFIX:
-			quickpkg_set(options, infos, arg, eout)
-			continue
-		try:
-			atom = Atom(arg, allow_wildcard=True, allow_repo=True)
-		except (InvalidAtom, InvalidData):
-			# maybe it's valid but missing category (requires dep_expand)
-			quickpkg_atom(options, infos, arg, eout)
-		else:
-			if atom.extended_syntax:
-				quickpkg_extended_atom(options, infos, atom, eout)
-			else:
-				quickpkg_atom(options, infos, atom, eout)
-
-	if not infos["successes"]:
-		eout.eerror("No packages found")
-		return 1
-	print()
-	eout.einfo("Packages now in '%s':" % bintree.pkgdir)
-	units = {10:'K', 20:'M', 30:'G', 40:'T',
-		50:'P', 60:'E', 70:'Z', 80:'Y'}
-	for cpv, size in infos["successes"]:
-		if not size:
-			# avoid OverflowError in math.log()
-			size_str = "0"
-		else:
-			power_of_2 = math.log(size, 2)
-			power_of_2 = 10*(power_of_2//10)
-			unit = units.get(power_of_2)
-			if unit:
-				size = float(size)/(2**power_of_2)
-				size_str = "%.1f" % size
-				if len(size_str) > 4:
-					# emulate `du -h`, don't show too many sig figs
-					size_str = str(int(size))
-				size_str += unit
-			else:
-				size_str = str(size)
-		eout.einfo("%s: %s" % (cpv, size_str))
-	if infos["config_files_excluded"]:
-		print()
-		eout.ewarn("Excluded config files: %d" % infos["config_files_excluded"])
-		eout.ewarn("See --help if you would like to include config files.")
-	if infos["missing"]:
-		print()
-		eout.ewarn("The following packages could not be found:")
-		eout.ewarn(" ".join(infos["missing"]))
-		return 2
-	return os.EX_OK
+    eroot = portage.settings["EROOT"]
+    trees = portage.db[eroot]
+    bintree = trees["bintree"]
+
+    try:
+        ensure_dirs(bintree.pkgdir)
+    except portage.exception.PortageException:
+        pass
+    if not os.access(bintree.pkgdir, os.W_OK):
+        eout.eerror("No write access to '%s'" % bintree.pkgdir)
+        return errno.EACCES
+
+    if "xattr" in portage.settings.features and not _xattr.XATTRS_WORKS:
+        eout.eerror(
+            "No xattr support library was found, " "so xattrs will not be preserved!"
+        )
+        portage.settings.unlock()
+        portage.settings.features.remove("xattr")
+        portage.settings.lock()
+
+    if portage.settings.get("BINPKG_GPG_SIGNING_KEY", None):
+        gpg = GPG(portage.settings)
+        gpg.unlock()
+
+    infos = {}
+    infos["successes"] = []
+    infos["missing"] = []
+    infos["config_files_excluded"] = 0
+    for arg in args:
+        if arg[0] == SETPREFIX:
+            quickpkg_set(options, infos, arg, eout)
+            continue
+        try:
+            atom = Atom(arg, allow_wildcard=True, allow_repo=True)
+        except (InvalidAtom, InvalidData):
+            # maybe it's valid but missing category (requires dep_expand)
+            quickpkg_atom(options, infos, arg, eout)
+        else:
+            if atom.extended_syntax:
+                quickpkg_extended_atom(options, infos, atom, eout)
+            else:
+                quickpkg_atom(options, infos, atom, eout)
+
+    if not infos["successes"]:
+        eout.eerror("No packages found")
+        return 1
+    print()
+    eout.einfo("Packages now in '%s':" % bintree.pkgdir)
+    units = {10: "K", 20: "M", 30: "G", 40: "T", 50: "P", 60: "E", 70: "Z", 80: "Y"}
+    for cpv, size in infos["successes"]:
+        if not size:
+            # avoid OverflowError in math.log()
+            size_str = "0"
+        else:
+            power_of_2 = math.log(size, 2)
+            power_of_2 = 10 * (power_of_2 // 10)
+            unit = units.get(power_of_2)
+            if unit:
+                size = float(size) / (2**power_of_2)
+                size_str = "%.1f" % size
+                if len(size_str) > 4:
+                    # emulate `du -h`, don't show too many sig figs
+                    size_str = str(int(size))
+                size_str += unit
+            else:
+                size_str = str(size)
+        eout.einfo("%s: %s" % (cpv, size_str))
+    if infos["config_files_excluded"]:
+        print()
+        eout.ewarn("Excluded config files: %d" % infos["config_files_excluded"])
+        eout.ewarn("See --help if you would like to include config files.")
+    if infos["missing"]:
+        print()
+        eout.ewarn("The following packages could not be found:")
+        eout.ewarn(" ".join(infos["missing"]))
+        return 2
+    return os.EX_OK
+
 
 if __name__ == "__main__":
-	usage = "quickpkg [options] <list of package atoms or package sets>"
-	parser = argparse.ArgumentParser(usage=usage)
-	parser.add_argument("--umask",
-		default="0077",
-		help="umask used during package creation (default is 0077)")
-	parser.add_argument("--ignore-default-opts",
-		action="store_true",
-		help="do not use the QUICKPKG_DEFAULT_OPTS environment variable")
-	parser.add_argument("--include-config",
-		choices=["y","n"],
-		default="n",
-		metavar="<y|n>",
-		help="include all files protected by CONFIG_PROTECT (as a security precaution, default is 'n')")
-	parser.add_argument("--include-unmodified-config",
-		choices=["y","n"],
-		default="n",
-		metavar="<y|n>",
-		help="include files protected by CONFIG_PROTECT that have not been modified since installation (as a security precaution, default is 'n')")
-	options, args = parser.parse_known_args(sys.argv[1:])
-	if not options.ignore_default_opts:
-		default_opts = shlex_split(
-			portage.settings.get("QUICKPKG_DEFAULT_OPTS", ""))
-		options, args = parser.parse_known_args(default_opts + sys.argv[1:])
-	if not args:
-		parser.error("no packages atoms given")
-	try:
-		umask = int(options.umask, 8)
-	except ValueError:
-		parser.error("invalid umask: %s" % options.umask)
-	# We need to ensure a sane umask for the packages that will be created.
-	old_umask = os.umask(umask)
-	eout = portage.output.EOutput()
-	def sigwinch_handler(signum, frame):
-		lines, eout.term_columns =  portage.output.get_term_size()
-	signal.signal(signal.SIGWINCH, sigwinch_handler)
-	try:
-		retval = quickpkg_main(options, args, eout)
-	finally:
-		os.umask(old_umask)
-		signal.signal(signal.SIGWINCH, signal.SIG_DFL)
-		global_event_loop().close()
-	sys.exit(retval)
+    usage = "quickpkg [options] <list of package atoms or package sets>"
+    parser = argparse.ArgumentParser(usage=usage)
+    parser.add_argument(
+        "--umask",
+        default="0077",
+        help="umask used during package creation (default is 0077)",
+    )
+    parser.add_argument(
+        "--ignore-default-opts",
+        action="store_true",
+        help="do not use the QUICKPKG_DEFAULT_OPTS environment variable",
+    )
+    parser.add_argument(
+        "--include-config",
+        choices=["y", "n"],
+        default="n",
+        metavar="<y|n>",
+        help="include all files protected by CONFIG_PROTECT (as a security precaution, default is 'n')",
+    )
+    parser.add_argument(
+        "--include-unmodified-config",
+        choices=["y", "n"],
+        default="n",
+        metavar="<y|n>",
+        help="include files protected by CONFIG_PROTECT that have not been modified since installation (as a security precaution, default is 'n')",
+    )
+    options, args = parser.parse_known_args(sys.argv[1:])
+    if not options.ignore_default_opts:
+        default_opts = shlex_split(portage.settings.get("QUICKPKG_DEFAULT_OPTS", ""))
+        options, args = parser.parse_known_args(default_opts + sys.argv[1:])
+    if not args:
+        parser.error("no packages atoms given")
+    try:
+        umask = int(options.umask, 8)
+    except ValueError:
+        parser.error("invalid umask: %s" % options.umask)
+    # We need to ensure a sane umask for the packages that will be created.
+    old_umask = os.umask(umask)
+    eout = portage.output.EOutput()
+
+    def sigwinch_handler(signum, frame):
+        lines, eout.term_columns = portage.output.get_term_size()
+
+    signal.signal(signal.SIGWINCH, sigwinch_handler)
+    try:
+        retval = quickpkg_main(options, args, eout)
+    finally:
+        os.umask(old_umask)
+        signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+        global_event_loop().close()
+    sys.exit(retval)

diff --git a/bin/regenworld b/bin/regenworld
index e3577a103..fd11ed14a 100755
--- a/bin/regenworld
+++ b/bin/regenworld
@@ -4,9 +4,15 @@
 
 import sys
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage import os
 from portage._sets.files import StaticFileSet, WorldSelectedPackagesSet
@@ -16,129 +22,138 @@ import tempfile
 import textwrap
 
 __candidatematcher__ = re.compile("^[0-9]+: \\*\\*\\* emerge ")
-__noncandidatematcher__ = re.compile(" sync( |$)| clean( |$)| search( |$)|--oneshot|--fetchonly| unmerge( |$)")
+__noncandidatematcher__ = re.compile(
+    " sync( |$)| clean( |$)| search( |$)|--oneshot|--fetchonly| unmerge( |$)"
+)
+
 
 def issyspkg(pkgline):
-	return pkgline[0] == "*"
+    return pkgline[0] == "*"
+
 
 def iscandidate(logline):
-	return (__candidatematcher__.match(logline)
-				and not __noncandidatematcher__.search(logline))
+    return __candidatematcher__.match(logline) and not __noncandidatematcher__.search(
+        logline
+    )
+
 
 def getpkginfo(logline):
-	logline = re.sub("^[0-9]+: \\*\\*\\* emerge ", "", logline)
-	logline = logline.strip()
-	logline = re.sub("(\\S+\\.(ebuild|tbz2))|(--\\S+)|inject ", "", logline)
-	return logline.strip()
+    logline = re.sub("^[0-9]+: \\*\\*\\* emerge ", "", logline)
+    logline = logline.strip()
+    logline = re.sub("(\\S+\\.(ebuild|tbz2))|(--\\S+)|inject ", "", logline)
+    return logline.strip()
+
 
 __uniqlist__ = []
+
+
 def isunwanted(pkgline):
-	if pkgline in ["world", "system", "depclean", "info", "regen", ""]:
-		return False
-	elif pkgline in __uniqlist__:
-		return False
-	elif not re.search("^[a-zA-Z<>=~]", pkgline):
-		return False
-	else:
-		__uniqlist__.append(pkgline)
-		return True
-
-eroot = portage.settings['EROOT']
+    if pkgline in ["world", "system", "depclean", "info", "regen", ""]:
+        return False
+    elif pkgline in __uniqlist__:
+        return False
+    elif not re.search("^[a-zA-Z<>=~]", pkgline):
+        return False
+    else:
+        __uniqlist__.append(pkgline)
+        return True
+
+
+eroot = portage.settings["EROOT"]
 world_file = os.path.join(eroot, portage.WORLD_FILE)
 
 # show a little description if we have arguments
 if len(sys.argv) >= 2 and sys.argv[1] in ["-h", "--help"]:
-	print("This script regenerates the portage world file by checking the portage")
-	print("logfile for all actions that you've done in the past. It ignores any")
-	print("arguments except --help. It is recommended that you make a backup of")
-	print("your existing world file (%s) before using this tool." % world_file)
-	sys.exit(0)
+    print("This script regenerates the portage world file by checking the portage")
+    print("logfile for all actions that you've done in the past. It ignores any")
+    print("arguments except --help. It is recommended that you make a backup of")
+    print("your existing world file (%s) before using this tool." % world_file)
+    sys.exit(0)
 
 worldlist = portage.grabfile(world_file)
 syslist = [x for x in portage.settings.packages if issyspkg(x)]
 
 if portage.settings.get("EMERGE_LOG_DIR"):
-	logfile = portage.grabfile(
-		os.path.join(portage.settings["EMERGE_LOG_DIR"], "emerge.log")
-	)
+    logfile = portage.grabfile(
+        os.path.join(portage.settings["EMERGE_LOG_DIR"], "emerge.log")
+    )
 else:
-	logfile = portage.grabfile(os.path.join(eroot, "var/log/emerge.log"))
+    logfile = portage.grabfile(os.path.join(eroot, "var/log/emerge.log"))
 biglist = [getpkginfo(x) for x in logfile if iscandidate(x)]
 tmplist = []
 for l in biglist:
-	tmplist += l.split()
+    tmplist += l.split()
 biglist = [x for x in tmplist if isunwanted(x)]
-#for p in biglist:
-#	print(p)
-#sys.exit(0)
+# for p in biglist:
+# 	print(p)
+# sys.exit(0)
 
 # resolving virtuals
 realsyslist = []
 for mykey in syslist:
-	# drop the asterix
-	mykey = mykey[1:]
-	#print("candidate:",mykey)
-	mylist = portage.db[eroot]["vartree"].dbapi.match(mykey)
-	if mylist:
-		mykey=portage.cpv_getkey(mylist[0])
-		if mykey not in realsyslist:
-			realsyslist.append(mykey)
+    # drop the asterix
+    mykey = mykey[1:]
+    # print("candidate:",mykey)
+    mylist = portage.db[eroot]["vartree"].dbapi.match(mykey)
+    if mylist:
+        mykey = portage.cpv_getkey(mylist[0])
+        if mykey not in realsyslist:
+            realsyslist.append(mykey)
 
 for mykey in biglist:
-	#print("checking:",mykey)
-	try:
-		mylist = portage.db[eroot]["vartree"].dbapi.match(mykey)
-	except (portage.exception.InvalidAtom, KeyError):
-		if "--debug" in sys.argv:
-			print("* ignoring broken log entry for %s (likely injected)" % mykey)
-	except ValueError as e:
-		try:
-			print("* %s is an ambiguous package name, candidates are:\n%s" % (mykey, e))
-		except AttributeError:
-			# FIXME: Find out what causes this (bug #344845).
-			print("* %s is an ambiguous package name" % (mykey,))
-		continue
-	if mylist:
-		#print "mylist:",mylist
-		myfavkey=portage.cpv_getkey(mylist[0])
-		if (myfavkey not in realsyslist) and (myfavkey not in worldlist):
-			print("add to world:",myfavkey)
-			worldlist.append(myfavkey)
+    # print("checking:",mykey)
+    try:
+        mylist = portage.db[eroot]["vartree"].dbapi.match(mykey)
+    except (portage.exception.InvalidAtom, KeyError):
+        if "--debug" in sys.argv:
+            print("* ignoring broken log entry for %s (likely injected)" % mykey)
+    except ValueError as e:
+        try:
+            print("* %s is an ambiguous package name, candidates are:\n%s" % (mykey, e))
+        except AttributeError:
+            # FIXME: Find out what causes this (bug #344845).
+            print("* %s is an ambiguous package name" % (mykey,))
+        continue
+    if mylist:
+        # print "mylist:",mylist
+        myfavkey = portage.cpv_getkey(mylist[0])
+        if (myfavkey not in realsyslist) and (myfavkey not in worldlist):
+            print("add to world:", myfavkey)
+            worldlist.append(myfavkey)
 
 if not worldlist:
-	pass
+    pass
 else:
-	existing_set = WorldSelectedPackagesSet(eroot)
-	existing_set.load()
-
-	if not existing_set:
-		existing_set.replace(worldlist)
-	else:
-		old_world = existing_set._filename
-		fd, tmp_filename = tempfile.mkstemp(suffix=".tmp",
-			prefix=os.path.basename(old_world) + ".",
-			dir=os.path.dirname(old_world))
-		os.close(fd)
-
-		new_set = StaticFileSet(tmp_filename)
-		new_set.update(worldlist)
-
-		if existing_set.getAtoms() == new_set.getAtoms():
-			os.unlink(tmp_filename)
-		else:
-			new_set.write()
-
-			msg = "Please review differences between old and new files, " + \
-				"and replace the old file if desired."
-
-			portage.util.writemsg_stdout("\n",
-				noiselevel=-1)
-			for line in textwrap.wrap(msg, 65):
-				portage.util.writemsg_stdout("%s\n" % line,
-					noiselevel=-1)
-			portage.util.writemsg_stdout("\n",
-				noiselevel=-1)
-			portage.util.writemsg_stdout("  old: %s\n\n" % old_world,
-				noiselevel=-1)
-			portage.util.writemsg_stdout("  new: %s\n\n" % tmp_filename,
-				noiselevel=-1)
+    existing_set = WorldSelectedPackagesSet(eroot)
+    existing_set.load()
+
+    if not existing_set:
+        existing_set.replace(worldlist)
+    else:
+        old_world = existing_set._filename
+        fd, tmp_filename = tempfile.mkstemp(
+            suffix=".tmp",
+            prefix=os.path.basename(old_world) + ".",
+            dir=os.path.dirname(old_world),
+        )
+        os.close(fd)
+
+        new_set = StaticFileSet(tmp_filename)
+        new_set.update(worldlist)
+
+        if existing_set.getAtoms() == new_set.getAtoms():
+            os.unlink(tmp_filename)
+        else:
+            new_set.write()
+
+            msg = (
+                "Please review differences between old and new files, "
+                + "and replace the old file if desired."
+            )
+
+            portage.util.writemsg_stdout("\n", noiselevel=-1)
+            for line in textwrap.wrap(msg, 65):
+                portage.util.writemsg_stdout("%s\n" % line, noiselevel=-1)
+            portage.util.writemsg_stdout("\n", noiselevel=-1)
+            portage.util.writemsg_stdout("  old: %s\n\n" % old_world, noiselevel=-1)
+            portage.util.writemsg_stdout("  new: %s\n\n" % tmp_filename, noiselevel=-1)

diff --git a/bin/shelve-utils b/bin/shelve-utils
index 6cfa36a81..3c513bd17 100755
--- a/bin/shelve-utils
+++ b/bin/shelve-utils
@@ -6,31 +6,37 @@ import argparse
 import sys
 
 from os import path as osp
-if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")):
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib"))
+
+if osp.isfile(
+    osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), ".portage_not_installed")
+):
+    sys.path.insert(
+        0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "lib")
+    )
 import portage
+
 portage._internal_caller = True
 from portage.util.shelve import dump, restore
 
 
 def main(argv=None):
-	parser = argparse.ArgumentParser(prog="shelve-utils")
-	subparsers = parser.add_subparsers(help="sub-command help")
+    parser = argparse.ArgumentParser(prog="shelve-utils")
+    subparsers = parser.add_subparsers(help="sub-command help")
 
-	dump_command = subparsers.add_parser("dump", help="dump shelve database")
-	dump_command.add_argument("src", help="input shelve file")
-	dump_command.add_argument("dest", help="output pickle file")
-	dump_command.set_defaults(func=dump)
+    dump_command = subparsers.add_parser("dump", help="dump shelve database")
+    dump_command.add_argument("src", help="input shelve file")
+    dump_command.add_argument("dest", help="output pickle file")
+    dump_command.set_defaults(func=dump)
 
-	restore_command = subparsers.add_parser("restore", help="restore shelve database")
-	restore_command.add_argument("src", help="input pickle file")
-	restore_command.add_argument("dest", help="output shelve file")
-	restore_command.set_defaults(func=restore)
+    restore_command = subparsers.add_parser("restore", help="restore shelve database")
+    restore_command.add_argument("src", help="input pickle file")
+    restore_command.add_argument("dest", help="output shelve file")
+    restore_command.set_defaults(func=restore)
 
-	args = parser.parse_args(args=portage._decode_argv(argv or sys.argv)[1:])
-	args.func(args)
+    args = parser.parse_args(args=portage._decode_argv(argv or sys.argv)[1:])
+    args.func(args)
 
 
 if __name__ == "__main__":
-	portage.util.initialize_logger()
-	main(argv=sys.argv)
+    portage.util.initialize_logger()
+    main(argv=sys.argv)

diff --git a/repoman/bin/repoman b/repoman/bin/repoman
index 427cb3162..beaf8147a 100755
--- a/repoman/bin/repoman
+++ b/repoman/bin/repoman
@@ -25,17 +25,21 @@ except KeyboardInterrupt:
     sys.exit(1)
 
 from os import path as osp
+
 here = osp.realpath(__file__)
 if osp.isfile(osp.join(osp.dirname(osp.dirname(here)), ".repoman_not_installed")):
     # Add the repoman subpkg
     pym_path = osp.join(osp.dirname(osp.dirname(here)), "lib")
     sys.path.insert(0, pym_path)
-    if osp.isfile(osp.join(osp.dirname(osp.dirname(osp.dirname(here))), ".portage_not_installed")):
+    if osp.isfile(
+        osp.join(osp.dirname(osp.dirname(osp.dirname(here))), ".portage_not_installed")
+    ):
         # Add the base portage pkg
         pym_path = osp.join(osp.dirname(osp.dirname(osp.dirname(here))), "lib")
         sys.path.insert(0, pym_path)
 
 import portage
+
 portage._internal_caller = True
 from portage.util._eventloop.global_event_loop import global_event_loop
 from repoman.main import repoman_main

diff --git a/repoman/runtests b/repoman/runtests
index 5b1306e59..f02bfe875 100755
--- a/repoman/runtests
+++ b/repoman/runtests
@@ -20,62 +20,53 @@ import tempfile
 
 
 # These are the versions we fully support and require to pass tests.
-PYTHON_SUPPORTED_VERSIONS = [
-    '2.7',
-    '3.6',
-    '3.7',
-    '3.8',
-    '3.9'
-]
+PYTHON_SUPPORTED_VERSIONS = ["2.7", "3.6", "3.7", "3.8", "3.9"]
 # The rest are just "nice to have".
-PYTHON_NICE_VERSIONS = [
-    'pypy3',
-    '3.10'
-]
+PYTHON_NICE_VERSIONS = ["pypy3", "3.10"]
 
-EPREFIX = os.environ.get('PORTAGE_OVERRIDE_EPREFIX', '/')
+EPREFIX = os.environ.get("PORTAGE_OVERRIDE_EPREFIX", "/")
 
 
 class Colors(object):
     """Simple object holding color constants."""
 
-    _COLORS_YES = ('y', 'yes', 'true')
-    _COLORS_NO = ('n', 'no', 'false')
+    _COLORS_YES = ("y", "yes", "true")
+    _COLORS_NO = ("n", "no", "false")
 
-    WARN = GOOD = BAD = NORMAL = ''
+    WARN = GOOD = BAD = NORMAL = ""
 
     def __init__(self, colorize=None):
         if colorize is None:
-            nocolors = os.environ.get('NOCOLOR', 'false')
+            nocolors = os.environ.get("NOCOLOR", "false")
             # Ugh, look away, for here we invert the world!
             if nocolors in self._COLORS_YES:
                 colorize = False
             elif nocolors in self._COLORS_NO:
                 colorize = True
             else:
-                raise ValueError('$NOCOLORS is invalid: %s' % nocolors)
+                raise ValueError("$NOCOLORS is invalid: %s" % nocolors)
         else:
             if colorize in self._COLORS_YES:
                 colorize = True
             elif colorize in self._COLORS_NO:
                 colorize = False
             else:
-                raise ValueError('--colors is invalid: %s' % colorize)
+                raise ValueError("--colors is invalid: %s" % colorize)
 
         if colorize:
-            self.WARN = '\033[1;33m'
-            self.GOOD = '\033[1;32m'
-            self.BAD = '\033[1;31m'
-            self.NORMAL = '\033[0m'
+            self.WARN = "\033[1;33m"
+            self.GOOD = "\033[1;32m"
+            self.BAD = "\033[1;31m"
+            self.NORMAL = "\033[0m"
 
 
 def get_python_executable(ver):
     """Find the right python executable for |ver|"""
-    if ver in ('pypy', 'pypy3'):
+    if ver in ("pypy", "pypy3"):
         prog = ver
     else:
-        prog = 'python' + ver
-    return os.path.join(EPREFIX, 'usr', 'bin', prog)
+        prog = "python" + ver
+    return os.path.join(EPREFIX, "usr", "bin", prog)
 
 
 def get_parser():
@@ -93,13 +84,25 @@ $ %(prog)s lib/portage/tests/xpak/test_decodeint.py
     parser = argparse.ArgumentParser(
         description=__doc__,
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=epilog)
-    parser.add_argument('--keep-temp', default=False, action='store_true',
-                        help='Do not delete the temporary directory when exiting')
-    parser.add_argument('--color', type=str, default=None,
-                        help='Whether to use colorized output (default is auto)')
-    parser.add_argument('--python-versions', action='append',
-                        help='Versions of python to test (default is test available)')
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "--keep-temp",
+        default=False,
+        action="store_true",
+        help="Do not delete the temporary directory when exiting",
+    )
+    parser.add_argument(
+        "--color",
+        type=str,
+        default=None,
+        help="Whether to use colorized output (default is auto)",
+    )
+    parser.add_argument(
+        "--python-versions",
+        action="append",
+        help="Versions of python to test (default is test available)",
+    )
     return parser
 
 
@@ -116,67 +119,71 @@ def main(argv):
         ignore_missing = False
         pyversions = []
         for ver in opts.python_versions:
-            if ver == 'supported':
+            if ver == "supported":
                 pyversions.extend(PYTHON_SUPPORTED_VERSIONS)
             else:
                 pyversions.extend(ver.split())
 
     here = os.path.dirname(__file__)
-    run_path = os.path.join(here, 'lib/repoman/tests/runTests.py')
+    run_path = os.path.join(here, "lib/repoman/tests/runTests.py")
     tempdir = None
     try:
         # Set up a single tempdir for all the tests to use.
         # This way we know the tests won't leak things on us.
-        tempdir = tempfile.mkdtemp(prefix='repoman.runtests.')
-        os.environ['TMPDIR'] = tempdir
+        tempdir = tempfile.mkdtemp(prefix="repoman.runtests.")
+        os.environ["TMPDIR"] = tempdir
 
         # Actually test those versions now.
         statuses = []
         for ver in pyversions:
             prog = get_python_executable(ver)
-            cmd = [prog, '-b', '-Wd', run_path] + args
+            cmd = [prog, "-b", "-Wd", run_path] + args
             if os.access(prog, os.X_OK):
-                print('%sTesting with Python %s...%s' %
-                      (colors.GOOD, ver, colors.NORMAL))
+                print(
+                    "%sTesting with Python %s...%s" % (colors.GOOD, ver, colors.NORMAL)
+                )
                 statuses.append((ver, subprocess.call(cmd)))
             elif not ignore_missing:
-                print('%sCould not find requested Python %s%s' %
-                      (colors.BAD, ver, colors.NORMAL))
+                print(
+                    "%sCould not find requested Python %s%s"
+                    % (colors.BAD, ver, colors.NORMAL)
+                )
                 statuses.append((ver, 1))
             else:
-                print('%sSkip Python %s...%s' %
-                      (colors.WARN, ver, colors.NORMAL))
+                print("%sSkip Python %s...%s" % (colors.WARN, ver, colors.NORMAL))
             print()
     finally:
         if tempdir is not None:
             if opts.keep_temp:
-                print('Temporary directory left behind:\n%s' % tempdir)
+                print("Temporary directory left behind:\n%s" % tempdir)
             else:
                 # Nuke our tempdir and anything that might be under it.
                 shutil.rmtree(tempdir, True)
 
     # Then summarize it all.
-    print('\nSummary:\n')
+    print("\nSummary:\n")
     width = 10
-    header = '| %-*s | %s' % (width, 'Version', 'Status')
-    print('%s\n|%s' % (header, '-' * (len(header) - 1)))
+    header = "| %-*s | %s" % (width, "Version", "Status")
+    print("%s\n|%s" % (header, "-" * (len(header) - 1)))
     exit_status = 0
     for ver, status in statuses:
         exit_status += status
         if status:
             color = colors.BAD
-            msg = 'FAIL'
+            msg = "FAIL"
         else:
             color = colors.GOOD
-            msg = 'PASS'
-        print('| %s%-*s%s | %s%s%s' %
-              (color, width, ver, colors.NORMAL, color, msg, colors.NORMAL))
+            msg = "PASS"
+        print(
+            "| %s%-*s%s | %s%s%s"
+            % (color, width, ver, colors.NORMAL, color, msg, colors.NORMAL)
+        )
     exit(exit_status)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     try:
         main(sys.argv[1:])
     except KeyboardInterrupt:
-        print('interrupted ...', file=sys.stderr)
+        print("interrupted ...", file=sys.stderr)
         exit(1)

diff --git a/runtests b/runtests
index bc3105026..2a653e3d4 100755
--- a/runtests
+++ b/runtests
@@ -20,61 +20,53 @@ import tempfile
 
 
 # These are the versions we fully support and require to pass tests.
-PYTHON_SUPPORTED_VERSIONS = [
-    '3.6',
-    '3.7',
-    '3.8',
-    '3.9'
-]
+PYTHON_SUPPORTED_VERSIONS = ["3.6", "3.7", "3.8", "3.9"]
 # The rest are just "nice to have".
-PYTHON_NICE_VERSIONS = [
-    'pypy3',
-    '3.10'
-]
+PYTHON_NICE_VERSIONS = ["pypy3", "3.10"]
 
-EPREFIX = os.environ.get('PORTAGE_OVERRIDE_EPREFIX', '/')
+EPREFIX = os.environ.get("PORTAGE_OVERRIDE_EPREFIX", "/")
 
 
 class Colors:
     """Simple object holding color constants."""
 
-    _COLORS_YES = ('y', 'yes', 'true')
-    _COLORS_NO = ('n', 'no', 'false')
+    _COLORS_YES = ("y", "yes", "true")
+    _COLORS_NO = ("n", "no", "false")
 
-    WARN = GOOD = BAD = NORMAL = ''
+    WARN = GOOD = BAD = NORMAL = ""
 
     def __init__(self, colorize=None):
         if colorize is None:
-            nocolors = os.environ.get('NOCOLOR', 'false')
+            nocolors = os.environ.get("NOCOLOR", "false")
             # Ugh, look away, for here we invert the world!
             if nocolors in self._COLORS_YES:
                 colorize = False
             elif nocolors in self._COLORS_NO:
                 colorize = True
             else:
-                raise ValueError('$NOCOLORS is invalid: %s' % nocolors)
+                raise ValueError("$NOCOLORS is invalid: %s" % nocolors)
         else:
             if colorize in self._COLORS_YES:
                 colorize = True
             elif colorize in self._COLORS_NO:
                 colorize = False
             else:
-                raise ValueError('--colors is invalid: %s' % colorize)
+                raise ValueError("--colors is invalid: %s" % colorize)
 
         if colorize:
-            self.WARN = '\033[1;33m'
-            self.GOOD = '\033[1;32m'
-            self.BAD = '\033[1;31m'
-            self.NORMAL = '\033[0m'
+            self.WARN = "\033[1;33m"
+            self.GOOD = "\033[1;32m"
+            self.BAD = "\033[1;31m"
+            self.NORMAL = "\033[0m"
 
 
 def get_python_executable(ver):
     """Find the right python executable for |ver|"""
-    if ver in ('pypy', 'pypy3'):
+    if ver in ("pypy", "pypy3"):
         prog = ver
     else:
-        prog = 'python' + ver
-    return os.path.join(EPREFIX, 'usr', 'bin', prog)
+        prog = "python" + ver
+    return os.path.join(EPREFIX, "usr", "bin", prog)
 
 
 def get_parser():
@@ -92,13 +84,25 @@ $ %(prog)s lib/portage/tests/xpak/test_decodeint.py
     parser = argparse.ArgumentParser(
         description=__doc__,
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=epilog)
-    parser.add_argument('--keep-temp', default=False, action='store_true',
-                        help='Do not delete the temporary directory when exiting')
-    parser.add_argument('--color', type=str, default=None,
-                        help='Whether to use colorized output (default is auto)')
-    parser.add_argument('--python-versions', action='append',
-                        help='Versions of python to test (default is test available)')
+        epilog=epilog,
+    )
+    parser.add_argument(
+        "--keep-temp",
+        default=False,
+        action="store_true",
+        help="Do not delete the temporary directory when exiting",
+    )
+    parser.add_argument(
+        "--color",
+        type=str,
+        default=None,
+        help="Whether to use colorized output (default is auto)",
+    )
+    parser.add_argument(
+        "--python-versions",
+        action="append",
+        help="Versions of python to test (default is test available)",
+    )
     return parser
 
 
@@ -115,7 +119,7 @@ def main(argv):
         ignore_missing = False
         pyversions = []
         for ver in opts.python_versions:
-            if ver == 'supported':
+            if ver == "supported":
                 pyversions.extend(PYTHON_SUPPORTED_VERSIONS)
             else:
                 pyversions.extend(ver.split())
@@ -124,56 +128,60 @@ def main(argv):
     try:
         # Set up a single tempdir for all the tests to use.
         # This way we know the tests won't leak things on us.
-        tempdir = tempfile.mkdtemp(prefix='portage.runtests.')
-        os.environ['TMPDIR'] = tempdir
+        tempdir = tempfile.mkdtemp(prefix="portage.runtests.")
+        os.environ["TMPDIR"] = tempdir
 
         # Actually test those versions now.
         statuses = []
         for ver in pyversions:
             prog = get_python_executable(ver)
-            cmd = [prog, '-b', '-Wd', 'lib/portage/tests/runTests.py'] + args
+            cmd = [prog, "-b", "-Wd", "lib/portage/tests/runTests.py"] + args
             if os.access(prog, os.X_OK):
-                print('%sTesting with Python %s...%s' %
-                      (colors.GOOD, ver, colors.NORMAL))
+                print(
+                    "%sTesting with Python %s...%s" % (colors.GOOD, ver, colors.NORMAL)
+                )
                 statuses.append((ver, subprocess.call(cmd)))
             elif not ignore_missing:
-                print('%sCould not find requested Python %s%s' %
-                      (colors.BAD, ver, colors.NORMAL))
+                print(
+                    "%sCould not find requested Python %s%s"
+                    % (colors.BAD, ver, colors.NORMAL)
+                )
                 statuses.append((ver, 1))
             else:
-                print('%sSkip Python %s...%s' %
-                      (colors.WARN, ver, colors.NORMAL))
+                print("%sSkip Python %s...%s" % (colors.WARN, ver, colors.NORMAL))
             print()
     finally:
         if tempdir is not None:
             if opts.keep_temp:
-                print('Temporary directory left behind:\n%s' % tempdir)
+                print("Temporary directory left behind:\n%s" % tempdir)
             else:
                 # Nuke our tempdir and anything that might be under it.
                 shutil.rmtree(tempdir, True)
 
     # Then summarize it all.
-    print('\nSummary:\n')
+    print("\nSummary:\n")
     width = 10
-    header = '| %-*s | %s' % (width, 'Version', 'Status')
-    print('%s\n|%s' % (header, '-' * (len(header) - 1)))
+    header = "| %-*s | %s" % (width, "Version", "Status")
+    print("%s\n|%s" % (header, "-" * (len(header) - 1)))
     exit_status = 0
     for ver, status in statuses:
         exit_status += status
         if status:
             color = colors.BAD
-            msg = 'FAIL'
+            msg = "FAIL"
         else:
             color = colors.GOOD
-            msg = 'PASS'
-        print('| %s%-*s%s | %s%s%s' %
-              (color, width, ver, colors.NORMAL, color, msg, colors.NORMAL))
+            msg = "PASS"
+        print(
+            "| %s%-*s%s | %s%s%s"
+            % (color, width, ver, colors.NORMAL, color, msg, colors.NORMAL)
+        )
     exit(exit_status)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     try:
         main(sys.argv[1:])
     except KeyboardInterrupt:
-        print('interrupted ...', file=sys.stderr)
+        print("interrupted ...", file=sys.stderr)
         exit(1)