dycw-actions 0.3.40__py3-none-any.whl

actions/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__version__ = "0.3.40"

actions/cli.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from click import group
+from utilities.click import CONTEXT_SETTINGS
+
+from actions.hooks.cli import hooks_sub_cmd
+from actions.publish.cli import publish_sub_cmd
+from actions.requirements.cli import requirements_sub_cmd
+from actions.sequence_strs.cli import sequence_strs_sub_cmd
+from actions.sleep.cli import sleep_sub_cmd
+from actions.tag.cli import tag_sub_cmd
+
+
+@group(**CONTEXT_SETTINGS)
+def _main() -> None: ...
+
+
+_ = _main.command(name="hooks", **CONTEXT_SETTINGS)(hooks_sub_cmd)
+_ = _main.command(name="publish", **CONTEXT_SETTINGS)(publish_sub_cmd)
+_ = _main.command(name="requirements", **CONTEXT_SETTINGS)(requirements_sub_cmd)
+_ = _main.command(name="sequence-strs", **CONTEXT_SETTINGS)(sequence_strs_sub_cmd)
+_ = _main.command(name="sleep", **CONTEXT_SETTINGS)(sleep_sub_cmd)
+_ = _main.command(name="tag", **CONTEXT_SETTINGS)(tag_sub_cmd)
+
+
+if __name__ == "__main__":
+    _main()

actions/conformalize/__init__.py

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

actions/conformalize/defaults.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+GITHUB_TOKEN = "${{github.token}}"  # noqa: S105
+PRERELEASE = "disallow"
+RESOLUTION = "highest"
+
+
+__all__ = ["GITHUB_TOKEN", "PRERELEASE", "RESOLUTION"]

