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

dycw_pre_commit_hooks-0.12.8.dist-info/RECORD

@@ -1,19 +0,0 @@
-pre_commit_hooks/__init__.py,sha256=YLG1ztMLECr37VVZERdQ_nviI-TnuwzwSfl9cBayIv8,59
-pre_commit_hooks/common.py,sha256=Ovg0kK5CBSBEalGdVxLKjvRX3gbjpzTFRNRopB8tEiw,4247
-pre_commit_hooks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pre_commit_hooks/check_submodules/__init__.py,sha256=8aJ6sbDclOML5uahK4TNf80Sxf6gCx1kIOYwkv37g9s,1092
-pre_commit_hooks/check_submodules/__main__.py,sha256=foSVebwCfSkKcAc3cD5YTzkmrWd7Wso9_mR9-zuyG-o,153
-pre_commit_hooks/format_requirements/__init__.py,sha256=dORQ5sNZaOWYY6cw0X1YIic4OHZeTt9EhI21D1uQFyE,3322
-pre_commit_hooks/format_requirements/__main__.py,sha256=15JSp_rhjI_Ddoj4MRkHFShfnYxs6GggUhLRlGtrQ0E,156
-pre_commit_hooks/mirror_files/__init__.py,sha256=XUmUYHz4otEF5wIK8X0ntH0vkYFBmJwJfXkI8Bz3n0I,1682
-pre_commit_hooks/mirror_files/__main__.py,sha256=YzOSNKR2XrVST5dgIVJrpRL28QkcziciOomuKtVX7Jo,149
-pre_commit_hooks/replace_sequence_str/__init__.py,sha256=nDjiKV14th2uWbnte1rSvXckysl7ooaLgWo6IP4HI2s,1618
-pre_commit_hooks/replace_sequence_str/__main__.py,sha256=B1dxOxngV4vUVnDVrXSywiySOs1P_zF30_4ZMRsOSaY,157
-pre_commit_hooks/run_bump_my_version/__init__.py,sha256=OsMY0boz3VTqAtgLCHtC8AvCXx6OYvOXA5H-VAwBFoY,1444
-pre_commit_hooks/run_bump_my_version/__main__.py,sha256=w2V3y61jrSau-zxjl8ciHtWPlJQwXbYxNJ2tGYVyI4s,156
-pre_commit_hooks/tag_commits/__init__.py,sha256=097p0gfZcykpOPUgGYsrLePe8Nar04eKlCMn_mqPepg,2945
-pre_commit_hooks/tag_commits/__main__.py,sha256=qefgYw7LWbvmzZS45-ym6olS4cHqw1Emw2wlqZBXN_o,148
-dycw_pre_commit_hooks-0.12.8.dist-info/METADATA,sha256=SPMmd6uxKS3rmwv3zR0RGgv44Py_NYMGWom8R7kIlcI,1105
-dycw_pre_commit_hooks-0.12.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_pre_commit_hooks-0.12.8.dist-info/entry_points.txt,sha256=0xGzim6HTjeOXJpusYjBk0aEYkXQR2IwrmfzM6KT_r0,368
-dycw_pre_commit_hooks-0.12.8.dist-info/RECORD,,

dycw_pre_commit_hooks-0.12.8.dist-info/entry_points.txt

@@ -1,7 +0,0 @@
-[console_scripts]
-check-submodules = pre_commit_hooks.check_submodules:main
-format-requirements = pre_commit_hooks.format_requirements:main
-mirror-files = pre_commit_hooks.mirror_files:main
-replace-sequence-str = pre_commit_hooks.replace_sequence_str:main
-run-bump-my-version = pre_commit_hooks.run_bump_my_version:main
-tag-commits = pre_commit_hooks.tag_commits:main

