s3ui 1.0.0__py3-none-any.whl

s3ui/db/database.py

@@ -0,0 +1,143 @@
+import logging
+import sqlite3
+import threading
+from pathlib import Path
+
+from s3ui.constants import DB_PATH
+
+logger = logging.getLogger("s3ui.db")
+
+MIGRATIONS_DIR = Path(__file__).parent / "migrations"
+
+
+class Database:
+    """Thread-safe SQLite database with WAL mode and migration support."""
+
+    def __init__(self, db_path: Path | None = None) -> None:
+        self._db_path = str(db_path or DB_PATH)
+        self._local = threading.local()
+        self._write_lock = threading.Lock()
+
+        # Ensure directory exists
+        Path(self._db_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Initialize on the creating thread and run migrations
+        conn = self._get_conn()
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA foreign_keys=ON")
+        self._run_migrations()
+        logger.info("Database initialized at %s", self._db_path)
+
+    def _get_conn(self) -> sqlite3.Connection:
+        """Get a thread-local connection."""
+        if not hasattr(self._local, "conn") or self._local.conn is None:
+            self._local.conn = sqlite3.connect(self._db_path)
+            self._local.conn.row_factory = sqlite3.Row
+            self._local.conn.execute("PRAGMA foreign_keys=ON")
+        return self._local.conn
+
+    def execute(self, sql: str, params: tuple = ()) -> sqlite3.Cursor:
+        """Execute a SQL statement with write serialization."""
+        conn = self._get_conn()
+        if sql.lstrip().upper().startswith("SELECT"):
+            return conn.execute(sql, params)
+        with self._write_lock:
+            cursor = conn.execute(sql, params)
+            conn.commit()
+            return cursor
+
+    def executemany(self, sql: str, params_list: list[tuple]) -> sqlite3.Cursor:
+        """Execute a SQL statement with multiple parameter sets."""
+        conn = self._get_conn()
+        with self._write_lock:
+            cursor = conn.executemany(sql, params_list)
+            conn.commit()
+            return cursor
+
+    def executescript(self, sql: str) -> None:
+        """Execute a SQL script (multiple statements)."""
+        conn = self._get_conn()
+        with self._write_lock:
+            conn.executescript(sql)
+
+    def fetchone(self, sql: str, params: tuple = ()) -> sqlite3.Row | None:
+        """Execute a SELECT and return one row."""
+        return self._get_conn().execute(sql, params).fetchone()
+
+    def fetchall(self, sql: str, params: tuple = ()) -> list[sqlite3.Row]:
+        """Execute a SELECT and return all rows."""
+        return self._get_conn().execute(sql, params).fetchall()
+
+    def _run_migrations(self) -> None:
+        """Apply pending migrations in order."""
+        conn = self._get_conn()
+
+        # Ensure schema_version table exists (bootstrap)
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS schema_version "
+            "(version INTEGER PRIMARY KEY, applied_at TEXT NOT NULL DEFAULT (datetime('now')))"
+        )
+        conn.commit()
+
+        current = self._get_schema_version()
+
+        migration_files = sorted(MIGRATIONS_DIR.glob("*.sql"))
+        for migration_file in migration_files:
+            version = int(migration_file.stem.split("_")[0])
+            if version > current:
+                logger.info("Applying migration %03d: %s", version, migration_file.name)
+                sql = migration_file.read_text()
+                with self._write_lock:
+                    conn.executescript(sql)
+                    conn.execute(
+                        "INSERT OR REPLACE INTO schema_version (version) VALUES (?)",
+                        (version,),
+                    )
+                    conn.commit()
+
+    def _get_schema_version(self) -> int:
+        """Get the current schema version."""
+        row = self._get_conn().execute("SELECT MAX(version) as v FROM schema_version").fetchone()
+        return row["v"] if row and row["v"] is not None else 0
+
+    def close(self) -> None:
+        """Close the thread-local connection."""
+        if hasattr(self._local, "conn") and self._local.conn is not None:
+            self._local.conn.close()
+            self._local.conn = None
+
+
+# Preferences helpers
+
+
+def get_pref(db: Database, key: str, default: str | None = None) -> str | None:
+    """Get a preference value by key."""
+    row = db.fetchone("SELECT value FROM preferences WHERE key = ?", (key,))
+    return row["value"] if row else default
+
+
+def set_pref(db: Database, key: str, value: str) -> None:
+    """Set a preference value."""
+    db.execute(
+        "INSERT OR REPLACE INTO preferences (key, value) VALUES (?, ?)",
+        (key, value),
+    )
+
+
+def get_bool_pref(db: Database, key: str, default: bool = False) -> bool:
+    """Get a boolean preference."""
+    val = get_pref(db, key)
+    if val is None:
+        return default
+    return val.lower() in ("true", "1", "yes")
+
+
+def get_int_pref(db: Database, key: str, default: int = 0) -> int:
+    """Get an integer preference."""
+    val = get_pref(db, key)
+    if val is None:
+        return default
+    try:
+        return int(val)
+    except ValueError:
+        return default

s3ui/db/migrations/001_initial.sql

