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

actions/pre_commit/utilities.py

@@ -5,7 +5,7 @@ from collections.abc import Iterator, MutableSet
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, assert_never
+from typing import TYPE_CHECKING, Any, assert_never, overload
 
 import tomlkit
 from libcst import Module, parse_module
@@ -16,8 +16,9 @@ from utilities.functions import ensure_class, ensure_str, get_func_name
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one
 from utilities.packaging import Requirement
 from utilities.types import PathLike, StrDict
+from utilities.typing import is_str_dict
 
-from actions.constants import PATH_CACHE, YAML_INSTANCE
+from actions.constants import PATH_CACHE, PYPROJECT_TOML, YAML_INSTANCE
 from actions.logging import LOGGER
 from actions.utilities import are_equal_modulo_new_line, write_text, yaml_dump
 
@@ -26,26 +27,26 @@ if TYPE_CHECKING:
 
     from utilities.types import PathLike, StrDict
 
-    from actions.types import FuncRequirement, HasAppend, HasSetDefault
+    from actions.types import ArrayLike, ContainerLike, FuncRequirement
 
 
-def ensure_aot_contains(array: AoT, /, *tables: Table) -> None:
-    for table_ in tables:
-        if table_ not in array:
-            array.append(table_)
+##
 
 
-def ensure_contains(array: HasAppend, /, *objs: Any) -> None:
-    if isinstance(array, AoT):
-        msg = f"Use {ensure_aot_contains.__name__!r} instead of {ensure_contains.__name__!r}"
-        raise TypeError(msg)
+@overload
+def ensure_contains(container: AoT, /, *objs: Table) -> None: ...
+@overload
+def ensure_contains(container: list[str], /, *objs: str) -> None: ...
+@overload
+def ensure_contains(container: list[StrDict], /, *objs: StrDict) -> None: ...
+def ensure_contains(container: ArrayLike, /, *objs: Any) -> None:
     for obj in objs:
-        if obj not in array:
-            array.append(obj)
+        if obj not in container:
+            container.append(obj)
 
 
 def ensure_contains_partial_dict(
-    container: HasAppend, partial: StrDict, /, *, extra: StrDict | None = None
+    container: list[StrDict], partial: StrDict, /, *, extra: StrDict | None = None
 ) -> StrDict:
     try:
         return get_partial_dict(container, partial, skip_log=True)
