protonfs 0.1.dev43__py3-none-any.whl

protonfs/commands/setup.py

@@ -0,0 +1,179 @@
+# src/protonfs/commands/setup.py
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import click
+
+from protonfs.commands.push import push as push_files
+from protonfs.config import Config, init_config, load_config
+from protonfs.context import RepoContext
+from protonfs.drive import DriveClient
+from protonfs.ignore import init_ignore
+from protonfs.index import IndexStore
+from protonfs.lfs import find_pointer_stubs, is_lfs_tracked
+
+
+def ensure_cli_present(drive: DriveClient) -> str:
+    version = drive.version()
+    if version is None:
+        raise click.ClickException(
+            "proton-drive CLI not found. Install it from "
+            "https://proton.me/download/drive/cli/index.html and ensure it's on PATH, "
+            "then re-run `protonfs setup`."
+        )
+    return version
+
+
+def ensure_authenticated(drive: DriveClient) -> None:
+    if not drive.is_authenticated():
+        raise click.ClickException(
+            "Not authenticated with Proton Drive. Run `proton-drive auth login`, "
+            "then re-run `protonfs setup`."
+        )
+
+
+def ensure_config(root: Path) -> Config:
+    existing = load_config(root)
+    if existing is not None:
+        return existing
+    remote_root = click.prompt("Remote Drive root path for this repo (e.g. /my-files/myproject)")
+    return init_config(root, remote_root)
+
+
+def _untrack_lfs_patterns(root: Path) -> list[str]:
+    gitattributes = root / ".gitattributes"
+    if not gitattributes.exists():
+        return []
+    removed_patterns: list[str] = []
+    kept_lines: list[str] = []
+    for line in gitattributes.read_text().splitlines():
+        if "filter=lfs" in line:
+            removed_patterns.append(line.split()[0])
+        else:
+            kept_lines.append(line)
+    gitattributes.write_text("\n".join(kept_lines) + ("\n" if kept_lines else ""))
+    return removed_patterns
+
+
+def _append_gitignore(root: Path, patterns: list[str]) -> None:
+    gitignore = root / ".gitignore"
+    existing = gitignore.read_text() if gitignore.exists() else ""
+    existing_lines = {line.strip() for line in existing.splitlines()}
+    lines_to_add = [p for p in patterns if p.strip() not in existing_lines]
+    if not lines_to_add:
+        return
+    with gitignore.open("a") as fh:
+        if existing and not existing.endswith("\n"):
+            fh.write("\n")
+        fh.write("\n".join(lines_to_add) + "\n")
+
+
+def migrate_lfs(ctx: RepoContext, dry_run: bool = False) -> bool:
+    root = ctx.root
+    if not is_lfs_tracked(root):
+        click.echo("No git-lfs tracking found -- skipping migration.")
+        return False
+
+    click.echo("git-lfs tracking detected.")
+    if dry_run:
+        click.echo("[dry-run] Would run: git lfs pull")
+        click.echo("[dry-run] Would upload LFS-tracked files to Drive via `protonfs push`.")
+        click.echo(
+            "[dry-run] Would remove LFS filter rules from .gitattributes, add to .gitignore,"
+        )
+        click.echo("[dry-run] git rm --cached the affected paths, and commit.")
+        return True
+
+    click.echo("Materializing real file content (git lfs pull)...")
+    subprocess.run(["git", "-C", str(root), "lfs", "pull"], check=True)
+
+    click.echo("Uploading LFS-tracked files to Drive before touching git tracking...")
+    result = push_files(ctx, subpath=None, resolve=None, dry_run=False)
+    if result.failed_items:
+        raise click.ClickException(
+            f"{result.failed_items} file(s) failed to upload -- aborting migration before "
+            "touching git tracking. Re-run `protonfs setup` once uploads succeed."
+        )
+
+    click.confirm(
+        f"Uploaded {result.transferred_items} file(s) to Drive. This will now remove LFS "
+        "filter rules from .gitattributes, gitignore the same paths, `git rm --cached` them, "
+        "and create one commit. Continue?",
+        abort=True,
+    )
+    patterns = _untrack_lfs_patterns(root)
+    _append_gitignore(root, patterns)
+    try:
+        subprocess.run(
+            ["git", "-C", str(root), "add", ".gitattributes", ".gitignore"], check=True
+        )
+        for pattern in patterns:
+            subprocess.run(
+                ["git", "-C", str(root), "rm", "-r", "--cached", "--ignore-unmatch", pattern],
+                check=True,
+            )
+        subprocess.run(
+            [
+                "git", "-C", str(root), "commit", "-m",
+                "chore: migrate dump storage from git-lfs to protonfs/Proton Drive",
+            ],
+            check=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(
+            f"git step of the LFS migration failed ({exc}). The files were already "
+            "uploaded to Drive successfully, but your working tree may now be "
+            "mid-migration -- inspect `git status` and revert/complete the git state "
+            "manually before re-running `protonfs setup`."
+        ) from exc
+    click.echo("Migration commit created. Review it before pushing.")
+    return True
+
+
+def clean_pointer_stubs(root: Path) -> int:
+    stubs = find_pointer_stubs(root, Path("."))
+    for stub in stubs:
+        stub.unlink()
+    return len(stubs)
+
+
+def maybe_uninstall_lfs_filters(root: Path) -> None:
+    gitattributes = root / ".gitattributes"
+    still_has_lfs = gitattributes.exists() and "filter=lfs" in gitattributes.read_text()
+    if still_has_lfs:
+        return
+    result = subprocess.run(["git", "-C", str(root), "lfs", "env"], capture_output=True, text=True)
+    if result.returncode != 0:
+        return  # git-lfs not installed at all -- nothing to uninstall
+    click.echo("No LFS patterns remain in .gitattributes; running `git lfs uninstall`.")
+    subprocess.run(["git", "-C", str(root), "lfs", "uninstall"], check=True)
+
+
+def run_setup(root: Path, dry_run: bool = False) -> None:
+    drive = DriveClient()
+    version = ensure_cli_present(drive)
+    click.echo(f"proton-drive CLI found: {version}")
+
+    ensure_authenticated(drive)
+    click.echo("Authenticated with Proton Drive.")
+
+    config = ensure_config(root)
+    init_ignore(root)
+    config_file = root / ".protonfs" / "config.json"
+    click.echo(f"Config ready at {config_file} (remote_root={config.remote_root}).")
+
+    ctx = RepoContext(root=root, config=config, index=IndexStore(root), drive=drive)
+    migrated = migrate_lfs(ctx, dry_run=dry_run)
+
+    removed = clean_pointer_stubs(root)
+    if removed:
+        click.echo(f"Removed {removed} leftover git-lfs pointer stub file(s).")
+    else:
+        click.echo("No leftover git-lfs pointer stubs found.")
+
+    if migrated and not dry_run:
+        maybe_uninstall_lfs_filters(root)
+
+    click.echo("protonfs setup complete.")

protonfs/commands/status.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+
+from protonfs.context import RepoContext
+from protonfs.diff import classify
+from protonfs.ignore import IgnoreMatcher
+from protonfs.localscan import scan
+
+
+def compute_status(ctx: RepoContext, subpath: str | None) -> Counter:
+    ignore = IgnoreMatcher.from_file(ctx.root)
+    scan_root = Path(subpath) if subpath else Path(".")
+    local = scan(ctx.root, scan_root, ignore, ctx.index, low_io=ctx.config.defaults.low_io)
+    entries = classify(local, ctx.index)
+    return Counter(entry.state.value for entry in entries)

protonfs/config.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+CONFIG_DIR_NAME = ".protonfs"
+CONFIG_FILE_NAME = "config.json"
+
+
+@dataclass
+class Defaults:
+    on_conflict: str = "skip"
+    low_io: bool = False
+
+
+@dataclass
+class Config:
+    remote_root: str
+    device_id: str
+    defaults: Defaults = field(default_factory=Defaults)
+
+    def to_dict(self) -> dict:
+        return {
+            "remote_root": self.remote_root,
+            "device_id": self.device_id,
+            "defaults": asdict(self.defaults),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Config:
+        defaults_data = data.get("defaults", {})
+        return cls(
+            remote_root=data["remote_root"],
+            device_id=data["device_id"],
+            defaults=Defaults(
+                on_conflict=defaults_data.get("on_conflict", "skip"),
+                low_io=defaults_data.get("low_io", False),
+            ),
+        )
+
+
+def config_dir(repo_root: Path) -> Path:
+    return repo_root / CONFIG_DIR_NAME
+
+
+def config_path(repo_root: Path) -> Path:
+    return config_dir(repo_root) / CONFIG_FILE_NAME
+
+
+def load_config(repo_root: Path) -> Config | None:
+    path = config_path(repo_root)
+    if not path.exists():
+        return None
+    return Config.from_dict(json.loads(path.read_text()))
+
+
+def save_config(repo_root: Path, config: Config) -> None:
+    config_dir(repo_root).mkdir(parents=True, exist_ok=True)
+    config_path(repo_root).write_text(json.dumps(config.to_dict(), indent=2) + "\n")
+
+
+def init_config(repo_root: Path, remote_root: str) -> Config:
+    config = Config(remote_root=remote_root, device_id=str(uuid.uuid4()))
+    save_config(repo_root, config)
+    return config

protonfs/context.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+from protonfs.config import Config, load_config
+from protonfs.drive import DriveClient
+from protonfs.index import IndexStore
+
+
+@dataclass
+class RepoContext:
+    root: Path
+    config: Config
+    index: IndexStore
+    drive: DriveClient
+
+
+def load_context(start: Path | None = None) -> RepoContext:
+    root = (start or Path.cwd()).resolve()
+    config = load_config(root)
+    if config is None:
+        raise click.ClickException(
+            "protonfs is not set up in this directory. Run `protonfs setup` first."
+        )
+    return RepoContext(root=root, config=config, index=IndexStore(root), drive=DriveClient())

protonfs/diff.py

@@ -0,0 +1,83 @@
+# src/protonfs/diff.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from protonfs.index import IndexStore
+from protonfs.localscan import ScanEntry
+
+
+class SyncState(str, Enum):
+    SYNCED = "synced"
+    LOCAL_ONLY = "local-only"
+    REMOTE_ONLY = "remote-only"
+    METADATA_ONLY = "metadata-only"
+    CONFLICT = "conflict"
+    REMOTE_CHANGED = "remote-changed"
+    REMOTE_DELETED = "remote-deleted"
+
+
+@dataclass
+class DiffEntry:
+    rel_path: str
+    state: SyncState
+
+
+def within_subpath(rel_path: str, subpath: str | None) -> bool:
+    """True when rel_path lies inside `subpath` (or when there is no subpath).
+
+    `classify` reasons over the whole repo-wide index, so a caller that scoped its
+    local scan and remote walk to a subpath MUST filter classify's output with this
+    before acting on it -- otherwise index entries outside the subpath (never
+    scanned, never walked) are misread as remote-deleted / remote-only.
+    """
+    if not subpath:
+        return True
+    return rel_path == subpath or rel_path.startswith(f"{subpath}/")
+
+
+def classify(
+    local: dict[str, ScanEntry],
+    index: IndexStore,
+    remote: dict[str, int] | None = None,
+) -> list[DiffEntry]:
+    known_paths = set(local) | set(index.all())
+    if remote is not None:
+        known_paths |= set(remote)
+
+    results: list[DiffEntry] = []
+    for rel_path in sorted(known_paths):
+        local_entry = local.get(rel_path)
+        index_entry = index.get(rel_path)
+
+        if local_entry is not None and index_entry is None:
+            state = SyncState.LOCAL_ONLY
+        elif local_entry is not None and index_entry is not None:
+            state = (
+                SyncState.SYNCED
+                if local_entry.sha256 == index_entry.sha256
+                else SyncState.CONFLICT
+            )
+        elif local_entry is None and index_entry is not None:
+            if remote is not None:
+                if rel_path not in remote:
+                    state = SyncState.REMOTE_DELETED
+                elif remote[rel_path] != index_entry.size:
+                    state = SyncState.REMOTE_CHANGED
+                else:
+                    state = (
+                        SyncState.METADATA_ONLY
+                        if index_entry.local_state == "metadata-only"
+                        else SyncState.REMOTE_ONLY
+                    )
+            else:
+                state = (
+                    SyncState.METADATA_ONLY
+                    if index_entry.local_state == "metadata-only"
+                    else SyncState.REMOTE_ONLY
+                )
+        else:
+            state = SyncState.REMOTE_ONLY
+        results.append(DiffEntry(rel_path, state))
+    return results

protonfs/drive.py

@@ -0,0 +1,221 @@
+# src/protonfs/drive.py
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+from collections import deque
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+BINARY_ENV_VAR = "PROTONFS_DRIVE_BIN"
+DEFAULT_BINARY = "proton-drive"
+
+
+class DriveError(RuntimeError):
+    pass
+
+
+class DriveAuthError(DriveError):
+    pass
+
+
+@dataclass
+class TransferResult:
+    transferred_items: int
+    skipped_items: int
+    failed_items: int
+    failures: list[dict]
+
+    @classmethod
+    def from_json(cls, data: dict) -> TransferResult:
+        return cls(
+            transferred_items=data.get("transferredItems", 0),
+            skipped_items=data.get("skippedItems", 0),
+            failed_items=data.get("failedItems", 0),
+            failures=data.get("failures", []),
+        )
+
+
+@dataclass
+class RemoteEntry:
+    rel_path: str
+    is_dir: bool
+    size: int
+
+
+def binary_path() -> str:
+    return os.environ.get(BINARY_ENV_VAR, DEFAULT_BINARY)
+
+
+# Specific phrases that signal a genuine auth failure. Tightened from the v0.1 broad
+# `"auth" in message` check, which false-positived on unrelated words ("author",
+# "unauthorized"/permission errors). D5.1: we prefer a false negative (a real auth
+# error surfaced as a generic DriveError, still an error) over a false positive
+# (a non-auth error mislabelled as auth). If proton-drive's exact wording is later
+# captured via a deliberate logout probe, add it here.
+_AUTH_ERROR_SIGNALS = (
+    "unauthenticated",
+    "not authenticated",
+    "not logged in",
+    "log in first",
+    "login required",
+    "authentication required",
+    "session expired",
+    "auth required",
+    "please authenticate",
+)
+
+
+def _is_auth_error(message: str) -> bool:
+    lowered = message.lower()
+    return any(signal in lowered for signal in _AUTH_ERROR_SIGNALS)
+
+
+def decrypted_name(entry: dict) -> str | None:
+    """The decrypted filename of a `filesystem list` entry, or None if its name could
+    not be decrypted (``name.ok`` is false). Central helper so every consumer parses
+    the ``{"name": {"ok": bool, "value": str}}`` shape identically."""
+    name = entry.get("name", {})
+    if not name.get("ok"):
+        return None
+    return name.get("value")
+
+
+class DriveClient:
+    def __init__(self, binary: str | None = None) -> None:
+        self._binary = binary or binary_path()
+
+    def _binary_available(self) -> bool:
+        return shutil.which(self._binary) is not None or Path(self._binary).exists()
+
+    def _invoke(self, args: list[str]) -> subprocess.CompletedProcess:
+        if not self._binary_available():
+            raise DriveError(f"proton-drive binary not found: {self._binary}")
+        return subprocess.run([self._binary, *args, "--json"], capture_output=True, text=True)
+
+    def _run_json(self, args: list[str]) -> dict | list:
+        result = self._invoke(args)
+        stdout = result.stdout.strip()
+        try:
+            parsed = json.loads(stdout) if stdout else {}
+        except json.JSONDecodeError as exc:
+            raise DriveError(f"unparseable output from proton-drive: {stdout!r}") from exc
+        if result.returncode != 0:
+            message = json.dumps(parsed) if parsed else result.stderr.strip()
+            if _is_auth_error(message):
+                raise DriveAuthError(f"proton-drive auth required: {message}")
+            raise DriveError(message)
+        return parsed
+
+    def _run_transfer(self, args: list[str]) -> TransferResult:
+        result = self._invoke(args)
+        stdout = result.stdout.strip()
+        try:
+            parsed = json.loads(stdout) if stdout else None
+        except json.JSONDecodeError:
+            parsed = None
+        if not isinstance(parsed, dict) or "transferredItems" not in parsed:
+            message = result.stderr.strip() or stdout
+            if _is_auth_error(message):
+                raise DriveAuthError(f"proton-drive auth required: {message}")
+            raise DriveError(message)
+        return TransferResult.from_json(parsed)
+
+    def version(self) -> str | None:
+        if not self._binary_available():
+            return None
+        result = subprocess.run([self._binary, "version"], capture_output=True, text=True)
+        if result.returncode != 0:
+            return None
+        return result.stdout.strip()
+
+    def is_authenticated(self) -> bool:
+        try:
+            self._run_json(["filesystem", "list", "/"])
+        except DriveError:
+            return False
+        return True
+
+    def list(self, remote_path: str) -> list[dict]:
+        result = self._run_json(["filesystem", "list", remote_path])
+        return result if isinstance(result, list) else []
+
+    def walk(self, remote_root: str) -> list[RemoteEntry]:
+        root = remote_root.rstrip("/")
+        results: list[RemoteEntry] = []
+        # queue of (absolute remote path, rel prefix); deque gives O(1) popleft
+        queue: deque[tuple[str, str]] = deque([(root, "")])
+        while queue:
+            abs_path, prefix = queue.popleft()
+            for entry in self.list(abs_path):
+                value = decrypted_name(entry)
+                if value is None:
+                    logger.warning(
+                        "skipping remote entry with undecryptable name under %s", abs_path
+                    )
+                    continue
+                rel = f"{prefix}{value}" if prefix else value
+                child_abs = f"{abs_path}/{value}"
+                if entry.get("type") == "folder":
+                    results.append(RemoteEntry(rel_path=rel, is_dir=True, size=0))
+                    queue.append((child_abs, f"{rel}/"))
+                else:
+                    results.append(
+                        RemoteEntry(
+                            rel_path=rel,
+                            is_dir=False,
+                            size=entry.get("totalStorageSize", 0),
+                        )
+                    )
+        return results
+
+    def upload(
+        self,
+        local_paths: list[Path],
+        remote_parent: str,
+        file_strategy: str | None = None,
+        folder_strategy: str | None = None,
+    ) -> TransferResult:
+        args = ["filesystem", "upload"]
+        if file_strategy:
+            args += ["-f", file_strategy]
+        if folder_strategy:
+            args += ["-d", folder_strategy]
+        args += [str(p) for p in local_paths] + [remote_parent]
+        return self._run_transfer(args)
+
+    def download(
+        self,
+        remote_paths: list[str],
+        local_folder: Path,
+        file_strategy: str | None = None,
+        folder_strategy: str | None = None,
+    ) -> TransferResult:
+        args = ["filesystem", "download"]
+        if file_strategy:
+            args += ["-f", file_strategy]
+        if folder_strategy:
+            args += ["-d", folder_strategy]
+        args += remote_paths + [str(local_folder)]
+        return self._run_transfer(args)
+
+    def trash(self, remote_paths: list[str]) -> list[dict]:
+        result = self._run_json(["filesystem", "trash", *remote_paths])
+        return result if isinstance(result, list) else []
+
+    def restore(self, remote_paths: list[str]) -> list[dict]:
+        result = self._run_json(["filesystem", "restore", *remote_paths])
+        return result if isinstance(result, list) else []
+
+    def delete(self, remote_paths: list[str]) -> list[dict]:
+        result = self._run_json(["filesystem", "delete", *remote_paths])
+        return result if isinstance(result, list) else []
+
+    def create_folder(self, parent_path: str, name: str) -> dict:
+        result = self._run_json(["filesystem", "create-folder", parent_path, name])
+        return result if isinstance(result, dict) else {}

protonfs/ignore.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pathspec
+
+IGNORE_FILE_NAME = "ignore"
+
+DEFAULT_IGNORE_TEMPLATE = """\
+# protonfs ignore patterns (gitignore syntax)
+# Scopes what protonfs will sync from a given directory -- independent of
+# the repo's own .gitignore.
+*.tmp
+*.swp
+core.*
+"""
+
+
+def ignore_path(repo_root: Path) -> Path:
+    return repo_root / ".protonfs" / IGNORE_FILE_NAME
+
+
+def init_ignore(repo_root: Path) -> None:
+    path = ignore_path(repo_root)
+    if path.exists():
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(DEFAULT_IGNORE_TEMPLATE)
+
+
+class IgnoreMatcher:
+    def __init__(self, patterns: list[str]) -> None:
+        self._spec = pathspec.GitIgnoreSpec.from_lines(patterns)
+
+    @classmethod
+    def from_file(cls, repo_root: Path) -> IgnoreMatcher:
+        path = ignore_path(repo_root)
+        if not path.exists():
+            return cls([])
+        return cls(path.read_text().splitlines())
+
+    def matches(self, rel_path: str) -> bool:
+        return self._spec.match_file(rel_path)

protonfs/index.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+INDEX_FILE_NAME = "index.json"
+
+
+@dataclass
+class IndexEntry:
+    size: int
+    mtime: float
+    sha256: str
+    remote_path: str
+    origin_device: str
+    local_state: str  # "present" | "metadata-only"
+    last_synced: str  # ISO-8601 timestamp
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> IndexEntry:
+        return cls(**data)
+
+
+class IndexStore:
+    def __init__(self, repo_root: Path) -> None:
+        self._path = repo_root / ".protonfs" / INDEX_FILE_NAME
+        self._entries: dict[str, IndexEntry] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if not self._path.exists():
+            return
+        raw = json.loads(self._path.read_text())
+        self._entries = {rel_path: IndexEntry.from_dict(data) for rel_path, data in raw.items()}
+
+    def save(self) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        raw = {rel_path: entry.to_dict() for rel_path, entry in self._entries.items()}
+        self._path.write_text(json.dumps(raw, indent=2, sort_keys=True) + "\n")
+
+    def get(self, rel_path: str) -> IndexEntry | None:
+        return self._entries.get(rel_path)
+
+    def set(self, rel_path: str, entry: IndexEntry) -> None:
+        self._entries[rel_path] = entry
+
+    def remove(self, rel_path: str) -> None:
+        self._entries.pop(rel_path, None)
+
+    def all(self) -> dict[str, IndexEntry]:
+        return dict(self._entries)