dycw-actions 0.2.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

actions/run_hooks/cli.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from rich.pretty import pretty_repr
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.run_hooks.lib import run_hooks
+from actions.run_hooks.settings import Settings
+from actions.utilities import LOADER
+
+
+@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="hooks")
+def run_hooks_sub_cmd(*, hooks: Settings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+        """),
+        run_hooks.__name__,
+        __version__,
+        pretty_repr(hooks),
+    )
+    run_hooks(repos=hooks.repos, hooks=hooks.hooks, sleep=hooks.sleep)
+
+
+__all__ = ["run_hooks_sub_cmd"]

actions/run_hooks/doc.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+DOCSTRING = "Run 'pre-commit' hooks"
+
+
+__all__ = ["DOCSTRING"]

actions/run_hooks/lib.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from re import search
+from subprocess import CalledProcessError
+from typing import TYPE_CHECKING, Any
+
+from utilities.functions import ensure_class, ensure_str
+from utilities.text import strip_and_dedent
+from whenever import TimeDelta
+from yaml import safe_load
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.run_hooks.settings import SETTINGS
+from actions.utilities import log_run
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def run_hooks(
+    *,
+    repos: list[str] | None = SETTINGS.repos,
+    hooks: list[str] | None = SETTINGS.hooks,
+    sleep: int = SETTINGS.sleep,
+) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - repos = %s
+             - hooks = %s
+             - sleep = %d
+        """),
+        run_hooks.__name__,
+        __version__,
+        repos,
+        hooks,
+        sleep,
+    )
+    results = {
+        hook: _run_hook(hook, sleep=sleep)
+        for hook in _yield_hooks(repos=repos, hooks=hooks)
+    }
+    failed = {hook: result for hook, result in results.items() if not result}
+    if len(failed) >= 1:
+        msg = f"Failed hook(s): {', '.join(failed)}"
+        raise RuntimeError(msg)
+
+
+def _yield_hooks(
+    *,
+    repos: list[str] | None = SETTINGS.repos,
+    hooks: list[str] | None = SETTINGS.hooks,
+) -> Iterator[str]:
+    dict_ = safe_load(Path(".pre-commit-config.yaml").read_text())
+    repos_list = ensure_class(dict_["repos"], list)
+    results: set[str] = set()
+    for repo in (ensure_class(r, dict) for r in repos_list):
+        url = repo["repo"]
+        if (repos is not None) and any(search(repo_i, url) for repo_i in repos):
+            results.update(_yield_repo_hooks(repo))
+        elif hooks is not None:
+            for hook in _yield_repo_hooks(repo):
+                if any(search(hook_i, hook) for hook_i in hooks):
+                    results.add(hook)
+    yield from sorted(results)
+
+
+def _yield_repo_hooks(repo: dict[str, Any], /) -> Iterator[str]:
+    hooks = ensure_class(repo["hooks"], list)
+    for hook in (ensure_class(r, dict) for r in hooks):
+        yield ensure_str(hook["id"])
+
+
+def _run_hook(hook: str, /, *, sleep: int = SETTINGS.sleep) -> bool:
+    LOGGER.info("Running '%s'...", hook)
+    try:
+        log_run("pre-commit", "run", "--verbose", "--all-files", hook, print=True)
+    except CalledProcessError:
+        is_success = False
+    else:
+        is_success = True
+    delta = TimeDelta(seconds=sleep)
+    LOGGER.info(
+        "Hook '%s' %s; sleeping for %s...",
+        hook,
+        "succeeded" if is_success else "failed",
+        delta,
+    )
+    time.sleep(sleep)
+    LOGGER.info("Finished sleeping for %s", delta)
+    return is_success
+
+
+__all__ = ["run_hooks"]

actions/run_hooks/settings.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typed_settings import load_settings, option, settings
+
+from actions.utilities import LOADER, convert_list_strs
+
+
+@settings
+class Settings:
+    repos: list[str] | None = option(
+        default=None,
+        converter=convert_list_strs,
+        help="The repos whose hooks are to be run",
+    )
+    hooks: list[str] | None = option(
+        default=None, converter=convert_list_strs, help="The hooks to be run"
+    )
+    sleep: int = option(default=1, help="Sleep in between runs")
+
+
+SETTINGS = load_settings(Settings, [LOADER])
+
+
+__all__ = ["SETTINGS", "Settings"]

actions/setup_cronjob/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

