s3ui 1.0.0__py3-none-any.whl

s3ui/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

s3ui/app.py

@@ -0,0 +1,56 @@
+import logging
+import sys
+
+from s3ui.constants import APP_DIR, APP_NAME
+
+
+def main() -> None:
+    # Ensure app directory exists before anything else
+    APP_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Set up logging before any other imports that might log
+    from s3ui.logging_setup import setup_logging
+
+    setup_logging()
+    logger = logging.getLogger("s3ui.app")
+    logger.info("Starting %s", APP_NAME)
+
+    from PyQt6.QtCore import QLockFile
+    from PyQt6.QtGui import QIcon
+    from PyQt6.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    app.setApplicationName(APP_NAME)
+
+    # Set application icon (window, dock, tray)
+    from importlib.resources import files
+
+    icon_path = str(files("s3ui.resources").joinpath("s3ui.png"))
+    app.setWindowIcon(QIcon(icon_path))
+
+    # Single-instance check
+    lock_file = QLockFile(str(APP_DIR / "s3ui.lock"))
+    if not lock_file.tryLock(100):
+        logger.warning("Another instance is already running, exiting")
+        sys.exit(0)
+
+    # Initialize database
+    from s3ui.db.database import Database
+
+    db = Database()
+
+    from s3ui.main_window import MainWindow
+
+    window = MainWindow(db=db)
+    window.show()
+    logger.info("Window shown, entering event loop")
+
+    exit_code = app.exec()
+    db.close()
+    lock_file.unlock()
+    logger.info("Exiting with code %d", exit_code)
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

s3ui/constants.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+APP_NAME = "S3UI"
+APP_DIR = Path.home() / ".s3ui"
+DB_PATH = APP_DIR / "s3ui.db"
+LOG_DIR = APP_DIR / "logs"
+LOG_FILE = LOG_DIR / "s3ui.log"
+KEYRING_SERVICE = "s3ui"
+
+# Transfer defaults
+DEFAULT_PART_SIZE = 8 * 1024 * 1024  # 8 MB
+LARGE_PART_SIZE = 64 * 1024 * 1024  # 64 MB
+HUGE_PART_SIZE = 512 * 1024 * 1024  # 512 MB
+MULTIPART_THRESHOLD = 8 * 1024 * 1024  # 8 MB
+MAX_CONCURRENT_TRANSFERS = 4
+MAX_RETRY_ATTEMPTS = 3
+
+# Cache defaults
+LISTING_CACHE_MAX_ENTRIES = 30
+LISTING_CACHE_STALE_SECONDS = 30.0
+
+# UI defaults
+MIN_WINDOW_WIDTH = 900
+MIN_WINDOW_HEIGHT = 600
+NAV_HISTORY_MAX = 50
+TRANSFER_COALESCE_MS = 100
+
+# Temp directory for quick-open downloads
+TEMP_DIR = APP_DIR / "temp"
+
+# Notification threshold
+NOTIFY_SIZE_THRESHOLD = 100 * 1024 * 1024  # 100 MB
+
+# Quick-open size threshold (files larger than this go through the transfer queue)
+QUICK_OPEN_THRESHOLD = 10 * 1024 * 1024  # 10 MB
+
+# Logging
+MAX_LOG_SIZE = 5 * 1024 * 1024  # 5 MB per file
+LOG_BACKUP_COUNT = 3

s3ui/core/cost.py

