gsuite-sdk 0.1.0__py3-none-any.whl

gsuite_core/storage/__init__.py

@@ -0,0 +1,13 @@
+"""Token storage implementations."""
+
+from gsuite_core.storage.base import TokenStore
+from gsuite_core.storage.sqlite import SQLiteTokenStore
+
+__all__ = ["TokenStore", "SQLiteTokenStore"]
+
+try:
+    from gsuite_core.storage.secretmanager import SecretManagerTokenStore
+
+    __all__.append("SecretManagerTokenStore")
+except ImportError:
+    pass

gsuite_core/storage/base.py

@@ -0,0 +1,65 @@
+"""Token store interface."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class TokenStore(ABC):
+    """
+    Abstract interface for OAuth token storage.
+
+    Implementations can store tokens in:
+    - SQLite (local development)
+    - Secret Manager (Cloud Run)
+    - Redis, files, etc.
+    """
+
+    @abstractmethod
+    def get_token(self, user_id: str = "default") -> dict[str, Any] | None:
+        """
+        Retrieve stored token data.
+
+        Args:
+            user_id: User identifier for multi-user setups
+
+        Returns:
+            Token data dict or None if not found
+        """
+        pass
+
+    @abstractmethod
+    def save_token(self, token_data: dict[str, Any], user_id: str = "default") -> None:
+        """
+        Store token data.
+
+        Args:
+            token_data: Token data to store
+            user_id: User identifier
+        """
+        pass
+
+    @abstractmethod
+    def delete_token(self, user_id: str = "default") -> bool:
+        """
+        Delete stored token.
+
+        Args:
+            user_id: User identifier
+
+        Returns:
+            True if token was deleted
+        """
+        pass
+
+    @abstractmethod
+    def exists(self, user_id: str = "default") -> bool:
+        """
+        Check if token exists.
+
+        Args:
+            user_id: User identifier
+
+        Returns:
+            True if token exists
+        """
+        pass

gsuite_core/storage/secretmanager.py

@@ -0,0 +1,141 @@
+"""Secret Manager token storage implementation."""
+
+import json
+import logging
+from typing import Any
+
+from google.api_core import exceptions
+from google.cloud import secretmanager
+
+from gsuite_core.storage.base import TokenStore
+
+logger = logging.getLogger(__name__)
+
+
+class SecretManagerTokenStore(TokenStore):
+    """
+    Google Secret Manager token storage for Cloud Run.
+
+    Stores OAuth tokens as secrets in Google Cloud Secret Manager.
+    Required for stateless deployments.
+    """
+
+    def __init__(
+        self,
+        project_id: str,
+        secret_name: str = "gsuite-token",
+        auto_create: bool = False,
+    ):
+        """
+        Initialize Secret Manager token store.
+
+        Args:
+            project_id: GCP project ID
+            secret_name: Name for the secret
+            auto_create: Auto-create secret if it doesn't exist
+        """
+        self.project_id = project_id
+        self.secret_name = secret_name
+        self.auto_create = auto_create
+        self.client = secretmanager.SecretManagerServiceClient()
+
+        self._secret_path = f"projects/{project_id}/secrets/{secret_name}"
+
+    def _get_latest_version_path(self) -> str:
+        """Get path to latest secret version."""
+        return f"{self._secret_path}/versions/latest"
+
+    def _ensure_secret_exists(self) -> None:
+        """Create secret if it doesn't exist and auto_create is enabled."""
+        if not self.auto_create:
+            return
+
+        try:
+            self.client.get_secret(request={"name": self._secret_path})
+        except exceptions.NotFound:
+            logger.info(f"Creating secret: {self.secret_name}")
+            self.client.create_secret(
+                request={
+                    "parent": f"projects/{self.project_id}",
+                    "secret_id": self.secret_name,
+                    "secret": {"replication": {"automatic": {}}},
+                }
+            )
+
+    def get_token(self, user_id: str = "default") -> dict[str, Any] | None:
+        """Retrieve stored token data from Secret Manager."""
+        try:
+            response = self.client.access_secret_version(
+                request={"name": self._get_latest_version_path()}
+            )
+            data = json.loads(response.payload.data.decode("utf-8"))
+
+            if user_id in data:
+                return data[user_id]
+            elif user_id == "default" and "token" in data:
+                return data
+
+            return None
+
+        except exceptions.NotFound:
+            return None
+        except Exception as e:
+            logger.error(f"Error accessing secret: {e}")
+            return None
+
+    def save_token(self, token_data: dict[str, Any], user_id: str = "default") -> None:
+        """Store token data in Secret Manager."""
+        self._ensure_secret_exists()
+
+        existing = {}
+        try:
+            response = self.client.access_secret_version(
+                request={"name": self._get_latest_version_path()}
+            )
+            existing = json.loads(response.payload.data.decode("utf-8"))
+        except exceptions.NotFound:
+            pass
+
+        if user_id == "default" and not existing:
+            payload = token_data
+        else:
+            existing[user_id] = token_data
+            payload = existing
+
+        self.client.add_secret_version(
+            request={
+                "parent": self._secret_path,
+                "payload": {"data": json.dumps(payload).encode("utf-8")},
+            }
+        )
+        logger.info(f"Token saved to Secret Manager: {self.secret_name}")
+
+    def delete_token(self, user_id: str = "default") -> bool:
+        """Delete token from Secret Manager."""
+        try:
+            response = self.client.access_secret_version(
+                request={"name": self._get_latest_version_path()}
+            )
+            data = json.loads(response.payload.data.decode("utf-8"))
+
+            if user_id in data:
+                del data[user_id]
+                self.client.add_secret_version(
+                    request={
+                        "parent": self._secret_path,
+                        "payload": {"data": json.dumps(data).encode("utf-8")},
+                    }
+                )
+                return True
+            elif user_id == "default":
+                self.client.delete_secret(request={"name": self._secret_path})
+                return True
+
+            return False
+
+        except exceptions.NotFound:
+            return False
+
+    def exists(self, user_id: str = "default") -> bool:
+        """Check if token exists in Secret Manager."""
+        return self.get_token(user_id) is not None

