cloudscope 0.1.0__py3-none-any.whl

cloudscope/sync/state.py

@@ -0,0 +1,140 @@
+"""SQLite-backed sync state tracking."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from pathlib import Path
+
+from platformdirs import user_data_dir
+
+from cloudscope.models.sync_state import SyncRecord
+
+SYNC_DATA_DIR = Path(user_data_dir("cloudscope", ensure_exists=True)) / "sync"
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS sync_state (
+    relative_path TEXT PRIMARY KEY,
+    local_size INTEGER,
+    local_mtime REAL,
+    local_checksum TEXT,
+    remote_size INTEGER,
+    remote_mtime REAL,
+    remote_checksum TEXT,
+    last_synced REAL NOT NULL,
+    sync_direction TEXT NOT NULL DEFAULT 'both'
+);
+"""
+
+
+class SyncStateDB:
+    """Persistent sync state stored in a SQLite database."""
+
+    def __init__(self, db_path: Path | None = None) -> None:
+        if db_path is None:
+            SYNC_DATA_DIR.mkdir(parents=True, exist_ok=True)
+            db_path = SYNC_DATA_DIR / "sync_state.db"
+        self._db_path = db_path
+        self._conn: sqlite3.Connection | None = None
+
+    def open(self) -> None:
+        self._conn = sqlite3.connect(str(self._db_path))
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.execute(_SCHEMA)
+        self._conn.commit()
+
+    def close(self) -> None:
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+    def __enter__(self) -> SyncStateDB:
+        self.open()
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def _ensure_open(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self.open()
+        return self._conn  # type: ignore[return-value]
+
+    def get_record(self, relative_path: str) -> SyncRecord | None:
+        conn = self._ensure_open()
+        row = conn.execute(
+            "SELECT * FROM sync_state WHERE relative_path = ?", (relative_path,)
+        ).fetchone()
+        if row is None:
+            return None
+        return self._row_to_record(row)
+
+    def upsert_record(self, record: SyncRecord) -> None:
+        conn = self._ensure_open()
+        conn.execute(
+            """
+            INSERT INTO sync_state
+                (relative_path, local_size, local_mtime, local_checksum,
+                 remote_size, remote_mtime, remote_checksum, last_synced, sync_direction)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(relative_path) DO UPDATE SET
+                local_size = excluded.local_size,
+                local_mtime = excluded.local_mtime,
+                local_checksum = excluded.local_checksum,
+                remote_size = excluded.remote_size,
+                remote_mtime = excluded.remote_mtime,
+                remote_checksum = excluded.remote_checksum,
+                last_synced = excluded.last_synced,
+                sync_direction = excluded.sync_direction
+            """,
+            (
+                record.relative_path,
+                record.local_size,
+                record.local_mtime,
+                record.local_checksum,
+                record.remote_size,
+                record.remote_mtime,
+                record.remote_checksum,
+                record.last_synced,
+                record.sync_direction,
+            ),
+        )
+        conn.commit()
+
+    def delete_record(self, relative_path: str) -> None:
+        conn = self._ensure_open()
+        conn.execute(
+            "DELETE FROM sync_state WHERE relative_path = ?", (relative_path,)
+        )
+        conn.commit()
+
+    def all_records(self) -> list[SyncRecord]:
+        conn = self._ensure_open()
+        rows = conn.execute("SELECT * FROM sync_state ORDER BY relative_path").fetchall()
+        return [self._row_to_record(row) for row in rows]
+
+    def clear(self) -> None:
+        conn = self._ensure_open()
+        conn.execute("DELETE FROM sync_state")
+        conn.commit()
+
+    @staticmethod
+    def _row_to_record(row: tuple) -> SyncRecord:
+        return SyncRecord(
+            relative_path=row[0],
+            local_size=row[1],
+            local_mtime=row[2],
+            local_checksum=row[3],
+            remote_size=row[4],
+            remote_mtime=row[5],
+            remote_checksum=row[6],
+            last_synced=row[7],
+            sync_direction=row[8],
+        )
+
+
+def db_path_for_sync_pair(backend_type: str, container: str, prefix: str) -> Path:
+    """Generate a unique DB path for a sync pair."""
+    safe_name = f"{backend_type}_{container}_{prefix}".replace("/", "_").replace("\\", "_")
+    SYNC_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    return SYNC_DATA_DIR / f"{safe_name}.db"

cloudscope/transfer/manager.py

@@ -0,0 +1,150 @@
+"""Transfer manager — queues and executes file transfers with concurrency control."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from collections.abc import Callable
+from pathlib import Path
+
+from cloudscope.backends.base import CloudBackend
+from cloudscope.models.transfer import TransferDirection, TransferJob, TransferStatus
+from cloudscope.transfer.progress import ProgressAdapter
+
+
+class TransferManager:
+    """Manages concurrent file transfer operations."""
+
+    def __init__(self, max_concurrent: int = 3) -> None:
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        self._jobs: dict[str, TransferJob] = {}
+        self._on_update: Callable[[TransferJob], None] | None = None
+
+    @property
+    def jobs(self) -> list[TransferJob]:
+        return list(self._jobs.values())
+
+    @property
+    def active_jobs(self) -> list[TransferJob]:
+        return [
+            j
+            for j in self._jobs.values()
+            if j.status in (TransferStatus.PENDING, TransferStatus.IN_PROGRESS)
+        ]
+
+    def set_update_callback(self, callback: Callable[[TransferJob], None]) -> None:
+        self._on_update = callback
+
+    async def download(
+        self,
+        backend: CloudBackend,
+        container: str,
+        remote_path: str,
+        local_path: str,
+    ) -> TransferJob:
+        """Queue a download job."""
+        job = TransferJob(
+            id=str(uuid.uuid4())[:8],
+            direction=TransferDirection.DOWNLOAD,
+            local_path=Path(local_path),
+            remote_container=container,
+            remote_path=remote_path,
+            backend_type=backend.backend_type,
+        )
+        self._jobs[job.id] = job
+        self._notify(job)
+
+        asyncio.create_task(self._execute_download(backend, job))
+        return job
+
+    async def upload(
+        self,
+        backend: CloudBackend,
+        container: str,
+        local_path: str,
+        remote_path: str,
+    ) -> TransferJob:
+        """Queue an upload job."""
+        local = Path(local_path)
+        job = TransferJob(
+            id=str(uuid.uuid4())[:8],
+            direction=TransferDirection.UPLOAD,
+            local_path=local,
+            remote_container=container,
+            remote_path=remote_path,
+            backend_type=backend.backend_type,
+            total_bytes=local.stat().st_size if local.exists() else 0,
+        )
+        self._jobs[job.id] = job
+        self._notify(job)
+
+        asyncio.create_task(self._execute_upload(backend, job))
+        return job
+
+    async def _execute_download(
+        self, backend: CloudBackend, job: TransferJob
+    ) -> None:
+        async with self._semaphore:
+            job.status = TransferStatus.IN_PROGRESS
+            self._notify(job)
+            try:
+                # Get file size first
+                try:
+                    stat = await backend.stat(job.remote_container, job.remote_path)
+                    job.total_bytes = stat.size
+                except Exception:
+                    pass
+
+                progress = ProgressAdapter(job, self._notify)
+                await backend.download(
+                    job.remote_container,
+                    job.remote_path,
+                    str(job.local_path),
+                    progress_callback=progress,
+                )
+                job.status = TransferStatus.COMPLETED
+                job.transferred_bytes = job.total_bytes
+            except Exception as e:
+                job.status = TransferStatus.FAILED
+                job.error = str(e)
+            self._notify(job)
+
+    async def _execute_upload(
+        self, backend: CloudBackend, job: TransferJob
+    ) -> None:
+        async with self._semaphore:
+            job.status = TransferStatus.IN_PROGRESS
+            self._notify(job)
+            try:
+                progress = ProgressAdapter(job, self._notify)
+                await backend.upload(
+                    job.remote_container,
+                    str(job.local_path),
+                    job.remote_path,
+                    progress_callback=progress,
+                )
+                job.status = TransferStatus.COMPLETED
+                job.transferred_bytes = job.total_bytes
+            except Exception as e:
+                job.status = TransferStatus.FAILED
+                job.error = str(e)
+            self._notify(job)
+
+    def cancel(self, job_id: str) -> None:
+        """Cancel a pending or in-progress job."""
+        job = self._jobs.get(job_id)
+        if job and job.status in (TransferStatus.PENDING, TransferStatus.IN_PROGRESS):
+            job.status = TransferStatus.CANCELLED
+            self._notify(job)
+
+    def clear_completed(self) -> None:
+        """Remove completed, failed, and cancelled jobs from the list."""
+        self._jobs = {
+            k: v
+            for k, v in self._jobs.items()
+            if v.status in (TransferStatus.PENDING, TransferStatus.IN_PROGRESS)
+        }
+
+    def _notify(self, job: TransferJob) -> None:
+        if self._on_update:
+            self._on_update(job)

cloudscope/transfer/progress.py

@@ -0,0 +1,20 @@
+"""Progress callback adapter — bridges SDK callbacks to the transfer manager."""
+
+from __future__ import annotations
+
+from cloudscope.models.transfer import TransferJob
+
+
+class ProgressAdapter:
+    """Wraps a TransferJob and updates it from SDK progress callbacks."""
+
+    def __init__(self, job: TransferJob, on_update: callable | None = None) -> None:
+        self._job = job
+        self._on_update = on_update
+
+    def __call__(self, bytes_transferred: int, total_bytes: int) -> None:
+        self._job.transferred_bytes = bytes_transferred
+        if total_bytes > 0:
+            self._job.total_bytes = total_bytes
+        if self._on_update:
+            self._on_update(self._job)

cloudscope/tui/commands.py

@@ -0,0 +1,47 @@
+"""Command palette provider for CloudScope."""
+
+from __future__ import annotations
+
+from functools import partial
+
+from textual.command import Hit, Hits, Provider
+
+
+class CloudScopeCommands(Provider):
+    """Provides app-specific commands for the Ctrl+K command palette."""
+
+    COMMANDS: list[tuple[str, str, str]] = [
+        ("Switch to S3", "switch_backend('s3')", "Connect to Amazon S3"),
+        ("Switch to GCS", "switch_backend('gcs')", "Connect to Google Cloud Storage"),
+        ("Switch to Google Drive", "switch_backend('drive')", "Connect to Google Drive"),
+        ("Download selected file", "download", "Download the currently selected file"),
+        ("Upload file", "upload", "Upload a local file to the current location"),
+        ("Create new folder", "new_folder", "Create a new folder in the current location"),
+        ("Delete selected", "delete_file", "Delete the currently selected file"),
+        ("Refresh", "refresh", "Refresh the current view"),
+        ("Open sync", "open_sync", "Open sync configuration"),
+        ("Open settings", "open_settings", "Open application settings"),
+        ("Open auth setup", "open_auth", "Configure authentication"),
+        ("Quit", "quit", "Exit CloudScope"),
+    ]
+
+    async def search(self, query: str) -> Hits:
+        matcher = self.matcher(query)
+        for name, action, help_text in self.COMMANDS:
+            score = matcher.match(name)
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(name),
+                    partial(self.app.run_action, action),
+                    help=help_text,
+                )
+
+    async def discover(self) -> Hits:
+        for name, action, help_text in self.COMMANDS:
+            yield Hit(
+                1.0,
+                name,
+                partial(self.app.run_action, action),
+                help=help_text,
+            )

cloudscope/tui/modals/confirm_dialog.py

@@ -0,0 +1,93 @@
+"""Generic confirmation modal dialog."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+
+class ConfirmDialog(ModalScreen[bool]):
+    """A modal dialog that asks for yes/no confirmation."""
+
+    DEFAULT_CSS = """
+    ConfirmDialog {
+        align: center middle;
+        background: rgba(10, 10, 26, 0.85);
+    }
+    ConfirmDialog > Vertical {
+        width: 50;
+        height: auto;
+        max-height: 15;
+        border: double #7c3aed;
+        background: #16213e;
+        padding: 1 2;
+    }
+    ConfirmDialog .title {
+        text-style: bold;
+        color: #e2e8f0;
+        width: 100%;
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+    ConfirmDialog .message {
+        color: #94a3b8;
+        width: 100%;
+        margin-bottom: 1;
+    }
+    ConfirmDialog Horizontal {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
+    ConfirmDialog Button {
+        margin: 0 1;
+        background: #1e2a4a;
+        color: #e2e8f0;
+        border: tall #2a2a4a;
+    }
+    ConfirmDialog Button:hover {
+        background: #2a2a4a;
+    }
+    ConfirmDialog #yes {
+        background: #ef4444;
+        color: #e2e8f0;
+        border: tall #dc2626;
+    }
+    ConfirmDialog #yes:hover {
+        background: #dc2626;
+    }
+    ConfirmDialog #no {
+        background: #7c3aed;
+        color: #e2e8f0;
+        border: tall #5b21b6;
+    }
+    ConfirmDialog #no:hover {
+        background: #5b21b6;
+    }
+    """
+
+    def __init__(
+        self,
+        title: str = "Confirm",
+        message: str = "Are you sure?",
+        yes_label: str = "Yes",
+        no_label: str = "No",
+    ) -> None:
+        super().__init__()
+        self._title = title
+        self._message = message
+        self._yes_label = yes_label
+        self._no_label = no_label
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label(self._title, classes="title")
+            yield Static(self._message, classes="message")
+            with Horizontal():
+                yield Button(self._yes_label, id="yes")
+                yield Button(self._no_label, id="no")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "yes")

