Migrate from setuptools to Meson and meson-python

This makes Portage PEP 517 compliant.

When building via meson-python, the man pages and logrotate config are
no longer included as there seems little point.

Bug: https://bugs.gentoo.org/910035
Signed-off-by: James Le Cuirot <chewi@gentoo.org>
Signed-off-by: Sam James <sam@gentoo.org>

1 files changed, 0 insertions, 925 deletions

diff --git a/setup.py b/setup.py
deleted file mode 100755
index 4525264c7..000000000
--- a/setup.py
+++ /dev/null
@@ -1,925 +0,0 @@
-#!/usr/bin/env python
-# Copyright 1998-2023 Gentoo Authors
-# Distributed under the terms of the GNU General Public License v2
-
-try:
-    from setuptools.core import setup, Command, Extension
-    from setuptools.command.build import build
-    from setuptools.command.build_ext import build_ext as _build_ext
-    from setuptools.command.build_scripts import build_scripts
-    from setuptools.command.clean import clean
-    from setuptools.command.install import install
-    from setuptools.command.install_data import install_data
-    from setuptools.command.install_lib import install_lib
-    from setuptools.command.install_scripts import install_scripts
-    from setuptools.command.sdist import sdist
-    from setuptools.dep_util import newer
-    from setuptools.dir_util import mkpath, remove_tree, copy_tree
-    from setuptools.util import change_root, subst_vars
-except ImportError:
-    from distutils.core import setup, Command, Extension
-    from distutils.command.build import build
-    from distutils.command.build_ext import build_ext as _build_ext
-    from distutils.command.build_scripts import build_scripts
-    from distutils.command.clean import clean
-    from distutils.command.install import install
-    from distutils.command.install_data import install_data
-    from distutils.command.install_lib import install_lib
-    from distutils.command.install_scripts import install_scripts
-    from distutils.command.sdist import sdist
-    from distutils.dep_util import newer
-    from distutils.dir_util import mkpath, remove_tree, copy_tree
-    from distutils.util import change_root, subst_vars
-
-import codecs
-import collections
-import glob
-import itertools
-import os
-import os.path
-import platform
-import re
-import subprocess
-import sys
-
-autodetect_pip = os.path.basename(os.environ.get("_", "")) == "pip" or os.path.basename(
-    os.path.dirname(__file__)
-).startswith("pip-")
-venv_prefix = "" if sys.prefix == sys.base_prefix else sys.prefix
-create_entry_points = bool(autodetect_pip or venv_prefix)
-with open(os.path.join(os.path.dirname(__file__), "README.md")) as f:
-    long_description = f.read()
-
-# TODO:
-# - smarter rebuilds of docs w/ 'install_docbook' and 'install_apidoc'.
-
-# Dictionary of scripts.  The structure is
-#   key   = location in filesystem to install the scripts
-#   value = list of scripts, path relative to top source directory
-x_scripts = {
-    "bin": [
-        "bin/ebuild",
-        "bin/egencache",
-        "bin/emerge",
-        "bin/emerge-webrsync",
-        "bin/emirrordist",
-        "bin/glsa-check",
-        "bin/portageq",
-        "bin/quickpkg",
-        "bin/gpkg-sign",
-    ],
-    "sbin": [
-        "bin/archive-conf",
-        "bin/dispatch-conf",
-        "bin/emaint",
-        "bin/env-update",
-        "bin/etc-update",
-        "bin/fixpackages",
-        "bin/regenworld",
-    ],
-}
-
-# Dictionary custom modules written in C/C++ here.  The structure is
-#   key   = module name
-#   value = list of C/C++ source code, path relative to top source directory
-x_c_helpers = {
-    "portage.util.libc": [
-        "src/portage_util_libc.c",
-    ],
-    "portage.util._whirlpool": [
-        "src/portage_util__whirlpool.c",
-    ],
-}
-
-if platform.system() == "Linux":
-    x_c_helpers.update(
-        {
-            "portage.util.file_copy.reflink_linux": [
-                "src/portage_util_file_copy_reflink_linux.c",
-            ],
-        }
-    )
-
-
-class x_build(build):
-    """Build command with extra build_man call."""
-
-    def run(self):
-        build.run(self)
-        self.run_command("build_man")
-
-
-class build_man(Command):
-    """Perform substitutions in manpages."""
-
-    user_options = []
-
-    def initialize_options(self):
-        self.build_base = None
-
-    def finalize_options(self):
-        self.set_undefined_options("build", ("build_base", "build_base"))
-
-    def run(self):
-        for d, files in self.distribution.data_files:
-            if not d.startswith("$mandir/"):
-                continue
-
-            for source in files:
-                target = os.path.join(self.build_base, source)
-                mkpath(os.path.dirname(target))
-
-                if not newer(source, target) and not newer(__file__, target):
-                    continue
-
-                print(f"copying and updating {source} -> {target}")
-
-                with codecs.open(source, "r", "utf8") as f:
-                    data = f.readlines()
-                data[0] = data[0].replace("VERSION", self.distribution.get_version())
-                with codecs.open(target, "w", "utf8") as f:
-                    f.writelines(data)
-
-
-class docbook(Command):
-    """Build docs using docbook."""
-
-    user_options = [
-        (
-            "doc-formats=",
-            None,
-            "Documentation formats to build (all xmlto formats for docbook are allowed, comma-separated",
-        ),
-    ]
-
-    def initialize_options(self):
-        self.doc_formats = "xhtml,xhtml-nochunks"
-
-    def finalize_options(self):
-        self.doc_formats = self.doc_formats.replace(",", " ").split()
-
-    def run(self):
-        if not os.path.isdir("doc/fragment"):
-            mkpath("doc/fragment")
-
-        with open("doc/fragment/date", "w"):
-            pass
-        with open("doc/fragment/version", "w") as f:
-            f.write(f"<releaseinfo>{self.distribution.get_version()}</releaseinfo>")
-
-        for f in self.doc_formats:
-            print(f"Building docs in {f} format...")
-            subprocess.check_call(
-                ["xmlto", "-o", "doc", "-m", "doc/custom.xsl", f, "doc/portage.docbook"]
-            )
-
-
-class apidoc(Command):
-    """Build API docs using apidoc."""
-
-    user_options = []
-
-    def initialize_options(self):
-        self.build_lib = None
-
-    def finalize_options(self):
-        self.set_undefined_options("build_py", ("build_lib", "build_lib"))
-
-    def run(self):
-        self.run_command("build_py")
-
-        print("Building API documentation...")
-
-        process_env = os.environ.copy()
-        pythonpath = self.build_lib
-        try:
-            pythonpath += ":" + process_env["PYTHONPATH"]
-        except KeyError:
-            pass
-        process_env["PYTHONPATH"] = pythonpath
-
-        subprocess.check_call(["make", "-C", "doc/api", "html"], env=process_env)
-
-
-class install_docbook(install_data):
-    """install_data for docbook docs"""
-
-    user_options = install_data.user_options + [
-        ("htmldir=", None, "HTML documentation install directory"),
-    ]
-
-    def initialize_options(self):
-        install_data.initialize_options(self)
-        self.htmldir = None
-
-    def finalize_options(self):
-        self.set_undefined_options("install", ("htmldir", "htmldir"))
-        install_data.finalize_options(self)
-
-    def run(self):
-        if not os.path.exists("doc/portage.html"):
-            self.run_command("docbook")
-        self.data_files = [
-            (self.htmldir, glob.glob("doc/*.html")),
-        ]
-        install_data.run(self)
-
-
-class install_apidoc(install_data):
-    """install_data for apidoc docs"""
-
-    user_options = install_data.user_options + [
-        ("htmldir=", None, "HTML documentation install directory"),
-    ]
-
-    def initialize_options(self):
-        install_data.initialize_options(self)
-        self.htmldir = None
-
-    def finalize_options(self):
-        self.set_undefined_options("install", ("htmldir", "htmldir"))
-        install_data.finalize_options(self)
-
-    def run(self):
-        if not os.path.exists("doc/api/build/html/index.html"):
-            self.run_command("apidoc")
-        self.data_files = [
-            (
-                os.path.join(self.htmldir, "api"),
-                glob.glob("doc/api/build/html/*.html")
-                + glob.glob("doc/api/build/html/*.js"),
-            ),
-            (
-                os.path.join(self.htmldir, "api/_static"),
-                glob.glob("doc/api/build/html/_static/*"),
-            ),
-        ]
-        install_data.run(self)
-
-
-class x_build_scripts_custom(build_scripts):
-    def finalize_options(self):
-        build_scripts.finalize_options(self)
-        if "dir_name" in dir(self):
-            self.build_dir = os.path.join(self.build_dir, self.dir_name)
-            if self.dir_name in x_scripts:
-                self.scripts = x_scripts[self.dir_name]
-            else:
-                self.scripts = set(self.scripts)
-                if not (create_entry_points and self.dir_name == "portage"):
-                    for other_files in x_scripts.values():
-                        self.scripts.difference_update(other_files)
-
-    def run(self):
-        # group scripts by subdirectory
-        split_scripts = collections.defaultdict(list)
-        for f in self.scripts:
-            dir_name = os.path.dirname(f[len("bin/") :])
-            split_scripts[dir_name].append(f)
-
-        base_dir = self.build_dir
-        base_scripts = self.scripts
-        for d, files in split_scripts.items():
-            self.build_dir = os.path.join(base_dir, d)
-            self.scripts = files
-            self.copy_scripts()
-
-        # restore previous values
-        self.build_dir = base_dir
-        self.scripts = base_scripts
-
-
-class x_build_scripts_bin(x_build_scripts_custom):
-    dir_name = "bin"
-
-
-class x_build_scripts_sbin(x_build_scripts_custom):
-    dir_name = "sbin"
-
-
-class x_build_scripts_portagebin(x_build_scripts_custom):
-    dir_name = "portage"
-
-
-class x_build_scripts(build_scripts):
-    def initialize_option(self):
-        build_scripts.initialize_options(self)
-
-    def finalize_options(self):
-        build_scripts.finalize_options(self)
-
-    def run(self):
-        self.run_command("build_scripts_bin")
-        self.run_command("build_scripts_portagebin")
-        self.run_command("build_scripts_sbin")
-
-
-class x_clean(clean):
-    """clean extended for doc & post-test cleaning"""
-
-    @staticmethod
-    def clean_docs():
-        def get_doc_outfiles():
-            for dirpath, _dirnames, filenames in os.walk("doc"):
-                for f in filenames:
-                    if f.endswith(".docbook") or f == "custom.xsl":
-                        pass
-                    else:
-                        yield os.path.join(dirpath, f)
-
-                # do not recurse
-                break
-
-        for f in get_doc_outfiles():
-            print(f"removing {repr(f)}")
-            os.remove(f)
-
-        if os.path.isdir("doc/fragment"):
-            remove_tree("doc/fragment")
-
-        if os.path.isdir("doc/api/build"):
-            remove_tree("doc/api/build")
-
-    def clean_tests(self):
-        # do not remove incorrect dirs accidentally
-        top_dir = os.path.normpath(os.path.join(self.build_lib, ".."))
-        cprefix = os.path.commonprefix((self.build_base, top_dir))
-        if cprefix != self.build_base:
-            return
-
-        bin_dir = os.path.join(top_dir, "bin")
-        if os.path.exists(bin_dir):
-            remove_tree(bin_dir)
-
-        conf_dir = os.path.join(top_dir, "cnf")
-        if os.path.islink(conf_dir):
-            print(f"removing {repr(conf_dir)} symlink")
-            os.unlink(conf_dir)
-
-        pni_file = os.path.join(top_dir, ".portage_not_installed")
-        if os.path.exists(pni_file):
-            print(f"removing {repr(pni_file)}")
-            os.unlink(pni_file)
-
-    def clean_man(self):
-        man_dir = os.path.join(self.build_base, "man")
-        if os.path.exists(man_dir):
-            remove_tree(man_dir)
-
-    def run(self):
-        if self.all:
-            self.clean_tests()
-            self.clean_docs()
-            self.clean_man()
-
-        clean.run(self)
-
-
-class x_install(install):
-    """install command with extra Portage paths"""
-
-    user_options = install.user_options + [
-        # note: $prefix and $exec_prefix are reserved for Python install
-        ("system-prefix=", None, "Prefix for architecture-independent data"),
-        ("system-exec-prefix=", None, "Prefix for architecture-specific data"),
-        ("bindir=", None, "Install directory for main executables"),
-        ("datarootdir=", None, "Data install root directory"),
-        ("docdir=", None, "Documentation install directory"),
-        ("htmldir=", None, "HTML documentation install directory"),
-        ("mandir=", None, "Manpage root install directory"),
-        ("portage-base=", "b", "Portage install base"),
-        (
-            "portage-bindir=",
-            None,
-            "Install directory for Portage internal-use executables",
-        ),
-        ("portage-datadir=", None, "Install directory for data files"),
-        ("sbindir=", None, "Install directory for superuser-intended executables"),
-        ("sysconfdir=", None, "System configuration path"),
-    ]
-
-    # note: the order is important for proper substitution
-    paths = [
-        ("system_prefix", "/usr"),
-        ("system_exec_prefix", "$system_prefix"),
-        ("bindir", "$system_exec_prefix/bin"),
-        ("sbindir", "$system_exec_prefix/sbin"),
-        ("sysconfdir", "/etc"),
-        ("datarootdir", "$system_prefix/share"),
-        ("docdir", "$datarootdir/doc/$package-$version"),
-        ("htmldir", "$docdir/html"),
-        ("mandir", "$datarootdir/man"),
-        ("portage_base", "$system_exec_prefix/lib/portage"),
-        ("portage_bindir", "$portage_base/bin"),
-        ("portage_datadir", "$datarootdir/portage"),
-        # not customized at the moment
-        ("logrotatedir", "$sysconfdir/logrotate.d"),
-        ("portage_confdir", "$portage_datadir/config"),
-        ("portage_setsdir", "$portage_confdir/sets"),
-    ]
-
-    def initialize_options(self):
-        install.initialize_options(self)
-
-        for key, default in self.paths:
-            setattr(self, key, default)
-        self.subst_paths = {}
-
-    def finalize_options(self):
-        install.finalize_options(self)
-
-        # substitute variables
-        new_paths = {
-            "package": self.distribution.get_name(),
-            "version": self.distribution.get_version(),
-        }
-        for key, _default in self.paths:
-            new_paths[key] = subst_vars(getattr(self, key), new_paths)
-            setattr(self, key, new_paths[key])
-        self.subst_paths = new_paths
-
-
-class x_install_data(install_data):
-    """install_data with customized path support"""
-
-    user_options = install_data.user_options
-
-    def initialize_options(self):
-        install_data.initialize_options(self)
-        self.build_base = None
-        self.paths = None
-
-    def finalize_options(self):
-        install_data.finalize_options(self)
-        self.set_undefined_options("build", ("build_base", "build_base"))
-        self.set_undefined_options("install", ("subst_paths", "paths"))
-
-    def run(self):
-        def re_sub_file(path, pattern, repl):
-            print(f"Rewriting {path}")
-            with codecs.open(path, "r", "utf-8") as f:
-                data = f.read()
-            data = re.sub(pattern, repl, data, flags=re.MULTILINE)
-            with codecs.open(path, "w", "utf-8") as f:
-                f.write(data)
-
-        if create_entry_points:
-            re_sub_file("cnf/repos.conf", r"= /", "= %(EPREFIX)s/")
-            re_sub_file("cnf/make.globals", r'DIR="/', 'DIR="${EPREFIX}/')
-
-        self.run_command("build_man")
-
-        def process_data_files(df):
-            for d, files in df:
-                # substitute man sources
-                if d.startswith("$mandir/"):
-                    files = [os.path.join(self.build_base, v) for v in files]
-
-                # substitute variables in path
-                d = subst_vars(d, self.paths)
-                yield (d, files)
-
-        old_data_files = self.data_files
-        self.data_files = process_data_files(self.data_files)
-
-        install_data.run(self)
-        self.data_files = old_data_files
-
-
-class x_install_lib(install_lib):
-    """install_lib command with Portage path substitution"""
-
-    user_options = install_lib.user_options
-
-    def initialize_options(self):
-        install_lib.initialize_options(self)
-        self.portage_base = None
-        self.portage_bindir = None
-        self.portage_confdir = None
-
-    def finalize_options(self):
-        install_lib.finalize_options(self)
-        self.set_undefined_options(
-            "install",
-            ("portage_base", "portage_base"),
-            ("portage_bindir", "portage_bindir"),
-            ("portage_confdir", "portage_confdir"),
-        )
-
-    def install(self):
-        ret = install_lib.install(self)
-
-        def rewrite_file(path, val_dict):
-            path = os.path.join(self.install_dir, path)
-            print(f"Rewriting {path}")
-            with codecs.open(path, "r", "utf-8") as f:
-                data = f.read()
-
-            for varname, val in val_dict.items():
-                regexp = r"(?m)^(%s\s*=).*$" % varname
-                repl = r"\1 %s" % repr(val)
-
-                data = re.sub(regexp, repl, data)
-
-            with codecs.open(path, "w", "utf-8") as f:
-                f.write(data)
-
-        rewrite_file(
-            "portage/__init__.py",
-            {
-                "VERSION": self.distribution.get_version(),
-            },
-        )
-
-        def re_sub_file(path, pattern_repl_items):
-            path = os.path.join(self.install_dir, path)
-            print(f"Rewriting {path}")
-            with codecs.open(path, "r", "utf-8") as f:
-                data = f.read()
-            for pattern, repl in pattern_repl_items:
-                data = re.sub(pattern, repl, data, flags=re.MULTILINE)
-            with codecs.open(path, "w", "utf-8") as f:
-                f.write(data)
-
-        val_dict = {}
-        if create_entry_points:
-            re_sub_file(
-                "portage/const.py",
-                (
-                    (
-                        r"^(GLOBAL_CONFIG_PATH\s*=\s*[\"'])(.*)([\"'])",
-                        lambda m: "{}{}{}".format(
-                            m.group(1),
-                            m.group(2).partition("/usr")[-1],
-                            m.group(3),
-                        ),
-                    ),
-                    (
-                        r"^(PORTAGE_BASE_PATH\s*=\s*)(.*)",
-                        lambda m: "{}{}".format(
-                            m.group(1),
-                            'os.path.join(os.path.realpath(__import__("sys").prefix), "lib/portage")',
-                        ),
-                    ),
-                    (
-                        r"^(EPREFIX\s*=\s*)(.*)",
-                        lambda m: f'{m.group(1)}__import__("sys").prefix',
-                    ),
-                ),
-            )
-        else:
-            val_dict.update(
-                {
-                    "PORTAGE_BASE_PATH": self.portage_base,
-                    "PORTAGE_BIN_PATH": self.portage_bindir,
-                }
-            )
-        rewrite_file("portage/const.py", val_dict)
-
-        return ret
-
-
-class x_install_scripts_custom(install_scripts):
-    def initialize_options(self):
-        install_scripts.initialize_options(self)
-        self.root = None
-
-    def finalize_options(self):
-        self.set_undefined_options(
-            "install", ("root", "root"), (self.var_name, "install_dir")
-        )
-        install_scripts.finalize_options(self)
-        self.build_dir = os.path.join(self.build_dir, self.dir_name)
-
-        # prepend root
-        if self.root is not None:
-            self.install_dir = change_root(self.root, self.install_dir)
-
-    def run(self):
-        if not create_entry_points:
-            install_scripts.run(self)
-
-
-class x_install_scripts_bin(x_install_scripts_custom):
-    dir_name = "bin"
-    var_name = "bindir"
-
-
-class x_install_scripts_sbin(x_install_scripts_custom):
-    dir_name = "sbin"
-    var_name = "sbindir"
-
-
-class x_install_scripts_portagebin(x_install_scripts_custom):
-    dir_name = "portage"
-    var_name = "portage_bindir"
-
-
-class x_install_scripts(install_scripts):
-    def initialize_option(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        self.run_command("install_scripts_bin")
-        self.run_command("install_scripts_portagebin")
-        self.run_command("install_scripts_sbin")
-
-
-class x_sdist(sdist):
-    """sdist defaulting to .tar.bz2 format, and archive files owned by root"""
-
-    def finalize_options(self):
-        if self.owner is None:
-            self.owner = "root"
-        if self.group is None:
-            self.group = "root"
-
-        sdist.finalize_options(self)
-
-
-class build_tests(x_build_scripts_custom):
-    """Prepare build dir for running tests."""
-
-    def initialize_options(self):
-        x_build_scripts_custom.initialize_options(self)
-        self.build_base = None
-        self.build_lib = None
-
-    def finalize_options(self):
-        x_build_scripts_custom.finalize_options(self)
-        self.set_undefined_options(
-            "build", ("build_base", "build_base"), ("build_lib", "build_lib")
-        )
-
-        # since we will be writing to $build_lib/.., it is important
-        # that we do not leave $build_base
-        self.top_dir = os.path.normpath(os.path.join(self.build_lib, ".."))
-        cprefix = os.path.commonprefix((self.build_base, self.top_dir))
-        if cprefix != self.build_base:
-            raise SystemError("build_lib must be a subdirectory of build_base")
-
-        self.build_dir = os.path.join(self.top_dir, "bin")
-
-    def run(self):
-        self.run_command("build_py")
-
-        # install all scripts $build_lib/../bin
-        # (we can't do a symlink since we want shebangs corrected)
-        x_build_scripts_custom.run(self)
-
-        # symlink 'cnf' directory
-        conf_dir = os.path.join(self.top_dir, "cnf")
-        if os.path.exists(conf_dir):
-            if not os.path.islink(conf_dir):
-                raise SystemError(
-                    f"{repr(conf_dir)} exists and is not a symlink (collision)"
-                )
-            os.unlink(conf_dir)
-        conf_src = os.path.relpath("cnf", self.top_dir)
-        print(f"Symlinking {conf_dir} -> {conf_src}")
-        os.symlink(conf_src, conf_dir)
-
-        source_path = os.path.realpath(__file__)
-
-        # copy GPG test keys
-        copy_tree(
-            os.path.join(
-                os.path.dirname(source_path), "lib", "portage", "tests", ".gnupg"
-            ),
-            os.path.join(self.build_lib, "portage", "tests", ".gnupg"),
-        )
-        os.chmod(os.path.join(self.build_lib, "portage", "tests", ".gnupg"), 0o700)
-
-        # create $build_lib/../.portage_not_installed
-        # to enable proper paths in tests
-        with open(os.path.join(self.top_dir, ".portage_not_installed"), "w"):
-            pass
-
-
-class test(Command):
-    """run tests"""
-
-    user_options = []
-
-    def initialize_options(self):
-        self.build_lib = None
-
-    def finalize_options(self):
-        self.set_undefined_options("build", ("build_lib", "build_lib"))
-
-    def run(self):
-        self.run_command("build_tests")
-
-        subprocess.check_call(
-            [
-                sys.executable,
-                "-bWd",
-                os.path.join(self.build_lib, "portage/tests/runTests.py"),
-            ]
-        )
-
-
-def find_packages():
-    for dirpath, _dirnames, filenames in os.walk("lib"):
-        if "__init__.py" in filenames:
-            yield os.path.relpath(dirpath, "lib")
-
-
-def find_scripts():
-    for dirpath, _dirnames, filenames in os.walk("bin"):
-        for f in filenames:
-            yield os.path.join(dirpath, f)
-
-
-def get_manpages():
-    linguas = os.environ.get("LINGUAS")
-    if linguas is not None:
-        linguas = linguas.split()
-
-    for dirpath, _dirnames, filenames in os.walk("man"):
-        groups = collections.defaultdict(list)
-        for f in filenames:
-            _fn, suffix = f.rsplit(".", 1)
-            groups[suffix].append(os.path.join(dirpath, f))
-
-        topdir = dirpath[len("man/") :]
-        if not topdir or linguas is None or topdir in linguas:
-            for g, mans in groups.items():
-                yield [os.path.join("$mandir", topdir, f"man{g}"), mans]
-
-
-class build_ext(_build_ext):
-    user_options = _build_ext.user_options + [
-        (
-            "portage-ext-modules",
-            None,
-            "enable portage's C/C++ extensions (cross-compiling is not supported)",
-        ),
-    ]
-
-    boolean_options = _build_ext.boolean_options + [
-        "portage_ext_modules",
-    ]
-
-    def initialize_options(self):
-        _build_ext.initialize_options(self)
-        self.portage_ext_modules = None
-
-    def run(self):
-        if self.portage_ext_modules:
-            _build_ext.run(self)
-
-
-def venv_data_files(locations):
-    if not create_entry_points:
-        return
-    for dest_prefix, source_path, file_args in locations:
-        specific_files = []
-        mode_arg = None
-        for arg in file_args:
-            if arg.startswith("-m"):
-                mode_arg = int(arg[2:], 8)
-            else:
-                specific_files.append(arg)
-
-        abs_source_path = os.path.abspath(source_path)
-        for root, dirs, files in os.walk(abs_source_path):
-            root_offset = root[len(abs_source_path) :].lstrip("/")
-            dest_path = os.path.join(dest_prefix, root_offset)
-
-            if specific_files:
-                matched_files = list(
-                    itertools.chain.from_iterable(
-                        glob.glob(os.path.join(root, x)) for x in specific_files
-                    )
-                )
-            else:
-                matched_files = [os.path.join(root, x) for x in files]
-
-            if mode_arg:
-                for filename in matched_files:
-                    if not os.path.islink(filename):
-                        os.chmod(filename, mode_arg)
-
-            yield (dest_path, matched_files)
-
-
-def get_data_files(regular_files, venv_files):
-    if create_entry_points:
-        return list(venv_data_files(venv_files))
-
-    return regular_files
-
-
-setup(
-    name="portage",
-    version="3.0.49",
-    url="https://wiki.gentoo.org/wiki/Project:Portage",
-    project_urls={
-        "Release Notes": "https://gitweb.gentoo.org/proj/portage.git/plain/NEWS",
-        "Documentation": "https://wiki.gentoo.org/wiki/Handbook:AMD64/Working/Portage",
-    },
-    author="Gentoo Portage Development Team",
-    author_email="dev-portage@gentoo.org",
-    description="Portage is the package management and distribution system for Gentoo",
-    license="GPLV2",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    package_dir={"": "lib"},
-    packages=list(find_packages()),
-    # something to cheat build & install commands
-    scripts=list(find_scripts()),
-    data_files=get_data_files(
-        list(get_manpages())
-        + [
-            ["$sysconfdir", ["cnf/etc-update.conf", "cnf/dispatch-conf.conf"]],
-            ["$logrotatedir", ["cnf/logrotate.d/elog-save-summary"]],
-            [
-                "$portage_confdir",
-                ["cnf/make.conf.example", "cnf/make.globals", "cnf/repos.conf"],
-            ],
-            ["$portage_setsdir", ["cnf/sets/portage.conf"]],
-            ["$docdir", ["NEWS", "RELEASE-NOTES"]],
-            ["$portage_confdir/repo.postsync.d", ["cnf/repo.postsync.d/example"]],
-        ],
-        [
-            ("etc", "cnf", ("etc-update.conf", "dispatch-conf.conf")),
-            ("etc/logrotate.d", "cnf/logrotate.d", ("elog-save-summary",)),
-            (
-                "share/portage/config/repo.postsync.d",
-                "cnf/repo.postsync.d",
-                ("example",),
-            ),
-            (
-                "share/portage/config",
-                "cnf",
-                ("make.conf.example", "make.globals", "repos.conf"),
-            ),
-            ("share/portage/config/sets", "cnf/sets", ("*.conf",)),
-            ("share/man/man1", "man", ("*.1",)),
-            ("share/man/man5", "man", ("*.5",)),
-            ("share/portage/doc", "", ("NEWS", "RELEASE-NOTES")),
-            ("lib/portage/bin", "bin", ("-m0755",)),
-        ],
-    ),
-    entry_points={
-        "console_scripts": [
-            f"{os.path.basename(path)}=portage.util.bin_entry_point:bin_entry_point"
-            for path in itertools.chain.from_iterable(x_scripts.values())
-        ],
-    }
-    if create_entry_points
-    else {},
-    # create_entry_points disables ext_modules, for pure python
-    ext_modules=[]
-    if create_entry_points
-    else [
-        Extension(
-            name=n,
-            sources=m,
-            extra_compile_args=[
-                "-D_FILE_OFFSET_BITS=64",
-                "-D_LARGEFILE_SOURCE",
-                "-D_LARGEFILE64_SOURCE",
-            ],
-        )
-        for n, m in x_c_helpers.items()
-    ],
-    cmdclass={
-        "build": x_build,
-        "build_ext": build_ext,
-        "build_man": build_man,
-        "build_scripts": x_build_scripts,
-        "build_scripts_bin": x_build_scripts_bin,
-        "build_scripts_portagebin": x_build_scripts_portagebin,
-        "build_scripts_sbin": x_build_scripts_sbin,
-        "build_tests": build_tests,
-        "clean": x_clean,
-        "docbook": docbook,
-        "apidoc": apidoc,
-        "install": x_install,
-        "install_data": x_install_data,
-        "install_docbook": install_docbook,
-        "install_apidoc": install_apidoc,
-        "install_lib": x_install_lib,
-        "install_scripts": x_install_scripts,
-        "install_scripts_bin": x_install_scripts_bin,
-        "install_scripts_portagebin": x_install_scripts_portagebin,
-        "install_scripts_sbin": x_install_scripts_sbin,
-        "sdist": x_sdist,
-        "test": test,
-    },
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Environment :: Console",
-        "Intended Audience :: System Administrators",
-        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
-        "Operating System :: POSIX",
-        "Programming Language :: Python :: 3",
-        "Topic :: System :: Installation/Setup",
-    ],
-    python_requires=">=3.9",
-)