@@ -55,52 +56,123 @@ def ensure_contains_partial_dict(
         return dict_
 
 
-def ensure_contains_partial_str(container: HasAppend, text: str, /) -> str:
+def ensure_contains_partial_str(list_: Array | list[str], text: str, /) -> str:
     try:
-        return get_partial_str(container, text, skip_log=True)
+        return get_partial_str(list_, text, skip_log=True)
     except OneEmptyError:
-        container.append(text)
+        list_.append(text)
         return text
 
 
-def ensure_not_contains(array: Array, /, *objs: Any) -> None:
+@overload
+def ensure_not_contains(container: AoT, /, *objs: Table) -> None: ...
+@overload
+def ensure_not_contains(container: list[str], /, *objs: str) -> None: ...
+@overload
+def ensure_not_contains(container: list[StrDict], /, *objs: StrDict) -> None: ...
+def ensure_not_contains(container: ArrayLike, /, *objs: Any) -> None:
     for obj in objs:
         try:
-            index = next(i for i, o in enumerate(array) if o == obj)
+            index = next(i for i, o in enumerate(container) if o == obj)
         except StopIteration:
             pass
         else:
-            del array[index]
+            del container[index]
+
+
+##
+
+
+def get_aot(container: ContainerLike, key: str, /) -> AoT:
+    return ensure_class(container[key], AoT)
+
+
+def get_array(container: ContainerLike, key: str, /) -> Array:
+    return ensure_class(container[key], Array)
+
+
+def get_dict(dict_: StrDict, key: str, /) -> StrDict:
+    if is_str_dict(value := dict_[key]):
+        return value
+    raise TypeError(value)
+
+
+def get_list_dicts(dict_: StrDict, key: str, /) -> list[StrDict]:
+    list_ = ensure_class(dict_[key], list)
+    for i in list_:
+        if not is_str_dict(i):
+            raise TypeError(i)
+    return list_
+
+
+def get_list_strs(dict_: StrDict, key: str, /) -> list[str]:
+    list_ = ensure_class(dict_[key], list)
+    for i in list_:
+        if not isinstance(i, str):
+            raise TypeError(i)
+    return list_
+
+
+def get_table(container: ContainerLike, key: str, /) -> Table:
+    return ensure_class(container[key], Table)
 
 
 ##
 
 
-def get_aot(container: HasSetDefault, key: str, /) -> AoT:
-    return ensure_class(container.setdefault(key, aot()), AoT)
+def get_set_aot(container: ContainerLike, key: str, /) -> AoT:
+    try:
+        return get_aot(container, key)
+    except KeyError:
+        value = container[key] = aot()
+        return value
+
+
+def get_set_array(container: ContainerLike, key: str, /) -> Array:
+    try:
+        return get_array(container, key)
+    except KeyError:
+        value = container[key] = array()
+        return value
 
 
-def get_array(container: HasSetDefault, key: str, /) -> Array:
-    return ensure_class(container.setdefault(key, array()), Array)
+def get_set_dict(dict_: StrDict, key: str, /) -> StrDict:
+    try:
+        return get_dict(dict_, key)
+    except KeyError:
+        value = dict_[key] = {}
+        return value
 
 
-def get_dict(container: HasSetDefault, key: str, /) -> StrDict:
-    return ensure_class(container.setdefault(key, {}), dict)
+def get_set_list_dicts(dict_: StrDict, key: str, /) -> list[StrDict]:
+    try:
+        return get_list_dicts(dict_, key)
+    except KeyError:
+        value = dict_[key] = []
+        return value
 
 
-def get_list(container: HasSetDefault, key: str, /) -> list[Any]:
-    return ensure_class(container.setdefault(key, []), list)
+def get_set_list_strs(dict_: StrDict, key: str, /) -> list[str]:
+    try:
+        return get_list_strs(dict_, key)
+    except KeyError:
+        value = dict_[key] = []
+        return value
 
 
-def get_table(container: HasSetDefault, key: str, /) -> Table:
-    return ensure_class(container.setdefault(key, table()), Table)
+def get_set_table(container: ContainerLike, key: str, /) -> Table:
+    try:
+        return get_table(container, key)
+    except KeyError:
+        value = container[key] = table()
+        return value
 
 
 ##
 
 
 def get_partial_dict(
-    iterable: Iterable[Any], dict_: StrDict, /, *, skip_log: bool = False
+    iterable: Iterable[StrDict], dict_: StrDict, /, *, skip_log: bool = False
 ) -> StrDict:
     try:
         return one(i for i in iterable if is_partial_dict(dict_, i))
@@ -177,19 +249,21 @@ def is_partial_str(obj: Any, text: str, /) -> bool:
 def get_pyproject_dependencies(doc: TOMLDocument, /) -> PyProjectDependencies:
     out = PyProjectDependencies()
     if (project_key := "project") in doc:
-        project = get_table(doc, project_key)
+        project = get_set_table(doc, project_key)
         if (dep_key := "dependencies") in project:
-            out.dependencies = get_array(project, dep_key)
+            out.dependencies = get_set_array(project, dep_key)
         if (opt_dep_key := "optional-dependencies") in project:
-            opt_dependencies = get_table(project, opt_dep_key)
+            opt_dependencies = get_set_table(project, opt_dep_key)
             out.opt_dependencies = {}
             for key in opt_dependencies:
-                out.opt_dependencies[ensure_str(key)] = get_array(opt_dependencies, key)
+                out.opt_dependencies[ensure_str(key)] = get_set_array(
+                    opt_dependencies, key
+                )
     if (dep_grps_key := "dependency-groups") in doc:
-        dep_grps = get_table(doc, dep_grps_key)
+        dep_grps = get_set_table(doc, dep_grps_key)
         out.dep_groups = {}
         for key in dep_grps:
-            out.dep_groups[ensure_str(key)] = get_array(dep_grps, key)
+            out.dep_groups[ensure_str(key)] = get_set_array(dep_grps, key)
     return out
 
 
@@ -295,6 +369,17 @@ def yield_json_dict(
 ##
 
 
+@contextmanager
+def yield_pyproject_toml(
+    *, modifications: MutableSet[Path] | None = None
+) -> Iterator[TOMLDocument]:
+    with yield_toml_doc(PYPROJECT_TOML, modifications=modifications) as doc:
+        yield doc
+
+
+##
+
+
 @contextmanager
 def yield_mutable_write_context[T](
     path: PathLike,
@@ -370,7 +455,6 @@ def yield_yaml_dict(
 __all__ = [
     "PyProjectDependencies",
     "WriteContext",
-    "ensure_aot_contains",
     "ensure_contains",
     "ensure_contains_partial_dict",
     "ensure_contains_partial_str",
@@ -378,10 +462,17 @@ __all__ = [
     "get_aot",
     "get_array",
     "get_dict",
-    "get_list",
+    "get_list_dicts",
+    "get_list_strs",
     "get_partial_dict",
     "get_partial_str",
     "get_pyproject_dependencies",
+    "get_set_aot",
+    "get_set_array",
+    "get_set_dict",
+    "get_set_list_dicts",
+    "get_set_list_strs",
+    "get_set_table",
     "get_table",
     "is_partial_dict",
     "is_partial_str",
@@ -389,6 +480,7 @@ __all__ = [
     "yield_immutable_write_context",
     "yield_json_dict",
     "yield_mutable_write_context",
+    "yield_pyproject_toml",
     "yield_python_file",
     "yield_text_file",
     "yield_toml_doc",

actions/publish_package/lib.py

@@ -2,15 +2,20 @@ 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
 
+    from actions.types import SecretLike
+
 
 def publish_package(
     *,
@@ -20,26 +25,34 @@ 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))
-    with TemporaryDirectory() as temp:
-        logged_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
-        logged_run(
-            "uv",
-            "publish",
-            *([] if username is None else ["--username", username]),
-            *([] if password is None else ["--password", password]),
-            *([] if publish_url is None else ["--publish-url", publish_url]),
-            *(["--trusted-publishing", "always"] if trusted_publishing else []),
-            *(["--native-tls"] if native_tls else []),
-            f"{temp}/*",
+    LOGGER.info(
+        func_param_desc(
+            publish_package,
+            __version__,
+            f"{username=}",
+            f"{password=}",
+            f"{publish_url=}",
+            f"{trusted_publishing=}",
+            f"{native_tls=}",
         )
+    )
+    build_head: list[str] = ["uv", "build", "--out-dir"]
+    build_tail: list[str] = ["--wheel", "--clear"]
+    publish: list[SecretLike] = ["uv", "publish"]
+    if username is not None:
+        publish.extend(["--username", username])
+    if password is not None:
+        publish.extend(["--password", password])
+    if publish_url is not None:
+        publish.extend(["--publish-url", publish_url])
+    if trusted_publishing:
+        publish.extend(["--trusted-publishing", "always"])
+    if native_tls:
+        publish.append("--native-tls")
+    with TemporaryDirectory() as temp:
+        logged_run(*build_head, str(temp), *build_tail)
+        logged_run(*publish, 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")
+    duration = TimeDelta(seconds=choice(range(min, max, step)))
+    LOGGER.info("Sleeping for %s...", duration)
+    end = (start + duration).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/re_encrypt/__init__.py

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

actions/re_encrypt/cli.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+from click import argument
+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.re_encrypt.lib import re_encrypt
+from actions.re_encrypt.settings import Settings
+from actions.utilities import LOADER
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+@argument("path", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def re_encrypt_sub_cmd(settings: Settings, /, *, path: PathLike) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    re_encrypt(
+        path,
+        key_file=settings.key_file,
+        key=settings.key,
+        new_key_file=settings.new_key_file,
+        new_key=settings.new_key,
+    )
+
+
+__all__ = ["re_encrypt_sub_cmd"]

actions/re_encrypt/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+RE_ENCRYPT_DOCSTRING = "Re-encrypt a JSON file"
+RE_ENCRYPT_SUB_CMD = "re-encrypt"
+
+
+__all__ = ["RE_ENCRYPT_DOCSTRING", "RE_ENCRYPT_SUB_CMD"]

actions/re_encrypt/lib.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from os import environ
+from pathlib import Path
+from typing import TYPE_CHECKING, assert_never
+
+from typed_settings import Secret
+from utilities.atomicwrites import writer
+from utilities.os import temp_environ
+from utilities.subprocess import run
+from utilities.tabulate import func_param_desc
+from utilities.tempfile import TemporaryFile
+from xdg_base_dirs import xdg_config_home
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.re_encrypt.settings import SETTINGS
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from utilities.types import PathLike
+
+
+def re_encrypt(
+    path: PathLike,
+    /,
+    *,
+    key_file: PathLike | None = SETTINGS.key_file,
+    key: Secret[str] | None = SETTINGS.key,
+    new_key_file: PathLike | None = SETTINGS.new_key_file,
+    new_key: Secret[str] | None = SETTINGS.new_key,
+) -> None:
+    """Re-encrypt a JSON file."""
+    LOGGER.info(
+        func_param_desc(
+            re_encrypt,
+            __version__,
+            f"{path=}",
+            f"{key_file=}",
+            f"{key=}",
+            f"{new_key_file=}",
+            f"{new_key=}",
+        )
+    )
+    with _yield_env(key_file=key_file, key=key):
+        decrypted = run(
+            "sops",
+            "decrypt",
+            "--input-type",
+            "json",
+            "--output-type",
+            "json",
+            "--ignore-mac",
+            str(path),
+            return_=True,
+        )
+    with _yield_env(key_file=new_key_file, key=new_key):
+        identity = _get_recipient()
+    with TemporaryFile(text=decrypted) as temp:
+        encrypted = run(
+            "sops",
+            "encrypt",
+            "--age",
+            identity,
+            "--input-type",
+            "json",
+            "--output-type",
+            "json",
+            str(temp),
+            return_=True,
+        )
+    with writer(path, overwrite=True) as temp:
+        _ = temp.write_text(encrypted)
+    LOGGER.info("Finished re-encrypting '%s'", path)
+
+
+@contextmanager
+def _yield_env(
+    *,
+    key_file: PathLike | None = SETTINGS.key_file,
+    key: Secret[str] | None = SETTINGS.key,
+) -> Iterator[None]:
+    match key_file, key:
+        case Path() | str(), _:
+            with temp_environ(SOPS_AGE_KEY_FILE=str(key_file)):
+                yield
+        case None, Secret():
+            with temp_environ(SOPS_AGE_KEY=key.get_secret_value()):
+                yield
+        case None, None:
+            path = xdg_config_home() / "sops/age/keys.txt"
+            with temp_environ(SOPS_AGE_KEY_FILE=str(path)):
+                yield
+        case never:
+            assert_never(never)
+
+
+def _get_recipient() -> str:
+    try:
+        key_file = environ["SOPS_AGE_KEY_FILE"]
+    except KeyError:
+        with TemporaryFile(text=environ["SOPS_AGE_KEY"]) as temp:
+            return _get_recipient_from_path(temp)
+    else:
+        return _get_recipient_from_path(key_file)
+
+
+def _get_recipient_from_path(path: PathLike, /) -> str:
+    recipient, *_ = run("age-keygen", "-y", str(path), return_=True).splitlines()
+    return recipient
+
+
+__all__ = ["re_encrypt"]

actions/re_encrypt/settings.py

@@ -0,0 +1,26 @@
+# ruff: noqa: TC003
+from __future__ import annotations
+
+from pathlib import Path
+
+from typed_settings import Secret, load_settings, option, secret, settings
+
+from actions.utilities import LOADER
+
+
+@settings
+class Settings:
+    key_file: Path | None = option(default=None, help="The key file")
+    key: Secret[str] | None = secret(default=None, help="The age identity")
+    new_key_file: Path | None = option(
+        default=None, help="The new key file for encryption"
+    )
+    new_key: Secret[str] | None = secret(
+        default=None, help="The new age identity for encryption"
+    )
+
+
+SETTINGS = load_settings(Settings, [LOADER])
+
+
+__all__ = ["SETTINGS", "Settings"]

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",