actions/conformalize/dicts.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from actions.conformalize.defaults import GITHUB_TOKEN, PRERELEASE, RESOLUTION
+
+if TYPE_CHECKING:
+    from actions.types import StrDict
+
+
+def run_action_pre_commit_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    submodules: str | None = None,
+    token_uv: str = GITHUB_TOKEN,
+    repos: Any | None = None,
+    hooks: Any | None = None,
+    sleep: int = 1,
+) -> StrDict:
+    dict_: StrDict = {"token-checkout": token_checkout}
+    _add_item(dict_, "submodules", value=submodules)
+    dict_["token-uv"] = token_uv
+    _add_item(dict_, "repos", value=repos)
+    _add_item(dict_, "hooks", value=hooks)
+    dict_["sleep"] = sleep
+    return {
+        "name": "Run 'pre-commit'",
+        "uses": "dycw/action-pre-commit@latest",
+        "with": dict_,
+    }
+
+
+def run_action_publish_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    token_uv: str = GITHUB_TOKEN,
+    username: str | None = None,
+    password: str | None = None,
+    publish_url: str | None = None,
+    trusted_publishing: bool = False,
+    native_tls: bool = False,
+) -> StrDict:
+    dict_: StrDict = {"token-checkout": token_checkout, "token-uv": token_uv}
+    _add_item(dict_, "username", value=username)
+    _add_item(dict_, "password", value=password)
+    _add_item(dict_, "publish-url", value=publish_url)
+    _add_boolean(dict_, "trusted-publishing", value=trusted_publishing)
+    _add_native_tls(dict_, native_tls=native_tls)
+    return {
+        "name": "Build and publish package",
+        "uses": "dycw/action-publish@latest",
+        "with": dict_,
+    }
+
+
+def run_action_pyright_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    token_uv: str = GITHUB_TOKEN,
+    python_version: str | None = None,
+    resolution: str = RESOLUTION,
+    prerelease: str = PRERELEASE,
+    native_tls: bool = False,
+    with_requirements: str | None = None,
+) -> StrDict:
+    dict_: StrDict = {"token-checkout": token_checkout, "token-uv": token_uv}
+    _add_python_version(dict_, python_version=python_version)
+    dict_["resolution"] = resolution
+    dict_["prerelease"] = prerelease
+    _add_native_tls(dict_, native_tls=native_tls)
+    _add_with_requirements(dict_, with_requirements=with_requirements)
+    return {
+        "name": "Run 'pyright'",
+        "uses": "dycw/action-pyright@latest",
+        "with": dict_,
+    }
+
+
+def run_action_pytest_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    token_uv: str = GITHUB_TOKEN,
+    python_version: str | None = None,
+    resolution: str = RESOLUTION,
+    prerelease: str = PRERELEASE,
+    native_tls: bool = False,
+    with_requirements: str | None = None,
+) -> StrDict:
+    dict_: StrDict = {"token-checkout": token_checkout, "token-uv": token_uv}
+    _add_python_version(dict_, python_version=python_version)
+    dict_["resolution"] = resolution
+    dict_["prerelease"] = prerelease
+    _add_native_tls(dict_, native_tls=native_tls)
+    _add_with_requirements(dict_, with_requirements=with_requirements)
+    return {"name": "Run 'pytest'", "uses": "dycw/action-pytest@latest", "with": dict_}
+
+
+def run_action_random_sleep_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    token_uv: str = GITHUB_TOKEN,
+    min: int = 0,  # noqa: A002
+    max: int = 3600,  # noqa: A002
+    step: int = 1,
+    log_freq: int = 1,
+) -> StrDict:
+    dict_: StrDict = {
+        "token-checkout": token_checkout,
+        "token-uv": token_uv,
+        "min": min,
+        "max": max,
+        "step": step,
+        "log-freq": log_freq,
+    }
+    return {
+        "name": "Tag latest commit",
+        "uses": "dycw/action-tag@latest",
+        "with": dict_,
+    }
+
+
+def run_action_ruff_dict(
+    *, token_checkout: str = GITHUB_TOKEN, token_ruff: str = GITHUB_TOKEN
+) -> StrDict:
+    dict_: StrDict = {"token-checkout": token_checkout, "token-ruff": token_ruff}
+    return {"name": "Run 'ruff'", "uses": "dycw/action-ruff@latest", "with": dict_}
+
+
+def run_action_tag_dict(
+    *,
+    token_checkout: str = GITHUB_TOKEN,
+    token_uv: str = GITHUB_TOKEN,
+    user_name: str = "github-actions-bot",
+    user_email: str = "noreply@github.com",
+    major_minor: bool = False,
+    major: bool = False,
+    latest: bool = False,
+) -> StrDict:
+    dict_: StrDict = {
+        "token-checkout": token_checkout,
+        "token-uv": token_uv,
+        "user-name": user_name,
+        "user-email": user_email,
+    }
+    _add_boolean(dict_, "major-minor", value=major_minor)
+    _add_boolean(dict_, "major", value=major)
+    _add_boolean(dict_, "latest", value=latest)
+    return {
+        "name": "Tag latest commit",
+        "uses": "dycw/action-tag@latest",
+        "with": dict_,
+    }
+
+
+def _add_boolean(dict_: StrDict, key: str, /, *, value: bool = False) -> None:
+    if value:
+        dict_[key] = value
+
+
+def _add_item(dict_: StrDict, key: str, /, *, value: Any | None = None) -> None:
+    if value is not None:
+        dict_[key] = value
+
+
+def _add_native_tls(dict_: StrDict, /, *, native_tls: bool = False) -> None:
+    _add_boolean(dict_, "native-tls", value=native_tls)
+
+
+def _add_python_version(
+    dict_: StrDict, /, *, python_version: str | None = None
+) -> None:
+    _add_item(dict_, "python-version", value=python_version)
+
+
+def _add_with_requirements(
+    dict_: StrDict, /, *, with_requirements: str | None = None
+) -> None:
+    _add_item(dict_, "with-requirements", value=with_requirements)
+
+
+__all__ = [
+    "run_action_pre_commit_dict",
+    "run_action_publish_dict",
+    "run_action_pyright_dict",
+    "run_action_pytest_dict",
+    "run_action_random_sleep_dict",
+    "run_action_ruff_dict",
+    "run_action_tag_dict",
+]

