bumpversion-slim 0.1.0__py3-none-any.whl

bumpversion_slim/bump.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import logging
+import typing as t
+from dataclasses import dataclass
+from pathlib import Path
+
+from bumpversion_slim import errors
+
+if t.TYPE_CHECKING:
+    from bumpversion_slim.config import Config
+
+logger = logging.getLogger(__name__)
+
+T = t.TypeVar("T", bound="BumpVersion")
+
+
+@dataclass
+class ModifyFile:
+    """Configured file for modification."""
+
+    filename: str
+    path: Path
+    patterns: list[str]
+
+    def update(self, current: str, new: str, *, dry_run: bool) -> tuple[Path, Path]:
+        """Update file with configured patterns."""
+        try:
+            with self.path.open("r") as f:
+                contents = f.read()
+        except FileNotFoundError as e:
+            msg = f"Configured file not found '{self.filename}'."
+            raise errors.VersionError(msg) from e
+
+        for pattern in self.patterns:
+            try:
+                search, replace = pattern.format(version=current), pattern.format(version=new)
+            except KeyError as e:
+                msg = f"Incorrect pattern '{pattern}' for '{self.filename}'."
+                raise errors.VersionError(msg) from e
+
+            if search == replace:
+                msg = f"Pattern '{pattern}' generated no change for '{self.filename}'."
+                raise errors.VersionError(msg)
+
+            new_contents = contents.replace(search, replace)
+            if new_contents == contents:
+                msg = f"No change for '{self.filename}', ensure pattern '{pattern}' is correct."
+                raise errors.VersionError(msg)
+            contents = new_contents
+
+        backup = Path(f"{self.path}.bak")
+        if not dry_run:
+            with backup.open("w") as f:
+                f.write(contents)
+
+        return (self.path, backup)
+
+
+class BumpVersion:  # noqa: D101
+    def __init__(self, cfg: Config, new: str = "", *, allow_dirty: bool = False, dry_run: bool = False) -> None:
+        self.allow_dirty = allow_dirty
+        self.dry_run = dry_run
+        self.config = cfg
+        self.new = new
+
+    def replace(self, version: str) -> list[str]:  # noqa: D102
+        cwd = Path.cwd()
+        files_to_modify = {
+            "pyproject.toml": ModifyFile("pyproject.toml", cwd / "pyproject.toml", ['current_version = "{version}"']),
+        }
+        for file in self.config.files:
+            mf = files_to_modify.get(file["filename"], ModifyFile(file["filename"], cwd / file["filename"], []))
+            mf.patterns.append(file.get("pattern", "{version}"))
+            files_to_modify[file["filename"]] = mf
+
+        modified_files = []
+        for file in files_to_modify.values():
+            try:
+                modified_files.append(file.update(self.config.current_version, version, dry_run=self.dry_run))
+            except Exception:  # noqa: PERF203
+                if not self.dry_run:
+                    for _original, backup in modified_files:
+                        backup.unlink()
+                raise
+
+        if not self.dry_run:
+            for original, backup in modified_files:
+                original.write_text(backup.read_text())
+                backup.unlink()
+
+        return sorted({mf.filename for mf in files_to_modify.values()})

