Reduce time complexity of URL subtraction

tests/test_url.py

@@ -93,7 +93,9 @@ def test_str():
     ],
 )
 def test_sub(target: str, base: str, expected: str):
-    assert URL(target) - URL(base) == URL(expected)
+    expected_result = URL(expected)
+    result = URL(target) - URL(base)
+    assert result == expected_result
 
 
 def test_sub_with_different_schemes():

yarl/_path.py

@@ -1,9 +1,10 @@
 """Utilities for working with paths."""
 
-from collections.abc import Sequence
+from collections.abc import Generator, Sequence
 from contextlib import suppress
 from itertools import chain
 from pathlib import PurePosixPath
+from typing import Union
 
 
 def normalize_path_segments(segments: Sequence[str]) -> list[str]:
@@ -43,6 +44,50 @@ def normalize_path(path: str) -> str:
     return prefix + "/".join(normalize_path_segments(segments))
 
 
+class SimplePath:
+    __slots__ = ("_tail", "_root", "_trailer", "normalized")
+
+    def __init__(self, path: str, strip_root: bool = False) -> None:
+        """Initialize a SimplePath object."""
+        self._tail = [x for x in path.split("/") if x and x != "."]
+
+        if strip_root:
+            if path[-1] != "/" and len(self._tail) > 0:
+                self._tail.pop()
+
+        self._root = "/" if path[0] == "/" else ""
+        self._trailer = "." if not path else ""
+        self.normalized = self._root + "/".join(self._tail) or self._trailer
+
+    @property
+    def name(self) -> str:
+        """Return the last part of the path."""
+        return (self._tail[-1] if self._tail else "") or self._trailer
+
+    @property
+    def parts_count(self) -> int:
+        """Return the number of parts in the path."""
+        return len(self._tail) + bool(self._root)
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        if self._root:
+            return (self._root,) + tuple(self._tail)
+        return tuple(self._tail)
+
+    def parents(self) -> Generator["SimplePath", None, None]:
+        """Return a list of parent paths for a given path."""
+        for i in range(len(self._tail) - 1, -1, -1):
+            parent = object.__new__(SimplePath)
+            parent._tail = self._tail[:i]
+            parent._root = self._root
+            parent._trailer = self._trailer
+            parent.normalized = self._root + ("/".join(parent._tail) or self._trailer)
+            yield parent
+
+
 def calculate_relative_path(target: str, base: str) -> str:
     """Return the relative path between two other paths.
 
@@ -52,20 +97,44 @@ def calculate_relative_path(target: str, base: str) -> str:
     target = target or "/"
     base = base or "/"
 
-    target_path = PurePosixPath(target)
-    base_path = PurePosixPath(base)
+    target_path = SimplePath(target)
+    base_path = SimplePath(base, strip_root=True)
 
-    if base[-1] != "/":
-        base_path = base_path.parent
-
-    for step, path in enumerate(chain((base_path,), base_path.parents)):
-        if path == target_path or path in target_path.parents:
+    target_path_parent_strs: Union[set[str], None] = None
+    for step, path in enumerate(chain((base_path,), base_path.parents())):
+        if path.normalized == target_path.normalized:
             break
-        elif path.name == "..":
-            raise ValueError(f"'..' segment in {str(base_path)!r} cannot be walked")
+        # If the target_path_parent_strs is already built use the quick path
+        if target_path_parent_strs is not None:
+            if path.normalized in target_path_parent_strs:
+                break
+            elif path.name == "..":
+                raise ValueError(
+                    f"'..' segment in {base_path.normalized!r} cannot be walked"
+                )
+            continue
+        target_path_parent_strs = set()
+        # We check one at a time because enumerating parents
+        # builds the value on demand, and we want to stop
+        # as soon as we find the common parent
+        for parent in target_path.parents():
+            if parent.normalized == base_path.normalized:
+                break
+            target_path_parent_strs.add(parent.normalized)
+        else:
+            # If we didn't break, it means we didn't find a common parent
+            if path.name == "..":
+                raise ValueError(
+                    f"'..' segment in {base_path.normalized!r} cannot be walked"
+                )
+            continue
+        break
     else:
-        raise ValueError(
-            f"{str(target_path)!r} and {str(base_path)!r} have different anchors"
+        msg = (
+            f"{target_path.normalized!r} and {base_path.normalized!r} "
+            "have different anchors"
         )
-    offset = len(path.parts)
+        raise ValueError(msg)
+
+    offset = path.parts_count
     return str(PurePosixPath(*("..",) * step, *target_path.parts[offset:]))