actions/hooks/__init__.py

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

actions/hooks/cli.py

@@ -0,0 +1,37 @@
+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.hooks.lib import run_hooks
+from actions.hooks.settings import HooksSettings
+from actions.logging import LOGGER
+from actions.settings import CommonSettings
+from actions.utilities import LOADER
+
+
+@click_options(CommonSettings, [LOADER], show_envvars_in_help=True, argname="common")
+@click_options(HooksSettings, [LOADER], show_envvars_in_help=True, argname="hooks")
+def hooks_sub_cmd(*, common: CommonSettings, hooks: HooksSettings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+            %s
+        """),
+        run_hooks.__name__,
+        __version__,
+        pretty_repr(common),
+        pretty_repr(hooks),
+    )
+    run_hooks(repos=hooks.repos, hooks=hooks.hooks, sleep=hooks.sleep)
+
+
+__all__ = ["hooks_sub_cmd"]

actions/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.hooks.settings import HOOKS_SETTINGS
+from actions.logging import LOGGER
+from actions.utilities import log_run
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def run_hooks(
+    *,
+    repos: list[str] | None = HOOKS_SETTINGS.repos,
+    hooks: list[str] | None = HOOKS_SETTINGS.hooks,
+    sleep: int = HOOKS_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 = HOOKS_SETTINGS.repos,
+    hooks: list[str] | None = HOOKS_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 = HOOKS_SETTINGS.sleep) -> bool:
+    LOGGER.info("Running '%s'...", hook)
+    try:
+        log_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/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 HooksSettings:
+    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")
+
+
+HOOKS_SETTINGS = load_settings(HooksSettings, [LOADER])
+
+
+__all__ = ["HOOKS_SETTINGS", "HooksSettings"]

actions/logging.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from logging import getLogger
+
+LOGGER = getLogger("actions")
+
+
+__all__ = ["LOGGER"]

actions/publish/__init__.py

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

actions/publish/cli.py

@@ -0,0 +1,43 @@
+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.lib import publish_package
+from actions.publish.settings import PublishSettings
+from actions.settings import CommonSettings
+from actions.utilities import LOADER
+
+
+@click_options(CommonSettings, [LOADER], show_envvars_in_help=True, argname="common")
+@click_options(PublishSettings, [LOADER], show_envvars_in_help=True, argname="publish")
+def publish_sub_cmd(*, common: CommonSettings, publish: PublishSettings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+            %s
+        """),
+        publish_package.__name__,
+        __version__,
+        pretty_repr(common),
+        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,
+    )
+
+
+__all__ = ["publish_sub_cmd"]

