dycw-utilities 0.138.3__tar.gz → 0.138.5__tar.gz

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.138.3
+Version: 0.138.5
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/pyproject.toml

@@ -105,7 +105,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.138.3"
+version = "0.138.5"
 
 [project.optional-dependencies]
 logging = [
@@ -133,7 +133,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.138.3"
+current_version = "0.138.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/src/tests/test_pathlib.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from shutil import copytree
 from typing import TYPE_CHECKING, Self
 
-from hypothesis import given, settings
-from hypothesis.strategies import integers, sets
+from hypothesis import HealthCheck, given, settings
+from hypothesis.strategies import DataObject, data, integers, sets
 from pytest import mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
@@ -17,13 +18,15 @@ from utilities.pathlib import (
     expand_path,
     get_path,
     get_root,
+    is_sub_path,
     list_dir,
     temp_cwd,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.tempfile import TemporaryDirectory
 
 if TYPE_CHECKING:
-    from utilities.types import MaybeCallablePathLike
+    from utilities.types import MaybeCallablePathLike, PathLike
 
 
 class TestEnsureSuffix:
@@ -98,34 +101,101 @@ class TestGetPath:
 
 
 class TestGetRoot:
-    @given(repo=git_repos())
-    @settings(max_examples=1)
-    def test_git(self, *, repo: Path) -> None:
-        root = get_root(path=repo)
+    @given(data=data(), repo=git_repos())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_git_dir(self, *, data: DataObject, repo: Path) -> None:
+        path = repo.joinpath(data.draw(paths()))
+        path.mkdir(parents=True, exist_ok=True)
+        root = get_root(path=path)
         expected = repo.resolve()
         assert root == expected
 
-    @given(root=temp_paths())
-    @settings(max_examples=1)
-    def test_envrc(self, *, root: Path) -> None:
-        root.joinpath(".envrc").touch()
-        result = get_root(path=root)
-        assert result == root
-
-    @given(root=temp_paths())
-    @settings(max_examples=1)
-    def test_envrc_from_inside(self, *, root: Path) -> None:
-        root.joinpath(".envrc").touch()
-        path = root.joinpath("foo", "bar", "baz")
-        path.mkdir(parents=True)
+    @given(data=data(), repo=git_repos())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_git_file(self, *, data: DataObject, repo: Path) -> None:
+        path = repo.joinpath(data.draw(paths(min_depth=1)))
+        path.touch()
+        root = get_root(path=path)
+        expected = repo.resolve()
+        assert root == expected
+
+    @given(data=data())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_envrc(self, *, data: DataObject, tmp_path: Path) -> None:
+        tmp_path.joinpath(".envrc").touch()
+        path = tmp_path.joinpath(data.draw(paths()))
         result = get_root(path=path)
-        assert result == root
+        expected = tmp_path.resolve()
+        assert result == expected
+
+    @given(data=data(), repo=git_repos())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_git_and_envrc(self, *, data: DataObject, repo: Path) -> None:
+        repo.joinpath(".envrc").touch()
+        path = repo.joinpath(data.draw(paths()))
+        root = get_root(path=path)
+        expected = repo.resolve()
+        assert root == expected
+
+    @given(data=data(), repo=git_repos())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_git_with_envrc_inside(self, *, data: DataObject, repo: Path) -> None:
+        path = repo.joinpath(data.draw(paths(min_depth=1)))
+        path.mkdir(parents=True)
+        path.joinpath(".envrc").touch()
+        root = get_root(path=path)
+        expected = path.resolve()
+        assert root == expected
+
+    @given(data=data(), repo=git_repos())
+    @settings(
+        max_examples=1, suppress_health_check={HealthCheck.function_scoped_fixture}
+    )
+    def test_envrc_with_git_inside(self, *, data: DataObject, repo: Path) -> None:
+        with TemporaryDirectory() as temp:
+            temp.joinpath(".envrc").touch()
+            path = temp.joinpath(data.draw(paths(min_depth=1)))
+            _ = copytree(repo, path)
+            root = get_root(path=path)
+            expected = path.resolve()
+            assert root == expected
 
     def test_error(self, *, tmp_path: Path) -> None:
         with raises(GetRootError, match="Unable to determine root from '.*'"):
             _ = get_root(path=tmp_path)
 
 
+class TestIsSubPath:
+    @mark.parametrize(
+        ("x", "y", "strict", "expected"),
+        [
+            param("foo", "foo", False, True),
+            param("foo", "foo", True, False),
+            param("foo/bar", "foo", False, True),
+            param("foo/bar", "foo", True, True),
+            param("foo/bar", "foo/baz", False, False),
+            param("foo/bar", "foo/baz", True, False),
+            param("foo", "foo/bar", False, False),
+            param("foo", "foo/bar", True, False),
+        ],
+    )
+    def test_main(
+        self, *, x: PathLike, y: PathLike, strict: bool, expected: bool
+    ) -> None:
+        result = is_sub_path(x, y, strict=strict)
+        assert result is expected
+
+
 class TestListDir:
     @given(root=temp_paths(), nums=sets(integers(0, 100), max_size=10))
     def test_main(self, *, root: Path, nums: set[str]) -> None:

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.138.3"
+__version__ = "0.138.5"

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/src/utilities/pathlib.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from contextlib import contextmanager, suppress
+from contextlib import contextmanager
 from dataclasses import dataclass
 from itertools import chain
 from os import chdir
@@ -11,6 +11,7 @@ from re import IGNORECASE, search
 from subprocess import PIPE, CalledProcessError, check_output
 from typing import TYPE_CHECKING, assert_never, overload, override
 
+from utilities.errors import ImpossibleCaseError
 from utilities.sentinel import Sentinel, sentinel
 
 if TYPE_CHECKING:
@@ -73,23 +74,50 @@ def get_path(
 def get_root(*, path: MaybeCallablePathLike | None = None) -> Path:
     """Get the root of a path."""
     path = get_path(path=path)
+    path_dir = path.parent if path.is_file() else path
     try:
         output = check_output(
-            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=path, text=True
+            ["git", "rev-parse", "--show-toplevel"],
+            stderr=PIPE,
+            cwd=path_dir,
+            text=True,
         )
     except CalledProcessError as error:
         # newer versions of git report "Not a git repository", whilst older
         # versions report "not a git repository"
         if not search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
             raise  # pragma: no cover
+        root_git = None
     else:
-        return Path(output.strip("\n"))
-    all_paths = list(chain([path], path.parents))
-    with suppress(StopIteration):
-        return next(
-            p for p in all_paths if any(p_i.name == ".envrc" for p_i in p.iterdir())
+        root_git = Path(output.strip("\n")).resolve()
+    all_paths = list(chain([path_dir], path_dir.parents))
+    try:
+        root_envrc = next(
+            p.resolve()
+            for p in all_paths
+            if any(p_i.name == ".envrc" for p_i in p.iterdir())
         )
-    raise GetRootError(path=path)
+    except StopIteration:
+        root_envrc = None
+    match root_git, root_envrc:
+        case None, None:
+            raise GetRootError(path=path)
+        case Path(), None:
+            return root_git
+        case None, Path():
+            return root_envrc
+        case Path(), Path():
+            if root_git == root_envrc:
+                return root_git
+            if is_sub_path(root_git, root_envrc, strict=True):
+                return root_git
+            if is_sub_path(root_envrc, root_git, strict=True):
+                return root_envrc
+            raise ImpossibleCaseError(  # pragma: no cover
+                case=[f"{root_git=}", f"{root_envrc=}"]
+            )
+        case _ as never:
+            assert_never(never)
 
 
 @dataclass(kw_only=True, slots=True)
@@ -104,6 +132,15 @@ class GetRootError(Exception):
 ##
 
 
+def is_sub_path(x: PathLike, y: PathLike, /, *, strict: bool = False) -> bool:
+    """Check if a path is a sub path of another."""
+    x, y = [Path(i).resolve() for i in [x, y]]
+    return x.is_relative_to(y) and not (strict and y.is_relative_to(x))
+
+
+##
+
+
 def list_dir(path: PathLike, /) -> Sequence[Path]:
     """List the contents of a directory."""
     return sorted(Path(path).iterdir())
@@ -123,4 +160,12 @@ def temp_cwd(path: PathLike, /) -> Iterator[None]:
         chdir(prev)
 
 
-__all__ = ["PWD", "ensure_suffix", "expand_path", "get_path", "list_dir", "temp_cwd"]
+__all__ = [
+    "PWD",
+    "ensure_suffix",
+    "expand_path",
+    "get_path",
+    "is_sub_path",
+    "list_dir",
+    "temp_cwd",
+]

{dycw_utilities-0.138.3 → dycw_utilities-0.138.5}/src/utilities/pytest.py

@@ -12,9 +12,8 @@ from whenever import ZonedDateTime
 
 from utilities.atomicwrites import writer
 from utilities.functools import cache
-from utilities.git import get_repo_root
 from utilities.hashlib import md5_hash
-from utilities.pathlib import ensure_suffix
+from utilities.pathlib import ensure_suffix, get_root
 from utilities.platform import (
     IS_LINUX,
     IS_MAC,
@@ -241,9 +240,7 @@ def _skipif_recent(*, root: PathLike | None = None, delta: TimeDelta = SECOND) -
 
 def _get_path(*, root: PathLike | None = None) -> Path:
     if root is None:
-        root_use = get_repo_root().joinpath(  # pragma: no cover
-            ".pytest_cache", "throttle"
-        )
+        root_use = get_root().joinpath(".pytest_cache", "throttle")  # pragma: no cover
     else:
         root_use = root
     return Path(root_use, _md5_hash_cached(_get_name()))

dycw_utilities-0.138.3/src/tests/test_git.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from hypothesis import given, settings
-from pytest import raises
-
-from utilities.git import GetRepoRootError, get_repo_root
-from utilities.hypothesis import git_repos
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-class TestGetRepoRoot:
-    @given(repo=git_repos())
-    @settings(max_examples=1)
-    def test_main(self, *, repo: Path) -> None:
-        root = get_repo_root(path=repo)
-        expected = repo.resolve()
-        assert root == expected
-
-    def test_error(self, *, tmp_path: Path) -> None:
-        with raises(
-            GetRepoRootError, match="Path is not part of a `git` repository: .*"
-        ):
-            _ = get_repo_root(path=tmp_path)

dycw_utilities-0.138.3/src/utilities/git.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-from re import IGNORECASE, search
-from subprocess import PIPE, CalledProcessError, check_output
-from typing import TYPE_CHECKING, override
-
-from utilities.pathlib import PWD
-
-if TYPE_CHECKING:
-    from utilities.types import PathLike
-
-
-def get_repo_root(*, path: PathLike = PWD) -> Path:
-    """Get the repo root."""
-    try:
-        output = check_output(
-            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=path, text=True
-        )
-    except CalledProcessError as error:
-        # newer versions of git report "Not a git repository", whilst older
-        # versions report "not a git repository"
-        if search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
-            raise GetRepoRootError(cwd=path) from error
-        raise  # pragma: no cover
-    else:
-        return Path(output.strip("\n"))
-
-
-@dataclass(kw_only=True, slots=True)
-class GetRepoRootError(Exception):
-    cwd: PathLike
-
-    @override
-    def __str__(self) -> str:
-        return f"Path is not part of a `git` repository: {self.cwd}"
-
-
-__all__ = ["GetRepoRootError", "get_repo_root"]