evo-cli 0.31.1__tar.gz → 0.31.2__tar.gz

{evo_cli-0.31.1 → evo_cli-0.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.31.1
+Version: 0.31.2
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.31.2/evo_cli/VERSION

@@ -0,0 +1 @@
+0.31.2

{evo_cli-0.31.1 → evo_cli-0.31.2}/evo_cli/commands/update.py

@@ -18,11 +18,16 @@ from evo_cli import __version__
 from evo_cli.console import CommandError, console, info, run_command, step, success, warning
 
 PACKAGE = "evo_cli"
+TOOL_NAME = "evo-cli"
 PYPI_JSON = "https://pypi.org/pypi/{package}/json"
 
 VERSION_RE = re.compile(r"^v?(\d+(?:\.\d+)*)(?:[-_.]?(dev|alpha|a|beta|b|rc|c|pre)[-_.]?(\d*))?")
 PRE_RANK = {"dev": -4, "alpha": -3, "a": -3, "beta": -2, "b": -2, "pre": -1, "rc": -1, "c": -1}
 
+EXACT_PIN_RE = re.compile(r"^===?\s*([^\s,*]+)$")
+PLAIN_RECEIPT_KEYS = {"requirements", "python", "entrypoints", "options"}
+PLAIN_REQUIREMENT_KEYS = {"name", "extras", "specifier"}
+
 EPILOG = Text.from_markup(
     "[bold]Examples[/bold]\n\n"
     "  [cyan]evo update[/cyan]              update to the newest release\n"
@@ -31,7 +36,9 @@ EPILOG = Text.from_markup(
     "  [cyan]evo update --dry-run[/cyan]    print the commands without running them\n"
     "  [cyan]evo update --force[/cyan]      reinstall even when already current\n\n"
     "[dim]An editable checkout is updated with git (fast-forward only, refusing to touch a\n"
-    "dirty tree); a pipx, uv or pip install is upgraded with its own installer.[/dim]"
+    "dirty tree); a pipx, uv or pip install is upgraded with its own installer. A uv tool\n"
+    "pinned to an older ==version is reinstalled without the pin. The update succeeds only\n"
+    "when the installed version reaches the newest release afterwards.[/dim]"
 )
 
 
@@ -138,7 +145,79 @@ def report(install, current, latest):
     console.print()
 
 
-def build_commands(mode, allow_pre):
+def load_toml(path):
+    try:
+        import tomllib
+    except ImportError:  # Python 3.10
+        try:
+            import tomli as tomllib
+        except ImportError:
+            return {}
+    try:
+        with open(path, "rb") as handle:
+            return tomllib.load(handle)
+    except (OSError, ValueError):
+        return {}
+
+
+def normalize_name(name):
+    return re.sub(r"[-_.]+", "-", str(name or "")).lower()
+
+
+def uv_receipt(location):
+    """The `[tool]` table of a uv tool receipt and its evo-cli requirement (None when absent)."""
+    tool = load_toml(Path(location) / "uv-receipt.toml").get("tool") or {}
+    for requirement in tool.get("requirements") or []:
+        if isinstance(requirement, dict) and normalize_name(requirement.get("name")) == TOOL_NAME:
+            return tool, requirement
+    return tool, None
+
+
+def exact_pin(requirement):
+    match = EXACT_PIN_RE.match(str((requirement or {}).get("specifier") or "").strip())
+    return match.group(1) if match else None
+
+
+def requirement_text(requirement, specifier):
+    extras = requirement.get("extras") or []
+    name = requirement["name"] + (f"[{','.join(extras)}]" if extras else "")
+    return f"{name}{specifier}"
+
+
+def uv_reinstall_command(location, latest, allow_pre):
+    """Reinstall a uv tool whose receipt pins an older `==` version, since `uv tool upgrade` keeps the pin.
+
+    Only a plain receipt is rebuilt: one evo-cli requirement from the index plus an optional Python
+    request. Anything more (`--with`, a git source, index options) goes through `uv tool upgrade`,
+    and the version check afterwards says what to run.
+    """
+    tool, requirement = uv_receipt(location)
+    pinned = exact_pin(requirement)
+    if latest is None or pinned is None or parse_version(pinned) >= parse_version(latest):
+        return None
+    if set(tool) - PLAIN_RECEIPT_KEYS or any((tool.get("options") or {}).values()):
+        return None
+    if len(tool.get("requirements") or []) != 1 or set(requirement) - PLAIN_REQUIREMENT_KEYS:
+        return None
+    info(f"The uv receipt pins [accent]{TOOL_NAME}=={pinned}[/accent], so the tool is reinstalled without the pin.")
+    cmd = [
+        "uv",
+        "tool",
+        "install",
+        "--force",
+        "--refresh-package",
+        requirement["name"],
+        requirement_text(requirement, f">={latest}"),
+    ]
+    if tool.get("python"):
+        cmd += ["--python", str(tool["python"])]
+    if allow_pre:
+        cmd.append("--prerelease=allow")
+    return cmd
+
+
+def build_commands(install, latest, allow_pre):
+    mode = install["mode"]
     target = f"{PACKAGE}"
     if mode == "pipx":
         if shutil.which("pipx") is None:
@@ -150,6 +229,9 @@ def build_commands(mode, allow_pre):
     if mode == "uv":
         if shutil.which("uv") is None:
             raise click.ClickException("This looks like a uv tool install but uv is not on PATH.")
+        reinstall = uv_reinstall_command(install["location"], latest, allow_pre)
+        if reinstall:
+            return [reinstall]
         cmd = ["uv", "tool", "upgrade", target]
         if allow_pre:
             cmd.append("--prerelease=allow")
@@ -163,6 +245,80 @@ def build_commands(mode, allow_pre):
     return [cmd]
 
 
+def installed_version():
+    """The evo version the install holds now, read by a new interpreter: this process keeps the old one.
+
+    The probe drops the current directory ("") from sys.path so that a checkout's egg-info cannot answer.
+    """
+    code = (
+        "import sys; sys.path = [p for p in sys.path if p]; "
+        f"from importlib.metadata import version; print(version({PACKAGE!r}))"
+    )
+    probe = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    version = (probe.stdout or "").strip()
+    return version if probe.returncode == 0 and version else None
+
+
+def pipx_spec(location):
+    try:
+        data = json.loads((Path(location) / "pipx_metadata.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return (data.get("main_package") or {}).get("package_or_url")
+
+
+def stale_hint(install, latest):
+    """Why the installer stopped short of `latest`, and the command that gets there."""
+    location = install["location"]
+    if install["mode"] == "uv":
+        _, requirement = uv_receipt(location)
+        specifier = (requirement or {}).get("specifier")
+        fix = f"uv tool install --force --refresh-package {TOOL_NAME} '{TOOL_NAME}>={latest}'"
+        if specifier:
+            receipt = Path(location) / "uv-receipt.toml"
+            return (
+                f"{receipt} pins {TOOL_NAME}{specifier}, which `uv tool upgrade` keeps. "
+                f"Reinstall without the pin:\n  {fix}"
+            )
+        return f"uv may have read a cached package index from before the release. Refresh it:\n  {fix}"
+    if install["mode"] == "pipx":
+        fix = f"pipx install --force '{TOOL_NAME}>={latest}'"
+        spec = pipx_spec(location)
+        if spec and re.search(r"[=<>~!]", spec):
+            return f"pipx installed evo as {spec}, which `pipx upgrade` keeps. Reinstall without the pin:\n  {fix}"
+        return f"Reinstall it:\n  {fix}"
+    return (
+        "A pip constraint or a cached index may hold it back. Run:\n"
+        f"  {sys.executable} -m pip install --upgrade '{TOOL_NAME}>={latest}'"
+    )
+
+
+def confirm_update(install, current, latest):
+    """Report success only for the version that is really installed now."""
+    installed = installed_version()
+    if installed is None:
+        raise click.ClickException("The installer finished, but the installed evo version cannot be read.")
+    if latest is None:
+        if installed == current:
+            warning(f"evo is still at [accent]{installed}[/accent], and PyPI did not say whether a newer one exists.")
+        else:
+            success(f"evo is now at [accent]{installed}[/accent].")
+        return
+    if parse_version(installed) < parse_version(latest):
+        raise click.ClickException(
+            f"evo is still at {installed}, not {latest}, after the update. {stale_hint(install, latest)}"
+        )
+    success(f"evo updated to [accent]{installed}[/accent].")
+    info("Open a new shell if the `evo` command still reports the old version.")
+
+
 def execute(commands, dry_run):
     for cmd in commands:
         if dry_run:
@@ -238,7 +394,7 @@ def update_editable(path, check, force, dry_run):
         success(f"evo is now at [accent]{version_file.read_text(encoding='utf-8').strip()}[/accent]")
 
 
-def update_package(mode, current, latest, check, allow_pre, force, dry_run):
+def update_package(install, current, latest, check, allow_pre, force, dry_run):
     if latest is None:
         if check:
             raise click.ClickException("Cannot determine the latest version from PyPI.")
@@ -253,10 +409,9 @@ def update_package(mode, current, latest, check, allow_pre, force, dry_run):
         info("Run [accent]evo update[/accent] to install it.")
         return
 
-    execute(build_commands(mode, allow_pre), dry_run)
+    execute(build_commands(install, latest, allow_pre), dry_run)
     if not dry_run:
-        success(f"evo updated to [accent]{latest or 'the latest release'}[/accent].")
-        info("Open a new shell if the `evo` command still reports the old version.")
+        confirm_update(install, current, latest)
 
 
 @click.command("update", epilog=EPILOG, context_settings={"help_option_names": ["-h", "--help"]})
@@ -288,4 +443,4 @@ def update(check, allow_pre, force, dry_run, timeout):
     if install["mode"] == "editable":
         update_editable(install["location"], check, force, dry_run)
         return
-    update_package(install["mode"], __version__, latest, check, allow_pre, force, dry_run)
+    update_package(install, __version__, latest, check, allow_pre, force, dry_run)

{evo_cli-0.31.1 → evo_cli-0.31.2}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.31.1
+Version: 0.31.2
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.31.1 → evo_cli-0.31.2}/tests/test_update.py

@@ -1,4 +1,5 @@
 import subprocess
+import sys
 
 from click.testing import CliRunner
 
@@ -18,6 +19,29 @@ def _stub_pypi(monkeypatch, versions):
     monkeypatch.setattr(update_command, "fetch_pypi", lambda package, timeout: _pypi(versions))
 
 
+def _stub_installer(monkeypatch, installed_after):
+    """Record the installer commands; the version probe then reports `installed_after`."""
+    ran = []
+    monkeypatch.setattr(update_command, "run_command", lambda cmd: ran.append([str(part) for part in cmd]))
+
+    def fake_run(cmd, **kwargs):
+        assert cmd[0] == sys.executable
+        return _result(stdout=f"{installed_after}\n")
+
+    monkeypatch.setattr(update_command.subprocess, "run", fake_run)
+    return ran
+
+
+def _uv_install(monkeypatch, tmp_path, receipt):
+    (tmp_path / "uv-receipt.toml").write_text(receipt, encoding="utf-8")
+    monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "uv", "location": tmp_path})
+    monkeypatch.setattr(update_command.shutil, "which", lambda name: f"/usr/bin/{name}")
+
+
+def _flat(output):
+    return " ".join(output.replace("│", " ").split())
+
+
 def test_update_command_is_registered():
     assert "update" in cli.commands
 
@@ -76,14 +100,113 @@ def test_update_runs_pip_upgrade_when_outdated(monkeypatch):
     _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
     monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
     monkeypatch.setattr(update_command, "__version__", "0.11.3")
-    monkeypatch.setattr(update_command, "build_commands", lambda mode, allow_pre: [["pip", "install", "-U", mode]])
+    monkeypatch.setattr(
+        update_command, "build_commands", lambda install, latest, allow_pre: [["pip", "install", "-U", install["mode"]]]
+    )
     calls = []
     monkeypatch.setattr(update_command, "execute", lambda commands, dry_run: calls.append((commands, dry_run)))
+    _stub_installer(monkeypatch, "0.12.0")
 
     result = CliRunner().invoke(cli, ["update"])
 
     assert result.exit_code == 0
     assert calls == [([["pip", "install", "-U", "pip"]], False)]
+    assert "evo updated to 0.12.0" in result.output
+
+
+def test_update_fails_when_the_upgrade_leaves_the_old_version(monkeypatch):
+    _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
+    monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
+    monkeypatch.setattr(update_command, "__version__", "0.11.3")
+    ran = _stub_installer(monkeypatch, "0.11.3")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 1
+    assert ran == [[sys.executable, "-m", "pip", "install", "--upgrade", "evo_cli"]]
+    assert "evo updated" not in result.output
+    assert "evo is still at 0.11.3, not 0.12.0" in _flat(result.output)
+
+
+def test_uv_update_reinstalls_over_a_stale_exact_pin(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", specifier = "==0.31.0" }]\n'
+        'entrypoints = [{ name = "evo", install-path = "/home/me/.local/bin/evo" }]\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [["uv", "tool", "install", "--force", "--refresh-package", "evo-cli", "evo-cli>=0.31.1"]]
+    assert "pins evo-cli==0.31.0" in _flat(result.output)
+    assert "evo updated to 0.31.1" in result.output
+
+
+def test_uv_reinstall_keeps_extras_and_python(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", extras = ["image"], specifier = "==0.31.0" }]\npython = "3.13"\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [
+        [
+            "uv",
+            "tool",
+            "install",
+            "--force",
+            "--refresh-package",
+            "evo-cli",
+            "evo-cli[image]>=0.31.1",
+            "--python",
+            "3.13",
+        ]
+    ]
+
+
+def test_uv_upgrade_held_by_a_pin_it_cannot_rebuild_fails_with_the_fix(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", specifier = "==0.31.0" }, { name = "rich" }]\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.0")
+
+    result = CliRunner().invoke(cli, ["update"])
+    output = _flat(result.output)
+
+    assert result.exit_code == 1
+    assert ran == [["uv", "tool", "upgrade", "evo_cli"]]
+    assert "evo updated" not in result.output
+    assert "evo is still at 0.31.0, not 0.31.1" in output
+    assert "pins evo-cli==0.31.0" in output
+    assert "uv tool install --force --refresh-package evo-cli 'evo-cli>=0.31.1'" in output
+
+
+def test_uv_upgrade_without_a_pin_skips_the_reinstall(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(monkeypatch, tmp_path, '[tool]\nrequirements = [{ name = "evo-cli" }]\n')
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [["uv", "tool", "upgrade", "evo_cli"]]
+    assert "evo updated to 0.31.1" in result.output
 
 
 def test_editable_update_pulls_and_reports_head(monkeypatch, tmp_path):
@@ -167,7 +290,9 @@ def test_dry_run_prints_commands_without_running_them(monkeypatch):
     _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
     monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
     monkeypatch.setattr(update_command, "__version__", "0.11.3")
-    monkeypatch.setattr(update_command, "build_commands", lambda mode, allow_pre: [["pip", "install", "-U", "evo_cli"]])
+    monkeypatch.setattr(
+        update_command, "build_commands", lambda install, latest, allow_pre: [["pip", "install", "-U", "evo_cli"]]
+    )
     monkeypatch.setattr(update_command, "run_command", lambda cmd: (_ for _ in ()).throw(AssertionError("ran")))
 
     result = CliRunner().invoke(cli, ["update", "--dry-run"])

evo_cli-0.31.1/evo_cli/VERSION

@@ -1 +0,0 @@
-0.31.1