actions/publish/lib.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from utilities.tempfile import TemporaryDirectory
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.publish.settings import PUBLISH_SETTINGS
+from actions.utilities import log_run
+
+if TYPE_CHECKING:
+    from typed_settings import Secret
+
+
+def publish_package(
+    *,
+    username: str | None = PUBLISH_SETTINGS.username,
+    password: Secret[str] | None = PUBLISH_SETTINGS.password,
+    publish_url: str | None = PUBLISH_SETTINGS.publish_url,
+    trusted_publishing: bool = PUBLISH_SETTINGS.trusted_publishing,
+    native_tls: bool = PUBLISH_SETTINGS.native_tls,
+) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - username           = %s
+             - password           = %s
+             - publish_url        = %s
+             - trusted_publishing = %s
+             - native_tls         = %s
+        """),
+        publish_package.__name__,
+        __version__,
+        username,
+        password,
+        publish_url,
+        trusted_publishing,
+        native_tls,
+    )
+    with TemporaryDirectory() as temp:
+        log_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
+        log_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}/*",
+        )
+
+
+__all__ = ["publish_package"]

actions/publish/settings.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typed_settings import Secret, load_settings, option, secret, settings
+
+from actions.utilities import LOADER, convert_secret_str, convert_str
+
+
+@settings
+class PublishSettings:
+    username: str | None = option(
+        default=None, converter=convert_str, help="The username of the upload"
+    )
+    password: Secret[str] | None = secret(
+        default=None, converter=convert_secret_str, help="The password for the upload"
+    )
+    publish_url: str | None = option(
+        default=None, converter=convert_str, help="The URL of the upload endpoint"
+    )
+    trusted_publishing: bool = option(
+        default=False, help="Configure trusted publishing"
+    )
+    native_tls: bool = option(
+        default=False,
+        help="Whether to load TLS certificates from the platform's native certificate store",
+    )
+
+
+PUBLISH_SETTINGS = load_settings(PublishSettings, [LOADER])
+
+
+__all__ = ["PUBLISH_SETTINGS", "PublishSettings"]

actions/requirements/__init__.py

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

actions/requirements/cli.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from click import argument
+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.requirements.lib import format_requirements
+
+
+@argument(
+    "paths",
+    nargs=-1,
+    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
+)
+def requirements_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        format_requirements.__name__,
+        __version__,
+        paths,
+    )
+    format_requirements(*paths)
+
+
+__all__ = ["requirements_sub_cmd"]

actions/requirements/lib.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, override
+
+from packaging._tokenizer import ParserSyntaxError
+from packaging.requirements import InvalidRequirement, Requirement, _parse_requirement
+from packaging.specifiers import Specifier, SpecifierSet
+from tomlkit import TOMLDocument, array, dumps, loads, string
+from tomlkit.items import Array, Table
+from utilities.text import repr_str, strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from utilities.types import PathLike
+
+
+_MODIFICATIONS: set[Path] = set()
+
+
+def format_requirements(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        format_requirements.__name__,
+        __version__,
+        paths,
+    )
+    for path in paths:
+        _format_path(path)
+    if len(_MODIFICATIONS) >= 1:
+        LOGGER.info(
+            "Exiting due to modifications: %s",
+            ", ".join(map(repr_str, sorted(_MODIFICATIONS))),
+        )
+        sys.exit(1)
+
+
+def _format_path(path: PathLike, /) -> None:
+    path = Path(path)
+    current = loads(path.read_text())
+    expected = _get_formatted(path)
+    is_equal = current == expected  # tomlkit cannot handle !=
+    if not is_equal:
+        _ = path.write_text(dumps(expected).rstrip("\n") + "\n")
+        _MODIFICATIONS.add(path)
+
+
+def _get_formatted(path: PathLike, /) -> TOMLDocument:
+    path = Path(path)
+    doc = loads(path.read_text())
+    if isinstance(dep_grps := doc.get("dependency-groups"), Table):
+        for key, value in dep_grps.items():
+            if isinstance(value, Array):
+                dep_grps[key] = _format_array(value)
+    if isinstance(project := doc["project"], Table):
+        if isinstance(deps := project["dependencies"], Array):
+            project["dependencies"] = _format_array(deps)
+        if isinstance(optional := project.get("optional-dependencies"), Table):
+            for key, value in optional.items():
+                if isinstance(value, Array):
+                    optional[key] = _format_array(value)
+    return doc
+
+
+def _format_array(dependencies: Array, /) -> Array:
+    new = array().multiline(multiline=True)
+    new.extend(map(_format_item, dependencies))
+    return new
+
+
+def _format_item(item: Any, /) -> Any:
+    if not isinstance(item, str):
+        return item
+    return string(str(_CustomRequirement(item)))
+
+
+class _CustomRequirement(Requirement):
+    @override
+    def __init__(self, requirement_string: str) -> None:
+        super().__init__(requirement_string)
+        try:
+            parsed = _parse_requirement(requirement_string)
+        except ParserSyntaxError as e:
+            raise InvalidRequirement(str(e)) from e
+        self.specifier = _CustomSpecifierSet(parsed.specifier)
+
+    @override
+    def _iter_parts(self, name: str) -> Iterator[str]:
+        yield name
+        if self.extras:
+            formatted_extras = ",".join(sorted(self.extras))
+            yield f"[{formatted_extras}]"
+        if self.specifier:
+            yield f" {self.specifier}"
+        if self.url:
+            yield f"@ {self.url}"
+            if self.marker:
+                yield " "
+        if self.marker:
+            yield f"; {self.marker}"
+
+
+class _CustomSpecifierSet(SpecifierSet):
+    @override
+    def __str__(self) -> str:
+        specs = sorted(self._specs, key=self._key)
+        return ", ".join(map(str, specs))
+
+    def _key(self, spec: Specifier, /) -> int:
+        return [">=", "<"].index(spec.operator)
+
+
+__all__ = ["format_requirements"]

actions/sequence_strs/__init__.py

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

actions/sequence_strs/cli.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from click import argument
+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.sequence_strs.lib import replace_sequence_strs
+
+
+@argument(
+    "paths",
+    nargs=-1,
+    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
+)
+def sequence_strs_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        replace_sequence_strs.__name__,
+        __version__,
+        paths,
+    )
+    replace_sequence_strs(*paths)
+
+
+__all__ = ["sequence_strs_sub_cmd"]

actions/sequence_strs/lib.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, override
+
+from libcst import CSTTransformer, Module, Name, Subscript, parse_module
+from libcst.matchers import Index as MIndex
+from libcst.matchers import Name as MName
+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.text import repr_str, strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+_MODIFICATIONS: set[Path] = set()
+
+
+def replace_sequence_strs(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        replace_sequence_strs.__name__,
+        __version__,
+        paths,
+    )
+    for path in paths:
+        _format_path(path)
+    if len(_MODIFICATIONS) >= 1:
+        LOGGER.info(
+            "Exiting due to modifications: %s",
+            ", ".join(map(repr_str, sorted(_MODIFICATIONS))),
+        )
+        sys.exit(1)
+
+
+def _format_path(path: PathLike, /) -> None:
+    path = Path(path)
+    current = parse_module(path.read_text())
+    expected = _get_formatted(path)
+    if current.code != expected.code:
+        _ = path.write_text(expected.code.rstrip("\n") + "\n")
+        _MODIFICATIONS.add(path)
+
+
+def _get_formatted(path: PathLike, /) -> Module:
+    path = Path(path)
+    existing = path.read_text()
+    wrapper = MetadataWrapper(parse_module(existing))
+    return wrapper.module.visit(SequenceToListTransformer())
+
+
+class SequenceToListTransformer(CSTTransformer):
+    @override
+    def leave_Subscript(
+        self, original_node: Subscript, updated_node: Subscript
+    ) -> Subscript:
+        _ = original_node
+        if matches(
+            updated_node,
+            MSubscript(
+                value=MName("Sequence"),
+                slice=[MSubscriptElement(slice=MIndex(value=MName("str")))],
+            ),
+        ):
+            return updated_node.with_changes(value=Name("list"))
+        return updated_node
+
+
+__all__ = ["replace_sequence_strs"]

actions/settings.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typed_settings import Secret, load_settings, secret, settings
+
+from actions.utilities import LOADER, convert_secret_str
+
+
+@settings
+class CommonSettings:
+    token: Secret[str] | None = secret(
+        default=None, converter=convert_secret_str, help="GitHub token"
+    )
+
+
+COMMON_SETTINGS = load_settings(CommonSettings, [LOADER])
+
+
+__all__ = ["COMMON_SETTINGS", "CommonSettings"]

actions/sleep/__init__.py

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

actions/sleep/cli.py

@@ -0,0 +1,39 @@
+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.settings import CommonSettings
+from actions.sleep.lib import random_sleep
+from actions.sleep.settings import SleepSettings
+from actions.utilities import LOADER
+
+
+@click_options(CommonSettings, [LOADER], show_envvars_in_help=True, argname="common")
+@click_options(SleepSettings, [LOADER], show_envvars_in_help=True, argname="sleep")
+def sleep_sub_cmd(*, common: CommonSettings, sleep: SleepSettings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+            %s
+        """),
+        random_sleep.__name__,
+        __version__,
+        pretty_repr(common),
+        pretty_repr(sleep),
+    )
+    random_sleep(
+        min_=sleep.min, max_=sleep.max, step=sleep.step, log_freq=sleep.log_freq
+    )
+
+
+__all__ = ["sleep_sub_cmd"]