gsuite_core/storage/sqlite.py

@@ -0,0 +1,79 @@
+"""SQLite token storage implementation."""
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from gsuite_core.storage.base import TokenStore
+
+
+class SQLiteTokenStore(TokenStore):
+    """
+    SQLite-based token storage for local development.
+
+    Stores OAuth tokens in a local SQLite database file.
+    """
+
+    def __init__(self, db_path: str = "tokens.db"):
+        """
+        Initialize SQLite token store.
+
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = Path(db_path)
+        self._init_db()
+
+    def _init_db(self) -> None:
+        """Create tokens table if it doesn't exist."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS tokens (
+                    user_id TEXT PRIMARY KEY,
+                    token_data TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            conn.commit()
+
+    def get_token(self, user_id: str = "default") -> dict[str, Any] | None:
+        """Retrieve stored token data."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("SELECT token_data FROM tokens WHERE user_id = ?", (user_id,))
+            row = cursor.fetchone()
+
+            if row:
+                return json.loads(row[0])
+            return None
+
+    def save_token(self, token_data: dict[str, Any], user_id: str = "default") -> None:
+        """Store token data."""
+        token_json = json.dumps(token_data)
+
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT INTO tokens (user_id, token_data, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(user_id) DO UPDATE SET
+                    token_data = excluded.token_data,
+                    updated_at = CURRENT_TIMESTAMP
+            """,
+                (user_id, token_json),
+            )
+            conn.commit()
+
+    def delete_token(self, user_id: str = "default") -> bool:
+        """Delete stored token."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("DELETE FROM tokens WHERE user_id = ?", (user_id,))
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def exists(self, user_id: str = "default") -> bool:
+        """Check if token exists."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("SELECT 1 FROM tokens WHERE user_id = ?", (user_id,))
+            return cursor.fetchone() is not None

gsuite_drive/__init__.py

@@ -0,0 +1,12 @@
+"""Google Suite Drive - Simple Drive API client."""
+
+__version__ = "0.1.0"
+
+from gsuite_drive.client import Drive
+from gsuite_drive.file import File, Folder
+
+__all__ = [
+    "Drive",
+    "File",
+    "Folder",
+]