pre_commit_hooks/check_submodules/__init__.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from click import command
-from git import Repo, Submodule
-
-from pre_commit_hooks.common import (
-    DEFAULT_MODE,
-    Mode,
-    get_toml_path,
-    get_version,
-    mode_option,
-    run_every_option,
-    throttled_run,
-)
-
-if TYPE_CHECKING:
-    from whenever import DateTimeDelta
-
-
-@command()
-@run_every_option
-def main(*, run_every: DateTimeDelta | None = None) -> bool:
-    """CLI for the `check-submodules` hook."""
-    return throttled_run("check-submodules", run_every, _process)
-
-
-def _process() -> bool:
-    repo = Repo(".", search_parent_directories=True)
-    results = [_process_submodule(s) for s in repo.submodules]  # run all
-    return all(results)
-
-
-def _process_submodule(submodule: Submodule, /) -> bool:
-    repo = submodule.module()
-    _ = repo.remotes.origin.fetch()
-    local = repo.commit("master")
-    remote = repo.commit("origin/master")
-    return local.hexsha == remote.hexsha
-
-
-__all__ = [
-    "DEFAULT_MODE",
-    "Mode",
-    "get_toml_path",
-    "get_version",
-    "main",
-    "mode_option",
-]

pre_commit_hooks/check_submodules/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.check_submodules import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))

pre_commit_hooks/common.py

