commandertui 1.0.0__py3-none-any.whl

commandertui/main_screen.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import os
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Header
+
+from .compare_screen import CompareScreen
+from .modals import InputScreen, MessageScreen, PlacesScreen, SizeScreen
+from .models import OpKind, OpSide, OperationQueue, QueuedOp
+from .run_queue import run_queue_with_progress
+from .scanner import path_size
+from .widgets import FilePanel
+
+
+class MainScreen(Screen):
+    """The dual-pane view and its keybindings.
+
+    Kept as its own Screen (rather than living directly on the App) so its
+    priority bindings only take effect while it is the active screen --
+    Textual checks an App's own priority bindings even when a different
+    screen (BootScreen, CompareScreen, a modal) is on top of the stack, so
+    anything pane-specific has to live here, not on CommanderApp.
+    """
+
+    # priority=True: the focused DataTable has built-in bindings for several
+    # of these same keys (notably Enter, which it uses internally to fire
+    # RowSelected) that would otherwise intercept the key before our action
+    # ever runs.
+    BINDINGS = [
+        Binding("tab", "switch_pane", "Switch pane", priority=True),
+        Binding("enter", "enter_dir", "Open", priority=True),
+        Binding("backspace", "up_dir", "Up", priority=True),
+        Binding("space", "toggle_mark", "Mark", priority=True),
+        Binding("f5", "copy", "Copy", priority=True),
+        Binding("f6", "move", "Move", priority=True),
+        Binding("f7", "make_dir", "MkDir", priority=True),
+        Binding("f8", "delete", "Delete", priority=True),
+        Binding("delete", "delete", "Delete", priority=True),
+        Binding("c", "show_compare", "Compare", priority=True),
+        Binding("p", "show_places", "Places", priority=True),
+        Binding("r", "refresh_both", "Refresh", priority=True),
+        Binding("h", "toggle_hidden", "Hidden", priority=True),
+        Binding("i", "show_size", "Size", priority=True),
+        # "app.quit", not "quit": this binding lives on the Screen, and a bare
+        # "quit" resolves against the Screen's own (nonexistent) action_quit
+        # rather than bubbling to the App, so it silently did nothing.
+        Binding("q", "app.quit", "Quit", priority=True),
+    ]
+
+    def __init__(self, left_path: str, right_path: str) -> None:
+        super().__init__()
+        self.left_path = left_path
+        self.right_path = right_path
+        self.active_side = "left"
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        with Horizontal():
+            yield FilePanel(self.left_path, side="left", id="panel-left")
+            yield FilePanel(self.right_path, side="right", id="panel-right")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._set_active("left")
+
+    # ------------------------------------------------------------ helpers
+    def _panel(self, side: str) -> FilePanel:
+        return self.query_one(f"#panel-{side}", FilePanel)
+
+    def _active_panel(self) -> FilePanel:
+        return self._panel(self.active_side)
+
+    def _other_panel(self) -> FilePanel:
+        return self._panel("right" if self.active_side == "left" else "left")
+
+    def _set_active(self, side: str) -> None:
+        self.active_side = side
+        self._panel("left").active = side == "left"
+        self._panel("right").active = side == "right"
+        # Marking a panel "active" only recolors its path bar; arrow-key
+        # navigation is driven by Textual's real focus, on the DataTable
+        # itself, so it has to move too or the cursor keeps responding to
+        # whichever pane was focused first regardless of which one looks active.
+        self._panel(side).query_one(DataTable).focus()
+
+    # -------------------------------------------------------------- nav
+    def action_switch_pane(self) -> None:
+        self._set_active("right" if self.active_side == "left" else "left")
+
+    def action_enter_dir(self) -> None:
+        self._active_panel().enter_selected()
+
+    def action_up_dir(self) -> None:
+        panel = self._active_panel()
+        panel.path = os.path.dirname(panel.path)
+        panel.marked.clear()
+        panel.refresh_listing()
+
+    def action_toggle_mark(self) -> None:
+        self._active_panel().toggle_mark_selected()
+
+    def action_refresh_both(self) -> None:
+        self._panel("left").refresh_listing()
+        self._panel("right").refresh_listing()
+
+    def action_toggle_hidden(self) -> None:
+        show = not self._panel("left").show_hidden
+        for side in ("left", "right"):
+            panel = self._panel(side)
+            panel.show_hidden = show
+            panel.refresh_listing()
+
+    def action_show_size(self) -> None:
+        items = self._active_panel().marked_or_selected()
+        if items:
+            self.app.push_screen(SizeScreen(items))
+
+    # ------------------------------------------------------------- mkdir
+    def action_make_dir(self) -> None:
+        panel = self._active_panel()
+
+        def on_named(name: str | None) -> None:
+            if not name:
+                return
+            target = os.path.join(panel.path, name)
+            try:
+                os.makedirs(target)
+            except FileExistsError:
+                self.app.push_screen(MessageScreen(f"'{name}' already exists."))
+                return
+            except OSError as exc:
+                self.app.push_screen(MessageScreen(f"Could not create '{name}': {exc}"))
+                return
+            panel.refresh_listing()
+
+        self.app.push_screen(InputScreen("New folder name:"), on_named)
+
+    # --------------------------------------------------------- op queues
+    def action_copy(self) -> None:
+        self._run_marked_op(OpKind.COPY, "Copy")
+
+    def action_move(self) -> None:
+        self._run_marked_op(OpKind.MOVE, "Move")
+
+    def action_delete(self) -> None:
+        src_panel = self._active_panel()
+        items = src_panel.marked_or_selected()
+        if not items:
+            return
+
+        side = OpSide.LEFT if src_panel.side == "left" else OpSide.RIGHT
+        queue = OperationQueue()
+        for item in items:
+            rel_path = os.path.relpath(item, src_panel.path)
+            queue.add(QueuedOp(OpKind.DELETE, side, rel_path, os.path.isdir(item), size=path_size(item)))
+
+        def after(report) -> None:
+            src_panel.marked.clear()
+            src_panel.refresh_listing()
+
+        run_queue_with_progress(
+            self, "Delete (to trash)", queue, self._panel("left").path, self._panel("right").path, after
+        )
+
+    def _run_marked_op(self, kind: OpKind, label: str) -> None:
+        src_panel = self._active_panel()
+        dst_panel = self._other_panel()
+        items = src_panel.marked_or_selected()
+        if not items:
+            return
+
+        side = OpSide.LEFT_TO_RIGHT if src_panel.side == "left" else OpSide.RIGHT_TO_LEFT
+        queue = OperationQueue()
+        for item in items:
+            rel_path = os.path.relpath(item, src_panel.path)
+            queue.add(QueuedOp(kind, side, rel_path, os.path.isdir(item), size=path_size(item)))
+
+        def after(report) -> None:
+            src_panel.marked.clear()
+            src_panel.refresh_listing()
+            dst_panel.refresh_listing()
+
+        run_queue_with_progress(
+            self,
+            f"{label} to {dst_panel.path}",
+            queue,
+            self._panel("left").path,
+            self._panel("right").path,
+            after,
+        )
+
+    # ------------------------------------------------------------- misc
+    def action_show_compare(self) -> None:
+        left = self._panel("left").path
+        right = self._panel("right").path
+        self.app.push_screen(CompareScreen(left, right))
+
+    def action_show_places(self) -> None:
+        def on_picked(path: str | None) -> None:
+            if not path:
+                return
+            panel = self._active_panel()
+            panel.path = path
+            panel.marked.clear()
+            panel.refresh_listing()
+
+        self.app.push_screen(PlacesScreen(), on_picked)

