tmuxpull 0.2.0__tar.gz → 0.2.1__tar.gz

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tmuxpull
-Version: 0.2.0
+Version: 0.2.1
 Summary: Keep every git repo under a directory in step with its remote, concurrently, with a tmux session per repo that needs you
 Project-URL: Homepage, https://github.com/nguyengg/tmuxpull
 Project-URL: Repository, https://github.com/nguyengg/tmuxpull.git
@@ -121,6 +121,40 @@ tmuxpull [-d DEPTH] [-j JOBS] [--tmux {on,off}] [--rebase-pushed]
 - `--no-log` — Don't write a report file
 - `-v, --verbose` — Show incoming commit subjects (`-v` = top 3, `-vv` = all)
 - `--dry-run` — List repos that would be processed, then exit
+- `-V, --version` — Print the version and the file it's running from, then exit
+
+### Am I running the latest?
+
+```bash
+$ tmuxpull --version
+tmuxpull 0.2.1 (/home/you/.local/share/uv/tools/tmuxpull/lib/python3.14/site-packages/tmuxpull/__init__.py)
+```
+
+The path is there because one machine can easily have three copies on `PATH` —
+a `pip install` into whichever Python was current, a `uv tool install`, and a
+curl'd standalone script — and the version number alone won't tell you which one
+just ran. The second field is always the bare version, so `tmuxpull --version |
+awk '{print $2}'` is scriptable.
+
+Compare against what's published:
+
+```bash
+curl -s https://pypi.org/pypi/tmuxpull/json | grep -o '"version":"[^"]*"' | head -1
+```
+
+Upgrading depends on how it was installed:
+
+```bash
+uv tool upgrade tmuxpull      # uv tool install
+pip install -U tmuxpull       # pip install
+```
+
+A `pip install` into a version-managed Python (mise, pyenv, asdf) is worth
+avoiding: the package lives under that exact interpreter, so the next Python
+upgrade silently leaves it behind — or drops it off `PATH` entirely. `uv tool
+install tmuxpull` keeps it in its own environment instead. The curl one-liners
+need no upgrade at all: they read `main` directly, so they're current the moment
+a fix lands.
 
 ### Per-repo git config
 

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/README.md

@@ -94,6 +94,40 @@ tmuxpull [-d DEPTH] [-j JOBS] [--tmux {on,off}] [--rebase-pushed]
 - `--no-log` — Don't write a report file
 - `-v, --verbose` — Show incoming commit subjects (`-v` = top 3, `-vv` = all)
 - `--dry-run` — List repos that would be processed, then exit
+- `-V, --version` — Print the version and the file it's running from, then exit
+
+### Am I running the latest?
+
+```bash
+$ tmuxpull --version
+tmuxpull 0.2.1 (/home/you/.local/share/uv/tools/tmuxpull/lib/python3.14/site-packages/tmuxpull/__init__.py)
+```
+
+The path is there because one machine can easily have three copies on `PATH` —
+a `pip install` into whichever Python was current, a `uv tool install`, and a
+curl'd standalone script — and the version number alone won't tell you which one
+just ran. The second field is always the bare version, so `tmuxpull --version |
+awk '{print $2}'` is scriptable.
+
+Compare against what's published:
+
+```bash
+curl -s https://pypi.org/pypi/tmuxpull/json | grep -o '"version":"[^"]*"' | head -1
+```
+
+Upgrading depends on how it was installed:
+
+```bash
+uv tool upgrade tmuxpull      # uv tool install
+pip install -U tmuxpull       # pip install
+```
+
+A `pip install` into a version-managed Python (mise, pyenv, asdf) is worth
+avoiding: the package lives under that exact interpreter, so the next Python
+upgrade silently leaves it behind — or drops it off `PATH` entirely. `uv tool
+install tmuxpull` keeps it in its own environment instead. The curl one-liners
+need no upgrade at all: they read `main` directly, so they're current the moment
+a fix lands.
 
 ### Per-repo git config
 

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/bin/rebase-all

@@ -35,6 +35,8 @@
 set -uo pipefail
 
 # --- defaults ------------------------------------------------------------
+# Kept in step with src/tmuxpull/__init__.py's __version__ by a test.
+version="0.2.1"
 max_depth=2
 jobs=8
 typeset -a excludes
