s3ui 1.0.0__py3-none-any.whl

s3ui/ui/breadcrumb_bar.py

@@ -0,0 +1,150 @@
+"""Clickable breadcrumb path bar with edit mode."""
+
+import sys
+from pathlib import Path
+
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QSizePolicy,
+    QToolButton,
+    QWidget,
+)
+
+
+class BreadcrumbBar(QWidget):
+    """Breadcrumb navigation bar.
+
+    Shows path segments as clickable buttons. Clicking whitespace to the right
+    enters edit mode with a QLineEdit for typing a path directly.
+    """
+
+    path_clicked = pyqtSignal(str)  # emitted when a segment is clicked
+    path_edited = pyqtSignal(str)  # emitted when path is typed and Enter pressed
+
+    def __init__(self, separator: str = "/", parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._separator = separator
+        self._current_path = ""
+        self._editing = False
+
+        self._layout = QHBoxLayout(self)
+        self._layout.setContentsMargins(2, 0, 2, 0)
+        self._layout.setSpacing(0)
+
+        # Edit line (hidden by default)
+        self._edit = QLineEdit(self)
+        self._edit.setVisible(False)
+        self._edit.returnPressed.connect(self._on_edit_accepted)
+        self._edit.installEventFilter(self)
+
+        # Clickable area to enter edit mode
+        self.setMouseTracking(True)
+        self.setCursor(Qt.CursorShape.IBeamCursor)
+
+    def set_path(self, path: str) -> None:
+        """Set the displayed path, rebuilding segment buttons."""
+        self._current_path = path
+        if not self._editing:
+            self._rebuild_segments()
+
+    def current_path(self) -> str:
+        return self._current_path
+
+    def _rebuild_segments(self) -> None:
+        # Clear existing widgets (except the edit line)
+        while self._layout.count():
+            item = self._layout.takeAt(0)
+            widget = item.widget()
+            if widget and widget is not self._edit:
+                widget.deleteLater()
+
+        if not self._current_path:
+            return
+
+        # Parse path into segments
+        if self._separator == "/":
+            parts = Path(self._current_path).parts
+        else:
+            parts = self._current_path.split(self._separator)
+            parts = [p for p in parts if p]
+
+        # Build segment buttons
+        for i, part in enumerate(parts):
+            if i > 0:
+                sep = QLabel(self._separator)
+                sep.setStyleSheet("color: gray; padding: 0 2px;")
+                self._layout.addWidget(sep)
+
+            btn = QToolButton()
+            btn.setText(part)
+            btn.setAutoRaise(True)
+            btn.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextOnly)
+
+            # Build the path up to this segment
+            if self._separator == "/":
+                segment_path = str(Path(*parts[: i + 1]))
+                # On Unix, ensure root starts with /
+                if sys.platform != "win32" and not segment_path.startswith("/"):
+                    segment_path = "/" + segment_path
+            else:
+                segment_path = self._separator.join(parts[: i + 1])
+                if not segment_path.endswith(self._separator):
+                    segment_path += self._separator
+
+            btn.clicked.connect(lambda checked, p=segment_path: self.path_clicked.emit(p))
+            self._layout.addWidget(btn)
+
+        # Spacer to fill remaining width (clicking it enters edit mode)
+        spacer = QWidget()
+        spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+        self._layout.addWidget(spacer)
+
+    def _enter_edit_mode(self) -> None:
+        self._editing = True
+        # Hide all segment widgets
+        for i in range(self._layout.count()):
+            w = self._layout.itemAt(i).widget()
+            if w:
+                w.setVisible(False)
+
+        self._edit.setText(self._current_path)
+        self._edit.setVisible(True)
+        self._edit.selectAll()
+        self._edit.setFocus()
+        self._layout.addWidget(self._edit)
+
+    def _exit_edit_mode(self) -> None:
+        self._editing = False
+        self._edit.setVisible(False)
+        self._rebuild_segments()
+
+    def _on_edit_accepted(self) -> None:
+        text = self._edit.text().strip()
+        self._exit_edit_mode()
+        if text:
+            self.path_edited.emit(text)
+
+    def mousePressEvent(self, event) -> None:
+        # Click on empty area enters edit mode
+        if not self._editing:
+            child = self.childAt(event.pos())
+            if child is None or child.objectName() == "":
+                self._enter_edit_mode()
+                return
+        super().mousePressEvent(event)
+
+    def eventFilter(self, obj, event) -> bool:
+        if obj is self._edit:
+            from PyQt6.QtCore import QEvent
+
+            if event.type() == QEvent.Type.KeyPress:
+                if event.key() == Qt.Key.Key_Escape:
+                    self._exit_edit_mode()
+                    return True
+            elif event.type() == QEvent.Type.FocusOut:
+                self._exit_edit_mode()
+                return True
+        return super().eventFilter(obj, event)