actions/sleep/lib.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+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
+
+
+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,
+) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - min_     = %s
+             - max_     = %s
+             - step     = %s
+             - log_freq = %s
+        """),
+        random_sleep.__name__,
+        __version__,
+        min_,
+        max_,
+        step,
+        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)
+
+
+def _intermediate(
+    start: ZonedDateTime,
+    now: ZonedDateTime,
+    end: ZonedDateTime,
+    /,
+    *,
+    log_freq: int = SLEEP_SETTINGS.log_freq,
+) -> None:
+    elapsed = TimeDelta(seconds=floor((now - start).in_seconds()))
+    remaining = TimeDelta(seconds=ceil((end - now).in_seconds()))
+    this_sleep = min(remaining, TimeDelta(seconds=log_freq))
+    LOGGER.info(
+        "Sleeping for %s... (elapsed = %s, remaining = %s)",
+        this_sleep,
+        elapsed,
+        remaining,
+    )
+    sleep(round(this_sleep.in_seconds()))
+
+
+__all__ = ["random_sleep"]

actions/sleep/settings.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typed_settings import load_settings, option, settings
+
+from actions.utilities import LOADER
+
+
+@settings
+class SleepSettings:
+    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])
+
+
+__all__ = ["SLEEP_SETTINGS", "SleepSettings"]

actions/tag/__init__.py

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

actions/tag/cli.py

@@ -0,0 +1,43 @@
+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.settings import CommonSettings
+from actions.tag.lib import tag_commit
+from actions.tag.settings import TagSettings
+from actions.utilities import LOADER
+
+
+@click_options(CommonSettings, [LOADER], show_envvars_in_help=True, argname="common")
+@click_options(TagSettings, [LOADER], show_envvars_in_help=True, argname="tag")
+def tag_sub_cmd(*, common: CommonSettings, tag: TagSettings) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+            %s
+            %s
+        """),
+        tag_commit.__name__,
+        __version__,
+        pretty_repr(common),
+        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,
+    )
+
+
+__all__ = ["tag_sub_cmd"]

