git-version-sync 1.4.0__py3-none-any.whl

git_version_sync/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

git_version_sync/cli.py

@@ -0,0 +1,36 @@
+from git_version_sync.models import BumpRequest
+from .parser import create_parser
+from .core import do_check, do_bump, do_sync
+
+def main():
+    parser = create_parser()
+    args = parser.parse_args()
+
+    try:
+        match args.command:
+            case 'bump':
+                bump_request = BumpRequest(
+                    args.part,
+                    tag_message=args.message,
+                    force=args.force,
+                    push=args.push,
+                    release=args.release,
+                    draft=args.draft,
+                )
+                print(do_bump(bump_request))
+
+            case 'sync':
+                print(do_sync(args.to_git, args.to_config))
+
+            case 'check':
+                print(do_check(args.fetch))
+
+            case _:
+                print(f"Invalid command {args.command}")
+
+        print("\n")
+    except Exception as e:
+        print(f"{e}")
+
+if __name__ == "__main__":
+    main()

git_version_sync/core/__init__.py

@@ -0,0 +1,3 @@
+from .check import do_check
+from .bump import do_bump
+from .sync import do_sync

git_version_sync/core/bump.py

@@ -0,0 +1,107 @@
+import subprocess, re
+from packaging.version import Version
+
+from .git import commit_config_change, push_to_remote, create_github_release
+from .check import parse_highest_verion, get_local_tags, get_config_tag
+from ..models import BumpRequest
+from ..utils import get_config_path
+
+def bump_git_tag(new_version: Version, message: str|None = None) -> None:
+    msg = message if message and message.strip() else f"bump version to v{new_version}"
+    command = [
+        'git',
+        'tag',
+        '-a', f'v{new_version}',
+        '-m', msg
+    ]
+
+    subprocess.run(
+        command,
+        capture_output=True,
+        text=True,
+        check=True
+    )
+
+def bump_config_version(new_version: Version) -> None:
+    config_path = get_config_path()
+    content = config_path.read_text(encoding="utf-8")
+
+    pattern = r'^(version\s*=\s*["\']).*?(["\'])'
+    replacement = rf'\g<1>{new_version}\g<2>'
+
+    new_content, count = re.subn(pattern, replacement, content, flags=re.MULTILINE)
+
+    if count == 0:
+        raise RuntimeError(f"Version field not found in {config_path.stem}")
+
+    config_path.write_text(new_content, encoding="utf-8")
+
+def bump_version(
+        request: BumpRequest,
+        new_version: Version,
+) -> None:
+    print("Updating pyproject.toml version...")
+    bump_config_version(new_version)
+
+    print("Committing new change...")
+    commit_config_change(new_version)
+
+    print(f"Creating git tag v{new_version}...")
+    bump_git_tag(new_version, request.tag_message)
+
+    if request.push:
+        print("Pushing commit and tag to remote...")
+        push_to_remote(new_version)
+
+    if request.release is not None:
+        print(f"Creating GitHub Release for v{new_version}...")
+        create_github_release(new_version, request.release, request.draft)
+
+def get_new_major(version: Version) -> str:
+    return f"{version.major + 1}.0.0"
+
+def get_new_minor(version: Version) -> str:
+    return f"{version.major}.{version.minor + 1}.0"
+
+def get_new_patch(version: Version):
+    return f"{version.major}.{version.minor}.{version.micro + 1}"
+
+def do_bump(request: BumpRequest):
+    config_tag = get_config_tag()
+    local_tags = get_local_tags()
+    highest_local_tag = parse_highest_verion(local_tags)
+
+    if config_tag != highest_local_tag and not request.force:
+        raise RuntimeError(
+            f"Version mismatch detected!\n"
+            f"  Config: v{config_tag}\n"
+            f"  Git   : v{highest_local_tag}\n"
+            f"Please run `git-version-sync sync` first or fix the mismatch."
+        )
+
+    if highest_local_tag:
+        old_version = max(config_tag, highest_local_tag)
+    else:
+        old_version = config_tag
+
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        raise RuntimeError(f"Config file not found: {config_path}")
+
+    match request.bump_type:
+        case "major":
+            new_version = get_new_major(old_version)
+        case "minor":
+            new_version = get_new_minor(old_version)
+        case "patch":
+            new_version = get_new_patch(old_version)
+
+    new_version = Version(new_version)
+
+    bump_version(
+        request,
+        new_version
+    )
+
+    return f"\nSuccess bump version to v{new_version}"

