cmeel 0.45.0__py3-none-any.whl → 0.47.1__py3-none-any.whl

cmeel/__init__.py

@@ -1,9 +1,6 @@
 """Cmeel module."""
 
-try:
-    from importlib.metadata import metadata
-except ImportError:  # Python < 3.8
-    from importlib_metadata import metadata  # type: ignore
+from importlib.metadata import metadata
 
 __metadata__ = metadata("cmeel")
 __project_name__ = __metadata__["name"]

cmeel/__main__.py

@@ -6,8 +6,10 @@ import os
 import pathlib
 import sys
 
+from . import __version__
 from .docker import add_docker_arguments, docker_build
 from .env import add_paths_arguments, get_paths
+from .release import add_release_arguments, release
 
 LOG = logging.getLogger("cmeel")
 
@@ -39,6 +41,10 @@ def parse_args() -> argparse.Namespace:
 
     add_paths_arguments(subparsers)
     add_docker_arguments(subparsers)
+    add_release_arguments(subparsers)
+
+    ver = subparsers.add_parser("version", help="print current cmeel version.")
+    ver.set_defaults(cmd="version")
 
     args = parser.parse_args()
 
@@ -48,7 +54,7 @@ def parse_args() -> argparse.Namespace:
         level = 30 - 10 * args.verbose
     logging.basicConfig(level=level)
 
-    LOG.debug("parsed arguments :%s", args)
+    LOG.debug("parsed arguments: %s", args)
 
     if "cmd" in args:
         LOG.debug("running subcommand %s", args.cmd)
@@ -63,6 +69,10 @@ def main():
     args = parse_args()
     if args.cmd == "docker":
         docker_build(**vars(args))
+    elif args.cmd == "release":
+        release(**vars(args))
+    elif args.cmd == "version":
+        print(f"This is cmeel version {__version__}")
     else:
         print(get_paths(**vars(args)))
 

cmeel/backports.py

@@ -1,7 +1,7 @@
 # ruff: noqa
 
 try:
-    from argparse import BooleanOptionalAction
+    from argparse import BooleanOptionalAction  # type: ignore
 except ImportError:
     # Python < 3.9
     # https://github.com/python/cpython/blob/3.11/Lib/argparse.py#L885

cmeel/build.py

@@ -1,357 +1,31 @@
-"""Cmeel build.
+"""PEP 517 & 660 entry points."""
 
-Functions to generate package archives.
-"""
 import logging
 import os
-import re
-import sys
-import warnings
-from importlib.util import find_spec
-from pathlib import Path
-from subprocess import CalledProcessError, check_call, check_output, run
 
-try:
-    from packaging.tags import sys_tags
-except ImportError as e:
-    err = "You need the 'build' extra option to use this build module.\n"
-    err += "For this you can install the 'cmeel[build]' package."
-    raise ImportError(err) from e
-try:
-    import tomllib  # type: ignore
-except ModuleNotFoundError:
-    import tomli as tomllib  # type: ignore
-
-from . import __version__
-from .config import cmeel_config
-from .consts import CMEEL_PREFIX, SITELIB
-from .metadata import (
-    get_deps,
-    get_keywords,
-    get_license,
-    get_people,
-    get_readme,
-    get_urls,
-    normalize,
-)
+from .impl import build_impl
+from .sdist import sdist_impl
 
 LOG = logging.getLogger("cmeel")
-EXECUTABLE = """#!python
-from cmeel.run import cmeel_run
-cmeel_run()
-"""
-PATCH_IGNORE = [
-    "hunk ignored",
-    "hunks ignored",
-    "Skipping patch.",
-    "The next patch would delete",
-]
-
-
-class NonRelocatableError(Exception):
-    """Exception raised when absolute paths are in the final package."""
-
-    pass
-
-
-class PatchError(CalledProcessError):
-    """Exception raised when patch operation failed."""
-
-    def __str__(self):
-        """Render this error as a string."""
-        if self.returncode and self.returncode < 0:
-            return super().__str__()
-        return (
-            f"Command '{self.cmd}' exit status {self.returncode}\n"
-            f"with output:\n{self.output}\n"
-            f"and stderr:\n{self.stderr}\n"
-        )
-
-
-def deprecate_build_system(pyproject, key, default):
-    """Cmeel up to v0.22 was using the "build-system" section of pyproject.toml.
 
-    This function helps to deprecate that and move to "tool.cmeel".
-    """
-    if key in pyproject["build-system"]:
-        default = pyproject["build-system"][key]
-        warnings.warn(
-            'Using the "build-system" section of pyproject.toml for cmeel '
-            "configuration is deprecated since cmeel v0.23 and will be removed in v1.\n"
-            f'Please move your "{key} = {default}" to the "tool.cmeel" section.',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-    if "tool" in pyproject and "cmeel" in pyproject["tool"]:
-        return pyproject["tool"]["cmeel"].get(key, default)
-    return default
 
-
-def build_editable(wheel_directory, config_settings=None, metadata_directory=None):
+def build_editable(
+    wheel_directory,
+    config_settings=None,
+    metadata_directory=None,
+) -> str:
     """Build an editable wheel: main entry point for PEP 660."""
+    LOG.info("cmeel build editable")
     os.environ["CMAKE_INSTALL_MODE"] = "ABS_SYMLINK"
-    return build(wheel_directory, editable=True)
+    return build_impl(wheel_directory, editable=True)
 
 
-def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None) -> str:
     """Build a binary wheel: main entry point for PEP 517."""