s3ui/ui/confirm_delete.py

@@ -0,0 +1,60 @@
+"""Delete confirmation dialog."""
+
+from __future__ import annotations
+
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QLabel,
+    QListWidget,
+    QVBoxLayout,
+)
+
+from s3ui.models.s3_objects import _format_size
+
+
+class DeleteConfirmDialog(QDialog):
+    """Confirm deletion of S3 objects."""
+
+    def __init__(
+        self,
+        keys: list[str],
+        total_size: int = 0,
+        parent=None,
+    ) -> None:
+        super().__init__(parent)
+        count = len(keys)
+        self.setWindowTitle(f"Delete {count} file{'s' if count != 1 else ''}?")
+        self.setMinimumWidth(400)
+
+        layout = QVBoxLayout(self)
+
+        # Warning
+        layout.addWidget(
+            QLabel(f"Are you sure you want to delete {count} item{'s' if count != 1 else ''}?")
+        )
+
+        # File list (first 10)
+        file_list = QListWidget()
+        for key in keys[:10]:
+            file_list.addItem(key)
+        if count > 10:
+            file_list.addItem(f"...and {count - 10} more")
+        file_list.setMaximumHeight(200)
+        layout.addWidget(file_list)
+
+        # Total size
+        if total_size > 0:
+            layout.addWidget(QLabel(f"Total size: {_format_size(total_size)}"))
+
+        # Warning
+        layout.addWidget(QLabel("This action cannot be undone."))
+
+        # Buttons
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Cancel | QDialogButtonBox.StandardButton.Ok
+        )
+        buttons.button(QDialogButtonBox.StandardButton.Ok).setText("Delete")
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)

s3ui/ui/cost_dialog.py

