python-snacks 0.1.2__py3-none-any.whl

python_snacks-0.1.2.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: python-snacks
+Version: 0.1.2
+Summary: A CLI tool for managing a personal stash of reusable Python code snippets.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.9
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# Snack Stash
+
+A personal CLI tool for managing a local stash of reusable Python code snippets. Browse, copy, and curate snippets across projects with a single command.
+
+```bash
+pipx install snack-stash
+snack stash create default ~/snack-stash
+snack unpack auth/google_oauth.py
+```
+
+---
+
+## Installation
+
+**Recommended (pipx):**
+```bash
+pipx install snack-stash
+```
+
+**Alternative (pip):**
+```bash
+pip install snack-stash
+```
+
+Requires Python 3.10+.
+
+---
+
+## Configuration
+
+### First-time setup
+
+Create a stash directory and register it:
+
+```bash
+snack stash create default ~/snack-stash
+```
+
+This creates `~/snack-stash`, writes `~/.snackstashrc`, and sets `default` as the active stash.
+
+### Environment variable (overrides config file)
+
+```bash
+export SNACK_STASH=~/snack-stash
+```
+
+Add to `~/.zshrc` or `~/.bashrc` to make it permanent. Takes priority over everything else.
+
+### Config file (`~/.snackstashrc`)
+
+Created automatically by `snack stash create`. You can also edit it by hand:
+
+```ini
+[config]
+active = default
+
+[stash.default]
+path = ~/snack-stash
+
+[stash.work]
+path = ~/work-stash
+```
+
+**Priority order:** `SNACK_STASH` env var → `~/.snackstashrc` active stash → error.
+
+---
+
+## Stash structure
+
+A stash is a plain directory of `.py` files, organized into subdirectories by category:
+
+```
+~/snack-stash/
+├── auth/
+│   ├── google_oauth_fastapi.py
+│   ├── google_oauth_flask.py
+│   └── jwt_helpers.py
+├── forms/
+│   ├── contact_form.py
+│   └── newsletter_signup.py
+└── email/
+    └── smtp_sender.py
+```
+
+You can manage the directory with Git, Dropbox, or any sync tool independently of this CLI.
+
+---
+
+## Commands
+
+### `snack list [category]`
+
+List all snippets in the active stash.
+
+```bash
+snack list           # all snippets
+snack list auth      # filtered by category (subdirectory)
+```
+
+### `snack search <keyword>`
+
+Search snippet filenames for a keyword (case-insensitive).
+
+```bash
+snack search oauth
+# auth/google_oauth_fastapi.py
+# auth/google_oauth_flask.py
+```
+
+### `snack unpack <snippet>`
+
+Copy a snippet **from the stash** into the current working directory.
+
+```bash
+snack unpack auth/google_oauth_fastapi.py
+# → ./auth/google_oauth_fastapi.py
+
+snack unpack auth/google_oauth_fastapi.py --flat
+# → ./google_oauth_fastapi.py  (no subdirectory)
+
+snack unpack auth/google_oauth_fastapi.py --force
+# Overwrites without prompting
+```
+
+### `snack pack <snippet>`
+
+Copy a file **from the current directory** back into the stash. Use this when you've improved a snippet on a project and want to update the canonical version.
+
+```bash
+snack pack auth/google_oauth_fastapi.py
+snack pack auth/google_oauth_fastapi.py --force
+```
+
+---
+
+## Stash management
+
+### `snack stash create <name> <path>`
+
+Register a new named stash. Creates the directory if it doesn't exist.
+
+```bash
+snack stash create default ~/snack-stash
+snack stash create work ~/work-stash --no-activate
+```
+
+The first stash created is automatically set as active. Use `--no-activate` to add a stash without switching to it.
+
+### `snack stash list`
+
+Show all configured stashes and which one is active.
+
+```bash
+snack stash list
+#   default  /Users/you/snack-stash  ← active
+#   work     /Users/you/work-stash
+```
+
+### `snack stash move <name> <new-path>`
+
+Move a stash to a new location. Moves the directory on disk and updates the config.
+
+```bash
+snack stash move default ~/new-location/snack-stash
+```
+
+### `snack stash add-remote <repo>`
+
+Copy Python snippets from a public GitHub repository into the active stash. Downloads the repo as a tarball and copies all `.py` files, preserving directory structure.
+
+```bash
+snack stash add-remote owner/repo
+snack stash add-remote https://github.com/owner/repo
+snack stash add-remote owner/repo --subdir auth   # only copy files under auth/
+snack stash add-remote owner/repo --force         # overwrite without prompting
+```
+
+---
+
+## Error handling
+
+| Situation | Behaviour |
+|---|---|
+| No stash configured | Error with setup instructions |
+| Stash path doesn't exist | Error with the attempted path |
+| Snippet not found in stash | Error — use `snack list` or `snack search` |
+| Source file not found | Error |
+| Destination file already exists | Prompt to confirm, or skip with `--force` |
+| Named stash already exists | Error |
+| Move target already exists | Error |
+| GitHub repo not found (HTTP 404) | Error with status code |
+
+---
+
+## Project structure
+
+```
+python-snacks/
+├── pyproject.toml
+├── snacks/
+│   ├── main.py      # Typer app, all command definitions
+│   ├── config.py    # SnackConfig class, stash path resolution
+│   └── ops.py       # File copy logic (pack, unpack, add_remote)
+└── tests/
+    ├── test_commands.py        # snippet commands
+    └── test_stash_commands.py  # stash management commands
+```
+
+---
+
+## CI / CD
+
+- **CI:** Tests run on every push and PR to `main` across Python 3.10, 3.11, and 3.12.
+- **Publish:** Push a `v*` tag to trigger a build, PyPI publish, and GitHub Release.
+
+```bash
+git tag v0.2.0 && git push origin v0.2.0
+```

