simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/generate.py

@@ -0,0 +1,590 @@
+"""Assemble one template into a standalone project folder.
+
+A template cannot run inside this repository: its code reads `sample/<part>.stl`, a path
+that deliberately resolves only after generation. So generating is the only thing that
+produces a runnable project, and the only thing that can prove this code works.
+
+Shared code arrives as the packages it already is, under its own name. Flattening it into
+the workflow folder was tried and reversed: a bare `stl.py` beside the customer's script
+shadows numpy-stl, the standard STL library in this industry, and their own
+`from stl import mesh` then fails naming a library they never installed.
+
+A folder that already holds files is reconciled rather than replaced, the way copier,
+`dotnet new` and Rails generators behave: new files are added, identical ones left alone,
+and a file that would change is a clash that stops the run before anything is written.
+`force` overwrites exactly the clashes. Nothing the template does not write is ever
+deleted — an earlier version replaced the whole folder and took the customer's `.git` and
+their own notes with it, which no mainstream scaffolder does.
+"""
+
+from __future__ import annotations
+
+import errno
+import json
+import os
+import re
+import shutil
+import tempfile
+import unicodedata
+from dataclasses import dataclass
+from pathlib import Path
+from string import Template
+
+from simcon_toolkit.choices import DEFAULT_PACKAGE_MANAGER, PACKAGE_MANAGERS
+from simcon_toolkit.instructions import SHARED_BASE, write_instruction_files
+from simcon_toolkit.manifest import ROOT, TemplateSpec, load_template
+from simcon_toolkit.project import (
+    GITATTRIBUTES,
+    PYTHON_VERSION_PIN,
+    UV_SETUP,
+    content_digest,
+    is_excluded,
+    render_pyproject,
+    stamp,
+    write_sample,
+)
+
+#: Which template and version a project came from. Named after the tool, like
+#: `.copier-answers.yml`; the hosted instructions tell an assistant to look for it.
+STAMP = ".simcon-toolkit.json"
+
+#: Around the setup block of every template README. The block between them is the pip route,
+#: which is what a reader of this repository sees; a uv project gets `UV_SETUP` in its place.
+#: HTML comments, so they render as nothing, and removed from every project either way.
+SETUP_START = "<!-- simcon-toolkit:setup -->"
+SETUP_END = "<!-- /simcon-toolkit:setup -->"
+
+#: The staging folder's name, so the walk that reports kept files can never mistake one
+#: left behind by a killed run for the customer's own work.
+STAGING_PREFIX = ".simcon-toolkit-"
+
+#: Folders never walked when reporting what was kept: version control, environments and
+#: caches, each of which holds hundreds of files nobody wants listed back to them.
+PRUNED = frozenset(
+    {".git", ".venv", "venv", "__pycache__", ".pytest_cache", ".ruff_cache", ".mypy_cache", "node_modules"}
+)
+
+#: Files an operating system writes on its own, and not worth naming.
+NOISE = frozenset({".DS_Store", "Thumbs.db"})
+
+# Exclusion rules live in simcon_toolkit.project, beside the digest that must apply the same ones.
+
+
+#: Where a placeholder may appear. Every text file a template ships, NOT just its README:
+#: a placeholder left unsubstituted ships verbatim into a customer's project and nothing
+#: downstream would ever notice it. A `.py` file is deliberately absent — a placeholder
+#: inside one would make the file invalid Python and invisible to lint and to the tests.
+RENDERED_SUFFIXES = (".md", ".toml", ".json", ".yaml", ".yml", ".txt")
+
+
+class PlaceholderTemplate(Template):
+    """`string.Template` with `%%` as the delimiter.
+
+    `$` collides with `$PY` and `$ pip` already written in our own documentation, and a
+    prompt character in a shell example is not a placeholder.
+
+    The form is `%%{name}` or bare `%%name` — a *leading* delimiter only. `%%name%%` is
+    not the syntax and raises, because the trailing pair is itself an invalid placeholder.
+    Write the braced form, which stays unambiguous next to other text.
+    """
+
+    delimiter = "%%"
+
+
+def _swap_setup(readme: Path, package_manager: str) -> None:
+    """Give the README the setup block for the installer the customer chose, and drop the markers.
+
+    A README without exactly one pair is refused rather than shipped: the pip route would
+    reach a customer who chose uv, and nothing downstream would notice.
+    """
+    text = readme.read_text(encoding="utf-8")
+    if text.count(SETUP_START) != 1 or text.count(SETUP_END) != 1 or text.index(SETUP_START) > text.index(SETUP_END):
+        raise GeneratorError(f"{readme.name} must mark its setup block once, with {SETUP_START} and {SETUP_END}.")
+    before, rest = text.split(SETUP_START)
+    kept, after = rest.split(SETUP_END)
+    # The markers sit on their own lines; take the newline after each with it.
+    kept, after = kept.removeprefix("\n"), after.removeprefix("\n")
+    block = UV_SETUP if package_manager == "uv" else kept
+    readme.write_text(before + block + after, encoding="utf-8", newline="\n")
+
+
+def _render_in_place(path: Path, values: dict[str, str]) -> None:
+    text = path.read_text(encoding="utf-8")
+    if PlaceholderTemplate.delimiter not in text:
+        return
+    # Strict: an unknown placeholder raises rather than shipping a literal `%%name%%` into
+    # a customer's project, where nothing downstream would ever notice it.
+    path.write_text(PlaceholderTemplate(text).substitute(values), encoding="utf-8", newline="\n")
+
+
+@dataclass(frozen=True)
+class Generated:
+    """What one run did to the destination, each list relative to it and sorted.
+
+    Split four ways because each one means something different to the person reading the
+    report: new work, work of theirs we replaced, nothing to do, and files we left alone.
+    """
+
+    destination: Path
+    created: list[str]
+    overwritten: list[str]
+    unchanged: list[str]
+    kept: list[str]
+
+    @property
+    def written(self) -> list[str]:
+        """Every file this run put on disk."""
+        return sorted(self.created + self.overwritten)
+
+
+def generate_project(
+    template: str,
+    destination: Path,
+    *,
+    project_name: str | None = None,
+    force: bool = False,
+    generated_at: str | None = None,
+    cli_version: str | None = None,
+    package_manager: str = DEFAULT_PACKAGE_MANAGER,
+) -> Generated:
+    """Write one template into `destination`, reconciling with whatever is already there.
+
+    A folder that already holds files is fine as long as none of them is a file the template
+    would write with different content. Every such clash is found before anything is
+    written, so a refusal changes nothing; `force` overwrites exactly those files. Nothing
+    the template does not write is ever deleted, and `.git` is never looked at.
+    """
+    if package_manager not in PACKAGE_MANAGERS:
+        raise GeneratorError(f"no package manager named {package_manager!r}. Available: {', '.join(PACKAGE_MANAGERS)}.")
+    spec: TemplateSpec = load_template(template)
+    shown = Path(destination)
+    # Absolute before anything else: `Path(".").parent` is `.` itself, so staging "beside"
+    # a relative `.` put it inside the project and reported our own staging files as the
+    # customer's.
+    # The names are checked as TYPED, before anything normalises them: on Windows `abspath`
+    # silently drops a trailing dot or space, and a device name such as `nul` "exists".
+    check_new_path(shown)
+    destination = Path(os.path.abspath(shown))
+    if destination.exists() and not destination.is_dir():
+        raise GeneratorError(f"{shown} is a file, not a folder. Choose another name.")
+    name = project_name or distribution_name(destination.name)
+    check_project_name(name)
+
+    staging = _staging_directory(destination)
+    try:
+        workspace = staging / "project"
+        _assemble(
+            spec,
+            workspace,
+            name,
+            generated_at=generated_at,
+            cli_version=cli_version,
+            package_manager=package_manager,
+        )
+        return _reconcile(workspace, destination, shown, force=force)
+    finally:
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def _staging_directory(destination: Path) -> Path:
+    """Where the project is assembled before it is compared and moved into place.
+
+    Beside the destination, so each final move is a rename within one filesystem: on Linux
+    the system temp directory is frequently a different one, and a cross-device move is a
+    copy. When the parent refuses a write — generating into a home directory, whose parent
+    belongs to the system — the temp directory is the fallback, at the cost of a copy.
+    """
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        return Path(tempfile.mkdtemp(prefix=STAGING_PREFIX, dir=destination.parent))
+    except PermissionError:
+        return Path(tempfile.mkdtemp(prefix=STAGING_PREFIX))
+
+
+def _assemble(
+    spec: TemplateSpec,
+    workspace: Path,
+    name: str,
+    *,
+    generated_at: str | None,
+    cli_version: str | None,
+    package_manager: str,
+) -> None:
+    _copy_tree(spec.directory, workspace)
+    _swap_setup(workspace / "README.md", package_manager)
+    for module in spec.module_sources():
+        _copy_tree(module, workspace / module.name)
+
+    write_sample(workspace, spec)
+
+    # Overwrites the template's own half, which the copy above brought across under the
+    # same name. The half is an input to the join, never the file a customer receives.
+    write_instruction_files(workspace, spec.directory, package_manager=package_manager)
+
+    (workspace / "pyproject.toml").write_text(render_pyproject(spec, name), encoding="utf-8", newline="\n")
+    (workspace / ".python-version").write_text(PYTHON_VERSION_PIN + "\n", encoding="utf-8", newline="\n")
+    (workspace / ".gitattributes").write_text(GITATTRIBUTES, encoding="utf-8", newline="\n")
+    # Through _copy_file, not write_bytes: these are text and must be normalised like
+    # every other copied file, or a Windows checkout ships them as the only CRLF files
+    # in an otherwise LF project.
+    _copy_file(ROOT / "LICENSE", workspace / "LICENSE")
+    _copy_file(ROOT / "NOTICE", workspace / "NOTICE")
+
+    digest = content_digest([SHARED_BASE, spec.directory, *spec.module_sources()])
+    record = stamp(spec, digest, generated_at=generated_at, cli_version=cli_version, package_manager=package_manager)
+    (workspace / STAMP).write_text(json.dumps(record, indent=2) + "\n", encoding="utf-8", newline="\n")
+
+    values = {"project_name": name, "template": spec.name, "sample": spec.sample}
+    for rendered in sorted(p for p in workspace.rglob("*") if p.is_file() and p.suffix in RENDERED_SUFFIXES):
+        _render_in_place(rendered, values)
+
+
+def _reconcile(workspace: Path, destination: Path, shown: Path, *, force: bool) -> Generated:
+    ours = sorted(p.relative_to(workspace).as_posix() for p in workspace.rglob("*") if p.is_file())
+    created, clashes, unchanged, blocked = [], [], [], []
+    # The on-disk spelling of each clash, which differs from ours only on a case-insensitive
+    # filesystem: `readme.md` IS `README.md` on macOS and Windows.
+    replaced_on_disk: dict[str, str] = {}
+    for relative in ours:
+        if _something_in_the_way(destination, relative):
+            blocked.append(relative)
+            continue
+        target = destination / relative
+        on_disk = _on_disk_spelling(destination, relative)
+        if on_disk is None and not target.is_symlink():
+            created.append(relative)
+            continue
+        # The stamp is compared by presence, not by content: two runs inside one second
+        # write identical stamps, and an existing project must always be named as one.
+        identical = (
+            on_disk == relative
+            and relative != STAMP
+            and target.is_file()
+            and not target.is_symlink()
+            and target.read_bytes() == (workspace / relative).read_bytes()
+        )
+        if identical:
+            unchanged.append(relative)
+        else:
+            clashes.append(relative)
+            replaced_on_disk[relative] = on_disk or relative
+
+    if blocked:
+        raise GeneratorError(
+            f"{shown} holds something in the way that is not a file this template writes: "
+            f"{format_listing(blocked)}. A folder, a link or a differently-capitalised folder sits where "
+            "the template writes. Move it aside, or generate into a new folder."
+        )
+    if clashes and not force:
+        raise ConflictError(shown, clashes, replaced_on_disk)
+
+    kept = _kept(destination, set(ours) | set(replaced_on_disk.values()))
+    existed = destination.exists()
+    moved: list[str] = []
+    try:
+        for relative in created + clashes:
+            target = destination / relative
+            target.parent.mkdir(parents=True, exist_ok=True)
+            spelled = replaced_on_disk.get(relative, relative)
+            if spelled != relative:
+                # Replacing through the old spelling would keep it, so the customer's copy
+                # keeps a name the project's own `pyproject.toml` does not point at on Linux.
+                (destination / spelled).unlink()
+            _move(workspace / relative, target)
+            moved.append(relative)
+    except OSError as failure:
+        # Only a folder this run created is ours to remove; one that was there before holds
+        # the customer's files, so it is left as it is and the error says what was written.
+        if not existed:
+            shutil.rmtree(destination, ignore_errors=True)
+            raise
+        raise WriteFailed(
+            f"writing into {shown} stopped after {len(moved)} of {len(created) + len(clashes)} files "
+            f"({failure.strerror or failure}). Nothing already there was removed. Fix the cause and "
+            "run the same command with --force to finish."
+        ) from failure
+    return Generated(shown, created, clashes, unchanged, kept)
+
+
+def _move(source: Path, target: Path) -> None:
+    """A rename, or a copy when staging had to fall back to another filesystem."""
+    try:
+        os.replace(source, target)
+    except OSError as failure:
+        if failure.errno != errno.EXDEV:
+            raise
+        shutil.copy2(source, target)
+        source.unlink()
+
+
+def _something_in_the_way(destination: Path, relative: str) -> bool:
+    """Whether writing `relative` would mean deleting or writing through something.
+
+    A folder where we write a file, a file where we need a folder, and a LINK anywhere on the
+    way: `is_dir()` follows a link, so a linked folder looks like our own and the files land
+    wherever it points, outside the project.
+    """
+    for parent in _parents(relative):
+        path = destination / parent
+        if path.is_symlink():
+            return True
+        spelled = _on_disk_spelling(destination, parent)
+        if spelled is not None and (spelled != parent or not path.is_dir()):
+            return True
+    # Follows a link on purpose: a link to a folder is as much in the way as a folder.
+    return (destination / relative).is_dir()
+
+
+def _on_disk_spelling(destination: Path, relative: str) -> str | None:
+    """The path as the filesystem spells it, or None when nothing is there.
+
+    Asked of the directory listing, because `exists()` answers True for `README.md` when
+    the folder holds `readme.md` on a case-insensitive filesystem, and says nothing about
+    which name is actually on disk.
+    """
+    current = destination
+    spelled = []
+    for part in relative.split("/"):
+        try:
+            entries = os.listdir(current)
+        except (FileNotFoundError, NotADirectoryError):
+            return None
+        if part in entries:
+            match = part
+        else:
+            folded = [entry for entry in entries if os.path.normcase(entry).casefold() == part.casefold()]
+            if not folded or not (current / part).exists():
+                return None
+            match = folded[0]
+        spelled.append(match)
+        current = current / match
+    return "/".join(spelled)
+
+
+def _parents(relative: str) -> list[str]:
+    parts = relative.split("/")[:-1]
+    return ["/".join(parts[: index + 1]) for index in range(len(parts))]
+
+
+def _kept(destination: Path, ours: set[str]) -> list[str]:
+    """Files already in the destination that this template does not write.
+
+    Reported rather than removed: they may be the customer's own work, or they may be left
+    over from a different template, and only the customer can tell which. The walk prunes
+    `.git`, virtual environments and caches rather than filtering them afterwards, so a
+    project with a `.venv` is not reported file by file and a home directory is not walked.
+    """
+    if not destination.is_dir():
+        return []
+    found = []
+    for folder, directories, files in os.walk(destination):
+        directories[:] = sorted(
+            name
+            for name in directories
+            if name not in PRUNED
+            and not name.startswith(STAGING_PREFIX)
+            and not os.path.islink(os.path.join(folder, name))
+        )
+        for name in sorted(files):
+            if name in NOISE:
+                continue
+            relative = Path(folder, name).relative_to(destination).as_posix()
+            if relative not in ours:
+                found.append(relative)
+    return sorted(found)
+
+
+def format_listing(paths: list[str], limit: int = 8) -> str:
+    """At most `limit` paths on one line, then a count, so a report never floods a terminal."""
+    shown = ", ".join(paths[:limit])
+    return shown if len(paths) <= limit else f"{shown} and {len(paths) - limit} more"
+
+
+#: Folder names Windows cannot create, whatever follows a dot: `NUL.txt` is `NUL`. The
+#: superscript digits are Microsoft's own addition, and are reserved in every directory.
+RESERVED_DEVICE_NAMES = frozenset(
+    # CONIN$ and CONOUT$ are absent from Microsoft's naming page and present in CPython's
+    # own reserved-name set, which is the list `os.path.isreserved` answers from.
+    {"CON", "PRN", "AUX", "NUL", "CONIN$", "CONOUT$"}
+    | {f"{port}{digit}" for port in ("COM", "LPT") for digit in (*"123456789", "¹", "²", "³")}
+)
+
+#: The longest folder name the filesystems a project reaches all accept.
+MAX_FOLDER_NAME_BYTES = 255
+
+#: Characters Windows refuses in a name, plus the control range it refuses too.
+RESERVED_CHARACTERS = frozenset('<>:"/\\|?*') | {chr(code) for code in range(32)}
+
+
+def check_folder_name(name: str) -> None:
+    """Fail on a folder name that cannot exist on every machine a project may reach.
+
+    Checked on every platform, not only on Windows: a project made on a Mac is committed and
+    cloned by a colleague on Windows, and a folder called `aux` then cannot be checked out.
+    """
+    if name in ("", ".", ".."):
+        raise GeneratorError(f"{name!r} is not a folder name. Give the project a name.")
+    # Checked here rather than left to the filesystem, whose answer depends on the Python:
+    # 3.12's `is_dir` raises "File name too long" and 3.14's returns False and carries on.
+    # 255 is the limit on ext4, APFS and NTFS alike; the name is not repeated, so the reason
+    # stays on screen in a prompt's one-line error.
+    if len(name.encode("utf-8")) > MAX_FOLDER_NAME_BYTES:
+        raise GeneratorError(
+            f"That folder name is {len(name.encode('utf-8'))} bytes; a folder name may be at most "
+            f"{MAX_FOLDER_NAME_BYTES}."
+        )
+    bad = sorted({character for character in name if character in RESERVED_CHARACTERS})
+    if bad:
+        shown = " ".join(repr(character) for character in bad)
+        raise GeneratorError(f"{name!r} contains {shown}, which Windows does not allow in a folder name.")
+    if name[-1] in ". ":
+        raise GeneratorError(f"{name!r} ends with a {'dot' if name[-1] == '.' else 'space'}, which Windows removes.")
+    if name.split(".")[0].rstrip(" ").upper() in RESERVED_DEVICE_NAMES:
+        raise GeneratorError(f"{name!r} is a device name Windows reserves. Choose another name.")
+
+
+def check_new_path(given: Path) -> None:
+    """Check every folder name in the path as typed, except folders that already exist.
+
+    An existing folder has already proved the filesystem accepts it. Anything else is checked
+    by name, including a device name that Windows reports as existing although it is no
+    folder at all.
+    """
+    parts = Path(given).parts
+    for index, name in enumerate(parts):
+        if name in (".", "..") or name == Path(given).anchor:
+            continue
+        # Before the lookup, which raises on such a name on some Pythons and not on others.
+        if len(name.encode("utf-8")) > MAX_FOLDER_NAME_BYTES:
+            check_folder_name(name)
+        if Path(*parts[: index + 1]).is_dir():
+            continue
+        check_folder_name(name)
+
+
+def distribution_name(folder: str) -> str:
+    """The package name a folder name becomes, so an ordinary folder name is never refused.
+
+    `Gate Study (v2)` is a perfectly good folder and not a valid distribution name. Accents
+    are folded first, so `Étude` becomes `etude` rather than losing its first letter; then
+    runs of anything that is not a letter or digit become one hyphen, lowercased, which is
+    the spelling PyPA normalises every name to anyway.
+    """
+    ascii_only = unicodedata.normalize("NFKD", folder).encode("ascii", "ignore").decode("ascii")
+    derived = re.sub(r"[^a-z0-9]+", "-", ascii_only.lower()).strip("-")
+    if not derived:
+        raise GeneratorError(
+            f"{folder!r} holds no ASCII letters or digits, so no project name can be made from it. Rename the folder."
+        )
+    return derived
+
+
+#: PEP 508 names the grammar a distribution name must match. Applied to a name passed
+#: explicitly; a name taken from the folder is derived into this shape first.
+PROJECT_NAME = re.compile(r"^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$")
+
+
+class GeneratorError(Exception):
+    """A refusal the caller can act on: an unusable name, a clash, a symlink in a template.
+
+    Separate from `ValueError`, which the generator still raises for a defect in this
+    repository — a shared instruction base with no trailing newline, say. Those should reach
+    a maintainer as a traceback rather than being printed to a customer as if they had done
+    something wrong.
+    """
+
+
+class ConflictError(GeneratorError):
+    """Files the template would write already exist with different content."""
+
+    def __init__(self, destination: Path, clashes: list[str], on_disk: dict[str, str] | None = None) -> None:
+        """Name every clash, and say so plainly when the folder is already a project."""
+        self.destination = destination
+        self.clashes = clashes
+        on_disk = on_disk or {}
+        named = [f"{on_disk[c]} (would become {c})" if on_disk.get(c, c) != c else c for c in clashes]
+        if STAMP in clashes:
+            previous = _previous_template(Path(destination) / STAMP)
+            what = f"a project generated from {previous!r}" if previous else "a generated project"
+            opening = f"{destination} already holds {what}."
+            advice = "Generate into a new folder beside it, or pass --force to overwrite"
+        else:
+            opening = f"{destination} already has {len(clashes)} file(s) this template would replace."
+            advice = "Pass --force to overwrite"
+        super().__init__(
+            f"{opening} Conflicting: {format_listing(named)}. {advice} those files; any changes you made "
+            "to them are lost, and nothing else in the folder is touched."
+        )
+
+
+class WriteFailed(GeneratorError):
+    """Writing stopped part-way into a folder that was already there, so it was left as is."""
+
+
+def _previous_template(stamp_file: Path) -> str | None:
+    try:
+        record = json.loads(stamp_file.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    template = record.get("template") if isinstance(record, dict) else None
+    return template if isinstance(template, str) else None
+
+
+def check_project_name(name: str) -> None:
+    """Fail on a name the generated manifest could not carry.
+
+    Interpolating an unchecked name into TOML is the sharper half: a name containing a
+    double quote produces a `pyproject.toml` that does not parse at all.
+    """
+    if not PROJECT_NAME.fullmatch(name):
+        raise GeneratorError(
+            f"{name!r} is not a usable project name. It must start and end with a letter or "
+            "digit and hold only letters, digits, '.', '-' and '_'."
+        )
+
+
+def _copy_file(source: Path, destination: Path) -> None:
+    """Copy one file, normalising text to LF.
+
+    `.gitattributes` checks the template trees out as LF everywhere, so this is belt and
+    braces there — but it still does real work for anything copied from outside them, where
+    the repository-wide `text=auto` checks out **native** and a byte copy ships CRLF while
+    the files written here are LF. A generated project would then depend on the machine it was generated on: the same
+    template produces different bytes on Windows and Linux, and two customers could not be
+    compared. The repository already declares LF as its line ending, so this carries that
+    through to what a customer receives rather than inventing a rule.
+
+    Binary is detected by a NUL byte and copied untouched — normalising an `.stl` would
+    corrupt the geometry.
+    """
+    data = source.read_bytes()
+    if b"\x00" in data:
+        shutil.copy2(source, destination)
+        return
+    destination.write_bytes(data.replace(b"\r\n", b"\n"))
+    shutil.copystat(source, destination)
+
+
+def _copy_tree(source: Path, destination: Path) -> None:
+    """Copy a template or package, leaving a developer's working tree behind.
+
+    Hand-walked rather than `shutil.copytree`, for two reasons its options cannot cover.
+    A symlink is **refused**: `copytree` defaults to following one, so a link inside a
+    template would copy the content of its target from anywhere on the developer's disk,
+    and a symlink in a customer's project is separately unwanted — on Windows it needs
+    Administrator, and git without symlink support writes a plain file holding the target's
+    name, which loads successfully and conveys nothing.
+    """
+    destination.mkdir(parents=True, exist_ok=True)
+    for entry in sorted(source.iterdir()):
+        if is_excluded(entry):
+            continue
+        if entry.is_symlink():
+            raise GeneratorError(
+                f"{entry} is a symlink. Templates ship real files: a link would be copied as its "
+                "target's contents, which may sit anywhere on this machine."
+            )
+        if entry.is_dir():
+            _copy_tree(entry, destination / entry.name)
+        else:
+            _copy_file(entry, destination / entry.name)