commandertui/modals.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import os
+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 DataTable, Footer, Input, Static
+
+from .bookmarks import Place, all_places
+from .models import OperationQueue
+from .scanner import tree_stats
+
+
+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"
+
+
+class ConfirmScreen(ModalScreen[bool]):
+    """A destructive action never runs without this: a plain-language summary
+    of exactly what is about to happen, requiring an explicit yes."""
+
+    DEFAULT_CSS = """
+    ConfirmScreen {
+        align: center middle;
+    }
+    #confirm-box {
+        width: 60;
+        height: auto;
+        border: solid $foreground;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        Binding("y", "confirm", "Confirm", priority=True),
+        Binding("n", "cancel", "Cancel", priority=True),
+        Binding("escape", "cancel", "Cancel", priority=True),
+    ]
+
+    def __init__(self, title: str, queue: OperationQueue) -> None:
+        super().__init__()
+        self.title_text = title
+        self.queue = queue
+
+    def compose(self) -> ComposeResult:
+        summary = self.queue.summary()
+        by_kind = ", ".join(f"{n} {k}" for k, n in summary["by_kind"].items())
+        text = (
+            f"{self.title_text}\n\n"
+            f"  {summary['count']} operations ({by_kind or 'nothing to do'})\n"
+            f"  {_human_bytes(summary['total_bytes'])} total"
+        )
+        with Vertical(id="confirm-box"):
+            yield Static(text)
+        # A real Footer, not a hand-written text line: it renders the actual
+        # keybindings the same way the rest of the app does, so "how do I
+        # confirm this" is never a guess.
+        yield Footer()
+
+    def action_confirm(self) -> None:
+        self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+
+class PlacesScreen(ModalScreen[str | None]):
+    """Quick-jump to a mounted drive (USB/SMB/local) or a saved bookmark,
+    instead of typing the path."""
+
+    DEFAULT_CSS = """
+    PlacesScreen {
+        align: center middle;
+    }
+    #places-box {
+        width: 70;
+        height: auto;
+        max-height: 20;
+        border: solid $foreground;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "cancel", "Cancel", priority=True)]
+
+    def compose(self) -> ComposeResult:
+        table = DataTable(id="places-table", cursor_type="row")
+        table.add_columns("Kind", "Label", "Path")
+        with Vertical(id="places-box"):
+            yield table
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#places-table", DataTable)
+        self.places: list[Place] = all_places()
+        for place in self.places:
+            table.add_row(place.kind, place.label, place.path, key=place.path)
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        self.dismiss(str(event.row_key.value))
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class InputScreen(ModalScreen[str | None]):
+    """A single text prompt (e.g. new folder name). Enter confirms with the
+    current text, Escape cancels with None -- same shape as ConfirmScreen so
+    callers can use the same push_screen(..., callback) pattern."""
+
+    DEFAULT_CSS = """
+    InputScreen {
+        align: center middle;
+    }
+    #input-box {
+        width: 60;
+        height: auto;
+        border: solid $foreground;
+        padding: 1 2;
+    }
+    #input-box Static {
+        margin-bottom: 1;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "cancel", "Cancel", priority=True)]
+
+    def __init__(self, prompt: str) -> None:
+        super().__init__()
+        self.prompt = prompt
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="input-box"):
+            yield Static(self.prompt)
+            yield Input(id="input-field")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.query_one(Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value.strip() or None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class SizeScreen(ModalScreen[None]):
+    """Counts files/folders/bytes of the given paths in a worker thread, so a
+    big tree (or a slow network share) never freezes the UI. Closing it
+    early (Escape) stops the count."""
+
+    DEFAULT_CSS = """
+    SizeScreen {
+        align: center middle;
+    }
+    #size-box {
+        width: 60;
+        height: auto;
+        border: solid $foreground;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", priority=True),
+        Binding("enter", "close", "Close", priority=True),
+    ]
+
+    def __init__(self, paths: list[str]) -> None:
+        super().__init__()
+        self.paths = paths
+        self.cancelled = False
+        self.label = os.path.basename(paths[0]) if len(paths) == 1 else f"{len(paths)} items"
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="size-box"):
+            yield Static(f"{self.label}\n\n  Calculating...", id="size-text")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.run_worker(self._work, thread=True)
+
+    def _work(self) -> None:
+        last = 0.0
+
+        def on_progress(files: int, dirs: int, total: int) -> None:
+            nonlocal last
+            now = time.monotonic()
+            if now - last >= 0.2:
+                last = now
+                self.app.call_from_thread(self._show, files, dirs, total, False)
+
+        files, dirs, total = tree_stats(self.paths, lambda: self.cancelled, on_progress)
+        if not self.cancelled:
+            self.app.call_from_thread(self._show, files, dirs, total, True)
+
+    def _show(self, files: int, dirs: int, total: int, done: bool) -> None:
+        if self.cancelled or not self.is_mounted:
+            return
+        status = "" if done else "  Calculating...\n"
+        self.query_one("#size-text", Static).update(
+            f"{self.label}\n\n{status}"
+            f"  {files:,} files, {dirs:,} folders\n"
+            f"  {_human_bytes(total)}  ({total:,} bytes)"
+        )
+
+    def action_close(self) -> None:
+        self.cancelled = True
+        self.dismiss(None)
+
+
+class MessageScreen(ModalScreen[None]):
+    """A short result notice (e.g. failures after an operation ran)."""
+
+    DEFAULT_CSS = """
+    MessageScreen {
+        align: center middle;
+    }
+    #msg-box {
+        width: 60;
+        height: auto;
+        border: solid $error;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", priority=True),
+        Binding("enter", "close", "Close", priority=True),
+    ]
+
+    def __init__(self, text: str) -> None:
+        super().__init__()
+        self.text = text
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="msg-box"):
+            yield Static(self.text)
+        yield Footer()
+
+    def action_close(self) -> None:
+        self.dismiss(None)

commandertui/models.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class DiffStatus(str, Enum):
+    LEFT_ONLY = "left_only"
+    RIGHT_ONLY = "right_only"
+    MODIFIED = "modified"
+    IDENTICAL = "identical"
+
+
+class EntryKind(str, Enum):
+    FILE = "file"
+    DIR = "dir"
+    SYMLINK = "symlink"
+
+
+@dataclass(frozen=True)
+class FileEntry:
+    rel_path: str
+    name: str
+    kind: EntryKind
+    size: int
+    mtime: float
+
+
+@dataclass(frozen=True)
+class DiffEntry:
+    rel_path: str
+    name: str
+    status: DiffStatus
+    left: FileEntry | None
+    right: FileEntry | None
+
+
+class OpKind(str, Enum):
+    COPY = "copy"
+    MOVE = "move"
+    DELETE = "delete"
+
+
+class OpSide(str, Enum):
+    LEFT_TO_RIGHT = "left_to_right"
+    RIGHT_TO_LEFT = "right_to_left"
+    LEFT = "left"
+    RIGHT = "right"
+
+
+@dataclass
+class QueuedOp:
+    kind: OpKind
+    side: OpSide
+    rel_path: str
+    is_dir: bool
+    size: int = 0
+
+
+@dataclass
+class OperationQueue:
+    ops: list[QueuedOp] = field(default_factory=list)
+
+    def add(self, op: QueuedOp) -> None:
+        self.ops.append(op)
+
+    def clear(self) -> None:
+        self.ops.clear()
+
+    def summary(self) -> dict:
+        by_kind: dict[str, int] = {}
+        total_bytes = 0
+        for op in self.ops:
+            by_kind[op.kind.value] = by_kind.get(op.kind.value, 0) + 1
+            total_bytes += op.size
+        return {"count": len(self.ops), "by_kind": by_kind, "total_bytes": total_bytes}
+
+    def __len__(self) -> int:
+        return len(self.ops)

commandertui/plan.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from .models import DiffEntry, DiffStatus, EntryKind, OpKind, OpSide, OperationQueue, QueuedOp
+
+
+def plan_mirror(diffs: list[DiffEntry]) -> OperationQueue:
+    """Make Right identical to Left: copy everything Left has, delete everything
+    Right has that Left doesn't."""
+    queue = OperationQueue()
+    for d in diffs:
+        if d.status in (DiffStatus.LEFT_ONLY, DiffStatus.MODIFIED):
+            queue.add(_copy_op(d, OpSide.LEFT_TO_RIGHT))
+        elif d.status == DiffStatus.RIGHT_ONLY:
+            queue.add(QueuedOp(OpKind.DELETE, OpSide.RIGHT, d.rel_path, _is_dir(d.right)))
+    return queue
+
+
+def plan_update(diffs: list[DiffEntry]) -> OperationQueue:
+    """Copy only new/modified files from Left to Right. Never deletes."""
+    queue = OperationQueue()
+    for d in diffs:
+        if d.status in (DiffStatus.LEFT_ONLY, DiffStatus.MODIFIED):
+            queue.add(_copy_op(d, OpSide.LEFT_TO_RIGHT))
+    return queue
+
+
+def plan_two_way(diffs: list[DiffEntry]) -> tuple[OperationQueue, list[DiffEntry]]:
+    """Propagate each side's exclusive files to the other. MODIFIED entries are
+    real conflicts (both sides changed) and are returned separately for the
+    user to resolve by hand rather than guessed at.
+    """
+    queue = OperationQueue()
+    conflicts: list[DiffEntry] = []
+    for d in diffs:
+        if d.status == DiffStatus.LEFT_ONLY:
+            queue.add(_copy_op(d, OpSide.LEFT_TO_RIGHT))
+        elif d.status == DiffStatus.RIGHT_ONLY:
+            queue.add(_copy_op(d, OpSide.RIGHT_TO_LEFT))
+        elif d.status == DiffStatus.MODIFIED:
+            conflicts.append(d)
+    return queue, conflicts
+
+
+def _copy_op(d: DiffEntry, side: OpSide) -> QueuedOp:
+    entry = d.left if side == OpSide.LEFT_TO_RIGHT else d.right
+    return QueuedOp(OpKind.COPY, side, d.rel_path, _is_dir(entry), size=entry.size if entry else 0)
+
+
+def _is_dir(entry) -> bool:
+    return bool(entry and entry.kind == EntryKind.DIR)