python_snacks-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+python_snacks-0.1.2.dist-info/licenses/LICENSE,sha256=htWWuqer0G2fpR7CYy3QZtv5TnWL5dqtSSbwYXxSaD4,1064
+snacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snacks/config.py,sha256=M7NiX2PO6rvCyehs50FWdJr-aBlW6W7UNWmulOAJeP4,4647
+snacks/main.py,sha256=cowFc93HT5VzBlgI-u8bDeI3Mvwf2OyIAm4UACgWO8U,6692
+snacks/ops.py,sha256=gKPd_z-W-l5XkpccwyMfEmfCzZQMNl9Pf5gVHRkaIvI,4294
+python_snacks-0.1.2.dist-info/METADATA,sha256=usF76ELo6ui-k8zZL1KSUvV6hQj_YkULqX0V_AQzTjA,5475
+python_snacks-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_snacks-0.1.2.dist-info/entry_points.txt,sha256=Lh3nJdMRCmTzRS8GQh1jM5wHu78UEt3Y5-3mxYSrZeM,42
+python_snacks-0.1.2.dist-info/top_level.txt,sha256=-WmY1X8EWrFI_5VT9DpsWVe3xv30-2TUXRQpTS_zde8,7
+python_snacks-0.1.2.dist-info/RECORD,,

python_snacks-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_snacks-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+snack = snacks.main:app

python_snacks-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kicka5h
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_snacks-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+snacks

snacks/config.py

