dycw-actions 0.8.11__py3-none-any.whl → 0.11.3__py3-none-any.whl

actions/pre_commit/replace_sequence_strs/lib.py

@@ -10,11 +10,13 @@ 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.functions import get_func_name
+from utilities.tabulate import func_param_desc
 from utilities.text import repr_str
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.pre_commit.utilities import yield_python_file
-from actions.utilities import log_func_call
 
 if TYPE_CHECKING:
     from collections.abc import MutableSet
@@ -24,7 +26,7 @@ if TYPE_CHECKING:
 
 
 def replace_sequence_strs(*paths: PathLike) -> None:
-    LOGGER.info(log_func_call(replace_sequence_strs, f"{paths=}"))
+    LOGGER.info(func_param_desc(replace_sequence_strs, __version__, f"{paths=}"))
     modifications: set[Path] = set()
     for path in paths:
         _format_path(path, modifications=modifications)
@@ -34,6 +36,7 @@ def replace_sequence_strs(*paths: PathLike) -> None:
             ", ".join(map(repr_str, sorted(modifications))),
         )
         sys.exit(1)
+    LOGGER.info("Finished running %r", get_func_name(replace_sequence_strs))
 
 
 def _format_path(

actions/pre_commit/touch_empty_py/lib.py

@@ -4,13 +4,15 @@ import sys
 from typing import TYPE_CHECKING
 
 from libcst import parse_statement
+from utilities.functions import get_func_name
+from utilities.tabulate import func_param_desc
 from utilities.text import repr_str
 from utilities.throttle import throttle
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.pre_commit.constants import THROTTLE_DELTA
 from actions.pre_commit.utilities import path_throttle_cache, yield_python_file
-from actions.utilities import log_func_call
 
 if TYPE_CHECKING:
     from collections.abc import MutableSet
@@ -20,7 +22,7 @@ if TYPE_CHECKING:
 
 
 def _touch_empty_py(*paths: PathLike) -> None:
-    LOGGER.info(log_func_call(touch_empty_py, f"{paths=}"))
+    LOGGER.info(func_param_desc(touch_empty_py, __version__, f"{paths=}"))
     modifications: set[Path] = set()
     for path in paths:
         _format_path(path, modifications=modifications)
@@ -30,6 +32,7 @@ def _touch_empty_py(*paths: PathLike) -> None:
             ", ".join(map(repr_str, sorted(modifications))),
         )
         sys.exit(1)
+    LOGGER.info("Finished running %r", get_func_name(touch_empty_py))
 
 
 touch_empty_py = throttle(

actions/pre_commit/touch_py_typed/lib.py

@@ -4,14 +4,16 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from utilities.functions import get_func_name
 from utilities.iterables import one
+from utilities.tabulate import func_param_desc
 from utilities.text import repr_str
 from utilities.throttle import throttle
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.pre_commit.constants import THROTTLE_DELTA
 from actions.pre_commit.utilities import path_throttle_cache
-from actions.utilities import log_func_call
 
 if TYPE_CHECKING:
     from collections.abc import MutableSet
@@ -20,7 +22,7 @@ if TYPE_CHECKING:
 
 
 def _touch_py_typed(*paths: PathLike) -> None:
-    LOGGER.info(log_func_call(touch_py_typed, f"{paths=}"))
+    LOGGER.info(func_param_desc(touch_py_typed, __version__, f"{paths=}"))
     modifications: set[Path] = set()
     for path in paths:
         _format_path(path, modifications=modifications)
@@ -30,6 +32,7 @@ def _touch_py_typed(*paths: PathLike) -> None:
             ", ".join(map(repr_str, sorted(modifications))),
         )
         sys.exit(1)
