dycw-pre-commit-hooks 0.12.0__tar.gz → 0.12.2__tar.gz

{dycw_pre_commit_hooks-0.12.0 → dycw_pre_commit_hooks-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-pre-commit-hooks
-Version: 0.12.0
+Version: 0.12.2
 Author-email: Derek Wan <d.wan@icloud.com>
 Requires-Python: >=3.12
 Requires-Dist: click<8.3,>=8.2.1
@@ -8,8 +8,10 @@ Requires-Dist: dycw-utilities<0.167,>=0.166.5
 Requires-Dist: gitpython<3.2,>=3.1.45
 Requires-Dist: libcst<1.9,>=1.8.2
 Requires-Dist: loguru<0.8,>=0.7.3
+Requires-Dist: orjson<3.12,>=3.11.3
 Requires-Dist: packaging<25.1,>=25.0
 Requires-Dist: tomlkit<0.14,>=0.13.2
+Requires-Dist: xdg-base-dirs<6.1,>=6.0.2
 Description-Content-Type: text/markdown
 
 # pre-commit-hooks

{dycw_pre_commit_hooks-0.12.0 → dycw_pre_commit_hooks-0.12.2}/pyproject.toml

@@ -22,13 +22,15 @@ dependencies = [
   "gitpython >=3.1.45, <3.2",
   "libcst >=1.8.2, <1.9",
   "loguru >=0.7.3, <0.8",
+  "orjson >=3.11.3, <3.12",
   "packaging >=25.0, <25.1",
   "tomlkit >=0.13.2, <0.14",
+  "xdg-base-dirs >=6.0.2, <6.1",
 ]
 name = "dycw-pre-commit-hooks"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.12.0"
+version = "0.12.2"
 
 [project.scripts]
 format-requirements = "pre_commit_hooks.format_requirements:main"
@@ -39,7 +41,7 @@ tag-commits = "pre_commit_hooks.tag_commits:main"
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.12.0"
+current_version = "0.12.2"
 
 [[tool.bumpversion.files]]
 filename = "src/pre_commit_hooks/__init__.py"

{dycw_pre_commit_hooks-0.12.0 → dycw_pre_commit_hooks-0.12.2}/src/pre_commit_hooks/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.12.0"
+__version__ = "0.12.2"

{dycw_pre_commit_hooks-0.12.0 → dycw_pre_commit_hooks-0.12.2}/src/pre_commit_hooks/common.py

@@ -12,51 +12,41 @@ from utilities.version import Version, parse_version
 PYPROJECT_TOML = get_repo_root().joinpath("pyproject.toml")
 
 
-def get_version(
-    path_or_text: Path | str | bytes | TOMLDocument, /, *, desc: str = ""
-) -> Version:
-    """Parse the version from a block of text."""
-    match path_or_text:
+def get_version(source: Path | str | bytes | TOMLDocument, /) -> Version:
+    """Get the `[tool.bumpversion]` version from a TOML file."""
+    match source:
         case Path() as path:
-            return get_version(
-                path.read_text(), desc=f" from {str(path)!r}" if desc == "" else desc
-            )
+            return get_version(path.read_text())
         case str() | bytes() as text:
-            return get_version(parse(text), desc=desc)
+            return get_version(parse(text))
         case TOMLDocument() as doc:
             try:
                 tool = doc["tool"]
             except KeyError:
-                logger.exception(
-                    f"Failed to get version{desc}; key 'tool' does not exist"
-                )
+                logger.exception("Failed to get version; key 'tool' does not exist")
                 raise
             if not isinstance(tool, Table):
-                logger.exception(f"Failed to get version{desc}; `tool` is not a Table")
+                logger.exception("Failed to get version; `tool` is not a Table")
                 raise TypeError
             try:
                 bumpversion = tool["bumpversion"]
             except KeyError:
                 logger.exception(
-                    f"Failed to get version{desc}; key 'bumpversion' does not exist"
+                    "Failed to get version; key 'bumpversion' does not exist"
                 )
                 raise
             if not isinstance(bumpversion, Table):
-                logger.exception(
-                    f"Failed to get version{desc}; `bumpversion` is not a Table"
-                )
+                logger.exception("Failed to get version; `bumpversion` is not a Table")
                 raise TypeError
             try:
                 version = bumpversion["current_version"]
             except KeyError:
                 logger.exception(
-                    f"Failed to get version{desc}; key 'current_version' does not exist"
+                    "Failed to get version; key 'current_version' does not exist"
                 )
                 raise
             if not isinstance(version, str):
-                logger.exception(
-                    f"Failed to get version{desc}; `version` is not a string"
-                )
+                logger.exception("Failed to get version; `version` is not a string")
                 raise TypeError
             return parse_version(version)
         case never:  # pyright: ignore[reportUnnecessaryComparison]

{dycw_pre_commit_hooks-0.12.0 → dycw_pre_commit_hooks-0.12.2}/src/pre_commit_hooks/run_bump_my_version/__init__.py

@@ -2,21 +2,32 @@ from __future__ import annotations
 
 from pathlib import Path
 from subprocess import PIPE, STDOUT, CalledProcessError, check_call, check_output
+from typing import Literal, assert_never
 
-from click import command
+from click import Choice, command, option
 from loguru import logger
+from utilities.pathlib import get_repo_root
 
 from pre_commit_hooks.common import PYPROJECT_TOML, get_version
 
+type _Mode = Literal["pyproject", "bumpversion"]
+_MODE: _Mode = "pyproject"
+
 
 @command()
-def main() -> bool:
+@option(
+    "--mode",
+    type=Choice(["pyproject", "bumpversion"], case_sensitive=False),
+    default=_MODE,
+    show_default=True,
+)
+def main(*, mode: _Mode = _MODE) -> bool:
     """CLI for the `run_bump_my_version` hook."""
-    return _process()
+    return _process(mode=mode)
 
 
-def _process() -> bool:
-    path = PYPROJECT_TOML.relative_to(Path.cwd())
+def _process(*, mode: _Mode = _MODE) -> bool:
+    path = _get_rel_path(mode=mode)
     current = get_version(path)
     commit = check_output(["git", "rev-parse", "origin/master"], text=True).rstrip("\n")
     contents = check_output(["git", "show", f"{commit}:{path}"], text=True)
@@ -44,4 +55,15 @@ def _process() -> bool:
     return False
 
 
+def _get_rel_path(*, mode: _Mode = _MODE) -> Path:
+    match mode:
+        case "pyproject":
+            path = PYPROJECT_TOML
+        case "bumpversion":
+            path = get_repo_root().joinpath(".bumpversion.toml")
+        case never:  # pyright: ignore[reportUnnecessaryComparison]
+            assert_never(never)
+    return path.relative_to(Path.cwd())
+
+
 __all__ = ["main"]

dycw_pre_commit_hooks-0.12.2/src/pre_commit_hooks/tag_commits/__init__.py

@@ -0,0 +1,127 @@
+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.hashlib import md5_hash
+from utilities.pathlib import get_repo_root
+from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
+from utilities.whenever import from_timestamp, get_now_local
+from whenever import DateTimeDelta, ZonedDateTime
+from xdg_base_dirs import xdg_cache_home
+
+from pre_commit_hooks.common import get_version
+
+if TYPE_CHECKING:
+    from collections.abc import Set as AbstractSet
+
+_RUN_EVERY: DateTimeDelta | None = None
+_MAX_AGE: DateTimeDelta | None = None
+
+
+@command()
+@option(
+    "--run-every",
+    type=utilities.click.DateTimeDelta(),
+    default=_RUN_EVERY,
+    show_default=True,
+)
+@option(
+    "--max-age",
+    type=utilities.click.DateTimeDelta(),
+    default=_MAX_AGE,
+    show_default=True,
+)
+def main(
+    *,
+    run_every: DateTimeDelta | None = _RUN_EVERY,
+    max_age: DateTimeDelta | None = _MAX_AGE,
+) -> bool:
+    """CLI for the `tag_commits` hook."""
+    return _process(run_every=run_every, max_age=max_age)
+
+
+def _process(
+    *,
+    run_every: DateTimeDelta | None = _RUN_EVERY,
+    max_age: DateTimeDelta | None = _MAX_AGE,
+) -> bool:
+    if run_every is not None:
+        last = _get_last_run()
+        min_date_time = get_now_local() - run_every
+        if (last is not None) and (min_date_time <= last):
+            return True
+    return _process_commits(max_age=max_age)
+
+
+def _get_last_run() -> ZonedDateTime | None:
+    hash_ = md5_hash(get_repo_root())
+    path = xdg_cache_home().joinpath("tag-commits", hash_)
+    try:
+        text = path.read_text()
+    except FileNotFoundError:
+        return None
+    try:
+        return ZonedDateTime.parse_common_iso(text.strip("\n"))
+    except ValueError:
+        return None
+
+
+def _process_commits(*, max_age: DateTimeDelta | None = None) -> 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) 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,
+) -> 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)
+    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, /) -> None:
+    sha = commit.hexsha[:7]
+    date = _get_date_time(commit)
+    try:
+        joined = commit.tree.join("pyproject.toml")
+    except KeyError:
+        logger.exception(f"`pyproject.toml` 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"]