@@ -1,131 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Literal, assert_never
-
-import utilities.click
-from click import Choice, option
-from loguru import logger
-from tomlkit import TOMLDocument, parse
-from tomlkit.items import Table
-from utilities.atomicwrites import writer
-from utilities.hashlib import md5_hash
-from utilities.pathlib import get_repo_root
-from utilities.typing import get_literal_elements
-from utilities.version import Version, parse_version
-from utilities.whenever import get_now_local, to_zoned_date_time
-from xdg_base_dirs import xdg_cache_home
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from whenever import DateTimeDelta
-
-type Mode = Literal["pyproject", "bumpversion"]
-DEFAULT_MODE: Mode = "pyproject"
-mode_option = option(
-    "--mode",
-    type=Choice(get_literal_elements(Mode), case_sensitive=False),
-    default=DEFAULT_MODE,
-    show_default=True,
-)
-run_every_option = option(
-    "--run-every", type=utilities.click.DateTimeDelta(), default=None, show_default=True
-)
-
-
-def get_version(source: Mode | Path | str | bytes | TOMLDocument, /) -> Version:
-    """Get the `[tool.bumpversion]` version from a TOML file."""
-    match source:
-        case "pyproject" | "bumpversion" as mode:
-            return get_version(get_toml_path(mode))
-        case Path() as path:
-            return get_version(path.read_text())
-        case str() | bytes() as text:
-            return get_version(parse(text))
-        case TOMLDocument() as doc:
-            try:
-                tool = doc["tool"]
-            except KeyError:
-                logger.exception("Failed to get version; key 'tool' does not exist")
-                raise
-            if not isinstance(tool, Table):
-                logger.exception("Failed to get version; `tool` is not a Table")
-                raise TypeError
-            try:
-                bumpversion = tool["bumpversion"]
-            except KeyError:
-                logger.exception(
-                    "Failed to get version; key 'bumpversion' does not exist"
-                )
-                raise
-            if not isinstance(bumpversion, Table):
-                logger.exception("Failed to get version; `bumpversion` is not a Table")
-                raise TypeError
-            try:
-                version = bumpversion["current_version"]
-            except KeyError:
-                logger.exception(
-                    "Failed to get version; key 'current_version' does not exist"
-                )
-                raise
-            if not isinstance(version, str):
-                logger.exception("Failed to get version; `version` is not a string")
-                raise TypeError
-            return parse_version(version)
-        case never:  # pyright: ignore[reportUnnecessaryComparison]
-            assert_never(never)
-
-
-def get_toml_path(mode: Mode = DEFAULT_MODE, /) -> Path:
-    """Get the path of the TOML file with the version."""
-    match mode:
-        case "pyproject":
-            return Path("pyproject.toml")
-        case "bumpversion":
-            return Path(".bumpversion.toml")
-        case never:  # pyright: ignore[reportUnnecessaryComparison]
-            assert_never(never)
-
-
-def throttled_run[**P](
-    name: str,
-    run_every: DateTimeDelta | None,
-    func: Callable[P, bool],
-    /,
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> bool:
-    """Throttled run."""
-    hash_ = md5_hash(get_repo_root())
-    path = xdg_cache_home().joinpath(name, hash_)
-    if run_every is not None:
-        min_date_time = get_now_local() - run_every
-        try:
-            text = path.read_text()
-        except FileNotFoundError:
-            pass
-        else:
-            try:
-                last_run = to_zoned_date_time(text.strip("\n"))
-            except ValueError:
-                pass
-            else:
-                if min_date_time <= last_run:
-                    return True
-    try:
-        return func(*args, **kwargs)
-    finally:
-        with writer(path, overwrite=True) as temp:
-            _ = temp.write_text(str(get_now_local()))
-
-
-__all__ = [
-    "DEFAULT_MODE",
-    "Mode",
-    "get_toml_path",
-    "get_version",
-    "mode_option",
-    "run_every_option",
-    "throttled_run",
-]

pre_commit_hooks/format_requirements/__init__.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, override
-
-import utilities.click
-from click import argument, command
-from packaging._tokenizer import ParserSyntaxError
-from packaging.requirements import (
-    InvalidRequirement,
-    Requirement,
-    _parse_requirement,  # pyright: ignore[reportPrivateImportUsage]
-)
-from packaging.specifiers import Specifier, SpecifierSet
-from tomlkit import array, dumps, loads, string
-from tomlkit.items import Array, Table
-from utilities.atomicwrites import writer
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from pathlib import Path
-
-    from tomlkit.toml_document import TOMLDocument
-
-
-@command()
-@argument("paths", nargs=-1, type=utilities.click.Path())
-def main(*, paths: tuple[Path, ...]) -> bool:
-    """CLI for the `format-requirements` hook."""
-    results = list(map(_process, paths))  # run all
-    return all(results)
-
-
-def _process(path: Path, /) -> bool:
-    doc = loads(path.read_text())
-    expected = _format_path(path)
-    if doc == expected:
-        return True
-    with writer(path, overwrite=True) as temp:
-        _ = temp.write_text(dumps(expected))
-    return False
-
-
-def _format_path(path: Path, /) -> TOMLDocument:
-    doc = loads(path.read_text())
-    if isinstance(dep_grps := doc.get("dependency-groups"), Table):
-        for key, value in dep_grps.items():
-            if isinstance(value, Array):
-                dep_grps[key] = _format_array(value)
-    if isinstance(project := doc["project"], Table):
-        if isinstance(deps := project["dependencies"], Array):
-            project["dependencies"] = _format_array(deps)
-        if isinstance(optional := project.get("optional-dependencies"), Table):
-            for key, value in optional.items():
-                if isinstance(value, Array):
-                    optional[key] = _format_array(value)
-    return doc
-
-
-def _format_array(dependencies: Array, /) -> Array:
-    new = array().multiline(multiline=True)
-    new.extend(map(_format_item, dependencies))
-    return new
-
-
-def _format_item(item: Any, /) -> Any:
-    if not isinstance(item, str):
-        return item
-    return string(str(_CustomRequirement(item)))
-
-
-class _CustomRequirement(Requirement):
-    @override
-    def __init__(self, requirement_string: str) -> None:
-        super().__init__(requirement_string)
-        try:
-            parsed = _parse_requirement(requirement_string)
-        except ParserSyntaxError as e:
-            raise InvalidRequirement(str(e)) from e
-        self.specifier = _CustomSpecifierSet(parsed.specifier)
-
-    @override
-    def _iter_parts(self, name: str) -> Iterator[str]:
-        yield name
-        if self.extras:
-            formatted_extras = ",".join(sorted(self.extras))
-            yield f"[{formatted_extras}]"
-        if self.specifier:
-            yield f" {self.specifier}"
-        if self.url:
-            yield f"@ {self.url}"
-            if self.marker:
-                yield " "
-        if self.marker:
-            yield f"; {self.marker}"
-
-
-class _CustomSpecifierSet(SpecifierSet):
-    @override
-    def __str__(self) -> str:
-        specs = sorted(self._specs, key=self._key)
-        return ", ".join(map(str, specs))
-
-    def _key(self, spec: Specifier, /) -> int:
-        return [">=", "<"].index(spec.operator)
-
-
-__all__ = ["main"]

pre_commit_hooks/format_requirements/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.format_requirements import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))

