dycw-pre-commit-hooks 0.12.8__py3-none-any.whl → 0.14.26__py3-none-any.whl

pre_commit_hooks/hooks/run_version_bump.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from functools import partial
+from subprocess import CalledProcessError
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+from utilities.version import Version3, Version3Error
+
+from pre_commit_hooks.constants import BUMPVERSION_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    get_version_from_git_show,
+    get_version_from_git_tag,
+    get_version_from_path,
+    run_all_maybe_raise,
+    run_bump_my_version,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p) for p in paths))
+
+
+def _run(*, path: PathLike = BUMPVERSION_TOML) -> bool:
+    try:
+        prev = get_version_from_git_tag()
+    except (CalledProcessError, ValueError):
+        try:
+            prev = get_version_from_git_show(path=path)
+        except (CalledProcessError, KeyError, Version3Error):
+            run_bump_my_version(Version3(0, 1, 0), path=path)
+            return False
+    current = get_version_from_path(path=path)
+    patched = prev.bump_patch()
+    if current in {patched, prev.bump_minor(), prev.bump_major()}:
+        return True
+    run_bump_my_version(patched)
+    return False
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_git.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from re import MULTILINE, escape, search
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.importlib import files
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import GITIGNORE, paths_argument
+from pre_commit_hooks.utilities import run_all_maybe_raise, yield_text_file
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+def _main(*, paths: tuple[Path, ...]) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(*(partial(_run, path=p.parent / GITIGNORE) for p in paths))
+
+
+def _run(*, path: PathLike = GITIGNORE) -> bool:
+    modifications: set[Path] = set()
+    with yield_text_file(path, modifications=modifications) as context:
+        text = (files(anchor="pre_commit_hooks") / "configs/gitignore").read_text()
+        if search(escape(text), context.output, flags=MULTILINE) is None:
+            context.output += f"\n\n{text}"
+    return len(modifications) == 0
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_pyright.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import (
+    DEFAULT_PYTHON_VERSION,
+    PYRIGHTCONFIG_JSON,
+    paths_argument,
+    python_version_option,
+)
+from pre_commit_hooks.utilities import (
+    ensure_contains,
+    get_set_list_strs,
+    run_all_maybe_raise,
+    yield_json_dict,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@python_version_option
+def _main(
+    *, paths: tuple[Path, ...], python_version: str = DEFAULT_PYTHON_VERSION
+) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(
+        *(
+            partial(
+                _run, path=p.parent / PYRIGHTCONFIG_JSON, python_version=python_version
+            )
+            for p in paths
+        )
+    )
+
+
+def _run(
+    *, path: PathLike = PYRIGHTCONFIG_JSON, python_version: str = DEFAULT_PYTHON_VERSION
+) -> bool:
+    modifications: set[Path] = set()
+    with yield_json_dict(path, modifications=modifications) as dict_:
+        dict_["deprecateTypingAliases"] = True
+        dict_["enableReachabilityAnalysis"] = False
+        include = get_set_list_strs(dict_, "include")
+        ensure_contains(include, "src")
+        dict_["pythonVersion"] = python_version
+        dict_["reportCallInDefaultInitializer"] = True
+        dict_["reportImplicitOverride"] = True
+        dict_["reportImplicitStringConcatenation"] = True
+        dict_["reportImportCycles"] = True
+        dict_["reportMissingSuperCall"] = True
+        dict_["reportMissingTypeArgument"] = False
+        dict_["reportMissingTypeStubs"] = False
+        dict_["reportPrivateImportUsage"] = False
+        dict_["reportPrivateUsage"] = False
+        dict_["reportPropertyTypeMismatch"] = True
+        dict_["reportUninitializedInstanceVariable"] = True
+        dict_["reportUnknownArgumentType"] = False
+        dict_["reportUnknownMemberType"] = False
+        dict_["reportUnknownParameterType"] = False
+        dict_["reportUnknownVariableType"] = False
+        dict_["reportUnnecessaryComparison"] = False
+        dict_["reportUnnecessaryTypeIgnoreComment"] = True
+        dict_["reportUnusedCallResult"] = True
+        dict_["reportUnusedImport"] = False
+        dict_["reportUnusedVariable"] = False
+        dict_["typeCheckingMode"] = "strict"
+    return len(modifications) == 0
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/setup_ruff.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING
+
+from click import command
+from utilities.click import CONTEXT_SETTINGS
+from utilities.os import is_pytest
+
+from pre_commit_hooks.constants import (
+    DEFAULT_PYTHON_VERSION,
+    RUFF_TOML,
+    paths_argument,
+    python_version_option,
+)
+from pre_commit_hooks.utilities import (
+    ensure_contains,
+    ensure_not_contains,
+    get_set_array,
+    get_set_table,
+    run_all_maybe_raise,
+    yield_toml_doc,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import PathLike
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@python_version_option
+def _main(
+    *, paths: tuple[Path, ...], python_version: str = DEFAULT_PYTHON_VERSION
+) -> None:
+    if is_pytest():
+        return
+    run_all_maybe_raise(
+        *(
+            partial(_run, path=p.parent / RUFF_TOML, python_version=python_version)
+            for p in paths
+        )
+    )
+
+
+def _run(
+    *, path: PathLike = RUFF_TOML, python_version: str = DEFAULT_PYTHON_VERSION
+) -> bool:
+    modifications: set[Path] = set()
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        doc["target-version"] = f"py{python_version.replace('.', '')}"
+        doc["unsafe-fixes"] = True
+        fmt = get_set_table(doc, "format")
+        fmt["preview"] = True
+        fmt["skip-magic-trailing-comma"] = True
+        lint = get_set_table(doc, "lint")
+        lint["explicit-preview-rules"] = True
+        fixable = get_set_array(lint, "fixable")
+        ensure_contains(fixable, "ALL")
+        ignore = get_set_array(lint, "ignore")
+        ensure_contains(
+            ignore,
+            "ANN401",  # any-type
+            "ASYNC109",  # async-function-with-timeout
+            "C901",  # complex-structure
+            "CPY",  # flake8-copyright
+            "D",  # pydocstyle
+            "E501",  # line-too-long
+            "PD",  # pandas-vet
+            "PERF203",  # try-except-in-loop
+            "PLC0415",  # import-outside-top-level
+            "PLE1205",  # logging-too-many-args
+            "PLR0904",  # too-many-public-methods
+            "PLR0911",  # too-many-return-statements
+            "PLR0912",  # too-many-branches
+            "PLR0913",  # too-many-arguments
+            "PLR0915",  # too-many-statements
+            "PLR2004",  # magic-value-comparison
+            "PT012",  # pytest-raises-with-multiple-statements
+            "PT013",  # pytest-incorrect-pytest-import
+            "PYI041",  # redundant-numeric-union
+            "S202",  # tarfile-unsafe-members
+            "S310",  # suspicious-url-open-usage
+            "S311",  # suspicious-non-cryptographic-random-usage
+            "S602",  # subprocess-popen-with-shell-equals-true
+            "S603",  # subprocess-without-shell-equals-true
+            "S607",  # start-process-with-partial-path
+            # preview
+            "S101",  # assert
+            # formatter
+            "W191",  # tab-indentation
+            "E111",  # indentation-with-invalid-multiple
+            "E114",  # indentation-with-invalid-multiple-comment
+            "E117",  # over-indented
+            "COM812",  # missing-trailing-comma
+            "COM819",  # prohibited-trailing-comma
+            "ISC001",  # single-line-implicit-string-concatenation
+            "ISC002",  # multi-line-implicit-string-concatenation
+        )
+        lint["preview"] = True
+        select = get_set_array(lint, "select")
+        selected_rules = [
+            "RUF022",  # unsorted-dunder-all
+            "RUF029",  # unused-async
+        ]
+        ensure_contains(select, "ALL", *selected_rules)
+        extend_per_file_ignores = get_set_table(lint, "extend-per-file-ignores")
+        test_py = get_set_array(extend_per_file_ignores, "test_*.py")
+        test_py_rules = [
+            "S101",  # assert
+            "SLF001",  # private-member-access
+        ]
+        ensure_contains(test_py, *test_py_rules)
+        ensure_not_contains(ignore, *selected_rules, *test_py_rules)
+        bugbear = get_set_table(lint, "flake8-bugbear")
+        extend_immutable_calls = get_set_array(bugbear, "extend-immutable-calls")
+        ensure_contains(extend_immutable_calls, "typing.cast")
+        tidy_imports = get_set_table(lint, "flake8-tidy-imports")
+        tidy_imports["ban-relative-imports"] = "all"
+        isort = get_set_table(lint, "isort")
+        req_imps = get_set_array(isort, "required-imports")
+        ensure_contains(req_imps, "from __future__ import annotations")
+        isort["split-on-trailing-comma"] = False
+    return len(modifications) == 0
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/hooks/update_requirements.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from click import command, option
+from utilities.click import CONTEXT_SETTINGS, ListStrs
+from utilities.functions import max_nullable
+from utilities.os import is_pytest
+from utilities.subprocess import uv_pip_list
+from utilities.version import Version2, Version2Or3, Version3, parse_version_2_or_3
+
+from pre_commit_hooks.constants import PYPROJECT_TOML, paths_argument
+from pre_commit_hooks.utilities import (
+    get_pyproject_dependencies,
+    run_all_maybe_raise,
+    yield_toml_doc,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.packaging import Requirement
+    from utilities.types import PathLike, StrDict
+
+
+type Version1or2 = int | Version2
+type VersionSet = dict[str, Version2Or3]
+
+
+@command(**CONTEXT_SETTINGS)
+@paths_argument
+@option("--index", type=ListStrs(), default=None)
+@option("--native-tls", is_flag=True, default=False)
+def _main(
+    *, paths: tuple[Path, ...], index: list[str] | None = None, native_tls: bool = False
+) -> None:
+    if is_pytest():
+        return
+    versions = _get_versions(index=index, native_tls=native_tls)
+    run_all_maybe_raise(
+        *(
+            partial(_run, path=p, versions=versions, index=index, native_tls=native_tls)
+            for p in paths
+        )
+    )
+
+
+def _get_versions(
+    *, index: list[str] | None = None, native_tls: bool = False
+) -> dict[str, Version2Or3]:
+    out: StrDict = {}
+    for item in uv_pip_list(exclude_editable=True, index=index, native_tls=native_tls):
+        match item.version, item.latest_version:
+            case Version2(), Version2() | None:
+                out[item.name] = max_nullable([item.version, item.latest_version])
+            case Version3(), Version3() | None:
+                out[item.name] = max_nullable([item.version, item.latest_version])
+            case _:
+                raise TypeError(item.version, item.latest_version)
+    return out
+
+
+def _run(
+    *,
+    path: PathLike = PYPROJECT_TOML,
+    versions: VersionSet | None = None,
+    index: list[str] | None = None,
+    native_tls: bool = False,
+) -> bool:
+    func = partial(_transform, versions=versions, index=index, native_tls=native_tls)
+    modifications: set[Path] = set()
+    with yield_toml_doc(path, modifications=modifications) as doc:
+        get_pyproject_dependencies(doc).map_requirements(func)
+    return len(modifications) == 0
+
+
+def _transform(
+    requirement: Requirement,
+    /,
+    *,
+    versions: VersionSet | None = None,
+    index: list[str] | None = None,
+    native_tls: bool = False,
+) -> Requirement:
+    if versions is None:
+        versions_use = _get_versions(index=index, native_tls=native_tls)
+    else:
+        versions_use = versions
+    try:
+        lower = parse_version_2_or_3(requirement[">="])
+    except KeyError:
+        lower = None
+    try:
+        upper = _parse_version_1_or_2(requirement["<"])
+    except KeyError:
+        upper = None
+    try:
+        fixed = parse_version_2_or_3(requirement["=="])
+    except KeyError:
+        fixed = None
+    latest = versions_use.get(requirement.name)
+    new_lower: Version2Or3 | None = None
+    new_upper: Version1or2 | None = None
+    match lower, upper, fixed, latest:
+        case None, None, None, None:
+            pass
+        case None, None, Version2() | Version3(), Version2() | Version3() | None:
+            pass
+        case None, None, None, Version2() | Version3():
+            new_lower = latest
+            new_upper = latest.bump_major().major
+        case Version2() | Version3(), None, None, None:
+            new_lower = lower
+        case (Version2(), None, None, Version2()) | (
+            Version3(),
+            None,
+            None,
+            Version3(),
+        ):
+            new_lower = max(lower, latest)
+        case None, int() | Version2(), None, None:
+            new_upper = upper
+        case None, int(), None, Version2():
+            new_upper = max(upper, latest.bump_major().major)
+        case None, Version2(), None, Version3():
+            bumped = latest.bump_minor()
+            new_upper = max(upper, Version2(bumped.major, bumped.minor))
+        case (
+            (Version2(), int(), None, None)
+            | (Version3(), int(), None, None)
+            | (Version3(), Version2(), None, None)
+        ):
+            new_lower = lower
+            new_upper = upper
+        case (Version2(), int(), None, Version2()) | (
+            Version3(),
+            int(),
+            None,
+            Version3(),
+        ):
+            new_lower = max(lower, latest)
+            new_upper = new_lower.bump_major().major
+        case Version3(), Version2(), None, Version3():
+            new_lower = max(lower, latest)
+            new_upper = new_lower.bump_minor().version2
+        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
+
+
+def _parse_version_1_or_2(version: str, /) -> Version1or2:
+    try:
+        return int(version)
+    except ValueError:
+        return Version2.parse(version)
+
+
+if __name__ == "__main__":
+    _main()

pre_commit_hooks/types.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from tomlkit.container import Container
+from tomlkit.items import AoT, Array, Table
+from utilities.packaging import Requirement
+from utilities.types import StrDict
+
+type ArrayLike = AoT | list[str] | list[StrDict]
+type ContainerLike = Container | Table
+
+
+type FuncRequirement = Callable[[Requirement], Requirement]
+type TransformArray = Callable[[Array], None]
+
+
+__all__ = ["ArrayLike", "ContainerLike", "FuncRequirement", "TransformArray"]