-    return build(wheel_directory, editable=False)
-
-
-def build(wheel_directory, editable=False):  # noqa: C901 TODO
-    """Run CMake configure / build / test / install steps, and pack the wheel."""
-    logging.basicConfig(level=cmeel_config.log_level.upper())
-    LOG.info("CMake Wheel in editable mode" if editable else "CMake Wheel")
-    LOG.info("cmeel version %s" % __version__)
-    if LOG.getEffectiveLevel() <= logging.DEBUG:
-        if find_spec("pip") is not None:
-            LOG.debug("pip freeze:")
-            deps = check_output([sys.executable, "-m", "pip", "freeze"], text=True)
-            for dep in deps.strip().split("\n"):
-                LOG.debug("  %s", dep)
-
-    prefix = Path(".") / "build-editable" if editable else cmeel_config.temp_dir
-    build = prefix / "bld"
-    wheel_dir = prefix / "whl"
-    install = (prefix if editable else wheel_dir) / CMEEL_PREFIX
-    tag = str(next(sys_tags()))
-    # handle cross compilation on macOS with cibuildwheel
-    # ref. https://github.com/pypa/cibuildwheel/blob/6549a9/cibuildwheel/macos.py#L221
-    if "_PYTHON_HOST_PLATFORM" in os.environ:
-        plat = os.environ["_PYTHON_HOST_PLATFORM"].replace("-", "_").replace(".", "_")
-        tag = "-".join(tag.split("-")[:-1] + [plat])
-
-    LOG.info("load conf from pyproject.toml")
-    with Path("pyproject.toml").open("rb") as f:
-        pyproject = tomllib.load(f)
-        conf = pyproject["project"]
-        conf["name"] = normalize(conf["name"])
-        source = deprecate_build_system(pyproject, "source", ".")
-        run_tests = (
-            os.environ.get("CMEEL_RUN_TESTS", "ON").upper()
-            not in ("0", "NO", "OFF", "FALSE")
-            if "CMEEL_RUN_TESTS" in os.environ
-            else deprecate_build_system(pyproject, "run-tests", True)
-        )
-        run_tests_after_install = deprecate_build_system(
-            pyproject,
-            "run-tests-after-install",
-            False,
-        )
-        build_number = deprecate_build_system(pyproject, "build-number", 0)
-        configure_args = deprecate_build_system(pyproject, "configure-args", [])
-        test_cmd = deprecate_build_system(
-            pyproject,
-            "test-cmd",
-            ["cmake", "--build", "BUILD_DIR", "-t", "test"],
-        )
-        check_relocatable = deprecate_build_system(pyproject, "check-relocatable", True)
-        fix_pkg_config = deprecate_build_system(pyproject, "fix-pkg-config", True)
-        if deprecate_build_system(pyproject, "py3-none", False):
-            tag = "-".join(["py3", "none", tag.split("-")[-1]])
-        elif deprecate_build_system(pyproject, "any", False):
-            tag = "py3-none-any"
-        elif deprecate_build_system(pyproject, "pyver-any", False):
-            tag = f"py3{sys.version_info.minor}-none-any"
-    distribution = f"{conf['name'].replace('-', '_')}-{conf['version']}"
-
-    LOG.info("build wheel")
-
-    # Patch
-
-    if Path("cmeel.patch").exists():
-        LOG.info("patching")
-        cmd = ["patch", "-p0", "-s", "-N", "-i", "cmeel.patch"]
-        ret = run(cmd, capture_output=True, text=True)
-        if ret.returncode != 0:
-            # If this patch was already applied, it's okay.
-            for line in ret.stdout.split("\n"):
-                if not line or any(val in line for val in PATCH_IGNORE):
-                    continue
-                raise PatchError(
-                    returncode=ret.returncode,
-                    cmd=cmd,
-                    output=ret.stdout,
-                    stderr=ret.stderr + f"\nwrong line: {line}\n",
-                )
-            LOG.info("this patch was already applied")
-
-    # Set env
-
-    if run_tests_after_install:
-        path = f"{install / SITELIB}"
-        old = os.environ.get("PYTHONPATH", "")
-        if old:
-            path += f"{os.pathsep}{old}"
-        os.environ.update(PYTHONPATH=path)
-
-    # Configure
-
-    LOG.info("configure")
-    configure_env = cmeel_config.get_configure_env()
-    configure_args = cmeel_config.get_configure_args(
-        conf,
-        install,
-        configure_args,
-        configure_env,
-        run_tests,
-    )
-    configure_cmd = ["cmake", "-S", source, "-B", str(build), *configure_args]
-    LOG.debug("configure environment: %s", configure_env)
-    LOG.debug("configure command: %s", configure_cmd)
-    check_call(configure_cmd, env=configure_env)
-
-    LOG.info("build")
-    build_cmd = ["cmake", "--build", str(build), f"-j{cmeel_config.jobs}"]
-    LOG.debug("build command: %s", build_cmd)
-    check_call(build_cmd)
-
-    def launch_tests():
-        LOG.info("test")
-        test_env = cmeel_config.get_test_env()
-        cmd = [i.replace("BUILD_DIR", str(build)) for i in test_cmd]
-        LOG.debug("test environment: %s", test_env)
-        LOG.debug("test command: %s", cmd)
-        check_call(cmd, env=test_env)
-
-    if run_tests and not run_tests_after_install:
-        launch_tests()
-
-    LOG.info("install")
-    install_cmd = ["cmake", "--build", str(build), "-t", "install"]
-    LOG.debug("install command: %s", install_cmd)
-    check_call(install_cmd)
-
-    if run_tests and run_tests_after_install:
-        launch_tests()
-
-    LOG.info("fix relocatablization")
-    # Replace absolute install path in generated .cmake files, if any.
-    for f in install.rglob("*.cmake"):
-        ff = install / f"{f.stem}.fix"
-        with f.open("r") as fr, ff.open("w") as fw:
-            fw.write(fr.read().replace(str(install), "${PACKAGE_PREFIX_DIR}"))
-        f.unlink()
-        ff.rename(f)
-
-    LOG.info("create dist-info")
-
-    dist_info = wheel_dir / f"{distribution}.dist-info"
-    dist_info.mkdir(parents=True)
-
-    LOG.info("create dist-info / METADATA")
-
-    metadata = [
-        "Metadata-Version: 2.1",
-        f"Name: {conf['name']}",
-        f"Version: {conf['version']}",
-        f"Summary: {conf['description']}",
-        f"Requires-Python: {conf.get('requires-python', '>=3.7')}",
-        *get_license(conf, dist_info),
-        *get_people(conf, "author"),
-        *get_people(conf, "maintainer"),
-        *get_keywords(conf),
-        *get_urls(conf),
-        *get_deps(conf, pyproject["build-system"]["requires"]),
-        *[f"Classifier: {classifier}" for classifier in conf.get("classifiers", [])],
-        *get_readme(conf),
-    ]
-
-    with (dist_info / "METADATA").open("w") as f:
-        f.write("\n".join(metadata))
-
-    LOG.info("create dist-info / top level")
-    with (dist_info / "top_level.txt").open("w") as f:
-        f.write("")
-
-    LOG.info("create dist-info / WHEEL")
-    with (dist_info / "WHEEL").open("w") as f:
-        f.write(
-            "\n".join(
-                [
-                    "Wheel-Version: 1.0",
-                    f"Generator: cmeel {__version__}",
-                    "Root-Is-Purelib: false",
-                    f"Tag: {tag}",
-                    "",
-                ],
-            ),
-        )
-
-    bin_dir = install / "bin"
-    if bin_dir.is_dir():
-        LOG.info("adding executables")
-        scripts = wheel_dir / f"{distribution}.data" / "scripts"
-        scripts.mkdir(parents=True)
-        for fn in bin_dir.glob("*"):
-            executable = scripts / fn.name
-            with executable.open("w") as fe:
-                fe.write(EXECUTABLE)
-            executable.chmod(0o755)
-
-    if check_relocatable:
-        LOG.info("check generated cmake files")
-        wrong_dirs = [
-            "/tmp/pip-build-env",
-            "/tmp/pip-req-build",
-            "/opt/_internal",
-            str(prefix),
-        ]
-        for fc in install.glob("**/*.cmake"):
-            with fc.open() as f:
-                cmake_file = f.read()
-                if any(wrong_dir in cmake_file for wrong_dir in wrong_dirs):
-                    lines = cmake_file.split("\n")
-                    # Get indexes of of problematic lines
-                    indexes = [
-                        idx
-                        for idx, line in enumerate(lines)
-                        if any(wrong_dir in line for wrong_dir in wrong_dirs)
-                    ]
-                    # Get lines at those indexes and around them to display
-                    display = [
-                        f"{i}: {line}"
-                        for i, line in enumerate(lines)
-                        if any(
-                            idx in indexes for idx in (i - 2, i - 1, i, i + 1, i + 2)
-                        )
-                    ]
-                    raise NonRelocatableError(
-                        f"{fc} references temporary paths:\n" + "\n".join(display),
-                    )
-    if fix_pkg_config and not editable:
-        LOG.info("fix pkg-config files")
-        for fc in install.glob("**/*.pc"):
-            with fc.open() as f:
-                pc_file = f.read()
-            if str(install) in pc_file:
-                rel = str(fc.parent.relative_to(install))
-                fix = "/".join(["${pcfiledir}"] + [".." for _ in rel.split("/")])
-                LOG.warning("fix pkg-config %s: replace %s by %s", fc, install, fix)
-                with fc.open("w") as f:
-                    f.write(pc_file.replace(str(install), fix))
-    if editable:
-        LOG.info("Add .pth in wheel")
-        with (wheel_dir / f"{distribution}.pth").open("w") as f:
-            f.write(str((install / SITELIB).absolute()))
+    LOG.info("cmeel build wheel")
+    return build_impl(wheel_directory, editable=False)
 
