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

pre_commit_hooks/hooks/setup_bump_my_version.py

@@ -9,13 +9,14 @@ 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_option,
+    python_package_name_internal_option,
 )
 from pre_commit_hooks.utilities import (
     ensure_contains,
@@ -27,31 +28,34 @@ from pre_commit_hooks.utilities import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import MutableSet
+    from collections.abc import Callable, MutableSet
 
     from utilities.types import PathLike
 
 
 @command(**CONTEXT_SETTINGS)
 @paths_argument
-@python_package_name_option
-def _main(*, paths: tuple[Path, ...], python_package_name: str | None = None) -> None:
+@python_package_name_internal_option
+def _main(
+    *, paths: tuple[Path, ...], python_package_name_internal: str | None = None
+) -> None:
     if is_pytest():
         return
-    run_all_maybe_raise(
-        *(
-            partial(
-                _run,
-                path=p.parent / BUMPVERSION_TOML,
-                python_package_name=python_package_name,
-            )
-            for p in paths
+    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: str | None = None
+    *,
+    path: PathLike = BUMPVERSION_TOML,
+    python_package_name_internal: str | None = None,
 ) -> bool:
     path = Path(path)
     modifications: set[Path] = set()
@@ -60,16 +64,19 @@ def _run(
         bumpversion = get_set_table(tool, "bumpversion")
         bumpversion["allow_dirty"] = True
         bumpversion.setdefault("current_version", str(Version3(0, 1, 0)))
-    if python_package_name is not None:
+    if python_package_name_internal is not None:
         _add_file(
-            'version = "${version}"',
             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.parent / "src" / python_package_name / "__init__.py",
             path_bumpversion_toml=path,
             modifications=modifications,
         )

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()

pre_commit_hooks/hooks/setup_coverage.py

@@ -0,0 +1,58 @@
+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 COVERAGERC_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    ensure_contains,
+    get_set_array,
+    get_set_table,
+    run_all_maybe_raise,
+    yield_toml_doc,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    funcs: list[Callable[[], bool]] = [
+        partial(_run, path=p.parent / COVERAGERC_TOML) for p in paths
+    ]
+    run_all_maybe_raise(*funcs)
+
+
+def _run(*, path: PathLike = COVERAGERC_TOML) -> bool:
+    modifications: set[Path] = set()
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        html = get_set_table(doc, "html")
+        html["directory"] = ".coverage/html"
+        report = get_set_table(doc, "report")
+        exclude_also = get_set_array(report, "exclude_also")
+        ensure_contains(exclude_also, "@overload", "if TYPE_CHECKING:")
+        report["fail_under"] = 100.0
+        report["skip_covered"] = True
+        report["skip_empty"] = True
+        run = get_set_table(doc, "run")
+        run["branch"] = True
+        run["data_file"] = ".coverage/data"
+        run["parallel"] = True
+    return len(modifications) == 0
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_direnv.py

@@ -24,7 +24,7 @@ from pre_commit_hooks.constants import (
 from pre_commit_hooks.utilities import run_all_maybe_raise, yield_text_file
 
 if TYPE_CHECKING:
-    from collections.abc import MutableSet
+    from collections.abc import Callable, MutableSet
     from pathlib import Path
 
     from utilities.types import MaybeSequenceStr, PathLike
@@ -46,19 +46,18 @@ def _main(
 ) -> None:
     if is_pytest():
         return
-    run_all_maybe_raise(
-        *(
-            partial(
-                _run,
-                path=p.parent / ENVRC,
-                python=python,
-                python_uv_index=python_uv_index,
-                python_uv_native_tls=python_uv_native_tls,
-                python_version=python_version,
-            )
-            for p in paths
+    funcs: list[Callable[[], bool]] = [
+        partial(
+            _run,
+            path=p.parent / ENVRC,
+            python=python,
+            python_uv_index=python_uv_index,
+            python_uv_native_tls=python_uv_native_tls,
+            python_version=python_version,
         )
-    )
+        for p in paths
+    ]
+    run_all_maybe_raise(*funcs)
 
 
 def _run(
@@ -71,12 +70,15 @@ def _run(
 ) -> bool:
     modifications: set[Path] = set()
     with yield_text_file(path, modifications=modifications) as context:
-        shebang = strip_and_dedent("""
+        text = strip_and_dedent("""
             #!/usr/bin/env sh
             # shellcheck source=/dev/null
+
+            # echo
+            echo_date() { echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" >&2; }
         """)
-        if search(escape(shebang), context.output, flags=MULTILINE) is None:
-            context.output += f"\n\n{shebang}"
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
     if python:
         _add_python(
             path=path,