Use pyproject.toml as version source; CI bump/tag/publish

- Read __version__ from package metadata (importlib.metadata), fallback to "DEVELOPMENT"
- Validate config version against buildrunner __version__; drop version.py and VERSION_FILE_PATH
- CI: bump patch on push to main (skip for bot bump commits), tag and publish only when bump ran
- Add VERSIONING.md; tests patch buildrunner.__version__ instead of version file

Author: shanejbrown

.github/workflows/build.yaml

@@ -57,56 +57,79 @@ jobs:
         check_name: "Test Results ${{ matrix.python-version }}"
         github_retries: 10
         secondary_rate_limit_wait_seconds: 60.0
+  # Version source of truth: pyproject.toml [project] version.
+  # - Patch: CI bumps patch on every push to main (and commits it).
+  # - Minor/major: Update version in pyproject.toml (e.g. uv version 3.22.0 or uv version --bump minor),
+  #   merge with message "Release 3.22.0"; CI will use that version as-is and tag it.
   get-version:
     if: github.repository == 'adobe/buildrunner'
     runs-on: ubuntu-latest
     needs: test
+    permissions:
+      contents: write
     outputs:
       current-version: ${{ steps.version-number.outputs.CURRENT_VERSION }}
+      should-tag: ${{ steps.tag-decision.outputs.should_tag }}
     steps:
       - uses: actions/checkout@v2
         with:
-          # Fetch all history instead of the latest commit
           fetch-depth: 0
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           python-version: 3.9
       - name: Install dependencies
         run: uv sync --locked
+      - name: Bump version (patch only when not the bot’s bump commit)
+        id: bump
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, 'Bump version to')
+        run: uv version --bump patch
       - name: Get current version
         id: version-number
-        run: echo "CURRENT_VERSION=$(uv version --short).$(git rev-list --count HEAD)" >> $GITHUB_OUTPUT
+        run: echo "CURRENT_VERSION=$(uv version --short)" >> $GITHUB_OUTPUT
       - name: Print current version
         run: echo CURRENT_VERSION ${{ steps.version-number.outputs.CURRENT_VERSION }}
+      - name: Set tag/publish decision
+        id: tag-decision
+        run: |
+          if [ "${{ steps.bump.outcome }}" = "success" ]; then echo "should_tag=true" >> $GITHUB_OUTPUT; exit 0; fi
+          echo "should_tag=false" >> $GITHUB_OUTPUT
+      - name: Print tag decision
+        run: echo "should_tag=${{ steps.tag-decision.outputs.should_tag }}"
+      - name: Commit and push version bump
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, 'Bump version to')
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml uv.lock
+          git diff --staged --quiet || (git commit -m "Bump version to ${{ steps.version-number.outputs.CURRENT_VERSION }}" && git push)
   tag-commit:
-    if: github.repository == 'adobe/buildrunner' && github.event_name == 'push' && github.ref == 'refs/heads/main'
+    if: github.repository == 'adobe/buildrunner' && github.event_name == 'push' && github.ref == 'refs/heads/main' && needs.get-version.outputs.should-tag == 'true'
     runs-on: ubuntu-latest
     needs: [test, get-version]
     steps:
       - uses: actions/checkout@v2
         with:
-          # Fetch all history instead of the latest commit
           fetch-depth: 0
+          ref: main
       - name: Tag commit
         run: git tag ${{ needs.get-version.outputs.current-version }} && git push --tags
   publish-pypi:
-    if: github.repository == 'adobe/buildrunner'
+    if: github.repository == 'adobe/buildrunner' && (github.event_name == 'pull_request' || (github.event_name == 'push' && github.ref == 'refs/heads/main' && needs.get-version.outputs.should-tag == 'true'))
     runs-on: ubuntu-latest
-    needs: test
+    needs: [test, get-version]
     steps:
     - uses: actions/checkout@v2
       with:
-        # Fetch all history instead of the latest commit
-        fetch-depth: 0
+        ref: ${{ github.ref == 'refs/heads/main' && 'main' || github.sha }}
     - name: Install uv
       uses: astral-sh/setup-uv@v6
       with:
         python-version: 3.9
     - name: Install dependencies
       run: uv sync --locked
     - name: Set version
-      run: uv version --no-sync "$(uv version --short).$(git rev-list --count HEAD)"
+      run: uv version --no-sync "${{ needs.get-version.outputs.current-version }}"
     - name: Build
       run: uv build
     - name: Check upload
@@ -119,14 +142,13 @@ jobs:
         user: __token__
         password: ${{ secrets.ADOBE_BOT_PYPI_TOKEN }}
   publish-docker:
