RFL.build 1.0.0__tar.gz

RFL.build-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: RFL.build
+Version: 1.0.0
+Summary: Rackslab Foundation Library: build package
+Author-email: Rémi Palancher <remi@rackslab.io>
+License: GPLv3+
+Project-URL: Homepage, https://github.com/rackslab/RFL
+Project-URL: Bug Tracker, https://github.com/rackslab/RFL/issues
+Keywords: utility,basic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: RFL.core
+Requires-Dist: tomli
+
+# RFL: build package
+
+Utilities to help backport builds of Python projects. 

RFL.build-1.0.0/README.md

@@ -0,0 +1,3 @@
+# RFL: build package
+
+Utilities to help backport builds of Python projects. 

RFL.build-1.0.0/RFL.build.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: RFL.build
+Version: 1.0.0
+Summary: Rackslab Foundation Library: build package
+Author-email: Rémi Palancher <remi@rackslab.io>
+License: GPLv3+
+Project-URL: Homepage, https://github.com/rackslab/RFL
+Project-URL: Bug Tracker, https://github.com/rackslab/RFL/issues
+Keywords: utility,basic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: RFL.core
+Requires-Dist: tomli
+
+# RFL: build package
+
+Utilities to help backport builds of Python projects. 

RFL.build-1.0.0/RFL.build.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+RFL.build.egg-info/PKG-INFO
+RFL.build.egg-info/SOURCES.txt
+RFL.build.egg-info/dependency_links.txt
+RFL.build.egg-info/entry_points.txt
+RFL.build.egg-info/requires.txt
+RFL.build.egg-info/top_level.txt
+rfl/build/__init__.py
+rfl/build/errors.py
+rfl/build/installsetup.py
+rfl/build/ninja.py
+rfl/build/projectversion.py
+rfl/build/scripts/setup

RFL.build-1.0.0/RFL.build.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

RFL.build-1.0.0/RFL.build.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+rfl-install-setup-generator = rfl.build.installsetup:main
+rfl-project-version = rfl.build.projectversion:main

RFL.build-1.0.0/RFL.build.egg-info/requires.txt

@@ -0,0 +1,2 @@
+RFL.core
+tomli

RFL.build-1.0.0/RFL.build.egg-info/top_level.txt

@@ -0,0 +1 @@
+rfl

RFL.build-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "RFL.build"
+version = "1.0.0"
+description = "Rackslab Foundation Library: build package"
+license = {text = "GPLv3+"}
+requires-python = ">=3.6"
+keywords = ["utility", "basic"]
+authors = [
+    {name = "Rémi Palancher", email = "remi@rackslab.io"},
+]
+dependencies = [
+    "RFL.core",
+    "tomli"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Systems Administration",
+]
+readme = "README.md"
+
+[project.urls]
+"Homepage" = "https://github.com/rackslab/RFL"
+"Bug Tracker" = "https://github.com/rackslab/RFL/issues"
+
+[project.scripts]
+rfl-install-setup-generator = "rfl.build.installsetup:main"
+rfl-project-version = "rfl.build.projectversion:main"
+
+[tool.setuptools.packages.find]
+include = ["rfl.build*"]
+
+[tool.setuptools.package-data]
+"rfl.build.scripts" = ["*"]

RFL.build-1.0.0/rfl/build/errors.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2024 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from rfl.core.errors import RFLError
+
+
+class BuildError(RFLError):
+    pass

RFL.build-1.0.0/rfl/build/installsetup.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import os
+from pathlib import Path
+import shutil
+
+
+def main():
+    """Install setup.py script provided by RFL.build package in scripts/ subfolder in
+    the current working directory."""
+    orig = Path(os.path.realpath(__file__)).parent.joinpath("scripts", "setup")
+    dest = Path(os.getcwd()).joinpath("setup.py")
+    print(f"Copying file {orig} to {dest}")
+    shutil.copy(orig, dest)

