pyselfupdate 0.2.0__tar.gz → 0.2.2__tar.gz

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyselfupdate
-Version: 0.2.0
+Version: 0.2.2
 Summary: Self-update and update notification for Python CLIs installed with uv tool
 Keywords: uv,cli,self-update,update-notifier,release
 Author: Chris Birch
@@ -126,8 +126,23 @@ add_update_command(app, CONFIG)  # gives you `mytool update [--check]`
 environment the running interpreter lives in**. Unlike replacing a Unix binary
 — where the process holds an inode and is untouched — this pulls modules out
 from under a live process, so anything imported afterwards may fail in ways
-that are hard to read. Make it the last thing your process does, or use
-`update_and_reexec` to replace the process with the new version immediately.
+that are hard to read. Make it the last thing your process does, then call
+`exit_now` — or use `update_and_reexec` to replace the process with the new
+version immediately.
+
+That cuts both ways: anything you want to *print* after the install has to be
+fetched before it. `run_update` resolves its changelog first for exactly this
+reason, and a caller that needs its own steps in between composes the three
+pieces `update` is made of rather than working around it:
+
+```python
+installation = require_updatable(config)  # refuses a checkout, costs nothing
+result = check(config)  # network, environment still intact
+notes = changelog(config, result.current, result.latest)
+install_release(config, result, installation)
+print(notes)
+exit_now()
+```
 
 ## What will not be updated
 

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/README.md

@@ -102,8 +102,23 @@ add_update_command(app, CONFIG)  # gives you `mytool update [--check]`
 environment the running interpreter lives in**. Unlike replacing a Unix binary
 — where the process holds an inode and is untouched — this pulls modules out
 from under a live process, so anything imported afterwards may fail in ways
-that are hard to read. Make it the last thing your process does, or use
-`update_and_reexec` to replace the process with the new version immediately.
+that are hard to read. Make it the last thing your process does, then call
+`exit_now` — or use `update_and_reexec` to replace the process with the new
+version immediately.
+
+That cuts both ways: anything you want to *print* after the install has to be
+fetched before it. `run_update` resolves its changelog first for exactly this
+reason, and a caller that needs its own steps in between composes the three
+pieces `update` is made of rather than working around it:
+
+```python
+installation = require_updatable(config)  # refuses a checkout, costs nothing
+result = check(config)  # network, environment still intact
+notes = changelog(config, result.current, result.latest)
+install_release(config, result, installation)
+print(notes)
+exit_now()
+```
 
 ## What will not be updated
 

pyselfupdate-0.2.2/pyproject.toml

@@ -0,0 +1,239 @@
+[project]
+name = "pyselfupdate"
+version = "0.2.2"
+description = "Self-update and update notification for Python CLIs installed with uv tool"
+readme = "README.md"
+keywords = [
+    "uv",
+    "cli",
+    "self-update",
+    "update-notifier",
+    "release",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Software Distribution",
+    "Typing :: Typed",
+]
+requires-python = ">=3.11"
+dependencies = []
+
+[[project.authors]]
+name = "Chris Birch"
+email = "datapointchris@gmail.com"
+
+[project.license]
+text = "MIT"
+
+[project.optional-dependencies]
+typer = ["typer>=0.12.0"]
+
+[project.urls]
+Repository = "https://github.com/datapointchris/pyselfupdate"
+Issues = "https://github.com/datapointchris/pyselfupdate/issues"
+Changelog = "https://github.com/datapointchris/pyselfupdate/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+dev = [
+    "bandit>=1.7.8",
+    "mypy>=1.10.0",
+    "pre-commit>=4.3.0",
+    "pytest>=8.0.0",
+    "ruff>=0.7.0",
+    "typer>=0.12.0",
+]
+
+[tool.bandit]
+exclude_dirs = [
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".venv",
+    "tests",
+]
+skips = [
+    "B311",
+    "B404",
+    "B603",
+]
+
+[tool.codespell]
+skip = "*.lock"
+check-filenames = true
+
+[tool.mypy]
+pretty = true
+ignore_missing_imports = true
+check_untyped_defs = false
+warn_return_any = false
+
+[tool.pytest.ini_options]
+addopts = "-vv"
+minversion = "8.0"
+testpaths = ["tests"]
+
+[tool.refurb]
+enable_all = true
+
+[tool.ruff]
+line-length = 140
+exclude = [
+    ".git",
+    "__pycache__",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".vscode",
+    ".venv",
+    "build",
+    "dist",
+]
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "UP",
+    "B",
+    "SIM",
+    "I",
+]
+ignore = ["SIM108"]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+branch = "main"
+commit_message = "build(release): {version}"
+build_command = """
+    pip install uv
+    uv lock --upgrade-package pyselfupdate
+    git add uv.lock
+"""
+
+[tool.pyright]
+typeCheckingMode = "standard"
+analyzeUnannotatedFunctions = true
+
+[tool.forge]
+managed = [
+    [
+    "ruff",
+    "line-length",
+],
+    [
+    "ruff",
+    "format",
+    "quote-style",
+],
+    [
+    "ruff",
+    "format",
+    "indent-style",
+],
+    [
+    "ruff",
+    "format",
+    "skip-magic-trailing-comma",
+],
+    [
+    "ruff",
+    "format",
+    "line-ending",
+],
+    [
+    "ruff",
+    "format",
+    "docstring-code-format",
+],
+    [
+    "ruff",
+    "lint",
+    "select",
+],
+    [
+    "ruff",
+    "lint",
+    "ignore",
+],
+    [
+    "ruff",
+    "lint",
+    "isort",
+    "force-single-line",
+],
+    [
+    "ruff",
+    "lint",
+    "per-file-ignores",
+    "__init__.py",
+],
+    [
+    "mypy",
+    "pretty",
+],
+    [
+    "mypy",
+    "ignore_missing_imports",
+],
+    [
+    "mypy",
+    "check_untyped_defs",
+],
+    [
+    "mypy",
+    "warn_return_any",
+],
+    [
+    "pyright",
+    "typeCheckingMode",
+],
+    [
+    "pyright",
+    "analyzeUnannotatedFunctions",
+],
+    [
+    "codespell",
+    "check-filenames",
+],
+    [
+    "pytest",
+    "ini_options",
+    "addopts",
+],
+    [
+    "pytest",
+    "ini_options",
+    "minversion",
+],
+    [
+    "pytest",
+    "ini_options",
+    "testpaths",
+],
+]
+
+[tool.uv.build-backend]
+module-name = "pyselfupdate"
+module-root = "src"
+
+[build-system]
+requires = ["uv_build>=0.11.32,<0.12.0"]
+build-backend = "uv_build"