cloudscope/tui/modals/download_dialog.py

@@ -0,0 +1,111 @@
+"""Download destination picker dialog."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, DirectoryTree, Input, Label, Static
+
+
+class DownloadDialog(ModalScreen[str | None]):
+    """Modal for selecting a local download destination."""
+
+    DEFAULT_CSS = """
+    DownloadDialog {
+        align: center middle;
+        background: rgba(10, 10, 26, 0.85);
+    }
+    DownloadDialog > Vertical {
+        width: 70;
+        height: 30;
+        border: double #7c3aed;
+        background: #16213e;
+        padding: 1 2;
+    }
+    DownloadDialog .title {
+        text-style: bold;
+        color: #e2e8f0;
+        width: 100%;
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+    DownloadDialog Static {
+        color: #94a3b8;
+    }
+    DownloadDialog DirectoryTree {
+        height: 1fr;
+        margin-bottom: 1;
+        background: #1a1a2e;
+        scrollbar-size: 1 1;
+        scrollbar-background: #1a1a2e;
+        scrollbar-color: #2a2a4a;
+        scrollbar-color-hover: #475569;
+    }
+    DownloadDialog Input {
+        margin-bottom: 1;
+        background: #1a1a2e;
+        color: #e2e8f0;
+        border: tall #2a2a4a;
+    }
+    DownloadDialog Input:focus {
+        border: tall #7c3aed;
+    }
+    DownloadDialog Horizontal {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
+    DownloadDialog Button {
+        margin: 0 1;
+        background: #1e2a4a;
+        color: #e2e8f0;
+        border: tall #2a2a4a;
+    }
+    DownloadDialog Button:hover {
+        background: #2a2a4a;
+    }
+    DownloadDialog #download {
+        background: #7c3aed;
+        color: #e2e8f0;
+        border: tall #5b21b6;
+    }
+    DownloadDialog #download:hover {
+        background: #5b21b6;
+    }
+    """
+
+    def __init__(self, file_name: str, default_dir: str | None = None) -> None:
+        super().__init__()
+        self._file_name = file_name
+        self._default_dir = default_dir or str(Path.home() / "Downloads")
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label(f"Download: {self._file_name}", classes="title")
+            yield Static("Select destination directory:")
+            yield DirectoryTree(self._default_dir, id="dir-tree")
+            yield Input(value=self._default_dir, placeholder="Destination path", id="path-input")
+            with Horizontal():
+                yield Button("Download", id="download")
+                yield Button("Cancel", id="cancel")
+
+    def on_directory_tree_directory_selected(
+        self, event: DirectoryTree.DirectorySelected
+    ) -> None:
+        path_input = self.query_one("#path-input", Input)
+        path_input.value = str(event.path)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "download":
+            path_input = self.query_one("#path-input", Input)
+            dest_dir = path_input.value.strip()
+            if dest_dir:
+                full_path = str(Path(dest_dir) / self._file_name)
+                self.dismiss(full_path)
+            else:
+                self.notify("Please select a destination", severity="warning")
+        else:
+            self.dismiss(None)

cloudscope/tui/modals/new_folder.py

@@ -0,0 +1,96 @@
+"""New folder creation dialog."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label
+
+
+class NewFolderDialog(ModalScreen[str | None]):
+    """Modal for entering a new folder name."""
+
+    DEFAULT_CSS = """
+    NewFolderDialog {
+        align: center middle;
+        background: rgba(10, 10, 26, 0.85);
+    }
+    NewFolderDialog > Vertical {
+        width: 50;
+        height: auto;
+        border: double #7c3aed;
+        background: #16213e;
+        padding: 1 2;
+    }
+    NewFolderDialog .title {
+        text-style: bold;
+        color: #e2e8f0;
+        width: 100%;
+        content-align: center middle;
+        margin-bottom: 1;
+    }
+    NewFolderDialog Input {
+        margin-bottom: 1;
+        background: #1a1a2e;
+        color: #e2e8f0;
+        border: tall #2a2a4a;
+    }
+    NewFolderDialog Input:focus {
+        border: tall #7c3aed;
+    }
+    NewFolderDialog Horizontal {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
+    NewFolderDialog Button {
+        margin: 0 1;
+        background: #1e2a4a;
+        color: #e2e8f0;
+        border: tall #2a2a4a;
+    }
+    NewFolderDialog Button:hover {
+        background: #2a2a4a;
+    }
+    NewFolderDialog #create {
+        background: #7c3aed;
+        color: #e2e8f0;
+        border: tall #5b21b6;
+    }
+    NewFolderDialog #create:hover {
+        background: #5b21b6;
+    }
+    """
+
+    def __init__(self, current_path: str = "") -> None:
+        super().__init__()
+        self._current_path = current_path
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Create New Folder", classes="title")
+            yield Input(placeholder="Folder name", id="folder-name")
+            with Horizontal():
+                yield Button("Create", id="create")
+                yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        self.query_one("#folder-name", Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self._submit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "create":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def _submit(self) -> None:
+        name = self.query_one("#folder-name", Input).value.strip()
+        if name:
+            path = f"{self._current_path}/{name}".lstrip("/")
+            self.dismiss(path)
+        else:
+            self.notify("Please enter a folder name", severity="warning")