actions/tag/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.settings import TAG_SETTINGS
+from actions.utilities import log_run
+
+
+def tag_commit(
+    *,
+    user_name: str = TAG_SETTINGS.user_name,
+    user_email: str = TAG_SETTINGS.user_email,
+    major_minor: bool = TAG_SETTINGS.major_minor,
+    major: bool = TAG_SETTINGS.major,
+    latest: bool = TAG_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,
+    )
+    log_run("git", "config", "--global", "user.name", user_name)
+    log_run("git", "config", "--global", "user.email", user_email)
+    version = parse_version(
+        log_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):
+        log_run("git", "tag", "--delete", version)
+    with suppress(CalledProcessError):
+        log_run("git", "push", "--delete", "origin", version)
+    log_run("git", "tag", "-a", version, "HEAD", "-m", version)
+    log_run("git", "push", "--tags", "--force", "--set-upstream", "origin")
+
+
+__all__ = ["tag_commit"]

actions/tag/settings.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typed_settings import load_settings, option, settings
+
+from actions.utilities import LOADER
+
+
+@settings
+class TagSettings:
+    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")
+    major: bool = option(default=False, help="Add the 'major' tag")
+    latest: bool = option(default=False, help="Add the 'latest' tag")
+
+
+TAG_SETTINGS = load_settings(TagSettings, [LOADER])
+
+
+__all__ = ["TAG_SETTINGS", "TagSettings"]