bumpversion_slim/cli.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import argparse
+import importlib
+import importlib.metadata
+import sys
+import time
+
+from bumpversion_slim import (
+    config,
+    errors,
+)
+from bumpversion_slim.bump import BumpVersion
+from bumpversion_slim.context import Context
+from bumpversion_slim.git import Git
+
+version = importlib.metadata.version("bumpversion_slim")
+parser = argparse.ArgumentParser(prog="bumpversion")
+parser.add_argument("--version", action="version", version=f"%(prog)s {version}")
+parser.add_argument("version_number", help="The desired version number to bump to.")
+parser.add_argument("--dry-run", action=argparse.BooleanOptionalAction, help="Don't commit changes, check for errors.")
+parser.add_argument(
+    "--allow-dirty",
+    action=argparse.BooleanOptionalAction,
+    help="Don't abort if branch contains uncommitted changes.",
+)
+parser.add_argument(
+    "--allow-missing",
+    action=argparse.BooleanOptionalAction,
+    help="Don't abort if missing commits on origin.",
+)
+parser.add_argument(
+    "--commit",
+    action=argparse.BooleanOptionalAction,
+    help="Commit changes made to package, and configured files, after writing.",
+)
+parser.add_argument("--tag", action=argparse.BooleanOptionalAction, help="Tag changes made after commit.")
+parser.add_argument("--verbose", "-v", action="count", default=0, help="Set output verbosity.")
+
+
+def process_info(info: dict, context: Context, cfg: config.Config, *, dry_run: bool) -> None:
+    """Process git info and raise on invalid state."""
+    if dry_run:
+        return
+
+    if info["dirty"] and not cfg.allow_dirty:
+        context.error("Working directory is not clean. Use `allow_dirty` configuration to ignore.")
+        sys.exit(1)
+
+    if info["missing_local"] and not cfg.allow_missing:
+        context.error(
+            "Current local branch is missing commits from remote %s.\nUse `allow_missing` configuration to ignore.",
+            info["branch"],
+        )
+        sys.exit(1)
+
+    if info["missing_remote"] and not cfg.allow_missing:
+        context.error(
+            "Current remote branch is missing commits from local %s.\nUse `allow_missing` configuration to ignore.",
+            info["branch"],
+        )
+        sys.exit(1)
+
+    allowed_branches = cfg.allowed_branches
+    if allowed_branches and info["branch"] not in allowed_branches:
+        context.error("Current branch not in allowed generation branches.")
+        sys.exit(1)
+
+
+def main() -> None:
+    """Bump package version."""
+    parsed = parser.parse_args()
+    start = time.time()
+    cfg = config.read(
+        allow_dirty=parsed.allow_dirty,
+        allow_missing=parsed.allow_missing,
+        commit=parsed.commit,
+        tag=parsed.tag,
+        verbose=parsed.verbose,
+    )
+    context = Context(cfg, parsed.verbose)
+
+    try:
+        _bump(
+            context,
+            cfg,
+            parsed.version_number,
+            dry_run=parsed.dry_run,
+        )
+    except errors.BumpException as ex:
+        context.stacktrace()
+        context.debug("Run time (error) %fms", (time.time() - start) * 1000)
+        context.error(str(ex))
+        sys.exit(1)
+    context.debug("Run time %fms", (time.time() - start) * 1000)
+    sys.exit(0)
+
+
+def _bump(
+    context: Context,
+    cfg: config.Config,
+    new_version: str,
+    *,
+    dry_run: bool = False,
+) -> None:
+    bv = BumpVersion(cfg, new_version, dry_run=dry_run, allow_dirty=cfg.allow_dirty)
+    git = Git(context=context, dry_run=dry_run, commit=cfg.commit, tag=cfg.tag)
+
+    process_info(git.get_current_info(), context, cfg, dry_run=dry_run)
+
+    version_tag = cfg.version_string.format(new_version=str(new_version))
+
+    def release_hook(_context: Context, new_version: str) -> list[str]:
+        return bv.replace(new_version)
+
+    hooks = [release_hook]
+    for hook in cfg.hooks:
+        try:
+            import_path, hook_func = hook.split(":")
+        except ValueError:
+            context.error("Invalid hook format, expected `path.to.module:hook_func`.")
+            sys.exit(1)
+
+        try:
+            mod = importlib.import_module(import_path)
+        except ModuleNotFoundError:
+            context.error("Invalid hook module `%s`, not found.", import_path)
+            sys.exit(1)
+
+        try:
+            hooks.append(getattr(mod, hook_func))
+        except AttributeError:
+            context.error("Invalid hook func `%s`, not found in hook module.", hook_func)
+            sys.exit(1)
+
+    paths = cfg.commit_extra
+    for hook in hooks:
+        hook_paths = hook(context, new_version)
+        paths.extend(hook_paths)
+
+    git.commit(cfg.current_version, new_version, version_tag, paths)

bumpversion_slim/config.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+from pathlib import Path
+
+import rtoml
+
+from bumpversion_slim import errors
+
+P = typing.ParamSpec("P")
+
+
+@dataclasses.dataclass
+class Config:
+    """Changelog configuration options."""
+
+    current_version: str
+    allowed_branches: list[str] = dataclasses.field(default_factory=list)
+
+    # CLI overrides
+    verbose: int = 0
+    commit: bool = True
+    tag: bool = True
+    allow_dirty: bool = False
+    allow_missing: bool = False
+    commit_extra: list[str] = dataclasses.field(default_factory=list)
+
+    # Version bumping
+    files: dict = dataclasses.field(default_factory=dict)
+    version_string: str = "v{new_version}"
+
+    # Hooks
+    hooks: list[str] = dataclasses.field(default_factory=list)
+    custom: dict = dataclasses.field(default_factory=dict)
+
+
+def _process_overrides(overrides: dict) -> dict:
+    """Process provided overrides.
+
+    Remove any unsupplied values (None).
+    """
+    return {k: v for k, v in overrides.items() if v is not None}
+
+
+def _process_pyproject(pyproject: Path) -> dict:
+    cfg = {}
+    with pyproject.open() as f:
+        data = rtoml.load(f)
+
+        if "tool" not in data or "bumpversion" not in data["tool"]:
+            return cfg
+
+        return data["tool"]["bumpversion"]
+
+
+def check_deprecations(cfg: dict) -> None:  # noqa: ARG001
+    """Check parsed configuration dict for deprecated features."""
+    # No current deprecations
+    return
+
+
+def read(path: str = "pyproject.toml", *args: P.args, **kwargs: P.kwargs) -> Config:  # noqa: ARG001
+    """Read configuration from local environment.
+
+    Supported configuration locations (checked in order):
+    * pyproject.toml
+    """
+    overrides = _process_overrides(kwargs)
+    cfg = {}
+
+    pyproject = Path(path)
+
+    if not pyproject.exists():
+        msg = "pyproject.toml configuration missing."
+        raise errors.BumpException(msg)
+
+    # parse pyproject
+    cfg = _process_pyproject(pyproject)
+
+    cfg.update(overrides)
+
+    check_deprecations(cfg)  # pragma: no mutate
+
+    try:
+        return Config(**cfg)
+    except TypeError as e:
+        msg = "Invalid configuration."
+        raise errors.BumpException(msg) from e

