kiarina-lib-google-cloud-storage 1.5.0__py3-none-any.whl

kiarina/lib/google/cloud_storage/__init__.py

@@ -0,0 +1,43 @@
+# __init__.py
+import logging
+from importlib import import_module
+from importlib.metadata import version
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._get_blob import get_blob
+    from ._get_bucket import get_bucket
+    from ._get_storage_client import get_storage_client
+    from .settings import GoogleCloudStorageSettings, settings_manager
+
+__version__ = version("kiarina-lib-google-cloud-storage")
+
+__all__ = [
+    # ._helpers
+    "get_blob",
+    "get_bucket",
+    "get_storage_client",
+    # .settings
+    "GoogleCloudStorageSettings",
+    "settings_manager",
+]
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+
+def __getattr__(name: str) -> object:
+    if name not in __all__:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+    module_map = {
+        # ._helpers
+        "get_blob": "._get_blob",
+        "get_bucket": "._get_bucket",
+        "get_storage_client": "._get_storage_client",
+        # .settings
+        "GoogleCloudStorageSettings": ".settings",
+        "settings_manager": ".settings",
+    }
+
+    globals()[name] = getattr(import_module(module_map[name], __name__), name)
+    return globals()[name]

kiarina/lib/google/cloud_storage/_get_blob.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from google.cloud import storage  # type: ignore[import-untyped]
+
+from ._get_bucket import get_bucket
+from .settings import settings_manager
+
+
+def get_blob(
+    config_key: str | None = None, blob_name: str | None = None, **kwargs: Any
+) -> storage.Blob:
+    settings = settings_manager.get_settings_by_key(config_key)
+
+    if blob_name is None and settings.blob_name is None:
+        raise ValueError("blob_name is not set in the settings and not provided")
+
+    if blob_name is None:
+        blob_name = settings.blob_name
+
+    if settings.blob_name_prefix:
+        blob_name = f"{settings.blob_name_prefix}/{blob_name}"
+
+    bucket = get_bucket(config_key, **kwargs)
+    return bucket.blob(blob_name)

kiarina/lib/google/cloud_storage/_get_bucket.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from google.cloud import storage  # type: ignore[import-untyped]
+
+from ._get_storage_client import get_storage_client
+from .settings import settings_manager
+
+
+def get_bucket(config_key: str | None = None, **kwargs: Any) -> storage.Bucket:
+    settings = settings_manager.get_settings_by_key(config_key)
+
+    if settings.bucket_name is None:
+        raise ValueError("bucket_name is not set in the settings")
+
+    client = get_storage_client(config_key, **kwargs)
+    return client.bucket(settings.bucket_name)

kiarina/lib/google/cloud_storage/_get_storage_client.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+from google.cloud import storage  # type: ignore[import-untyped]
+from kiarina.lib.google.auth import get_credentials
+
+from .settings import settings_manager
+
+
+def get_storage_client(config_key: str | None = None, **kwargs: Any) -> storage.Client:
+    settings = settings_manager.get_settings_by_key(config_key)
+    credentials = get_credentials(settings.google_auth_config_key)
+    return storage.Client(credentials=credentials, **kwargs)

kiarina/lib/google/cloud_storage/settings.py

@@ -0,0 +1,15 @@
+from pydantic_settings import BaseSettings
+from pydantic_settings_manager import SettingsManager
+
+
+class GoogleCloudStorageSettings(BaseSettings):
+    google_auth_config_key: str | None = None
+
+    bucket_name: str | None = None
+
+    blob_name_prefix: str | None = None
+
+    blob_name: str | None = None
+
+
+settings_manager = SettingsManager(GoogleCloudStorageSettings, multi=True)

kiarina_lib_google_cloud_storage-1.5.0.dist-info/METADATA