actions/types.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
+from typed_settings import Secret
+
+type SecretLike = str | Secret[str]
+type StrDict = dict[str, Any]
+
+
+__all__ = ["SecretLike", "StrDict"]

actions/utilities.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, assert_never, overload
+
+from typed_settings import EnvLoader, Secret
+from utilities.subprocess import run
+
+from actions.logging import LOGGER
+
+if TYPE_CHECKING:
+    from utilities.types import StrStrMapping
+
+    from actions.types import SecretLike
+
+
+LOADER = EnvLoader("")
+
+
+def convert_list_strs(
+    x: str | list[str] | tuple[str, ...] | None, /
+) -> list[str] | None:
+    match x:
+        case None:
+            return None
+        case list():
+            return x
+        case tuple():
+            return None if x == () else list(x)
+        case str():
+            return x.splitlines()
+        case never:
+            assert_never(never)
+
+
+def convert_secret_str(x: SecretLike | None, /) -> Secret[str] | None:
+    empty = {None, ""}
+    match x:
+        case Secret():
+            return None if x.get_secret_value() in empty else x
+        case str():
+            return None if x in empty else Secret(x)
+        case None:
+            return None
+        case never:
+            assert_never(never)
+
+
+def convert_str(x: str | None, /) -> str | None:
+    match x:
+        case str():
+            return None if x == "" else x
+        case None:
+            return None
+        case never:
+            assert_never(never)
+
+
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: Literal[True],
+) -> str: ...
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: Literal[False] = False,
+) -> None: ...
+@overload
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,
+    return_: bool = False,
+) -> str | None: ...
+def log_run(
+    cmd: SecretLike,
+    /,
+    *cmds: SecretLike,
+    env: StrStrMapping | None = None,
+    print: bool = False,  # noqa: A002
+    return_: bool = False,
+) -> str | None:
+    all_cmds = [cmd, *cmds]
+    LOGGER.info("Running '%s'...", " ".join(map(str, all_cmds)))
+    unwrapped = [c if isinstance(c, str) else c.get_secret_value() for c in all_cmds]
+    return run(*unwrapped, env=env, print=print, return_=return_, logger=LOGGER)
+
+
+__all__ = [
+    "LOADER",
+    "convert_list_strs",
+    "convert_secret_str",
+    "convert_str",
+    "log_run",
+]

dycw_actions-0.3.40.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.3
+Name: dycw-actions
+Version: 0.3.40
+Summary: GitHub actions
+Requires-Dist: click>=8.3.1,<9
+Requires-Dist: dycw-utilities>=0.176.1,<1
+Requires-Dist: libcst>=1.8.6,<2
+Requires-Dist: packaging>=25.0,<26
+Requires-Dist: pyyaml>=6.0.3,<7
+Requires-Dist: rich>=14.2.0,<15
+Requires-Dist: tomlkit>=0.13.3,<1
+Requires-Dist: typed-settings[attrs,click]>=25.3.0,<26
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# `actions`
+
+GitHub actions

dycw_actions-0.3.40.dist-info/RECORD