@@ -0,0 +1,149 @@
+import configparser
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+CONFIG_PATH = Path("~/.snackstashrc").expanduser()
+
+
+class SnackConfig:
+    """Read/write ~/.snackstashrc.
+
+    New format (INI):
+        [config]
+        active = default
+
+        [stash.default]
+        path = ~/snack-stash
+
+    Legacy format (still read, never written):
+        stash=~/snack-stash
+    """
+
+    def __init__(self) -> None:
+        self._cp = configparser.ConfigParser()
+        self._legacy_path: Optional[Path] = None
+
+        if not CONFIG_PATH.exists():
+            return
+
+        content = CONFIG_PATH.read_text().strip()
+        if not content:
+            return
+
+        if not content.lstrip().startswith("["):
+            # Legacy sectionless format
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("stash="):
+                    self._legacy_path = Path(line[len("stash="):].strip()).expanduser()
+                    break
+        else:
+            self._cp.read_string(content)
+
+    # ── read ────────────────────────────────────────────────────────────────
+
+    @property
+    def is_legacy(self) -> bool:
+        return self._legacy_path is not None
+
+    @property
+    def legacy_path(self) -> Optional[Path]:
+        return self._legacy_path
+
+    def active_name(self) -> Optional[str]:
+        return self._cp.get("config", "active", fallback=None)
+
+    def stashes(self) -> dict[str, Path]:
+        return {
+            section[len("stash."):]: Path(self._cp[section]["path"]).expanduser()
+            for section in self._cp.sections()
+            if section.startswith("stash.")
+        }
+
+    def stash_path(self, name: str) -> Optional[Path]:
+        section = f"stash.{name}"
+        if section in self._cp and "path" in self._cp[section]:
+            return Path(self._cp[section]["path"]).expanduser()
+        return None
+
+    def has_stash(self, name: str) -> bool:
+        return f"stash.{name}" in self._cp
+
+    # ── write ───────────────────────────────────────────────────────────────
+
+    def set_stash(self, name: str, path: Path) -> None:
+        if "config" not in self._cp:
+            self._cp["config"] = {}
+        self._cp[f"stash.{name}"] = {"path": str(path)}
+
+    def set_active(self, name: str) -> None:
+        if "config" not in self._cp:
+            self._cp["config"] = {}
+        self._cp["config"]["active"] = name
+
+    def remove_stash(self, name: str) -> bool:
+        return self._cp.remove_section(f"stash.{name}")
+
+    def save(self) -> None:
+        CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_PATH, "w") as f:
+            self._cp.write(f)
+
+
+def get_stash_path() -> Path:
+    """Resolve the active stash directory. Raises Exit(1) on any error."""
+    # Env var overrides everything
+    env_val = os.environ.get("SNACK_STASH")
+    if env_val:
+        path = Path(env_val).expanduser()
+        if not path.exists():
+            typer.echo(
+                f"[error] SNACK_STASH is set to '{env_val}' but that path does not exist.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        return path
+
+    cfg = SnackConfig()
+
+    # Legacy format
+    if cfg.is_legacy:
+        path = cfg.legacy_path
+        if not path.exists():
+            typer.echo(
+                f"[error] stash path in ~/.snackstashrc ('{path}') does not exist.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        return path
+
+    # Multi-stash: use active
+    active = cfg.active_name()
+    if active:
+        path = cfg.stash_path(active)
+        if path is None:
+            typer.echo(
+                f"[error] Active stash '{active}' is not defined in config.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        if not path.exists():
+            typer.echo(
+                f"[error] Active stash '{active}' path '{path}' does not exist.",
+                err=True,
+            )
+            raise typer.Exit(1)
+        return path
+
+    typer.echo(
+        "[error] Snack stash location is not configured.\n"
+        "Create a stash with:\n"
+        "  snack stash create default ~/snack-stash\n"
+        "Or set the SNACK_STASH environment variable:\n"
+        "  export SNACK_STASH=~/snack-stash",
+        err=True,
+    )
+    raise typer.Exit(1)

snacks/main.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import importlib.metadata
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from snacks.config import SnackConfig, get_stash_path
+from snacks.ops import add_remote as do_add_remote
+from snacks.ops import pack as do_pack, unpack as do_unpack
+
+app = typer.Typer(
+    name="snack",
+    help="Manage your personal snack stash of reusable Python snippets.",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        version = importlib.metadata.version("python-snacks")
+        typer.echo(f"snack-stash v{version}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+    ),
+) -> None:
+    pass
+
+stash_app = typer.Typer(help="Manage stash directories.")
+app.add_typer(stash_app, name="stash")
+
+
+# ── snippet commands ─────────────────────────────────────────────────────────
+
+@app.command()
+def unpack(
+    snippet: str = typer.Argument(..., help="Path relative to the stash root (e.g. auth/google_oauth.py)"),
+    flat: bool = typer.Option(False, "--flat", help="Copy file into cwd without preserving subdirectory structure."),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing files without prompting."),
+) -> None:
+    """Copy a snippet FROM the stash INTO the current working directory."""
+    do_unpack(get_stash_path(), snippet, flat=flat, force=force)
+
+
+@app.command()
+def pack(
+    snippet: str = typer.Argument(..., help="Path relative to cwd (e.g. auth/google_oauth.py)"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing stash file without prompting."),
+) -> None:
+    """Copy a snippet FROM the current working directory INTO the stash."""
+    do_pack(get_stash_path(), snippet, force=force)
+
+
+@app.command(name="list")
+def list_snacks(
+    category: Optional[str] = typer.Argument(None, help="Filter by category (subdirectory name)."),
+) -> None:
+    """List all snippets in the stash."""
+    stash = get_stash_path()
+    snippets = sorted(
+        p.relative_to(stash).as_posix()
+        for p in stash.rglob("*.py")
+        if not p.name.startswith("_")
+    )
+    if category:
+        snippets = [s for s in snippets if s.startswith(f"{category}/")]
+    typer.echo("\n".join(snippets) if snippets else "No snippets found.")
+
+
+@app.command()
+def search(
+    keyword: str = typer.Argument(..., help="Keyword to search for in snippet filenames."),
+) -> None:
+    """Search snippet filenames for a keyword."""
+    stash = get_stash_path()
+    matches = sorted(
+        p.relative_to(stash).as_posix()
+        for p in stash.rglob("*.py")
+        if keyword.lower() in p.name.lower() and not p.name.startswith("_")
+    )
+    typer.echo("\n".join(matches) if matches else f"No snippets matching '{keyword}'.")
+
+
+# ── stash management commands ────────────────────────────────────────────────
+
+@stash_app.command("create")
+def stash_create(
+    name: str = typer.Argument(..., help="Name for the new stash (e.g. 'default', 'work')."),
+    path: Path = typer.Argument(..., help="Directory path for the new stash."),
+    activate: bool = typer.Option(True, "--activate/--no-activate", help="Set as the active stash."),
+) -> None:
+    """Create a new stash directory and register it in config."""
+    cfg = SnackConfig()
+    if cfg.has_stash(name):
+        typer.echo(f"[error] A stash named '{name}' already exists.", err=True)
+        raise typer.Exit(1)
+
+    is_first = len(cfg.stashes()) == 0
+    expanded = path.expanduser().resolve()
+    expanded.mkdir(parents=True, exist_ok=True)
+    cfg.set_stash(name, expanded)
+
+    if activate or is_first:
+        cfg.set_active(name)
+
+    cfg.save()
+    typer.echo(f"Created stash '{name}' at {expanded}.")
+    if activate or is_first:
+        typer.echo(f"Active stash → '{name}'.")
+
+
+@stash_app.command("list")
+def stash_list() -> None:
+    """List all configured stashes."""
+    cfg = SnackConfig()
+    env_val = os.environ.get("SNACK_STASH")
+
+    if cfg.is_legacy:
+        typer.echo(f"  (legacy)  {cfg.legacy_path}  ← active")
+        return
+
+    stashes = cfg.stashes()
+    if not stashes:
+        typer.echo(
+            "No stashes configured. Create one with:\n"
+            "  snack stash create <name> <path>"
+        )
+        return
+
+    active = cfg.active_name()
+    width = max(len(n) for n in stashes)
+    for name, stash_path in sorted(stashes.items()):
+        marker = " ← active" if name == active else ""
+        missing = " [path missing!]" if not stash_path.exists() else ""
+        typer.echo(f"  {name:<{width}}  {stash_path}{marker}{missing}")
+
+    if env_val:
+        typer.echo(f"\n  Note: SNACK_STASH env var is set and overrides the active stash.")
+
+
+@stash_app.command("move")
+def stash_move(
+    name: str = typer.Argument(..., help="Name of the stash to move."),
+    new_path: Path = typer.Argument(..., help="New directory path."),
+) -> None:
+    """Move a stash to a new location and update config."""
+    cfg = SnackConfig()
+    if not cfg.has_stash(name):
+        typer.echo(
+            f"[error] No stash named '{name}'. Run 'snack stash list' to see available stashes.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    old_path = cfg.stash_path(name)
+    expanded_new = new_path.expanduser().resolve()
+
+    if expanded_new.exists() and expanded_new != old_path:
+        typer.echo(f"[error] '{expanded_new}' already exists.", err=True)
+        raise typer.Exit(1)
+
+    if old_path.exists():
+        shutil.move(str(old_path), str(expanded_new))
+        typer.echo(f"Moved '{name}': {old_path} → {expanded_new}")
+    else:
+        expanded_new.mkdir(parents=True, exist_ok=True)
+        typer.echo(f"Old path {old_path} did not exist. Created {expanded_new}.")
+
+    cfg.set_stash(name, expanded_new)
+    cfg.save()
+
+
+@stash_app.command("add-remote")
+def stash_add_remote(
+    repo: str = typer.Argument(..., help="GitHub repo as 'owner/repo' or a full GitHub URL."),
+    subdir: Optional[str] = typer.Option(None, "--subdir", help="Only copy files from this subdirectory of the repo."),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing files without prompting."),
+) -> None:
+    """Copy Python snippets from a GitHub repository into the active stash."""
+    do_add_remote(get_stash_path(), repo, subdir=subdir, force=force)

snacks/ops.py

@@ -0,0 +1,126 @@
+import shutil
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+
+def unpack(stash: Path, snippet_path: str, flat: bool, force: bool) -> None:
+    """Copy a file from the stash into the current working directory."""
+    src = stash / snippet_path
+    if not src.exists():
+        typer.echo(f"[error] '{snippet_path}' not found in stash ({stash}).", err=True)
+        raise typer.Exit(1)
+
+    dest = Path.cwd() / (src.name if flat else snippet_path)
+    _copy(src, dest, force)
+    typer.echo(f"Unpacked {snippet_path} → {dest}")
+
+
+def pack(stash: Path, snippet_path: str, force: bool) -> None:
+    """Copy a file from the current working directory into the stash."""
+    src = Path.cwd() / snippet_path
+    if not src.exists():
+        typer.echo(f"[error] '{snippet_path}' not found in current directory.", err=True)
+        raise typer.Exit(1)
+
+    dest = stash / snippet_path
+    _copy(src, dest, force)
+    typer.echo(f"Packed {snippet_path} → {dest}")
+
+
+def add_remote(stash: Path, repo: str, subdir: Optional[str], force: bool) -> None:
+    """Download .py files from a GitHub repo into the stash."""
+    owner, repo_name = _parse_github_repo(repo)
+    url = f"https://api.github.com/repos/{owner}/{repo_name}/tarball"
+
+    typer.echo(f"Fetching {owner}/{repo_name}...")
+    req = urllib.request.Request(
+        url,
+        headers={"User-Agent": "snack-stash", "Accept": "application/vnd.github+json"},
+    )
+
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            tarball = tmp / "repo.tar.gz"
+
+            with urllib.request.urlopen(req) as response:
+                tarball.write_bytes(response.read())
+
+            extract_dir = tmp / "repo"
+            extract_dir.mkdir()
+            with tarfile.open(tarball) as tf:
+                try:
+                    tf.extractall(extract_dir, filter="data")
+                except TypeError:
+                    tf.extractall(extract_dir)  # Python < 3.12
+
+            roots = list(extract_dir.iterdir())
+            if not roots:
+                typer.echo("[error] Downloaded archive was empty.", err=True)
+                raise typer.Exit(1)
+            repo_root = roots[0]
+
+            py_files = sorted(
+                p for p in repo_root.rglob("*.py")
+                if subdir is None or _is_under_subdir(p.relative_to(repo_root), subdir)
+            )
+
+            if not py_files:
+                msg = "No Python files found"
+                if subdir:
+                    msg += f" under '{subdir}'"
+                typer.echo(msg + ".")
+                return
+
+            for src in py_files:
+                rel = src.relative_to(repo_root)
+                _copy(src, stash / rel, force)
+                typer.echo(f"  + {rel.as_posix()}")
+
+            typer.echo(f"\nAdded {len(py_files)} file(s) from {owner}/{repo_name}.")
+
+    except urllib.error.HTTPError as e:
+        typer.echo(f"[error] HTTP {e.code}: {e.reason}", err=True)
+        raise typer.Exit(1)
+    except urllib.error.URLError as e:
+        typer.echo(f"[error] Network error: {e.reason}", err=True)
+        raise typer.Exit(1)
+
+
+def _parse_github_repo(repo: str) -> tuple[str, str]:
+    repo = repo.strip().rstrip("/")
+    for prefix in ("https://github.com/", "http://github.com/", "github.com/"):
+        if repo.startswith(prefix):
+            repo = repo[len(prefix):]
+            break
+    if repo.endswith(".git"):
+        repo = repo[:-4]
+    parts = repo.split("/")
+    if len(parts) != 2 or not all(parts):
+        typer.echo(
+            f"[error] Invalid repo '{repo}'. Use 'owner/repo' or a full GitHub URL.",
+            err=True,
+        )
+        raise typer.Exit(1)
+    return parts[0], parts[1]
+
+
+def _is_under_subdir(rel: Path, subdir: str) -> bool:
+    target = tuple(Path(subdir.strip("/")).parts)
+    return rel.parts[: len(target)] == target
+
+
+def _copy(src: Path, dest: Path, force: bool) -> None:
+    if dest.exists() and not force:
+        overwrite = typer.confirm(f"'{dest}' already exists. Overwrite?")
+        if not overwrite:
+            typer.echo("Aborted.")
+            raise typer.Exit(0)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dest)