dycw-pre-commit-hooks 0.12.8__py3-none-any.whl → 0.14.39__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

@@ -0,0 +1,42 @@
+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 pre_commit_hooks.constants import BUMPVERSION_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    get_version_from_path,
+    run_all_maybe_raise,
+    set_version,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p) for p in paths))
+
+
+def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
+    version = get_version_from_path(path=path)
+    try:
+        set_version(version, path=path)
+    except CalledProcessError:
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/format_pre_commit_config.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from contextlib import suppress
+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 (
+    PRE_COMMIT_CONFIG_HOOK_KEYS,
+    PRE_COMMIT_CONFIG_REPO_KEYS,
+    PRE_COMMIT_CONFIG_YAML,
+    PRE_COMMIT_HOOKS_HOOK_KEYS,
+    paths_argument,
+)
+from pre_commit_hooks.utilities import (
+    get_list_dicts,
+    run_all_maybe_raise,
+    yield_yaml_dict,
+)
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike, StrDict, StrMapping
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p) for p in paths))
+
+
+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":
+                keys = PRE_COMMIT_HOOKS_HOOK_KEYS
+            else:
+                keys = PRE_COMMIT_CONFIG_HOOK_KEYS
+            for hook_dict in hooks_list:
+                _re_insert(hook_dict, keys)
+    return path.read_text() == current
+
+
+def _re_insert(dict_: StrDict, keys: list[str], /) -> None:
+    copy = dict_.copy()
+    dict_.clear()
+    for key in keys:
+        with suppress(KeyError):
+            dict_[key] = copy[key]
+
+
+def _sort_key(mapping: StrMapping, /) -> tuple[str, str]:
+    return mapping["repo"], mapping.get("rev", "")
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/format_requirements.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import command
+from tomlkit import string
+from tomlkit.items import Array
+from utilities.click import CONTEXT_SETTINGS
+from utilities.functions import ensure_str
+from utilities.os import is_pytest
+from utilities.packaging import Requirement
+from utilities.types import PathLike
+
+from pre_commit_hooks.constants import PYPROJECT_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    get_pyproject_dependencies,
+    run_all_maybe_raise,
+    yield_toml_doc,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from tomlkit.items import Array
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p) for p in paths))
+
+
+def _run(*, path: PathLike = PYPROJECT_TOML) -> bool:
+    modifications: set[Path] = set()
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        get_pyproject_dependencies(doc).map_array(_transform)
+    return len(modifications) == 0
+
+
+def _transform(array: Array, /) -> None:
+    new: list[str] = []
+    for curr_i in array:
+        req = Requirement(ensure_str(curr_i))
+        new.append(str(req))
+    array.clear()
+    for new_i in sorted(new):
+        array.append(string(new_i))
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/{replace_sequence_str/__init__.py → hooks/replace_sequence_str.py}

@@ -1,38 +1,43 @@
 from __future__ import annotations
 
+from functools import partial
 from typing import TYPE_CHECKING, override
 
-import utilities.click
-from click import argument, command
-from libcst import CSTTransformer, Name, Subscript, parse_module
+from click import command
+from libcst import CSTTransformer, Name, Subscript
 from libcst.matchers import Index as MIndex
 from libcst.matchers import Name as MName
 from libcst.matchers import Subscript as MSubscript
 from libcst.matchers import SubscriptElement as MSubscriptElement
 from libcst.matchers import matches
 from libcst.metadata import MetadataWrapper
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import paths_argument
+from pre_commit_hooks.utilities import run_all_maybe_raise, yield_python_file
 
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from utilities.types import PathLike
+
 
-@command()
-@argument("paths", nargs=-1, type=utilities.click.Path())
-def main(*, paths: tuple[Path, ...]) -> bool:
-    """CLI for the `replace-sequence-str` hook."""
-    results = list(map(_process, paths))  # run all
-    return all(results)
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, p) for p in paths))
 
 
-def _process(path: Path, /) -> bool:
-    existing = path.read_text()
-    wrapper = MetadataWrapper(parse_module(existing))
-    transformed = wrapper.module.visit(SequenceToListTransformer())
-    new = transformed.code
-    if existing == new:
-        return True
-    _ = path.write_text(new)
-    return False
+def _run(path: PathLike, /) -> bool:
+    modifications: set[Path] = set()
+    with yield_python_file(path, modifications=modifications) as context:
+        context.output = MetadataWrapper(context.input).module.visit(
+            SequenceToListTransformer()
+        )
+    return len(modifications) == 0
 
 
 class SequenceToListTransformer(CSTTransformer):
@@ -52,4 +57,5 @@ class SequenceToListTransformer(CSTTransformer):
         return updated_node
 
 
-__all__ = ["main"]
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/run_prek_autoupdate.py

@@ -0,0 +1,56 @@
+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.subprocess import run
+from utilities.throttle import throttle
+
+from pre_commit_hooks.constants import (
+    PRE_COMMIT_CONFIG_YAML,
+    THROTTLE_DURATION,
+    paths_argument,
+    throttle_option,
+)
+from pre_commit_hooks.utilities import path_throttle_cache, run_all_maybe_raise
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+    from pathlib import Path
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@throttle_option
+def _main(*, paths: tuple[Path, ...], throttle: bool = True) -> None:
+    if is_pytest():
+        return
+    if len(paths) >= 1:
+        run_all_maybe_raise(partial(_run, throttle=throttle))
+
+
+def _run(*, throttle: bool = False) -> bool:
+    modifications: set[Path] = set()
+    func = _run_throttled if throttle else _run_unthrottled
+    func(modifications=modifications)
+    return len(modifications) == 0
+
+
+def _run_unthrottled(*, modifications: MutableSet[Path] | None = None) -> None:
+    current = PRE_COMMIT_CONFIG_YAML.read_text()
+    run("prek", "autoupdate")
+    if (modifications is not None) and (PRE_COMMIT_CONFIG_YAML.read_text() != current):
+        modifications.add(PRE_COMMIT_CONFIG_YAML)
+
+
+_run_throttled = throttle(
+    duration=THROTTLE_DURATION, path=path_throttle_cache("run-prek-autoupdate")
+)(_run_unthrottled)
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/run_version_bump.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from functools import partial
+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
+
+from pre_commit_hooks.constants import BUMPVERSION_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    get_version_from_path,
+    get_version_origin_master,
+    run_all_maybe_raise,
+    set_version,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p) for p in paths))
+
+
+def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
+    try:
+        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
+    set_version(patched, path=path)
+    return False
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_bump_my_version.py