@@ -0,0 +1,35 @@
+actions/__init__.py,sha256=lw2DhpYl61GrPl9-Oi7xYfsHKXdE7tIgKWgLrQAcRQg,59
+actions/cli.py,sha256=SnlIyfHLjC8uZ6yLhg4S15nqOf9TT81J74rZOqvyqiM,929
+actions/conformalize/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/conformalize/defaults.py,sha256=tYYLr3aRRRvnR6NSADOJMN-B6gtqg2A9gBuheEPyGy4,189
+actions/conformalize/dicts.py,sha256=_l_3y-07bjDq7n8xQgsykrwZ6dEFFIzm0_P3PZMcaRo,5630
+actions/hooks/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/hooks/cli.py,sha256=xV-2TgrDUhkKYbLRVtCglYCu8uWmh0leiYnob66rS5k,1141
+actions/hooks/lib.py,sha256=QNszNiQKzdao-mOWfmwFLR9KaGsUTv46oPKqu3oCt8E,2882
+actions/hooks/settings.py,sha256=gWuBgU5vdN98LM_t5qzJ9cra64M0qA3ULpQ7hmXGNS4,633
+actions/logging.py,sha256=rMTcQMGndUHTCaXXtyOHt_VXUMhQGRHoN7okpoX0y5I,120
+actions/publish/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/publish/cli.py,sha256=OEJSe5dYW06Mmf5JzAthUOFm8K5ZbkwAsUcP6L1kLa0,1334
+actions/publish/lib.py,sha256=0zkNFWGqJcC-2v-3YXWdhO4VcQCX9BCo6uKIOvAFLUw,1785
+actions/publish/settings.py,sha256=mVu2jjQQyFH9TDsh30dscSSB1LlxY493mxRiw31mgQo,972
+actions/requirements/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/requirements/cli.py,sha256=I4Nd14TYnoA2iWbreQyiGcm4NSpstLIRFkOHO2ymX0M,887
+actions/requirements/lib.py,sha256=ovZAolTQQAAMVabBxyWNuY13ENp8-vRnRt1ymFurVhQ,3709
+actions/sequence_strs/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/sequence_strs/cli.py,sha256=YMC8jNXfHjASwkIca3rED8FeE-jgGv5ek04F7G2bIJA,896
+actions/sequence_strs/lib.py,sha256=F1YFX9nrcMWnfvDtnx4jEXIHiX7LgB3vQGfjOQsjKXA,2260
+actions/settings.py,sha256=D-bSBoDn183sIs2ejSHGUXps3HLHuUXYbnbJ3ZHWFg8,423
+actions/sleep/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/sleep/cli.py,sha256=8fw8cr8BzaymJ87appXwk8ntrxqTUtMVxGNchS4qHjo,1181
+actions/sleep/lib.py,sha256=y_Sxjv_KD_pamHyQySF96YQ5ETA-wHHKOOJq6OD8ub4,1791
+actions/sleep/settings.py,sha256=1hMd5mUsFb6gLajdAZ8bvFYjDhE1BWiPSKOYiHJEvqM,556
+actions/tag/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+actions/tag/cli.py,sha256=itaa71bML6zb91jBDei0npLclIoh8ZKbvFWNzMNRR1g,1231
+actions/tag/lib.py,sha256=3pyhj-b81NWVRGSzoeNkCk8fcrtCjcWss5bMr9xFEeU,1842
+actions/tag/settings.py,sha256=s6QBI4bZFjk2mIPKIlyb3sLET5ZpXsTb-2bzjW9m5Ew,646
+actions/types.py,sha256=azBTLx4DER-Sd1qGCmbJSFs3uzNe9w-7iyKwT2h6iOk,199
+actions/utilities.py,sha256=o-OKP9EbeQ2yG4tTM1eHIRhtF928n7E6YjJQPlbmtIQ,2426
+dycw_actions-0.3.40.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+dycw_actions-0.3.40.dist-info/entry_points.txt,sha256=2Uu7wAZOm0mmcsGBEsGB370HAWgVWECRFJ9rKgfC3-I,46
+dycw_actions-0.3.40.dist-info/METADATA,sha256=6WAaMT5QZbVNsKM6cGNexpqJuDetmlAMc-FQUq4uhn4,467
+dycw_actions-0.3.40.dist-info/RECORD,,

dycw_actions-0.3.40.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.21
+Root-Is-Purelib: true
+Tag: py3-none-any

dycw_actions-0.3.40.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+action = actions.cli:_main
+