lib-cli-exit-tools 1.0.3__tar.gz → 1.1.0__tar.gz

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [1.1.0] - 2025-09-16
+
+- introduced lib_cli_exit_tools.run_cli helper to reduce boilerplate code. see cli.py as example
+
 ## [1.0.3] - 2025-09-16
 
 - added make menu

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lib_cli_exit_tools
-Version: 1.0.3
+Version: 1.1.0
 Summary: CLI exit handling helpers: clean signals, exit codes, and error printing
 Project-URL: Homepage, https://github.com/bitranox/lib_cli_exit_tools
 Project-URL: Repository, https://github.com/bitranox/lib_cli_exit_tools.git
@@ -25,6 +25,7 @@ Requires-Dist: pytest-cov>=5.0; extra == 'dev'
 Requires-Dist: pytest>=8.2; extra == 'dev'
 Requires-Dist: ruff>=0.5; extra == 'dev'
 Requires-Dist: textual>=0.50; extra == 'dev'
+Requires-Dist: tomli>=2.0; extra == 'dev'
 Requires-Dist: twine>=5.1; extra == 'dev'
 Description-Content-Type: text/markdown
 
@@ -230,6 +231,37 @@ cli-exit-tools --help  # alias
 lib_cli_exit_tools info
 ```
 
+### Embed in your own CLI
+
+The `run_cli` helper wraps any Click command with lib_cli_exit_tools’ signal and error handling.
+
+```python
+from __future__ import annotations
+
+import click
+
+from lib_cli_exit_tools import run_cli
+
+
+@click.command()
+def hello() -> None:
+    """Minimal Click command with automatic signal-aware exit handling."""
+
+    click.echo("Hello from lib_cli_exit_tools!")
+
+
+if __name__ == "__main__":
+    # run_cli handles SIGINT/SIGTERM/SIGBREAK, Click exceptions, and converts
+    # any other exception into an appropriate exit code.
+    raise SystemExit(run_cli(hello))
+```
+
+Run it with:
+
+```bash
+python hello.py
+```
+
 Library:
 
 ```python

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/README.md

@@ -200,6 +200,37 @@ cli-exit-tools --help  # alias
 lib_cli_exit_tools info
 ```
 
+### Embed in your own CLI
+
+The `run_cli` helper wraps any Click command with lib_cli_exit_tools’ signal and error handling.
+
+```python
+from __future__ import annotations
+
+import click
+
+from lib_cli_exit_tools import run_cli
+
+
+@click.command()
+def hello() -> None:
+    """Minimal Click command with automatic signal-aware exit handling."""
+
+    click.echo("Hello from lib_cli_exit_tools!")
+
+
+if __name__ == "__main__":
+    # run_cli handles SIGINT/SIGTERM/SIGBREAK, Click exceptions, and converts
+    # any other exception into an appropriate exit code.
+    raise SystemExit(run_cli(hello))
+```
+
+Run it with:
+
+```bash
+python hello.py
+```
+
 Library:
 
 ```python

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/packaging/brew/Formula/lib-cli-exit-tools.rb

@@ -3,7 +3,7 @@ class LibCliExitTools < Formula
 
   desc "CLI exit handling helpers: clean signals, exit codes, and error printing"
   homepage "https://github.com/bitranox/lib_cli_exit_tools"
-  url "https://github.com/bitranox/lib_cli_exit_tools/archive/refs/tags/v1.0.3.tar.gz"
+  url "https://github.com/bitranox/lib_cli_exit_tools/archive/refs/tags/v1.1.0.tar.gz"
 k3cc316e7d0b09dd79e617cb3e91b14ee414b7e6695b108a326d9d3ccd08dd9"
   license "MIT"
 

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/packaging/conda/recipe/meta.yaml

@@ -1,5 +1,5 @@
 {% set name = "lib_cli_exit_tools" %}
-{% set version = "1.0.3" %}
+{% set version = "1.1.0" %}
 
 package:
   name: {{ name|lower }}

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/packaging/nix/flake.nix