RFL.build-1.0.0/rfl/build/ninja.py

@@ -0,0 +1,235 @@
+# Copyright (c) 2011 Google Inc
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# This file originally comes from Ninja build system source tree:
+# https://github.com/ninja-build/ninja/blob/master/misc/ninja_syntax.py
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Python module to help generating .ninja files."""
+
+import sys
+import io
+import re
+import textwrap
+from pathlib import PurePath
+import subprocess
+
+
+def escape_path(word):
+    if isinstance(word, PurePath):
+        word = str(word)
+    return word.replace("$ ", "$$ ").replace(" ", "$ ").replace(":", "$:")
+
+
+def as_list(input):
+    if input is None:
+        return []
+    if isinstance(input, list):
+        return input
+    return [input]
+
+
+def escape(string):
+    """Escape a string such that it can be embedded into a Ninja file without
+    further interpretation."""
+    assert "\n" not in string, "Ninja syntax does not allow newlines"
+    # We only have one special metacharacter: '$'.
+    return string.replace("$", "$$")
+
+
+def expand(string, vars, local_vars={}):
+    """Expand a string containing $vars as Ninja would.
+
+    Note: doesn't handle the full Ninja variable syntax, but it's enough
+    to make configure.py's use of it work.
+    """
+
+    def exp(m):
+        var = m.group(1)
+        if var == "$":
+            return "$"
+        return local_vars.get(var, vars.get(var, ""))
+
+    return re.sub(r"\$(\$|\w*)", exp, string)
+
+
+class NinjaBuilder(object):
+    def __init__(self, width=512):
+        self.output = io.StringIO()
+        self.width = width
+
+    def newline(self):
+        self.output.write("\n")
+
+    def comment(self, text):
+        for line in textwrap.wrap(
+            text, self.width - 2, break_long_words=False, break_on_hyphens=False
+        ):
+            self.output.write("# " + line + "\n")
+
+    def variable(self, key, value, indent=0):
+        if value is None:
+            return
+        if isinstance(value, list):
+            value = " ".join(filter(None, value))  # Filter out empty strings.
+        self._line("%s = %s" % (key, value), indent)
+
+    def pool(self, name, depth):
+        self._line("pool %s" % name)
+        self.variable("depth", depth, indent=1)
+
+    def rule(
+        self,
+        name,
+        command,
+        description=None,
+        depfile=None,
+        generator=False,
+        pool=None,
+        restat=False,
+        rspfile=None,
+        rspfile_content=None,
+        deps=None,
+    ):
+        self._line("rule %s" % name)
+        self.variable("command", command, indent=1)
+        if description:
+            self.variable("description", description, indent=1)
+        if depfile:
+            self.variable("depfile", depfile, indent=1)
+        if generator:
+            self.variable("generator", "1", indent=1)
+        if pool:
+            self.variable("pool", pool, indent=1)
+        if restat:
+            self.variable("restat", "1", indent=1)
+        if rspfile:
+            self.variable("rspfile", rspfile, indent=1)
+        if rspfile_content:
+            self.variable("rspfile_content", rspfile_content, indent=1)
+        if deps:
+            self.variable("deps", deps, indent=1)
+
+    def build(
+        self,
+        outputs,
+        rule,
+        inputs=None,
+        implicit=None,
+        order_only=None,
+        variables=None,
+        implicit_outputs=None,
+        pool=None,
+        dyndep=None,
+    ):
+        outputs = as_list(outputs)
+        out_outputs = [escape_path(x) for x in outputs]
+        all_inputs = [escape_path(x) for x in as_list(inputs)]
+
+        if implicit:
+            implicit = [escape_path(x) for x in as_list(implicit)]
+            all_inputs.append("|")
+            all_inputs.extend(implicit)
+        if order_only:
+            order_only = [escape_path(x) for x in as_list(order_only)]
+            all_inputs.append("||")
+            all_inputs.extend(order_only)
+        if implicit_outputs:
+            implicit_outputs = [escape_path(x) for x in as_list(implicit_outputs)]
+            out_outputs.append("|")
+            out_outputs.extend(implicit_outputs)
+
+        self._line(
+            "build %s: %s" % (" ".join(out_outputs), " ".join([rule] + all_inputs))
+        )
+        if pool is not None:
+            self._line("  pool = %s" % pool)
+        if dyndep is not None:
+            self._line("  dyndep = %s" % dyndep)
+
+        if variables:
+            if isinstance(variables, dict):
+                iterator = iter(variables.items())
+            else:
+                iterator = iter(variables)
+
+            for key, val in iterator:
+                self.variable(key, val, indent=1)
+
+        return outputs
+
+    def include(self, path):
+        self._line("include %s" % path)
+
+    def subninja(self, path):
+        self._line("subninja %s" % path)
+
+    def default(self, paths):
+        self._line("default %s" % " ".join(as_list(paths)))
+
+    def _count_dollars_before_index(self, s, i):
+        """Returns the number of '$' characters right in front of s[i]."""
+        dollar_count = 0
+        dollar_index = i - 1
+        while dollar_index > 0 and s[dollar_index] == "$":
+            dollar_count += 1
+            dollar_index -= 1
+        return dollar_count
+
+    def _line(self, text, indent=0):
+        """Write 'text' word-wrapped at self.width characters."""
+        leading_space = "  " * indent
+        while len(leading_space) + len(text) > self.width:
+            # The text is too wide; wrap if possible.
+
+            # Find the rightmost space that would obey our width constraint and
+            # that's not an escaped space.
+            available_space = self.width - len(leading_space) - len(" $")
+            space = available_space
+            while True:
+                space = text.rfind(" ", 0, space)
+                if space < 0 or self._count_dollars_before_index(text, space) % 2 == 0:
+                    break
+
+            if space < 0:
+                # No such space; just use the first unescaped space we can find.
+                space = available_space - 1
+                while True:
+                    space = text.find(" ", space + 1)
+                    if (
+                        space < 0
+                        or self._count_dollars_before_index(text, space) % 2 == 0
+                    ):
+                        break
+            if space < 0:
+                # Give up on breaking.
+                break
+
+            self.output.write(leading_space + text[0:space] + " $\n")
+            text = text[space + 1 :]
+
+            # Subsequent lines are continuations, so indent them.
+            leading_space = "  " * (indent + 2)
+
+        self.output.write(leading_space + text + "\n")
+
+    def run(self):
+        self.output.seek(0)
+        try:
+            subprocess.run(
+                ["ninja", "-f", "/dev/stdin"], input=self.output.read().encode()
+            )
+        except subprocess.CalledProcessError as err:
+            print(
+                "Error while running ninja:\n"
+                f"  exit code: {err.returncode}\n"
+                f"  stdout: {err.stdout}\n"
+                f"  stderr: {err.stderr}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        finally:
+            self.output.close()

RFL.build-1.0.0/rfl/build/projectversion.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""
+This tiny utility loads pyproject.toml file of current working directory project,
+looking for this file in parents directory recursively up to filesystem root. If the
+file is found, print the version of the project on stdout. Else, print an error.
+"""
+
+import sys
+from pathlib import Path
+
+# First try to import Python standard toml library (available in Python 3.11+) and
+# fallback to external library.
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+from .errors import BuildError
+
+
+def project_version():
+    current_dir = Path.cwd()
+    found = False
+    while True:
+        pyproject_path = current_dir.joinpath("pyproject.toml")
+        if pyproject_path.exists():
+            found = True
+            break
+        else:
+            # Stop iteration when filesystem root is reached.
+            if str(current_dir) == current_dir.root:
+                break
+            # Jump to parent directory.
+            current_dir = current_dir.parent
+
+    if not found:
+        raise BuildError(
+            "Unable to find project pyproject.toml file of current working directory",
+        )
+    content = tomllib.load(open(pyproject_path, "rb"))
+    try:
+        return content["project"]["version"]
+    except KeyError as err:
+        raise BuildError(
+            f"Unable to extract version from project file {pyproject_path}"
+        ) from err
+
+
+def main():
+    try:
+        print(project_version())
+    except BuildError as err:
+        print(str(err), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

RFL.build-1.0.0/rfl/build/scripts/setup

@@ -0,0 +1,100 @@
+# Copyright (c) 2023 Rackslab
+#
+# This file is part of RFL.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""
+This setup.py loads parameter defined in pyproject.toml and calls setuptools.setup()
+with these parameters. This script is especially useful to build modern PEP 518 Python
+projects that provide pyproject.toml with old versions of pip/python (eg. python 3.6)
+without PEP 518 support.
+"""
+
+import sys
+import os
+
+from setuptools import setup, find_packages
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+header = "rfl-build"
+
+with open("pyproject.toml", "rb") as fh:
+    pyproject = tomllib.load(fh)
+
+# Nothing much can be done by the script.
+if "project" not in pyproject:
+    print(f"{header}: project section not found, leaving.")
+    sys.exit(0)
+
+# Initialize dict of additional options
+kwargs = {}
+
+if "scripts" in pyproject["project"]:
+    kwargs["entry_points"] = {
+        "console_scripts": [
+            f"{executable}={caller}"
+            for executable, caller in pyproject["project"]["scripts"].items()
+        ]
+    }
+
+# Python Packaging User Guide suggests using find_namespace_packages(…) to support
+# namespace packages:
+#
+# https://packaging.python.org/en/latest/guides/packaging-namespace-packages/#native-namespace-packages
+#
+# Unfortunately, this function is not support in setuptools < v40.1.0 that is provided
+# on systems with Python 3.6 where this setup.py script is required (el8). The
+# alternative solution is to explicitely list the packages to install. Then the
+# following logic detects if there is a native namespace (when one topfolder declared in
+# [tool.setuptools.packages.find] include directive does not contain an __init__.py). In
+# this case, the subpackages are explicity declared (without wildcard) in setup(). If no
+# namespace is detected, the packages are automatically detected with find_packages().
+
+autofind = True
+packages = []
+for include in pyproject["tool"]["setuptools"]["packages"]["find"]["include"]:
+    if "." not in include:
+        continue
+    topfolder = include.split(".", 1)[0]
+    if "__init__.py" not in os.listdir(topfolder):
+        autofind = False
+    packages.append(include.replace("*", ""))
+
+if autofind:
+    kwargs["packages"] = find_packages()
+else:
+    kwargs["packages"] = packages
+
+print(f"{header}: packages: {kwargs['packages']}")
+
+if "package-data" in pyproject["tool"]["setuptools"]:
+    kwargs["package_data"] = {
+        package: data
+        for package, data in pyproject["tool"]["setuptools"]["package-data"].items()
+    }
+    kwargs["include_package_data"] = True
+    print(f"{header}: package data {kwargs['package_data']}")
+
+if "optional-dependencies" in pyproject["project"]:
+    kwargs["extras_require"] = {
+        extra: deps
+        for extra, deps in pyproject["project"]["optional-dependencies"].items()
+    }
+    print(f"{header}: extras require {kwargs['extras_require']}")
+
+setup(
+    name=pyproject["project"]["name"],
+    version=pyproject["project"]["version"],
+    author=pyproject["project"]["authors"][0]["name"],
+    author_email=pyproject["project"]["authors"][0]["email"],
+    license=pyproject["project"]["license"]["text"],
+    url=pyproject["project"]["urls"]["Homepage"],
+    platforms=["GNU/Linux"],
+    install_requires=pyproject["project"]["dependencies"],
+    **kwargs,
+)

RFL.build-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+