s3ui 1.0.0__py3-none-any.whl

s3ui/models/s3_objects.py

@@ -0,0 +1,295 @@
+"""S3 object data structures and Qt table model."""
+
+from __future__ import annotations
+
+import bisect
+import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from PyQt6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from PyQt6.QtWidgets import QFileIconProvider
+
+logger = logging.getLogger("s3ui.s3_objects")
+
+
+@dataclass
+class S3Item:
+    """Represents a single S3 object or prefix (folder) in a listing."""
+
+    name: str
+    key: str
+    is_prefix: bool
+    size: int | None = None
+    last_modified: datetime | None = None
+    storage_class: str | None = None
+    etag: str | None = None
+
+
+def _sort_key(item: S3Item) -> tuple[int, str]:
+    """Sort key: prefixes first (0), then objects (1), alphabetical by name."""
+    return (0 if item.is_prefix else 1, item.name.lower())
+
+
+def _format_size(size_bytes: int | None) -> str:
+    """Format bytes into human-readable string."""
+    if size_bytes is None:
+        return ""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+    else:
+        return f"{size_bytes / (1024**3):.1f} GB"
+
+
+def _format_date(dt: datetime | None) -> str:
+    """Format datetime into human-readable string."""
+    if dt is None:
+        return ""
+    now = datetime.now(UTC)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    delta = now - dt
+    if delta.total_seconds() < 0:
+        return dt.strftime("%b %d, %Y")
+    if delta.total_seconds() < 60:
+        return "Just now"
+    if delta.total_seconds() < 3600:
+        mins = int(delta.total_seconds() / 60)
+        return f"{mins} minute{'s' if mins != 1 else ''} ago"
+    if delta.total_seconds() < 86400:
+        hours = int(delta.total_seconds() / 3600)
+        return f"{hours} hour{'s' if hours != 1 else ''} ago"
+    if dt.year == now.year:
+        return dt.strftime("%b %d")
+    return dt.strftime("%b %d, %Y")
+
+
+# Column indices
+COL_NAME = 0
+COL_SIZE = 1
+COL_MODIFIED = 2
+
+_COLUMN_HEADERS = ["Name", "Size", "Date Modified"]
+_COLUMN_COUNT = len(_COLUMN_HEADERS)
+
+
+class S3ObjectModel(QAbstractTableModel):
+    """Table model for S3 objects with granular mutation API."""
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self._items: list[S3Item] = []
+        self._icon_provider = QFileIconProvider()
+
+    # --- Qt model interface ---
+
+    _EMPTY_INDEX = QModelIndex()
+
+    def rowCount(self, parent: QModelIndex = _EMPTY_INDEX) -> int:
+        if parent.isValid():
+            return 0
+        return len(self._items)
+
+    def columnCount(self, parent: QModelIndex = _EMPTY_INDEX) -> int:
+        if parent.isValid():
+            return 0
+        return _COLUMN_COUNT
+
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or index.row() >= len(self._items):
+            return None
+
+        item = self._items[index.row()]
+        col = index.column()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            if col == COL_NAME:
+                return item.name
+            elif col == COL_SIZE:
+                if item.is_prefix:
+                    return ""
+                return _format_size(item.size)
+            elif col == COL_MODIFIED:
+                return _format_date(item.last_modified)
+            return None
+
+        if role == Qt.ItemDataRole.DecorationRole and col == COL_NAME:
+            if item.is_prefix:
+                return self._icon_provider.icon(QFileIconProvider.IconType.Folder)
+            return self._icon_provider.icon(QFileIconProvider.IconType.File)
+
+        if role == Qt.ItemDataRole.TextAlignmentRole:
+            if col == COL_SIZE:
+                return Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+            return Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter
+
+        if role == Qt.ItemDataRole.UserRole:
+            return item
+
+        return None
+
+    def headerData(
+        self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole
+    ):
+        if (
+            orientation == Qt.Orientation.Horizontal
+            and role == Qt.ItemDataRole.DisplayRole
+            and 0 <= section < _COLUMN_COUNT
+        ):
+            return _COLUMN_HEADERS[section]
+        return None
+
+    def flags(self, index: QModelIndex) -> Qt.ItemFlag:
+        base = super().flags(index)
+        if index.isValid():
+            return base | Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsDragEnabled
+        return base
+
+    # --- Data access ---
+
+    def get_item(self, row: int) -> S3Item | None:
+        """Get item at row index."""
+        if 0 <= row < len(self._items):
+            return self._items[row]
+        return None
+
+    def total_size(self) -> int:
+        """Sum of all item sizes."""
+        return sum(item.size or 0 for item in self._items if not item.is_prefix)
+
+    def item_count(self) -> int:
+        return len(self._items)
+
+    def items(self) -> list[S3Item]:
+        """Return a copy of the current items list."""
+        return list(self._items)
+
+    # --- Bulk operations ---
+
+    def set_items(self, items: list[S3Item]) -> None:
+        """Replace all items. Only for initial load."""
+        self.beginResetModel()
+        self._items = sorted(items, key=_sort_key)
+        self.endResetModel()
+
+    def clear(self) -> None:
+        """Remove all items."""
+        if not self._items:
+            return
+        self.beginResetModel()
+        self._items.clear()
+        self.endResetModel()
+
+    # --- Granular mutation methods ---
+
+    def insert_item(self, item: S3Item) -> int:
+        """Insert item in sorted position. Returns the row index."""
+        key = _sort_key(item)
+        keys = [_sort_key(i) for i in self._items]
+        row = bisect.bisect_left(keys, key)
+        self.beginInsertRows(QModelIndex(), row, row)
+        self._items.insert(row, item)
+        self.endInsertRows()
+        return row
+
+    def remove_item(self, key: str) -> bool:
+        """Remove item by key. Returns True if found."""
+        for row, item in enumerate(self._items):
+            if item.key == key:
+                self.beginRemoveRows(QModelIndex(), row, row)
+                self._items.pop(row)
+                self.endRemoveRows()
+                return True
+        return False
+
+    def remove_items(self, keys: set[str]) -> int:
+        """Batch remove items by keys. Removes highest index first. Returns count removed."""
+        rows_to_remove = []
+        for row, item in enumerate(self._items):
+            if item.key in keys:
+                rows_to_remove.append(row)
+        if not rows_to_remove:
+            return 0
+        # Remove from highest index first to avoid shifting
+        for row in reversed(rows_to_remove):
+            self.beginRemoveRows(QModelIndex(), row, row)
+            self._items.pop(row)
+            self.endRemoveRows()
+        return len(rows_to_remove)
+
+    def update_item(self, item_key: str, **fields) -> bool:
+        """Update fields on an existing item. Emits dataChanged for that row only."""
+        for row, item in enumerate(self._items):
+            if item.key == item_key:
+                for field, value in fields.items():
+                    if hasattr(item, field):
+                        setattr(item, field, value)
+                top_left = self.index(row, 0)
+                bottom_right = self.index(row, _COLUMN_COUNT - 1)
+                self.dataChanged.emit(top_left, bottom_right)
+                return True
+        return False
+
+    def append_items(self, items: list[S3Item]) -> None:
+        """Append items at end (for incremental page loading)."""
+        if not items:
+            return
+        start = len(self._items)
+        end = start + len(items) - 1
+        self.beginInsertRows(QModelIndex(), start, end)
+        self._items.extend(items)
+        self.endInsertRows()
+
+    def diff_apply(self, new_items: list[S3Item]) -> bool:
+        """Compute diff against current data and apply changes.
+
+        Returns True if any changes were made.
+        Used by background revalidation to minimize UI disruption.
+        """
+        new_sorted = sorted(new_items, key=_sort_key)
+        old_by_key = {item.key: item for item in self._items}
+        new_by_key = {item.key: item for item in new_sorted}
+
+        old_keys = set(old_by_key.keys())
+        new_keys = set(new_by_key.keys())
+
+        removed_keys = old_keys - new_keys
+        added_keys = new_keys - old_keys
+        common_keys = old_keys & new_keys
+
+        changed = False
+
+        # Remove missing items
+        if removed_keys:
+            self.remove_items(removed_keys)
+            changed = True
+
+        # Update changed items
+        for key in common_keys:
+            old_item = old_by_key[key]
+            new_item = new_by_key[key]
+            updates = {}
+            if old_item.size != new_item.size:
+                updates["size"] = new_item.size
+            if old_item.last_modified != new_item.last_modified:
+                updates["last_modified"] = new_item.last_modified
+            if old_item.storage_class != new_item.storage_class:
+                updates["storage_class"] = new_item.storage_class
+            if old_item.etag != new_item.etag:
+                updates["etag"] = new_item.etag
+            if old_item.name != new_item.name:
+                updates["name"] = new_item.name
+            if updates:
+                self.update_item(key, **updates)
+                changed = True
+
+        # Insert new items
+        for key in added_keys:
+            self.insert_item(new_by_key[key])
+            changed = True
+
+        return changed