@@ -0,0 +1,163 @@
+"""Cost dashboard dialog."""
+
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import TYPE_CHECKING
+
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFileDialog,
+    QLabel,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+)
+
+if TYPE_CHECKING:
+    from s3ui.core.cost import CostTracker
+
+
+def _fmt_bytes(n: int) -> str:
+    """Human-readable byte size."""
+    if n < 1024:
+        return f"{n} B"
+    if n < 1024**2:
+        return f"{n / 1024:.1f} KB"
+    if n < 1024**3:
+        return f"{n / 1024**2:.1f} MB"
+    return f"{n / 1024**3:.2f} GB"
+
+
+class CostDialog(QDialog):
+    """Shows monthly cost estimate and daily breakdown."""
+
+    def __init__(self, cost_tracker: CostTracker | None = None, parent=None) -> None:
+        super().__init__(parent)
+        self._cost = cost_tracker
+        self.setWindowTitle("Cost Dashboard")
+        self.setMinimumSize(500, 400)
+
+        layout = QVBoxLayout(self)
+
+        # Monthly estimate
+        self._estimate_label = QLabel("Estimated cost this month: —")
+        self._estimate_label.setStyleSheet("font-size: 18px; font-weight: bold;")
+        layout.addWidget(self._estimate_label)
+
+        # Daily breakdown table
+        layout.addWidget(QLabel("Daily Breakdown (last 30 days):"))
+        self._daily_table = QTableWidget()
+        self._daily_table.setColumnCount(5)
+        self._daily_table.setHorizontalHeaderLabels(
+            ["Date", "Requests", "Upload", "Download", "Est. Cost"]
+        )
+        layout.addWidget(self._daily_table)
+
+        # Buttons
+        btn_layout = QDialogButtonBox()
+
+        export_btn = QPushButton("Export CSV")
+        export_btn.clicked.connect(self._export_csv)
+        btn_layout.addButton(export_btn, QDialogButtonBox.ButtonRole.ActionRole)
+
+        close_btn = btn_layout.addButton(QDialogButtonBox.StandardButton.Close)
+        close_btn.clicked.connect(self.accept)
+        layout.addWidget(btn_layout)
+
+        self._load_data()
+
+    def _load_data(self) -> None:
+        if not self._cost:
+            return
+
+        estimate = self._cost.get_monthly_estimate()
+        self._estimate_label.setText(f"Estimated cost this month: ${estimate:.4f}")
+
+        today = date.today()
+        start = (today - timedelta(days=29)).isoformat()
+        end = today.isoformat()
+        days = self._cost.get_daily_costs(start, end)
+
+        # Get raw usage rows for request counts and byte totals
+        usage_map = self._build_usage_map(start, end)
+
+        self._daily_table.setRowCount(len(days))
+        for i, day in enumerate(days):
+            self._daily_table.setItem(i, 0, QTableWidgetItem(day.date))
+
+            usage = usage_map.get(day.date)
+            if usage:
+                total_reqs = (
+                    (usage["put_requests"] or 0)
+                    + (usage["get_requests"] or 0)
+                    + (usage["list_requests"] or 0)
+                    + (usage["delete_requests"] or 0)
+                    + (usage["head_requests"] or 0)
+                    + (usage["copy_requests"] or 0)
+                )
+                upload = usage["bytes_uploaded"] or 0
+                download = usage["bytes_downloaded"] or 0
+            else:
+                total_reqs = 0
+                upload = 0
+                download = 0
+
+            self._daily_table.setItem(i, 1, QTableWidgetItem(f"{total_reqs:,}"))
+            self._daily_table.setItem(i, 2, QTableWidgetItem(_fmt_bytes(upload)))
+            self._daily_table.setItem(i, 3, QTableWidgetItem(_fmt_bytes(download)))
+            self._daily_table.setItem(i, 4, QTableWidgetItem(f"${day.total:.4f}"))
+
+    def _build_usage_map(self, start: str, end: str) -> dict:
+        """Query raw daily_usage rows and index by date."""
+        if not self._cost or not self._cost._db:
+            return {}
+        rows = self._cost._db.fetchall(
+            "SELECT * FROM daily_usage WHERE bucket_id = ? "
+            "AND usage_date >= ? AND usage_date <= ? ORDER BY usage_date",
+            (self._cost._bucket_id, start, end),
+        )
+        return {row["usage_date"]: row for row in rows}
+
+    def _export_csv(self) -> None:
+        path, _ = QFileDialog.getSaveFileName(
+            self, "Export Cost Data", "s3ui-costs.csv", "CSV Files (*.csv)"
+        )
+        if not path or not self._cost:
+            return
+
+        today = date.today()
+        start = (today - timedelta(days=364)).isoformat()
+        end = today.isoformat()
+        days = self._cost.get_daily_costs(start, end)
+        usage_map = self._build_usage_map(start, end)
+
+        with open(path, "w") as f:
+            f.write(
+                "date,put_requests,get_requests,list_requests,delete_requests,"
+                "head_requests,copy_requests,bytes_uploaded,bytes_downloaded,"
+                "storage_cost,request_cost,transfer_cost,total_cost\n"
+            )
+            for day in days:
+                usage = usage_map.get(day.date)
+                if usage:
+                    f.write(
+                        f"{day.date},{usage['put_requests'] or 0},"
+                        f"{usage['get_requests'] or 0},"
+                        f"{usage['list_requests'] or 0},"
+                        f"{usage['delete_requests'] or 0},"
+                        f"{usage['head_requests'] or 0},"
+                        f"{usage['copy_requests'] or 0},"
+                        f"{usage['bytes_uploaded'] or 0},"
+                        f"{usage['bytes_downloaded'] or 0},"
+                        f"{day.storage:.6f},{day.requests:.6f},"
+                        f"{day.transfer:.6f},{day.total:.6f}\n"
+                    )
+                else:
+                    f.write(
+                        f"{day.date},0,0,0,0,0,0,0,0,"
+                        f"{day.storage:.6f},0.000000,0.000000,"
+                        f"{day.storage:.6f}\n"
+                    )

s3ui/ui/get_info.py

