@weirdfingers/baseboards 0.9.5 → 0.9.7

package/templates/api/src/boards/storage/factory.py

@@ -1,288 +0,0 @@
-"""Factory for creating storage providers and managers."""
-
-from pathlib import Path
-from typing import Any
-
-from ..logging import get_logger
-from .base import StorageManager, StorageProvider
-from .config import StorageConfig, load_storage_config
-from .implementations.local import LocalStorageProvider
-
-logger = get_logger(__name__)
-
-# Singleton storage configuration
-# Loaded once at module import time to avoid re-parsing YAML on every request
-_storage_config: StorageConfig | None = None
-
-
-def get_storage_config() -> StorageConfig:
-    """Get the singleton storage configuration.
-
-    Loads the configuration from settings.storage_config_path on first access.
-    Subsequent calls return the cached configuration.
-
-    Returns:
-        StorageConfig instance
-    """
-    global _storage_config
-
-    if _storage_config is None:
-        from ..config import settings
-
-        config_path = Path(settings.storage_config_path) if settings.storage_config_path else None
-        _storage_config = load_storage_config(config_path)
-        logger.info(
-            f"Loaded storage configuration: default_provider={_storage_config.default_provider}, "
-            f"providers={list(_storage_config.providers.keys())}"
-        )
-
-    return _storage_config
-
-
-# Optional imports for cloud providers
-try:
-    from .implementations.supabase import SupabaseStorageProvider
-
-    _supabase_available = True
-except ImportError:
-    SupabaseStorageProvider = None
-    _supabase_available = False
-    logger.warning(
-        "Supabase storage not available. "
-        "Install with: pip install weirdfingers-boards[storage-supabase]"
-    )
-
-try:
-    from .implementations.s3 import S3StorageProvider
-
-    _s3_available = True
-except ImportError:
-    S3StorageProvider = None
-    _s3_available = False
-    logger.warning(
-        "S3 storage not available. Install with: pip install weirdfingers-boards[storage-s3]"
-    )
-
-try:
-    from .implementations.gcs import GCSStorageProvider
-
-    _gcs_available = True
-except ImportError:
-    GCSStorageProvider = None
-    _gcs_available = False
-    logger.warning(
-        "GCS storage not available. Install with: pip install weirdfingers-boards[storage-gcs]"
-    )
-
-
-def create_storage_provider(provider_type: str, config: dict[str, Any]) -> StorageProvider:
-    """Create a storage provider instance from configuration.
-
-    Args:
-        provider_type: Type of provider ('local', 'supabase', 's3')
-        config: Provider configuration dictionary
-
-    Returns:
-        StorageProvider instance
-
-    Raises:
-        ValueError: If provider type is unknown or configuration is invalid
-        ImportError: If required dependencies are not available
-    """
-
-    if provider_type == "local":
-        return _create_local_provider(config)
-    elif provider_type == "supabase":
-        if not _supabase_available:
-            raise ImportError(
-                "Supabase storage requires additional dependencies. "
-                "Install with: pip install weirdfingers-boards[storage-supabase]"
-            )
-        return _create_supabase_provider(config)
-    elif provider_type == "s3":
-        if not _s3_available:
-            raise ImportError(
-                "S3 storage requires additional dependencies. "
-                "Install with: pip install weirdfingers-boards[storage-s3]"
-            )
-        return _create_s3_provider(config)
-    elif provider_type == "gcs":
-        if not _gcs_available:
-            raise ImportError(
-                "GCS storage requires additional dependencies. "
-                "Install with: pip install weirdfingers-boards[storage-gcs]"
-            )
-        return _create_gcs_provider(config)
-    else:
-        raise ValueError(f"Unknown storage provider type: {provider_type}")
-
-
-def _create_local_provider(config: dict[str, Any]) -> LocalStorageProvider:
-    """Create local storage provider."""
-    base_path = config.get("base_path", "/tmp/boards/storage")
-    public_url_base = config.get("public_url_base")
-
-    return LocalStorageProvider(base_path=Path(base_path), public_url_base=public_url_base)
-
-
-def _create_supabase_provider(config: dict[str, Any]) -> StorageProvider:
-    """Create Supabase storage provider."""
-    if SupabaseStorageProvider is None:
-        raise ImportError("Supabase storage not available")
-
-    url = config.get("url")
-    key = config.get("key")
-    bucket = config.get("bucket", "boards-artifacts")
-
-    if not url:
-        raise ValueError("Supabase storage requires 'url' in configuration")
-    if not key:
-        raise ValueError("Supabase storage requires 'key' in configuration")
-
-    return SupabaseStorageProvider(url=url, key=key, bucket=bucket)
-
-
-def _create_s3_provider(config: dict[str, Any]) -> StorageProvider:
-    """Create S3 storage provider."""
-    if S3StorageProvider is None:
-        raise ImportError("S3 storage not available")
-
-    bucket = config.get("bucket")
-    if not bucket:
-        raise ValueError("S3 storage requires 'bucket' in configuration")
-
-    region = config.get("region", "us-east-1")
-    aws_access_key_id = config.get("aws_access_key_id")
-    aws_secret_access_key = config.get("aws_secret_access_key")
-    aws_session_token = config.get("aws_session_token")
-    endpoint_url = config.get("endpoint_url")
-    cloudfront_domain = config.get("cloudfront_domain")
-    upload_config = config.get("upload_config", {})
-
-    return S3StorageProvider(
-        bucket=bucket,
-        region=region,
-        aws_access_key_id=aws_access_key_id,
-        aws_secret_access_key=aws_secret_access_key,
-        aws_session_token=aws_session_token,
-        endpoint_url=endpoint_url,
-        cloudfront_domain=cloudfront_domain,
-        upload_config=upload_config,
-    )
-
-
-def _create_gcs_provider(config: dict[str, Any]) -> StorageProvider:
-    """Create GCS storage provider."""
-    if GCSStorageProvider is None:
-        raise ImportError("GCS storage not available")
-
-    bucket = config.get("bucket")
-    if not bucket:
-        raise ValueError("GCS storage requires 'bucket' in configuration")
-
-    project_id = config.get("project_id")
-    credentials_path = config.get("credentials_path")
-    credentials_json = config.get("credentials_json")
-    cdn_domain = config.get("cdn_domain")
-    upload_config = config.get("upload_config", {})
-
-    return GCSStorageProvider(
-        bucket=bucket,
-        project_id=project_id,
-        credentials_path=credentials_path,
-        credentials_json=credentials_json,
-        cdn_domain=cdn_domain,
-        upload_config=upload_config,
-    )
-
-
-def _build_storage_manager_from_config(storage_config: StorageConfig) -> StorageManager:
-    """Build a storage manager from a StorageConfig, registering all providers.
-
-    This is an internal helper that can be used for testing.
-
-    Args:
-        storage_config: Storage configuration
-
-    Returns:
-        StorageManager instance with registered providers
-
-    Raises:
-        RuntimeError: If no storage providers were successfully registered
-    """
-    # Create storage manager
-    manager = StorageManager(storage_config)
-
-    # Register providers
-    for provider_name, provider_config in storage_config.providers.items():
-        try:
-            provider_type = provider_config.get("type", provider_name)
-            provider_instance = create_storage_provider(
-                provider_type, provider_config.get("config", {})
-            )
-            manager.register_provider(provider_name, provider_instance)
-
-            logger.info(f"Registered storage provider: {provider_name} ({provider_type})")
-
-        except Exception as e:
-            logger.error(f"Failed to register provider {provider_name}: {e}")
-            # Continue with other providers rather than failing completely
-            continue
-
-    # Validate default provider is available
-    if storage_config.default_provider not in manager.providers:
-        available = list(manager.providers.keys())
-        if not available:
-            raise RuntimeError("No storage providers were successfully registered")
-
-        logger.warning(
-            f"Default provider '{storage_config.default_provider}' not available. "
-            f"Using '{available[0]}' instead."
-        )
-        manager.default_provider = available[0]
-
-    return manager
-
-
-def create_storage_manager() -> StorageManager:
-    """Create a configured storage manager using global singleton config.
-
-    The storage configuration is loaded once from settings.storage_config_path
-    and cached for the lifetime of the process.
-
-    Returns:
-        StorageManager instance with registered providers
-    """
-    storage_config = get_storage_config()
-    return _build_storage_manager_from_config(storage_config)
-
-
-def create_development_storage() -> StorageManager:
-    """Create a simple storage manager for development use.
-
-    Uses local filesystem storage with sensible defaults.
-    This is primarily used for testing and creates a standalone manager
-    rather than using global settings.
-    """
-    config = StorageConfig(
-        default_provider="local",
-        providers={
-            "local": {
-                "type": "local",
-                "config": {
-                    "base_path": "/tmp/boards/storage",
-                    "public_url_base": "http://localhost:8088/api/storage",
-                },
-            }
-        },
-        routing_rules=[{"provider": "local"}],
-    )
-
-    # Create storage manager directly without using global settings
-    manager = StorageManager(config)
-
-    # Register the local provider
-    local_provider = create_storage_provider("local", config.providers["local"]["config"])
-    manager.register_provider("local", local_provider)
-
-    return manager

