cola-cli 0.1.0__py3-none-any.whl

cola_cli/__init__.py

@@ -0,0 +1,3 @@
+"""The CLI never imports COLA's native Python bindings."""
+
+__version__ = "0.1.0"

cola_cli/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

cola_cli/builders.py

@@ -0,0 +1,347 @@
+"""Adapters for CMake, uv, Julia Pkg and Gradle. No custom dependency resolver."""
+
+import json
+import os
+import platform
+import shlex
+import shutil
+from pathlib import Path
+
+import click
+
+from .common import ColaError, execute
+from .sources import ordered, snapshot, toml
+
+SCRIPTS = Path(__file__).with_name("scripts")
+
+
+def managed_environment(root, generation, spec):
+    env = os.environ.copy()
+    for key in (
+        "COLA_DIR",
+        "COLA_ROOT",
+        "COLA_INSTALL_PREFIX",
+        "COLA_FETCH_MODE",
+        "CMAKE_PREFIX_PATH",
+        "DESTDIR",
+        "PYTHONPATH",
+        "PYTHONHOME",
+        "VIRTUAL_ENV",
+        "CONDA_PREFIX",
+        "JULIA_PROJECT",
+        "JULIA_LOAD_PATH",
+        "JULIA_DEPOT_PATH",
+        "CLASSPATH",
+        "LD_LIBRARY_PATH",
+        "DYLD_LIBRARY_PATH",
+        "CMAKE_ARGS",
+    ):
+        env.pop(key, None)
+    for key in list(env):
+        if key.startswith("UV_") and key not in {"UV_INDEX_URL", "UV_EXTRA_INDEX_URL", "UV_DEFAULT_INDEX", "UV_INDEX"}:
+            env.pop(key)
+    prefix = generation / "prefix"
+    env.update(
+        COLA_DIR=str(prefix),
+        COLA_INSTALL_PREFIX=str(prefix),
+        PYTHONNOUSERSITE="1",
+        CMAKE_PREFIX_PATH=os.pathsep.join([str(prefix), *spec.get("prefixes", [])]),
+        JULIA_PROJECT=str(generation / "julia"),
+        JULIA_LOAD_PATH="@:@stdlib",
+        JULIA_DEPOT_PATH=str(generation / "julia-depot"),
+        JULIA_PKG_PRECOMPILE_AUTO="0",
+        UV_CACHE_DIR=str(root / "cache" / "uv"),
+        UV_NO_CONFIG="1",
+        UV_PYTHON_DOWNLOADS="never",
+        COLA_BUILD_LOG=str(generation / "build.log"),
+    )
+    # PEP 517 backends may prefer clang++ from PATH while plain CMake chooses c++.
+    # Select one compiler before either tool is invoked (also avoids accidental WASI toolchains).
+    for variable, default in (("CC", "cc"), ("CXX", "c++"), ("FC", "gfortran")):
+        executable = shutil.which(env.get(variable, default))
+        if executable:
+            env[variable] = executable
+    return env
+
+
+class Builder:
+    def __init__(self, root, generation, spec, modules, previous, jobs):
+        self.root, self.generation, self.spec = root, generation, spec
+        self.modules, self.previous, self.jobs = modules, previous, jobs
+        self.prefix = generation / "prefix"
+        self.env = managed_environment(root, generation, spec)
+        self.locks = {"native": {}, "gradle": {}}
+
+    def command(self, args, **kwargs):
+        return execute(args, env=self.env, **kwargs)
+
+    def uv(self, *args, **kwargs):
+        from uv import find_uv_bin
+
+        return self.command([find_uv_bin(), *args], **kwargs)
+
+    def source(self, name):
+        return self.generation / "src" / name
+
+    def toolchain(self):
+        from uv import find_uv_bin
+
+        from . import __version__
+
+        commands = {
+            "python": [self.spec["python"], "--version"],
+            "cmake": ["cmake", "--version"],
+            "cxx": [self.env.get("CXX", "c++"), "--version"],
+            "uv": [find_uv_bin(), "--version"],
+        }
+        if "fortran" in self.modules:
+            commands["fortran"] = [self.env.get("FC", "gfortran"), "--version"]
+        if "julia" in self.modules:
+            commands["julia"] = ["julia", "--version"]
+        if "java" in self.modules:
+            commands["java"] = ["javac", "--version"]
+        for name in self.modules:
+            source = self.source(name)
+            if any(source.glob("build.gradle*")):
+                gradle = source / "gradlew"
+                if gradle.is_file():
+                    # Lock the wrapper's bytes through the source snapshot, not its transient path.
+                    commands[f"gradle:{name}"] = [str(gradle), "--version"]
+                else:
+                    commands[f"gradle:{name}"] = ["gradle", "--version"]
+        versions = {}
+        for key, command in commands.items():
+            versions[key] = self.command(command, capture=True).strip()
+        versions["system"] = platform.system()
+        versions["machine"] = platform.machine()
+        versions["cola-cli"] = __version__
+        versions["flags"] = {
+            key: os.environ.get(key, "")
+            for key in (
+                "CC",
+                "CXX",
+                "FC",
+                "CFLAGS",
+                "CXXFLAGS",
+                "FFLAGS",
+                "LDFLAGS",
+                "SDKROOT",
+                "MACOSX_DEPLOYMENT_TARGET",
+                "JAVA_HOME",
+                "CMAKE_TOOLCHAIN_FILE",
+            )
+        }
+        return versions
+
+    def native(self, name):
+        click.echo(f"Building {name} with CMake")
+        source = self.source(name)
+        if name == "core":
+            # Older COLA releases interpolate unquoted prefixes into their installed config.
+            # Apply this compatibility fix to the generation copy, never the user's checkout.
+            config = source / "data" / "COLAConfig.cmake.in"
+            if config.is_file():
+                text = config.read_text()
+                lines = []
+                for line in text.splitlines():
+                    if line.startswith("include(@CMAKE_INSTALL_PREFIX@/"):
+                        line = 'include("' + line[len("include(") : -1] + '")'
+                    elif line.startswith("set_and_check(") and " @CMAKE_INSTALL_PREFIX@" in line:
+                        key, path = line[:-1].split(" ", 1)
+                        line = key + ' "' + path + '")'
+                    lines.append(line)
+                config.write_text("\n".join(lines) + "\n")
+        build = self.generation / "build" / name
+        args = [
+            "cmake",
+            "-S",
+            source,
+            "-B",
+            build,
+            "-G",
+            "Unix Makefiles",
+            "-DCMAKE_BUILD_TYPE=Release",
+            f"-DCMAKE_INSTALL_PREFIX={self.prefix}",
+            "-DCMAKE_INSTALL_LIBDIR=lib",
+            "-DBUILD_TESTING=OFF",
+            "-Dtinyxml2_BUILD_TESTING=OFF",
+            "-DCMAKE_FIND_USE_PACKAGE_REGISTRY=OFF",
+            "-DCMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY=OFF",
+            *self.modules[name]["cmake_args"],
+        ]
+        if self.previous:
+            args.append("-DFETCHCONTENT_FULLY_DISCONNECTED=ON")
+            for dependency, identity in self.previous["locks"]["native"].get(name, {}).items():
+                cached = self.root / "sources" / identity["sha256"]
+                from .sources import tree_hash
+
+                if not cached.is_dir() or tree_hash(cached) != identity["sha256"]:
+                    raise ColaError(f"Missing or modified native dependency snapshot: {cached}")
+                target = self.generation / "native-deps" / name / dependency
+                shutil.copytree(cached, target)
+                args.append(f"-DFETCHCONTENT_SOURCE_DIR_{dependency.upper()}={target}")
+        if any(source.glob("build.gradle*")):
+            args.append(f"-DGRADLE_EXECUTABLE={self.gradle(name)}")
+        self.command(args)
+        self.command(["cmake", "--build", build, "--parallel", self.jobs])
+        self.command(["cmake", "--install", build])
+        dependencies = {}
+        if self.previous:
+            dependencies = self.previous["locks"]["native"].get(name, {})
+        elif (build / "_deps").is_dir():
+            for dependency in sorted((build / "_deps").glob("*-src")):
+                dependencies[dependency.name.removesuffix("-src")] = snapshot(
+                    self.root,
+                    {"kind": "path", "path": str(dependency), "subdirectory": "."},
+                )
+        self.locks["native"][name] = dependencies
+        if any(source.glob("build.gradle*")):
+            files = {}
+            for path in source.rglob("*gradle.lockfile"):
+                files[path.relative_to(source).as_posix()] = path.read_text()
+            if not files:
+                raise ColaError(f"Gradle produced no dependency lock for {name}; cannot seal this environment.")
+            self.locks["gradle"][name] = files
+
+    def gradle(self, name):
+        source = self.source(name)
+        if self.previous:
+            for relative, text in self.previous["locks"]["gradle"].get(name, {}).items():
+                path = source / relative
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(text)
+        executable = source / "gradlew"
+        if not executable.is_file():
+            executable = shutil.which("gradle")
+            if not executable:
+                raise ColaError(f"{name} requires Gradle or a checked-in Gradle Wrapper.")
+        script = self.generation / "bin" / f"{name}-gradle"
+        script.parent.mkdir(parents=True, exist_ok=True)
+        args = [str(executable), "--no-daemon", "--init-script", str(SCRIPTS / "locking.gradle")]
+        if not self.previous:
+            args.append("--write-locks")
+        script.write_text("#!/bin/sh\nexec " + shlex.join(args) + ' "$@"\n')
+        script.chmod(0o755)
+        return script
+
+    def julia(self):
+        packages = [name for name in ordered(self.modules) if self.modules[name]["backend"] == "julia"]
+        if not packages:
+            return
+        click.echo("Installing Julia packages with Pkg")
+        project = self.generation / "julia"
+        project.mkdir()
+        if self.previous:
+            for filename, text in self.previous["locks"]["julia"].items():
+                (project / filename).write_text(text)
+        args = [
+            "julia",
+            "--startup-file=no",
+            f"--project={project}",
+            str(SCRIPTS / "install.jl"),
+            "locked" if self.previous else "resolve",
+            *[f"../src/{name}" for name in packages],
+        ]
+        self.command(args, cwd=project)
+        files = {filename: (project / filename).read_text() for filename in ("Project.toml", "Manifest.toml")}
+        if self.previous and files != self.previous["locks"]["julia"]:
+            raise ColaError("Julia Pkg changed the locked environment; run 'cola build' to accept a new resolution.")
+        self.locks["julia"] = files
+
+    def python(self):
+        click.echo("Installing Python packages with uv")
+        project = self.generation / "python"
+        project.mkdir()
+        packages, requirements = {}, set()
+        for name in ordered(self.modules):
+            if self.modules[name]["backend"] != "python":
+                continue
+            metadata = toml(self.source(name) / "pyproject.toml")
+            package_name = metadata.get("project", {}).get("name")
+            if not package_name:
+                raise ColaError(f"{name} must declare project.name in pyproject.toml.")
+            if package_name in packages:
+                raise ColaError(f"Two modules provide the Python distribution {package_name}.")
+            packages[package_name] = name
+            requirements.update(metadata.get("build-system", {}).get("requires", []))
+        dependencies = sorted(set(packages) | requirements)
+        quote = json.dumps
+        text = (
+            '[project]\nname = "cola-global-runtime"\nversion = "0.0.0"\nrequires-python = ">=3.11"\n'
+            + "dependencies = "
+            + json.dumps(dependencies)
+            + "\n\n[tool.uv]\npackage = false\n\n[tool.uv.sources]\n"
+        )
+        for package, name in sorted(packages.items()):
+            text += f"{quote(package)} = {{ path = {quote('../src/' + name)}, editable = false }}\n"
+        (project / "pyproject.toml").write_text(text)
+        if self.previous:
+            if text != self.previous["locks"]["python"]["pyproject.toml"]:
+                raise ColaError("Python package metadata differs from the active lock.")
+            (project / "uv.lock").write_text(self.previous["locks"]["python"]["uv.lock"])
+        else:
+            self.uv("lock", "--project", project, "--python", self.spec["python"])
+        # Install the locked build backends first, then build first-party packages in that environment.
+        # This keeps PEP 517 build requirements under the same uv lock.
+        common = ["sync", "--locked", "--project", project, "--python", self.spec["python"]]
+        skip = [arg for package in packages for arg in ("--no-install-package", package)]
+        self.uv(*common, *skip)
+        # COLA wheels embed a generation-specific native prefix; never reuse such a wheel from another build.
+        self.uv(*common, "--no-build-isolation", "--no-cache")
+        self.locks["python"] = {
+            filename: (project / filename).read_text() for filename in ("pyproject.toml", "uv.lock")
+        }
+
+    def build(self):
+        order = ordered(self.modules)
+        # The MVP has a deliberate build phase order. Reject unsupported cross-language
+        # build cycles instead of attempting to resolve them or silently ignoring depends.
+        phases = {}
+        for name in order:
+            module = self.modules[name]
+            phases[name] = (
+                0
+                if module["role"] == "core"
+                else 1
+                if module["role"] in {"java", "fortran"}
+                else 2
+                if module["backend"] == "julia"
+                else 3
+                if module["backend"] == "cmake"
+                else 4
+            )
+        for name, module in self.modules.items():
+            for dependency in module["depends"]:
+                if phases[dependency] > phases[name]:
+                    raise ColaError(
+                        f"{name} requires {dependency} in an unsupported build phase. "
+                        "MVP order: core, Java/Fortran bridges, Julia, native filters, Python packages."
+                    )
+        self.prefix.mkdir()
+        # Julia's Pkg.build installs its CMake bridge after the core exists.
+        self.native("core")
+        for name in order:
+            if name != "core" and self.modules[name]["role"] in {"fortran", "java"}:
+                self.native(name)
+        self.julia()
+        for name in order:
+            if self.modules[name]["backend"] == "cmake" and not self.modules[name]["role"]:
+                self.native(name)
+        self.python()
+        return self.locks
+
+    def check(self):
+        click.echo("Checking the completed runtime and native modules")
+        libraries = list(
+            dict.fromkeys(library for name in ordered(self.modules) for library in self.modules[name]["libraries"])
+        )
+        self.command(
+            [
+                self.generation / "python" / ".venv" / "bin" / "python",
+                "-I",
+                Path(__file__).with_name("runtime.py"),
+                "--check",
+                "--libraries",
+                json.dumps(libraries),
+            ]
+        )