git_version_sync/core/check.py

@@ -0,0 +1,101 @@
+import subprocess, tomllib
+from packaging.version import Version
+from git_version_sync.utils import get_git_path, get_config_path
+
+
+def get_local_tags() -> set[str]:
+    command = ["git", "tag", "--list"]
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    tags = {tag for tag in result.stdout.strip().splitlines()}
+
+    return tags
+
+def parse_highest_verion(tags: set[str]) -> Version|None:
+    valid_version = []
+    for tag in tags:
+        try:
+            clean_tag = tag.removeprefix("v")
+            valid_version.append(Version(clean_tag))
+        except Exception:
+            continue
+
+    return max(valid_version) if valid_version else None
+
+def get_config_tag() -> Version:
+    config_path = get_config_path()
+
+    with config_path.open('rb') as f:
+        config = tomllib.load(f)
+        project_config = config.get('project', {})
+        config_tag = project_config.get("version", None)
+
+    if config_tag is None:
+        raise ValueError("No version found in project config.")
+
+    return Version(config_tag)
+
+def get_remote_tags() -> set[str]:
+    command = ['git', 'ls-remote', '--tags', 'origin']
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        text=True,
+        check=True
+    )
+
+    if result.returncode != 0:
+        return set()
+
+    remote_tags = set()
+    for line in result.stdout.strip().splitlines():
+        if not line:
+            continue
+
+        parts = line.split()
+        if len(parts) == 2:
+            ref = parts[1]
+            if ref.endswith("^{}"):
+                continue
+            tag_name = ref.removeprefix("refs/tags/")
+            remote_tags.add(tag_name)
+
+    return remote_tags
+
+def do_check(fetch_true: bool = False) -> str:
+    config_tag = get_config_tag()
+    local_tags = get_local_tags()
+    remote_tags = get_remote_tags()
+
+    output = []
+
+    highest_local_version = parse_highest_verion(local_tags)
+    if highest_local_version is None:
+        return "No local tags found."
+
+    if highest_local_version == config_tag:
+        output.append(f"Version is synchronized with highest local tag (v{config_tag})")
+    else:
+        output.append(
+            f"Version mismatch\n"
+            f"Git Local: {highest_local_version}\n"
+            f"Config:    {config_tag}"
+        )
+
+    if fetch_true:
+        missing_in_local = remote_tags - local_tags
+        if missing_in_local:
+            output.append(f"New tag(s) found from remote: ")
+            for tag in sorted(missing_in_local):
+                output.append(f"  - {tag}")
+            output.append("")
+
+    return "\n".join(output)
+
+if __name__ == "__main__":
+    print(do_check())

git_version_sync/core/git.py