@@ -0,0 +1,218 @@
+"""Cost tracking and estimation for S3 operations."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import date, timedelta
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from s3ui.db.database import Database
+
+logger = logging.getLogger("s3ui.cost")
+
+REQUEST_TYPE_COLUMN = {
+    "put": "put_requests",
+    "get": "get_requests",
+    "list": "list_requests",
+    "delete": "delete_requests",
+    "copy": "copy_requests",
+    "head": "head_requests",
+}
+
+
+@dataclass
+class DailyCost:
+    date: str
+    storage: float
+    requests: float
+    transfer: float
+
+    @property
+    def total(self) -> float:
+        return self.storage + self.requests + self.transfer
+
+
+class CostTracker:
+    """Tracks S3 API usage and calculates cost estimates."""
+
+    def __init__(self, db: Database, bucket_id: int) -> None:
+        self._db = db
+        self._bucket_id = bucket_id
+
+    def record_request(self, request_type: str, count: int = 1) -> None:
+        """Record API request(s) for cost tracking."""
+        column = REQUEST_TYPE_COLUMN.get(request_type)
+        if not column:
+            logger.warning("Unknown request type: %s", request_type)
+            return
+
+        today = date.today().isoformat()
+        self._db.execute(
+            f"INSERT INTO daily_usage (bucket_id, usage_date, {column}) "
+            f"VALUES (?, ?, ?) "
+            f"ON CONFLICT(bucket_id, usage_date) DO UPDATE SET {column} = {column} + ?",
+            (self._bucket_id, today, count, count),
+        )
+
+    def record_upload_bytes(self, size: int) -> None:
+        """Record bytes uploaded."""
+        today = date.today().isoformat()
+        self._db.execute(
+            "INSERT INTO daily_usage (bucket_id, usage_date, bytes_uploaded) "
+            "VALUES (?, ?, ?) "
+            "ON CONFLICT(bucket_id, usage_date) DO UPDATE SET bytes_uploaded = bytes_uploaded + ?",
+            (self._bucket_id, today, size, size),
+        )
+
+    def record_download_bytes(self, size: int) -> None:
+        """Record bytes downloaded."""
+        today = date.today().isoformat()
+        self._db.execute(
+            "INSERT INTO daily_usage (bucket_id, usage_date, bytes_downloaded) "
+            "VALUES (?, ?, ?) "
+            "ON CONFLICT(bucket_id, usage_date) DO UPDATE "
+            "SET bytes_downloaded = bytes_downloaded + ?",
+            (self._bucket_id, today, size, size),
+        )
+
+    def get_rate(self, name: str) -> float:
+        """Get a cost rate by name."""
+        row = self._db.fetchone("SELECT rate FROM cost_rates WHERE name = ?", (name,))
+        return row["rate"] if row else 0.0
+
+    def set_rate(self, name: str, rate: float) -> None:
+        """Update a cost rate."""
+        self._db.execute(
+            "UPDATE cost_rates SET rate = ?, updated_at = datetime('now') WHERE name = ?",
+            (rate, name),
+        )
+
+    def get_daily_cost(self, target_date: str) -> DailyCost:
+        """Calculate estimated cost for a single day."""
+        storage_cost = self._calc_storage_cost(target_date)
+        request_cost = self._calc_request_cost(target_date)
+        transfer_cost = self._calc_transfer_cost(target_date)
+        return DailyCost(
+            date=target_date,
+            storage=storage_cost,
+            requests=request_cost,
+            transfer=transfer_cost,
+        )
+
+    def get_daily_costs(self, start_date: str, end_date: str) -> list[DailyCost]:
+        """Get daily costs for a date range (for charting)."""
+        costs = []
+        current = date.fromisoformat(start_date)
+        end = date.fromisoformat(end_date)
+        while current <= end:
+            costs.append(self.get_daily_cost(current.isoformat()))
+            current += timedelta(days=1)
+        return costs
+
+    def get_monthly_estimate(self) -> float:
+        """Estimate the current month's total cost."""
+        today = date.today()
+        first_of_month = today.replace(day=1)
+
+        # Storage: use the most recent snapshot, prorate for the full month
+        snapshot = self._db.fetchone(
+            "SELECT total_bytes, standard_bytes, ia_bytes, glacier_bytes, "
+            "deep_archive_bytes, intelligent_tiering_bytes "
+            "FROM bucket_snapshots WHERE bucket_id = ? "
+            "ORDER BY snapshot_date DESC LIMIT 1",
+            (self._bucket_id,),
+        )
+        if snapshot:
+            import calendar
+
+            days_in_month = calendar.monthrange(today.year, today.month)[1]
+            storage_cost = self._storage_cost_from_snapshot(snapshot) * days_in_month
+        else:
+            storage_cost = 0.0
+
+        # Requests and transfer: sum month-to-date
+        request_cost = 0.0
+        transfer_cost = 0.0
+        rows = self._db.fetchall(
+            "SELECT * FROM daily_usage WHERE bucket_id = ? AND usage_date >= ?",
+            (self._bucket_id, first_of_month.isoformat()),
+        )
+        for row in rows:
+            request_cost += self._request_cost_from_row(row)
+            transfer_cost += self._transfer_cost_from_row(row)
+
+        return storage_cost + request_cost + transfer_cost
+
+    # --- Internal calculation methods ---
+
+    def _calc_storage_cost(self, target_date: str) -> float:
+        """Storage cost for one day based on the most recent snapshot."""
+        snapshot = self._db.fetchone(
+            "SELECT * FROM bucket_snapshots WHERE bucket_id = ? AND snapshot_date <= ? "
+            "ORDER BY snapshot_date DESC LIMIT 1",
+            (self._bucket_id, target_date),
+        )
+        if not snapshot:
+            return 0.0
+        return self._storage_cost_from_snapshot(snapshot)
+
+    def _storage_cost_from_snapshot(self, snapshot) -> float:
+        """Calculate daily storage cost from a snapshot row."""
+        gb = 1024**3
+        tiers = [
+            ("standard_bytes", "storage_standard_gb_month"),
+            ("ia_bytes", "storage_ia_gb_month"),
+            ("glacier_bytes", "storage_glacier_gb_month"),
+            ("deep_archive_bytes", "storage_deep_archive_gb_month"),
+            ("intelligent_tiering_bytes", "storage_intelligent_tiering_gb_month"),
+        ]
+        cost = 0.0
+        for col, rate_name in tiers:
+            cost += (snapshot[col] or 0) / gb * self.get_rate(rate_name) / 30
+        return cost
+
+    def _calc_request_cost(self, target_date: str) -> float:
+        row = self._db.fetchone(
+            "SELECT * FROM daily_usage WHERE bucket_id = ? AND usage_date = ?",
+            (self._bucket_id, target_date),
+        )
+        if not row:
+            return 0.0
+        return self._request_cost_from_row(row)
+
+    def _request_cost_from_row(self, row) -> float:
+        cost = 0.0
+        cost += (row["put_requests"] or 0) * self.get_rate("put_request")
+        cost += (row["get_requests"] or 0) * self.get_rate("get_request")
+        cost += (row["list_requests"] or 0) * self.get_rate("list_request")
+        cost += (row["delete_requests"] or 0) * self.get_rate("delete_request")
+        cost += (row["copy_requests"] or 0) * self.get_rate("copy_request")
+        cost += (row["head_requests"] or 0) * self.get_rate("head_request")
+        return cost
+
+    def _calc_transfer_cost(self, target_date: str) -> float:
+        row = self._db.fetchone(
+            "SELECT * FROM daily_usage WHERE bucket_id = ? AND usage_date = ?",
+            (self._bucket_id, target_date),
+        )
+        if not row:
+            return 0.0
+        return self._transfer_cost_from_row(row)
+
+    def _transfer_cost_from_row(self, row) -> float:
+        # Transfer IN is free
+        # Transfer OUT is tiered
+        gb = 1024**3
+        bytes_out = row["bytes_downloaded"] or 0
+        gb_out = bytes_out / gb
+
+        cost = 0.0
+        if gb_out <= 100:
+            cost = gb_out * self.get_rate("transfer_out_gb_first_100")
+        else:
+            cost = 100 * self.get_rate("transfer_out_gb_first_100")
+            cost += (gb_out - 100) * self.get_rate("transfer_out_gb_next_10k")
+
+        return cost