cola_cli/cli.py

@@ -0,0 +1,177 @@
+"""Global-only command interface. Importing it requires no native COLA installation."""
+
+import json
+import shutil
+import subprocess
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+import click
+
+from .common import cli
+from .environment import GlobalEnvironment, fingerprint
+from .setup import setup  # noqa: F401 -- registers scaffold commands on cli
+from .sources import BUILTINS, source_spec
+
+
+@cli.command()
+@click.option("--core", default=BUILTINS["core"], show_default=True, help="COLA core Git URL or directory.")
+@click.option("--core-ref", help="Core Git tag, branch or commit.")
+@click.option("--bindings", default=BUILTINS["python"], show_default=True, help="COLA-PY Git URL or directory.")
+@click.option("--bindings-ref", help="COLA-PY Git tag, branch or commit.")
+@click.option(
+    "--python",
+    default=getattr(sys, "_base_executable", sys.executable),
+    help="Existing Python 3.11+ executable for the runtime (defaults to the CLI's base interpreter).",
+)
+@click.option(
+    "--prefix",
+    multiple=True,
+    type=click.Path(exists=True, file_okay=False),
+    help="Explicit external native dependency prefix (repeatable).",
+)
+def init(core, core_ref, bindings, bindings_ref, python, prefix):
+    """Initialize the one global environment; do not build or install yet."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        environment.initialize(source_spec(core, core_ref), source_spec(bindings, bindings_ref), python, prefix)
+    click.echo(f"Initialized {environment.root}. Add modules, then run 'cola build'.")
+
+
+@cli.command()
+@click.argument("source")
+@click.option("--ref", help="Git tag, branch or commit; resolved to a commit when added.")
+@click.option("--subdirectory", default=".", help="Package directory inside the repository.")
+@click.option("--name", help="Global module identifier.")
+@click.option("--backend", type=click.Choice(["cmake", "python", "julia"]))
+@click.option("--library", multiple=True, help="Native COLA module to load at runtime (repeatable).")
+@click.option("--requires", multiple=True, help="Another explicitly selected module (repeatable).")
+@click.option("--cmake-arg", multiple=True, help="Additional -D definition (use --cmake-arg=-DNAME=value).")
+def add(source, ref, subdirectory, name, backend, library, requires, cmake_arg):
+    """Add a Git or local module to the desired global specification."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        identifier = environment.add(
+            source_spec(source, ref, subdirectory),
+            name=name,
+            backend=backend,
+            libraries=list(library),
+            depends=list(requires),
+            cmake_args=list(cmake_arg),
+        )
+    click.echo(f"Added {identifier}. Run 'cola build' to activate the change.")
+
+
+@cli.command()
+@click.argument("name")
+def remove(name):
+    """Remove a module from the desired specification; keep the running build intact."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        environment.remove(name)
+    click.echo(f"Removed {name}. Run 'cola build' to activate the change.")
+
+
+def build_options(function):
+    return click.option("--jobs", type=click.IntRange(min=1), default=2, show_default=True)(function)
+
+
+@cli.command()
+@click.option("--locked", is_flag=True, help="Restore the active source and language locks without re-resolving.")
+@build_options
+def build(locked, jobs):
+    """Build and atomically activate the complete global environment."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        generation = environment.build(locked=locked, jobs=jobs)
+    click.echo(f"Activated global environment: {generation}")
+
+
+@cli.command()
+@click.option("--locked", is_flag=True, default=True, help="Use the active lock (always enabled for sync).")
+@build_options
+def sync(locked, jobs):
+    """Restore the active lock into a fresh build; never update dependencies."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        generation = environment.build(locked=True, jobs=jobs)
+    click.echo(f"Restored global environment: {generation}")
+
+
+@cli.command()
+@click.argument("names", nargs=-1)
+@build_options
+def update(names, jobs):
+    """Re-resolve selected Git refs (all by default), rebuild and activate."""
+    environment = GlobalEnvironment()
+    with environment.writing():
+        names = names or tuple(environment.spec()["modules"])
+        generation = environment.build(update=names, jobs=jobs)
+    click.echo(f"Updated global environment: {generation}")
+
+
+@cli.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Print desired and active state as JSON.")
+def list_modules(as_json):
+    """Show desired modules and the currently active build."""
+    environment = GlobalEnvironment()
+    spec = environment.spec()
+    current = environment.root / "current"
+    active = environment.current()[1] if current.is_symlink() else None
+    if as_json:
+        click.echo(json.dumps({"home": str(environment.root), "desired": spec, "active": active}, indent=2))
+        return
+    click.echo(f"Global environment: {environment.root}")
+    click.echo(f"{'Module':24} {'Backend':8} {'Active rev.':12} Desired source")
+    for name, module in spec["modules"].items():
+        source = module["source"]
+        origin = source.get("path", source.get("url"))
+        locked = active["modules"].get(name) if active else None
+        revision = (locked["snapshot"]["commit"] or locked["snapshot"]["sha256"])[:12] if locked else "pending"
+        click.echo(f"{name:24} {module['backend']:8} {revision:12} {origin}")
+    click.echo("Active build: " + (str(current.resolve()) if active else "none; run cola build"))
+    if active and active["spec_digest"] != fingerprint(spec):
+        click.echo("Pending specification changes: run cola build to activate them.")
+
+
+@cli.command()
+def doctor():
+    """Report available tools and global runtime state without importing colapy."""
+    environment = GlobalEnvironment()
+    click.echo(f"Global environment: {environment.root}")
+    for executable in ("git", "cmake", "c++", "gfortran", "julia", "javac", "gradle"):
+        click.echo(f"{executable:12} {shutil.which(executable) or 'not found'}")
+    try:
+        click.echo(f"uv           {version('uv')}")
+    except PackageNotFoundError:
+        click.echo("uv           not installed; reinstall cola-cli with its dependencies")
+    click.echo(f"Specification: {'present' if environment.manifest.exists() else 'run cola init'}")
+    click.echo(
+        f"Active build: {environment.root / 'current' if (environment.root / 'current').is_symlink() else 'none'}"
+    )
+
+
+@cli.command()
+@click.option("--config", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--library", "-l", multiple=True, help="Override the modules loaded from the global manifest.")
+@click.option("--steps", "-n", type=click.IntRange(min=1), default=1, show_default=True)
+@click.pass_context
+def run(ctx, config, library, steps):
+    """Run a calculation in a fresh process belonging to the global environment."""
+    ctx.exit(GlobalEnvironment().run(config, library, steps))
+
+
+@cli.command("exec", context_settings={"ignore_unknown_options": True})
+@click.argument("command", nargs=-1, required=True, type=click.UNPROCESSED)
+@click.pass_context
+def exec_command(ctx, command):
+    """Execute a command in the active global environment: cola exec python ..."""
+    _, _, env = GlobalEnvironment().runtime_environment()
+    ctx.exit(subprocess.call(command, env=env))
+
+
+def main():
+    try:
+        cli()
+    except OSError as error:
+        raise SystemExit(f"Error: {error}") from error

cola_cli/common.py

@@ -0,0 +1,98 @@
+"""Small, shared CLI utilities; no native runtime imports."""
+
+import json
+import os
+import signal
+import subprocess
+import tempfile
+from collections import deque
+from contextlib import nullcontext
+from pathlib import Path
+
+import click
+
+from . import __version__
+
+
+@click.group()
+@click.version_option(__version__)
+def cli():
+    """Manage the single global COLA environment (Linux/macOS)."""
+
+
+class ColaError(click.ClickException):
+    """An actionable environment or build error."""
+
+
+def execute(args, *, cwd=None, env=None, capture=False):
+    """Run tools directly, without a shell. Preserve their diagnostics in build.log."""
+    args = [str(arg) for arg in args]
+    log_path = env.get("COLA_BUILD_LOG") if env else None
+    context = Path(log_path).open("a", encoding="utf-8") if log_path else nullcontext(None)
+    with context as log:
+        if log:
+            log.write(f"\n$ {args!r}\n")
+            log.flush()
+        try:
+            if capture:
+                result = subprocess.run(args, cwd=cwd, env=env, text=True, capture_output=True, check=False)
+                output = result.stdout + result.stderr
+                if log:
+                    log.write(output + "\n")
+                if result.returncode:
+                    raise ColaError(f"{args[0]} exited with status {result.returncode}:\n{output[-12000:]}")
+                return result.stdout
+            process = subprocess.Popen(
+                args,
+                cwd=cwd,
+                env=env,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                start_new_session=True,
+            )
+        except OSError as error:
+            raise ColaError(f"Cannot execute {args[0]}: {error}") from error
+        tail = deque(maxlen=100)
+        try:
+            for line in process.stdout:
+                tail.append(line)
+                click.echo(line, nl=False)
+                if log:
+                    log.write(line)
+                    log.flush()
+            code = process.wait()
+        except BaseException:
+            if process.poll() is None:
+                os.killpg(process.pid, signal.SIGTERM)
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    os.killpg(process.pid, signal.SIGKILL)
+                    process.wait()
+            raise
+        finally:
+            process.stdout.close()
+        if code:
+            raise ColaError(f"{args[0]} exited with status {code}:\n{''.join(tail)[-12000:]}")
+        return ""
+
+
+def read_json(path):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as error:
+        raise ColaError(f"Cannot read {path}: {error}") from error
+
+
+def write_json(path, value):
+    """Replace one state file atomically, on the same filesystem."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(dir=path.parent, prefix=".state-")
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+            json.dump(value, stream, indent=2, sort_keys=True)
+            stream.write("\n")
+        os.replace(temporary, path)
+    finally:
+        Path(temporary).unlink(missing_ok=True)