s3ui/models/transfer_model.py

@@ -0,0 +1,282 @@
+"""Transfer model for the transfer panel with signal coalescing."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PyQt6.QtCore import QAbstractTableModel, QModelIndex, Qt, QTimer
+
+if TYPE_CHECKING:
+    from s3ui.db.database import Database
+
+logger = logging.getLogger("s3ui.transfer_model")
+
+# Column indices
+COL_DIRECTION = 0
+COL_FILE = 1
+COL_PROGRESS = 2
+COL_SPEED = 3
+COL_ETA = 4
+COL_STATUS = 5
+
+_COLUMN_HEADERS = ["", "File", "Progress", "Speed", "ETA", "Status"]
+_COLUMN_COUNT = len(_COLUMN_HEADERS)
+
+
+@dataclass
+class TransferRow:
+    """In-memory representation of a transfer for display."""
+
+    transfer_id: int
+    direction: str  # "upload" or "download"
+    filename: str
+    local_path: str
+    s3_key: str
+    total_bytes: int
+    transferred_bytes: int = 0
+    speed_bps: float = 0.0
+    eta_seconds: float = 0.0
+    _smoothed_eta: float = 0.0
+    status: str = "queued"
+    error_message: str = ""
+
+
+def _format_speed(bps: float) -> str:
+    if bps <= 0:
+        return "—"
+    if bps < 1024:
+        return f"{bps:.0f} B/s"
+    if bps < 1024 * 1024:
+        return f"{bps / 1024:.1f} KB/s"
+    return f"{bps / (1024 * 1024):.1f} MB/s"
+
+
+def _format_eta(seconds: float) -> str:
+    if seconds <= 0:
+        return "—"
+    if seconds < 60:
+        return f"~{int(seconds)} sec"
+    if seconds < 3600:
+        return f"~{int(seconds / 60)} min"
+    return f"~{seconds / 3600:.1f} hr"
+
+
+def _format_progress(transferred: int, total: int) -> str:
+    if total <= 0:
+        return "0%"
+    pct = (transferred / total) * 100
+    return f"{pct:.0f}%"
+
+
+def _format_status(row: TransferRow) -> str:
+    if row.status == "completed":
+        return "Complete"
+    if row.status == "failed":
+        return "Failed"
+    if row.status == "cancelled":
+        return "Cancelled"
+    if row.status == "paused":
+        return "Paused"
+    if row.status == "in_progress":
+        return _format_progress(row.transferred_bytes, row.total_bytes)
+    return "Queued"
+
+
+class TransferModel(QAbstractTableModel):
+    """Table model for transfers with 100ms coalesced updates."""
+
+    _EMPTY_INDEX = QModelIndex()
+
+    def __init__(self, db: Database | None = None, parent=None) -> None:
+        super().__init__(parent)
+        self._db = db
+        self._rows: list[TransferRow] = []
+        self._id_to_row: dict[int, int] = {}
+        self._pending_updates: dict[int, dict] = {}
+        self._dirty_rows: set[int] = set()
+
+        # Coalescing timer
+        self._timer = QTimer(self)
+        self._timer.setInterval(100)
+        self._timer.timeout.connect(self._flush_updates)
+
+    # --- Qt model interface ---
+
+    def rowCount(self, parent: QModelIndex = _EMPTY_INDEX) -> int:
+        if parent.isValid():
+            return 0
+        return len(self._rows)
+
+    def columnCount(self, parent: QModelIndex = _EMPTY_INDEX) -> int:
+        if parent.isValid():
+            return 0
+        return _COLUMN_COUNT
+
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole):
+        if not index.isValid() or index.row() >= len(self._rows):
+            return None
+
+        row = self._rows[index.row()]
+        col = index.column()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            if col == COL_DIRECTION:
+                return "↑" if row.direction == "upload" else "↓"
+            if col == COL_FILE:
+                return row.filename
+            if col == COL_PROGRESS:
+                return _format_progress(row.transferred_bytes, row.total_bytes)
+            if col == COL_SPEED:
+                if row.status == "in_progress":
+                    return _format_speed(row.speed_bps)
+                return "—"
+            if col == COL_ETA:
+                if row.status == "in_progress":
+                    return _format_eta(row.eta_seconds)
+                return "—"
+            if col == COL_STATUS:
+                return _format_status(row)
+            return None
+
+        if role == Qt.ItemDataRole.TextAlignmentRole:
+            if col in (COL_PROGRESS, COL_SPEED, COL_ETA):
+                return Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+            if col == COL_DIRECTION:
+                return Qt.AlignmentFlag.AlignCenter | Qt.AlignmentFlag.AlignVCenter
+            return Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter
+
+        if role == Qt.ItemDataRole.UserRole:
+            return row
+
+        if role == Qt.ItemDataRole.ToolTipRole and col == COL_STATUS:
+            if row.status == "failed":
+                return row.error_message
+            return None
+
+        return None
+
+    def headerData(
+        self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole
+    ):
+        if (
+            orientation == Qt.Orientation.Horizontal
+            and role == Qt.ItemDataRole.DisplayRole
+            and 0 <= section < _COLUMN_COUNT
+        ):
+            return _COLUMN_HEADERS[section]
+        return None
+
+    # --- Public API ---
+
+    def add_transfer(self, transfer_id: int) -> None:
+        """Add a transfer from the database."""
+        if self._db is None:
+            return
+        db_row = self._db.fetchone("SELECT * FROM transfers WHERE id = ?", (transfer_id,))
+        if not db_row:
+            return
+
+        from pathlib import Path
+
+        filename = Path(db_row["local_path"]).name
+
+        row = TransferRow(
+            transfer_id=transfer_id,
+            direction=db_row["direction"],
+            filename=filename,
+            local_path=db_row["local_path"],
+            s3_key=db_row["object_key"],
+            total_bytes=db_row["total_bytes"] or 0,
+            transferred_bytes=db_row["transferred"] or 0,
+            status=db_row["status"],
+        )
+
+        idx = len(self._rows)
+        self.beginInsertRows(QModelIndex(), idx, idx)
+        self._rows.append(row)
+        self._id_to_row[transfer_id] = idx
+        self.endInsertRows()
+
+        if not self._timer.isActive():
+            self._timer.start()
+
+    def get_transfer_row(self, transfer_id: int) -> TransferRow | None:
+        idx = self._id_to_row.get(transfer_id)
+        if idx is not None and idx < len(self._rows):
+            return self._rows[idx]
+        return None
+
+    # --- Signal handlers (buffer into pending updates) ---
+
+    def on_progress(self, transfer_id: int, bytes_done: int, total: int) -> None:
+        self._buffer_update(transfer_id, transferred_bytes=bytes_done, total_bytes=total)
+
+    def on_speed(self, transfer_id: int, bps: float) -> None:
+        idx = self._id_to_row.get(transfer_id)
+        if idx is not None:
+            row = self._rows[idx]
+            remaining = row.total_bytes - row.transferred_bytes
+            eta = remaining / bps if bps > 0 else 0
+            # ETA smoothing
+            smoothed = 0.7 * eta + 0.3 * row._smoothed_eta if row._smoothed_eta > 0 else eta
+            self._buffer_update(
+                transfer_id, speed_bps=bps, eta_seconds=smoothed, _smoothed_eta=smoothed
+            )
+
+    def on_status_changed(self, transfer_id: int, new_status: str) -> None:
+        self._buffer_update(transfer_id, status=new_status)
+
+    def on_error(self, transfer_id: int, user_msg: str, detail: str) -> None:
+        self._buffer_update(transfer_id, status="failed", error_message=user_msg)
+
+    def on_finished(self, transfer_id: int) -> None:
+        self._buffer_update(
+            transfer_id, status="completed", speed_bps=0, eta_seconds=0, _smoothed_eta=0
+        )
+
+    # --- Internal ---
+
+    def _buffer_update(self, transfer_id: int, **fields) -> None:
+        if transfer_id not in self._pending_updates:
+            self._pending_updates[transfer_id] = {}
+        self._pending_updates[transfer_id].update(fields)
+
+        idx = self._id_to_row.get(transfer_id)
+        if idx is not None:
+            self._dirty_rows.add(idx)
+
+    def _flush_updates(self) -> None:
+        if not self._pending_updates:
+            return
+
+        for transfer_id, fields in self._pending_updates.items():
+            idx = self._id_to_row.get(transfer_id)
+            if idx is None or idx >= len(self._rows):
+                continue
+            row = self._rows[idx]
+            for field_name, value in fields.items():
+                if hasattr(row, field_name):
+                    setattr(row, field_name, value)
+
+        if self._dirty_rows:
+            min_row = min(self._dirty_rows)
+            max_row = max(self._dirty_rows)
+            top_left = self.index(min_row, 0)
+            bottom_right = self.index(max_row, _COLUMN_COUNT - 1)
+            self.dataChanged.emit(top_left, bottom_right)
+
+        self._pending_updates.clear()
+        self._dirty_rows.clear()
+
+        # Stop timer if no active transfers
+        has_active = any(r.status in ("queued", "in_progress", "paused") for r in self._rows)
+        if not has_active:
+            self._timer.stop()
+
+    def active_count(self) -> int:
+        return sum(1 for r in self._rows if r.status == "in_progress")
+
+    def queued_count(self) -> int:
+        return sum(1 for r in self._rows if r.status == "queued")