+    LOGGER.info("Finished running %r", get_func_name(touch_py_typed))
 
 
 touch_py_typed = throttle(

actions/pre_commit/update_requirements/lib.py

@@ -5,9 +5,11 @@ from functools import partial
 from typing import TYPE_CHECKING
 
 from pydantic import TypeAdapter
-from utilities.functions import max_nullable
+from utilities.functions import get_func_name, max_nullable
+from utilities.tabulate import func_param_desc
 from utilities.text import repr_str
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.pre_commit.update_requirements.classes import (
     PipListOutdatedOutput,
@@ -19,7 +21,7 @@ from actions.pre_commit.update_requirements.classes import (
     parse_version2_or_3,
 )
 from actions.pre_commit.utilities import get_pyproject_dependencies, yield_toml_doc
-from actions.utilities import log_func_call, logged_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from collections.abc import MutableSet
@@ -32,7 +34,7 @@ if TYPE_CHECKING:
 
 
 def update_requirements(*paths: PathLike) -> None:
-    LOGGER.info(log_func_call(update_requirements, f"{paths=}"))
+    LOGGER.info(func_param_desc(update_requirements, __version__, f"{paths=}"))
     modifications: set[Path] = set()
     for path in paths:
         _format_path(path, modifications=modifications)
@@ -42,6 +44,7 @@ def update_requirements(*paths: PathLike) -> None:
             ", ".join(map(repr_str, sorted(modifications))),
         )
         sys.exit(1)
+    LOGGER.info("Finished running %r", get_func_name(update_requirements))
 
 
 def _format_path(

actions/publish_package/lib.py

@@ -2,11 +2,14 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from utilities.functions import get_func_name
+from utilities.tabulate import func_param_desc
 from utilities.tempfile import TemporaryDirectory
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.publish_package.settings import SETTINGS
-from actions.utilities import log_func_call, logged_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from typed_settings import Secret
@@ -20,14 +23,17 @@ def publish_package(
     trusted_publishing: bool = SETTINGS.trusted_publishing,
     native_tls: bool = SETTINGS.native_tls,
 ) -> None:
-    variables = [
-        f"{username=}",
-        f"{password=}",
-        f"{publish_url=}",
-        f"{trusted_publishing=}",
-        f"{native_tls=}",
-    ]
-    LOGGER.info(log_func_call(publish_package, *variables))
+    LOGGER.info(
+        func_param_desc(
+            publish_package,
+            __version__,
+            f"{username=}",
+            f"{password=}",
+            f"{publish_url=}",
+            f"{trusted_publishing=}",
+            f"{native_tls=}",
+        )
+    )
     with TemporaryDirectory() as temp:
         logged_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
         logged_run(
@@ -40,6 +46,7 @@ def publish_package(
             *(["--native-tls"] if native_tls else []),
             f"{temp}/*",
         )
+    LOGGER.info("Finished running %r", get_func_name(publish_package))
 
 
 __all__ = ["publish_package"]

actions/random_sleep/lib.py

@@ -4,12 +4,14 @@ from math import ceil, floor
 from random import choice
 from time import sleep
 
+from utilities.functions import get_func_name
+from utilities.tabulate import func_param_desc
 from utilities.whenever import get_now
 from whenever import TimeDelta, ZonedDateTime
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.random_sleep.settings import SETTINGS
-from actions.utilities import log_func_call
 
 
 def random_sleep(
@@ -19,15 +21,18 @@ def random_sleep(
     step: int = SETTINGS.step,
     log_freq: int = SETTINGS.log_freq,
 ) -> None:
-    variables = [f"{min=}", f"{max=}", f"{step=}", f"{log_freq=}"]
-    LOGGER.info(log_func_call(random_sleep, *variables))
+    LOGGER.info(
+        func_param_desc(
+            random_sleep, __version__, f"{min=}", f"{max=}", f"{step=}", f"{log_freq=}"
+        )
+    )
     start = get_now()
     delta = TimeDelta(seconds=choice(range(min, max, step)))
     LOGGER.info("Sleeping for %s...", delta)
     end = (start + delta).round(mode="ceil")
     while (now := get_now()) < end:
         _intermediate(start, now, end, log_freq=log_freq)
-    LOGGER.info("Finished sleeping for %s", delta)
+    LOGGER.info("Finished running %r", get_func_name(random_sleep))
 
 
 def _intermediate(

actions/register_gitea_runner/configs/entrypoint.sh

@@ -6,16 +6,16 @@ echo_date() { echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" >&2; }
 
 # main
 wait-for-it.sh \
-    --host="${GITEA_HOST}" \
-    --port="${GITEA_PORT}" \
-    --strict \
-    -- \
-    echo "${GITEA_HOST}:${GITEA_PORT} is up"
+	--host="${GITEA_HOST}" \
+	--port="${GITEA_PORT}" \
+	--strict \
+	-- \
+	echo "${GITEA_HOST}:${GITEA_PORT} is up"
 
 if ! command -v update-ca-certificates >/dev/null 2>&1; then
-    echo_date "Installing 'ca-certificates'..."
-    apk update
-    apk add --no-cache ca-certificates
+	echo_date "Installing 'ca-certificates'..."
+	apk update
+	apk add --no-cache ca-certificates
 fi
 
 update-ca-certificates || true

actions/register_gitea_runner/lib.py

@@ -7,8 +7,11 @@ from typing import TYPE_CHECKING
 
 from requests import get
 from utilities.atomicwrites import writer
+from utilities.functions import get_func_name
 from utilities.subprocess import chmod, rm_cmd, ssh, sudo_cmd
+from utilities.tabulate import func_param_desc
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.register_gitea_runner.constants import (
     PATH_CACHE,
@@ -17,7 +20,7 @@ from actions.register_gitea_runner.constants import (
     URL_WAIT_FOR_IT,
 )
 from actions.register_gitea_runner.settings import SETTINGS
-from actions.utilities import log_func_call, logged_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from utilities.types import PathLike
@@ -37,19 +40,22 @@ def register_gitea_runner(
     runner_instance_name: str = SETTINGS.runner_instance_name,
 ) -> None:
     """Register against a remote instance of Gitea."""
-    variables = [
-        f"{ssh_user=}",
-        f"{ssh_host=}",
-        f"{gitea_container_user=}",
-        f"{gitea_container_name=}",
-        f"{runner_certificate=}",
-        f"{runner_capacity=}",
-        f"{runner_container_name=}",
-        f"{gitea_host=}",
-        f"{gitea_port=}",
-        f"{runner_instance_name=}",
-    ]
-    LOGGER.info(log_func_call(register_gitea_runner, *variables))
+    LOGGER.info(
+        func_param_desc(
+            register_gitea_runner,
+            __version__,
+            f"{ssh_user=}",
+            f"{ssh_host=}",
+            f"{gitea_container_user=}",
+            f"{gitea_container_name=}",
+            f"{runner_certificate=}",
+            f"{runner_capacity=}",
+            f"{runner_container_name=}",
+            f"{gitea_host=}",
+            f"{gitea_port=}",
+            f"{runner_instance_name=}",
+        )
+    )
     token = ssh(
         ssh_user,
         ssh_host,
@@ -66,6 +72,7 @@ def register_gitea_runner(
         gitea_port=gitea_port,
         runner_instance_name=runner_instance_name,
     )
+    LOGGER.info("Finished running %r", get_func_name(register_gitea_runner))
 
 
 def register_against_local(
@@ -155,6 +162,8 @@ def _docker_run_act_runner_args(
         f"GITEA_RUNNER_REGISTRATION_TOKEN={token}",
         "--name",
         container_name,
+        "--restart",
+        "always",
         "--volume",
         "/var/run/docker.sock:/var/run/docker.sock",
         "--volume",

actions/run_hooks/lib.py

@@ -7,13 +7,15 @@ from re import search
 from subprocess import CalledProcessError
 from typing import TYPE_CHECKING, Any
 
-from utilities.functions import ensure_class, ensure_str
+from utilities.functions import ensure_class, ensure_str, get_func_name
+from utilities.tabulate import func_param_desc
 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_func_call, logged_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -26,8 +28,16 @@ def run_hooks(
     hooks_exclude: list[str] | None = SETTINGS.hooks_exclude,
     sleep: int = SETTINGS.sleep,
 ) -> None:
-    variables = [f"{repos=}", f"{hooks=}", f"{hooks_exclude=}", f"{sleep=}"]
-    LOGGER.info(log_func_call(run_hooks, *variables))
+    LOGGER.info(
+        func_param_desc(
+            run_hooks,
+            __version__,
+            f"{repos=}",
+            f"{hooks=}",
+            f"{hooks_exclude=}",
+            f"{sleep=}",
+        )
+    )
     results = {
         hook: _run_hook(hook, sleep=sleep)
         for hook in _yield_hooks(repos=repos, hooks=hooks, hooks_exclude=hooks_exclude)
@@ -36,6 +46,7 @@ def run_hooks(
     if len(failed) >= 1:
         msg = f"Failed hook(s): {', '.join(failed)}"
         raise RuntimeError(msg)
+    LOGGER.info("Finished running %r", get_func_name(run_hooks))
 
 
 def _yield_hooks(

actions/setup_cronjob/lib.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 from string import Template
 from typing import TYPE_CHECKING
 
+from utilities.functions import get_func_name
 from utilities.platform import SYSTEM
 from utilities.subprocess import chmod, chown, tee
+from utilities.tabulate import func_param_desc
 
+from actions import __version__
 from actions.logging import LOGGER
 from actions.setup_cronjob.constants import PATH_CONFIGS
 from actions.setup_cronjob.settings import SETTINGS
-from actions.utilities import log_func_call
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -30,18 +32,21 @@ def setup_cronjob(
     logs_keep: int = SETTINGS.logs_keep,
 ) -> None:
     """Set up a cronjob & logrotate."""
-    variables = [
-        f"{name=}",
-        f"{prepend_path=}",
-        f"{schedule=}",
-        f"{user=}",
-        f"{timeout=}",
-        f"{kill_after=}",
-        f"{command=}",
-        f"{args=}",
-        f"{logs_keep=}",
-    ]
-    LOGGER.info(log_func_call(setup_cronjob, *variables))
+    LOGGER.info(
+        func_param_desc(
+            setup_cronjob,
+            __version__,
+            f"{name=}",
+            f"{prepend_path=}",
+            f"{schedule=}",
+            f"{user=}",
+            f"{timeout=}",
+            f"{kill_after=}",
+            f"{command=}",
+            f"{args=}",
+            f"{logs_keep=}",
+        )
+    )
     if SYSTEM != "linux":
         msg = f"System must be 'linux'; got {SYSTEM!r}"
         raise TypeError(msg)
@@ -61,6 +66,7 @@ def setup_cronjob(
     _tee_and_perms(
         f"/etc/logrotate.d/{name}", _get_logrotate(name=name, logs_keep=logs_keep)
     )
+    LOGGER.info("Finished running %r", get_func_name(setup_cronjob))
 
 
 def _get_crontab(

actions/setup_ssh_config/__init__.py

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

actions/setup_ssh_config/cli.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from utilities.logging import basic_config
+from utilities.os import is_pytest
+
+from actions.logging import LOGGER
+from actions.setup_ssh_config.lib import setup_ssh_config
+
+
+def setup_ssh_config_sub_cmd() -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    setup_ssh_config()
+
+
+__all__ = ["setup_ssh_config_sub_cmd"]

actions/setup_ssh_config/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+SETUP_SSH_CONFIG_DOCSTRING = "Setup '.ssh/config.d'"
+SETUP_SSH_CONFIG_SUB_CMD = "setup-ssh-config"
+
+
+__all__ = ["SETUP_SSH_CONFIG_DOCSTRING", "SETUP_SSH_CONFIG_SUB_CMD"]

actions/setup_ssh_config/lib.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from utilities.atomicwrites import writer
+from utilities.functions import get_func_name
+from utilities.tabulate import func_param_desc
+
+from actions import __version__
+from actions.constants import SSH
+from actions.logging import LOGGER
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def setup_ssh_config() -> None:
+    LOGGER.info(func_param_desc(setup_ssh_config, __version__))
+    path = get_ssh_config("*")
+    with writer(SSH / "config", overwrite=True) as temp:
+        _ = temp.write_text(f"Include {path}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    LOGGER.info("Finished running %r", get_func_name(setup_ssh_config))
+
+
+def get_ssh_config(stem: str, /) -> Path:
+    return SSH / "config.d" / f"{stem}.conf"
+
+
+__all__ = ["setup_ssh_config"]

actions/tag_commit/lib.py

@@ -3,11 +3,14 @@ from __future__ import annotations
 from contextlib import suppress
 from subprocess import CalledProcessError
 
+from utilities.functions import get_func_name
+from utilities.tabulate import func_param_desc
 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_func_call, logged_run
+from actions.utilities import logged_run
 
 
 def tag_commit(
@@ -18,14 +21,17 @@ def tag_commit(
     major: bool = SETTINGS.major,
     latest: bool = SETTINGS.latest,
 ) -> None:
-    variables = [
-        f"{user_name=}",
-        f"{user_email=}",
-        f"{major_minor=}",
-        f"{major=}",
-        f"{latest=}",
-    ]
-    LOGGER.info(log_func_call(tag_commit, *variables))
+    LOGGER.info(
+        func_param_desc(
+            tag_commit,
+            __version__,
+            f"{user_name=}",
+            f"{user_email=}",
+            f"{major_minor=}",
+            f"{major=}",
+            f"{latest=}",
+        )
+    )
     logged_run("git", "config", "--global", "user.name", user_name)
     logged_run("git", "config", "--global", "user.email", user_email)
     version = parse_version(
@@ -38,6 +44,7 @@ def tag_commit(
         _tag(str(version.major))
     if latest:
         _tag("latest")
+    LOGGER.info("Finished running %r", get_func_name(tag_commit))
 
 
 def _tag(version: str, /) -> None:

actions/utilities.py

@@ -2,22 +2,18 @@ from __future__ import annotations
 
 from io import StringIO
 from pathlib import Path
-from textwrap import indent
 from typing import TYPE_CHECKING, Any, Literal, assert_never, overload
 
-from tabulate import tabulate
 from typed_settings import EnvLoader, Secret
 from utilities.atomicwrites import writer
-from utilities.functions import get_func_name
 from utilities.subprocess import run
 from utilities.text import split_str
 
-from actions import __version__
 from actions.constants import YAML_INSTANCE
 from actions.logging import LOGGER
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, MutableSet
+    from collections.abc import MutableSet
 
     from utilities.types import PathLike, StrStrMapping
 
@@ -87,17 +83,6 @@ def ensure_new_line(text: str, /) -> str:
     return text.strip("\n") + "\n"
 
 
-def log_func_call(func: Callable[..., Any], /, *variables: str) -> str:
-    name = get_func_name(func)
-    table = tabulate(
-        list(map(split_f_str_equals, variables)), tablefmt="rounded_outline"
-    )
-    indented = indent(table, "  ")
-    return f"""
-Running {name!r} (version {__version__}) with:
-{indented}"""
-
-
 @overload
 def logged_run(
     cmd: SecretLike,

{dycw_actions-0.8.11.dist-info → dycw_actions-0.11.3.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: dycw-actions
-Version: 0.8.11
+Version: 0.11.3
 Summary: Library of actions
 Requires-Dist: click>=8.3.1,<9
-Requires-Dist: dycw-utilities>=0.179.0,<1
+Requires-Dist: dycw-utilities>=0.179.3,<1
 Requires-Dist: inflect>=7.5.0,<8
 Requires-Dist: libcst>=1.8.6,<2
 Requires-Dist: packaging>=25.0,<26
@@ -13,7 +13,7 @@ Requires-Dist: requests>=2.32.5,<3
 Requires-Dist: rich>=14.2.0,<15
 Requires-Dist: ruamel-yaml>=0.19.1,<1
 Requires-Dist: tabulate>=0.9.0,<1
-Requires-Dist: tomlkit>=0.13.3,<1
+Requires-Dist: tomlkit>=0.14.0,<1
 Requires-Dist: typed-settings[attrs,click]>=25.3.0,<26
 Requires-Dist: xdg-base-dirs>=6.0.2,<7
 Requires-Python: >=3.12