actions/setup_cronjob/cli.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from rich.pretty import pretty_repr
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.setup_cronjob.lib import setup_cronjob
+from actions.setup_cronjob.settings import Settings
+from actions.utilities import LOADER
+
+
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def setup_cronjob_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+        """),
+        setup_cronjob.__name__,
+        __version__,
+        pretty_repr(settings),
+    )
+    setup_cronjob(
+        name=settings.name,
+        prepend_path=settings.prepend_path,
+        schedule=settings.schedule,
+        user=settings.user,
+        timeout=settings.timeout,
+        kill_after=settings.kill_after,
+        command=settings.command,
+        args=settings.args,
+        logs_keep=settings.logs_keep,
+    )
+
+
+__all__ = ["setup_cronjob_sub_cmd"]

actions/setup_cronjob/configs/cron.tmpl

@@ -0,0 +1,3 @@
+PATH=${PREPEND_PATH}/usr/local/bin:/usr/bin:/bin
+
+${SCHEDULE} ${USER} (echo "[$$(date '+\%Y-\%m-\%d \%H:\%M:\%S') | $$$$] Starting '${NAME}'..."; flock --nonblock --verbose /tmp/cron-${NAME}.lock timeout --kill-after=${KILL_AFTER}s --verbose ${TIMEOUT}s ${COMMAND}${SPACE}${ARGS}; echo "[$$(date '+\%Y-\%m-\%d \%H:\%M:\%S') | $$$$] Finished '${NAME}' with exit code $$?") 2>&1 | sudo tee -a /var/log/${NAME}.log

actions/setup_cronjob/configs/logrotate.tmpl

@@ -0,0 +1,10 @@
+/var/log/${NAME}.log {
+  compress
+  daily
+  dateext
+  dateformat -%Y-%m-%d
+  delaycompress
+  missingok
+  notifempty
+  rotate ${ROTATE}
+}

actions/setup_cronjob/constants.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from actions.constants import PATH_ACTIONS
+
+PATH_CONFIGS = PATH_ACTIONS / "setup_cronjob/configs"
+
+
+__all__ = ["PATH_CONFIGS"]

actions/setup_cronjob/lib.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from string import Template
+from typing import TYPE_CHECKING
+
+from utilities.platform import SYSTEM
+from utilities.subprocess import chmod, chown, tee
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.setup_cronjob.constants import PATH_CONFIGS
+from actions.setup_cronjob.settings import SETTINGS
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from utilities.types import PathLike
+
+
+def setup_cronjob(
+    *,
+    name: str = SETTINGS.name,
+    prepend_path: Sequence[PathLike] | None = SETTINGS.prepend_path,
+    schedule: str = SETTINGS.schedule,
+    user: str = SETTINGS.user,
+    timeout: int = SETTINGS.timeout,
+    kill_after: int = SETTINGS.kill_after,
+    command: PathLike = SETTINGS.command,
+    args: list[str] | None = SETTINGS.args,
+    logs_keep: int = SETTINGS.logs_keep,
+) -> None:
+    """Set up a cronjob & logrotate."""
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - name         = %s
+             - prepend_path = %s
+             - schedule     = %s
+             - user         = %s
+             - timeout      = %d
+             - kill_after   = %d
+             - command      = %s
+             - args         = %s
+             - logs_keep    = %d
+        """),
+        setup_cronjob.__name__,
+        __version__,
+        name,
+        prepend_path,
+        schedule,
+        user,
+        timeout,
+        kill_after,
+        command,
+        args,
+        logs_keep,
+    )
+    if SYSTEM != "linux":
+        msg = f"System must be 'linux'; got {SYSTEM!r}"
+        raise TypeError(msg)
+    _tee_and_perms(
+        f"/etc/cron.d/{name}",
+        _get_crontab(
+            prepend_path=prepend_path,
+            schedule=schedule,
+            user=user,
+            name=name,
+            timeout=timeout,
+            kill_after=kill_after,
+            command=command,
+            args=args,
+        ),
+    )
+    _tee_and_perms(
+        f"/etc/logrotate.d/{name}", _get_logrotate(name=name, logs_keep=logs_keep)
+    )
+
+
+def _get_crontab(
+    *,
+    prepend_path: Sequence[PathLike] | None = SETTINGS.prepend_path,
+    schedule: str = SETTINGS.schedule,
+    user: str = SETTINGS.user,
+    name: str = SETTINGS.name,
+    timeout: int = SETTINGS.timeout,
+    kill_after: int = SETTINGS.kill_after,
+    command: PathLike | None = SETTINGS.command,
+    args: list[str] | None = SETTINGS.args,
+) -> str:
+    return Template((PATH_CONFIGS / "cron.tmpl").read_text()).substitute(
+        PREPEND_PATH=""
+        if prepend_path is None
+        else "".join(f"{p}:" for p in prepend_path),
+        SCHEDULE=schedule,
+        USER=user,
+        NAME=name,
+        TIMEOUT=timeout,
+        KILL_AFTER=kill_after,
+        COMMAND=command,
+        SPACE=" " if (args is not None) and (len(args) >= 1) else "",
+        ARGS="" if args is None else " ".join(args),
+    )
+
+
+def _get_logrotate(
+    *, name: str = SETTINGS.name, logs_keep: int = SETTINGS.logs_keep
+) -> str:
+    return Template((PATH_CONFIGS / "logrotate.tmpl").read_text()).substitute(
+        NAME=name, ROTATE=logs_keep
+    )
+
+
+def _tee_and_perms(path: PathLike, text: str, /) -> None:
+    tee(path, text, sudo=True)
+    chown(path, sudo=True, user="root", group="root")
+    chmod(path, "u=rw,g=r,o=r", sudo=True)
+
+
+__all__ = ["setup_cronjob"]