@@ -0,0 +1,66 @@
+import subprocess, shutil
+
+from packaging.version import Version
+from git_version_sync.utils import get_config_path
+
+def commit_config_change(new_version: Version) -> None:
+    subprocess.run([
+        'git', 'add', str(get_config_path())],
+        capture_output=True,
+        text=True,
+        check=True
+    )
+
+    try:
+        commit_msg = f"chore({get_config_path().name}): bump version to v{new_version}"
+        subprocess.run(
+            ['git', 'commit', '-m', commit_msg],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        output = (e.stdout or "") + (e.stderr or "")
+        if "nothing to commit" in output:
+            return
+        raise RuntimeError(f"Git commit failed: \n{e.stderr.strip()}") from e
+
+def push_to_remote(new_version: Version) -> None:
+    try:
+        command = [
+            'git', 'push',
+            'origin', 'HEAD',
+            f'v{new_version}'
+        ]
+
+        subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to push to remote: \n{e.stderr.strip()}") from e
+
+def create_github_release(version: Version, message: str|None=None, draft: bool=False):
+    tag_name = f"v{version}"
+    command = ['gh', 'release', 'create', tag_name, '--generate-notes']
+
+    if not shutil.which('gh'):
+        raise RuntimeError("Github CLI ('gh') not installed yet, please install 'gh' first.")
+
+    if message and message.strip():
+        command.extend(['--notes', message])
+    if draft:
+        command.extend(['--draft'])
+
+    push_to_remote(version)
+    try:
+        subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to create release tag: \n{e.stderr.strip()}") from e

git_version_sync/core/sync.py

@@ -0,0 +1,34 @@
+from .bump import bump_config_version, bump_git_tag
+from .check import get_config_tag, get_local_tags, parse_highest_verion
+
+def do_sync(to_git: bool=False, to_config: bool=False) -> str:
+    config_tag = get_config_tag()
+    local_tags = get_local_tags()
+    highest_local_tag = parse_highest_verion(local_tags)
+
+    if config_tag == highest_local_tag:
+        return f"Already in sync at (v{config_tag})"
+
+    if to_git:
+        if highest_local_tag:
+            bump_config_version(highest_local_tag)
+            return f"Synced config version to match Git tag v{highest_local_tag}"
+        else:
+            raise RuntimeError("No git tag found on local.")
+
+    elif to_config and highest_local_tag:
+        bump_git_tag(config_tag, message=f"Sync git tag to v{config_tag}")
+        return f"Synced Git tag to match config version v{config_tag}"
+
+    else:
+        if highest_local_tag:
+            target_version = max(config_tag, highest_local_tag)
+        else:
+            target_version = config_tag
+
+        if highest_local_tag and highest_local_tag > config_tag:
+            bump_config_version(target_version)
+        else:
+            bump_git_tag(target_version)
+
+        return f"Synced workspace to highest version v{target_version}"

git_version_sync/models/__init__.py

@@ -0,0 +1 @@
+from .bump import BumpRequest

git_version_sync/models/bump.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Literal
+
+BumpType = Literal["major", "minor", "patch"]
+
+@dataclass(frozen=True)
+class BumpRequest:
+    bump_type   : BumpType
+    tag_message : str|None
+    force       : bool
+    push        : bool
+    release     : str|None
+    draft       : bool

git_version_sync/parser.py

@@ -0,0 +1,83 @@
+import argparse
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        prog="git-version-sync",
+        description="Sync Git tags and pyproject.toml versions.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Subcommand: check
+    check_parser = subparsers.add_parser(
+        "check",
+        help="Check and compare current version status between Git tags and pyproject.toml"
+    )
+    check_parser.add_argument(
+        "--fetch",
+        action="store_true",
+        help="Fetch remote tags before checking"
+    )
+
+    # Subcommand: sync
+    sync_parser = subparsers.add_parser(
+        "sync",
+        help="Sync version discrepancies between pyproject.toml and Git tags"
+    )
+    sync_group = sync_parser.add_mutually_exclusive_group()
+    sync_group.add_argument(
+        "--to-git",
+        action="store_true",
+        help="Force config version (pyproject.toml) to match the highest Git tag"
+    )
+    sync_group.add_argument(
+        "--to-config",
+        action="store_true",
+        help="Force Git tag to match the version in pyproject.toml"
+    )
+
+    # Subcommand: bump
+    bump_parser = subparsers.add_parser(
+        "bump",
+        help="Increment version in pyproject.toml and create a corresponding Git tag"
+    )
+    bump_parser.add_argument(
+        "part",
+        choices=["major", "minor", "patch"],
+        help="Version part to increment (major, minor, or patch)"
+    )
+    bump_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Force bump even if version mismatch occurs"
+    )
+    bump_parser.add_argument(
+        "-p",
+        "--push",
+        action="store_true",
+        help="Automatically push commit and the new tag to remote"
+    )
+    bump_parser.add_argument(
+        "-m",
+        "--message",
+        type=str,
+        help="Custom annotation message for the created Git tag"
+    )
+    bump_parser.add_argument(
+        "-r",
+        "--release",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="NOTES",
+        help="Create a GitHub release for the bumped version (requires 'gh' CLI)"
+    )
+    bump_parser.add_argument(
+        "-d",
+        "--draft",
+        action="store_true",
+        help="Save the GitHub release as a draft (requires --release)",
+    )
+
+    return parser

