dycw-actions 0.3.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

actions/pre_commit/update_requirements/lib.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import sys
+from functools import partial
+from typing import TYPE_CHECKING
+
+from pydantic import TypeAdapter
+from utilities.text import repr_str, strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.pre_commit.update_requirements.classes import (
+    PipListOutdatedOutput,
+    Version1or2,
+    Version2,
+    Version3,
+    parse_version1_or_2,
+    parse_version2_or_3,
+)
+from actions.pre_commit.utilities import get_pyproject_dependencies, yield_toml_doc
+from actions.utilities import logged_run
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+    from pathlib import Path
+
+    from utilities.packaging import Requirement
+    from utilities.types import PathLike
+
+    from actions.pre_commit.update_requirements.classes import Version2or3, VersionSet
+
+
+def update_requirements(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        update_requirements.__name__,
+        __version__,
+        paths,
+    )
+    modifications: set[Path] = set()
+    for path in paths:
+        _format_path(path, modifications=modifications)
+    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,
+    /,
+    *,
+    versions: VersionSet | None = None,
+    modifications: MutableSet[Path] | None = None,
+) -> None:
+    versions_use = _get_versions() if versions is None else versions
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        get_pyproject_dependencies(doc).apply(
+            partial(_format_req, versions=versions_use)
+        )
+
+
+def _get_versions() -> VersionSet:
+    json = logged_run(
+        "uv", "pip", "list", "--format", "json", "--outdated", "--strict", return_=True
+    )
+    packages = TypeAdapter(list[PipListOutdatedOutput]).validate_json(json)
+    return {p.name: parse_version2_or_3(p.latest_version) for p in packages}
+
+
+def _format_req(requirement: Requirement, /, *, versions: VersionSet) -> Requirement:
+    try:
+        lower = parse_version2_or_3(requirement[">="])
+    except KeyError:
+        lower = None
+    try:
+        upper = parse_version1_or_2(requirement["<"])
+    except KeyError:
+        upper = None
+    latest = versions.get(requirement.name)
+    new_lower: Version2or3 | None = None
+    new_upper: Version1or2 | None = None
+    match lower, upper, latest:
+        case None, None, None:
+            ...
+        case None, None, Version2() | Version3():
+            new_lower = latest
+            new_upper = latest.bump_major().major
+        case Version2() | Version3(), None, None:
+            new_lower = lower
+        case (Version2(), None, Version2()) | (Version3(), None, Version3()):
+            new_lower = max(lower, latest)
+        case None, int() | Version2(), None:
+            new_upper = upper
+        case None, int(), Version2():
+            new_upper = max(upper, latest.bump_major().major)
+        case None, Version2(), Version3():
+            bumped = latest.bump_minor()
+            new_upper = max(upper, Version2(bumped.major, bumped.minor))
+        case (
+            (Version2(), int(), None)
+            | (Version3(), int(), None)
+            | (Version3(), Version2(), None)
+        ):
+            new_lower = lower
+            new_upper = lower.bump_major().major
+        case (
+            (Version2(), int(), Version2())
+            | (Version3(), int(), Version3())
+            | (Version3(), Version2(), Version3())
+        ):
+            new_lower = max(lower, latest)
+            new_upper = new_lower.bump_major().major
+        case never:
+            raise NotImplementedError(never)
+    if new_lower is not None:
+        requirement = requirement.replace(">=", str(new_lower))
+    if new_upper is not None:
+        requirement = requirement.replace("<", str(new_upper))
+    return requirement
+
+
+__all__ = ["update_requirements"]

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/__init__.py

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

actions/publish_package/cli.py

@@ -0,0 +1,27 @@
+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.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)
+def publish_package_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    publish_package(
+        username=settings.username,
+        password=settings.password,
+        publish_url=settings.publish_url,
+        trusted_publishing=settings.trusted_publishing,
+        native_tls=settings.native_tls,
+    )
+
+
+__all__ = ["publish_package_sub_cmd"]

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 → publish_package}/lib.py

@@ -3,11 +3,12 @@ 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
+from actions.publish_package.settings import SETTINGS
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from typed_settings import Secret
@@ -15,21 +16,21 @@ if TYPE_CHECKING:
 
 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,
+    username: str | None = SETTINGS.username,
+    password: Secret[str] | None = SETTINGS.password,
+    publish_url: str | None = SETTINGS.publish_url,
+    trusted_publishing: bool = SETTINGS.trusted_publishing,
+    native_tls: bool = SETTINGS.native_tls,
 ) -> None:
     LOGGER.info(
-        """\
-Running %r (version %s) with settings:
- - username           = %s
- - password           = %s
- - publish_url        = %s
- - trusted_publishing = %s
- - native_tls         = %s
- """,
+        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,
@@ -39,8 +40,8 @@ Running %r (version %s) with settings:
         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/{publish → publish_package}/settings.py

@@ -2,19 +2,19 @@ from __future__ import annotations
 
 from typed_settings import Secret, load_settings, option, secret, settings
 
-from actions.utilities import LOADER, empty_str_to_none
+from actions.utilities import LOADER, convert_secret_str, convert_str
 
 
 @settings
-class PublishSettings:
+class Settings:
     username: str | None = option(
-        default=None, converter=empty_str_to_none, help="The username of the upload"
+        default=None, converter=convert_str, help="The username of the upload"
     )
     password: Secret[str] | None = secret(
-        default=None, converter=empty_str_to_none, help="The password for the upload"
+        default=None, converter=convert_secret_str, help="The password for the upload"
     )
     publish_url: str | None = option(
-        default=None, converter=empty_str_to_none, help="The URL of the upload endpoint"
+        default=None, converter=convert_str, help="The URL of the upload endpoint"
     )
     trusted_publishing: bool = option(
         default=False, help="Configure trusted publishing"
@@ -25,7 +25,7 @@ class PublishSettings:
     )
 
 
-PUBLISH_SETTINGS = load_settings(PublishSettings, [LOADER])
+SETTINGS = load_settings(Settings, [LOADER])
 
 
-__all__ = ["PUBLISH_SETTINGS", "PublishSettings"]
+__all__ = ["SETTINGS", "Settings"]

actions/random_sleep/__init__.py

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

actions/random_sleep/cli.py

@@ -0,0 +1,26 @@
+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.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)
+def random_sleep_sub_cmd(settings: Settings, /) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    random_sleep(
+        min_=settings.min,
+        max_=settings.max,
+        step=settings.step,
+        log_freq=settings.log_freq,
+    )
+
+
+__all__ = ["random_sleep_sub_cmd"]

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