actions/setup_cronjob/settings.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typed_settings import load_settings, option, settings
+from utilities.getpass import USER
+
+from actions.utilities import LOADER
+
+
+@settings
+class Settings:
+    name: str = option(default="name", help="Cron job name")
+    prepend_path: list[str] | None = option(default=None, help="Paths to prepend")
+    schedule: str = option(default="* * * * *", help="Cron job schedule")
+    user: str = option(default=USER, help="Cron job user")
+    timeout: int = option(default=60, help="Seconds until timing-out the cron job")
+    kill_after: int = option(
+        default=10, help="Seconds until killing the cron job (after timeout)"
+    )
+    command: str = option(default="true", help="Command or executable script")
+    args: list[str] | None = option(default=None, help="Command arguments")
+    logs_keep: int = option(default=7, help="Number of logs to keep")
+
+
+SETTINGS = load_settings(Settings, [LOADER])
+
+
+__all__ = ["LOADER", "SETTINGS", "Settings"]

actions/tag_commit/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

actions/tag_commit/cli.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from rich.pretty import pretty_repr
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.tag_commit.lib import tag_commit
+from actions.tag_commit.settings import Settings
+from actions.utilities import LOADER
+
+
+@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="tag")
+def tag_commit_sub_cmd(*, tag: Settings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+        """),
+        tag_commit.__name__,
+        __version__,
+        pretty_repr(tag),
+    )
+    tag_commit(
+        user_name=tag.user_name,
+        user_email=tag.user_email,
+        major_minor=tag.major_minor,
+        major=tag.major,
+        latest=tag.latest,
+    )
+
+
+__all__ = ["tag_commit_sub_cmd"]

actions/tag_commit/doc.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+DOCSTRING = "Tag the latest commit"
+
+
+__all__ = ["DOCSTRING"]

actions/tag_commit/lib.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from subprocess import CalledProcessError
+
+from utilities.text import strip_and_dedent
+from utilities.version import parse_version
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.tag_commit.settings import SETTINGS
+from actions.utilities import log_run
+
+
+def tag_commit(
+    *,
+    user_name: str = SETTINGS.user_name,
+    user_email: str = SETTINGS.user_email,
+    major_minor: bool = SETTINGS.major_minor,
+    major: bool = SETTINGS.major,
+    latest: bool = SETTINGS.latest,
+) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - user_name   = %s
+             - user_email  = %s
+             - major_minor = %s
+             - major       = %s
+             - latest      = %s
+        """),
+        tag_commit.__name__,
+        __version__,
+        user_name,
+        user_email,
+        major_minor,
+        major,
+        latest,
+    )
+    log_run("git", "config", "--global", "user.name", user_name)
+    log_run("git", "config", "--global", "user.email", user_email)
+    version = parse_version(
+        log_run("bump-my-version", "show", "current_version", return_=True)
+    )
+    _tag(str(version))
+    if major_minor:
+        _tag(f"{version.major}.{version.minor}")
+    if major:
+        _tag(str(version.major))
+    if latest:
+        _tag("latest")
+
+
+def _tag(version: str, /) -> None:
+    with suppress(CalledProcessError):
+        log_run("git", "tag", "--delete", version)
+    with suppress(CalledProcessError):
+        log_run("git", "push", "--delete", "origin", version)
+    log_run("git", "tag", "-a", version, "HEAD", "-m", version)
+    log_run("git", "push", "--tags", "--force", "--set-upstream", "origin")
+
+
+__all__ = ["tag_commit"]

actions/{tag → tag_commit}/settings.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from typed_settings import load_settings, option, settings
 
-from actions.utilities import ENV_LOADER
+from actions.utilities import LOADER
 
 
 @settings
