bump-py-version 2.1.0__py3-none-any.whl

bump_py_version/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.0"

bump_py_version/cli.py

@@ -0,0 +1,245 @@
+import sys
+import argparse
+import shlex
+import shutil
+import tomlkit
+import subprocess
+from bump_py_version import __version__
+
+
+def parse_version_tag(tag):
+    """
+    Remove leading 'v' if it exists
+    """
+    if tag.startswith("v"):
+        return tag[1:]
+    return tag
+
+
+def alter_pyproject(doc, version):
+    """
+    Changes the project version and the poetry version
+    in the pyproject.toml file, preserving formatting.
+    """
+    version = parse_version_tag(version)
+
+    if "project" in doc:
+        doc["project"]["version"] = version
+
+    with open("pyproject.toml", "w", encoding="utf-8") as f:
+        f.write(tomlkit.dumps(doc))
+
+
+def alter_init(path, version):
+    """
+    Changes the version in the __init__.py file
+    """
+    version = parse_version_tag(version)
+    with open(path, "r") as f:
+        lines = f.readlines()
+    with open(path, "w") as f:
+        for line in lines:
+            if line.startswith("__version__ ="):
+                f.write(f'__version__ = "{version}"\n')
+            else:
+                f.write(line)
+
+
+def alter_text_file(file, str_search, replace):
+    """
+    Changes the version in a text file by replacing
+    the line after the line matching str_search.
+    """
+    dynamic_next_line = False
+    with open(file, "r") as f:
+        lines = f.readlines()
+    with open(file, "w") as f:
+        for line in lines:
+            if dynamic_next_line:
+                f.write(replace)
+                dynamic_next_line = False
+            elif line.startswith(str_search):
+                f.write(line)
+                dynamic_next_line = True
+            else:
+                f.write(line)
+
+
+def alter_version(version):
+    try:
+        with open("pyproject.toml", "r", encoding="utf-8") as f:
+            content = f.read()
+            doc = tomlkit.parse(content)
+    except FileNotFoundError:
+        doc = None
+
+    # Alter pyproject.toml
+    if doc:
+        alter_pyproject(doc, version)
+
+        # Alter __init__.py
+        try:
+            version_file = doc["tool"]["bump_version"]["version_file"]
+            alter_init(version_file, version)
+        except KeyError:
+            pass
+
+        # Alter text files
+        try:
+            replace_patterns = doc["tool"]["bump_version"]["replace_patterns"]
+            for _, pattern in replace_patterns.items():
+                pattern["replace"] = pattern["replace"].replace("{version}", version)
+                alter_text_file(
+                    pattern["file"],
+                    pattern["search"],
+                    pattern["replace"],
+                )
+        except KeyError:
+            pass
+
+
+def run_command_check_untracked():
+    """
+    Checks if there are untracked files.
+    """
+    status_message = """There are untracked files.
+Use `git status` to see the files.
+Please remove or commit the files before running the command."""
+
+    result = subprocess.run(
+        "git ls-files --others --exclude-standard",
+        check=True,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    if result.stdout.strip():
+        print(status_message)
+        sys.exit(1)
+
+
+def run_command_check_uncommited():
+    """
+    Checks if there are uncommited changes.
+    """
+    status_message = (
+        "There are uncommited changes. " "Use `git status` to see the changes.\n" "Please commit the changes before running the command."
+    )
+
+    try:
+        subprocess.run(
+            "git diff-index --quiet HEAD --",
+            check=True,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except Exception:
+        print(status_message)
+        sys.exit(1)
+
+
+def run_command(command):
+    try:
+        subprocess.run(command, check=True, shell=True)
+    except subprocess.CalledProcessError as e:
+        error_message = "Command execution failed: " + str(e)
+        print(error_message)
+        sys.exit(1)
+
+
+def check_uv_lock():
+    """Read the opt-in setting and check prerequisites before editing files."""
+    try:
+        with open("pyproject.toml", "r", encoding="utf-8") as f:
+            doc = tomlkit.parse(f.read())
+    except FileNotFoundError:
+        return False
+
+    enabled = doc.get("tool", {}).get("bump_version", {}).get("uv_lock", False)
+    if not isinstance(enabled, bool):
+        print("tool.bump_version.uv_lock must be true or false.")
+        sys.exit(1)
+    if not enabled:
+        return False
+
+    result = subprocess.run(["git", "check-ignore", "--quiet", "uv.lock"])
+    if result.returncode == 0:
+        print(
+            "uv.lock is ignored by Git. Remove uv.lock from .gitignore "
+            "(or the applicable Git ignore rules) before using uv_lock = true."
+        )
+        sys.exit(1)
+    if result.returncode != 1:
+        print("Could not check whether uv.lock is ignored by Git.")
+        sys.exit(1)
+    if shutil.which("uv") is None:
+        print("uv_lock = true requires uv to be installed and available on PATH.")
+        sys.exit(1)
+    return True
+
+
+def bump_version(version, message=None):
+    uv_lock = check_uv_lock()
+
+    # Check if there are files that are not tracked. If there are, exit
+    run_command_check_untracked()
+
+    # Check if there are uncommited changes
+    run_command_check_uncommited()
+
+    # Alter the version in the files
+    alter_version(version)
+
+    if uv_lock:
+        run_command("uv lock")
+
+    # Add the changes
+    run_command("git add .")
+
+    # Commit the changes
+    run_command(f'git commit -m "bump version to {version}"')
+
+    # Push the changes
+    run_command("git push")
+
+    # Create a tag
+    tag_message = message if message else f"bump version to {version}"
+    run_command(f"git tag -a {shlex.quote(version)} -m {shlex.quote(tag_message)}")
+
+    # Push the tag
+    run_command("git push --tags")
+
+
+def get_version():
+    """Reads version from pyproject.toml at runtime, only when needed."""
+    with open("pyproject.toml", "r", encoding="utf-8") as f:
+        content = f.read()
+        doc = tomlkit.parse(content)
+        return doc["project"]["version"]
+
+
+def cli():
+    parser = argparse.ArgumentParser(
+        prog="bump-py-version",
+        description=f"Bump the version of a git-enabled python package. Version ({__version__}).",
+        epilog="""Example:
+
+    bump-py-version v1.2.3
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("version", help="Version to bump to, e.g. v1.2.3 or 1.2.3")
+    parser.add_argument(
+        "--message",
+        help="Custom git tag message. Overrides the default tag message.",
+    )
+    args = parser.parse_args()
+    bump_version(args.version, message=args.message)
+
+
+if __name__ == "__main__":
+    cli()

bump_py_version-2.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: bump-py-version
+Version: 2.1.0
+Summary: Bump a python version in python files. Create a new tag and push it to git repository.
+Author-email: Dennis Iversen <dennis.iversen@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/diversen/bump-py-version
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomlkit==0.13.3
+Dynamic: license-file
+
+# bump-py-version
+
+This is a simple and opinionated python `tool` to bump the of a python package.
+
+1. The script will check for any changes in the current `git` repository and abort if there are any.
+
+2. If there are no changes, it will check for a `version` field in `pyproject.toml`. If the `project.version` exist it is altered to the specified version. Other options are specified below. 
+
+3. The script commits and pushes the changes. 
+4. Then a new tag is created using the new `version` specified to the script.
+5. Finally the script pushes the new tag to the remote repository.
+
+## Installation
+
+Install latest version:
+
+<!-- LATEST-VERSION-UV -->
+	uv tool install git+https://github.com/diversen/bump-py-version@v2.1.0
+
+## Configuration
+
+You may also bump the python version `__version__` in e.g.  `__init__.py` file (or similar) using a `pyproject.toml` setting like the following:
+
+```toml
+[tool.bump_version]
+version_file = "bump_py_version/__init__.py"
+```
+
+You may configure the script to alter text files (e.g. `README.md`) by setting the section `tool.bump_version.replace_patterns` in the `pyproject.toml` file. Example:
+
+```toml
+[tool.bump_version.replace_patterns.pipx]
+file = "README.md"
+search = "<!-- LATEST-VERSION-UV -->"
+replace = "\tuv tool install git+https://github.com/diversen/bump-py-version@{version}\n"
+
+```
+
+The above will cause the line below the `search` string to be replaced with the `replace` string. Then it is easy to show the latest version of the package in a `README.md` file.
+
+### Updating uv.lock
+
+To update `uv.lock` as part of each version bump, enable:
+
+```toml
+[tool.bump_version]
+uv_lock = true
+```
+
+This runs `uv lock` after updating the version files and before staging changes,
+so the lockfile is included in the release commit and tag. It does not request
+dependency upgrades. If the lockfile does not exist, `uv lock` creates it.
+
+`uv` must be installed and available on `PATH`. The command checks these
+prerequisites before modifying files and rejects an ignored `uv.lock`, explaining
+that it must be removed from `.gitignore` or the applicable Git ignore rules.
+An existing, untracked lockfile must be committed before bumping, just like any
+other non-ignored untracked file.
+
+If `uv lock` fails, the command stops before committing, pushing, or tagging;
+local edits remain available for inspection. The setting defaults to `false`,
+which preserves the existing behavior without running `uv`.
+
+## Usage example
+
+Example:
+
+```bash
+bump-py-version v1.2.3
+```
+
+# License
+
+MIT © [Dennis Iversen](https://github.com/diversen)

bump_py_version-2.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+bump_py_version/__init__.py,sha256=Xybt2skBZamGMNlLuOX1IG-h4uIxqUDGAO8MIGWrJac,22
+bump_py_version/cli.py,sha256=olHbFQQvZGRppY2jjVci7JxLyqKY-N4etipRdeVHD1Q,6774
+bump_py_version-2.1.0.dist-info/licenses/LICENSE,sha256=RhJa9n3MJadQpolKbuGOiundPNs_9pqw2rNV4GaONmw,1071
+bump_py_version-2.1.0.dist-info/METADATA,sha256=4VAgfAo7tSoLYMUngdY8QFr377UR_NAESGGDeKVrHGk,3327
+bump_py_version-2.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bump_py_version-2.1.0.dist-info/entry_points.txt,sha256=GDJqphGw3wBeNi7wmy3lA9CAuw9VvAMLERK36CVS_D0,60
+bump_py_version-2.1.0.dist-info/top_level.txt,sha256=T6wmloAit2RKV2sN--qTdH2dJPlv40t2Juea_1Q5GcU,16
+bump_py_version-2.1.0.dist-info/RECORD,,

bump_py_version-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bump_py_version-2.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bump-py-version = bump_py_version.cli:cli

bump_py_version-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dennis Iversen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bump_py_version-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bump_py_version