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

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

actions/pre_commit/replace_sequence_strs/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.replace_sequence_strs.lib import replace_sequence_strs
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@path_argument
+def replace_sequence_strs_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    replace_sequence_strs(*paths)
+
+
+__all__ = ["replace_sequence_strs_sub_cmd"]

actions/pre_commit/replace_sequence_strs/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+REPLACE_SEQUENCE_STRS_DOCSTRING = "Replace 'Sequence[str]' with 'list[str]'"
+REPLACE_SEQUENCE_STRS_SUB_CMD = "replace-sequence-strs"
+
+
+__all__ = ["REPLACE_SEQUENCE_STRS_DOCSTRING", "REPLACE_SEQUENCE_STRS_SUB_CMD"]

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

@@ -1,10 +1,9 @@
 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 import CSTTransformer, Name, Subscript
 from libcst.matchers import Index as MIndex
 from libcst.matchers import Name as MName
 from libcst.matchers import Subscript as MSubscript
@@ -15,12 +14,13 @@ from utilities.text import repr_str, strip_and_dedent
 
 from actions import __version__
 from actions.logging import LOGGER
+from actions.pre_commit.utilities import yield_python_file
 
 if TYPE_CHECKING:
-    from utilities.types import PathLike
-
+    from collections.abc import MutableSet
+    from pathlib import Path
 
-_MODIFICATIONS: set[Path] = set()
+    from utilities.types import PathLike
 
 
 def replace_sequence_strs(*paths: PathLike) -> None:
@@ -33,30 +33,24 @@ def replace_sequence_strs(*paths: PathLike) -> None:
         __version__,
         paths,
     )
+    modifications: set[Path] = set()
     for path in paths:
