dycw-pre-commit-hooks 0.14.26__py3-none-any.whl → 0.14.53__py3-none-any.whl

pre_commit_hooks/hooks/check_version_bumped.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import BUMPVERSION_TOML
+from pre_commit_hooks.utilities import (
+    get_version_from_path,
+    get_version_origin_master,
+    run_all_maybe_raise,
+)
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+def _main() -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(_run)
+
+
+def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
+    try:
+        current = get_version_from_path(path=path)
+        prev = get_version_origin_master(path=path)
+    except ValueError:
+        return False
+    return current != prev
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/check_versions_consistent.py

@@ -12,7 +12,7 @@ from pre_commit_hooks.constants import BUMPVERSION_TOML, paths_argument
 from pre_commit_hooks.utilities import (
     get_version_from_path,
     run_all_maybe_raise,
-    run_bump_my_version,
+    set_version,
 )
 
 if TYPE_CHECKING:
@@ -32,7 +32,7 @@ def _main(*, paths: tuple[Path, ...]) -> None:
 def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
     version = get_version_from_path(path=path)
     try:
-        run_bump_my_version(version, path=path)
+        set_version(version, path=path)
     except CalledProcessError:
         return False
     return True

pre_commit_hooks/hooks/format_pre_commit_config.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 
 from click import command
 from utilities.click import CONTEXT_SETTINGS
+from utilities.constants import sentinel
 from utilities.os import is_pytest
 from utilities.types import PathLike
 
@@ -39,18 +40,22 @@ def _run(*, path: PathLike = PRE_COMMIT_CONFIG_YAML) -> bool:
     path = Path(path)
     current = path.read_text()
     with yield_yaml_dict(path, sort_keys=False) as dict_:
-        repos_list = get_list_dicts(dict_, "repos")
-        repos_list.sort(key=_sort_key)
-        for repo_dict in repos_list:
-            _re_insert(repo_dict, PRE_COMMIT_CONFIG_REPO_KEYS)
-            hooks_list = get_list_dicts(repo_dict, "hooks")
-            hooks_list.sort(key=lambda x: x["id"])
-            if repo_dict["repo"] == "local":
+        repos = get_list_dicts(dict_, "repos")
+        repos.sort(key=_sort_key)
+        for repo in repos:
+            _re_insert(repo, PRE_COMMIT_CONFIG_REPO_KEYS)
+            hooks = get_list_dicts(repo, "hooks")
+            hooks.sort(key=lambda x: x["id"])
+            if repo["repo"] == "local":
                 keys = PRE_COMMIT_HOOKS_HOOK_KEYS
             else:
                 keys = PRE_COMMIT_CONFIG_HOOK_KEYS
-            for hook_dict in hooks_list:
-                _re_insert(hook_dict, keys)
+            for hook in hooks:
+                _re_insert(hook, keys)
+        repos.append({"repo": str(sentinel)})
+    with yield_yaml_dict(path, sort_keys=False) as dict_:
+        repos = get_list_dicts(dict_, "repos")
+        _ = repos.pop(-1)
     return path.read_text() == current
 
 

pre_commit_hooks/hooks/run_version_bump.py

@@ -1,21 +1,19 @@
 from __future__ import annotations
 
 from functools import partial
-from subprocess import CalledProcessError
 from typing import TYPE_CHECKING
 
 from click import command
 from utilities.click import CONTEXT_SETTINGS
 from utilities.os import is_pytest
-from utilities.version import Version3, Version3Error
+from utilities.version import Version3
 
 from pre_commit_hooks.constants import BUMPVERSION_TOML, paths_argument
 from pre_commit_hooks.utilities import (
-    get_version_from_git_show,
-    get_version_from_git_tag,
     get_version_from_path,
+    get_version_origin_master,
     run_all_maybe_raise,
-    run_bump_my_version,
+    set_version,
 )
 
 if TYPE_CHECKING:
@@ -34,18 +32,15 @@ def _main(*, paths: tuple[Path, ...]) -> None:
 
 def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
     try:
