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

actions/pre_commit/constants.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from utilities.whenever import HOUR
+from utilities.constants import HOUR
 
 from actions.constants import PATH_ACTIONS
 
 PATH_PRE_COMMIT = PATH_ACTIONS / "pre_commit"
-THROTTLE_DELTA = 12 * HOUR
+THROTTLE_DURATION = 12 * HOUR
 
 
-__all__ = ["PATH_PRE_COMMIT", "THROTTLE_DELTA"]
+__all__ = ["PATH_PRE_COMMIT", "THROTTLE_DURATION"]

actions/pre_commit/touch_empty_py/lib.py

@@ -11,7 +11,7 @@ from utilities.throttle import throttle
 
 from actions import __version__
 from actions.logging import LOGGER
-from actions.pre_commit.constants import THROTTLE_DELTA
+from actions.pre_commit.constants import THROTTLE_DURATION
 from actions.pre_commit.utilities import path_throttle_cache, yield_python_file
 
 if TYPE_CHECKING:
@@ -36,7 +36,7 @@ def _touch_empty_py(*paths: PathLike) -> None:
 
 
 touch_empty_py = throttle(
-    delta=THROTTLE_DELTA, path=path_throttle_cache(_touch_empty_py)
+    duration=THROTTLE_DURATION, path=path_throttle_cache(_touch_empty_py)
 )(_touch_empty_py)
 
 

actions/pre_commit/touch_py_typed/lib.py

@@ -11,8 +11,9 @@ from utilities.text import repr_str
 from utilities.throttle import throttle
 
 from actions import __version__
+from actions.constants import PYPROJECT_TOML
 from actions.logging import LOGGER
-from actions.pre_commit.constants import THROTTLE_DELTA
+from actions.pre_commit.constants import THROTTLE_DURATION
 from actions.pre_commit.utilities import path_throttle_cache
 
 if TYPE_CHECKING:
@@ -36,7 +37,7 @@ def _touch_py_typed(*paths: PathLike) -> None:
 
 
 touch_py_typed = throttle(
-    delta=THROTTLE_DELTA, path=path_throttle_cache(_touch_py_typed)
+    duration=THROTTLE_DURATION, path=path_throttle_cache(_touch_py_typed)
 )(_touch_py_typed)
 
 
