cmeel 0.46.0__tar.gz → 0.47.1__tar.gz

{cmeel-0.46.0 → cmeel-0.47.1}/PKG-INFO

@@ -1,18 +1,17 @@
 Metadata-Version: 2.1
 Name: cmeel
-Version: 0.46.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

{cmeel-0.46.0 → cmeel-0.47.1}/README.md

@@ -23,7 +23,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

{cmeel-0.46.0 → cmeel-0.47.1}/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-0.46.0 → cmeel-0.47.1}/cmeel/__main__.py

@@ -6,6 +6,7 @@ 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
@@ -42,6 +43,9 @@ def parse_args() -> argparse.Namespace:
     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()
 
     if args.verbose == 0:
@@ -50,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)
@@ -65,8 +69,10 @@ def main():
     args = parse_args()
     if args.cmd == "docker":
         docker_build(**vars(args))
-    if args.cmd == "release":
+    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-0.47.1/cmeel/build.py

@@ -0,0 +1,31 @@
+"""PEP 517 & 660 entry points."""
+
+import logging
+import os
+
+from .impl import build_impl
+from .sdist import sdist_impl
+
+LOG = logging.getLogger("cmeel")
+
+
+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_impl(wheel_directory, editable=True)
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None) -> str:
+    """Build a binary wheel: main entry point for PEP 517."""
+    LOG.info("cmeel build wheel")
+    return build_impl(wheel_directory, editable=False)
+
+
+def build_sdist(sdist_directory, config_settings=None) -> str:
+    """Generate a gzipped distribution tarball."""
+    return sdist_impl(sdist_directory)

{cmeel-0.46.0 → cmeel-0.47.1}/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-0.47.1/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-0.46.0 → cmeel-0.47.1}/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-0.47.1/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-0.47.1/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.46.0 → cmeel-0.47.1}/pyproject.toml

@@ -23,32 +23,32 @@ include = ['cmeel.pth']
 license = "BSD-2-Clause"
 name = "cmeel"
 readme = "README.md"
-version = "0.46.0"
+version = "0.47.1"
 
 [tool.poetry.dependencies]
-cmake = {optional = true, version = "^3.22.3"}
-importlib-metadata = {python = "<3.8", version = "^6.0.0"}
-packaging = {optional = true, version = "^23.0"}
-python = "^3.7"
+cmake = {optional = true, version = "^3.27.0"}
+git-archive-all = {optional = true, version = "^1.23.1"}
+packaging = {optional = true, version = "^23.1"}
+python = "^3.8"
 tomli = {python = "< 3.11", version = "^2.0.1"}
-wheel = {optional = true, version = ">=0.38.4,<0.41.0"}
+wheel = {optional = true, version = "^0.41.0"}
 
 [tool.poetry.extras]
-build = ["cmake", "packaging", "wheel"]
+build = ["cmake", "git-archive-all", "packaging", "wheel"]
 
 [tool.poetry.group.dev]
 optional = true
 
 [tool.poetry.group.dev.dependencies]
-black = "^23.1.0"
-furo = "^2023.3.27"
-isort = {python = "^3.8", version = "^5.12.0"}
-mypy = "^1.1.1"
-myst-parser = ">=0.18.1,<1.1.0"
-requests = "^2.29.0"
-ruff = ">=0.0.264,<0.0.271"
-safety = {allow-prereleases = true, version = "^2.4.0b1"}
-sphinx = "^5.3.0"
+black = "^23.7.0"
+furo = "^2023.7.26"
+isort = "^5.12.0"
+mypy = "^1.4.1"
+myst-parser = "^2.0.0"
+requests = "^2.31.0"
+ruff = "^0.0.282"
+# safety = {allow-prereleases = true, version = "^2.4.0b1"} TODO: bump when they fix packaging support
+sphinx = "^7.1.2"
 
 [tool.poetry.scripts]
 cmeel = "cmeel.__main__:main"

cmeel-0.46.0/cmeel/build.py

@@ -1,357 +0,0 @@
-"""Cmeel build.
-
-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,
-)
-
-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):
-    """Build an editable wheel: main entry point for PEP 660."""
-    os.environ["CMAKE_INSTALL_MODE"] = "ABS_SYMLINK"
-    return build(wheel_directory, editable=True)
-
-
-def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
-    """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("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