pyselfupdate-0.2.0/pyproject.toml → pyselfupdate-0.2.2/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "pyselfupdate"
-version = "0.2.0"
+version = "0.2.2"
 description = "Self-update and update notification for Python CLIs installed with uv tool"
 authors = [{ name = "Chris Birch", email = "datapointchris@gmail.com" }]
 license = { text = "MIT" }
@@ -66,6 +66,9 @@ ignore_missing_imports = true
 check_untyped_defs = false
 warn_return_any = false
 
+# `standard` replaces the per-rule opt-outs repos used to accumulate; basedpyright
+# defaults to `recommended`, which turns every one of them back on. Named
+# `pyright` so both basedpyright and Pylance read it.
 
 [tool.pytest.ini_options]
 addopts = "-vv"
@@ -99,20 +102,16 @@ docstring-code-format = true
 
 [tool.ruff.lint]
 select = [
-    # pycodestyle
-    "E",
-    # Pyflakes
-    "F",
-    # pyupgrade
-    "UP",
-    # flake8-bugbear
-    "B",
-    # flake8-simplify
-    "SIM",
-    # isort
-    "I",
+    "E",    # pycodestyle errors
+    "F",    # pyflakes
+    "UP",   # pyupgrade
+    "B",    # flake8-bugbear
+    "SIM",  # flake8-simplify
+    "I",    # isort
+]
+ignore = [
+    "SIM108",  # ternary operator — often less readable
 ]
-ignore = ["SIM108"]
 
 [tool.ruff.lint.isort]
 force-single-line = true
@@ -120,7 +119,6 @@ force-single-line = true
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
 
-
 [tool.semantic_release]
 version_toml = ["pyproject.toml:project.version"]
 branch = "main"