git_version_sync/utils/__init__.py

@@ -0,0 +1 @@
+from .config import get_git_path, get_config_path

git_version_sync/utils/config.py

@@ -0,0 +1,20 @@
+import subprocess
+from pathlib import Path
+
+def get_git_path() -> Path:
+    command = ["git", "rev-parse", "--show-toplevel"]
+    result = subprocess.run(
+        command,
+        capture_output=True,
+        text=True,
+        check=True
+    )
+
+    return Path(result.stdout.strip())
+
+def get_config_path() -> Path:
+    config_path = get_git_path() / "pyproject.toml"
+    if config_path.exists():
+        return config_path
+    else:
+        raise RuntimeError(f"Config file not found: {config_path}")

git_version_sync-1.4.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.3
+Name: git-version-sync
+Version: 1.4.0
+Summary: Tools to sync and update semantic versions
+Keywords: git,versioning,semver,pyproject,cli
+Author: Finsa-SC
+Author-email: Finsa-SC <finsakusumaputra@gmail.com>
+License: MIT
+Requires-Dist: packaging>=26.3
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/Finsa-SC/git-version-sync
+Project-URL: Repository, https://github.com/Finsa-SC/git-version-sync
+Project-URL: Issues, https://github.com/Finsa-SC/git-version-sync/issues
+Description-Content-Type: text/markdown
+
+# git-version-sync
+
+A command-line tool to synchronize semantic versions between Git tags and `pyproject.toml`.
+
+## Features
+
+- **Check** version status and consistency between Git tags and `pyproject.toml`
+- **Sync** version discrepancies with flexible sync directions
+- **Bump** versions following semantic versioning (major, minor, patch)
+- **Auto Push** option to push commits and tags directly to remote
+- **Custom annotations** for Git tags
+- **Force mode** for bypassing version mismatches
+
+## Installation
+
+### Requirements
+- Python >= 3.11
+- Git
+
+### Via PyPI (Recommended)
+
+```bash
+pip install git-version-sync
+```
+
+Or with pipx for isolated installation:
+
+```bash
+pipx install git-version-sync
+```
+
+### From Source
+
+```bash
+git clone <repository-url>
+cd git-version-sync
+pip install -e .
+```
+
+## Usage
+
+### Check Command
+
+Verify version consistency between Git tags and `pyproject.toml`:
+
+```bash
+git-version-sync check
+```
+
+**Options:**
+- `--fetch` - Fetch remote tags before checking
+
+### Sync Command
+
+Synchronize versions when discrepancies are detected:
+
+```bash
+git-version-sync sync
+```
+
+**Options (mutually exclusive):**
+- `--to-git` - Force `pyproject.toml` version to match the highest Git tag
+- `--to-config` - Force Git tag to match `pyproject.toml` version
+
+### Bump Command
+
+Increment the version in `pyproject.toml` and create a corresponding Git tag:
+
+```bash
+git-version-sync bump {major|minor|patch}
+```
+
+**Options:**
+- `-f, --force` - Force bump even if version mismatch occurs
+- `-p, --push` - Automatically push commit and tag to remote
+- `-m, --message MESSAGE` - Custom annotation message for the Git tag
+
+## Examples
+
+### Check current version status
+```bash
+$ git-version-sync check
+Version is synchronized with highest local tag (v1.0.0)
+```
+
+### Bump patch version
+```bash
+$ git-version-sync bump patch
+Success bump version to v1.0.1
+```
+
+### Bump minor version with custom message and auto-push
+```bash
+$ git-version-sync bump minor -m "Add new features" -p
+Success bump version to v1.1.0
+Pushing commit and tag to remote...
+```
+
+### Bump major version with force flag
+```bash
+$ git-version-sync bump major -f
+Success bump version to v2.0.0
+```
+
+### Sync to Git tags
+```bash
+$ git-version-sync sync --to-git
+Successfully synced version to match highest tag
+```
+
+## Dependencies
+
+- `packaging>=26.3` - For version parsing and comparison
+
+## License
+
+See LICENSE file for details.
+
+## Author
+
+Finsa-SC