-class TagSettings:
+class Settings:
     user_name: str = option(default="github-actions-bot", help="'git' user name")
     user_email: str = option(default="noreply@github.com", help="'git' user email")
     major_minor: bool = option(default=False, help="Add the 'major.minor' tag")
@@ -14,7 +14,7 @@ class TagSettings:
     latest: bool = option(default=False, help="Add the 'latest' tag")
 
 
-TAG_SETTINGS = load_settings(TagSettings, [ENV_LOADER])
+SETTINGS = load_settings(Settings, [LOADER])
 
 
-__all__ = ["TAG_SETTINGS", "TagSettings"]
+__all__ = ["SETTINGS", "Settings"]

actions/types.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from tomlkit.items import Array, Table
+from typed_settings import Secret
+
+if TYPE_CHECKING:
+    from tomlkit.container import Container
+
+
+type HasAppend = Array | list[Any]
+type HasSetDefault = Container | StrDict | Table
+type SecretLike = str | Secret[str]
+type StrDict = dict[str, Any]
+
+
+__all__ = ["HasAppend", "HasSetDefault", "SecretLike", "StrDict"]

actions/utilities.py

@@ -1,23 +1,110 @@
 from __future__ import annotations
 
-from subprocess import check_output
+from typing import TYPE_CHECKING, Literal, assert_never, overload
 
 from typed_settings import EnvLoader, Secret
+from utilities.subprocess import run
 
 from actions.logging import LOGGER
 
-ENV_LOADER = EnvLoader("")
+if TYPE_CHECKING:
+    from utilities.types import StrStrMapping
 
+    from actions.types import SecretLike
 
-def empty_str_to_none(text: str, /) -> str | None:
-    return None if text == "" else text
 
+LOADER = EnvLoader("")
 
-def log_run(*cmds: str | Secret[str]) -> str:
-    LOGGER.info("Running '%s'...", " ".join(map(str, cmds)))
-    return check_output(
-        [c if isinstance(c, str) else c.get_secret_value() for c in cmds], text=True
-    ).rstrip("\n")
 
+def convert_list_strs(
+    x: str | list[str] | tuple[str, ...] | None, /
+) -> list[str] | None:
+    match x:
+        case None:
+            return None
+        case list():
+            return x
+        case tuple():
+            return None if x == () else list(x)
+        case str():
+            return x.splitlines()
+        case never:
+            assert_never(never)
 
-__all__ = ["ENV_LOADER", "empty_str_to_none", "log_run"]
+
+def convert_secret_str(x: SecretLike | None, /) -> Secret[str] | None:
+    match x:
+        case Secret():
+            match x.get_secret_value():
+                case None:
+                    return None
+                case str() as inner:
+                    return None if inner == "" else Secret(inner)
+                case never:
+                    assert_never(never)
+        case str():
+            return None if x == "" else Secret(x)
+        case None:
+            return None
+        case never:
+            assert_never(never)
+
+
+def convert_str(x: str | None, /) -> str | None:
+    match x:
+        case str():
+            return None if x == "" else x
+        case None:
+            return None
+        case never:
+            assert_never(never)
+
+
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: Literal[True],
+) -> str: ...
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: Literal[False] = False,
+) -> None: ...
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: bool = False,
+) -> str | None: ...
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,  # noqa: A002
+    return_: bool = False,
+) -> str | None:
+    all_cmds = [cmd, *cmds]
+    LOGGER.info("Running '%s'...", " ".join(map(str, all_cmds)))
+    unwrapped = [c if isinstance(c, str) else c.get_secret_value() for c in all_cmds]
+    return run(*unwrapped, env=env, print=print, return_=return_, logger=LOGGER)
+
+
+__all__ = [
+    "LOADER",
+    "convert_list_strs",
+    "convert_secret_str",
+    "convert_str",
+    "log_run",
+]

dycw_actions-0.6.4.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: dycw-actions
+Version: 0.6.4
+Summary: Library of actions
+Requires-Dist: click>=8.3.1,<9
+Requires-Dist: dycw-utilities>=0.176.3,<1
+Requires-Dist: inflect>=7.5.0,<8
+Requires-Dist: libcst>=1.8.6,<2
+Requires-Dist: packaging>=25.0,<26
+Requires-Dist: pyyaml>=6.0.3,<7
+Requires-Dist: rich>=14.2.0,<15
+Requires-Dist: ruamel-yaml>=0.19.0,<1
+Requires-Dist: tomlkit>=0.13.3,<1
+Requires-Dist: typed-settings[attrs,click]>=25.3.0,<26
+Requires-Dist: xdg-base-dirs>=6.0.2,<7
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# `actions`
+
+Library of actions