dycw-actions 0.6.4__py3-none-any.whl → 0.7.1__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/run_hooks/cli.py

@@ -1,33 +1,21 @@
 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:
+@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)
-    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)
+    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

@@ -14,7 +14,7 @@ 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
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -77,7 +77,7 @@ def _yield_repo_hooks(repo: dict[str, Any], /) -> Iterator[str]:
 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)
+        logged_run("pre-commit", "run", "--verbose", "--all-files", hook, print=True)
     except CalledProcessError:
         is_success = False
     else:

actions/setup_cronjob/cli.py

@@ -1,12 +1,9 @@
 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
@@ -18,15 +15,6 @@ 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,

actions/setup_cronjob/constants.py

@@ -5,4 +5,8 @@ from actions.constants import PATH_ACTIONS
 PATH_CONFIGS = PATH_ACTIONS / "setup_cronjob/configs"
 
 
-__all__ = ["PATH_CONFIGS"]
+SETUP_CRONJOB_SUB_CMD = "setup-cronjob"
+SETUP_CRONJOB_DOCSTRING = "Setup a cronjob"
+
+
+__all__ = ["PATH_CONFIGS", "SETUP_CRONJOB_DOCSTRING", "SETUP_CRONJOB_SUB_CMD"]

actions/tag_commit/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.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:
+@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)
-    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,
+        user_name=settings.user_name,
+        user_email=settings.user_email,
+        major_minor=settings.major_minor,
+        major=settings.major,
+        latest=settings.latest,
     )
 
 

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