hlsync 1.17.2__py3-none-any.whl

hlsync/comparison.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import PurePosixPath
+from typing import Literal
+
+from hlsync.selection import FileSelection, SelectionError
+from hlsync.snapshot import EntryKind, TreeEntry, TreeSnapshot
+
+Direction = Literal["push", "pull"]
+ComparisonState = Literal[
+    "identical",
+    "local-only",
+    "remote-only",
+    "changed",
+    "destination-newer",
+    "excluded",
+    "remote-excluded",
+    "type-conflict",
+    "symlink-conflict",
+]
+PlanAction = Literal[
+    "unchanged",
+    "skip",
+    "create-remote",
+    "upload",
+    "replace-remote",
+    "replace-local",
+    "delete-remote",
+    "conflict",
+    "excluded",
+    "untraversed",
+]
+
+
+@dataclass(frozen=True)
+class ComparisonEntry:
+    path: str
+    state: ComparisonState
+    action: PlanAction
+    local_kind: EntryKind | None
+    remote_kind: EntryKind | None
+
+
+@dataclass(frozen=True)
+class ComparisonPlan:
+    direction: Direction
+    prune_remote: bool
+    entries: tuple[ComparisonEntry, ...]
+
+    @property
+    def differences(self) -> tuple[ComparisonEntry, ...]:
+        return tuple(entry for entry in self.entries if entry.action != "unchanged")
+
+
+def mark_untraversed_directories(
+    plan: ComparisonPlan,
+    paths: frozenset[str],
+) -> ComparisonPlan:
+    """Make directory boundaries visible without making them executable."""
+    retained_ancestors = frozenset(
+        parent.as_posix()
+        for path in paths
+        for parent in PurePosixPath(path).parents
+    )
+    return replace(
+        plan,
+        entries=tuple(
+            replace(entry, action="untraversed")
+            if entry.path in paths and entry.action != "excluded"
+            else replace(entry, action="skip")
+            if entry.action == "delete-remote"
+            and entry.remote_kind == "directory"
+            and entry.path in retained_ancestors
+            else entry
+            for entry in plan.entries
+        ),
+    )
+
+
+def _comparable_timestamps(
+    local: TreeEntry, remote: TreeEntry
+) -> tuple[int, int] | None:
+    if (
+        local.modified_ns is None
+        or remote.modified_ns is None
+        or local.timestamp_precision_ns is None
+        or remote.timestamp_precision_ns is None
+    ):
+        return None
+    precision_ns = max(
+        local.timestamp_precision_ns,
+        remote.timestamp_precision_ns,
+    )
+    return (
+        local.modified_ns // precision_ns,
+        remote.modified_ns // precision_ns,
+    )
+
+
+def _files_identical(local: TreeEntry, remote: TreeEntry) -> bool:
+    if local.size != remote.size:
+        return False
+    timestamps = _comparable_timestamps(local, remote)
+    return timestamps is not None and timestamps[0] == timestamps[1]
+
+
+def _source_is_newer(
+    local: TreeEntry, remote: TreeEntry, direction: Direction
+) -> bool:
+    timestamps = _comparable_timestamps(local, remote)
+    if timestamps is None:
+        return False
+    local_time, remote_time = timestamps
+    return local_time > remote_time if direction == "push" else remote_time > local_time
+
+
+def build_comparison(
+    local: TreeSnapshot,
+    remote: TreeSnapshot,
+    *,
+    direction: Direction = "push",
+    prune_remote: bool = False,
+    force: bool = False,
+    selector: FileSelection | None = None,
+) -> ComparisonPlan:
+    local_entries = {entry.path: entry for entry in local.entries}
+    remote_entries = {entry.path: entry for entry in remote.entries}
+    remote_exclusion_roots = tuple(
+        PurePosixPath(entry.path)
+        for entry in (*local.entries, *remote.entries)
+        if entry.remote_excluded
+    )
+    comparison: list[ComparisonEntry] = []
+
+    for path in sorted(local_entries.keys() | remote_entries.keys()):
+        candidate_path = PurePosixPath(path)
+        if any(root in candidate_path.parents for root in remote_exclusion_roots):
+            continue
+        local_entry = local_entries.get(path)
+        remote_entry = remote_entries.get(path)
+        if selector is not None and not selector.matches(path):
+            continue
+        protected_entry = next(
+            (
+                entry
+                for entry in (remote_entry, local_entry)
+                if entry is not None and entry.remote_excluded
+            ),
+            None,
+        )
+        if protected_entry is not None:
+            comparison.append(
+                ComparisonEntry(
+                    path=path,
+                    state="remote-excluded",
+                    action="excluded",
+                    local_kind=local_entry.kind if local_entry else None,
+                    remote_kind=remote_entry.kind if remote_entry else None,
+                )
+            )
+            continue
+        if any(
+            entry is not None and entry.excluded
+            for entry in (local_entry, remote_entry)
+        ):
+            excluded_directory = any(
+                entry is not None
+                and entry.excluded
+                and entry.kind == "directory"
+                for entry in (local_entry, remote_entry)
+            )
+            if (
+                direction == "push"
+                and prune_remote
+                and remote_entry is not None
+                and not excluded_directory
+            ):
+                comparison.append(
+                    ComparisonEntry(
+                        path=path,
+                        state="excluded",
+                        action="delete-remote",
+                        local_kind=local_entry.kind if local_entry else None,
+                        remote_kind=remote_entry.kind,
+                    )
+                )
+                continue
+            comparison.append(
+                ComparisonEntry(
+                    path=path,
+                    state="excluded",
+                    action="excluded",
+                    local_kind=local_entry.kind if local_entry else None,
+                    remote_kind=remote_entry.kind if remote_entry else None,
+                )
+            )
+            continue
+        if local_entry is None:
+            comparison.append(
+                ComparisonEntry(
+                    path=path,
+                    state="remote-only",
+                    action="delete-remote" if prune_remote else "skip",
+                    local_kind=None,
+                    remote_kind=remote_entry.kind if remote_entry else None,
+                )
+            )
+            continue
+        if remote_entry is None:
+            if local_entry.kind == "symlink":
+                action: PlanAction = "conflict"
+            elif direction == "pull":
+                action = "skip"
+            elif local_entry.kind == "directory":
+                action = "create-remote"
+            else:
+                action = "upload"
+            comparison.append(
+                ComparisonEntry(
+                    path=path,
+                    state="local-only",
+                    action=action,
+                    local_kind=local_entry.kind,
+                    remote_kind=None,
+                )
+            )
+            continue
+        if local_entry.kind != remote_entry.kind:
+            state: ComparisonState = "type-conflict"
+            action = "conflict"
+        elif local_entry.kind == "symlink":
+            state = "symlink-conflict"
+            action = "conflict"
+        elif local_entry.kind == "directory" or _files_identical(
+            local_entry, remote_entry
+        ):
+            state = "identical"
+            action = "unchanged"
+        elif force or _source_is_newer(local_entry, remote_entry, direction):
+            state = "changed"
+            action = "replace-remote" if direction == "push" else "replace-local"
+        else:
+            state = "destination-newer"
+            action = "conflict"
+        comparison.append(
+            ComparisonEntry(
+                path=path,
+                state=state,
+                action=action,
+                local_kind=local_entry.kind,
+                remote_kind=remote_entry.kind,
+            )
+        )
+
+    protected_paths = tuple(
+        PurePosixPath(entry.path)
+        for entry in comparison
+        if entry.state == "remote-excluded"
+    )
+    if protected_paths:
+        comparison = [
+            replace(entry, action="skip")
+            if entry.action == "delete-remote"
+            and entry.remote_kind == "directory"
+            and any(
+                PurePosixPath(entry.path) in path.parents
+                for path in protected_paths
+            )
+            else entry
+            for entry in comparison
+        ]
+
+    if selector is not None and not comparison:
+        raise SelectionError(
+            f"file selector '{selector.pattern}' matched no paths"
+        )
+    return ComparisonPlan(direction, prune_remote, tuple(comparison))