@@ -73,6 +75,7 @@ Options:
   -v               Verbose: -v shows top 3 incoming commit subjects per repo,
                    -vv shows all
   --dry-run        List repos and exit
+  -V, --version    Show the version and which copy is running, then exit
   -h, --help       Show this help
 
 Per-repo git config:
@@ -93,6 +96,7 @@ while [[ $# -gt 0 ]]; do
         -v) ((verbose++)); shift ;;
         -vv) verbose=2; shift ;;
         --dry-run) dry_run=true; shift ;;
+        -V|--version) printf 'tmuxpull %s (%s)\n' "$version" "${0:A}"; exit 0 ;;
         -h|--help) usage; exit 0 ;;
         --) shift; break ;;
         -*) echo "Unknown option: $1" >&2; usage; exit 1 ;;

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/bin/rebase-all.py

@@ -60,6 +60,12 @@ from typing import Iterable
 import libtmux
 
 
+# Single source of truth for the version: pyproject.toml reads it from here
+# (hatch dynamic version), so the PyPI package, the generated standalone script
+# and `--version` can never disagree.
+__version__ = "0.2.1"
+
+
 # Directories that are never a repo we want to descend into.
 _SKIP_DIRS: frozenset[str] = frozenset(
     {
@@ -923,6 +929,32 @@ async def _run(repos: list[Repo], jobs: int, verbose: int, opts: Options) -> lis
     return results
 
 
+def version_line() -> str:
+    """Version plus the file it is running from.
+
+    The path matters as much as the number: the same machine can have a PyPI
+    install, a `uv tool` install and a curl'd standalone script on PATH, and
+    this says which one you just ran.
+    """
+    return f"tmuxpull {__version__} ({Path(__file__).resolve()})"
+
+
+class _VersionAction(argparse.Action):
+    """Print version_line() verbatim.
+
+    argparse's built-in "version" action runs its text through the help
+    formatter, which re-wraps at terminal width and splits the path onto its
+    own line -- so `--version` output would depend on how wide the window is.
+    """
+
+    def __init__(self, option_strings: list[str], dest: str, **kw: object) -> None:
+        super().__init__(option_strings, dest, nargs=0, **kw)  # type: ignore[arg-type]
+
+    def __call__(self, parser, namespace, values, option_string=None) -> None:  # noqa: ANN001
+        print(version_line())
+        parser.exit()
+
+
 def main() -> None:
     ap = argparse.ArgumentParser(
         prog="tmuxpull",
@@ -941,6 +973,12 @@ def main() -> None:
             "main/master/trunk)."
         ),
     )
+    ap.add_argument(
+        "-V",
+        "--version",
+        action=_VersionAction,
+        help="Show the version and which copy is running, then exit.",
+    )
     ap.add_argument(
         "-d",
         "--max-depth",

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tmuxpull"
-version = "0.2.0"
+dynamic = ["version"]
 description = "Keep every git repo under a directory in step with its remote, concurrently, with a tmux session per repo that needs you"
 readme = "README.md"
 license = "MIT"
@@ -42,6 +42,10 @@ tmuxpull = "tmuxpull.__main__:main"
 [tool.hatch.build.targets.wheel]
 packages = ["src/tmuxpull"]
 
+# One place to bump: src/tmuxpull/__init__.py's __version__.
+[tool.hatch.version]
+path = "src/tmuxpull/__init__.py"
+
 [tool.ruff]
 line-length = 120
 target-version = "py311"

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/src/tmuxpull/__init__.py

@@ -50,6 +50,12 @@ from typing import Iterable
 import libtmux
 
 
+# Single source of truth for the version: pyproject.toml reads it from here
+# (hatch dynamic version), so the PyPI package, the generated standalone script
+# and `--version` can never disagree.
+__version__ = "0.2.1"
+
+
 # Directories that are never a repo we want to descend into.
 _SKIP_DIRS: frozenset[str] = frozenset(
     {
@@ -913,6 +919,32 @@ async def _run(repos: list[Repo], jobs: int, verbose: int, opts: Options) -> lis
     return results
 
 
+def version_line() -> str:
+    """Version plus the file it is running from.
+
+    The path matters as much as the number: the same machine can have a PyPI
+    install, a `uv tool` install and a curl'd standalone script on PATH, and
+    this says which one you just ran.
+    """
+    return f"tmuxpull {__version__} ({Path(__file__).resolve()})"
+
+
+class _VersionAction(argparse.Action):
+    """Print version_line() verbatim.
+
+    argparse's built-in "version" action runs its text through the help
+    formatter, which re-wraps at terminal width and splits the path onto its
+    own line -- so `--version` output would depend on how wide the window is.
+    """
+
+    def __init__(self, option_strings: list[str], dest: str, **kw: object) -> None:
+        super().__init__(option_strings, dest, nargs=0, **kw)  # type: ignore[arg-type]
+
+    def __call__(self, parser, namespace, values, option_string=None) -> None:  # noqa: ANN001
+        print(version_line())
+        parser.exit()
+
+
 def main() -> None:
     ap = argparse.ArgumentParser(
         prog="tmuxpull",
@@ -931,6 +963,12 @@ def main() -> None:
             "main/master/trunk)."
         ),
     )
+    ap.add_argument(
+        "-V",
+        "--version",
+        action=_VersionAction,
+        help="Show the version and which copy is running, then exit.",
+    )
     ap.add_argument(
         "-d",
         "--max-depth",

tmuxpull-0.2.1/tests/test_version.py

@@ -0,0 +1,90 @@
+"""The version must be one number, reported the same way by every copy.
+
+There are four places it could drift: the module, the packaging metadata, the
+generated standalone script, and the zsh port. `__version__` is the source of
+truth (pyproject reads it via hatch's dynamic version) and these pin the rest
+to it.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import tmuxpull
+from tmuxpull import __version__, version_line
+
+ROOT = Path(__file__).resolve().parent.parent
+ZSH_SCRIPT = ROOT / "bin" / "rebase-all"
+STANDALONE = ROOT / "bin" / "rebase-all.py"
+
+
+def _env() -> dict[str, str]:
+    import os
+
+    env = dict(os.environ)
+    env["PYTHONPATH"] = str(ROOT / "src")
+    return env
+
+
+def test_version_is_a_release_number():
+    assert re.fullmatch(r"\d+\.\d+\.\d+([a-z0-9.]*)?", __version__), __version__
+
+
+def test_packaging_metadata_matches_the_module():
+    """Proves pyproject's hatch dynamic version is wired to __version__."""
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        installed = version("tmuxpull")
+    except PackageNotFoundError:
+        pytest.skip("tmuxpull is not installed in this environment")
+    assert installed == __version__
+
+
+def test_pyproject_does_not_hardcode_a_second_version():
+    body = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    assert 'dynamic = ["version"]' in body
+    assert '[tool.hatch.version]' in body
+    assert not re.search(r'(?m)^version = ', body), "a literal version would drift"
+
+
+def test_version_line_names_the_running_file():
+    line = version_line()
+    assert line.startswith(f"tmuxpull {__version__} (")
+    assert str(Path(tmuxpull.__file__).resolve()) in line
+
+
+def test_cli_version_flag_prints_and_exits_zero():
+    for flag in ("--version", "-V"):
+        proc = subprocess.run(
+            [sys.executable, "-m", "tmuxpull", flag],
+            capture_output=True,
+            text=True,
+            env=_env(),
+        )
+        assert proc.returncode == 0, proc.stderr
+        out = (proc.stdout + proc.stderr).strip()
+        assert out.startswith(f"tmuxpull {__version__} ")
+        # the second field is the bare version, so `--version | awk '{print $2}'` works
+        assert out.split()[1] == __version__
+
+
+def test_standalone_script_carries_the_same_version():
+    body = STANDALONE.read_text(encoding="utf-8")
+    assert f'__version__ = "{__version__}"' in body
+
+
+@pytest.mark.skipif(shutil.which("zsh") is None, reason="zsh not available")
+def test_zsh_port_reports_the_same_version():
+    proc = subprocess.run(
+        [str(ZSH_SCRIPT), "--version"], capture_output=True, text=True, env=_env()
+    )
+    assert proc.returncode == 0, proc.stderr
+    out = proc.stdout.strip()
+    assert out.startswith(f"tmuxpull {__version__} (")
+    assert out.split()[1] == __version__

{tmuxpull-0.2.0 → tmuxpull-0.2.1}/uv.lock

@@ -13,7 +13,6 @@ wheels = [
 
 [[package]]
 name = "tmuxpull"
-version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "libtmux" },