fetchurl-sdk 0.2.1__tar.gz → 0.2.2__tar.gz

{fetchurl_sdk-0.2.1 → fetchurl_sdk-0.2.2}/.github/workflows/autorelease.yml

@@ -18,12 +18,10 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-      # Trusted publishing (PyPI) — enable if you configure OIDC on PyPI instead of UV_PUBLISH_TOKEN
       id-token: write
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
-          # svu needs full history + tags
           fetch-depth: 0
 
       - name: Setup git config
@@ -46,25 +44,14 @@ jobs:
         run: uv run --extra test python -m unittest test_fetchurl_integration.py
         continue-on-error: true
 
-      - name: Bump version (svu)
+      - name: Prepare release (svu, commit, local tag)
         if: github.event_name == 'workflow_dispatch'
         env:
           NEW_VERSION: ${{ github.event.inputs.new_version }}
         run: |
-          VERSION="$(NO_TAG=1 ./make_release "$NEW_VERSION")"
+          VERSION="$(./make_release prepare "$NEW_VERSION")"
           echo "RELEASE_VERSION=$VERSION" >> "$GITHUB_ENV"
-          echo "New version: $VERSION (from svu $NEW_VERSION)" >> "$GITHUB_STEP_SUMMARY"
-
-      - name: Create GitHub release
-        if: env.RELEASE_VERSION != ''
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAG: ${{ env.RELEASE_VERSION }}
-        run: |
-          git tag "$TAG"
-          git push origin "$TAG"
-          git push origin HEAD:main
-          gh release create "$TAG" --title "Release $TAG" --generate-notes
+          echo "Prepared $VERSION (not pushed until publish succeeds)" >> "$GITHUB_STEP_SUMMARY"
 
       - name: Build
         if: env.RELEASE_VERSION != ''
@@ -81,3 +68,9 @@ jobs:
           else
             uv publish --token "$UV_PUBLISH_TOKEN"
           fi
+
+      - name: Push commit, tag, and GitHub release
+        if: env.RELEASE_VERSION != ''
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ./make_release push "$RELEASE_VERSION"

fetchurl_sdk-0.2.2/.gitignore

@@ -0,0 +1 @@
+__pycache__/