@@ -47,7 +48,7 @@ def _format_path(
     if not path.is_file():
         msg = f"Expected a file; {str(path)!r} is not"
         raise FileNotFoundError(msg)
-    if path.name != "pyproject.toml":
+    if path.name != PYPROJECT_TOML.name:
         msg = f"Expected 'pyproject.toml'; got {str(path)!r}"
         raise TypeError(msg)
     src = path.parent / "src"

actions/pre_commit/update_requirements/cli.py

@@ -2,23 +2,31 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+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.pre_commit.click import path_argument
 from actions.pre_commit.update_requirements.lib import update_requirements
+from actions.pre_commit.update_requirements.settings import Settings
+from actions.utilities import LOADER
 
 if TYPE_CHECKING:
     from pathlib import Path
 
 
 @path_argument
-def update_requirements_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def update_requirements_sub_cmd(
+    settings: Settings, /, *, paths: tuple[Path, ...]
+) -> None:
     if is_pytest():
         return
     basic_config(obj=LOGGER)
-    update_requirements(*paths)
+    update_requirements(
+        *paths, indexes=settings.indexes, native_tls=settings.native_tls
+    )
 
 
 __all__ = ["update_requirements_sub_cmd"]

actions/pre_commit/update_requirements/lib.py

@@ -4,8 +4,9 @@ import sys
 from functools import partial
 from typing import TYPE_CHECKING
 
+from ordered_set import OrderedSet
 from pydantic import TypeAdapter
-from utilities.functions import get_func_name, max_nullable
+from utilities.functions import ensure_str, get_func_name, max_nullable
 from utilities.tabulate import func_param_desc
 from utilities.text import repr_str
 
@@ -20,11 +21,18 @@ from actions.pre_commit.update_requirements.classes import (
     parse_version1_or_2,
     parse_version2_or_3,
 )
-from actions.pre_commit.utilities import get_pyproject_dependencies, yield_toml_doc
+from actions.pre_commit.update_requirements.settings import SETTINGS
+from actions.pre_commit.utilities import (
+    get_aot,
+    get_pyproject_dependencies,
+    get_table,
+    yield_pyproject_toml,
+    yield_toml_doc,
+)
 from actions.utilities import logged_run
 
 if TYPE_CHECKING:
-    from collections.abc import MutableSet
+    from collections.abc import Iterator, MutableSet
     from pathlib import Path
 
     from utilities.packaging import Requirement
@@ -33,11 +41,25 @@ if TYPE_CHECKING:
     from actions.pre_commit.update_requirements.classes import Version2or3, VersionSet
 
 
-def update_requirements(*paths: PathLike) -> None:
-    LOGGER.info(func_param_desc(update_requirements, __version__, f"{paths=}"))
+def update_requirements(
+    *paths: PathLike,
+    indexes: list[str] | None = SETTINGS.indexes,
+    native_tls: bool = SETTINGS.native_tls,
+) -> None:
+    LOGGER.info(
+        func_param_desc(
+            update_requirements,
+            __version__,
+            f"{paths=}",
+            f"{indexes=}",
+            f"{native_tls=}",
+        )
+    )
     modifications: set[Path] = set()
     for path in paths:
-        _format_path(path, modifications=modifications)
+        _format_path(
+            path, indexes=indexes, native_tls=native_tls, modifications=modifications
+        )
     if len(modifications) >= 1:
         LOGGER.info(
             "Exiting due to modifications: %s",
@@ -52,24 +74,40 @@ def _format_path(
     /,
     *,
     versions: VersionSet | None = None,
+    indexes: list[str] | None = SETTINGS.indexes,
+    native_tls: bool = SETTINGS.native_tls,
     modifications: MutableSet[Path] | None = None,
 ) -> None:
-    versions_use = _get_versions() if versions is None else versions
+    versions_use = (
+        _get_versions(indexes=indexes, native_tls=native_tls)
+        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:
-    json1 = logged_run(
-        "uv", "pip", "list", "--format", "json", "--strict", return_=True
-    )
+def _get_versions(
+    *,
+    indexes: list[str] | None = SETTINGS.indexes,
+    native_tls: bool = SETTINGS.native_tls,
+) -> VersionSet:
+    index_args: OrderedSet[str] = OrderedSet([])
+    _ = index_args.update(list(_yield_indexes()))
+    if indexes is not None:
+        _ = index_args.update(indexes)
+    head: list[str] = ["uv", "pip", "list", "--format", "json"]
+    tail: list[str] = ["--strict"]
+    if len(index_args) >= 1:
+        tail.extend(["--index", ",".join(index_args)])
+    if native_tls:
+        tail.append("--native-tls")
+    json1 = logged_run(*head, *tail, return_=True)
     models1 = TypeAdapter(list[PipListOutput]).validate_json(json1)
     versions1 = {p.name: parse_version2_or_3(p.version) for p in models1}
-    json2 = logged_run(
-        "uv", "pip", "list", "--format", "json", "--outdated", "--strict", return_=True
-    )
+    json2 = logged_run(*head, "--outdated", *tail, return_=True)
     models2 = TypeAdapter(list[PipListOutdatedOutput]).validate_json(json2)
     versions2 = {p.name: parse_version2_or_3(p.latest_version) for p in models2}
     out: StrDict = {}
@@ -78,6 +116,28 @@ def _get_versions() -> VersionSet:
     return out
 
 
+def _yield_indexes() -> Iterator[str]:
+    try:
+        with yield_pyproject_toml() as doc:
+            try:
+                tool = get_table(doc, "tool")
+            except KeyError:
+                return
+            try:
+                uv = get_table(tool, "uv")
+            except KeyError:
+                return
+            try:
+                indexes = get_aot(uv, "index")
+            except KeyError:
+                return
+            else:
+                for index in indexes:
+                    yield ensure_str(index["url"])
+    except FileNotFoundError:
+        return
+
+
 def _format_req(requirement: Requirement, /, *, versions: VersionSet) -> Requirement:
     try:
         lower = parse_version2_or_3(requirement[">="])

actions/pre_commit/update_requirements/settings.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typed_settings import load_settings, option, settings
+
+from actions.utilities import LOADER
+
+
+@settings
+class Settings:
+    indexes: list[str] | None = option(
+        factory=list,
+        help="List of URLs as additional indexes when searching for packages",
+    )
+    native_tls: bool = option(
+        default=False,
+        help="Whether to load TLS certificates from the platform's native certificate store",
+    )
+
+
+SETTINGS = load_settings(Settings, [LOADER])
+
+
+__all__ = ["SETTINGS", "Settings"]

actions/pre_commit/utilities.py

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

actions/publish_package/lib.py

@@ -14,6 +14,8 @@ from actions.utilities import logged_run
 if TYPE_CHECKING:
     from typed_settings import Secret
 
+    from actions.types import SecretLike
+
 
 def publish_package(
     *,
@@ -34,18 +36,22 @@ def publish_package(
             f"{native_tls=}",
         )
     )
+    build_head: list[str] = ["uv", "build", "--out-dir"]
+    build_tail: list[str] = ["--wheel", "--clear"]
+    publish: list[SecretLike] = ["uv", "publish"]
+    if username is not None:
+        publish.extend(["--username", username])
+    if password is not None:
+        publish.extend(["--password", password])
+    if publish_url is not None:
+        publish.extend(["--publish-url", publish_url])
+    if trusted_publishing:
+        publish.extend(["--trusted-publishing", "always"])
+    if native_tls:
+        publish.append("--native-tls")
     with TemporaryDirectory() as temp:
-        logged_run("uv", "build", "--out-dir", str(temp), "--wheel", "--clear")
-        logged_run(
-            "uv",
-            "publish",
-            *([] if username is None else ["--username", username]),
-            *([] if password is None else ["--password", password]),
-            *([] if publish_url is None else ["--publish-url", publish_url]),
-            *(["--trusted-publishing", "always"] if trusted_publishing else []),
-            *(["--native-tls"] if native_tls else []),
-            f"{temp}/*",
-        )
+        logged_run(*build_head, str(temp), *build_tail)
+        logged_run(*publish, f"{temp}/*")
     LOGGER.info("Finished running %r", get_func_name(publish_package))
 
 

actions/random_sleep/lib.py

@@ -27,9 +27,9 @@ def random_sleep(
         )
     )
     start = get_now()
-    delta = TimeDelta(seconds=choice(range(min, max, step)))
-    LOGGER.info("Sleeping for %s...", delta)
-    end = (start + delta).round(mode="ceil")
+    duration = TimeDelta(seconds=choice(range(min, max, step)))
+    LOGGER.info("Sleeping for %s...", duration)
+    end = (start + duration).round(mode="ceil")
     while (now := get_now()) < end:
         _intermediate(start, now, end, log_freq=log_freq)
     LOGGER.info("Finished running %r", get_func_name(random_sleep))

actions/re_encrypt/__init__.py

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

actions/re_encrypt/cli.py

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

actions/re_encrypt/constants.py

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