dycw-actions 0.3.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

actions/{sleep → random_sleep}/lib.py

@@ -4,29 +4,30 @@ from math import ceil, floor
 from random import choice
 from time import sleep
 
+from utilities.text import strip_and_dedent
 from utilities.whenever import get_now
 from whenever import TimeDelta, ZonedDateTime
 
 from actions import __version__
 from actions.logging import LOGGER
-from actions.sleep.settings import SLEEP_SETTINGS
+from actions.random_sleep.settings import SETTINGS
 
 
 def random_sleep(
     *,
-    min_: int = SLEEP_SETTINGS.min,
-    max_: int = SLEEP_SETTINGS.max,
-    step: int = SLEEP_SETTINGS.step,
-    log_freq: int = SLEEP_SETTINGS.log_freq,
+    min_: int = SETTINGS.min,
+    max_: int = SETTINGS.max,
+    step: int = SETTINGS.step,
+    log_freq: int = SETTINGS.log_freq,
 ) -> None:
     LOGGER.info(
-        """\
-Running %r (version %s) with settings:
- - min_     = %s
- - max_     = %s
- - step     = %s
- - log_freq = %s
-""",
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - min_     = %s
+             - max_     = %s
+             - step     = %s
+             - log_freq = %s
+        """),
         random_sleep.__name__,
         __version__,
         min_,
@@ -49,7 +50,7 @@ def _intermediate(
     end: ZonedDateTime,
     /,
     *,
-    log_freq: int = SLEEP_SETTINGS.log_freq,
+    log_freq: int = SETTINGS.log_freq,
 ) -> None:
     elapsed = TimeDelta(seconds=floor((now - start).in_seconds()))
     remaining = TimeDelta(seconds=ceil((end - now).in_seconds()))

actions/{sleep → random_sleep}/settings.py

@@ -6,14 +6,14 @@ from actions.utilities import LOADER
 
 
 @settings
-class SleepSettings:
+class Settings:
     min: int = option(default=0, help="Minimum duration, in seconds")
     max: int = option(default=3600, help="Maximum duration, in seconds")
     step: int = option(default=1, help="Step duration, in seconds")
     log_freq: int = option(default=60, help="Log frequency, in seconds")
 
 
-SLEEP_SETTINGS = load_settings(SleepSettings, [LOADER])
+SETTINGS = load_settings(Settings, [LOADER])
 
 
-__all__ = ["SLEEP_SETTINGS", "SleepSettings"]
+__all__ = ["SETTINGS", "Settings"]

actions/run_hooks/__init__.py

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

actions/run_hooks/cli.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+
+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)
+def run_hooks_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    run_hooks(repos=settings.repos, hooks=settings.hooks, sleep=settings.sleep)
+
+
+__all__ = ["run_hooks_sub_cmd"]

actions/run_hooks/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+RUN_HOOKS_DOCSTRING = "Run 'pre-commit' hooks"
+RUN_HOOKS_SUB_CMD = "run-hooks"
+
+
+__all__ = ["RUN_HOOKS_DOCSTRING", "RUN_HOOKS_SUB_CMD"]

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 logged_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:
+        logged_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,31 @@
+from __future__ import annotations
+
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+
+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)
+    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,12 @@
+from __future__ import annotations
+
+from actions.constants import PATH_ACTIONS
+
+PATH_CONFIGS = PATH_ACTIONS / "setup_cronjob/configs"
+
+
+SETUP_CRONJOB_SUB_CMD = "setup-cronjob"
+SETUP_CRONJOB_DOCSTRING = "Setup a cronjob"
+
+
+__all__ = ["PATH_CONFIGS", "SETUP_CRONJOB_DOCSTRING", "SETUP_CRONJOB_SUB_CMD"]

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,27 @@
+from __future__ import annotations
+
+from typed_settings import click_options
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+
+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)
+def tag_commit_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    tag_commit(
+        user_name=settings.user_name,
+        user_email=settings.user_email,
+        major_minor=settings.major_minor,
+        major=settings.major,
+        latest=settings.latest,
+    )
+
+
+__all__ = ["tag_commit_sub_cmd"]

actions/tag_commit/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+TAG_COMMIT_DOCSTRING = "Tag the latest commit"
+TAG_COMMIT_SUB_CMD = "tag-commit"
+
+
+__all__ = ["TAG_COMMIT_DOCSTRING", "TAG_COMMIT_SUB_CMD"]

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 logged_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,
+    )
+    logged_run("git", "config", "--global", "user.name", user_name)
+    logged_run("git", "config", "--global", "user.email", user_email)
+    version = parse_version(
+        logged_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):
+        logged_run("git", "tag", "--delete", version)
+    with suppress(CalledProcessError):
+        logged_run("git", "push", "--delete", "origin", version)
+    logged_run("git", "tag", "-a", version, "HEAD", "-m", version)
+    logged_run("git", "push", "--tags", "--force", "--set-upstream", "origin")
+
+
+__all__ = ["tag_commit"]

actions/{tag → tag_commit}/settings.py

@@ -6,7 +6,7 @@ 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, [LOADER])
+SETTINGS = load_settings(Settings, [LOADER])
 
 
-__all__ = ["TAG_SETTINGS", "TagSettings"]
+__all__ = ["SETTINGS", "Settings"]

actions/types.py

@@ -1,8 +1,21 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from tomlkit.items import Array, Table
 from typed_settings import Secret
+from utilities.packaging import Requirement
+
+if TYPE_CHECKING:
+    from tomlkit.container import Container
+
 
+type FuncRequirement = Callable[[Requirement], Requirement]
+type HasAppend = Array | list[Any]
+type HasSetDefault = Container | StrDict | Table
 type SecretLike = str | Secret[str]
+type StrDict = dict[str, Any]
 
 
-__all__ = ["SecretLike"]
+__all__ = ["FuncRequirement", "HasAppend", "HasSetDefault", "SecretLike", "StrDict"]