commandertui 1.0.0__py3-none-any.whl

commandertui/progress_screen.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import time
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Footer, ProgressBar, Static
+
+from .executor import TransferStatus
+
+
+def _human_bytes(n: int) -> str:
+    size = float(n)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
+def _human_rate(bytes_per_sec: float) -> str:
+    # Bits, decimal units: comparable with network link speeds.
+    mbit = bytes_per_sec * 8 / 1_000_000
+    return f"{mbit / 1000:.2f} Gb/s" if mbit >= 1000 else f"{mbit:.1f} Mb/s"
+
+
+def _human_duration(seconds: float) -> str:
+    s = int(seconds)
+    if s < 60:
+        return f"{s}s"
+    if s < 3600:
+        return f"{s // 60}m {s % 60:02d}s"
+    return f"{s // 3600}h {s % 3600 // 60:02d}m"
+
+
+class ProgressScreen(ModalScreen[None]):
+    """Shown while an OperationQueue runs: one bar for the current file, one
+    for the whole job (by bytes). Escape asks before cancelling, so a stray
+    keypress can't stop a transfer by itself."""
+
+    DEFAULT_CSS = """
+    ProgressScreen {
+        align: center middle;
+    }
+    #progress-box {
+        width: 72;
+        height: auto;
+        border: solid $foreground;
+        padding: 1 2;
+    }
+    #progress-box ProgressBar {
+        margin-bottom: 1;
+    }
+    #progress-title, #progress-rate {
+        margin-bottom: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "ask_cancel", "Cancel", priority=True),
+        Binding("y", "confirm_cancel", "Yes, cancel", priority=True),
+        Binding("n", "resume", "No, continue", priority=True),
+    ]
+
+    def __init__(self, title: str, total_ops: int) -> None:
+        super().__init__()
+        self.title_text = title
+        self.total_ops = total_ops
+        self.cancel_requested = False
+        self.asking = False
+        self.started = time.monotonic()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="progress-box"):
+            yield Static(f"{self.title_text}\n\n  Preparing...", id="progress-title")
+            yield Static("", id="file-label")
+            yield ProgressBar(total=100, id="file-bar", show_eta=False)
+            yield Static("", id="total-label")
+            yield ProgressBar(total=100, id="total-bar", show_eta=False)
+            yield Static("", id="progress-rate")
+        yield Footer()
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action in ("confirm_cancel", "resume"):
+            return self.asking
+        if action == "ask_cancel":
+            return not self.asking and not self.cancel_requested
+        return True
+
+    def action_ask_cancel(self) -> None:
+        self.asking = True
+        self.refresh_bindings()
+        self.query_one("#progress-rate", Static).update(
+            "Cancel? The file being copied is discarded; finished files stay."
+        )
+
+    def action_confirm_cancel(self) -> None:
+        self.asking = False
+        self.cancel_requested = True
+        self.refresh_bindings()
+        self.query_one("#progress-rate", Static).update("Cancelling...")
+
+    def action_resume(self) -> None:
+        self.asking = False
+        self.refresh_bindings()
+
+    def report(self, s: TransferStatus) -> None:
+        """Called via app.call_from_thread from the worker -- safe to touch widgets."""
+        self.query_one("#progress-title", Static).update(self.title_text)
+
+        if s.bytes_total:
+            self.query_one("#file-label", Static).update(
+                f"File: {s.file_name}   {_human_bytes(s.file_done)} of {_human_bytes(s.file_total)}"
+            )
+            file_pct = 100 * s.file_done / s.file_total if s.file_total else 100
+            self.query_one("#file-bar", ProgressBar).update(progress=file_pct)
+            self.query_one("#total-label", Static).update(
+                f"Total: file {s.files_done:,} of {s.files_total:,}   "
+                f"{_human_bytes(s.bytes_done)} of {_human_bytes(s.bytes_total)}"
+            )
+            total_pct = 100 * s.bytes_done / s.bytes_total
+        else:  # nothing byte-sized (deletes, empty files): count items instead
+            self.query_one("#total-label", Static).update(f"Total: {s.ops_done} of {s.ops_total} items")
+            total_pct = 100 * s.ops_done / s.ops_total if s.ops_total else 100
+        self.query_one("#total-bar", ProgressBar).update(progress=total_pct)
+
+        if self.asking or self.cancel_requested:
+            return
+        elapsed = time.monotonic() - self.started
+        if s.bytes_total and s.bytes_done and elapsed > 1:
+            rate = s.bytes_done / elapsed
+            left = (s.bytes_total - s.bytes_done) / rate
+            self.query_one("#progress-rate", Static).update(
+                f"{_human_rate(rate)}  -  about {_human_duration(left)} left"
+            )

commandertui/run_queue.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import time
+from dataclasses import replace
+from typing import Callable
+
+from .executor import ExecutionReport, TransferStatus, execute
+from .modals import ConfirmScreen, MessageScreen
+from .models import OperationQueue
+from .progress_screen import ProgressScreen
+
+
+def run_queue_with_progress(
+    owner,  # Screen: MainScreen or CompareScreen
+    title: str,
+    queue: OperationQueue,
+    left_root: str,
+    right_root: str,
+    after: Callable[[ExecutionReport], None] | None = None,
+) -> None:
+    """Confirm, then run an OperationQueue in a background thread with a
+    live progress screen.
+
+    Running `execute()` straight on the UI thread (the original approach)
+    blocked Textual's event loop for the whole transfer: no repaint, no
+    input, the screen just sat frozen until it finished. Everything that
+    touches a widget from inside `work()` goes through `call_from_thread`,
+    which is the only safe way back onto the UI thread from a worker.
+    """
+    if len(queue) == 0:
+        owner.app.push_screen(MessageScreen("Nothing to do."))
+        return
+
+    def on_confirmed(confirmed: bool | None) -> None:
+        if not confirmed:
+            return
+
+        progress = ProgressScreen(title, len(queue))
+        owner.app.push_screen(progress)
+
+        def work() -> None:
+            last = 0.0
+
+            def on_transfer(status: TransferStatus) -> None:
+                # Throttled: a per-chunk UI update would flood the event loop.
+                nonlocal last
+                now = time.monotonic()
+                if now - last >= 0.1 or status.file_done == status.file_total:
+                    last = now
+                    owner.app.call_from_thread(progress.report, replace(status))
+
+            report = execute(
+                queue,
+                left_root,
+                right_root,
+                cancel_check=lambda: progress.cancel_requested,
+                on_transfer=on_transfer,
+            )
+
+            def finish() -> None:
+                progress.dismiss()
+                if after:
+                    after(report)
+                if report.cancelled:
+                    owner.app.push_screen(
+                        MessageScreen(
+                            "Cancelled.\n\n"
+                            "Files already copied stay at the destination.\n"
+                            "The file in progress was discarded - no half-copied files were left.\n"
+                            "For a move, the source of anything unfinished is still in place."
+                        )
+                    )
+                elif report.failed:
+                    lines = "\n".join(f"  {p}: {e}" for p, e in report.failed[:10])
+                    owner.app.push_screen(
+                        MessageScreen(f"{report.succeeded} ok, {len(report.failed)} failed:\n{lines}")
+                    )
+
+            owner.app.call_from_thread(finish)
+
+        owner.run_worker(work, thread=True)
+
+    owner.app.push_screen(ConfirmScreen(title, queue), on_confirmed)

commandertui/scanner.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import os
+import stat
+
+from .models import EntryKind, FileEntry
+
+DEFAULT_EXCLUSIONS = {
+    ".git",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "node_modules",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+}
+
+
+def _kind_of(entry: os.DirEntry) -> EntryKind:
+    if entry.is_symlink():
+        return EntryKind.SYMLINK
+    if entry.is_dir(follow_symlinks=False):
+        return EntryKind.DIR
+    return EntryKind.FILE
+
+
+def scan_directory(
+    root: str,
+    exclusions: set[str] = frozenset(DEFAULT_EXCLUSIONS),
+    cancel_check=None,
+) -> dict[str, FileEntry]:
+    """Recursively scan a directory, returning a map of rel_path -> FileEntry.
+
+    Directories are included as entries too (needed to diff empty folders),
+    but only files/symlinks contribute to size comparisons.
+    """
+    results: dict[str, FileEntry] = {}
+
+    def walk(current_abs: str, current_rel: str) -> None:
+        if cancel_check and cancel_check():
+            return
+        try:
+            with os.scandir(current_abs) as it:
+                entries = sorted(it, key=lambda e: e.name)
+        except (PermissionError, FileNotFoundError):
+            return
+
+        for entry in entries:
+            if entry.name in exclusions:
+                continue
+            rel_path = f"{current_rel}/{entry.name}" if current_rel else entry.name
+            kind = _kind_of(entry)
+            try:
+                stat = entry.stat(follow_symlinks=False)
+            except (PermissionError, FileNotFoundError):
+                continue
+
+            results[rel_path] = FileEntry(
+                rel_path=rel_path,
+                name=entry.name,
+                kind=kind,
+                size=stat.st_size if kind != EntryKind.DIR else 0,
+                mtime=stat.st_mtime,
+            )
+
+            if kind == EntryKind.DIR:
+                walk(entry.path, rel_path)
+
+    walk(root, "")
+    return results
+
+
+def tree_stats(paths, cancel_check=None, on_progress=None) -> tuple[int, int, int]:
+    """(files, subfolders, bytes) under `paths`. Read-only, never follows
+    symlinks; the given top-level folders themselves aren't counted."""
+    top = set(paths)
+    stack = list(paths)
+    files = dirs = total = 0
+    while stack:
+        if cancel_check and cancel_check():
+            break
+        p = stack.pop()
+        try:
+            st = os.lstat(p)
+        except OSError:
+            continue
+        if stat.S_ISDIR(st.st_mode):
+            if p not in top:
+                dirs += 1
+            try:
+                with os.scandir(p) as it:
+                    stack.extend(e.path for e in it)
+            except OSError:
+                pass
+        else:
+            files += 1
+            total += st.st_size
+        if on_progress:
+            on_progress(files, dirs, total)
+    return files, dirs, total
+
+
+def path_size(path: str) -> int:
+    """Total bytes under `path` -- a single file's size, or a directory
+    tree's total. Used for the byte counts shown in confirmation dialogs;
+    without this, manually-marked items always reported "0 bytes" since
+    only the bulk compare/sync path (plan.py) computed real sizes.
+    """
+    try:
+        if os.path.isdir(path) and not os.path.islink(path):
+            return sum(path_size(entry.path) for entry in os.scandir(path))
+        return os.path.getsize(path)
+    except OSError:
+        return 0

