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

actions/{conformalize_repo → pre_commit/conformalize_repo}/lib.py

@@ -1,31 +1,23 @@
 from __future__ import annotations
 
-import json
 import sys
 from contextlib import contextmanager, suppress
-from io import StringIO
 from itertools import product
 from pathlib import Path
-from re import MULTILINE, escape, sub
+from re import MULTILINE, escape, search, sub
 from shlex import join
 from string import Template
 from subprocess import CalledProcessError
-from typing import TYPE_CHECKING, Any, Literal, assert_never
+from typing import TYPE_CHECKING, Literal, assert_never
 
 import tomlkit
-from rich.pretty import pretty_repr
 from ruamel.yaml.scalarstring import LiteralScalarString
-from tomlkit import TOMLDocument, aot, array, document, table
+from tomlkit import TOMLDocument, table
 from tomlkit.exceptions import NonExistentKey
-from tomlkit.items import AoT, Array, Table
-from utilities.atomicwrites import writer
-from utilities.functions import ensure_class
 from utilities.inflect import counted_noun
-from utilities.iterables import OneEmptyError, OneNonUniqueError, one
 from utilities.pathlib import get_repo_root
 from utilities.re import extract_groups
-from utilities.subprocess import append_text, ripgrep, run
-from utilities.tempfile import TemporaryFile
+from utilities.subprocess import ripgrep
 from utilities.text import repr_str, strip_and_dedent
 from utilities.version import ParseVersionError, Version, parse_version
 from utilities.whenever import HOUR, get_now
@@ -41,9 +33,12 @@ from actions.action_dicts.lib import (
     run_action_ruff_dict,
     run_action_tag_dict,
 )