-        prev = get_version_from_git_tag()
-    except (CalledProcessError, ValueError):
-        try:
-            prev = get_version_from_git_show(path=path)
-        except (CalledProcessError, KeyError, Version3Error):
-            run_bump_my_version(Version3(0, 1, 0), path=path)
-            return False
-    current = get_version_from_path(path=path)
+        prev = get_version_origin_master(path=path)
+        current = get_version_from_path(path=path)
+    except ValueError:
+        set_version(Version3(0, 1, 0), path=path)
+        return False
     patched = prev.bump_patch()
     if current in {patched, prev.bump_minor(), prev.bump_major()}:
         return True
-    run_bump_my_version(patched)
+    set_version(patched, path=path)
     return False
 
 

pre_commit_hooks/hooks/setup_bump_my_version.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import command
+from tomlkit import table
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+from utilities.string import substitute
+from utilities.text import snake_case
+from utilities.version import Version3
+
+from pre_commit_hooks.constants import (
+    BUMPVERSION_TOML,
+    PYPROJECT_TOML,
+    paths_argument,
+    python_package_name_internal_option,
+)
+from pre_commit_hooks.utilities import (
+    ensure_contains,
+    get_set_aot,
+    get_set_table,
+    get_table,
+    run_all_maybe_raise,
+    yield_toml_doc,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, MutableSet
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@python_package_name_internal_option
+def _main(
+    *, paths: tuple[Path, ...], python_package_name_internal: str | None = None
+) -> None:
+    if is_pytest():
+        return
+    funcs: list[Callable[[], bool]] = [
+        partial(
+            _run,
+            path=p.parent / BUMPVERSION_TOML,
+            python_package_name_internal=python_package_name_internal,
+        )
+        for p in paths
+    ]
+    run_all_maybe_raise(*funcs)
+
+
+def _run(
+    *,
+    path: PathLike = BUMPVERSION_TOML,
+    python_package_name_internal: str | None = None,
+) -> bool:
+    path = Path(path)
+    modifications: set[Path] = set()
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        tool = get_set_table(doc, "tool")
+        bumpversion = get_set_table(tool, "bumpversion")
+        bumpversion["allow_dirty"] = True
+        bumpversion.setdefault("current_version", str(Version3(0, 1, 0)))
+    if python_package_name_internal is not None:
+        _add_file(
+            path.parent / PYPROJECT_TOML,
+            'version = "${version}"',
+            path_bumpversion_toml=path,
+            modifications=modifications,
+        )
+        _add_file(
+            path.parent
+            / "src"
+            / snake_case(python_package_name_internal)
+            / "__init__.py",
+            '__version__ = "${version}"',
+            path_bumpversion_toml=path,
+            modifications=modifications,
+        )
+    return len(modifications) == 0
+
+
+def _add_file(
+    path_data: PathLike,
+    template: PathLike,
+    /,
+    *,
+    path_bumpversion_toml: PathLike = BUMPVERSION_TOML,
+    modifications: MutableSet[Path] | None = None,
+) -> None:
+    with yield_toml_doc(path_bumpversion_toml, modifications=modifications) as doc:
+        tool = get_table(doc, "tool")
+        bumpversion = get_table(tool, "bumpversion")
+        files = get_set_aot(bumpversion, "files")
+        tab = table()
+        tab["filename"] = str(path_data)
+        tab["search"] = substitute(template, version="{current_version}")
+        tab["replace"] = substitute(template, version="{new_version}")
+        ensure_contains(files, tab)
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_ci_pull_request.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+from functools import partial
+from hashlib import blake2b
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.iterables import always_iterable
+from utilities.os import is_pytest
+from utilities.re import extract_groups
+from utilities.types import PathLike
+
+from pre_commit_hooks.constants import (
+    DEFAULT_PYTHON_VERSION,
+    GITEA_PULL_REQUEST_YAML,
+    GITHUB_PULL_REQUEST_YAML,
+    MAX_PYTHON_VERSION,
+    ci_pytest_os_option,
+    ci_pytest_python_version_option,
+    ci_pytest_runs_on_option,
+    gitea_option,
+    paths_argument,
+    python_uv_native_tls_option,
+    python_version_option,
+    repo_name_option,
+)
+from pre_commit_hooks.utilities import (
+    ensure_contains,
+    ensure_contains_partial_dict,
+    get_set_dict,
+    get_set_list_dicts,
+    get_set_list_strs,
+    run_all_maybe_raise,
+    yield_yaml_dict,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, MutableSet
+    from pathlib import Path
+
+    from utilities.types import MaybeSequenceStr, PathLike, StrDict
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@gitea_option
+@ci_pytest_os_option
+@ci_pytest_python_version_option
+@ci_pytest_runs_on_option
+@python_uv_native_tls_option
+@python_version_option
+@repo_name_option
+def _main(
+    *,
+    paths: tuple[Path, ...],
+    gitea: bool = False,
+    ci_pytest_os: MaybeSequenceStr | None = None,
+    ci_pytest_python_version: MaybeSequenceStr | None = None,
+    ci_pytest_runs_on: MaybeSequenceStr | None = None,
+    python_uv_native_tls: bool = False,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+    repo_name: str | None = None,
+) -> None:
+    if is_pytest():
+        return
+    funcs: list[Callable[[], bool]] = [
+        partial(
+            _run,
+            path=p.parent
+            / (GITEA_PULL_REQUEST_YAML if gitea else GITHUB_PULL_REQUEST_YAML),
+            pytest_os=ci_pytest_os,
+            pytest_python_version=ci_pytest_python_version,
+            pytest_runs_on=ci_pytest_runs_on,
+            python_version=python_version,
+            uv_native_tls=python_uv_native_tls,
+            repo_name=repo_name,
+        )
+        for p in paths
+    ]
+    run_all_maybe_raise(*funcs)
+
+
+def _run(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    pytest_os: MaybeSequenceStr | None = None,
+    pytest_python_version: MaybeSequenceStr | None = None,
+    pytest_runs_on: MaybeSequenceStr | None = None,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+    uv_native_tls: bool = False,
+    repo_name: str | None = None,
+) -> bool:
+    modifications: set[Path] = set()
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        dict_["name"] = "pull-request"
+        on = get_set_dict(dict_, "on")
+        pull_request = get_set_dict(on, "pull_request")
+        branches = get_set_list_strs(pull_request, "branches")
+        ensure_contains(branches, "master")
+        schedule = get_set_list_dicts(on, "schedule")
+        ensure_contains(schedule, {"cron": _get_cron_job(repo_name=repo_name)})
+    _add_pyright(
+        path=path,
+        modifications=modifications,
+        python_version=python_version,
+        uv_native_tls=uv_native_tls,
+    )
+    _add_pytest(
+        path=path,
+        modifications=modifications,
+        pytest_os=pytest_os,
+        pytest_runs_on=pytest_runs_on,
+        pytest_python_version=pytest_python_version,
+        python_version=python_version,
+        uv_native_tls=uv_native_tls,
+    )
+    _add_ruff(path=path, modifications=modifications, uv_native_tls=uv_native_tls)
+    return len(modifications) == 0
+
+
+def _get_cron_job(*, repo_name: str | None = None) -> str:
+    if repo_name is None:
+        minute = hour = 0
+    else:
+        digest = blake2b(repo_name.encode(), digest_size=8).digest()
+        value = int.from_bytes(digest, "big")
+        minute = value % 60
+        hour = (value // 60) % 24
+    return f"{minute} {hour} * * *"
+
+
+def _add_pyright(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    modifications: MutableSet[Path] | None = None,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+    uv_native_tls: bool = False,
+) -> None:
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        jobs = get_set_dict(dict_, "jobs")
+        pyright = get_set_dict(jobs, "pyright")
+        pyright["runs-on"] = "ubuntu-latest"
+        steps = get_set_list_dicts(pyright, "steps")
+        if uv_native_tls:
+            _add_update_certificates(steps)
+        step = ensure_contains_partial_dict(
+            steps, {"name": "Run 'pyright'", "uses": "dycw/action-pyright@latest"}
+        )
+        with_ = get_set_dict(step, "with")
+        with_["python-version"] = python_version
+        if uv_native_tls:
+            with_["native-tls"] = True
+
+
+def _add_pytest(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    modifications: MutableSet[Path] | None = None,
+    pytest_os: MaybeSequenceStr | None = None,
+    pytest_python_version: MaybeSequenceStr | None = None,
+    pytest_runs_on: MaybeSequenceStr | None = None,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+    uv_native_tls: bool = False,
+) -> None:
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        jobs = get_set_dict(dict_, "jobs")
+        pytest = get_set_dict(jobs, "pytest")
+        env = get_set_dict(pytest, "env")
+        env["CI"] = "1"
+        pytest["name"] = (
+            "pytest (${{matrix.os}}, ${{matrix.python-version}}, ${{matrix.resolution}})"
+        )
+        runs_on = get_set_list_strs(pytest, "runs-on")
+        ensure_contains(runs_on, "${{matrix.os}}")
+        if pytest_runs_on is not None:
+            ensure_contains(runs_on, *always_iterable(pytest_runs_on))
+        steps = get_set_list_dicts(pytest, "steps")
+        if uv_native_tls:
+            _add_update_certificates(steps)
+        step = ensure_contains_partial_dict(
+            steps, {"name": "Run 'pytest'", "uses": "dycw/action-pytest@latest"}
+        )
+        with_ = get_set_dict(step, "with")
+        with_["python-version"] = "${{matrix.python-version}}"
+        with_["resolution"] = "${{matrix.resolution}}"
+        if uv_native_tls:
+            with_["native-tls"] = True
+        strategy = get_set_dict(pytest, "strategy")
+        strategy["fail-fast"] = False
+        matrix = get_set_dict(strategy, "matrix")
+        os = get_set_list_strs(matrix, "os")
+        if pytest_os is None:
+            pytest_os_use = ["macos-latest", "ubuntu-latest"]
+        else:
+            pytest_os_use = list(always_iterable(pytest_os))
+        ensure_contains(os, *pytest_os_use)
+        python_version_dict = get_set_list_strs(matrix, "python-version")
+        if pytest_python_version is None:
+            pytest_python_version_use = list(
+                _yield_python_versions(version=python_version)
+            )
+        else:
+            pytest_python_version_use = list(always_iterable(pytest_python_version))
+        ensure_contains(python_version_dict, *pytest_python_version_use)
+        resolution = get_set_list_strs(matrix, "resolution")
+        ensure_contains(resolution, "highest", "lowest-direct")
+        pytest["timeout-minutes"] = 10
+
+
+def _add_ruff(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    modifications: MutableSet[Path] | None = None,
+    uv_native_tls: bool = False,
+) -> None:
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        jobs = get_set_dict(dict_, "jobs")
+        ruff = get_set_dict(jobs, "ruff")
+        ruff["runs-on"] = "ubuntu-latest"
+        steps = get_set_list_dicts(ruff, "steps")
+        if uv_native_tls:
+            _add_update_certificates(steps)
+        step = ensure_contains_partial_dict(
+            steps, {"name": "Run 'ruff'", "uses": "dycw/action-ruff@latest"}
+        )
+        with_ = get_set_dict(step, "with")
+        if uv_native_tls:
+            with_["native-tls"] = True
+
+
+def _add_update_certificates(steps: list[StrDict], /) -> None:
+    ensure_contains(
+        steps, {"name": "Update CA certificates", "run": "sudo update-ca-certificates"}
+    )
+
+
+def _yield_python_versions(
+    *, version: str = DEFAULT_PYTHON_VERSION, max_: str = MAX_PYTHON_VERSION
+) -> Iterator[str]:
+    major, minor = _extract_python_version_tuple(version)
+    max_major, max_minor = _extract_python_version_tuple(max_)
+    if major != max_major:
+        msg = f"Major versions must be equal; got {major} and {max_major}"
+        raise ValueError(msg)
+    if minor > max_minor:
+        msg = f"Minor version must be at most {max_minor}; got {minor}"
+        raise ValueError(msg)
+    for i in range(minor, max_minor + 1):
+        yield f"{major}.{i}"
+
+
+def _extract_python_version_tuple(version: str, /) -> tuple[int, int]:
+    major, minor = extract_groups(r"^(\d+)\.(\d+)$", version)
+    return int(major), int(minor)
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_ci_push.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+from utilities.types import PathLike
+
+from pre_commit_hooks.constants import (
+    GITEA_PUSH_YAML,
+    GITHUB_PULL_REQUEST_YAML,
+    GITHUB_PUSH_YAML,
+    gitea_option,
+    paths_argument,
+    python_uv_native_tls_option,
+)
+from pre_commit_hooks.utilities import (
+    add_update_certificates,
+    ensure_contains,
+    ensure_contains_partial_dict,
+    get_set_dict,
+    get_set_list_dicts,
+    get_set_list_strs,
+    run_all_maybe_raise,
+    yield_yaml_dict,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, MutableSet
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@gitea_option
+@python_uv_native_tls_option
+def _main(
+    *, paths: tuple[Path, ...], gitea: bool = False, python_uv_native_tls: bool = False
+) -> None:
+    if is_pytest():
+        return
+    funcs: list[Callable[[], bool]] = [
+        partial(
+            _run,
+            path=p.parent / (GITEA_PUSH_YAML if gitea else GITHUB_PUSH_YAML),
+            gitea=gitea,
+            uv_native_tls=python_uv_native_tls,
+        )
+        for p in paths
+    ]
+    run_all_maybe_raise(*funcs)
+
+
+def _run(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    gitea: bool = False,
+    uv_native_tls: bool = False,
+) -> bool:
+    modifications: set[Path] = set()
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        dict_["name"] = "push"
+        on = get_set_dict(dict_, "on")
+        push = get_set_dict(on, "push")
+        branches = get_set_list_strs(push, "branches")
+        ensure_contains(branches, "master")
+    _add_publish(
+        path=path, modifications=modifications, gitea=gitea, uv_native_tls=uv_native_tls
+    )
+    _add_tag(path=path, modifications=modifications, uv_native_tls=uv_native_tls)
+    return len(modifications) == 0
+
+
+def _add_publish(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    modifications: MutableSet[Path] | None = None,
+    gitea: bool = False,
+    uv_native_tls: bool = False,
+) -> None:
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        jobs = get_set_dict(dict_, "jobs")
+        publish = get_set_dict(jobs, "publish")
+        if not gitea:
+            environment = get_set_dict(publish, "environment")
+            environment["name"] = "pypi"
+            permissions = get_set_dict(publish, "permissions")
+            permissions["id-token"] = "write"
+        publish["runs-on"] = "ubuntu-latest"
+        steps = get_set_list_dicts(publish, "steps")
+        if uv_native_tls:
+            add_update_certificates(steps)
+        step = ensure_contains_partial_dict(
+            steps,
+            {
+                "name": "Build and publish the package",
+                "uses": "dycw/action-publish-package@latest",
+            },
+        )
+        with_ = get_set_dict(step, "with")
+        if uv_native_tls:
+            with_["native-tls"] = True
+
+
+def _add_tag(
+    *,
+    path: PathLike = GITHUB_PULL_REQUEST_YAML,
+    modifications: MutableSet[Path] | None = None,
+    uv_native_tls: bool = False,
+) -> None:
+    with yield_yaml_dict(path, modifications=modifications) as dict_:
+        jobs = get_set_dict(dict_, "jobs")
+        tag = get_set_dict(jobs, "tag")
+        tag["runs-on"] = "ubuntu-latest"
+        steps = get_set_list_dicts(tag, "steps")
+        if uv_native_tls:
+            add_update_certificates(steps)
+        step = ensure_contains_partial_dict(
+            steps,
+            {"name": "Tag the latest commit", "uses": "dycw/action-tag-commit@latest"},
+        )
+        with_ = get_set_dict(step, "with")
+        if uv_native_tls:
+            with_["native-tls"] = True
+
+
+if __name__ == "__main__":
+    _main()