pre_commit_hooks/mirror_files/__init__.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Literal
-
-import utilities.click
-from click import argument, command
-from loguru import logger
-from more_itertools import chunked
-from utilities.atomicwrites import writer
-
-from pre_commit_hooks.common import run_every_option, throttled_run
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable
-    from pathlib import Path
-
-    from whenever import DateTimeDelta
-
-
-@command()
-@argument("paths", nargs=-1, type=utilities.click.Path())
-@run_every_option
-def main(*, paths: tuple[Path, ...], run_every: DateTimeDelta | None = None) -> bool:
-    """CLI for the `format-requirements` hook."""
-    return throttled_run("mirror-files", run_every, _process, paths)
-
-
-def _process(paths: Iterable[Path], /) -> bool:
-    paths = list(paths)
-    if len(paths) % 2 == 1:
-        logger.exception(f"Expected an even number of paths; got {len(paths)}")
-        raise RuntimeError
-    results = list(map(_process_pair, chunked(paths, 2, strict=True)))  # run all
-    return all(results)
-
-
-def _process_pair(paths: Iterable[Path], /) -> bool:
-    path_from, path_to = paths
-    try:
-        text_from = path_from.read_text()
-    except FileNotFoundError:
-        logger.exception(f"Source file {str(path_from)!r} not found")
-        raise
-    try:
-        text_to = path_to.read_text()
-    except FileNotFoundError:
-        return _write_text(text_from, path_to)
-    return True if text_from == text_to else _write_text(text_from, path_to)
-
-
-def _write_text(text: str, path: Path, /) -> Literal[False]:
-    with writer(path, overwrite=True) as temp:
-        _ = temp.write_text(text)
-    return False
-
-
-__all__ = ["main"]

pre_commit_hooks/mirror_files/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.mirror_files import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))

pre_commit_hooks/replace_sequence_str/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.replace_sequence_str import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))

pre_commit_hooks/run_bump_my_version/__init__.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from subprocess import PIPE, STDOUT, CalledProcessError, check_call, check_output
-
-from click import command
-from loguru import logger
-
-from pre_commit_hooks.common import (
-    DEFAULT_MODE,
-    Mode,
-    get_toml_path,
-    get_version,
-    mode_option,
-)
-
-
-@command()
-@mode_option
-def main(*, mode: Mode = DEFAULT_MODE) -> bool:
-    """CLI for the `run-bump-my-version` hook."""
-    return _process(mode=mode)
-
-
-def _process(*, mode: Mode = DEFAULT_MODE) -> bool:
-    current = get_version(mode)
-    commit = check_output(["git", "rev-parse", "origin/master"], text=True).rstrip("\n")
-    path = get_toml_path(mode)
-    contents = check_output(["git", "show", f"{commit}:{path}"], text=True)
-    master = get_version(contents)
-    if current in {master.bump_patch(), master.bump_minor(), master.bump_major()}:
-        return True
-    cmd = [
-        "bump-my-version",
-        "replace",
-        "--new-version",
-        str(master.bump_patch()),
-        str(path),
-    ]
-    try:
-        _ = check_call(cmd, stdout=PIPE, stderr=STDOUT)
-    except CalledProcessError as error:
-        if error.returncode != 1:
-            logger.exception("Failed to run {cmd!r}", cmd=" ".join(cmd))
-    except FileNotFoundError:
-        logger.exception(
-            "Failed to run {cmd!r}. Is `bump-my-version` installed?", cmd=" ".join(cmd)
-        )
-    else:
-        return True
-    return False
-
-
-__all__ = ["main"]