-from actions.conformalize_repo.constants import (
+from actions.constants import YAML_INSTANCE
+from actions.logging import LOGGER
+from actions.pre_commit.conformalize_repo.constants import (
     ACTIONS_URL,
     BUMPVERSION_TOML,
+    CONFORMALIZE_REPO_SUB_CMD,
     COVERAGERC_TOML,
     DOCKERFMT_URL,
     ENVRC,
@@ -65,16 +60,38 @@ from actions.conformalize_repo.constants import (
     TAPLO_URL,
     UV_URL,
 )
-from actions.conformalize_repo.settings import SETTINGS
-from actions.constants import YAML_INSTANCE
-from actions.logging import LOGGER
+from actions.pre_commit.conformalize_repo.settings import SETTINGS
+from actions.pre_commit.format_requirements.constants import FORMAT_REQUIREMENTS_SUB_CMD
+from actions.pre_commit.replace_sequence_strs.constants import (
+    REPLACE_SEQUENCE_STRS_SUB_CMD,
+)
+from actions.pre_commit.touch_empty_py.constants import TOUCH_EMPTY_PY_SUB_CMD
+from actions.pre_commit.touch_py_typed.constants import TOUCH_PY_TYPED_SUB_CMD
+from actions.pre_commit.utilities import (
+    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_table,
+    yield_json_dict,
+    yield_text_file,
+    yield_toml_doc,
+    yield_yaml_dict,
+)
+from actions.utilities import logged_run, write_text
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator, MutableSet
+    from collections.abc import Iterator, MutableSet
 
+    from tomlkit.items import Table
     from utilities.types import PathLike
 
-    from actions.types import HasAppend, HasSetDefault, StrDict
+    from actions.types import StrDict
 
 
 def conformalize_repo(
@@ -411,31 +428,27 @@ def add_envrc(
     python_version: str = SETTINGS.python_version,
     script: str | None = SETTINGS.script,
 ) -> None:
-    with yield_text_file(ENVRC, modifications=modifications) as temp:
+    with yield_text_file(ENVRC, modifications=modifications) as context:
         shebang = strip_and_dedent("""
             #!/usr/bin/env sh
             # shellcheck source=/dev/null
         """)
-        append_text(temp, shebang, skip_if_present=True, flags=MULTILINE, blank_lines=2)
+        if search(escape(shebang), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{shebang}"
 
         echo = strip_and_dedent("""
             # echo
             echo_date() { echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" >&2; }
         """)
-        append_text(temp, echo, skip_if_present=True, flags=MULTILINE, blank_lines=2)
+        if search(escape(echo), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{echo}"
 
         if uv:
-            append_text(
-                temp,
-                _add_envrc_uv_text(
-                    native_tls=uv__native_tls,
-                    python_version=python_version,
-                    script=script,
-                ),
-                skip_if_present=True,
-                flags=MULTILINE,
-                blank_lines=2,
+            uv_text = _add_envrc_uv_text(
+                native_tls=uv__native_tls, python_version=python_version, script=script
             )
+            if search(escape(uv_text), context.output, flags=MULTILINE) is None:
+                context.output += f"\n\n{echo}"
 
 
 def _add_envrc_uv_text(
@@ -615,9 +628,10 @@ def add_github_push_yaml(
 
 
 def add_gitignore(*, modifications: MutableSet[Path] | None = None) -> None:
-    with yield_text_file(GITIGNORE, modifications=modifications) as temp:
+    with yield_text_file(GITIGNORE, modifications=modifications) as context:
         text = (PATH_CONFIGS / "gitignore").read_text()
-        append_text(temp, text, skip_if_present=True, flags=MULTILINE)
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
 
 
 ##
@@ -636,7 +650,7 @@ def add_pre_commit_config_yaml(
     script: str | None = SETTINGS.script,
 ) -> None:
     with yield_yaml_dict(PRE_COMMIT_CONFIG_YAML, modifications=modifications) as dict_:
-        _add_pre_commit_config_repo(dict_, ACTIONS_URL, "conformalize-repo")
+        _add_pre_commit_config_repo(dict_, ACTIONS_URL, CONFORMALIZE_REPO_SUB_CMD)
         _add_pre_commit_config_repo(
             dict_, PRE_COMMIT_HOOKS_URL, "check-executables-have-shebangs"
         )
@@ -675,8 +689,12 @@ def add_pre_commit_config_yaml(
                 types_or=["markdown", "yaml"],
             )
         if python:
-            _add_pre_commit_config_repo(dict_, ACTIONS_URL, "format-requirements")
-            _add_pre_commit_config_repo(dict_, ACTIONS_URL, "replace-sequence-strs")
+            _add_pre_commit_config_repo(dict_, ACTIONS_URL, FORMAT_REQUIREMENTS_SUB_CMD)
+            _add_pre_commit_config_repo(
+                dict_, ACTIONS_URL, REPLACE_SEQUENCE_STRS_SUB_CMD
+            )
+            _add_pre_commit_config_repo(dict_, ACTIONS_URL, TOUCH_EMPTY_PY_SUB_CMD)
+            _add_pre_commit_config_repo(dict_, ACTIONS_URL, TOUCH_PY_TYPED_SUB_CMD)
         if ruff:
             _add_pre_commit_config_repo(
                 dict_, RUFF_URL, "ruff-check", args=("add", ["--fix"])
@@ -730,11 +748,11 @@ def _add_pre_commit_config_repo(
     args: tuple[Literal["add", "exact"], list[str]] | None = None,
 ) -> None:
     repos_list = get_list(pre_commit_dict, "repos")
-    repo_dict = ensure_contains_partial(
+    repo_dict = ensure_contains_partial_dict(
         repos_list, {"repo": url}, extra={} if url == "local" else {"rev": "master"}
     )
     hooks_list = get_list(repo_dict, "hooks")
-    hook_dict = ensure_contains_partial(hooks_list, {"id": id_})
+    hook_dict = ensure_contains_partial_dict(hooks_list, {"id": id_})
     if name is not None:
         hook_dict["name"] = name
     if entry is not None:
@@ -785,12 +803,13 @@ def add_pyproject_toml(
         project.setdefault("version", "0.1.0")
         dependency_groups = get_table(doc, "dependency-groups")
         dev = get_array(dependency_groups, "dev")
-        ensure_contains(dev, "dycw-utilities[test]")
-        ensure_contains(dev, "rich")
+        _ = ensure_contains_partial_str(dev, "dycw-utilities[test]")
+        _ = ensure_contains_partial_str(dev, "pyright")
+        _ = ensure_contains_partial_str(dev, "rich")
         if optional_dependencies__scripts:
             optional_dependencies = get_table(project, "optional-dependencies")
             scripts = get_array(optional_dependencies, "scripts")
-            ensure_contains(scripts, "click >=8.3.1")
+            _ = ensure_contains_partial_str(scripts, "click")
         if python_package_name is not None:
             tool = get_table(doc, "tool")
             uv = get_table(tool, "uv")
@@ -921,13 +940,15 @@ def add_readme_md(
     name: str | None = SETTINGS.package_name,
     description: str | None = SETTINGS.description,
 ) -> None:
-    with yield_text_file(README_MD, modifications=modifications) as temp:
+    with yield_text_file(README_MD, modifications=modifications) as context:
         lines: list[str] = []
         if name is not None:
             lines.append(f"# `{name}`")
         if description is not None:
             lines.append(description)
-        _ = temp.write_text("\n\n".join(lines))
+        text = "\n\n".join(lines)
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
 
 
 ##
@@ -1029,112 +1050,6 @@ def check_versions() -> None:
 ##
 
 
-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(
-    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_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_python_package_name(
     *,
     package_name: str | None = SETTINGS.package_name,
@@ -1168,12 +1083,12 @@ def get_version_from_bumpversion_toml(
 
 
 def get_version_from_git_show() -> Version:
-    text = run("git", "show", f"origin/master:{BUMPVERSION_TOML}", return_=True)
+    text = logged_run("git", "show", f"origin/master:{BUMPVERSION_TOML}", return_=True)
     return get_version_from_bumpversion_toml(obj=text.rstrip("\n"))
 
 
 def get_version_from_git_tag() -> Version:
-    text = run("git", "tag", "--points-at", "origin/master", return_=True)
+    text = logged_run("git", "tag", "--points-at", "origin/master", return_=True)
     for line in text.splitlines():
         with suppress(ParseVersionError):
             return parse_version(line)
@@ -1210,25 +1125,19 @@ def run_bump_my_version(*, modifications: MutableSet[Path] | None = None) -> Non
 
 def run_pre_commit_update(*, modifications: MutableSet[Path] | None = None) -> None:
     cache = xdg_cache_home() / "conformalize" / get_repo_root().name
-
-    def run_autoupdate() -> None:
-        current = PRE_COMMIT_CONFIG_YAML.read_text()
-        run("pre-commit", "autoupdate", print=True)
-        with writer(cache, overwrite=True) as temp:
-            _ = temp.write_text(get_now().format_iso())
-        if (modifications is not None) and (
-            PRE_COMMIT_CONFIG_YAML.read_text() != current
-        ):
-            modifications.add(PRE_COMMIT_CONFIG_YAML)
-
     try:
         text = cache.read_text()
     except FileNotFoundError:
-        run_autoupdate()
+        ...
     else:
         prev = ZonedDateTime.parse_iso(text.rstrip("\n"))
-        if prev < (get_now() - 12 * HOUR):
-            run_autoupdate()
+        if prev >= (get_now() - 12 * HOUR):
+            return
+    write_text(cache, get_now().format_iso())
+    current = PRE_COMMIT_CONFIG_YAML.read_text()
+    logged_run("pre-commit", "autoupdate", print=True)
+    if (modifications is not None) and (PRE_COMMIT_CONFIG_YAML.read_text() != current):
+        modifications.add(PRE_COMMIT_CONFIG_YAML)
 
 
 ##
@@ -1247,22 +1156,21 @@ def run_ripgrep_and_replace(
     )
     if result is None:
         return
-    for path in map(Path, result.splitlines()):
-        with yield_text_file(path, modifications=modifications) as temp:
-            text = sub(
+    for path in result.splitlines():
+        with yield_text_file(path, modifications=modifications) as context:
+            context.output = sub(
                 r'# requires-python = ">=\d+\.\d+"',
                 rf'# requires-python = ">={version}"',
-                path.read_text(),
+                context.input,
                 flags=MULTILINE,
             )
-            _ = temp.write_text(text)
 
 
 ##
 
 
 def set_version(version: Version, /) -> None:
-    run(
+    logged_run(
         "bump-my-version",
         "replace",
         "--new-version",
@@ -1318,35 +1226,6 @@ def update_action_versions(*, modifications: MutableSet[Path] | None = None) ->
 ##
 
 
-def write_text(
-    verb: str,
-    src: PathLike,
-    dest: PathLike,
-    /,
-    *,
-    modifications: MutableSet[Path] | None = None,
-) -> None:
-    src, dest = map(Path, [src, dest])
-    LOGGER.info("%s '%s'...", verb, dest)
-    text = src.read_text().rstrip("\n") + "\n"
-    with writer(dest, overwrite=True) as temp:
-        _ = temp.write_text(text)
-    if modifications is not None:
-        modifications.add(dest)
-
-
-##
-
-
-def yaml_dump(obj: Any, /) -> str:
-    stream = StringIO()
-    YAML_INSTANCE.dump(obj, stream)
-    return stream.getvalue()
-
-
-##
-
-
 @contextmanager
 def yield_bumpversion_toml(
     *, modifications: MutableSet[Path] | None = None
@@ -1362,19 +1241,6 @@ def yield_bumpversion_toml(
 ##
 
 
-@contextmanager
-def yield_json_dict(
-    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
-) -> Iterator[StrDict]:
-    with yield_write_context(
-        path, json.loads, dict, json.dumps, modifications=modifications
-    ) as dict_:
-        yield dict_
-
-
-##
-
-
 def yield_python_versions(
     version: str, /, *, max_: str = MAX_PYTHON_VERSION
 ) -> Iterator[str]:
@@ -1398,83 +1264,6 @@ def _yield_python_version_tuple(version: str, /) -> tuple[int, int]:
 ##
 
 
-@contextmanager
-def yield_text_file(
-    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
-) -> Iterator[Path]:
-    path = Path(path)
-    try:
-        current = path.read_text()
-    except FileNotFoundError:
-        with TemporaryFile() as temp:
-            yield temp
-            write_text("Writing", temp, path, modifications=modifications)
-    else:
-        with TemporaryFile(text=current) as temp:
-            yield temp
-            if temp.read_text().rstrip("\n") != current.rstrip("\n"):
-                write_text("Writing", temp, path, modifications=modifications)
-
-
-##
-
-
-@contextmanager
-def yield_toml_doc(
-    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
-) -> Iterator[TOMLDocument]:
-    with yield_write_context(
-        path, tomlkit.parse, document, tomlkit.dumps, modifications=modifications
-    ) as doc:
-        yield doc
-
-
-##
-
-
-@contextmanager
-def yield_write_context[T](
-    path: PathLike,
-    loads: Callable[[str], T],
-    get_default: Callable[[], T],
-    dumps: Callable[[T], str],
-    /,
-    *,
-    modifications: MutableSet[Path] | None = None,
-) -> Iterator[T]:
-    path = Path(path)
-
-    def run_write(verb: str, data: T, /) -> None:
-        with writer(path, overwrite=True) as temp:
-            _ = temp.write_text(dumps(data))
-            write_text(verb, temp, path, modifications=modifications)
-
-    try:
-        current = path.read_text()
-    except FileNotFoundError:
-        yield (default := get_default())
-        run_write("Writing", default)
-    else:
-        data = loads(current)
-        yield data
-        is_equal = data == loads(current)  # tomlkit cannot handle !=
-        if not is_equal:
-            run_write("Modifying", data)
-
-
-##
-
-
-@contextmanager
-def yield_yaml_dict(
-    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
-) -> Iterator[StrDict]:
-    with yield_write_context(
-        path, YAML_INSTANCE.load, dict, yaml_dump, modifications=modifications
-    ) as dict_:
-        yield dict_
-
-
 __all__ = [
     "add_bumpversion_toml",
     "add_coveragerc_toml",
@@ -1489,34 +1278,16 @@ __all__ = [
     "add_readme_md",
     "add_ruff_toml",
     "check_versions",
-    "ensure_aot_contains",
-    "ensure_contains",
-    "ensure_contains_partial",
-    "ensure_not_contains",
-    "get_aot",
-    "get_array",
-    "get_dict",
-    "get_list",
-    "get_partial_dict",
     "get_python_package_name",
-    "get_table",
     "get_version_from_bumpversion_toml",
     "get_version_from_git_show",
     "get_version_from_git_tag",
-    "is_partial_dict",
     "run_bump_my_version",
     "run_pre_commit_update",
     "run_ripgrep_and_replace",
     "set_version",
     "update_action_file_extensions",
     "update_action_versions",
-    "write_text",
-    "yaml_dump",
     "yield_bumpversion_toml",
-    "yield_json_dict",
     "yield_python_versions",
-    "yield_text_file",
-    "yield_toml_doc",
-    "yield_write_context",
-    "yield_yaml_dict",
 ]

actions/{conformalize_repo → pre_commit/conformalize_repo}/settings.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typed_settings import load_settings, option, settings
 
-from actions.conformalize_repo.constants import RUN_VERSION_BUMP
+from actions.pre_commit.conformalize_repo.constants import RUN_VERSION_BUMP
 from actions.utilities import LOADER
 
 

actions/pre_commit/constants.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from actions.constants import PATH_ACTIONS
+
+PATH_PRE_COMMIT = PATH_ACTIONS / "pre_commit"
+
+
+__all__ = ["PATH_PRE_COMMIT"]

actions/pre_commit/format_requirements/cli.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+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.format_requirements.lib import format_requirements
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@path_argument
+def format_requirements_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    format_requirements(*paths)
+
+
+__all__ = ["format_requirements_sub_cmd"]

actions/pre_commit/format_requirements/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+FORMAT_REQUIREMENTS_DOCSTRING = "Format a set of requirements"
+FORMAT_REQUIREMENTS_SUB_CMD = "format-requirements"
+
+
+__all__ = ["FORMAT_REQUIREMENTS_DOCSTRING", "FORMAT_REQUIREMENTS_SUB_CMD"]

actions/pre_commit/format_requirements/lib.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from utilities.text import repr_str, strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.pre_commit.utilities import get_pyproject_dependencies, yield_toml_doc
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+    from pathlib import Path
+
+    from utilities.packaging import Requirement
+    from utilities.types import PathLike
+
+
+def format_requirements(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        format_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, /, *, modifications: MutableSet[Path] | None = None
+) -> None:
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        get_pyproject_dependencies(doc).apply(_format_req)
+
+
+def _format_req(requirement: Requirement, /) -> Requirement:
+    return requirement
+
+
+__all__ = ["format_requirements"]

actions/pre_commit/replace_sequence_strs/__init__.py

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