-    LOG.info("wheel pack")
-    pack = check_output(
-        [
-            sys.executable,
-            "-m",
-            "wheel",
-            "pack",
-            "--build-number",
-            str(build_number),
-            "-d",
-            wheel_directory,
-            str(wheel_dir),
-        ],
-    ).decode()
-    LOG.debug("wheel pack output: %s", pack)
-    name = Path(re.search("Repacking wheel as (.*\\.whl)\\.\\.\\.", pack).group(1)).name
-    LOG.debug("returning '%s'", name)
 
-    LOG.info("done")
-    return name
+def build_sdist(sdist_directory, config_settings=None) -> str:
+    """Generate a gzipped distribution tarball."""
+    return sdist_impl(sdist_directory)

cmeel/consts.py

@@ -3,6 +3,6 @@ import os
 import sys
 
 CMEEL_PREFIX = "cmeel.prefix"
-SITELIB = os.sep.join(
+SITELIB = os.sep.join(  # noqa: PTH118
     ["lib", "python" + ".".join(sys.version.split(".")[:2]), "site-packages"],
 )

cmeel/impl.py

@@ -0,0 +1,200 @@
+"""Implementation of the main build function."""
+
+import logging
+import os
+import re
+import sys
+from pathlib import Path
+from subprocess import check_call, check_output
+
+try:
+    import tomllib  # type: ignore
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore
+
+from . import __version__
+from .config import cmeel_config
+from .consts import CMEEL_PREFIX, SITELIB
+from .metadata import metadata
+from .utils import (
+    deprecate_build_system,
+    ensure_relocatable,
+    expose_bin,
+    get_tag,
+    launch_tests,
+    log_pip,
+    normalize,
+    patch,
+)
+
+LOG = logging.getLogger("cmeel.impl")
+
+
+def build_impl(wheel_directory, editable=False) -> str:
+    """Run CMake configure / build / test / install steps, and pack the wheel."""
+    logging.basicConfig(level=cmeel_config.log_level.upper())
+    LOG.info("CMake Wheel in editable mode" if editable else "CMake Wheel")
+    LOG.info("cmeel version %s" % __version__)
+    log_pip()
+
+    prefix = Path() / "build-editable" if editable else cmeel_config.temp_dir
+    build = prefix / "bld"
+    wheel_dir = prefix / "whl"
+    install = (prefix if editable else wheel_dir) / CMEEL_PREFIX
+
+    LOG.info("load conf from pyproject.toml")
+    with Path("pyproject.toml").open("rb") as f:
+        pyproject = tomllib.load(f)
+
+    conf = pyproject["project"]
+    conf["name"] = normalize(conf["name"])
+    distribution = f"{conf['name'].replace('-', '_')}-{conf['version']}"
+
+    source = deprecate_build_system(pyproject, "source", ".")
+    run_tests = (
+        os.environ.get("CMEEL_RUN_TESTS", "ON").upper()
+        not in ("0", "NO", "OFF", "FALSE")
+        if "CMEEL_RUN_TESTS" in os.environ
+        else deprecate_build_system(pyproject, "run-tests", True)
+    )
+    run_tests_after_install = deprecate_build_system(
+        pyproject,
+        "run-tests-after-install",
+        False,
+    )
+    build_number = deprecate_build_system(pyproject, "build-number", 0)
+    configure_args = deprecate_build_system(pyproject, "configure-args", [])
+
+    check_relocatable = deprecate_build_system(pyproject, "check-relocatable", True)
+    fix_pkg_config = deprecate_build_system(pyproject, "fix-pkg-config", True)
+
+    LOG.info("build wheel")
+
+    # Patch
+
+    patch()
+
+    # Set env
+
+    if run_tests_after_install:
+        path = f"{install / SITELIB}"
+        old = os.environ.get("PYTHONPATH", "")
+        if old:
+            path += f"{os.pathsep}{old}"
+        os.environ.update(PYTHONPATH=path)
+
+    # Configure
+
+    LOG.info("configure")
+    configure_env = cmeel_config.get_configure_env()
+    configure_args = cmeel_config.get_configure_args(
+        conf,
+        install,
+        configure_args,
+        configure_env,
+        run_tests,
+    )
+    configure_cmd = ["cmake", "-S", source, "-B", str(build), *configure_args]
+    LOG.debug("configure environment: %s", configure_env)
+    LOG.debug("configure command: %s", configure_cmd)
+    check_call(configure_cmd, env=configure_env)
+
+    LOG.info("build")
+    build_cmd = ["cmake", "--build", str(build), f"-j{cmeel_config.jobs}"]
+    LOG.debug("build command: %s", build_cmd)
+    check_call(build_cmd)
+
+    launch_tests(True, run_tests and not run_tests_after_install, pyproject, build)
+
+    LOG.info("install")
+    install_cmd = ["cmake", "--build", str(build), "-t", "install"]
+    LOG.debug("install command: %s", install_cmd)
+    check_call(install_cmd)
+
+    launch_tests(False, run_tests and run_tests_after_install, pyproject, build)
+
+    LOG.info("fix relocatablization")
+    # Replace absolute install path in generated .cmake files, if any.
+    for cmake_file in install.rglob("*.cmake"):
+        ff = install / f"{cmake_file.stem}.fix"
+        with cmake_file.open("r") as fr, ff.open("w") as fw:
+            fw.write(fr.read().replace(str(install), "${PACKAGE_PREFIX_DIR}"))
+        cmake_file.unlink()
+        ff.rename(cmake_file)
+
+    LOG.info("create dist-info")
+
+    dist_info = wheel_dir / f"{distribution}.dist-info"
+    dist_info.mkdir(parents=True)
+
+    LOG.info("create dist-info / METADATA")
+
+    with (dist_info / "METADATA").open("w") as f:
+        requires = pyproject["build-system"]["requires"]
+        f.write("\n".join(metadata(conf, dist_info, requires)))
+
+    LOG.info("create dist-info / top level")
+    with (dist_info / "top_level.txt").open("w") as f:
+        f.write("")
+
+    LOG.info("create dist-info / WHEEL")
+    with (dist_info / "WHEEL").open("w") as f:
+        f.write(
+            "\n".join(
+                [
+                    "Wheel-Version: 1.0",
+                    f"Generator: cmeel {__version__}",
+                    "Root-Is-Purelib: false",
+                    f"Tag: {get_tag(pyproject)}",
+                    "",
+                ],
+            ),
+        )
+
+    expose_bin(install, wheel_dir, distribution)
+
+    ensure_relocatable(check_relocatable, install, prefix)
+
+    if editable:
+        LOG.info("Add .pth in wheel")
+        with (wheel_dir / f"{distribution}.pth").open("w") as f:
+            f.write(str((install / SITELIB).absolute()))
+    elif fix_pkg_config:
+        LOG.info("fix pkg-config files")
+        for fc in install.glob("**/*.pc"):
+            with fc.open() as f:
+                pc_file = f.read()
+            if str(install) in pc_file:
+                rel = str(fc.parent.relative_to(install))
+                fix = "/".join(["${pcfiledir}"] + [".." for _ in rel.split("/")])
+                LOG.warning("fix pkg-config %s: replace %s by %s", fc, install, fix)
+                with fc.open("w") as f:
+                    f.write(pc_file.replace(str(install), fix))
+
+    LOG.info("wheel pack")
+    pack = check_output(
+        [
+            sys.executable,
+            "-m",
+            "wheel",
+            "pack",
+            "--build-number",
+            str(build_number),
+            "-d",
+            wheel_directory,
+            str(wheel_dir),
+        ],
+    ).decode()
+    LOG.debug("wheel pack output: %s", pack)
+    parse_pack = re.search("Repacking wheel as (.*\\.whl)\\.\\.\\.", pack)
+    if parse_pack is None:
+        err = (
+            "'wheel pack' command did not provide the .whl name, "
+            "or the parser must be updated. Please report the following output: \n"
+        )
+        raise FileNotFoundError(err + pack)
+    name = Path(parse_pack.group(1)).name
+    LOG.debug("returning '%s'", name)
+
+    LOG.info("done")
+    return name

cmeel/metadata.py

@@ -5,7 +5,6 @@ https://packaging.python.org/en/latest/specifications/declaring-project-metadata
 """
 
 import glob
-import re
 import warnings
 from pathlib import Path
 from typing import Any, Dict, List, Tuple, Union
@@ -13,14 +12,6 @@ from typing import Any, Dict, List, Tuple, Union
 LICENSE_GLOBS = ["LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*"]
 
 
-def normalize(name: str) -> str:
-    """Normalize name.
-
-    ref. https://packaging.python.org/en/latest/specifications/name-normalization
-    """
-    return re.sub(r"[-_.]+", "-", name).lower()
-
-
 def get_license(conf: Dict[str, Any], dist_info: Path) -> List[str]:
     """Parse 'license' and 'license-files' keys."""
     metadata = []
@@ -237,3 +228,22 @@ def get_keywords(conf: Dict[str, Any]) -> List[str]:
         keywords = ",".join(conf["keywords"])
         metadata.append(f"Keywords: {keywords}")
     return metadata
+
+
+def metadata(conf, dist_info, requires) -> List[str]:
+    """Return the lines which should go in the METADATA / PKG-INFO file."""
+    return [
+        "Metadata-Version: 2.1",
+        f"Name: {conf['name']}",
+        f"Version: {conf['version']}",
+        f"Summary: {conf['description']}",
+        f"Requires-Python: {conf.get('requires-python', '>=3.8')}",
+        *get_license(conf, dist_info),
+        *get_people(conf, "author"),
+        *get_people(conf, "maintainer"),
+        *get_keywords(conf),
+        *get_urls(conf),
+        *get_deps(conf, requires),
+        *[f"Classifier: {classifier}" for classifier in conf.get("classifiers", [])],
+        *get_readme(conf),
+    ]

cmeel/release.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+"""Helper to release a cmeel project."""
+from logging import getLogger
+from pathlib import Path
+from subprocess import check_call
+
+try:
+    import tomllib  # type: ignore
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore
+
+LOG = getLogger("cmeel.release")
+
+
+def add_release_arguments(subparsers):
+    """Append release command for argparse."""
+    sub = subparsers.add_parser("release", help="release a cmeel project.")
+    sub.set_defaults(cmd="release")
+
+
+def release(**kwargs):
+    """Release a cmeel project."""
+    with Path("pyproject.toml").open("rb") as f:
+        pyproject = tomllib.load(f)
+
+    version = pyproject["project"]["version"]
+    build = pyproject.get("tool", {}).get("cmeel", {}).get("build-number", 0)
+    tag = f"v{version}.c{build}"
+    release = f"Cmeel Release {tag}"
+
+    LOG.info("Releasing vesion '%s'", tag)
+
+    commit_cmd = ["git", "commit", "-am", release]
+    LOG.debug("commit command: %s", commit_cmd)
+    check_call(commit_cmd)
+
+    tag_cmd = ["git", "tag", "-s", tag, "-m", release]
+    LOG.debug("tag command: %s", tag_cmd)
+    check_call(tag_cmd)
+
+    push_cmd = ["git", "push", "origin", tag]
+    LOG.debug("push command: %s", push_cmd)
+    check_call(push_cmd)
+
+
+if __name__ == "__main__":
+    import logging
+
+    logging.basicConfig(level=logging.DEBUG)
+    release()

cmeel/sdist.py

@@ -0,0 +1,36 @@
+"""Generate .tar.gz source distribution."""
+
+import logging
+from pathlib import Path
+
+try:
+    import tomllib  # type: ignore
+except ModuleNotFoundError:
+    import tomli as tomllib  # type: ignore
+
+try:
+    import git_archive_all
+except ImportError as e:
+    err = "You need the 'build' extra option to use this build module.\n"
+    err += "For this you can install the 'cmeel[build]' package."
+    raise ImportError(err) from e
+
+from .utils import normalize
+
+LOG = logging.getLogger("cmeel.sdist")
+
+
+def sdist_impl(sdist_directory) -> str:
+    """Implement the build_sdist entry point."""
+    LOG.info("load conf from pyproject.toml")
+    with Path("pyproject.toml").open("rb") as f:
+        pyproject = tomllib.load(f)
+
+    conf = pyproject["project"]
+    conf["name"] = normalize(conf["name"])
+    distribution = f"{conf['name'].replace('-', '_')}-{conf['version']}"
+
+    git_archive_all.main(
+        ["git_archive_all.py", str(Path(sdist_directory) / f"{distribution}.tar.gz")],
+    )
+    return distribution

cmeel/utils.py

@@ -0,0 +1,193 @@
+"""Utilities."""
+
+import logging
+import os
+import re
+import sys
+import warnings
+from importlib.util import find_spec
+from pathlib import Path
+from subprocess import CalledProcessError, check_call, check_output, run
+
+from .config import cmeel_config
+
+try:
+    from packaging.tags import sys_tags
+except ImportError as e:
+    err = "You need the 'build' extra option to use this build module.\n"
+    err += "For this you can install the 'cmeel[build]' package."
+    raise ImportError(err) from e
+
+LOG = logging.getLogger("cmeel.utils")
+
+PATCH_IGNORE = [
+    "hunk ignored",
+    "hunks ignored",
+    "Skipping patch.",
+    "The next patch would delete",
+]
+
+EXECUTABLE = """#!python
+from cmeel.run import cmeel_run
+cmeel_run()
+"""
+
+
+class PatchError(CalledProcessError):
+    """Exception raised when patch operation failed."""
+
+    def __str__(self):
+        """Render this error as a string."""
+        if self.returncode and self.returncode < 0:
+            return super().__str__()
+        return (
+            f"Command '{self.cmd}' exit status {self.returncode}\n"
+            f"with output:\n{self.output}\n"
+            f"and stderr:\n{self.stderr}\n"
+        )
+
+
+class NonRelocatableError(Exception):
+    """Exception raised when absolute paths are in the final package."""
+
+    pass
+
+
+def deprecate_build_system(pyproject, key, default):
+    """Cmeel up to v0.22 was using the "build-system" section of pyproject.toml.
+
+    This function helps to deprecate that and move to "tool.cmeel".
+    """
+    if key in pyproject["build-system"]:
+        default = pyproject["build-system"][key]
+        warnings.warn(
+            'Using the "build-system" section of pyproject.toml for cmeel '
+            "configuration is deprecated since cmeel v0.23 and will be removed in v1.\n"
+            f'Please move your "{key} = {default}" to the "tool.cmeel" section.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if "tool" in pyproject and "cmeel" in pyproject["tool"]:
+        return pyproject["tool"]["cmeel"].get(key, default)
+    return default
+
+
+def normalize(name: str) -> str:
+    """Normalize name.
+
+    ref. https://packaging.python.org/en/latest/specifications/name-normalization
+    """
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def log_pip():
+    """Log output of pip freeze."""
+    if LOG.getEffectiveLevel() <= logging.DEBUG:
+        if find_spec("pip") is not None:
+            LOG.debug("pip freeze:")
+            deps = check_output([sys.executable, "-m", "pip", "freeze"], text=True)
+            for dep in deps.strip().split("\n"):
+                LOG.debug("  %s", dep)
+
+
+def get_tag(pyproject) -> str:
+    """Find the correct tag for the wheel."""
+    tag = str(next(sys_tags()))
+    # handle cross compilation on macOS with cibuildwheel
+    # ref. https://github.com/pypa/cibuildwheel/blob/6549a9/cibuildwheel/macos.py#L221
+    if "_PYTHON_HOST_PLATFORM" in os.environ:
+        plat = os.environ["_PYTHON_HOST_PLATFORM"].replace("-", "_").replace(".", "_")
+        tag = "-".join(tag.split("-")[:-1] + [plat])
+
+    if deprecate_build_system(pyproject, "py3-none", False):
+        tag = "-".join(["py3", "none", tag.split("-")[-1]])
+    elif deprecate_build_system(pyproject, "any", False):
+        tag = "py3-none-any"
+    elif deprecate_build_system(pyproject, "pyver-any", False):
+        tag = f"py3{sys.version_info.minor}-none-any"
+    return tag
+
+
+def patch():
+    """Apply cmeel.patch if it exists and was not already applied."""
+    if Path("cmeel.patch").exists():
+        LOG.info("patching")
+        cmd = ["patch", "-p0", "-s", "-N", "-i", "cmeel.patch"]
+        ret = run(cmd, capture_output=True, text=True)
+        if ret.returncode != 0:
+            # If this patch was already applied, it's okay.
+            for line in ret.stdout.split("\n"):
+                if not line or any(val in line for val in PATCH_IGNORE):
+                    continue
+                raise PatchError(
+                    returncode=ret.returncode,
+                    cmd=cmd,
+                    output=ret.stdout,
+                    stderr=ret.stderr + f"\nwrong line: {line}\n",
+                )
+            LOG.info("this patch was already applied")
+
+
+def expose_bin(install: Path, wheel_dir: Path, distribution: str):
+    """Add scripts wrapping calls to CMEEL_PREFIX/bin/ executables."""
+    bin_dir = install / "bin"
+    if bin_dir.is_dir():
+        LOG.info("adding executables")
+        scripts = wheel_dir / f"{distribution}.data" / "scripts"
+        scripts.mkdir(parents=True)
+        for fn in bin_dir.glob("*"):
+            executable = scripts / fn.name
+            with executable.open("w") as fe:
+                fe.write(EXECUTABLE)
+            executable.chmod(0o755)
+
+
+def ensure_relocatable(check_relocatable: bool, install: Path, prefix: Path):
+    """Ensure no cmake file contains wrong absolute paths."""
+    if not check_relocatable:
+        return
+    LOG.info("check generated cmake files")
+    wrong_dirs = [
+        "/tmp/pip-build-env",
+        "/tmp/pip-req-build",
+        "/opt/_internal",
+        str(prefix),
+    ]
+    for fc in install.glob("**/*.cmake"):
+        with fc.open() as f:
+            cmake_file = f.read()
+            if any(wrong_dir in cmake_file for wrong_dir in wrong_dirs):
+                lines = cmake_file.split("\n")
+                # Get indexes of of problematic lines
+                indexes = [
+                    idx
+                    for idx, line in enumerate(lines)
+                    if any(wrong_dir in line for wrong_dir in wrong_dirs)
+                ]
+                # Get lines at those indexes and around them to display
+                display = [
+                    f"{i}: {line}"
+                    for i, line in enumerate(lines)
+                    if any(idx in indexes for idx in (i - 2, i - 1, i, i + 1, i + 2))
+                ]
+                raise NonRelocatableError(
+                    f"{fc} references temporary paths:\n" + "\n".join(display),
+                )
+
+
+def launch_tests(before: bool, now: bool, pyproject, build: Path):
+    """Launch tests, before or after the install."""
+    if not now:
+        return
+
+    test_cmd = deprecate_build_system(
+        pyproject,
+        "test-cmd",
+        ["cmake", "--build", "BUILD_DIR", "-t", "test"],
+    )
+    LOG.info("test {} install".format("before") if before else "after")
+    test_env = cmeel_config.get_test_env()
+    cmd = [i.replace("BUILD_DIR", str(build)) for i in test_cmd]
+    LOG.debug("test environment: %s", test_env)
+    LOG.debug("test command: %s", cmd)
+    check_call(cmd, env=test_env)

{cmeel-0.45.0.dist-info → cmeel-0.47.1.dist-info}/METADATA

@@ -1,18 +1,17 @@
 Metadata-Version: 2.1
 Name: cmeel
-Version: 0.45.0
+Version: 0.47.1
 Summary: Create Wheel from CMake projects
 Home-page: https://github.com/cmake-wheel/cmeel
 License: BSD-2-Clause
 Author: Guilhem Saurel
 Author-email: guilhem.saurel@laas.fr
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -21,11 +20,11 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: System :: Archiving :: Packaging
 Classifier: Topic :: System :: Software Distribution
 Provides-Extra: build
-Requires-Dist: cmake (>=3.22.3,<4.0.0) ; extra == "build"
-Requires-Dist: importlib-metadata (>=6.0.0,<7.0.0) ; python_version < "3.8"
-Requires-Dist: packaging (>=23.0,<24.0) ; extra == "build"
+Requires-Dist: cmake (>=3.27.0,<4.0.0) ; extra == "build"
+Requires-Dist: git-archive-all (>=1.23.1,<2.0.0) ; extra == "build"
+Requires-Dist: packaging (>=23.1,<24.0) ; extra == "build"
 Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
-Requires-Dist: wheel (>=0.38.4,<0.41.0) ; extra == "build"
+Requires-Dist: wheel (>=0.41.0,<0.42.0) ; extra == "build"
 Project-URL: Documentation, https://cmeel.readthedocs.io/
 Project-URL: changelog, https://github.com/cmake-wheel/cmeel/blob/main/CHANGELOG.md
 Description-Content-Type: text/markdown
@@ -55,7 +54,7 @@ https://matrix.to/#/#cmake-wheel:matrix.org
 
 ## Basic idea
 
-Glue between PEP 517 `build_wheel` function and modern CMake standard project configuration / build / test / install
+Glue between PEP 517 & 660 entry points and modern CMake standard project configuration / build / test / install
 
 This Install in `${PYTHON_SITELIB}/cmeel.prefix/`:
 - As there is a dot, it is not a valid python module name, so no risk of importing anything there by mistake
@@ -92,3 +91,11 @@ build-backend = "cmeel.build"
 Complete specification is available at:
 https://packaging.python.org/en/latest/specifications/declaring-project-metadata
 
+## Install
+
+If you want to use the helpers provided by cmeel, to *eg*. test building a project in a manylinux container with
+`cmeel docker`, the best way to install cmeel is to use pipx: `pipx install cmeel`
+
+Otherwise, if you just want to use the build backend, there is no need to install anything: your frontent (*eg.* `pip`)
+should do this for you
+

cmeel-0.47.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+cmeel/__init__.py,sha256=eEZ_-QB8hrFy71rXK-I3CfkC-LbTqMaM-5EzynRzwHU,247
+cmeel/__main__.py,sha256=gLQ5_di07raiL6u75jpE36QydXlsbBzSdff9mVKtbg4,2042
+cmeel/backports.py,sha256=ZJ34NDWgrlrSkq8AGrKof9SQexQH8sver2HmJIur80c,1473
+cmeel/build.py,sha256=iYcKI1CCiRry2ESee1gUrL71N8-6rC_yie97hCfKgz0,867
+cmeel/config.py,sha256=VrxuFCaoQ7c9cVeGNNMFR7Hl6Vv_G44x8perI-XhrjA,3634
+cmeel/consts.py,sha256=m0wZ8IbghuFII9hVnLzWBK9GLQn0ibrHIQkPB5YF0Yk,195
+cmeel/docker.py,sha256=wT-VZuGKj1wcdldwgsYcWmJK_rjo2Eh1USEDMOmlsBU,2775
+cmeel/env.py,sha256=OOA64v6KysZTvFup5rZuBFYVSDvPoW_6PqUcuf4m0Os,1235
+cmeel/impl.py,sha256=B7BbnV5hahytfkinwdtP_hfV1PwbOhQGMci92qUNhV8,6372
+cmeel/metadata.py,sha256=MVR2noMFVzJAKAdpSfi3nbLxf60btK_yHmsT9lETMaw,8496
+cmeel/pth.py,sha256=N0G1d8BHRcuzNEfQaK9WMW0h6s-Sjigc7JUAPPoeu4Q,403
+cmeel/release.py,sha256=j8vxeAevtUFfwlV4gXGJ6tWqR-CNHn_d69FRhgeWkjY,1356
+cmeel/run.py,sha256=sD2Is7MEb5yIUu6dMjzyOJgb-ErJh-EBII9WzL13zco,743
+cmeel/sdist.py,sha256=RRN-FksbDSnCsSpIkfpd0AWKIkbcqUUpAKml_8l3R1k,1015
+cmeel/utils.py,sha256=VGzjn5Z4Xjw--8sdL1ldaWXhC5oQEPG2Nl4v1JbUH2c,6604
+cmeel.pth,sha256=CD-QdG4ceUgq5wIEJZpipOSZQF8apq7i9u9RhsBWbc8,17
+cmeel-0.47.1.dist-info/LICENSE,sha256=4QHEuqIDbscybBc21CcazwRjix-rV-AH2QAZ4IqxlzQ,1324
+cmeel-0.47.1.dist-info/METADATA,sha256=rukCJUfjjF0vTv8jHCLeoji-62_AoylQV06Q1c7dnNk,4906
+cmeel-0.47.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+cmeel-0.47.1.dist-info/entry_points.txt,sha256=AiK0nCTi1LpRXxyiSCcbPsLYIpSvYW8GF7jcllMIl1U,45
+cmeel-0.47.1.dist-info/RECORD,,

cmeel-0.45.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-cmeel/__init__.py,sha256=qXgvoZwlDxRzuWhU5M88WFU42uSbOQS9TY4CfmKJTKY,352
-cmeel/__main__.py,sha256=oUdz8nBX0mtsDHoMh-_leiTY7grjFwrEzV-wkupKfYk,1661
-cmeel/backports.py,sha256=ahVkwvNplt4xqY8RAb7lzzDks9tzrgB5QEAGVzkeBqg,1457
-cmeel/build.py,sha256=dvUj6ofbpQLau3VvlvagqP0X6ap0cjB1r0jPecfvphI,12583
-cmeel/config.py,sha256=VrxuFCaoQ7c9cVeGNNMFR7Hl6Vv_G44x8perI-XhrjA,3634
-cmeel/consts.py,sha256=HRFNs1Zusp1aw7TfzseUcE6Llz4zbCGhxw0O1Wc5c5E,179
-cmeel/docker.py,sha256=wT-VZuGKj1wcdldwgsYcWmJK_rjo2Eh1USEDMOmlsBU,2775
-cmeel/env.py,sha256=OOA64v6KysZTvFup5rZuBFYVSDvPoW_6PqUcuf4m0Os,1235
-cmeel/metadata.py,sha256=sjcuglpUdalkTIB6REaH7eoD-6f04jzYIO9rftTaZOQ,8017
-cmeel/pth.py,sha256=N0G1d8BHRcuzNEfQaK9WMW0h6s-Sjigc7JUAPPoeu4Q,403
-cmeel/run.py,sha256=sD2Is7MEb5yIUu6dMjzyOJgb-ErJh-EBII9WzL13zco,743
-cmeel.pth,sha256=CD-QdG4ceUgq5wIEJZpipOSZQF8apq7i9u9RhsBWbc8,17
-cmeel-0.45.0.dist-info/LICENSE,sha256=4QHEuqIDbscybBc21CcazwRjix-rV-AH2QAZ4IqxlzQ,1324
-cmeel-0.45.0.dist-info/METADATA,sha256=Uf18Ajzg2ePo2nQZ48aRMvDb2tIlSnmCNPnTgz3CxRw,4615
-cmeel-0.45.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-cmeel-0.45.0.dist-info/entry_points.txt,sha256=AiK0nCTi1LpRXxyiSCcbPsLYIpSvYW8GF7jcllMIl1U,45
-cmeel-0.45.0.dist-info/RECORD,,