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

actions/pre_commit/utilities.py

@@ -0,0 +1,386 @@
+from __future__ import annotations
+
+import json
+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
+
+import tomlkit
+from libcst import Module, parse_module
+from rich.pretty import pretty_repr
+from tomlkit import TOMLDocument, aot, array, document, string, table
+from tomlkit.items import AoT, Array, Table
+from utilities.functions import ensure_class, ensure_str
+from utilities.iterables import OneEmptyError, OneNonUniqueError, one
+from utilities.packaging import Requirement
+from utilities.types import PathLike
+
+from actions.constants import YAML_INSTANCE
+from actions.logging import LOGGER
+from actions.types import StrDict
+from actions.utilities import are_equal_modulo_new_line, write_text, yaml_dump
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator, MutableSet
+
+    from utilities.types import PathLike
+
+    from actions.types import FuncRequirement, HasAppend, HasSetDefault, StrDict
+
+
+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)
+    for obj in objs:
+        if obj not in array:
+            array.append(obj)
+
+
+def ensure_contains_partial_dict(
+    container: HasAppend, partial: StrDict, /, *, extra: StrDict | None = None
+) -> StrDict:
+    try:
+        return get_partial_dict(container, partial, skip_log=True)
+    except OneEmptyError:
+        dict_ = partial | ({} if extra is None else extra)
+        container.append(dict_)
+        return dict_
+
+
+def ensure_contains_partial_str(container: HasAppend, text: str, /) -> str:
+    try:
+        return get_partial_str(container, text, skip_log=True)
+    except OneEmptyError:
+        container.append(text)
+        return text
+
+
+def ensure_not_contains(array: Array, /, *objs: Any) -> None:
+    for obj in objs:
+        try:
+            index = next(i for i, o in enumerate(array) if o == obj)
+        except StopIteration:
+            pass
+        else:
+            del array[index]
+
+
+##
+
+
+def get_aot(container: HasSetDefault, key: str, /) -> AoT:
+    return ensure_class(container.setdefault(key, aot()), AoT)
+
+
+def get_array(container: HasSetDefault, key: str, /) -> Array:
+    return ensure_class(container.setdefault(key, array()), Array)
+
+
+def get_dict(container: HasSetDefault, key: str, /) -> StrDict:
+    return ensure_class(container.setdefault(key, {}), dict)
+
+
+def get_list(container: HasSetDefault, key: str, /) -> list[Any]:
+    return ensure_class(container.setdefault(key, []), list)
+
+
+def get_table(container: HasSetDefault, key: str, /) -> Table:
+    return ensure_class(container.setdefault(key, table()), Table)
+
+
+##
+
+
+def get_partial_dict(
+    iterable: Iterable[Any], dict_: StrDict, /, *, skip_log: bool = False
+) -> StrDict:
+    try:
+        return one(i for i in iterable if is_partial_dict(dict_, i))
+    except OneEmptyError:
+        if not skip_log:
+            LOGGER.exception(
+                "Expected %s to contain %s (as a partial)",
+                pretty_repr(iterable),
+                pretty_repr(dict_),
+            )
+        raise
+    except OneNonUniqueError as error:
+        LOGGER.exception(
+            "Expected %s to contain %s uniquely (as a partial); got %s, %s and perhaps more",
+            pretty_repr(iterable),
+            pretty_repr(dict_),
+            pretty_repr(error.first),
+            pretty_repr(error.second),
+        )
+        raise
+
+
+def is_partial_dict(obj: Any, dict_: StrDict, /) -> bool:
+    if not isinstance(obj, dict):
+        return False
+    results: dict[str, bool] = {}
+    for key, obj_value in obj.items():
+        try:
+            dict_value = dict_[key]
+        except KeyError:
+            results[key] = False
+        else:
+            if isinstance(obj_value, dict) and isinstance(dict_value, dict):
+                results[key] = is_partial_dict(obj_value, dict_value)
+            else:
+                results[key] = obj_value == dict_value
+    return all(results.values())
+
+
+##
+
+
+def get_partial_str(
+    iterable: Iterable[Any], text: str, /, *, skip_log: bool = False
+) -> str:
+    try:
+        return one(i for i in iterable if is_partial_str(i, text))
+    except OneEmptyError:
+        if not skip_log:
+            LOGGER.exception(
+                "Expected %s to contain %s (as a partial)",
+                pretty_repr(iterable),
+                pretty_repr(text),
+            )
+        raise
+    except OneNonUniqueError as error:
+        LOGGER.exception(
+            "Expected %s to contain %s uniquely (as a partial); got %s, %s and perhaps more",
+            pretty_repr(iterable),
+            pretty_repr(text),
+            pretty_repr(error.first),
+            pretty_repr(error.second),
+        )
+        raise
+
+
+def is_partial_str(obj: Any, text: str, /) -> bool:
+    return isinstance(obj, str) and (text in obj)
+
+
+##
+
+
+def get_pyproject_dependencies(doc: TOMLDocument, /) -> PyProjectDependencies:
+    out = PyProjectDependencies()
+    if (project_key := "project") in doc:
+        project = get_table(doc, project_key)
+        if (dep_key := "dependencies") in project:
+            out.dependencies = get_array(project, dep_key)
+        if (opt_dep_key := "optional-dependencies") in project:
+            opt_dependencies = get_table(project, opt_dep_key)
+            out.opt_dependencies = {}
+            for key in opt_dependencies:
+                out.opt_dependencies[ensure_str(key)] = get_array(opt_dependencies, key)
+    if (dep_grps_key := "dependency-groups") in doc:
+        dep_grps = get_table(doc, dep_grps_key)
+        out.dep_groups = {}
+        for key in dep_grps:
+            out.dep_groups[ensure_str(key)] = get_array(dep_grps, key)
+    return out
+
+
+@dataclass(kw_only=True, slots=True)
+class PyProjectDependencies:
+    dependencies: Array | None = None
+    opt_dependencies: dict[str, Array] | None = None
+    dep_groups: dict[str, Array] | None = None
+
+    def apply(self, func: FuncRequirement, /) -> None:
+        if (deps := self.dependencies) is not None:
+            self._apply_to_array(deps, func)
+        if (opt_depedencies := self.opt_dependencies) is not None:
+            for deps in opt_depedencies.values():
+                self._apply_to_array(deps, func)
+        if (dep_grps := self.dep_groups) is not None:
+            for deps in dep_grps.values():
+                self._apply_to_array(deps, func)
+
+    def _apply_to_array(self, array: Array, func: FuncRequirement, /) -> None:
+        strs = list(map(ensure_str, array))
+        reqs = list(map(Requirement, strs))
+        results = list(map(func, reqs))
+        new_strs = list(map(str, results))
+        strings = list(map(string, new_strs))
+        array.clear()
+        ensure_contains(array, *strings)
+
+
+##
+
+
+@contextmanager
+def yield_json_dict(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> Iterator[StrDict]:
+    with yield_mutable_write_context(
+        path, json.loads, dict, json.dumps, modifications=modifications
+    ) as dict_:
+        yield dict_
+
+
+##
+
+
+@contextmanager
+def yield_python_file(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> Iterator[WriteContext[Module]]:
+    with yield_immutable_write_context(
+        path,
+        parse_module,
+        lambda: Module(body=[]),
+        lambda module: module.code,
+        modifications=modifications,
+    ) as context:
+        yield context
+
+
+##
+
+
+@contextmanager
+def yield_text_file(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> Iterator[WriteContext[str]]:
+    with yield_immutable_write_context(
+        path, str, lambda: "", str, modifications=modifications
+    ) as context:
+        yield context
+
+
+##
+
+
+@contextmanager
+def yield_toml_doc(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> Iterator[TOMLDocument]:
+    with yield_mutable_write_context(
+        path, tomlkit.parse, document, tomlkit.dumps, modifications=modifications
+    ) as doc:
+        yield doc
+
+
+##
+
+
+@contextmanager
+def yield_mutable_write_context[T](
+    path: PathLike,
+    loads: Callable[[str], T],
+    get_default: Callable[[], T],
+    dumps: Callable[[T], str],
+    /,
+    *,
+    modifications: MutableSet[Path] | None = None,
+) -> Iterator[T]:
+    with yield_immutable_write_context(
+        path, loads, get_default, dumps, modifications=modifications
+    ) as context:
+        yield context.output
+
+
+##
+
+
+@dataclass(kw_only=True, slots=True)
+class WriteContext[T]:
+    input: T
+    output: T
+
+
+@contextmanager
+def yield_immutable_write_context[T](
+    path: PathLike,
+    loads: Callable[[str], T],
+    get_default: Callable[[], T],
+    dumps: Callable[[T], str],
+    /,
+    *,
+    modifications: MutableSet[Path] | None = None,
+) -> Iterator[WriteContext[T]]:
+    try:
+        current = Path(path).read_text()
+    except FileNotFoundError:
+        current = None
+        input_ = get_default()
+        output = get_default()
+    else:
+        input_ = loads(current)
+        output = loads(current)
+    yield (context := WriteContext(input=input_, output=output))
+    if current is None:
+        write_text(path, dumps(context.output), modifications=modifications)
+    else:
+        match context.output, loads(current):
+            case Module() as output_module, Module() as current_module:
+                if not are_equal_modulo_new_line(
+                    output_module.code, current_module.code
+                ):
+                    write_text(path, dumps(output_module), modifications=modifications)
+            case TOMLDocument() as output_doc, TOMLDocument() as current_doc:
+                if not (output_doc == current_doc):  # noqa: SIM201
+                    write_text(path, dumps(output_doc), modifications=modifications)
+            case str() as output_text, str() as current_text:
+                if not are_equal_modulo_new_line(output_text, current_text):
+                    write_text(path, dumps(output_text), modifications=modifications)
+            case output_obj, current_obj:
+                if output_obj != current_obj:
+                    write_text(path, dumps(output_obj), modifications=modifications)
+            case never:
+                assert_never(never)
+
+
+##
+
+
+@contextmanager
+def yield_yaml_dict(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> Iterator[StrDict]:
+    with yield_mutable_write_context(
+        path, YAML_INSTANCE.load, dict, yaml_dump, modifications=modifications
+    ) as dict_:
+        yield dict_
+
+
+__all__ = [
+    "PyProjectDependencies",
+    "ensure_aot_contains",
+    "ensure_contains",
+    "ensure_contains_partial_dict",
+    "ensure_contains_partial_str",
+    "ensure_not_contains",
+    "get_aot",
+    "get_array",
+    "get_dict",
+    "get_list",
+    "get_partial_dict",
+    "get_partial_str",
+    "get_pyproject_dependencies",
+    "get_table",
+    "is_partial_dict",
+    "is_partial_str",
+    "yield_immutable_write_context",
+    "yield_json_dict",
+    "yield_mutable_write_context",
+    "yield_python_file",
+    "yield_text_file",
+    "yield_toml_doc",
+    "yield_yaml_dict",
+]

actions/publish_package/cli.py

@@ -1,38 +1,26 @@
 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.publish_package.lib import publish_package
 from actions.publish_package.settings import Settings
 from actions.utilities import LOADER
 
 
-@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="publish")
-def publish_package_sub_cmd(*, publish: Settings) -> None:
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def publish_package_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
-        """),
-        publish_package.__name__,
-        __version__,
-        pretty_repr(publish),
-    )
     publish_package(
-        username=publish.username,
-        password=publish.password,
-        publish_url=publish.publish_url,
-        trusted_publishing=publish.trusted_publishing,
-        native_tls=publish.native_tls,
+        username=settings.username,
+        password=settings.password,
+        publish_url=settings.publish_url,
+        trusted_publishing=settings.trusted_publishing,
+        native_tls=settings.native_tls,
     )
 
 

actions/publish_package/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+PUBLISH_PACKAGE_DOCSTRING = "Build and publish the package"
+PUBLISH_PACKAGE_SUB_CMD = "publish-package"
+
+
+__all__ = ["PUBLISH_PACKAGE_DOCSTRING", "PUBLISH_PACKAGE_SUB_CMD"]

actions/publish_package/lib.py

@@ -8,7 +8,7 @@ from utilities.text import strip_and_dedent
 from actions import __version__
 from actions.logging import LOGGER
 from actions.publish_package.settings import SETTINGS
-from actions.utilities import log_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from typed_settings import Secret
@@ -40,8 +40,8 @@ def publish_package(
         native_tls,
     )
     with TemporaryDirectory() as temp:
-        log_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
-        log_run(
+        logged_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
+        logged_run(
             "uv",
             "publish",
             *([] if username is None else ["--username", username]),

actions/random_sleep/cli.py

@@ -1,34 +1,25 @@
 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.random_sleep.lib import random_sleep
 from actions.random_sleep.settings import Settings
 from actions.utilities import LOADER
 
 
-@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="sleep")
-def random_sleep_sub_cmd(*, sleep: Settings) -> None:
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def random_sleep_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
-        """),
-        random_sleep.__name__,
-        __version__,
-        pretty_repr(sleep),
-    )
     random_sleep(
-        min_=sleep.min, max_=sleep.max, step=sleep.step, log_freq=sleep.log_freq
+        min_=settings.min,
+        max_=settings.max,
+        step=settings.step,
+        log_freq=settings.log_freq,
     )
 
 

actions/random_sleep/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+RANDOM_SLEEP_DOCSTRING = "Random sleep with logging"
+RANDOM_SLEEP_SUB_CMD = "random-sleep"
+
+
+__all__ = ["RANDOM_SLEEP_DOCSTRING", "RANDOM_SLEEP_SUB_CMD"]

actions/register_gitea_runner/__init__.py

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

actions/register_gitea_runner/cli.py

@@ -0,0 +1,32 @@
+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.register_gitea_runner.lib import register_gitea_runner
+from actions.register_gitea_runner.settings import Settings
+from actions.utilities import LOADER
+
+
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def register_gitea_runner_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    register_gitea_runner(
+        ssh_user=settings.ssh_user,
+        ssh_host=settings.ssh_host,
+        gitea_container_user=settings.gitea_container_user,
+        gitea_container_name=settings.gitea_container_name,
+        runner_certificate=settings.runner_certificate,
+        runner_capacity=settings.runner_capacity,
+        runner_container_name=settings.runner_container_name,
+        gitea_host=settings.gitea_host,
+        gitea_port=settings.gitea_port,
+        runner_instance_name=settings.runner_instance_name,
+    )
+
+
+__all__ = ["register_gitea_runner_sub_cmd"]

actions/register_gitea_runner/configs/config.yml

@@ -0,0 +1,110 @@
+# Example configuration file, it's safe to copy this as the default config file without any modification.
+
+# You don't have to copy this file to your instance,
+# just run `./act_runner generate-config > config.yaml` to generate a config file.
+
+log:
+  # The level of logging, can be trace, debug, info, warn, error, fatal
+  level: info
+
+runner:
+  # Where to store the registration result.
+  file: .runner
+  # Execute how many tasks concurrently at the same time.
+  capacity: ${CAPACITY}
+  # Extra environment variables to run jobs.
+  envs:
+    A_TEST_ENV_NAME_1: a_test_env_value_1
+    A_TEST_ENV_NAME_2: a_test_env_value_2
+  # Extra environment variables to run jobs from a file.
+  # It will be ignored if it's empty or the file doesn't exist.
+  env_file: .env
+  # The timeout for a job to be finished.
+  # Please note that the Gitea instance also has a timeout (3h by default) for the job.
+  # So the job could be stopped by the Gitea instance if it's timeout is shorter than this.
+  timeout: 3h
+  # The timeout for the runner to wait for running jobs to finish when shutting down.
+  # Any running jobs that haven't finished after this timeout will be cancelled.
+  shutdown_timeout: 0s
+  # Whether skip verifying the TLS certificate of the Gitea instance.
+  insecure: false
+  # The timeout for fetching the job from the Gitea instance.
+  fetch_timeout: 5s
+  # The interval for fetching the job from the Gitea instance.
+  fetch_interval: 2s
+  # The github_mirror of a runner is used to specify the mirror address of the github that pulls the action repository.
+  # It works when something like `uses: actions/checkout@v4` is used and DEFAULT_ACTIONS_URL is set to github,
+  # and github_mirror is not empty. In this case,
+  # it replaces https://github.com with the value here, which is useful for some special network environments.
+  github_mirror: ""
+  # The labels of a runner are used to determine which jobs the runner can run, and how to run them.
+  # Like: "macos-arm64:host" or "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
+  # Find more images provided by Gitea at https://gitea.com/docker.gitea.com/runner-images .
+  # If it's empty when registering, it will ask for inputting labels.
+  # If it's empty when execute `daemon`, will use labels in `.runner` file.
+  labels:
+    - "ubuntu-latest:docker://docker.gitea.com/runner-images:ubuntu-latest"
+    - "ubuntu-22.04:docker://docker.gitea.com/runner-images:ubuntu-22.04"
+    - "ubuntu-20.04:docker://docker.gitea.com/runner-images:ubuntu-20.04"
+
+cache:
+  # Enable cache server to use actions/cache.
+  enabled: true
+  # The directory to store the cache data.
+  # If it's empty, the cache data will be stored in ${HOME}/.cache/actcache.
+  dir: ""
+  # The host of the cache server.
+  # It's not for the address to listen, but the address to connect from job containers.
+  # So 0.0.0.0 is a bad choice, leave it empty to detect automatically.
+  host: ""
+  # The port of the cache server.
+  # 0 means to use a random available port.
+  port: 0
+  # The external cache server URL. Valid only when enable is true.
+  # If it's specified, act_runner will use this URL as the ACTIONS_CACHE_URL rather than start a server by itself.
+  # The URL should generally end with "/".
+  external_server: ""
+
+container:
+  # Specifies the network to which the container will connect.
+  # Could be host, bridge or the name of a custom network.
+  # If it's empty, act_runner will create a network automatically.
+  network: ""
+  # Whether to use privileged mode or not when launching task containers (privileged mode is required for Docker-in-Docker).
+  privileged: false
+  # And other options to be used when the container is started (eg, --add-host=my.gitea.url:host-gateway).
+  options: "-v ${CERTIFICATE}:/usr/local/share/ca-certificates/root.crt:ro"
+  # The parent directory of a job's working directory.
+  # NOTE: There is no need to add the first '/' of the path as act_runner will add it automatically.
+  # If the path starts with '/', the '/' will be trimmed.
+  # For example, if the parent directory is /path/to/my/dir, workdir_parent should be path/to/my/dir
+  # If it's empty, /workspace will be used.
+  workdir_parent:
+  # Volumes (including bind mounts) can be mounted to containers. Glob syntax is supported, see https://github.com/gobwas/glob
+  # You can specify multiple volumes. If the sequence is empty, no volumes can be mounted.
+  # For example, if you only allow containers to mount the `data` volume and all the json files in `/src`, you should change the config to:
+  # valid_volumes:
+  #   - data
+  #   - /src/*.json
+  # If you want to allow any volume, please use the following configuration:
+  # valid_volumes:
+  #   - '**'
+  valid_volumes: ["**"]
+  # overrides the docker client host with the specified one.
+  # If it's empty, act_runner will find an available docker host automatically.
+  # If it's "-", act_runner will find an available docker host automatically, but the docker host won't be mounted to the job containers and service containers.
+  # If it's not empty or "-", the specified docker host will be used. An error will be returned if it doesn't work.
+  docker_host: ""
+  # Pull docker image(s) even if already present
+  force_pull: true
+  # Rebuild docker image(s) even if already present
+  force_rebuild: false
+  # Always require a reachable docker daemon, even if not required by act_runner
+  require_docker: false
+  # Timeout to wait for the docker daemon to be reachable, if docker is required by require_docker or act_runner
+  docker_timeout: 0s
+
+host:
+  # The parent directory of a job's working directory.
+  # If it's empty, ${HOME}/.cache/act/ will be used.
+  workdir_parent:

actions/register_gitea_runner/configs/entrypoint.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env sh
+set -euxo
+
+# echo
+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"
+
+if ! command -v update-ca-certificates >/dev/null 2>&1; then
+    echo_date "Installing 'ca-certificates'..."
+    apk update
+    apk add --no-cache ca-certificates
+fi
+
+update-ca-certificates || true
+
+exec /sbin/tini -- run.sh