-        _format_path(path)
-    if len(_MODIFICATIONS) >= 1:
+        _format_path(path, modifications=modifications)
+    if len(modifications) >= 1:
         LOGGER.info(
             "Exiting due to modifications: %s",
-            ", ".join(map(repr_str, sorted(_MODIFICATIONS))),
+            ", ".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())
+def _format_path(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> None:
+    with yield_python_file(path, modifications=modifications) as context:
+        context.output = MetadataWrapper(context.input).module.visit(
+            SequenceToListTransformer()
+        )
 
 
 class SequenceToListTransformer(CSTTransformer):

actions/pre_commit/touch_empty_py/__init__.py

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

actions/pre_commit/touch_empty_py/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.touch_empty_py.lib import touch_empty_py
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@path_argument
+def touch_empty_py_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    touch_empty_py(*paths)
+
+
+__all__ = ["touch_empty_py_sub_cmd"]

actions/pre_commit/touch_empty_py/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+TOUCH_EMPTY_PY_DOCSTRING = "Touch empty '.py' files"
+TOUCH_EMPTY_PY_SUB_CMD = "touch-empty-py"
+
+
+__all__ = ["TOUCH_EMPTY_PY_DOCSTRING", "TOUCH_EMPTY_PY_SUB_CMD"]

actions/pre_commit/touch_empty_py/lib.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from libcst import parse_statement
+from utilities.text import repr_str, strip_and_dedent
+from utilities.throttle import throttle
+from utilities.whenever import HOUR
+
+from actions import __version__
+from actions.constants import PATH_THROTTLE_CACHE
+from actions.logging import LOGGER
+from actions.pre_commit.utilities import yield_python_file
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+def _touch_empty_py(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        touch_empty_py.__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)
+
+
+touch_empty_py = throttle(
+    delta=12 * HOUR, path=PATH_THROTTLE_CACHE / _touch_empty_py.__name__
+)(_touch_empty_py)
+
+
+def _format_path(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> None:
+    with yield_python_file(path, modifications=modifications) as context:
+        if len(context.input.body) >= 1:
+            return
+        body = [
+            *context.input.body,
+            parse_statement("from __future__ import annotations"),
+        ]
+        context.output = context.input.with_changes(body=body)
+
+
+__all__ = ["touch_empty_py"]

actions/pre_commit/touch_py_typed/__init__.py

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

actions/pre_commit/touch_py_typed/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.touch_py_typed.lib import touch_py_typed
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@path_argument
+def touch_py_typed_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    touch_py_typed(*paths)
+
+
+__all__ = ["touch_py_typed_sub_cmd"]

actions/pre_commit/touch_py_typed/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+TOUCH_PY_TYPED_DOCSTRING = "Touch 'py.typed'"
+TOUCH_PY_TYPED_SUB_CMD = "touch-py-typed"
+
+
+__all__ = ["TOUCH_PY_TYPED_DOCSTRING", "TOUCH_PY_TYPED_SUB_CMD"]

actions/pre_commit/touch_py_typed/lib.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from utilities.iterables import one
+from utilities.text import repr_str, strip_and_dedent
+from utilities.throttle import throttle
+from utilities.whenever import HOUR
+
+from actions import __version__
+from actions.constants import PATH_THROTTLE_CACHE
+from actions.logging import LOGGER
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSet
+
+    from utilities.types import PathLike
+
+
+def _touch_py_typed(*paths: PathLike) -> None:
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - paths = %s
+        """),
+        touch_py_typed.__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)
+
+
+touch_py_typed = throttle(
+    delta=12 * HOUR, path=PATH_THROTTLE_CACHE / _touch_py_typed.__name__
+)(_touch_py_typed)
+
+
+def _format_path(
+    path: PathLike, /, *, modifications: MutableSet[Path] | None = None
+) -> None:
+    path = Path(path)
+    if not path.is_file():
+        msg = f"Expected a file; {str(path)!r} is not"
+        raise FileNotFoundError(msg)
+    if path.name != "pyproject.toml":
+        msg = f"Expected 'pyproject.toml'; got {str(path)!r}"
+        raise TypeError(msg)
+    src = path.parent / "src"
+    if not src.exists():
+        return
+    if not src.is_dir():
+        msg = f"Expected a directory; {str(src)!r} is not"
+        raise NotADirectoryError(msg)
+    non_tests = one(p for p in src.iterdir() if p.name != "tests")
+    py_typed = non_tests / "py.typed"
+    if not py_typed.exists():
+        py_typed.touch()
+        if modifications is not None:
+            modifications.add(py_typed)
+
+
+__all__ = ["touch_py_typed"]

actions/pre_commit/update_requirements/__init__.py

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

actions/pre_commit/update_requirements/classes.py

@@ -0,0 +1,130 @@
+# ruff: noqa: TC003
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field, replace
+from functools import total_ordering
+from pathlib import Path
+from typing import Any, Self, override
+
+from pydantic import BaseModel
+from utilities.version import (
+    ParseVersionError,
+    _VersionEmptySuffixError,
+    _VersionNegativeMajorVersionError,
+    _VersionNegativeMinorVersionError,
+    _VersionZeroError,
+)
+from utilities.version import Version as Version3
+from utilities.version import parse_version as parse_version3
+
+type TwoSidedVersions = tuple[Version2or3 | None, Version1or2 | None]
+type Version1or2 = int | Version2
+type Version2or3 = Version2 | Version3
+type VersionSet = dict[str, Version2or3]
+
+
+##
+
+
+class PipListOutput(BaseModel):
+    name: str
+    version: str
+    editable_project_location: Path | None = None
+
+
+class PipListOutdatedOutput(BaseModel):
+    name: str
+    version: str
+    latest_version: str
+    latest_filetype: str
+
+
+_ = PipListOutput.model_rebuild()
+_ = PipListOutdatedOutput.model_rebuild()
+
+
+##
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+@total_ordering
+class Version2:
+    """A version identifier."""
+
+    major: int = 0
+    minor: int = 0
+    suffix: str | None = field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        if (self.major == 0) and (self.minor == 0):
+            raise _VersionZeroError(major=self.major, minor=self.minor, patch=0)
+        if self.major < 0:
+            raise _VersionNegativeMajorVersionError(major=self.major)
+        if self.minor < 0:
+            raise _VersionNegativeMinorVersionError(minor=self.minor)
+        if (self.suffix is not None) and (len(self.suffix) == 0):
+            raise _VersionEmptySuffixError(suffix=self.suffix)
+
+    def __le__(self, other: Any, /) -> bool:
+        if not isinstance(other, type(self)):
+            return NotImplemented
+        self_as_tuple = (self.major, self.minor)
+        other_as_tuple = (other.major, other.minor)
+        return self_as_tuple <= other_as_tuple
+
+    @override
+    def __repr__(self) -> str:
+        version = f"{self.major}.{self.minor}"
+        if self.suffix is not None:
+            version = f"{version}-{self.suffix}"
+        return version
+
+    def bump_major(self) -> Self:
+        return type(self)(self.major + 1, 0)
+
+    def bump_minor(self) -> Self:
+        return type(self)(self.major, self.minor + 1)
+
+    def with_suffix(self, *, suffix: str | None = None) -> Self:
+        return replace(self, suffix=suffix)
+
+
+def parse_version1_or_2(version: str, /) -> Version1or2:
+    try:
+        return parse_version2(version)
+    except ParseVersionError:
+        return int(version)
+
+
+def parse_version2_or_3(version: str, /) -> Version2or3:
+    try:
+        return parse_version3(version)
+    except ParseVersionError:
+        return parse_version2(version)
+
+
+def parse_version2(version: str, /) -> Version2:
+    try:
+        ((major, minor, suffix),) = _PARSE_VERSION2_PATTERN.findall(version)
+    except ValueError:
+        raise ParseVersionError(version=version) from None
+    return Version2(int(major), int(minor), suffix=None if suffix == "" else suffix)
+
+
+_PARSE_VERSION2_PATTERN = re.compile(r"^(\d+)\.(\d+)(?:-(\w+))?")
+
+
+__all__ = [
+    "PipListOutdatedOutput",
+    "PipListOutput",
+    "TwoSidedVersions",
+    "Version1or2",
+    "Version2",
+    "Version2or3",
+    "Version3",
+    "VersionSet",
+    "parse_version1_or_2",
+    "parse_version2",
+    "parse_version2_or_3",
+]

actions/pre_commit/update_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.update_requirements.lib import update_requirements
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@path_argument
+def update_requirements_sub_cmd(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    basic_config(obj=LOGGER)
+    update_requirements(*paths)
+
+
+__all__ = ["update_requirements_sub_cmd"]

actions/pre_commit/update_requirements/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+UPDATE_REQUIREMENTS_DOCSTRING = "Update a set of requirements"
+UPDATE_REQUIREMENTS_SUB_CMD = "update-requirements"
+
+
+__all__ = ["UPDATE_REQUIREMENTS_DOCSTRING", "UPDATE_REQUIREMENTS_SUB_CMD"]

actions/pre_commit/update_requirements/lib.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import sys
+from functools import partial
+from typing import TYPE_CHECKING
+
+from pydantic import TypeAdapter
+from utilities.functions import max_nullable
+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,
+    PipListOutput,
+    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
+    from actions.types import StrDict
+
+
+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:
+    json1 = logged_run(
+        "uv", "pip", "list", "--format", "json", "--strict", 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
+    )
+    models2 = TypeAdapter(list[PipListOutdatedOutput]).validate_json(json2)
+    versions2 = {p.name: parse_version2_or_3(p.latest_version) for p in models2}
+    out: StrDict = {}
+    for key in set(versions1) | set(versions2):
+        out[key] = max_nullable([versions1.get(key), versions2.get(key)])
+    return out
+
+
+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"]