@@ -0,0 +1,50 @@
+"""Get Info dialog showing S3 object metadata."""
+
+from __future__ import annotations
+
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QLabel,
+    QVBoxLayout,
+)
+
+from s3ui.models.s3_objects import S3Item, _format_date, _format_size
+
+
+class GetInfoDialog(QDialog):
+    """Shows detailed metadata for an S3 object or prefix."""
+
+    def __init__(self, item: S3Item, parent=None) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Get Info")
+        self.setMinimumWidth(400)
+
+        layout = QVBoxLayout(self)
+
+        # File name (large)
+        name_label = QLabel(item.name)
+        name_label.setStyleSheet("font-size: 16px; font-weight: bold;")
+        layout.addWidget(name_label)
+
+        # Details
+        form = QFormLayout()
+
+        form.addRow("S3 Key:", QLabel(item.key))
+
+        if not item.is_prefix:
+            form.addRow("Size:", QLabel(_format_size(item.size)))
+            form.addRow("Last Modified:", QLabel(_format_date(item.last_modified)))
+            if item.storage_class:
+                form.addRow("Storage Class:", QLabel(item.storage_class))
+            if item.etag:
+                form.addRow("ETag:", QLabel(item.etag))
+        else:
+            form.addRow("Type:", QLabel("Folder (prefix)"))
+
+        layout.addLayout(form)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)

s3ui/ui/local_pane.py