{fetchurl_sdk-0.2.1 → fetchurl_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fetchurl-sdk
-Version: 0.2.1
+Version: 0.2.2
 Summary: Protocol-level client SDK for fetchurl content-addressable cache servers
 Project-URL: Homepage, https://pypi.org/project/fetchurl-sdk/
 Project-URL: Repository, https://github.com/fetchurl/sdk-python

fetchurl_sdk-0.2.2/make_release

@@ -0,0 +1,193 @@
+#!/usr/bin/env -S python3 -u
+"""Bump version (svu), commit + tag locally. Push only via `push` after publish succeeds."""
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+MANIFEST = ROOT / "pyproject.toml"
+MANIFEST_PATHS = [str(MANIFEST.relative_to(ROOT))]
+SVU_MODES = frozenset({"next", "major", "minor", "patch"})
+UPLOAD_GLOB: str | None = None
+VERSION_RE = re.compile(r'^version\s*=\s*"[^"]*"', re.M)
+
+
+def log(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+def run(cmd: list[str], *, check: bool = True, capture: bool = False) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, cwd=ROOT, check=check, text=True, capture_output=capture)
+
+
+def run_out(cmd: list[str]) -> str:
+    return run(cmd, capture=True).stdout.strip()
+
+
+def resolve_version(mode: str) -> str:
+    mode = mode.lstrip("v")
+    if mode in SVU_MODES:
+        return run_out(["svu", mode]).lstrip("v")
+    return mode
+
+
+def write_manifest(version: str) -> None:
+    text = MANIFEST.read_text(encoding="utf-8")
+    if not VERSION_RE.search(text):
+        raise SystemExit('version = "..." not found in pyproject.toml')
+    MANIFEST.write_text(VERSION_RE.sub(f'version = "{version}"', text, count=1), encoding="utf-8")
+
+
+def read_manifest_version() -> str:
+    m = re.search(r'^version\s*=\s*"([^"]+)"', MANIFEST.read_text(encoding="utf-8"), re.M)
+    if not m:
+        raise SystemExit("could not read version from pyproject.toml")
+    return m.group(1)
+
+def git_commit_and_tag(version: str, paths: list[str]) -> None:
+    # Never let git write to stdout — CI captures only the version line from prepare.
+    if paths:
+        run(["git", "add", *paths], capture=True)
+    else:
+        run(["git", "add", "-A"], capture=True)
+    staged = run(["git", "diff", "--cached", "--quiet"], check=False, capture=True)
+    if staged.returncode != 0:
+        cp = run(["git", "commit", "-sm", f"bump to {version}"], capture=True)
+        if cp.stdout:
+            log(cp.stdout.rstrip())
+        if cp.stderr:
+            log(cp.stderr.rstrip())
+    else:
+        log("nothing to commit (manifest unchanged?)")
+    exists = run(["git", "rev-parse", "-q", "--verify", f"refs/tags/{version}"], check=False, capture=True)
+    if exists.returncode == 0:
+        run(["git", "tag", "-f", version], capture=True)
+        log(f"moved local tag {version}")
+    else:
+        run(["git", "tag", version], capture=True)
+        log(f"created local tag {version}")
+
+
+def push_release(version: str, *, upload_glob: str | None = None) -> None:
+    """Push branch + tag and create GitHub release. Call only after registry publish succeeds."""
+    branch = run_out(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    for cmd in (
+        ["git", "push", "origin", f"HEAD:{branch}"],
+        ["git", "push", "origin", version],
+    ):
+        cp = run(cmd, capture=True)
+        if cp.stdout:
+            log(cp.stdout.rstrip())
+        if cp.stderr:
+            log(cp.stderr.rstrip())
+    chk = run(["gh", "release", "view", version], check=False, capture=True)
+    if chk.returncode == 0:
+        log(f"GitHub release {version} already exists")
+    else:
+        cp = run(
+            [
+                "gh",
+                "release",
+                "create",
+                version,
+                "--title",
+                f"Release {version}",
+                "--generate-notes",
+            ],
+            capture=True,
+        )
+        if cp.stdout:
+            log(cp.stdout.rstrip())
+        if cp.stderr:
+            log(cp.stderr.rstrip())
+    if upload_glob:
+        paths = sorted(ROOT.glob(upload_glob))
+        if paths:
+            cp = run(
+                ["gh", "release", "upload", version, *[str(p) for p in paths], "--clobber"],
+                capture=True,
+            )
+            if cp.stdout:
+                log(cp.stdout.rstrip())
+            if cp.stderr:
+                log(cp.stderr.rstrip())
+    log(f"pushed commit + tag + release {version}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="./make_release",
+        description=(
+            "Bump version with svu, commit and tag locally. "
+            "Push commit/tag/GitHub release only via the push subcommand "
+            "(run after a successful registry publish)."
+        ),
+    )
+    sub = p.add_subparsers(dest="command", required=True)
+
+    prep = sub.add_parser(
+        "prepare",
+        help="svu → write manifest → local commit + local tag (no remote push)",
+    )
+    prep.add_argument(
+        "mode",
+        nargs="?",
+        default="next",
+        help="svu mode (next|major|minor|patch) or explicit x.y.z (default: next)",
+    )
+
+    push_p = sub.add_parser(
+        "push",
+        help="push branch + tag and create GitHub release (after successful publish)",
+    )
+    push_p.add_argument(
+        "version",
+        nargs="?",
+        default=None,
+        help="semver to push (default: version from manifest)",
+    )
+
+    for mode in sorted(SVU_MODES):
+        sp = sub.add_parser(mode, help=f"shorthand for: prepare {mode}")
+        sp.set_defaults(command="prepare", mode=mode)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args_list = list(sys.argv[1:] if argv is None else argv)
+    # Bare semver → prepare <semver>
+    if (
+        args_list
+        and args_list[0] not in ("prepare", "push", "-h", "--help")
+        and args_list[0] not in SVU_MODES
+        and re.fullmatch(r"v?\d+\.\d+\.\d+", args_list[0])
+    ):
+        args_list = ["prepare", args_list[0].lstrip("v"), *args_list[1:]]
+
+    args = parser.parse_args(args_list)
+
+    if args.command == "prepare":
+        version = resolve_version(args.mode)
+        write_manifest(version)
+        git_commit_and_tag(version, MANIFEST_PATHS)
+        print(version)
+        return 0
+
+    if args.command == "push":
+        version = (args.version or read_manifest_version()).lstrip("v")
+        push_release(version, upload_glob=UPLOAD_GLOB)
+        print(version)
+        return 0
+
+    parser.error(f"unknown command {args.command!r}")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{fetchurl_sdk-0.2.1 → fetchurl_sdk-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fetchurl-sdk"
-version = "0.2.1"
+version = "0.2.2"
 description = "Protocol-level client SDK for fetchurl content-addressable cache servers"
 readme = "README.md"
 requires-python = ">=3.8"

fetchurl_sdk-0.2.1/make_release

@@ -1,28 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Usage: ./make_release [next|major|minor|patch|<x.y.z>]
-# Only the semver is printed on stdout; everything else goes to stderr.
-MODE="${1:-next}"
-
-case "$MODE" in
-  next|major|minor|patch)
-    VERSION="$(svu "$MODE")"
-    ;;
-  *)
-    VERSION="${MODE#v}"
-    ;;
-esac
-VERSION="${VERSION#v}"
-
-sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
-git add pyproject.toml
-
-git commit -sm "bump to $VERSION" 1>&2 || true
-if [[ ! -v NO_TAG ]]; then
-  git tag "$VERSION"
-  git push origin "$VERSION" 1>&2
-fi
-git push origin HEAD 1>&2
-
-printf '%s\n' "$VERSION"