-    if: github.repository == 'adobe/buildrunner'
+    if: github.repository == 'adobe/buildrunner' && (github.event_name == 'pull_request' || (github.event_name == 'push' && github.ref == 'refs/heads/main' && needs.get-version.outputs.should-tag == 'true'))
     runs-on: ubuntu-latest
     needs: [test, get-version]
     steps:
     - uses: actions/checkout@v2
       with:
-        # Fetch all history instead of the latest commit
-        fetch-depth: 0
+        ref: ${{ github.ref == 'refs/heads/main' && 'main' || github.sha }}
     - name: Docker Tags
       id: docker_tags
       uses: docker/metadata-action@v3

VERSIONING.md

@@ -0,0 +1,22 @@
+# Versioning
+
+The **source of truth** for the version is `pyproject.toml` → `[project]` → `version`.  
+CI uses that value and the resulting git tag as the release version.
+
+## Where to update version
+
+- **Single place:** `pyproject.toml` — set `version = "X.Y.Z"` (e.g. `"3.21"` or `"3.21.0"`).
+
+## How versions are produced
+
+| You want | What to do |
+|----------|------------|
+| **Patch** (e.g. 3.21.0 → 3.21.1) | Nothing. Push to `main`; CI bumps patch, commits it, tags that version, and publishes. |
+| **Minor** (e.g. 3.21 → 3.22.0) | Update version in `pyproject.toml` (e.g. `uv version 3.22.0` or `uv version --bump minor`). Commit with message **`Release 3.22.0`** and merge to `main`. CI will use that version as-is (no bump), tag it, and publish. |
+| **Major** (e.g. 3.21 → 4.0.0) | Same as minor: set `version = "4.0.0"` in `pyproject.toml`, commit **`Release 4.0.0`**, merge to `main`. |
+
+## Summary
+
+- **Track/update** major.minor.patch in **`pyproject.toml`**.
+- **Patch releases:** automatic on every push to `main` (CI bumps and commits).
+- **Minor/major releases:** set the version in `pyproject.toml` and use a commit message starting with **`Release X.Y.Z`** so CI does not bump again and tags that version.

buildrunner/__init__.py

@@ -9,7 +9,7 @@
 
 from collections import OrderedDict
 import fnmatch
-import importlib.machinery
+import importlib.metadata
 import inspect
 import json
 import logging
@@ -19,7 +19,6 @@
 import tarfile
 import tempfile
 import traceback
-import types
 from typing import List, Optional
 
 import requests
@@ -45,18 +44,10 @@
 
 LOGGER = logging.getLogger(__name__)
 
-__version__ = "DEVELOPMENT"
 try:
-    _VERSION_FILE = os.path.join(os.path.dirname(__file__), "version.py")
-    if os.path.exists(_VERSION_FILE):
-        loader = importlib.machinery.SourceFileLoader(
-            "buildrunnerversion", _VERSION_FILE
-        )
-        _VERSION_MOD = types.ModuleType(loader.name)
-        loader.exec_module(_VERSION_MOD)
-        __version__ = getattr(_VERSION_MOD, "__version__", __version__)
-except Exception:  # pylint: disable=broad-except
-    pass
+    __version__ = importlib.metadata.version("buildrunner")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "DEVELOPMENT"
 
 SOURCE_DOCKERFILE = os.path.join(os.path.dirname(__file__), "SourceDockerfile")
 

buildrunner/config/loader.py

@@ -37,9 +37,6 @@
 
 
 MASTER_GLOBAL_CONFIG_FILE = "/etc/buildrunner/buildrunner.yaml"
-VERSION_FILE_PATH = (
-    f"{os.path.realpath(os.path.join(os.path.dirname(__file__), '..'))}/version.py"
-)
 RESULTS_DIR = "buildrunner.results"
 LOGGER = logging.getLogger(__name__)
 