package/templates/api/src/boards/storage/implementations/__init__.py

@@ -1,27 +0,0 @@
-"""Storage provider implementations."""
-
-from .local import LocalStorageProvider
-
-# Optional cloud providers - imported conditionally to avoid import errors
-__all__ = ["LocalStorageProvider"]
-
-try:
-    from .supabase import SupabaseStorageProvider
-
-    __all__.append("SupabaseStorageProvider")
-except ImportError:
-    pass
-
-try:
-    from .s3 import S3StorageProvider
-
-    __all__.append("S3StorageProvider")
-except ImportError:
-    pass
-
-try:
-    from .gcs import GCSStorageProvider
-
-    __all__.append("GCSStorageProvider")
-except ImportError:
-    pass

package/templates/api/src/boards/storage/implementations/gcs.py

@@ -1,340 +0,0 @@
-"""Google Cloud Storage provider with IAM auth and CDN support."""
-
-import json
-import os
-from collections.abc import AsyncIterator
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from google.cloud import storage
-
-try:
-    import asyncio
-
-    from google.auth import default
-    from google.auth.exceptions import DefaultCredentialsError
-    from google.cloud import storage
-    from google.cloud.exceptions import GoogleCloudError, NotFound
-
-    _gcs_available = True
-except ImportError:
-    storage = None
-    NotFound = None
-    GoogleCloudError = None
-    default = None
-    DefaultCredentialsError = None
-    _gcs_available = False
-
-from ...logging import get_logger
-from ..base import StorageException, StorageProvider
-
-logger = get_logger(__name__)
-
-
-class GCSStorageProvider(StorageProvider):
-    """Google Cloud Storage with IAM auth, Cloud CDN, and proper async patterns."""
-
-    def __init__(
-        self,
-        bucket: str,
-        project_id: str | None = None,
-        credentials_path: str | None = None,
-        credentials_json: str | None = None,
-        cdn_domain: str | None = None,
-        upload_config: dict[str, Any] | None = None,
-    ):
-        if not _gcs_available:
-            raise ImportError(
-                "google-cloud-storage is required for GCSStorageProvider. "
-                "Install with: pip install google-cloud-storage"
-            )
-
-        self.bucket_name = bucket
-        self.project_id = project_id
-        self.credentials_path = credentials_path
-        self.credentials_json = credentials_json
-        self.cdn_domain = cdn_domain
-
-        # Default upload configuration
-        self.upload_config = {
-            "cache_control": "public, max-age=3600",
-            "predefined_acl": None,  # Use bucket's default ACL
-            **(upload_config or {}),
-        }
-
-        self._client: Any | None = None
-        self._bucket: Any | None = None
-
-        # Client will be initialized lazily on first use
-
-    def _get_client(self) -> Any:
-        """Get or create the GCS client with proper authentication."""
-        if self._client is None:
-            if storage is None:
-                raise ImportError("google-cloud-storage is required for GCSStorageProvider")
-
-            try:
-                if self.credentials_json:
-                    # Use JSON credentials string
-                    credentials_info = json.loads(self.credentials_json)
-                    from google.oauth2 import service_account
-
-                    credentials = service_account.Credentials.from_service_account_info(
-                        credentials_info,
-                        scopes=["https://www.googleapis.com/auth/cloud-platform"],
-                    )
-                    self._client = storage.Client(credentials=credentials, project=self.project_id)
-                elif self.credentials_path:
-                    # Use service account file
-                    credentials_path = Path(self.credentials_path)
-                    if not credentials_path.exists():
-                        raise FileNotFoundError(
-                            f"Credentials file not found: {self.credentials_path}"
-                        )
-
-                    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = str(credentials_path)
-                    self._client = storage.Client(project=self.project_id)
-                else:
-                    # Use default credentials (environment variables, gcloud, etc.)
-                    self._client = storage.Client(project=self.project_id)
-
-                # Get bucket reference
-                self._bucket = self._client.bucket(self.bucket_name)
-
-            except Exception as e:
-                logger.error(f"Failed to initialize GCS client: {e}")
-                raise StorageException(f"GCS client initialization failed: {e}") from e
-
-        return self._client
-
-    async def _run_sync(self, func, *args, **kwargs) -> Any:
-        """Run synchronous GCS operations in thread pool."""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, func, *args, **kwargs)
-
-    async def upload(
-        self,
-        key: str,
-        content: bytes | AsyncIterator[bytes],
-        content_type: str,
-        metadata: dict[str, Any] | None = None,
-    ) -> str:
-        """Upload content to GCS."""
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            # Create blob object
-            blob = bucket.blob(key)
-
-            # Set content type
-            blob.content_type = content_type
-
-            # Set cache control and other configuration
-            if self.upload_config.get("cache_control"):
-                blob.cache_control = self.upload_config["cache_control"]
-
-            # Add custom metadata
-            if metadata:
-                # GCS metadata keys must be lowercase and can contain only letters,
-                # numbers, and underscores
-                gcs_metadata = {}
-                for k, v in metadata.items():
-                    # Convert key to lowercase and replace invalid characters
-                    clean_key = k.lower().replace("-", "_").replace(" ", "_")
-                    gcs_metadata[clean_key] = str(v)
-                blob.metadata = gcs_metadata
-
-            # Handle streaming content for large files
-            if isinstance(content, bytes):
-                file_content = content
-            else:
-                # Collect streaming content into memory for upload
-                # For very large files, consider using resumable uploads
-                chunks = []
-                total_size = 0
-                async for chunk in content:
-                    chunks.append(chunk)
-                    total_size += len(chunk)
-                    # For files larger than 100MB, we could implement resumable upload
-                    if total_size > 100 * 1024 * 1024:
-                        logger.warning(
-                            f"Large file upload ({total_size} bytes) - "
-                            f"consider implementing resumable upload for key: {key}"
-                        )
-
-                file_content = b"".join(chunks)
-
-            # Upload using thread pool to avoid blocking
-            await self._run_sync(blob.upload_from_string, file_content, content_type=content_type)
-
-            # Return the CDN URL if configured, otherwise public GCS URL
-            if self.cdn_domain:
-                return f"https://{self.cdn_domain}/{key}"
-            else:
-                return f"https://storage.googleapis.com/{self.bucket_name}/{key}"
-
-        except Exception as e:
-            if isinstance(e, StorageException):
-                raise
-            logger.error(f"Unexpected error uploading {key} to GCS: {e}")
-            raise StorageException(f"GCS upload failed: {e}") from e
-
-    async def download(self, key: str) -> bytes:
-        """Download file content from GCS."""
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-
-            # Download using thread pool to avoid blocking
-            content = await self._run_sync(blob.download_as_bytes)
-            return content
-
-        except Exception as e:
-            if isinstance(e, StorageException):
-                raise
-            logger.error(f"Failed to download {key} from GCS: {e}")
-            raise StorageException(f"GCS download failed: {e}") from e
-
-    async def get_presigned_upload_url(
-        self,
-        key: str,
-        content_type: str,
-        expires_in: timedelta | None = None,
-    ) -> dict[str, Any]:
-        """Generate presigned URL for direct client uploads."""
-        if expires_in is None:
-            expires_in = timedelta(hours=1)
-
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-
-            # Generate signed URL for PUT operations
-            url = await self._run_sync(
-                blob.generate_signed_url,
-                version="v4",
-                expiration=expires_in,
-                method="PUT",
-                content_type=content_type,
-                headers={"Content-Type": content_type},
-            )
-
-            return {
-                "url": url,
-                "method": "PUT",
-                "headers": {"Content-Type": content_type},
-                "expires_at": (datetime.now(UTC) + expires_in).isoformat(),
-            }
-
-        except Exception as e:
-            if isinstance(e, StorageException):
-                raise
-            logger.error(f"Failed to create presigned upload URL for {key}: {e}")
-            raise StorageException(f"GCS presigned URL creation failed: {e}") from e
-
-    async def get_presigned_download_url(
-        self, key: str, expires_in: timedelta | None = None
-    ) -> str:
-        """Generate presigned URL for secure downloads."""
-        if expires_in is None:
-            expires_in = timedelta(hours=1)
-
-        try:
-            # Always use GCS native signed URLs for security
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-
-            # Generate signed URL for GET operations
-            url = await self._run_sync(
-                blob.generate_signed_url,
-                version="v4",
-                expiration=expires_in,
-                method="GET",
-            )
-
-            return url
-
-        except Exception as e:
-            if isinstance(e, StorageException):
-                raise
-            logger.error(f"Failed to create presigned download URL for {key}: {e}")
-            raise StorageException(f"GCS presigned download URL creation failed: {e}") from e
-
-    async def delete(self, key: str) -> bool:
-        """Delete file by storage key."""
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-            await self._run_sync(blob.delete)
-            return True
-
-        except Exception as e:
-            logger.error(f"Unexpected error deleting {key} from GCS: {e}")
-            raise StorageException(f"GCS delete failed: {e}") from e
-
-    async def exists(self, key: str) -> bool:
-        """Check if file exists."""
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-            exists = await self._run_sync(blob.exists)
-            return exists
-
-        except Exception:
-            return False
-
-    async def get_metadata(self, key: str) -> dict[str, Any]:
-        """Get file metadata (size, modified date, etc.)."""
-        try:
-            # Get client (initializes on first use)
-            client = self._get_client()
-            bucket = client.bucket(self.bucket_name)
-
-            blob = bucket.blob(key)
-
-            # Reload blob to get latest metadata
-            await self._run_sync(blob.reload)
-
-            result = {
-                "size": blob.size or 0,
-                "last_modified": blob.updated,
-                "content_type": blob.content_type,
-                "etag": blob.etag,
-                "generation": blob.generation,
-                "storage_class": blob.storage_class,
-                "cache_control": blob.cache_control,
-                "content_encoding": blob.content_encoding,
-                "content_disposition": blob.content_disposition,
-                "content_language": blob.content_language,
-            }
-
-            # Add custom metadata
-            if blob.metadata:
-                result["custom_metadata"] = blob.metadata
-
-            return result
-
-        except Exception as e:
-            if isinstance(e, StorageException):
-                raise
-            logger.error(f"Failed to get metadata for {key} from GCS: {e}")
-            raise StorageException(f"GCS get metadata failed: {e}") from e