@@ -35,7 +35,7 @@
       {
         packages.default = pypkgs.buildPythonPackage {
           pname = "lib_cli_exit_tools";
-          version = "1.0.3";
+          version = "1.1.0";
           pyproject = true;
           # Build from the repository root (two levels up from packaging/nix)
           src = ../..;
@@ -43,7 +43,7 @@
           # src = pkgs.fetchFromGitHub {
           #   owner = "bitranox";
           #   repo = "lib_cli_exit_tools";
-          #   rev = "v1.0.3";
+          #   rev = "v1.1.0";
           #   sha256 = "<fill-me>";
           # };
 

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lib_cli_exit_tools"
-version = "1.0.3"
+version = "1.1.0"
 description = "CLI exit handling helpers: clean signals, exit codes, and error printing"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,7 @@ dev = [
   "twine>=5.1",
   "codecov>=2.1.13",
   "textual>=0.50",
+  "tomli>=2.0",
 ]
 
 [project.scripts]

lib_cli_exit_tools-1.1.0/scripts/_utils.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import re
+import shlex
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from subprocess import CompletedProcess
+from typing import Any, Mapping, Sequence
+from urllib.parse import urlparse
+
+try:  # Python 3.11+
+    import tomllib  # type: ignore[attr-defined]
+except ModuleNotFoundError:  # pragma: no cover - fallback for older interpreters
+    try:
+        import tomli as tomllib  # type: ignore
+    except ModuleNotFoundError:  # pragma: no cover - pyproject parsing will degrade gracefully
+        tomllib = None  # type: ignore
+
+
+@dataclass(slots=True)
+class RunResult:
+    code: int
+    out: str
+    err: str
+
+
+@dataclass(slots=True)
+class ProjectMetadata:
+    name: str
+    slug: str
+    repo_url: str
+    repo_host: str
+    repo_owner: str
+    repo_name: str
+    homepage: str
+    import_package: str
+    coverage_source: str
+
+    @property
+    def brew_formula_path(self) -> str:
+        return f"packaging/brew/Formula/{self.slug}.rb"
+
+    def github_tarball_url(self, version: str) -> str:
+        if self.repo_host == "github.com" and self.repo_owner and self.repo_name:
+            return f"https://github.com/{self.repo_owner}/{self.repo_name}/archive/refs/tags/v{version}.tar.gz"
+        return ""
+
+
+_PYPROJECT_DATA_CACHE: dict[Path, dict[str, Any]] = {}
+_METADATA_CACHE: dict[Path, ProjectMetadata] = {}
+
+
+def run(
+    cmd: Sequence[str] | str,
+    *,
+    check: bool = True,
+    capture: bool = True,
+    cwd: str | None = None,
+    env: Mapping[str, str] | None = None,
+    dry_run: bool = False,
+) -> RunResult:
+    if isinstance(cmd, str):
+        display = cmd
+        shell = True
+        args: Sequence[str] | str = cmd
+    else:
+        display = " ".join(shlex.quote(p) for p in cmd)
+        shell = False
+        args = list(cmd)
+    if dry_run:
+        print(f"[dry-run] {display}")
+        return RunResult(0, "", "")
+    proc: CompletedProcess[str] = subprocess.run(
+        args,
+        shell=shell,
+        cwd=cwd,
+        env=env,
+        text=True,
+        capture_output=capture,
+    )
+    if check and proc.returncode != 0:
+        raise SystemExit(proc.returncode)
+    return RunResult(int(proc.returncode or 0), proc.stdout or "", proc.stderr or "")
+
+
+def cmd_exists(name: str) -> bool:
+    return subprocess.call(["bash", "-lc", f"command -v {shlex.quote(name)} >/dev/null 2>&1"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0
+
+
+def _normalize_slug(value: str) -> str:
+    slug = re.sub(r"[^A-Za-z0-9]+", "-", value).strip("-").lower()
+    return slug or value.replace("_", "-").lower()
+
+
+def _load_pyproject(pyproject: Path) -> dict[str, Any]:
+    path = pyproject.resolve()
+    cached = _PYPROJECT_DATA_CACHE.get(path)
+    if cached is not None:
+        return cached
+    text = path.read_text(encoding="utf-8")
+    data: dict[str, Any] = {}
+    if tomllib is not None:
+        try:
+            data = tomllib.loads(text)
+        except Exception:
+            data = {}
+    _PYPROJECT_DATA_CACHE[path] = data
+    return data
+
+
+def _derive_import_package(data: dict[str, Any], fallback: str) -> str:
+    try:
+        packages = data.get("tool", {}).get("hatch", {}).get("build", {}).get("targets", {}).get("wheel", {}).get("packages", [])
+        if isinstance(packages, list) and packages:
+            first = packages[0]
+            if isinstance(first, str) and first:
+                return Path(first).name
+    except AttributeError:
+        pass
+    project_scripts = data.get("project", {}).get("scripts", {})
+    if isinstance(project_scripts, dict):
+        for value in project_scripts.values():
+            if isinstance(value, str) and ":" in value:
+                module = value.split(":", 1)[0]
+                return module.split(".", 1)[0]
+    return fallback.replace("-", "_")
+
+
+def _derive_coverage_source(data: dict[str, Any], fallback: str) -> str:
+    try:
+        sources = data.get("tool", {}).get("coverage", {}).get("run", {}).get("source", [])
+        if isinstance(sources, list) and sources:
+            first = sources[0]
+            if isinstance(first, str) and first:
+                return first
+    except AttributeError:
+        pass
+    return fallback
+
+
+def get_project_metadata(pyproject: Path = Path("pyproject.toml")) -> ProjectMetadata:
+    path = pyproject.resolve()
+    cached = _METADATA_CACHE.get(path)
+    if cached is not None:
+        return cached
+
+    data = _load_pyproject(pyproject)
+    project = data.get("project", {}) if isinstance(data, dict) else {}
+    name = str(project.get("name") or pyproject.stem).strip() or "project"
+    slug = _normalize_slug(name)
+
+    urls = project.get("urls", {}) if isinstance(project, dict) else {}
+    repo_url = str(urls.get("Repository") or "")
+    homepage = str(urls.get("Homepage") or project.get("homepage") or "")
+    repo_host = repo_owner = repo_name = ""
+    if repo_url:
+        parsed = urlparse(repo_url)
+        repo_host = parsed.netloc.lower()
+        repo_path = parsed.path.strip("/")
+        if repo_path.endswith(".git"):
+            repo_path = repo_path[:-4]
+        parts = [p for p in repo_path.split("/") if p]
+        if len(parts) >= 2:
+            repo_owner, repo_name = parts[0], parts[1]
+
+    import_package = _derive_import_package(data, name)
+    coverage_source = _derive_coverage_source(data, import_package)
+
+    meta = ProjectMetadata(
+        name=name,
+        slug=slug,
+        repo_url=repo_url,
+        repo_host=repo_host,
+        repo_owner=repo_owner,
+        repo_name=repo_name,
+        homepage=homepage,
+        import_package=import_package,
+        coverage_source=coverage_source,
+    )
+    _METADATA_CACHE[path] = meta
+    return meta
+
+
+def read_version_from_pyproject(pyproject: Path = Path("pyproject.toml")) -> str:
+    data = _load_pyproject(pyproject)
+    project = data.get("project", {}) if isinstance(data, dict) else {}
+    version = str(project.get("version") or "").strip()
+    if version:
+        return version
+    text = pyproject.read_text(encoding="utf-8")
+    match = re.search(r'(?m)^version\s*=\s*"([0-9]+(?:\.[0-9]+){2})"', text)
+    return match.group(1) if match else ""
+
+
+def ensure_clean_git_tree() -> None:
+    dirty = subprocess.call(["bash", "-lc", "! git diff --quiet || ! git diff --cached --quiet"], stdout=subprocess.DEVNULL)
+    if dirty == 0:
+        print("[release] Working tree not clean. Commit or stash changes first.", file=sys.stderr)
+        raise SystemExit(1)
+
+
+def git_branch() -> str:
+    return run(["git", "rev-parse", "--abbrev-ref", "HEAD"], capture=True).out.strip()
+
+
+def git_delete_tag(name: str, *, remote: str | None = None) -> None:
+    run(["git", "tag", "-d", name], check=False, capture=True)
+    if remote:
+        run(["git", "push", remote, f":refs/tags/{name}"], check=False)
+
+
+def git_tag_exists(name: str) -> bool:
+    return subprocess.call(["bash", "-lc", f"git rev-parse -q --verify {shlex.quote('refs/tags/' + name)} >/dev/null"], stdout=subprocess.DEVNULL) == 0
+
+
+def git_create_annotated_tag(name: str, message: str) -> None:
+    run(["git", "tag", "-a", name, "-m", message])
+
+
+def git_push(remote: str, ref: str) -> None:
+    run(["git", "push", remote, ref])
+
+
+def gh_available() -> bool:
+    return cmd_exists("gh")
+
+
+def gh_release_exists(tag: str) -> bool:
+    return subprocess.call(["bash", "-lc", f"gh release view {shlex.quote(tag)} >/dev/null 2>&1"], stdout=subprocess.DEVNULL) == 0
+
+
+def gh_release_create(tag: str, title: str, body: str) -> None:
+    run(["gh", "release", "create", tag, "-t", title, "-n", body], check=False)
+
+
+def gh_release_edit(tag: str, title: str, body: str) -> None:
+    run(["gh", "release", "edit", tag, "-t", title, "-n", body], check=False)
+
+
+def sync_packaging() -> None:
+    run([sys.executable, "scripts/bump_version.py", "--sync-packaging"], check=False)
+
+
+def bootstrap_dev() -> None:
+    if not (cmd_exists("ruff") and cmd_exists("pyright")):
+        print("[bootstrap] Installing dev dependencies via 'pip install -e .[dev]'")
+        run([sys.executable, "-m", "pip", "install", "-e", ".[dev]"])
+    try:
+        from importlib import import_module
+
+        import_module("sqlite3")
+    except Exception:
+        run([sys.executable, "-m", "pip", "install", "pysqlite3-binary"], check=False)

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/scripts/build.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import click
 import sys
 
-from ._utils import cmd_exists, run
+from ._utils import cmd_exists, get_project_metadata, run
 
 
 @click.command(help="Build wheel/sdist, optionally attempt conda/brew/nix builds if tools present")
@@ -14,6 +14,8 @@ def main(conda: bool, brew: bool, nix: bool) -> None:
     click.echo("[1/4] Building wheel/sdist via python -m build")
     run([sys.executable, "-m", "build"])  # requires build in dev deps
 
+    project = get_project_metadata()
+
     click.echo("[2/4] Attempting conda-build")
     if conda and cmd_exists("conda"):
         run(["bash", "-lc", "CONDA_USE_LOCAL=1 conda build packaging/conda/recipe"], check=False)
@@ -22,7 +24,7 @@ def main(conda: bool, brew: bool, nix: bool) -> None:
 
     click.echo("[3/4] Attempting Homebrew build/install from local formula")
     if brew and cmd_exists("brew"):
-        run(["bash", "-lc", "brew install --build-from-source packaging/brew/Formula/lib-cli-exit-tools.rb"], check=False)
+        run(["bash", "-lc", f"brew install --build-from-source {project.brew_formula_path}"], check=False)
     else:
         click.echo("[brew] skipping: Homebrew not available or disabled")
 

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/scripts/bump_version.py

@@ -8,6 +8,10 @@ from typing import Any, Dict, Tuple, Optional, cast
 import json
 import urllib.request
 import hashlib
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from scripts._utils import get_project_metadata  # noqa: E402
 
 # Optional TOML parser for Python < 3.11 support during type checking
 try:  # pragma: no cover - import resolution
@@ -18,6 +22,8 @@ except Exception:  # pragma: no cover - best-effort fallback
     except Exception:  # noqa: PLC1901
         _tomllib = None  # type: ignore[assignment]
 
+PROJECT_META = get_project_metadata()
+
 
 def parse_args() -> argparse.Namespace:
     p = argparse.ArgumentParser(description="Bump version in pyproject.toml and CHANGELOG.md")
@@ -221,19 +227,20 @@ def _update_conda_recipe(version: str, path: Path) -> None:
             text = new_text
             changed = True
     # Attempt to set sha256 for remote source tarball (used when COND A_USE_LOCAL != 1)
-    try:
-        tar_url = f"https://github.com/bitranox/lib_cli_exit_tools/archive/refs/tags/v{version}.tar.gz"
-        with urllib.request.urlopen(tar_url, timeout=10) as resp:
-            data = resp.read()
-        sha = hashlib.sha256(data).hexdigest()
-        text_sha = re.sub(r'(sha256:\s*")([^"]*)(")', rf"\1{sha}\3", text)
-        if text_sha != text:
-            text = text_sha
-            changed = True
-            print(f"[bump] conda recipe: sha256 updated for v{version}")
-    except Exception:
-        # Network may be unavailable; leave sha256 as-is
-        pass
+    tar_url = PROJECT_META.github_tarball_url(version)
+    if tar_url:
+        try:
+            with urllib.request.urlopen(tar_url, timeout=10) as resp:
+                data = resp.read()
+            sha = hashlib.sha256(data).hexdigest()
+            text_sha = re.sub(r'(sha256:\s*")([^"]*)(")', rf"\1{sha}\3", text)
+            if text_sha != text:
+                text = text_sha
+                changed = True
+                print(f"[bump] conda recipe: sha256 updated for v{version}")
+        except Exception:
+            # Network may be unavailable; leave sha256 as-is
+            pass
 
     if changed:
         path.write_text(text, encoding="utf-8")
@@ -248,18 +255,19 @@ def _brew_set_source_tag(text: str, version: str) -> tuple[str, bool]:
         changed = True
         text = new_text
     # Try to fetch tarball and compute sha256; replace first sha256 occurrence (main formula)
-    try:
-        tar_url = f"https://github.com/bitranox/lib_cli_exit_tools/archive/refs/tags/v{version}.tar.gz"
-        with urllib.request.urlopen(tar_url, timeout=10) as resp:
-            data = resp.read()
-        sha = hashlib.sha256(data).hexdigest()
-        pattern = r'(^\s*sha256\s+")([^"]+)(")'
-        updated = re.sub(pattern, rf"\1{sha}\3", text, count=1, flags=re.M)
-        if updated != text:
-            text = updated
-            changed = True
-    except Exception:
-        pass
+    tar_url = PROJECT_META.github_tarball_url(version)
+    if tar_url:
+        try:
+            with urllib.request.urlopen(tar_url, timeout=10) as resp:
+                data = resp.read()
+            sha = hashlib.sha256(data).hexdigest()
+            pattern = r'(^\s*sha256\s+")([^"]+)(")'
+            updated = re.sub(pattern, rf"\1{sha}\3", text, count=1, flags=re.M)
+            if updated != text:
+                text = updated
+                changed = True
+        except Exception:
+            pass
     return text, changed
 
 
@@ -338,12 +346,13 @@ def _update_nix_flake(version: str, path: Path) -> None:
         return
 
     # Replace version = "X.Y.Z";
-    # Update package block version only for pname = "lib_cli_exit_tools"
+    # Update package block version only for the configured pname from pyproject
     def repl_pkg_block(m: re.Match[str]) -> str:
         return f"{m.group(1)}{version}{m.group(3)}"
 
+    name_pattern = re.escape(PROJECT_META.name)
     t1 = re.sub(
-        r"(pname\s*=\s*\"lib_cli_exit_tools\";\s*[^}]*?\bversion\s*=\s*\")(\d+\.\d+\.\d+)(\";)",
+        rf"(pname\s*=\s*\"{name_pattern}\";\s*[^}}]*?\bversion\s*=\s*\")(\d+\.\d+\.\d+)(\";)",
         repl_pkg_block,
         text,
         flags=re.S,
@@ -398,7 +407,7 @@ def main() -> int:
             raise SystemExit("version not found in pyproject.toml")
         target = m.group(1)
         _update_conda_recipe(target, Path("packaging/conda/recipe/meta.yaml"))
-        _update_brew_formula(target, Path("packaging/brew/Formula/lib-cli-exit-tools.rb"))
+        _update_brew_formula(target, Path(PROJECT_META.brew_formula_path))
         _update_nix_flake(target, Path("packaging/nix/flake.nix"))
         return 0
 
@@ -429,7 +438,7 @@ def main() -> int:
 
     # Also bump packaging skeletons if present
     _update_conda_recipe(target, Path("packaging/conda/recipe/meta.yaml"))
-    _update_brew_formula(target, Path("packaging/brew/Formula/lib-cli-exit-tools.rb"))
+    _update_brew_formula(target, Path(PROJECT_META.brew_formula_path))
     _update_nix_flake(target, Path("packaging/nix/flake.nix"))
     return 0
 

{lib_cli_exit_tools-1.0.3 → lib_cli_exit_tools-1.1.0}/scripts/menu.py

@@ -4,12 +4,20 @@ import asyncio
 import os
 import signal
 from dataclasses import dataclass
+from pathlib import Path
 from typing import TYPE_CHECKING, Callable, Dict, Optional
 
 import contextlib
 
 from rich.text import Text
 
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from scripts._utils import get_project_metadata  # noqa: E402
+
+PROJECT = get_project_metadata()
+
 if TYPE_CHECKING:
     from textual import events
     from textual.app import App, ComposeResult
@@ -170,7 +178,7 @@ class MenuScreen(Screen[None]):
     def compose(self) -> ComposeResult:  # type: ignore[override]
         with Container(id="backdrop"):
             with Vertical(id="window", classes="whiptail-window"):
-                yield Static("lib_cli_exit_tools — Make Targets", id="title")
+                yield Static(f"{PROJECT.name} — Make Targets", id="title")
                 self._description = Static("Select a target and press Enter.", id="description")
                 yield self._description
                 yield self._build_list()

lib_cli_exit_tools-1.1.0/scripts/run_cli.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import click
+import sys
+from importlib import import_module
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from scripts._utils import get_project_metadata  # noqa: E402
+
+PROJECT = get_project_metadata()
+PACKAGE = PROJECT.import_package
+
+
+@click.command(help=f"Run {PROJECT.name} CLI (passes additional args)")
+@click.argument("args", nargs=-1)
+def main(args: tuple[str, ...]) -> None:
+    import_module(f"{PACKAGE}.__main__")
+    cli_main = import_module(f"{PACKAGE}.cli").main
+
+    code = cli_main(list(args) if args else ["--help"])  # returns int
+    raise SystemExit(int(code))
+
+
+if __name__ == "__main__":
+    main()