@@ -0,0 +1,719 @@
+Metadata-Version: 2.4
+Name: kiarina-lib-google-cloud-storage
+Version: 1.5.0
+Summary: Google Cloud Storage client library for kiarina namespace
+Project-URL: Homepage, https://github.com/kiarina/kiarina-python
+Project-URL: Repository, https://github.com/kiarina/kiarina-python
+Project-URL: Issues, https://github.com/kiarina/kiarina-python/issues
+Project-URL: Changelog, https://github.com/kiarina/kiarina-python/blob/main/packages/kiarina-lib-google-cloud-storage/CHANGELOG.md
+Project-URL: Documentation, https://github.com/kiarina/kiarina-python/tree/main/packages/kiarina-lib-google-cloud-storage#readme
+Author-email: kiarina <kiarinadawa@gmail.com>
+Maintainer-email: kiarina <kiarinadawa@gmail.com>
+License-Expression: MIT
+Keywords: client,cloud,gcp,gcs,google,google-cloud,pydantic,settings,storage
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: google-cloud-storage>=2.19.0
+Requires-Dist: kiarina-lib-google-auth>=1.4.0
+Requires-Dist: pydantic-settings-manager>=2.1.0
+Requires-Dist: pydantic-settings>=2.10.1
+Description-Content-Type: text/markdown
+
+# kiarina-lib-google-cloud-storage
+
+A Python client library for Google Cloud Storage that separates infrastructure configuration from application logic.
+
+## Design Philosophy
+
+This library follows the principle of **separating infrastructure concerns from application logic**.
+
+### The Problem
+
+When using Google Cloud Storage directly, application code becomes tightly coupled with infrastructure details:
+
+```python
+# ❌ Infrastructure details leak into application code
+from google.cloud import storage
+from google.oauth2 import service_account
+
+# Hard-coded credentials and bucket configuration
+credentials = service_account.Credentials.from_service_account_file(
+    '/path/to/service-account-key.json'
+)
+client = storage.Client(credentials=credentials)
+bucket = client.bucket("prod-us-west1-app-data")  # Hard-coded bucket name
+blob = bucket.blob("v2/users/data.json")  # Hard-coded path structure
+```
+
+**Problems with this approach:**
+- Environment-specific details are scattered throughout the codebase
+- Difficult to test (requires mocking or actual GCS access)
+- Hard to support multiple environments (dev, staging, production)
+- Challenging to implement multi-tenancy
+- Credentials management is error-prone
+
+### The Solution
+
+This library externalizes all infrastructure configuration:
+
+```python
+# ✅ Application code only knows logical names
+from kiarina.lib.google.cloud_storage import get_blob
+
+# All infrastructure details are managed externally
+blob = get_blob(blob_name="user_data.json")
+blob.upload_from_string(json.dumps(data))
+```
+
+**Benefits:**
+- **Environment-agnostic**: Same code works in dev, staging, and production
+- **Testable**: Easy to inject test configurations
+- **Multi-tenant ready**: Different configurations for different tenants
+- **Secure**: Credentials managed through kiarina-lib-google-auth
+- **Maintainable**: Infrastructure changes don't require code changes
+
+## Features
+
+- **Configuration Management**: Use `pydantic-settings-manager` for flexible configuration
+- **Type Safety**: Full type hints and Pydantic validation
+- **Integration with kiarina-lib-google-auth**: Seamless authentication
+- **Multiple Configurations**: Support for multiple named configurations
+- **Environment Variable Support**: Configure via environment variables
+- **Blob Name Prefix**: Organize blobs with configurable prefixes
+- **Native API Access**: Returns native `google-cloud-storage` objects for full API access
+
+## Installation
+
+```bash
+pip install kiarina-lib-google-cloud-storage
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from kiarina.lib.google.cloud_storage import get_blob, settings_manager
+
+# Configure once (typically in your app initialization)
+settings_manager.user_config = {
+    "default": {
+        "google_auth_config_key": "default",
+        "bucket_name": "my-app-data",
+        "blob_name_prefix": "production/v1"
+    }
+}
+
+# Application code - clean and simple
+blob = get_blob(blob_name="user_data.json")
+# Actual path: gs://my-app-data/production/v1/user_data.json
+
+# Use native google-cloud-storage API
+blob.upload_from_string("Hello, World!")
+content = blob.download_as_text()
+```
+
+### Configuration via Environment Variables
+
+```bash
+# Set once in your deployment environment
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_BUCKET_NAME="my-app-data"
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_BLOB_NAME_PREFIX="production/v1"
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_GOOGLE_AUTH_CONFIG_KEY="default"
+```
+
+```python
+# Application code - no configuration needed
+from kiarina.lib.google.cloud_storage import get_blob
+
+blob = get_blob(blob_name="user_data.json")
+blob.upload_from_string("Hello, World!")
+```
+
+## Real-World Use Cases
+
+### Use Case 1: Multi-Environment Deployment
+
+Deploy the same application code to different environments with different configurations.
+
+```yaml
+# config/production.yaml
+google_cloud_storage:
+  default:
+    google_auth_config_key: "production"
+    bucket_name: "prod-us-west1-app-data"
+    blob_name_prefix: "v2/production"
+
+# config/staging.yaml
+google_cloud_storage:
+  default:
+    google_auth_config_key: "staging"
+    bucket_name: "staging-app-data"
+    blob_name_prefix: "v2/staging"
+
+# config/development.yaml
+google_cloud_storage:
+  default:
+    google_auth_config_key: "development"
+    bucket_name: "dev-local-data"
+    blob_name_prefix: "v2/dev"
+```
+
+```python
+# Application code (same for all environments)
+from kiarina.lib.google.cloud_storage import get_blob
+
+def save_user_profile(user_id: str, profile: dict):
+    """Save user profile - works in any environment"""
+    blob = get_blob(blob_name=f"users/{user_id}/profile.json")
+    blob.upload_from_string(json.dumps(profile))
+
+def load_user_profile(user_id: str) -> dict:
+    """Load user profile - works in any environment"""
+    blob = get_blob(blob_name=f"users/{user_id}/profile.json")
+    return json.loads(blob.download_as_text())
+```
+
+**Result:**
+- Production: `gs://prod-us-west1-app-data/v2/production/users/{user_id}/profile.json`
+- Staging: `gs://staging-app-data/v2/staging/users/{user_id}/profile.json`
+- Development: `gs://dev-local-data/v2/dev/users/{user_id}/profile.json`
+
+### Use Case 2: Multi-Tenant Application
+
+Support multiple tenants with isolated storage, without changing application code.
+
+```python
+from kiarina.lib.google.cloud_storage import settings_manager, get_blob
+
+# Configure tenant-specific storage
+settings_manager.user_config = {
+    "tenant_acme": {
+        "google_auth_config_key": "tenant_acme",
+        "bucket_name": "acme-corp-data",
+        "blob_name_prefix": "app-data"
+    },
+    "tenant_globex": {
+        "google_auth_config_key": "tenant_globex",
+        "bucket_name": "globex-data",
+        "blob_name_prefix": "app-data"
+    }
+}
+
+# Application code - tenant-agnostic
+def save_document(tenant_id: str, doc_id: str, content: bytes):
+    """Save document for any tenant"""
+    config_key = f"tenant_{tenant_id}"
+    blob = get_blob(config_key=config_key, blob_name=f"documents/{doc_id}.pdf")
+    blob.upload_from_string(content)
+
+def list_documents(tenant_id: str) -> list[str]:
+    """List documents for any tenant"""
+    from kiarina.lib.google.cloud_storage import get_bucket
+    
+    config_key = f"tenant_{tenant_id}"
+    bucket = get_bucket(config_key=config_key)
+    
+    # Get prefix from settings
+    settings = settings_manager.get_settings_by_key(config_key)
+    prefix = f"{settings.blob_name_prefix}/documents/" if settings.blob_name_prefix else "documents/"
+    
+    blobs = bucket.list_blobs(prefix=prefix)
+    return [blob.name for blob in blobs]
+```
+
+**Result:**
+- Tenant ACME: `gs://acme-corp-data/app-data/documents/{doc_id}.pdf`
+- Tenant Globex: `gs://globex-data/app-data/documents/{doc_id}.pdf`
+
+### Use Case 3: Testing
+
+Write tests without touching real Google Cloud Storage.
+
+```python
+# tests/conftest.py
+import pytest
+from kiarina.lib.google.cloud_storage import settings_manager
+
+@pytest.fixture
+def mock_storage_config():
+    """Configure test storage"""
+    settings_manager.user_config = {
+        "test": {
+            "google_auth_config_key": "test",
+            "bucket_name": "test-bucket",
+            "blob_name_prefix": f"test-run-{datetime.now().isoformat()}"
+        }
+    }
+    yield
+    # Cleanup test data if needed
+
+# tests/test_user_service.py
+def test_save_user_profile(mock_storage_config):
+    """Test user profile saving"""
+    from myapp.services import save_user_profile
+    
+    # Application code uses test configuration automatically
+    save_user_profile("user123", {"name": "Alice"})
+    
+    # Verify using the same configuration
+    from kiarina.lib.google.cloud_storage import get_blob
+    blob = get_blob(blob_name="users/user123/profile.json")
+    assert blob.exists()
+```
+
+### Use Case 4: Debugging and Troubleshooting
+
+Understand where your data is actually stored.
+
+```python
+from kiarina.lib.google.cloud_storage import settings_manager
+
+def debug_storage_config(config_key: str | None = None):
+    """Show actual storage paths for debugging"""
+    settings = settings_manager.get_settings_by_key(config_key)
+    
+    print(f"Configuration: {config_key or 'default'}")
+    print(f"  Bucket: {settings.bucket_name}")
+    print(f"  Prefix: {settings.blob_name_prefix or '(none)'}")
+    print(f"  Auth: {settings.google_auth_config_key}")
+    
+    # Example paths
+    example_blob = "users/123/profile.json"
+    if settings.blob_name_prefix:
+        full_path = f"{settings.blob_name_prefix}/{example_blob}"
+    else:
+        full_path = example_blob
+    
+    print(f"  Example: gs://{settings.bucket_name}/{full_path}")
+
+# Usage
+debug_storage_config("production")
+# Output:
+# Configuration: production
+#   Bucket: prod-us-west1-app-data
+#   Prefix: v2/production
+#   Auth: production
+#   Example: gs://prod-us-west1-app-data/v2/production/users/123/profile.json
+```
+
+## Configuration
+
+This library uses [pydantic-settings-manager](https://github.com/kiarina/pydantic-settings-manager) for flexible configuration management.
+
+### GoogleCloudStorageSettings
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `google_auth_config_key` | `str \| None` | No | Configuration key for kiarina-lib-google-auth |
+| `bucket_name` | `str \| None` | Yes* | Google Cloud Storage bucket name |
+| `blob_name_prefix` | `str \| None` | No | Prefix for blob names (e.g., "production/v1") |
+| `blob_name` | `str \| None` | No | Default blob name (rarely used) |
+
+*Required when using `get_bucket()` or `get_blob()`
+
+### Configuration Methods
+
+#### 1. Programmatic Configuration
+
+```python
+from kiarina.lib.google.cloud_storage import settings_manager
+
+settings_manager.user_config = {
+    "default": {
+        "google_auth_config_key": "default",
+        "bucket_name": "my-bucket",
+        "blob_name_prefix": "app-data"
+    }
+}
+```
+
+#### 2. Environment Variables
+
+All settings can be configured via environment variables with the `KIARINA_LIB_GOOGLE_CLOUD_STORAGE_` prefix:
+
+```bash
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_GOOGLE_AUTH_CONFIG_KEY="default"
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_BUCKET_NAME="my-bucket"
+export KIARINA_LIB_GOOGLE_CLOUD_STORAGE_BLOB_NAME_PREFIX="app-data"
+```
+
+#### 3. Configuration Files (with YAML)
+
+```python
+import yaml
+from kiarina.lib.google.cloud_storage import settings_manager
+
+# Load from YAML file
+with open("config.yaml") as f:
+    config = yaml.safe_load(f)
+
+settings_manager.user_config = config["google_cloud_storage"]
+```
+
+### Integration with kiarina-lib-google-auth
+
+This library integrates seamlessly with [kiarina-lib-google-auth](../kiarina-lib-google-auth/) for authentication:
+
+```python
+from kiarina.lib.google.auth import settings_manager as auth_settings_manager
+from kiarina.lib.google.cloud_storage import settings_manager as storage_settings_manager
+
+# Configure authentication
+auth_settings_manager.user_config = {
+    "default": {
+        "type": "service_account",
+        "service_account_file": "~/service-account-key.json"
+    }
+}
+
+# Configure storage (references auth config)
+storage_settings_manager.user_config = {
+    "default": {
+        "google_auth_config_key": "default",  # References auth config above
+        "bucket_name": "my-bucket"
+    }
+}
+
+# Use authenticated storage
+from kiarina.lib.google.cloud_storage import get_bucket
+bucket = get_bucket()  # Automatically authenticated
+```
+
+## API Reference
+
+### get_storage_client()
+
+Get a Google Cloud Storage client with credentials from kiarina-lib-google-auth.
+
+```python
+def get_storage_client(
+    config_key: str | None = None,
+    **kwargs: Any
+) -> storage.Client
+```
+
+**Parameters:**
+- `config_key`: Configuration key to use (default: None uses active key)
+- `**kwargs`: Additional arguments passed to `storage.Client()`
+
+**Returns:**
+- `storage.Client`: Authenticated Google Cloud Storage client
+
+**Example:**
+```python
+client = get_storage_client()
+client = get_storage_client(config_key="production")
+client = get_storage_client(project="my-project")  # Override project
+```
+
+### get_bucket()
+
+Get a Google Cloud Storage bucket.
+
+```python
+def get_bucket(
+    config_key: str | None = None,
+    **kwargs: Any
+) -> storage.Bucket
+```
+
+**Parameters:**
+- `config_key`: Configuration key to use (default: None uses active key)
+- `**kwargs`: Additional arguments passed to `get_storage_client()`
+
+**Returns:**
+- `storage.Bucket`: Google Cloud Storage bucket
+
+**Raises:**
+- `ValueError`: If `bucket_name` is not set in settings
+
+**Example:**
+```python
+bucket = get_bucket()
+bucket = get_bucket(config_key="production")
+
+# Use native google-cloud-storage API
+for blob in bucket.list_blobs(prefix="users/"):
+    print(blob.name)
+```
+
+### get_blob()
+
+Get a Google Cloud Storage blob.
+
+```python
+def get_blob(
+    config_key: str | None = None,
+    blob_name: str | None = None,
+    **kwargs: Any
+) -> storage.Blob
+```
+
+**Parameters:**
+- `config_key`: Configuration key to use (default: None uses active key)
+- `blob_name`: Blob name (default: None uses settings.blob_name)
+- `**kwargs`: Additional arguments passed to `get_bucket()`
+
+**Returns:**
+- `storage.Blob`: Google Cloud Storage blob
+
+**Raises:**
+- `ValueError`: If `blob_name` is not provided and not set in settings
+
+**Example:**
+```python
+# Basic usage
+blob = get_blob(blob_name="data.json")
+
+# With blob_name_prefix in settings
+# If blob_name_prefix="production/v1" and blob_name="data.json"
+# Actual blob name will be "production/v1/data.json"
+blob = get_blob(blob_name="data.json")
+
+# Use native google-cloud-storage API
+blob.upload_from_string("content")
+content = blob.download_as_text()
+blob.delete()
+```
+
+### settings_manager
+
+Global settings manager instance for Google Cloud Storage configuration.
+
+```python
+settings_manager: SettingsManager[GoogleCloudStorageSettings]
+```
+
+**Properties:**
+- `settings`: Get the current active settings
+- `user_config`: Get/set user configuration
+- `active_key`: Get/set active configuration key
+
+**Methods:**
+- `get_settings_by_key(key: str)`: Get settings by specific key
+- `clear()`: Clear cached settings
+
+## Common Operations
+
+### Upload and Download
+
+```python
+from kiarina.lib.google.cloud_storage import get_blob
+
+# Upload from string
+blob = get_blob(blob_name="data.json")
+blob.upload_from_string(json.dumps({"key": "value"}))
+
+# Upload from file
+blob = get_blob(blob_name="document.pdf")
+blob.upload_from_filename("/path/to/document.pdf")
+
+# Download as string
+blob = get_blob(blob_name="data.json")
+content = blob.download_as_text()
+data = json.loads(content)
+
+# Download to file
+blob = get_blob(blob_name="document.pdf")
+blob.download_to_filename("/path/to/downloaded.pdf")
+```
+
+### List Blobs
+
+```python
+from kiarina.lib.google.cloud_storage import get_bucket, settings_manager
+
+bucket = get_bucket()
+
+# Get prefix from settings
+settings = settings_manager.settings
+prefix = f"{settings.blob_name_prefix}/users/" if settings.blob_name_prefix else "users/"
+
+# List blobs
+for blob in bucket.list_blobs(prefix=prefix):
+    print(f"{blob.name}: {blob.size} bytes")
+```
+
+### Check Existence
+
+```python
+from kiarina.lib.google.cloud_storage import get_blob
+
+blob = get_blob(blob_name="data.json")
+if blob.exists():
+    print("Blob exists")
+    print(f"Size: {blob.size} bytes")
+    print(f"Updated: {blob.updated}")
+else:
+    print("Blob does not exist")
+```
+
+### Delete Blob
+
+```python
+from kiarina.lib.google.cloud_storage import get_blob
+
+blob = get_blob(blob_name="old_data.json")
+if blob.exists():
+    blob.delete()
+    print("Blob deleted")
+```
+
+### Copy Blob
+
+```python
+from kiarina.lib.google.cloud_storage import get_bucket
+
+bucket = get_bucket()
+source_blob = bucket.blob("source.json")
+destination_blob = bucket.blob("backup/source.json")
+
+bucket.copy_blob(source_blob, bucket, destination_blob.name)
+print("Blob copied")
+```
+
+## Error Handling
+
+```python
+from google.cloud import storage
+from google.api_core import exceptions
+from kiarina.lib.google.cloud_storage import get_blob
+
+try:
+    blob = get_blob(blob_name="data.json")
+    content = blob.download_as_text()
+except exceptions.NotFound:
+    print("Blob not found")
+except exceptions.Forbidden:
+    print("Permission denied")
+except exceptions.GoogleAPIError as e:
+    print(f"Google API error: {e}")
+except ValueError as e:
+    print(f"Configuration error: {e}")
+```
+
+## Best Practices
+
+### 1. Configure Once, Use Everywhere
+
+```python
+# app/config.py
+from kiarina.lib.google.cloud_storage import settings_manager
+import yaml
+
+def init_storage_config():
+    """Initialize storage configuration at app startup"""
+    with open("config/storage.yaml") as f:
+        config = yaml.safe_load(f)
+    settings_manager.user_config = config
+
+# app/main.py
+from app.config import init_storage_config
+
+def main():
+    init_storage_config()
+    # Now all modules can use get_blob() without configuration
+```
+
+### 2. Use Logical Names
+
+```python
+# ✅ Good - logical, environment-agnostic names
+blob = get_blob(blob_name="users/123/profile.json")
+blob = get_blob(blob_name="reports/2024/january.pdf")
+
+# ❌ Bad - environment-specific details in code
+blob = get_blob(blob_name="prod-v2-users-123-profile.json")
+```
+
+### 3. Organize with Prefixes
+
+```python
+# Configure hierarchical structure
+settings_manager.user_config = {
+    "default": {
+        "bucket_name": "my-app-data",
+        "blob_name_prefix": "production/v2"  # Version and environment
+    }
+}
+
+# Application uses clean paths
+blob = get_blob(blob_name="users/123/profile.json")
+# Actual: gs://my-app-data/production/v2/users/123/profile.json
+```
+
+### 4. Validate Configuration
+
+```python
+def validate_storage_config(config_key: str | None = None) -> bool:
+    """Validate storage configuration at startup"""
+    try:
+        from kiarina.lib.google.cloud_storage import get_bucket
+        bucket = get_bucket(config_key)
+        bucket.exists()
+        print(f"✓ Storage configuration valid: {bucket.name}")
+        return True
+    except Exception as e:
+        print(f"✗ Storage configuration invalid: {e}")
+        return False
+
+# At app startup
+if not validate_storage_config():
+    raise RuntimeError("Invalid storage configuration")
+```
+
+## Development
+
+### Prerequisites
+
+- Python 3.12+
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/kiarina/kiarina-python.git
+cd kiarina-python
+
+# Setup development environment
+mise run setup
+```
+
+### Running Tests
+
+```bash
+# Run format, lint, type checks and tests
+mise run package kiarina-lib-google-cloud-storage
+
+# Coverage report
+mise run package:test kiarina-lib-google-cloud-storage --coverage
+```
+
+## Dependencies
+
+- [google-cloud-storage](https://github.com/googleapis/python-storage) - Google Cloud Storage client library
+- [kiarina-lib-google-auth](../kiarina-lib-google-auth/) - Google Cloud authentication library
+- [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) - Settings management
+- [pydantic-settings-manager](https://github.com/kiarina/pydantic-settings-manager) - Advanced settings management
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+
+## Contributing
+
+This is a personal project, but contributions are welcome! Please feel free to submit issues or pull requests.
+
+## Related Projects
+
+- [kiarina-python](https://github.com/kiarina/kiarina-python) - The main monorepo containing this package
+- [kiarina-lib-google-auth](../kiarina-lib-google-auth/) - Google Cloud authentication library
+- [pydantic-settings-manager](https://github.com/kiarina/pydantic-settings-manager) - Configuration management library used by this package

kiarina_lib_google_cloud_storage-1.5.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+kiarina/lib/google/cloud_storage/__init__.py,sha256=q2AdOOOHUj_D-eot8_1-atrIaCKsCg0YatUOdq3kVVE,1184
+kiarina/lib/google/cloud_storage/_get_blob.py,sha256=baZ7msH9xPme3jw0mI9x2NzikapdeSyBqH_6iDdgohI,728
+kiarina/lib/google/cloud_storage/_get_bucket.py,sha256=Y7gX-igAkLoLhxa3cDazTAcNX_X_uUjJRUs93lcRg98,534
+kiarina/lib/google/cloud_storage/_get_storage_client.py,sha256=XTsjQdVN4_tqO1KX-pC4-st7As7mMxeB1XhagzuJLaY,463
+kiarina/lib/google/cloud_storage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kiarina/lib/google/cloud_storage/settings.py,sha256=QSY37za-Vi3S7fQLX7AzC5m65QxjxtuYYT9wq08Ee0o,381
+kiarina_lib_google_cloud_storage-1.5.0.dist-info/METADATA,sha256=SCFb0PFxO75UWAhAtGMGVTMb3KvU0N7QPjc_2MdRUuY,20994
+kiarina_lib_google_cloud_storage-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kiarina_lib_google_cloud_storage-1.5.0.dist-info/RECORD,,

kiarina_lib_google_cloud_storage-1.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any