@@ -0,0 +1,114 @@
+-- Tracks known buckets and their associated credential profile
+CREATE TABLE IF NOT EXISTS buckets (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    name        TEXT NOT NULL,
+    region      TEXT,
+    profile     TEXT NOT NULL,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(name, profile)
+);
+
+-- Daily storage snapshots from bucket scans
+CREATE TABLE IF NOT EXISTS bucket_snapshots (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    bucket_id       INTEGER NOT NULL REFERENCES buckets(id) ON DELETE CASCADE,
+    snapshot_date   TEXT NOT NULL,
+    total_objects   INTEGER,
+    total_bytes     INTEGER,
+    standard_bytes  INTEGER DEFAULT 0,
+    ia_bytes        INTEGER DEFAULT 0,
+    glacier_bytes   INTEGER DEFAULT 0,
+    deep_archive_bytes  INTEGER DEFAULT 0,
+    intelligent_tiering_bytes INTEGER DEFAULT 0,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(bucket_id, snapshot_date)
+);
+CREATE INDEX IF NOT EXISTS idx_snapshots_bucket_date ON bucket_snapshots(bucket_id, snapshot_date);
+
+-- Daily API usage and transfer volume
+CREATE TABLE IF NOT EXISTS daily_usage (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    bucket_id       INTEGER NOT NULL REFERENCES buckets(id) ON DELETE CASCADE,
+    usage_date      TEXT NOT NULL,
+    bytes_uploaded  INTEGER DEFAULT 0,
+    bytes_downloaded INTEGER DEFAULT 0,
+    put_requests    INTEGER DEFAULT 0,
+    get_requests    INTEGER DEFAULT 0,
+    list_requests   INTEGER DEFAULT 0,
+    delete_requests INTEGER DEFAULT 0,
+    copy_requests   INTEGER DEFAULT 0,
+    head_requests   INTEGER DEFAULT 0,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(bucket_id, usage_date)
+);
+CREATE INDEX IF NOT EXISTS idx_usage_bucket_date ON daily_usage(bucket_id, usage_date);
+
+-- Configurable cost rates
+CREATE TABLE IF NOT EXISTS cost_rates (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    name        TEXT NOT NULL UNIQUE,
+    rate        REAL NOT NULL,
+    unit        TEXT NOT NULL,
+    updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Seed default cost rates (US East pricing as of 2025)
+INSERT OR IGNORE INTO cost_rates (name, rate, unit) VALUES
+    ('storage_standard_gb_month', 0.023, '$/GB/month'),
+    ('storage_ia_gb_month', 0.0125, '$/GB/month'),
+    ('storage_glacier_gb_month', 0.004, '$/GB/month'),
+    ('storage_deep_archive_gb_month', 0.00099, '$/GB/month'),
+    ('storage_intelligent_tiering_gb_month', 0.023, '$/GB/month'),
+    ('put_request', 0.000005, '$/request'),
+    ('get_request', 0.0000004, '$/request'),
+    ('list_request', 0.000005, '$/request'),
+    ('delete_request', 0.0, '$/request'),
+    ('copy_request', 0.000005, '$/request'),
+    ('head_request', 0.0000004, '$/request'),
+    ('transfer_out_gb_first_100', 0.09, '$/GB'),
+    ('transfer_out_gb_next_10k', 0.085, '$/GB'),
+    ('transfer_in_gb', 0.0, '$/GB');
+
+-- Transfer queue with resume support
+CREATE TABLE IF NOT EXISTS transfers (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    bucket_id       INTEGER NOT NULL REFERENCES buckets(id) ON DELETE CASCADE,
+    object_key      TEXT NOT NULL,
+    direction       TEXT NOT NULL CHECK(direction IN ('upload', 'download')),
+    total_bytes     INTEGER,
+    transferred     INTEGER DEFAULT 0,
+    status          TEXT NOT NULL DEFAULT 'queued'
+                    CHECK(status IN ('queued','in_progress','paused','completed','failed','cancelled')),
+    upload_id       TEXT,
+    local_path      TEXT NOT NULL,
+    error_message   TEXT,
+    retry_count     INTEGER DEFAULT 0,
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_transfers_status ON transfers(status);
+
+-- Individual parts for multipart uploads (resume support)
+CREATE TABLE IF NOT EXISTS transfer_parts (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    transfer_id     INTEGER NOT NULL REFERENCES transfers(id) ON DELETE CASCADE,
+    part_number     INTEGER NOT NULL,
+    offset          INTEGER NOT NULL,
+    size            INTEGER NOT NULL,
+    etag            TEXT,
+    status          TEXT NOT NULL DEFAULT 'pending'
+                    CHECK(status IN ('pending','in_progress','completed','failed')),
+    UNIQUE(transfer_id, part_number)
+);
+
+-- Key-value store for app preferences and UI state
+CREATE TABLE IF NOT EXISTS preferences (
+    key         TEXT PRIMARY KEY,
+    value       TEXT NOT NULL
+);
+
+-- Schema version tracking for migrations
+CREATE TABLE IF NOT EXISTS schema_version (
+    version     INTEGER PRIMARY KEY,
+    applied_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);

s3ui/logging_setup.py

@@ -0,0 +1,18 @@
+import logging
+from logging.handlers import RotatingFileHandler
+
+from s3ui.constants import LOG_BACKUP_COUNT, LOG_DIR, LOG_FILE, MAX_LOG_SIZE
+
+
+def setup_logging() -> None:
+    """Configure rotating file logger for s3ui."""
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    handler = RotatingFileHandler(
+        LOG_FILE,
+        maxBytes=MAX_LOG_SIZE,
+        backupCount=LOG_BACKUP_COUNT,
+    )
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s [%(name)s] %(message)s"))
+    root = logging.getLogger("s3ui")
+    root.setLevel(logging.DEBUG)
+    root.addHandler(handler)