pre_commit_hooks/run_bump_my_version/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.run_bump_my_version import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))

pre_commit_hooks/tag_commits/__init__.py

@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import utilities.click
-from click import command, option
-from git import Commit, GitCommandError, Repo
-from loguru import logger
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import from_timestamp, get_now_local
-
-from pre_commit_hooks.common import (
-    DEFAULT_MODE,
-    Mode,
-    get_toml_path,
-    get_version,
-    mode_option,
-    run_every_option,
-    throttled_run,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Set as AbstractSet
-
-    from whenever import DateTimeDelta, ZonedDateTime
-
-
-@command()
-@run_every_option
-@option(
-    "--max-age", type=utilities.click.DateTimeDelta(), default=None, show_default=True
-)
-@mode_option
-def main(
-    *,
-    run_every: DateTimeDelta | None = None,
-    max_age: DateTimeDelta | None = None,
-    mode: Mode = DEFAULT_MODE,
-) -> bool:
-    """CLI for the `tag-commits` hook."""
-    return throttled_run("tag-commits", run_every, _process, max_age=max_age, mode=mode)
-
-
-def _process(
-    *, max_age: DateTimeDelta | None = None, mode: Mode = DEFAULT_MODE
-) -> bool:
-    repo = Repo(".", search_parent_directories=True)
-    tagged = {tag.commit.hexsha for tag in repo.tags}
-    min_date_time = None if max_age is None else (get_now_local() - max_age)
-    commits = reversed(list(repo.iter_commits(repo.refs["origin/master"])))
-    results = [
-        _process_commit(c, tagged, repo, min_date_time=min_date_time, mode=mode)
-        for c in commits
-    ]  # run all
-    return all(results)
-
-
-def _process_commit(
-    commit: Commit,
-    tagged: AbstractSet[str],
-    repo: Repo,
-    /,
-    *,
-    min_date_time: ZonedDateTime | None = None,
-    mode: Mode = DEFAULT_MODE,
-) -> bool:
-    if (commit.hexsha in tagged) or (
-        (min_date_time is not None) and (_get_date_time(commit) < min_date_time)
-    ):
-        return True
-    try:
-        _tag_commit(commit, repo, mode=mode)
-    except GitCommandError:
-        return False
-    return True
-
-
-def _get_date_time(commit: Commit, /) -> ZonedDateTime:
-    return from_timestamp(commit.committed_date, time_zone=LOCAL_TIME_ZONE_NAME)
-
-
-def _tag_commit(commit: Commit, repo: Repo, /, *, mode: Mode = DEFAULT_MODE) -> None:
-    sha = commit.hexsha[:7]
-    date = _get_date_time(commit)
-    path = get_toml_path(mode)
-    try:
-        joined = commit.tree.join(str(path))
-    except KeyError:
-        logger.exception(f"`{str(path)!r}` not found; failed to tag {sha!r} ({date})")
-        return
-    text = joined.data_stream.read()
-    version = get_version(text)
-    try:
-        tag = repo.create_tag(str(version), ref=sha)
-    except GitCommandError as error:
-        desc = error.stderr.strip("\n").strip()
-        logger.exception(f"Failed to tag {sha!r} ({date}) due to {desc}")
-        return
-    logger.info(f"Tagging {sha!r} ({date}) as {str(version)!r}...")
-    _ = repo.remotes.origin.push(f"refs/tags/{tag.name}")
-
-
-__all__ = ["main"]

pre_commit_hooks/tag_commits/__main__.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-from pre_commit_hooks.tag_commits import main
-
-if __name__ == "__main__":
-    raise SystemExit(int(not main()))