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

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

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

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

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

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

@@ -14,10 +14,15 @@ from utilities.dataclasses import replace_non_sentinel
 from utilities.hypothesis import git_repos, paths, temp_paths
 from utilities.pathlib import (
     GetRootError,
+    _GetTailDisambiguate,
+    _GetTailEmptyError,
+    _GetTailLengthError,
+    _GetTailNonUniqueError,
     ensure_suffix,
     expand_path,
     get_path,
     get_root,
+    get_tail,
     is_sub_path,
     list_dir,
     temp_cwd,
@@ -175,6 +180,49 @@ class TestGetRoot:
             _ = get_root(path=tmp_path)
 
 
+class TestGetTail:
+    @mark.parametrize(
+        ("path", "root", "disambiguate", "expected"),
+        [
+            param("foo/bar/baz", "foo", "raise", Path("bar/baz")),
+            param("foo/bar/baz", "foo/bar", "raise", Path("baz")),
+            param("a/b/c/d/a/b/c/d/e", "b/c", "earlier", Path("d/a/b/c/d/e")),
+            param("a/b/c/d/a/b/c/d/e", "b/c", "later", Path("d/e")),
+        ],
+    )
+    def test_main(
+        self,
+        *,
+        path: PathLike,
+        root: PathLike,
+        disambiguate: _GetTailDisambiguate,
+        expected: Path,
+    ) -> None:
+        tail = get_tail(path, root, disambiguate=disambiguate)
+        assert tail == expected
+
+    def test_error_length(self) -> None:
+        with raises(
+            _GetTailLengthError,
+            match="Unable to get the tail of 'foo' with root of length 2",
+        ):
+            _ = get_tail("foo", "bar/baz")
+
+    def test_error_empty(self) -> None:
+        with raises(
+            _GetTailEmptyError,
+            match="Unable to get the tail of 'foo/bar' with root 'baz'",
+        ):
+            _ = get_tail("foo/bar", "baz")
+
+    def test_error_non_unique(self) -> None:
+        with raises(
+            _GetTailNonUniqueError,
+            match="Path '.*' must contain exactly one tail with root 'b'; got '.*', '.*' and perhaps more",
+        ):
+            _ = get_tail("a/b/c/a/b/c", "b")
+
+
 class TestIsSubPath:
     @mark.parametrize(
         ("x", "y", "strict", "expected"),

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

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

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

@@ -9,7 +9,7 @@ from os.path import expandvars
 from pathlib import Path
 from re import IGNORECASE, search
 from subprocess import PIPE, CalledProcessError, check_output
-from typing import TYPE_CHECKING, assert_never, overload, override
+from typing import TYPE_CHECKING, Literal, assert_never, overload, override
 
 from utilities.errors import ImpossibleCaseError
 from utilities.sentinel import Sentinel, sentinel
@@ -132,6 +132,85 @@ class GetRootError(Exception):
 ##
 
 
+type _GetTailDisambiguate = Literal["raise", "earlier", "later"]
+
+
+def get_tail(
+    path: PathLike, root: PathLike, /, *, disambiguate: _GetTailDisambiguate = "raise"
+) -> Path:
+    """Get the tail of a path following a root match."""
+    path_parts, root_parts = [Path(p).parts for p in [path, root]]
+    len_path, len_root = map(len, [path_parts, root_parts])
+    if len_root > len_path:
+        raise _GetTailLengthError(path=path, root=root, len_root=len_root)
+    candidates = {
+        i + len_root: path_parts[i : i + len_root]
+        for i in range(len_path + 1 - len_root)
+    }
+    matches = {k: v for k, v in candidates.items() if v == root_parts}
+    match len(matches), disambiguate:
+        case 0, _:
+            raise _GetTailEmptyError(path=path, root=root)
+        case 1, _:
+            return _get_tail_core(path, next(iter(matches)))
+        case _, "raise":
+            first, second, *_ = matches
+            raise _GetTailNonUniqueError(
+                path=path,
+                root=root,
+                first=_get_tail_core(path, first),
+                second=_get_tail_core(path, second),
+            )
+        case _, "earlier":
+            return _get_tail_core(path, next(iter(matches)))
+        case _, "later":
+            return _get_tail_core(path, next(iter(reversed(matches))))
+        case _ as never:
+            assert_never(never)
+
+
+def _get_tail_core(path: PathLike, i: int, /) -> Path:
+    parts = Path(path).parts
+    return Path(*parts[i:])
+
+
+@dataclass(kw_only=True, slots=True)
+class GetTailError(Exception):
+    path: PathLike
+    root: PathLike
+
+
+@dataclass(kw_only=True, slots=True)
+class _GetTailLengthError(GetTailError):
+    len_root: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to get the tail of {str(self.path)!r} with root of length {self.len_root}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _GetTailEmptyError(GetTailError):
+    @override
+    def __str__(self) -> str:
+        return (
+            f"Unable to get the tail of {str(self.path)!r} with root {str(self.root)!r}"
+        )
+
+
+@dataclass(kw_only=True, slots=True)
+class _GetTailNonUniqueError(GetTailError):
+    first: Path
+    second: Path
+
+    @override
+    def __str__(self) -> str:
+        return f"Path {str(self.path)!r} must contain exactly one tail with root {str(self.root)!r}; got {str(self.first)!r}, {str(self.second)!r} and perhaps more"
+
+
+##
+
+
 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]]
@@ -162,9 +241,11 @@ def temp_cwd(path: PathLike, /) -> Iterator[None]:
 
 __all__ = [
     "PWD",
+    "GetTailError",
     "ensure_suffix",
     "expand_path",
     "get_path",
+    "get_tail",
     "is_sub_path",
     "list_dir",
     "temp_cwd",