@@ -0,0 +1,226 @@
+"""Local file system pane — left side of the dual-pane browser."""
+
+import logging
+from pathlib import Path
+
+from PyQt6.QtCore import QDir, QModelIndex, Qt, QUrl, pyqtSignal
+from PyQt6.QtGui import QDesktopServices, QFileSystemModel
+from PyQt6.QtWidgets import (
+    QAbstractItemView,
+    QHBoxLayout,
+    QLabel,
+    QToolButton,
+    QTreeView,
+    QVBoxLayout,
+    QWidget,
+)
+
+from s3ui.constants import NAV_HISTORY_MAX
+from s3ui.ui.breadcrumb_bar import BreadcrumbBar
+
+logger = logging.getLogger("s3ui.local_pane")
+
+
+class LocalPaneWidget(QWidget):
+    """Pane for browsing local files with QFileSystemModel."""
+
+    directory_changed = pyqtSignal(str)  # current directory path
+    upload_requested = pyqtSignal(list)  # list of local file paths
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._history_back: list[str] = []
+        self._history_forward: list[str] = []
+        self._current_path = str(Path.home())
+        self._show_hidden = False
+
+        self._setup_ui()
+        self._setup_model()
+        self.navigate_to(self._current_path, record_history=False)
+
+    def _setup_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Mini toolbar
+        toolbar = QHBoxLayout()
+        toolbar.setContentsMargins(4, 2, 4, 2)
+        toolbar.setSpacing(2)
+
+        self._back_btn = QToolButton()
+        self._back_btn.setText("◀")
+        self._back_btn.setToolTip("Back")
+        self._back_btn.setAutoRaise(True)
+        self._back_btn.clicked.connect(self.go_back)
+        self._back_btn.setEnabled(False)
+        toolbar.addWidget(self._back_btn)
+
+        self._forward_btn = QToolButton()
+        self._forward_btn.setText("▶")
+        self._forward_btn.setToolTip("Forward")
+        self._forward_btn.setAutoRaise(True)
+        self._forward_btn.clicked.connect(self.go_forward)
+        self._forward_btn.setEnabled(False)
+        toolbar.addWidget(self._forward_btn)
+
+        self._up_btn = QToolButton()
+        self._up_btn.setText("▲")
+        self._up_btn.setToolTip("Enclosing Folder")
+        self._up_btn.setAutoRaise(True)
+        self._up_btn.clicked.connect(self.go_up)
+        toolbar.addWidget(self._up_btn)
+
+        self._breadcrumb = BreadcrumbBar(separator="/")
+        self._breadcrumb.path_clicked.connect(self._on_breadcrumb_clicked)
+        self._breadcrumb.path_edited.connect(self._on_breadcrumb_edited)
+        toolbar.addWidget(self._breadcrumb, 1)
+
+        toolbar_widget = QWidget()
+        toolbar_widget.setLayout(toolbar)
+        layout.addWidget(toolbar_widget)
+
+        # Tree view
+        self._tree = QTreeView()
+        self._tree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self._tree.setUniformRowHeights(True)
+        self._tree.setSortingEnabled(True)
+        self._tree.setAnimated(False)
+        self._tree.setDragEnabled(True)
+        self._tree.setDragDropMode(QAbstractItemView.DragDropMode.DragOnly)
+        self._tree.doubleClicked.connect(self._on_double_click)
+        self._tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self._tree.customContextMenuRequested.connect(self._on_context_menu)
+        layout.addWidget(self._tree, 1)
+
+        # Footer
+        self._footer = QLabel("0 items")
+        self._footer.setContentsMargins(8, 2, 8, 2)
+        self._footer.setStyleSheet("color: gray; font-size: 11px;")
+        layout.addWidget(self._footer)
+
+    def _setup_model(self) -> None:
+        self._model = QFileSystemModel()
+        self._model.setRootPath("")
+        self._model.setFilter(QDir.Filter.AllDirs | QDir.Filter.Files | QDir.Filter.NoDotAndDotDot)
+        self._tree.setModel(self._model)
+
+        # Show only Name, Size, Date Modified
+        self._tree.setColumnHidden(2, True)  # Hide Type column
+
+        # Sort dirs before files, then alphabetical
+        self._tree.sortByColumn(0, Qt.SortOrder.AscendingOrder)
+
+        # Connect directory loaded signal for footer updates
+        self._model.directoryLoaded.connect(self._update_footer)
+
+    def navigate_to(self, path: str, record_history: bool = True) -> None:
+        """Navigate to a directory path."""
+        p = Path(path)
+        if not p.is_dir():
+            return
+
+        if record_history and self._current_path != path:
+            self._history_back.append(self._current_path)
+            if len(self._history_back) > NAV_HISTORY_MAX:
+                self._history_back = self._history_back[-NAV_HISTORY_MAX:]
+            self._history_forward.clear()
+
+        self._current_path = str(p)
+        index = self._model.index(self._current_path)
+        self._tree.setRootIndex(index)
+        self._breadcrumb.set_path(self._current_path)
+        self._update_nav_buttons()
+        self._update_footer(self._current_path)
+        self.directory_changed.emit(self._current_path)
+        logger.debug("Navigated to %s", self._current_path)
+
+    def go_back(self) -> None:
+        if not self._history_back:
+            return
+        self._history_forward.append(self._current_path)
+        path = self._history_back.pop()
+        self.navigate_to(path, record_history=False)
+
+    def go_forward(self) -> None:
+        if not self._history_forward:
+            return
+        self._history_back.append(self._current_path)
+        path = self._history_forward.pop()
+        self.navigate_to(path, record_history=False)
+
+    def go_up(self) -> None:
+        parent = str(Path(self._current_path).parent)
+        if parent != self._current_path:
+            self.navigate_to(parent)
+
+    def set_show_hidden(self, show: bool) -> None:
+        self._show_hidden = show
+        filters = QDir.Filter.AllDirs | QDir.Filter.Files | QDir.Filter.NoDotAndDotDot
+        if show:
+            filters |= QDir.Filter.Hidden
+        self._model.setFilter(filters)
+
+    def current_path(self) -> str:
+        return self._current_path
+
+    def selected_paths(self) -> list[str]:
+        """Return full paths of selected items."""
+        paths = []
+        for idx in self._tree.selectionModel().selectedRows():
+            paths.append(self._model.filePath(idx))
+        return paths
+
+    def _on_double_click(self, index: QModelIndex) -> None:
+        path = self._model.filePath(index)
+        if self._model.isDir(index):
+            self.navigate_to(path)
+        else:
+            QDesktopServices.openUrl(QUrl.fromLocalFile(path))
+
+    def _on_breadcrumb_clicked(self, path: str) -> None:
+        self.navigate_to(path)
+
+    def _on_breadcrumb_edited(self, path: str) -> None:
+        if Path(path).is_dir():
+            self.navigate_to(path)
+
+    def _update_nav_buttons(self) -> None:
+        self._back_btn.setEnabled(len(self._history_back) > 0)
+        self._forward_btn.setEnabled(len(self._history_forward) > 0)
+
+    def _update_footer(self, path: str = "") -> None:
+        index = self._model.index(self._current_path)
+        count = self._model.rowCount(index)
+        total_size = 0
+        for i in range(count):
+            child = self._model.index(i, 0, index)
+            if not self._model.isDir(child):
+                total_size += self._model.size(child)
+
+        size_str = _format_size(total_size)
+        self._footer.setText(f"{count} items, {size_str}")
+
+    def _on_context_menu(self, pos) -> None:
+        from PyQt6.QtWidgets import QMenu
+
+        selected = self.selected_paths()
+        if not selected:
+            return
+
+        menu = QMenu(self)
+        upload_action = menu.addAction("Upload to S3")
+        upload_action.triggered.connect(lambda: self.upload_requested.emit(selected))
+        menu.exec(self._tree.viewport().mapToGlobal(pos))
+
+
+def _format_size(size_bytes: int) -> str:
+    """Format bytes into human-readable string."""
+    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"