bumpversion_slim/context.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import io
+import sys
+import traceback
+import typing
+from enum import IntEnum
+
+if typing.TYPE_CHECKING:
+    from bumpversion_slim.config import Config
+
+
+class Verbosity(IntEnum):
+    """Verbosity levels."""
+
+    quiet = 0
+    verbose1 = 1
+    verbose2 = 2
+    verbose3 = 3
+
+
+P = typing.ParamSpec("P")
+
+
+class Context:
+    """Global context class."""
+
+    def __init__(self, config: Config, verbose: int = 0) -> None:
+        self.config = config
+        self._verbose = verbose
+        self._indent = 0
+
+    def reset(self) -> None:
+        """Reset context messaging indentation."""
+        self._indent = 0
+
+    def indent(self) -> None:
+        """Indent context messaging."""
+        self._indent += 1
+
+    def dedent(self) -> None:
+        """Dedent context messaging."""
+        self._indent = max(0, self._indent - 1)
+
+    def _echo(self, message: str, *args: P.args, **kwargs: P.kwargs) -> None:  # noqa: ARG002
+        """Echo to the console."""
+        message = message % args
+        print(f"{'  ' * self._indent}{message}")
+
+    def error(self, message: str, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Echo to the console."""
+        self._echo(message, *args, **kwargs)
+
+    def warning(self, message: str, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Echo to the console for -v."""
+        if self._verbose > Verbosity.quiet:
+            self._echo(message, *args, **kwargs)
+
+    def info(self, message: str, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Echo to the console for -vv."""
+        if self._verbose > Verbosity.verbose1:
+            self._echo(message, *args, **kwargs)
+
+    def debug(self, message: str, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Echo to the console for -vvv."""
+        if self._verbose > Verbosity.verbose2:
+            self._echo(message, *args, **kwargs)
+
+    def stacktrace(self) -> None:
+        """Echo exceptions to console for -vvv."""
+        if self._verbose > Verbosity.verbose2:
+            t, v, tb = sys.exc_info()
+            sio = io.StringIO()
+            traceback.print_exception(t, v, tb, None, sio)
+            s = sio.getvalue()
+            # Clean up odd python 3.11, 3.12 formatting on mac
+            s = s.replace("\n    ^^^^^^^^^^^^^^^^^^^^^^^^^^", "")
+            sio.close()
+            self._echo(s)

bumpversion_slim/errors.py

@@ -0,0 +1,10 @@
+class BumpException(Exception):  # noqa: N818
+    """Base exception class."""
+
+
+class GitError(BumpException):
+    """Version control error."""
+
+
+class VersionError(BumpException):
+    """Version change error."""

bumpversion_slim/git.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import typing as t
+
+import git
+
+from bumpversion_slim import errors
+
+if t.TYPE_CHECKING:
+    from bumpversion_slim.context import Context
+
+T = t.TypeVar("T", bound="Git")
+
+
+class Git:
+    """VCS implementation for git repositories."""
+
+    def __init__(
+        self,
+        context: Context,
+        *,
+        commit: bool = True,
+        tag: bool = True,
+        dry_run: bool = False,
+    ) -> None:
+        self.context = context
+        self._commit = commit
+        self._tag = tag
+        self.dry_run = dry_run
+        try:
+            self.repo = git.Repo()
+        except git.exc.InvalidGitRepositoryError as e:
+            msg = "No git repository found, please run git init."
+            raise errors.GitError(msg) from e
+
+    def get_current_info(self) -> dict[str, str | bool]:
+        """Get current state info from git."""
+        branch = self.repo.active_branch.name
+        try:
+            missing_local = list(self.repo.iter_commits(f"HEAD..origin/{branch}"))
+        except git.GitCommandError as e:
+            if f"bad revision 'HEAD..origin/{branch}'" in str(e):
+                missing_local = []
+            else:
+                msg = f"Unable to determine missing commit status: {e}"
+                raise errors.GitError(msg) from e
+
+        try:
+            missing_remote = list(self.repo.iter_commits(f"origin/{branch}..HEAD"))
+        except git.GitCommandError as e:
+            if f"bad revision 'origin/{branch}..HEAD'" in str(e):
+                missing_remote = ["missing"]
+            else:
+                msg = f"Unable to determine missing commit status: {e}"
+                raise errors.GitError(msg) from e
+
+        return {
+            "missing_local": missing_local != [],
+            "missing_remote": missing_remote != [],
+            "dirty": self.repo.is_dirty(),
+            "branch": branch,
+        }
+
+    def add_paths(self, paths: list[str]) -> None:
+        """Add path to git repository."""
+        if self.dry_run:
+            self.context.warning("  Would add paths '%s' to Git", "', '".join(paths))
+            return
+        self.repo.git.add(*paths)
+
+    def commit(self, current: str, new: str, tag: str, paths: list[str] | None = None) -> None:
+        """Commit changes to git repository."""
+        self.context.warning("Would prepare Git commit")
+        paths = paths or []
+
+        if paths:
+            self.add_paths(paths)
+
+        msg = [
+            f"Update CHANGELOG for {new}",
+            f"Bump version: {current} → {new}",
+        ]
+
+        message = "\n".join(msg).strip()
+        if self.dry_run or not self._commit:
+            self.context.warning("  Would commit to Git with message '%s", message)
+            return
+
+        try:
+            self.repo.git.commit(message=message)
+        except git.GitCommandError as e:
+            msg = f"Unable to commit: {e}"
+            raise errors.GitError(msg) from e
+
+        if not self._tag:
+            self.context.warning("  Would tag with version '%s", tag)
+            return
+
+        try:
+            self.repo.git.tag(tag)
+        except git.GitCommandError as e:
+            self.revert()
+            msg = f"Unable to tag: {e}"
+            raise errors.GitError(msg) from e
+
+    def revert(self) -> None:
+        """Revert a commit."""
+        if self.dry_run:
+            self.context.warning("Would revert commit in Git")
+            return
+        self.repo.git.reset("HEAD~1", hard=True)

bumpversion_slim-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: bumpversion-slim
+Version: 0.1.0
+Summary: A lightweight tool to bump package versions
+Author-email: Daniel Edgecombe <daniel@nrwl.co>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.10
+Requires-Dist: gitpython>=3.1.46
+Requires-Dist: rtoml>=0.13.0
+Provides-Extra: dev
+Requires-Dist: git-cliff>=2.12.0; extra == 'dev'
+Requires-Dist: prek>=0.3.4; extra == 'dev'
+Requires-Dist: ruff>=0.14.10; extra == 'dev'
+Requires-Dist: ty>=0.0.17; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: freezegun>=1.2.1; extra == 'test'
+Requires-Dist: path<17,>=16; extra == 'test'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'test'
+Requires-Dist: pytest-git<1.8,>=1.7.0; extra == 'test'
+Requires-Dist: pytest-httpx>=0.36.0; extra == 'test'
+Requires-Dist: pytest-random-order>=1.2.0; extra == 'test'
+Requires-Dist: pytest>=9.0.0; extra == 'test'

bumpversion_slim-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+bumpversion_slim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bumpversion_slim/bump.py,sha256=kHJMsWAvUf3MkqlHSM13fCrvBz4_ZcthSSZqR7hAV1I,3213
+bumpversion_slim/cli.py,sha256=tysVOK80yCtUaCUDagtAuApiKYIlB-HThtePLbQ0fxY,4636
+bumpversion_slim/config.py,sha256=OeZLnBKzkm8JNveSOJwKioGwbhjK1JlzvPjpwZtT1ow,2206
+bumpversion_slim/context.py,sha256=nXbsP4iTrXexh500NggIqIRizNAWVIg3nmFK2IKS1i0,2355
+bumpversion_slim/errors.py,sha256=e4oUs0DoqZOeV7Uq5DmjbVMgKfDnXVrJ10pASQLPJXY,213
+bumpversion_slim/git.py,sha256=l4g7B-2lSuzdNf6bvfK_q6Q3mdFHuStQATlM9plyfY8,3476
+bumpversion_slim/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bumpversion_slim-0.1.0.dist-info/METADATA,sha256=QieAreL1C2ljr9fDNZc0OC0m0oLS6zgrfId0P0ToZc0,1660
+bumpversion_slim-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+bumpversion_slim-0.1.0.dist-info/entry_points.txt,sha256=Slc323FHt9s9JUJQ_dRTbGYk_1Jg6hCYR3lhei7Ax5I,58
+bumpversion_slim-0.1.0.dist-info/RECORD,,

bumpversion_slim-0.1.0.dist-info/WHEEL

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

bumpversion_slim-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bumpversion = bumpversion_slim.cli:main