dycw_pre_commit_hooks-0.12.0/src/pre_commit_hooks/tag_commits/__init__.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from click import command
-from git import Commit, GitCommandError, Repo
-from loguru import logger
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import WEEK, from_timestamp, get_now_local
-
-from pre_commit_hooks.common import get_version
-
-if TYPE_CHECKING:
-    from collections.abc import Set as AbstractSet
-
-    from whenever import ZonedDateTime
-
-
-@command()
-def main() -> bool:
-    """CLI for the `tag_commits` hook."""
-    return _process()
-
-
-def _process() -> bool:
-    repo = Repo(".", search_parent_directories=True)
-    tagged = {tag.commit.hexsha for tag in repo.tags}
-    min_dt = get_now_local() - WEEK
-    commits = reversed(list(repo.iter_commits(repo.refs["origin/master"])))
-    results = [_process_commit(c, tagged, min_dt, repo) for c in commits]  # run all
-    return all(results)
-
-
-def _process_commit(
-    commit: Commit, tagged: AbstractSet[str], min_date: ZonedDateTime, repo: Repo, /
-) -> bool:
-    if (commit.hexsha in tagged) or (_get_date_time(commit) < min_date):
-        return True
-    try:
-        _tag_commit(commit, repo)
-    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, /) -> None:
-    sha = commit.hexsha[:7]
-    date = _get_date_time(commit)
-    try:
-        joined = commit.tree.join("pyproject.toml")
-    except KeyError:
-        logger.exception(f"`pyproject.toml` not found; failed to tag {sha!r} ({date})")
-        return
-    text = joined.data_stream.read()
-    version = get_version(text, desc=f"'pyproject.toml' @ {sha}")
-    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"]