git_version_sync-1.4.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+git_version_sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_version_sync/__main__.py,sha256=0g3iknXOS9gZUcpL_trgAcuCJnZZKjdsT_xt61WOVb4,60
+git_version_sync/cli.py,sha256=-PQ_HZ6XahKdIhFQQmnLksS7z3o-G3fmBpJe8y6QC4Y,944
+git_version_sync/core/__init__.py,sha256=5rc6piRQPZeqxBFN5V2lRdjdPGKREJtW1zh77msNuLc,79
+git_version_sync/core/bump.py,sha256=NbbLsV4PcWmgLIzYg-1YIPRrZyYyrbXTLmSTmmtpI2E,3214
+git_version_sync/core/check.py,sha256=8mNbE3g9fI3ZsOQUCW65s7sBa6SlCWCWJMM3ClN0CVM,2717
+git_version_sync/core/git.py,sha256=7CPRgXiAoCp-G6AKdiwh5ChDFqrhnZZY0NXoOUogstI,2012
+git_version_sync/core/sync.py,sha256=Yg_XA730DxI5PvaIpG4n05Zv9qOD9ZjbjVsSRhkQNQY,1250
+git_version_sync/models/__init__.py,sha256=aW3l0SjQ5DuGh9gkrU7KO-kqp3notaCJO4humOKeEYk,29
+git_version_sync/models/bump.py,sha256=ndCF9FL4baNc9h15GNTKoGAfSaBOqwqMllb_1-fCvcA,301
+git_version_sync/parser.py,sha256=XDLVfZJJsuYFly1ucrpOgCds-q0OlQrmOptcg5wHwU0,2349
+git_version_sync/utils/__init__.py,sha256=SlMounMaDolLS1rMQ4nIZlOaupbsu6GFql4IyU8DDqI,49
+git_version_sync/utils/config.py,sha256=LtkXM_SJUtuKm2iZ5tF2-6poez2VIso-39FHiiF6tlI,502
+git_version_sync-1.4.0.dist-info/WHEEL,sha256=7hzKWg-J8I3Buqyw5tBii5z_MmAVsDYXXijd_QAtNZ8,81
+git_version_sync-1.4.0.dist-info/entry_points.txt,sha256=wR2mKbwOuvSbzPstfLGoA6-Qbm2amNdhUsYfYZJCqT0,64
+git_version_sync-1.4.0.dist-info/METADATA,sha256=noL5_ZO-VDIsse_kykLym7y--xTJqPRcb8lSXiPtiIs,2985
+git_version_sync-1.4.0.dist-info/RECORD,,

git_version_sync-1.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.18
+Root-Is-Purelib: true
+Tag: py3-none-any

git_version_sync-1.4.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+git-version-sync = git_version_sync.cli:main
+