s3ui/core/credentials.py

@@ -0,0 +1,165 @@
+"""Credential storage via OS keyring, AWS config discovery, and profile management."""
+
+import json
+import logging
+from dataclasses import dataclass, field
+
+import keyring
+
+from s3ui.constants import KEYRING_SERVICE
+from s3ui.core.errors import translate_error
+
+logger = logging.getLogger("s3ui.credentials")
+
+PROFILES_INDEX_KEY = "profiles"
+
+
+@dataclass
+class Profile:
+    name: str
+    access_key_id: str = ""
+    secret_access_key: str = ""
+    region: str = ""
+    endpoint_url: str = ""
+    is_aws_profile: bool = False  # True = use boto3 Session(profile_name=name)
+
+
+@dataclass
+class TestResult:
+    success: bool
+    buckets: list[str] = field(default_factory=list)
+    error_message: str = ""
+    error_detail: str = ""
+
+
+def discover_aws_profiles() -> list[str]:
+    """Discover profile names from ~/.aws/config and ~/.aws/credentials.
+
+    Returns a list of available AWS CLI profile names (e.g., ["default", "work"]).
+    """
+    try:
+        import botocore.session
+
+        session = botocore.session.Session()
+        profiles = list(session.available_profiles)
+        logger.debug("Discovered %d AWS profiles: %s", len(profiles), profiles)
+        return sorted(profiles)
+    except Exception:
+        logger.debug("Could not discover AWS profiles", exc_info=True)
+        return []
+
+
+def get_aws_profile_region(profile_name: str) -> str:
+    """Read the region configured for an AWS CLI profile, or empty string."""
+    try:
+        import botocore.session
+
+        session = botocore.session.Session(profile=profile_name)
+        return session.get_config_variable("region") or ""
+    except Exception:
+        return ""
+
+
+class CredentialStore:
+    """Manages AWS credential profiles — both AWS CLI profiles and custom keyring profiles."""
+
+    def list_profiles(self) -> list[str]:
+        """Return names of all saved custom profiles (from keyring)."""
+        raw = keyring.get_password(KEYRING_SERVICE, PROFILES_INDEX_KEY)
+        if not raw:
+            return []
+        try:
+            return json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            return []
+
+    def get_profile(self, name: str) -> Profile | None:
+        """Load a custom profile by name from the keyring."""
+        raw = keyring.get_password(KEYRING_SERVICE, f"profile:{name}")
+        if not raw:
+            return None
+        try:
+            data = json.loads(raw)
+            return Profile(
+                name=name,
+                access_key_id=data.get("access_key_id", ""),
+                secret_access_key=data.get("secret_access_key", ""),
+                region=data.get("region", ""),
+                endpoint_url=data.get("endpoint_url", ""),
+                is_aws_profile=data.get("is_aws_profile", False),
+            )
+        except (json.JSONDecodeError, KeyError, TypeError):
+            logger.error("Corrupt profile data for '%s'", name)
+            return None
+
+    def save_profile(self, profile: Profile) -> None:
+        """Save a profile to the keyring and update the index."""
+        data = json.dumps(
+            {
+                "access_key_id": profile.access_key_id,
+                "secret_access_key": profile.secret_access_key,
+                "region": profile.region,
+                "endpoint_url": profile.endpoint_url,
+                "is_aws_profile": profile.is_aws_profile,
+            }
+        )
+        keyring.set_password(KEYRING_SERVICE, f"profile:{profile.name}", data)
+
+        # Update profile index
+        profiles = self.list_profiles()
+        if profile.name not in profiles:
+            profiles.append(profile.name)
+            keyring.set_password(KEYRING_SERVICE, PROFILES_INDEX_KEY, json.dumps(profiles))
+        logger.info("Saved profile '%s' (aws_profile=%s)", profile.name, profile.is_aws_profile)
+
+    def delete_profile(self, name: str) -> None:
+        """Remove a profile from the keyring and index."""
+        keyring.delete_password(KEYRING_SERVICE, f"profile:{name}")
+
+        profiles = self.list_profiles()
+        if name in profiles:
+            profiles.remove(name)
+            keyring.set_password(KEYRING_SERVICE, PROFILES_INDEX_KEY, json.dumps(profiles))
+        logger.info("Deleted profile '%s'", name)
+
+    def test_connection(self, profile: Profile) -> TestResult:
+        """Test AWS credentials by calling list_buckets.
+
+        Supports both AWS CLI profiles (is_aws_profile=True) and explicit keys.
+        """
+        try:
+            import boto3
+
+            endpoint = profile.endpoint_url or None
+            if profile.is_aws_profile:
+                session = boto3.Session(profile_name=profile.name)
+                client = session.client(
+                    "s3",
+                    region_name=profile.region or None,
+                    endpoint_url=endpoint,
+                )
+            else:
+                client = boto3.client(
+                    "s3",
+                    aws_access_key_id=profile.access_key_id,
+                    aws_secret_access_key=profile.secret_access_key,
+                    region_name=profile.region,
+                    endpoint_url=endpoint,
+                )
+            response = client.list_buckets()
+            bucket_names = [b["Name"] for b in response.get("Buckets", [])]
+            logger.info(
+                "Connection test succeeded for profile '%s': %d buckets",
+                profile.name,
+                len(bucket_names),
+            )
+            return TestResult(success=True, buckets=bucket_names)
+        except Exception as e:
+            user_msg, detail = translate_error(e)
+            logger.warning("Connection test failed for profile '%s': %s", profile.name, detail)
+            return TestResult(
+                success=False,
+                buckets=[],
+                error_message=user_msg,
+                error_detail=detail,
+            )