@@ -124,41 +121,23 @@ def _validate_version(config: dict) -> None:
     buildrunner. If the config version is greater than the buildrunner version or any parsing error occurs
     it will raise a buildrunner exception.
     """
-    buildrunner_version = None
+    from buildrunner import __version__
+
+    parts = __version__.strip().split(".")
+    buildrunner_version = f"{parts[0]}.{parts[1]}" if len(parts) >= 2 else None
 
-    if not os.path.exists(VERSION_FILE_PATH):
+    if not buildrunner_version:
+        if __version__ != "DEVELOPMENT":
+            raise BuildRunnerVersionError("unable to determine buildrunner version")
         LOGGER.warning(
-            f"File {VERSION_FILE_PATH} does not exist. This could indicate an error with "
-            f"the buildrunner installation. Unable to validate version."
+            "Unable to determine buildrunner version for validation. Skipping config version check."
         )
         return
 
-    with open(VERSION_FILE_PATH, "r", encoding="utf-8") as version_file:
-        for line in version_file.readlines():
-            if "__version__" in line:
-                try:
-                    version_values = (
-                        line.split("=")[1]
-                        .strip()
-                        .replace("'", "")
-                        .replace('"', "")
-                        .split(".")
-                    )
-                    buildrunner_version = f"{version_values[0]}.{version_values[1]}"
-                except IndexError as exception:
-                    raise ConfigVersionFormatError(
-                        f'couldn\'t parse version from "{line}"'
-                    ) from exception
-
-    if not buildrunner_version:
-        raise BuildRunnerVersionError("unable to determine buildrunner version")
-
-    # version is optional and is valid to not have it in the config
-    if "version" not in config.keys():
+    if "version" not in config:
         return
 
     config_version = config["version"]
-
     try:
         if float(config_version) > float(buildrunner_version):
             raise ConfigVersionFormatError(
@@ -168,8 +147,7 @@ def _validate_version(config: dict) -> None:
     except ValueError as exception:
         raise ConfigVersionTypeError(
             f'unable to convert config version "{config_version}" '
-            f'or buildrunner version "{buildrunner_version}" '
-            f"to a float"
+            f'or buildrunner version "{buildrunner_version}" to a float'
         ) from exception
 
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "buildrunner"
-version = "3.21"
+version = "3.22"
 description = "Docker-based build tool"
 readme = "README.rst"
 requires-python = ">=3.9"

tests/test_version.py

@@ -1,4 +1,5 @@
 from collections import OrderedDict
+from unittest.mock import patch
 
 import pytest
 from buildrunner.config import loader
@@ -18,63 +19,43 @@ def fixture_config_file():
     yield config
 
 
-@pytest.fixture(name="version_file", autouse=True)
-def fixture_setup_version_file(tmp_path):
-    version_file = tmp_path / "version.py"
-    version_file.write_text(f"__version__ = '{buildrunner_version}'")
-    original_path = loader.VERSION_FILE_PATH
-    loader.VERSION_FILE_PATH = str(version_file)
-    yield str(version_file)
-    loader.VERSION_FILE_PATH = original_path
-
-
+@patch("buildrunner.__version__", buildrunner_version)
 def test_valid_version_file(config):
     loader._validate_version(config=config)
 
 
+@patch("buildrunner.__version__", "DEVELOPMENT")
 def test_missing_version_file(config):
-    # No exception for a missing version file it just prints a warning
-    loader.VERSION_FILE_PATH = "bogus"
+    # When version is DEVELOPMENT, validation is skipped (no exception)
     loader._validate_version(config=config)
 
 
-def test_missing_version_in_version_file(config, version_file):
-    with open(version_file, "w") as file:
-        file.truncate()
-
+@patch("buildrunner.__version__", "")
+def test_missing_version_in_version_file(config):
     with pytest.raises(BuildRunnerVersionError):
         loader._validate_version(config=config)
 
 
-def test_invalid_delim_version(config, version_file):
-    with open(version_file, "w") as file:
-        file.truncate()
-        file.write("__version__: '1.3.4'")
-
-    with pytest.raises(ConfigVersionFormatError):
-        loader._validate_version(config=config)
-
+@patch("buildrunner.__version__", "1.3.4")
+def test_valid_version_parsing(config):
+    # 1.3.4 parses to 1.3; config 2.0 > 1.3 so use config without version
+    loader._validate_version(config=OrderedDict({}))
 
-def test_invalid_config_number_version(config, version_file):
-    with open(version_file, "w") as file:
-        file.truncate()
-        file.write("__version__ = '1'")
 
-    with pytest.raises(ConfigVersionFormatError):
+@patch("buildrunner.__version__", "1")
+def test_invalid_single_component_version(config):
+    with pytest.raises(BuildRunnerVersionError):
         loader._validate_version(config=config)
 
 
-def test_invalid_config_version_type(config, version_file):
-    with open(version_file, "w") as file:
-        file.truncate()
-        file.write("__version__ = 'two.zero.five'")
-
+@patch("buildrunner.__version__", "2.0.701")
+def test_invalid_config_version_type(config):
     with pytest.raises(ConfigVersionTypeError):
-        loader._validate_version(config=config)
+        loader._validate_version(config={"version": "two.zero.five"})
 
 
 def test_bad_version(config):
-    config = OrderedDict({"version": 2.1})
-
-    with pytest.raises(ConfigVersionFormatError):
-        loader._validate_version(config=config)
+    bad_config = OrderedDict({"version": 2.1})
+    with patch("buildrunner.__version__", buildrunner_version):
+        with pytest.raises(ConfigVersionFormatError):
+            loader._validate_version(config=bad_config)