@@ -135,6 +133,37 @@ build_command = """
 # ---------- Build System ---------- #
 
 
+[tool.pyright]
+typeCheckingMode = "standard"
+analyzeUnannotatedFunctions = true  # or pylance stops analyzing in vscode
+
+[tool.forge]
+# Keys the standard owns, written by `forge dies run maintenance/sync-pyproject.sh`.
+# Dropping one from the template removes it here on the next sync; a key absent
+# from this list belongs to the project and is never touched. Do not hand-edit.
+managed = [
+    ["ruff", "line-length"],
+    ["ruff", "format", "quote-style"],
+    ["ruff", "format", "indent-style"],
+    ["ruff", "format", "skip-magic-trailing-comma"],
+    ["ruff", "format", "line-ending"],
+    ["ruff", "format", "docstring-code-format"],
+    ["ruff", "lint", "select"],
+    ["ruff", "lint", "ignore"],
+    ["ruff", "lint", "isort", "force-single-line"],
+    ["ruff", "lint", "per-file-ignores", "__init__.py"],
+    ["mypy", "pretty"],
+    ["mypy", "ignore_missing_imports"],
+    ["mypy", "check_untyped_defs"],
+    ["mypy", "warn_return_any"],
+    ["pyright", "typeCheckingMode"],
+    ["pyright", "analyzeUnannotatedFunctions"],
+    ["codespell", "check-filenames"],
+    ["pytest", "ini_options", "addopts"],
+    ["pytest", "ini_options", "minversion"],
+    ["pytest", "ini_options", "testpaths"],
+]
+
 [build-system]
 requires = ["uv_build>=0.11.32,<0.12.0"]
 build-backend = "uv_build"

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/src/pyselfupdate/__init__.py

@@ -28,6 +28,7 @@ from pyselfupdate.errors import SourceError
 from pyselfupdate.github import GitHubSource
 from pyselfupdate.install import Installation
 from pyselfupdate.install import InstallKind
+from pyselfupdate.install import exit_now
 from pyselfupdate.install import read_installation
 from pyselfupdate.notifier import Outcome
 from pyselfupdate.notifier import Skip
@@ -40,6 +41,8 @@ from pyselfupdate.state import read as read_state
 from pyselfupdate.updater import Result
 from pyselfupdate.updater import changelog
 from pyselfupdate.updater import check
+from pyselfupdate.updater import install_release
+from pyselfupdate.updater import require_updatable
 from pyselfupdate.updater import update
 from pyselfupdate.updater import update_and_reexec
 
@@ -64,9 +67,12 @@ __all__ = [
     'changelog',
     'check',
     'enabled',
+    'exit_now',
+    'install_release',
     'notify',
     'read_installation',
     'read_state',
+    'require_updatable',
     'update',
     'update_and_reexec',
 ]

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/src/pyselfupdate/install.py

@@ -156,6 +156,25 @@ def run_install(requirement: str, *, quiet: bool = True) -> None:
         raise InstallFailedError(f'uv tool install failed: {message}')
 
 
+def exit_now(code: int = 0) -> None:
+    """End this process immediately, after flushing what it has written.
+
+    The sibling of `reexec` for when there is nothing left to run. Both exist
+    for the same reason: the environment has been rewritten, so no further
+    import can be trusted. `sys.exit` raises SystemExit, which unwinds through
+    whatever CLI framework called us and then through interpreter shutdown --
+    and both are free to import a module they had not needed yet, from a
+    directory that is no longer the one this process started in. `os._exit`
+    skips both, which is why the flushes are done here rather than left to the
+    shutdown that no longer happens.
+
+    Never returns.
+    """
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(code)
+
+
 def reexec() -> None:
     """Replace this process with the newly installed one.
 

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/src/pyselfupdate/notifier.py

@@ -3,7 +3,7 @@
 This layer never installs. `<tool> update` installs, and `<tool> update` is
 where errors are printed; a failure here is recorded in the state file and
 swallowed. That single rule is what keeps a dev checkout from printing an
-upgrade failure on every invocation.
+update failure on every invocation.
 """
 
 from __future__ import annotations
@@ -96,7 +96,7 @@ def notify(
 def enabled(config: Config, *, interactive: bool | None = None) -> tuple[bool, Skip | None]:
     """Whether a check would run, without touching the network or the clock.
 
-    Backs `<tool> update --why` and any fleet dashboard. The interval is
+    Backs a fleet dashboard and a `<tool> update --why`. The interval is
     deliberately not consulted: this answers "is this tool opted in", not "is it
     due".
     """

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/src/pyselfupdate/typercmd.py

@@ -21,15 +21,16 @@ rather than at the first call.
 
 from __future__ import annotations
 
-import sys
-
 import typer
 
 from pyselfupdate.config import Config
 from pyselfupdate.errors import SelfUpdateError
+from pyselfupdate.install import Installation
+from pyselfupdate.install import exit_now
 from pyselfupdate.updater import changelog
 from pyselfupdate.updater import check
-from pyselfupdate.updater import update
+from pyselfupdate.updater import install_release
+from pyselfupdate.updater import require_updatable
 
 
 def add_update_command(app: typer.Typer, config: Config, *, name: str = 'update') -> None:
@@ -50,37 +51,51 @@ def run_update(config: Config, *, check_only: bool = False, skip_changelog: bool
     the command under a group, does not have to reimplement the reporting. The
     output format is identical to goselfupdate's, because a fleet that reports
     the same thing three different ways is a fleet you have to read carefully.
+
+    The step order is the load-bearing part. Everything that reaches the network
+    or imports a module happens before the install; after it, this process only
+    prints what it already holds and exits without unwinding. Both halves of
+    that are lessons from a real failure: syncer 4.0.0 fetched its changelog
+    after replacing its own environment, and died on httpx's lazy import of
+    httpcore -- a module the release it had just installed no longer depended
+    on, and so had just deleted.
     """
     tool = config.tool