@@ -0,0 +1,99 @@
+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.version import Version3
+
+from pre_commit_hooks.constants import (
+    BUMPVERSION_TOML,
+    PYPROJECT_TOML,
+    paths_argument,
+    python_package_name_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 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:
+    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
+        )
+    )
+
+
+def _run(
+    *, path: PathLike = BUMPVERSION_TOML, python_package_name: 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 is not None:
+        _add_file(
+            'version = "${version}"',
+            path.parent / PYPROJECT_TOML,
+            path_bumpversion_toml=path,
+            modifications=modifications,
+        )
+        _add_file(
+            '__version__ = "${version}"',
+            path.parent / "src" / python_package_name / "__init__.py",
+            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_direnv.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from re import MULTILINE, escape, search
+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.text import strip_and_dedent
+from utilities.types import PathLike
+
+from pre_commit_hooks.constants import (
+    DEFAULT_PYTHON_VERSION,
+    ENVRC,
+    paths_argument,
+    python_option,
+    python_uv_index_option,
+    python_uv_native_tls_option,
+    python_version_option,
+)
+from pre_commit_hooks.utilities import run_all_maybe_raise, yield_text_file
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+    from pathlib import Path
+
+    from utilities.types import MaybeSequenceStr, PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@python_option
+@python_uv_index_option
+@python_uv_native_tls_option
+@python_version_option
+def _main(
+    *,
+    paths: tuple[Path, ...],
+    python: bool = False,
+    python_uv_index: MaybeSequenceStr | None = None,
+    python_uv_native_tls: bool = False,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+) -> 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
+        )
+    )
+
+
+def _run(
+    *,
+    path: PathLike = ENVRC,
+    python: bool = False,
+    python_uv_index: MaybeSequenceStr | None = None,
+    python_uv_native_tls: bool = False,
+    python_version: str = DEFAULT_PYTHON_VERSION,
+) -> bool:
+    modifications: set[Path] = set()
+    with yield_text_file(path, modifications=modifications) as context:
+        shebang = strip_and_dedent("""
+            #!/usr/bin/env sh
+            # shellcheck source=/dev/null
+        """)
+        if search(escape(shebang), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{shebang}"
+    if python:
+        _add_python(
+            path=path,
+            modifications=modifications,
+            uv_index=python_uv_index,
+            uv_native_tls=python_uv_native_tls,
+            version=python_version,
+        )
+    return len(modifications) == 0
+
+
+def _add_python(
+    *,
+    path: PathLike = ENVRC,
+    modifications: MutableSet[Path] | None = None,
+    uv_index: MaybeSequenceStr | None = None,
+    uv_native_tls: bool = False,
+    version: str = DEFAULT_PYTHON_VERSION,
+) -> None:
+    with yield_text_file(path, modifications=modifications) as context:
+        text = _get_text(
+            uv_index=uv_index, uv_native_tls=uv_native_tls, version=version
+        )
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
+
+
+def _get_text(
+    *,
+    uv_index: MaybeSequenceStr | None = None,
+    uv_native_tls: bool = False,
+    version: str = DEFAULT_PYTHON_VERSION,
+) -> str:
+    lines: list[str] = ["# uv", "export UV_MANAGED_PYTHON='true'"]
+    if uv_index is not None:
+        lines.append(f"export UV_INDEX='{','.join(always_iterable(uv_index))}'")
+    if uv_native_tls:
+        lines.append("export UV_NATIVE_TLS='true'")
+    lines.extend([
+        "export UV_PRERELEASE='disallow'",
+        f"export UV_PYTHON='{version}'",
+        "export UV_RESOLUTION='highest'",
+        "export UV_VENV_CLEAR=1",
+        strip_and_dedent("""\
+            if ! command -v uv >/dev/null 2>&1; then
+            \techo_date "ERROR: 'uv' not found" && exit 1
+            fi
+        """),
+        "activate='.venv/bin/activate'",
+        strip_and_dedent("""\
+            if [ -f $activate ]; then
+            \t. $activate
+            else
+            \tuv venv
+            fi
+        """),
+        "uv sync --all-extras --all-groups --active --locked",
+    ])
+    return "\n".join(lines) + "\n"
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_git.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from re import MULTILINE, escape, search
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.importlib import files
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import GITIGNORE, paths_argument
+from pre_commit_hooks.utilities import run_all_maybe_raise, yield_text_file
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p.parent / GITIGNORE) for p in paths))
+
+
+def _run(*, path: PathLike = GITIGNORE) -> bool:
+    modifications: set[Path] = set()
+    with yield_text_file(path, modifications=modifications) as context:
+        text = (files(anchor="pre_commit_hooks") / "configs/gitignore").read_text()
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
+    return len(modifications) == 0
+
+
+if __name__ == "__main__":
+    _main()