commandertui/sync.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+from dataclasses import dataclass
+from typing import Callable
+
+from .trash import send_to_trash
+
+ProgressCallback = Callable[[int, int, str], None]  # (bytes_done, bytes_total, current_name)
+CancelCheck = Callable[[], bool]
+CHUNK_SIZE = 1024 * 1024  # 1 MiB
+
+
+class OperationCancelled(Exception):
+    pass
+
+
+@dataclass
+class TransferResult:
+    ok: bool
+    error: str | None = None
+    cancelled: bool = False
+
+
+def _atomic_copy_file(
+    src: str, dst: str, progress: ProgressCallback | None = None, cancel_check: CancelCheck | None = None
+) -> None:
+    """Copy one file into dst via a hidden temp file + atomic rename.
+
+    The destination is never seen half-written: a reader either sees the old
+    file or the fully-copied new one, never something in between. Metadata
+    (mode, mtime) is preserved with copystat.
+    """
+    dst_dir = os.path.dirname(dst)
+    os.makedirs(dst_dir, exist_ok=True)
+    tmp_path = os.path.join(dst_dir, f".{os.path.basename(dst)}.{os.getpid()}.tmp")
+
+    total = os.path.getsize(src)
+    done = 0
+    name = os.path.basename(src)
+    if progress:
+        progress(0, total, name)
+    try:
+        with open(src, "rb") as fsrc, open(tmp_path, "wb") as fdst:
+            while True:
+                # Checked per chunk so a cancel stops mid-file; the except
+                # below removes the temp file, dst is never touched.
+                if cancel_check and cancel_check():
+                    raise OperationCancelled()
+                chunk = fsrc.read(CHUNK_SIZE)
+                if not chunk:
+                    break
+                fdst.write(chunk)
+                done += len(chunk)
+                if progress:
+                    progress(done, total, name)
+        shutil.copystat(src, tmp_path, follow_symlinks=False)
+        os.replace(tmp_path, dst)
+    except BaseException:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        raise
+
+
+def copy_item(
+    src: str, dst: str, progress: ProgressCallback | None = None, cancel_check: CancelCheck | None = None
+) -> TransferResult:
+    """Copy a file or directory tree atomically, file by file."""
+    try:
+        if cancel_check and cancel_check():
+            raise OperationCancelled()
+        if os.path.islink(src):
+            link_target = os.readlink(src)
+            dst_dir = os.path.dirname(dst)
+            os.makedirs(dst_dir, exist_ok=True)
+            if os.path.lexists(dst):
+                os.remove(dst)
+            os.symlink(link_target, dst)
+        elif os.path.isdir(src):
+            os.makedirs(dst, exist_ok=True)
+            for entry in os.scandir(src):
+                sub_result = copy_item(entry.path, os.path.join(dst, entry.name), progress, cancel_check)
+                if not sub_result.ok:
+                    return sub_result
+            shutil.copystat(src, dst, follow_symlinks=False)
+        else:
+            _atomic_copy_file(src, dst, progress, cancel_check)
+        return TransferResult(ok=True)
+    except OperationCancelled:
+        return TransferResult(ok=False, error="cancelled", cancelled=True)
+    except Exception as e:
+        return TransferResult(ok=False, error=str(e))
+
+
+def move_item(
+    src: str, dst: str, progress: ProgressCallback | None = None, cancel_check: CancelCheck | None = None
+) -> TransferResult:
+    """Move a file or directory. Same-filesystem moves are atomic (os.replace);
+    cross-filesystem moves fall back to copy + trash-the-source, so a failed
+    or interrupted move never leaves the source half-deleted.
+    """
+    try:
+        dst_dir = os.path.dirname(dst)
+        os.makedirs(dst_dir, exist_ok=True)
+        try:
+            os.rename(src, dst)
+            return TransferResult(ok=True)
+        except OSError:
+            pass  # cross-device or dst exists as a different type; fall through
+
+        # A cancelled or failed copy returns here, before the source is
+        # trashed -- the source is only removed after a complete copy.
+        result = copy_item(src, dst, progress, cancel_check)
+        if not result.ok:
+            return result
+        if not send_to_trash(src):
+            return TransferResult(ok=False, error="Copied to destination but could not remove source")
+        return TransferResult(ok=True)
+    except Exception as e:
+        return TransferResult(ok=False, error=str(e))
+
+
+def delete_item(path: str) -> TransferResult:
+    if send_to_trash(path):
+        return TransferResult(ok=True)
+    return TransferResult(ok=False, error="All trash methods failed")
+
+
+def sha256_of(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            chunk = f.read(CHUNK_SIZE)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def verify_copy(src: str, dst: str) -> bool:
+    """Checksum verification for critical transfers (USB/network)."""
+    if os.path.isdir(src):
+        for entry in os.scandir(src):
+            if not verify_copy(entry.path, os.path.join(dst, entry.name)):
+                return False
+        return True
+    return os.path.exists(dst) and sha256_of(src) == sha256_of(dst)

commandertui/theme.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+# Phosphor palettes, consistent with the rest of the green-CRT TUI family
+# (btrfs-restore-tui). Amber is the classic VT220 alternative for long
+# sessions.
+PALETTES = {
+    "green": {
+        "foreground": "#00FF66",
+        "dim": "#0A5C2C",
+        "background": "#001A0D",
+        "accent": "#66FFB2",
+        "danger": "#FF4444",
+        "warning": "#FFD24C",
+    },
+    "amber": {
+        "foreground": "#FFB000",
+        "dim": "#5C3F00",
+        "background": "#1A1000",
+        "accent": "#FFD24C",
+        "danger": "#FF4444",
+        "warning": "#FFEE66",
+    },
+}
+
+
+def css_for(palette_name: str = "green") -> str:
+    p = PALETTES.get(palette_name, PALETTES["green"])
+    return f"""
+Screen {{
+    background: {p['background']};
+    color: {p['foreground']};
+}}
+
+.dim {{
+    color: {p['dim']};
+}}
+
+.accent {{
+    color: {p['accent']};
+}}
+
+.danger {{
+    color: {p['danger']};
+}}
+
+.warning {{
+    color: {p['warning']};
+}}
+
+Header, Footer {{
+    background: {p['background']};
+    color: {p['foreground']};
+}}
+
+/* DataTable draws its own cell colors independently of Screen, so every
+   part of it needs to be told about the palette explicitly -- otherwise it
+   falls back to Textual's default theme (white text) regardless of what the
+   rest of the app looks like. */
+DataTable {{
+    background: {p['background']};
+    color: {p['foreground']};
+    scrollbar-color: {p['dim']};
+    scrollbar-background: {p['background']};
+}}
+
+DataTable > .datatable--header {{
+    background: {p['background']};
+    color: {p['accent']};
+    text-style: bold;
+}}
+
+DataTable > .datatable--cursor {{
+    background: {p['foreground']};
+    color: {p['background']};
+}}
+
+DataTable > .datatable--odd-row {{
+    background: {p['background']};
+}}
+
+DataTable > .datatable--even-row {{
+    background: {p['background']};
+}}
+
+.pathbar {{
+    color: {p['dim']};
+    padding: 0 1;
+}}
+
+.pathbar.active {{
+    color: {p['accent']};
+    text-style: bold;
+}}
+"""

commandertui/trash.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+
+
+def send_to_trash(path: str) -> bool:
+    """Move a file or directory to the system trash. Never a raw rm/rmtree.
+
+    Three-layer fallback, in order of preference:
+      1. send2trash (FreeDesktop-native, cross-desktop)
+      2. `gio trash` (GLib/GIO, present on GNOME/KDE)
+      3. Direct move into ~/.local/share/Trash/files (last resort, e.g. for
+         external disks or network mounts without native trash support)
+    """
+    abs_path = os.path.abspath(path)
+    if not os.path.exists(abs_path):
+        return False
+
+    try:
+        import send2trash
+
+        send2trash.send2trash(abs_path)
+        return True
+    except Exception:
+        pass
+
+    try:
+        result = subprocess.run(["gio", "trash", abs_path], capture_output=True, text=True, timeout=30)
+        if result.returncode == 0:
+            return True
+    except Exception:
+        pass
+
+    try:
+        trash_dir = os.path.expanduser("~/.local/share/Trash/files")
+        os.makedirs(trash_dir, exist_ok=True)
+        base = os.path.basename(abs_path)
+        name, ext = os.path.splitext(base)
+        target = os.path.join(trash_dir, base)
+        counter = 1
+        while os.path.exists(target):
+            target = os.path.join(trash_dir, f"{name}_{counter}{ext}")
+            counter += 1
+        shutil.move(abs_path, target)
+        return True
+    except Exception:
+        return False