+    installation: Installation | None = None
     try:
-        result = check(config) if check_only else update(config)
+        if not check_only:
+            installation = require_updatable(config)
+        result = check(config)
     except SelfUpdateError as error:
-        typer.echo(f'✗ {tool} upgrade failed: {error}', err=True)
+        typer.echo(f'✗ {tool} update failed: {error}', err=True)
         raise typer.Exit(1) from error
 
     if not result.update_available:
         typer.echo(f'✓ {tool} already at latest: {result.latest}')
         return
 
-    if result.applied:
-        typer.echo(f'✓ {tool} upgraded: {result.current} → {result.latest}')
-    else:
-        typer.echo(f'✓ {tool} update available: {result.current} → {result.latest}')
+    subjects = [] if skip_changelog else changelog(config, result.current, result.latest)
 
-    if skip_changelog:
+    if installation is None:
+        typer.echo(f'✓ {tool} update available: {result.current} → {result.latest}')
+        _echo_changes(subjects)
         return
 
-    subjects = changelog(config, result.current, result.latest)
+    try:
+        install_release(config, result, installation)
+    except SelfUpdateError as error:
+        typer.echo(f'✗ {tool} update failed: {error}', err=True)
+        raise typer.Exit(1) from error
+
+    typer.echo(f'✓ {tool} updated: {result.current} → {result.latest}')
+    _echo_changes(subjects)
+    exit_now()
+
+
+def _echo_changes(subjects: list[str]) -> None:
     if not subjects:
         return
-
     typer.echo('')
     typer.echo('Changes:')
     for subject in subjects:
         typer.echo(f'  • {subject}')
-
-    # The environment this interpreter is running in has just been replaced.
-    # Nothing more may be imported, so the process ends here rather than
-    # returning into a CLI that might touch a lazily-loaded module.
-    if result.applied:
-        sys.stdout.flush()

{pyselfupdate-0.2.0 → pyselfupdate-0.2.2}/src/pyselfupdate/updater.py

@@ -55,18 +55,27 @@ def check(config: Config) -> Result:
     return Result(current=current, latest=latest, release=release)
 
 
-def update(config: Config, *, quiet: bool = True) -> Result:
-    """Install the latest release over the running one.
+def require_updatable(config: Config) -> Installation:
+    """The installation an update would rewrite, refusing one that must not be.
 
-    A no-op returning `applied=False` when already current. Note that on
-    success the running interpreter's environment has been rewritten underneath
-    it -- see `pyselfupdate.install.reexec`.
+    Public because it is the only part of an update that costs nothing and can
+    still refuse outright. A caller that orders the steps itself -- as
+    `typercmd.run_update` does, to fetch a changelog while the environment is
+    still intact -- keeps the refusal ahead of the network by starting here.
     """
-    resolved = config.resolved()
-    installation = read_installation(resolved.tool)
+    installation = read_installation(config.resolved().tool)
     _require_updatable(installation)
+    return installation
 
-    result = check(resolved)
+
+def install_release(config: Config, result: Result, installation: Installation, *, quiet: bool = True) -> Result:
+    """Install the release `result` names, over the running one.
+
+    A no-op returning the result unchanged when there is nothing newer. On
+    success this interpreter's environment has been rewritten underneath it, so
+    the caller may not import anything afterwards -- see
+    `pyselfupdate.install.reexec` and `pyselfupdate.install.exit_now`.
+    """
     if not result.update_available or result.release is None:
         return result
 
@@ -81,6 +90,20 @@ def update(config: Config, *, quiet: bool = True) -> Result:
     )
 
 
+def update(config: Config, *, quiet: bool = True) -> Result:
+    """Check for a newer release and install it, in one call.
+
+    A no-op returning `applied=False` when already current. The composition of
+    `require_updatable`, `check` and `install_release`, in the order that keeps
+    a refusal cheap; a caller needing to do work between the check and the
+    install calls those three itself.
+    """
+    resolved = config.resolved()
+    installation = require_updatable(resolved)
+    result = check(resolved)
+    return install_release(resolved, result, installation, quiet=quiet)
+
+
 def update_and_reexec(config: Config, *, quiet: bool = True) -> Result:
     """`update`, then replace this process when anything was installed.