chuk-artifacts 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

{chuk_artifacts-0.1.0.dist-info → chuk_artifacts-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-artifacts
-Version: 0.1.0
+Version: 0.1.2
 Summary: Add your description here
 License: MIT
 Requires-Python: >=3.11
@@ -27,18 +27,20 @@ Dynamic: license-file
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-**Asynchronous, multi-backend artifact storage with metadata caching and presigned URLs**
+**Asynchronous, multi-backend artifact storage with session-based security and presigned URLs**
 
-Chuk Artifacts provides a production-ready, modular artifact storage system that works seamlessly across multiple storage backends (memory, filesystem, AWS S3, IBM Cloud Object Storage) with Redis or memory-based metadata caching.
+Chuk Artifacts provides a production-ready, modular artifact storage system that works seamlessly across multiple storage backends (memory, filesystem, AWS S3, IBM Cloud Object Storage) with Redis or memory-based metadata caching and **strict session-based security**.
 
 ## ✨ Key Features
 
-- 🏗️ **Modular Architecture**: 5 specialized operation modules for clean separation of concerns
+- 🏗️ **Modular Architecture**: 6 specialized operation modules for clean separation of concerns
+- 🔒 **Session-Based Security**: Strict isolation with no cross-session operations allowed
 - 🔄 **Multi-Backend Support**: Memory, filesystem, S3, IBM COS with seamless switching
-- ⚡ **Fully Async**: Built with async/await for high performance
+- ⚡ **Fully Async**: Built with async/await for high performance (3,000+ ops/sec)
 - 🔗 **Presigned URLs**: Secure, time-limited access without credential exposure
 - 📊 **Batch Operations**: Efficient multi-file uploads and processing
 - 🗃️ **Metadata Caching**: Fast lookups with Redis or memory-based sessions
+- 📁 **Directory-Like Operations**: Organize files with path-based prefixes
 - 🔧 **Zero Configuration**: Works out of the box with sensible defaults
 - 🌍 **Production Ready**: Battle-tested with comprehensive error handling
 
@@ -65,7 +67,8 @@ artifact_id = await store.store(
     data=b"Hello, world!",
     mime="text/plain",
     summary="A simple greeting",
-    filename="hello.txt"
+    filename="hello.txt",
+    session_id="user_123"  # Session-based isolation
 )
 
 # Retrieve it
@@ -76,6 +79,41 @@ print(data.decode())  # "Hello, world!"
 download_url = await store.presign_medium(artifact_id)  # 1 hour
 ```
 
+### Session-Based File Management
+
+```python
+# Create files in user sessions
+doc_id = await store.write_file(
+    content="# User's Document\n\nPrivate content here.",
+    filename="docs/private.md",
+    mime="text/markdown",
+    session_id="user_alice"
+)
+
+# List files in a session
+files = await store.list_by_session("user_alice")
+print(f"Alice has {len(files)} files")
+
+# List directory-like contents
+docs = await store.get_directory_contents("user_alice", "docs/")
+print(f"Alice's docs: {len(docs)} files")
+
+# Copy within same session (allowed)
+backup_id = await store.copy_file(
+    doc_id,
+    new_filename="docs/private_backup.md"
+)
+
+# Cross-session operations are BLOCKED for security
+try:
+    await store.copy_file(
+        doc_id, 
+        target_session_id="user_bob"  # This will fail
+    )
+except ArtifactStoreError:
+    print("Cross-session operations blocked!")
+```
+
 ### With Configuration
 
 ```python
@@ -104,7 +142,8 @@ Chuk Artifacts uses a modular architecture with specialized operation modules:
 ArtifactStore (Main Coordinator)
 ├── CoreStorageOperations     # store() and retrieve()
 ├── PresignedURLOperations    # URL generation and upload workflows
-├── MetadataOperations        # metadata, exists, delete, update
+├── MetadataOperations        # metadata, exists, delete, update, list_by_session
+├── SessionOperations         # session-based file operations (NEW)
 ├── BatchOperations          # store_batch() for multiple files
 └── AdminOperations          # validate_configuration, get_stats
 ```
@@ -114,6 +153,43 @@ This design provides:
 - **Enhanced maintainability**: Clear separation of concerns
 - **Easy extensibility**: Add new operation types without touching core
 - **Improved debugging**: Isolated functionality for easier troubleshooting
+- **Session security**: Dedicated module for secure session operations
+
+## 🔒 Session-Based Security
+
+### Strict Session Isolation
+```python
+# Users can only access their own files
+alice_files = await store.list_by_session("user_alice")
+bob_files = await store.list_by_session("user_bob")
+
+# Cross-session operations are blocked
+await store.copy_file(alice_file_id, target_session_id="user_bob")  # ❌ Blocked
+await store.move_file(alice_file_id, new_session_id="user_bob")     # ❌ Blocked
+```
+
+### Multi-Tenant Safe
+```python
+# Perfect for SaaS applications
+company_a_files = await store.list_by_session("company_a")
+company_b_files = await store.list_by_session("company_b")
+
+# Companies cannot access each other's data
+# Compliance-ready: GDPR, SOX, HIPAA
+```
+
+### Directory-Like Organization
+```python
+# Organize files with path-like prefixes
+await store.write_file(content, filename="docs/reports/q1_sales.pdf", session_id="user_123")
+await store.write_file(content, filename="docs/contracts/client_a.pdf", session_id="user_123")
+await store.write_file(content, filename="images/profile.jpg", session_id="user_123")
+
+# List by directory
+docs = await store.get_directory_contents("user_123", "docs/")
+reports = await store.get_directory_contents("user_123", "docs/reports/")
+images = await store.get_directory_contents("user_123", "images/")
+```
 
 ## 📦 Storage Providers
 
@@ -124,7 +200,7 @@ store = ArtifactStore(storage_provider="memory")
 - Perfect for development and testing
 - Zero configuration required
 - Non-persistent (data lost on restart)
-- Isolation between async contexts
+- Session listing returns empty (graceful degradation)
 
 ### Filesystem Provider
 ```python
@@ -135,6 +211,7 @@ os.environ["ARTIFACT_FS_ROOT"] = "./my-artifacts"
 - Local disk storage
 - Persistent across restarts
 - `file://` URLs for local access
+- **Full session listing support**
 - Great for development and small deployments
 
 ### AWS S3 Provider
@@ -151,6 +228,7 @@ os.environ.update({
 - Industry-standard cloud storage
 - Native presigned URL support
 - Highly scalable and durable
+- **Full session listing support**
 - Perfect for production workloads
 
 ### IBM Cloud Object Storage
@@ -192,6 +270,40 @@ os.environ["SESSION_REDIS_URL"] = "redis://localhost:6379/0"
 
 ## 🎯 Common Use Cases
 
+### MCP Server Integration
+
+```python
+from chuk_artifacts import ArtifactStore
+
+# Initialize for MCP server
+store = ArtifactStore(
+    storage_provider="filesystem",  # or "s3" for production
+    session_provider="redis"
+)
+
+# MCP tool: Upload file
+async def upload_file(data_base64: str, filename: str, mime: str, session_id: str):
+    data = base64.b64decode(data_base64)
+    artifact_id = await store.store(
+        data=data,
+        mime=mime,
+        summary=f"Uploaded: {filename}",
+        filename=filename,
+        session_id=session_id  # Session isolation
+    )
+    return {"artifact_id": artifact_id}
+
+# MCP tool: List session files
+async def list_session_files(session_id: str, prefix: str = ""):
+    files = await store.list_by_prefix(session_id, prefix)
+    return {"files": files}
+
+# MCP tool: Copy file (within session only)
+async def copy_file(artifact_id: str, new_filename: str):
+    new_id = await store.copy_file(artifact_id, new_filename=new_filename)
+    return {"new_artifact_id": new_id}
+```
+
 ### Web Framework Integration
 
 ```python
@@ -203,13 +315,14 @@ store = ArtifactStore(
     session_provider="redis"
 )
 
-async def upload_file(file_content: bytes, filename: str, content_type: str):
-    """Handle file upload in FastAPI/Flask"""
+async def upload_file(file_content: bytes, filename: str, content_type: str, user_id: str):
+    """Handle file upload in FastAPI/Flask with user isolation"""
     artifact_id = await store.store(
         data=file_content,
         mime=content_type,
         summary=f"Uploaded: {filename}",
-        filename=filename
+        filename=filename,
+        session_id=f"user_{user_id}"  # User-specific session
     )
     
     # Return download URL
@@ -218,6 +331,73 @@ async def upload_file(file_content: bytes, filename: str, content_type: str):
         "artifact_id": artifact_id,
         "download_url": download_url
     }
+
+async def list_user_files(user_id: str, directory: str = ""):
+    """List files for a specific user"""
+    return await store.get_directory_contents(f"user_{user_id}", directory)
+```
+
+### Multi-Tenant SaaS Application
+
+```python
+# Tenant isolation
+async def create_tenant_workspace(tenant_id: str):
+    """Create isolated workspace for tenant"""
+    
+    # Create tenant directory structure
+    directories = ["documents/", "images/", "reports/", "config/"]
+    
+    for directory in directories:
+        # Create a marker file for the directory
+        await store.write_file(
+            content=f"# {directory.rstrip('/')} Directory\n\nTenant workspace created.",
+            filename=f"{directory}README.md",
+            session_id=f"tenant_{tenant_id}"
+        )
+    
+    return {"tenant_id": tenant_id, "directories": directories}
+
+async def get_tenant_usage(tenant_id: str):
+    """Get storage usage for a tenant"""
+    files = await store.list_by_session(f"tenant_{tenant_id}")
+    total_bytes = sum(file.get('bytes', 0) for file in files)
+    
+    return {
+        "tenant_id": tenant_id,
+        "file_count": len(files),
+        "total_bytes": total_bytes,
+        "total_mb": round(total_bytes / 1024 / 1024, 2)
+    }
+```
+
+### Advanced File Operations
+
+```python
+# Read file content directly
+content = await store.read_file(artifact_id, as_text=True)
+print(f"File content: {content}")
+
+# Write file with content
+new_id = await store.write_file(
+    content="# New Document\n\nThis is a new file.",
+    filename="documents/new_doc.md",
+    mime="text/markdown",
+    session_id="user_123"
+)
+
+# Move/rename file within session
+await store.move_file(
+    artifact_id,
+    new_filename="documents/renamed_doc.md"
+)
+
+# Update file content (overwrite)
+updated_id = await store.write_file(
+    content="# Updated Document\n\nThis content replaces the old file.",
+    filename="documents/updated_doc.md",
+    session_id="user_123",
+    overwrite_artifact_id=old_artifact_id
+)
 ```
 
 ### Batch Processing
@@ -229,45 +409,18 @@ items = [
         "data": file1_content,
         "mime": "image/png",
         "summary": "Product image 1",
-        "filename": "product1.png"
+        "filename": "images/product1.png"
     },
     {
         "data": file2_content,
         "mime": "image/png", 
         "summary": "Product image 2",
-        "filename": "product2.png"
+        "filename": "images/product2.png"
     }
 ]
 
-# Store all at once
-artifact_ids = await store.store_batch(items, session_id="product-images")
-```
-
-### Advanced Metadata Management
-
-```python
-# Store with custom metadata
-artifact_id = await store.store(
-    data=image_data,
-    mime="image/png",
-    summary="Product photo",
-    filename="product.png",
-    meta={
-        "product_id": "12345",
-        "photographer": "John Doe",
-        "category": "electronics"
-    }
-)
-
-# Update metadata later
-await store.update_metadata(
-    artifact_id,
-    summary="Updated product photo",
-    meta={"edited": True, "version": 2}
-)
-
-# Extend TTL
-await store.extend_ttl(artifact_id, 3600)  # Add 1 hour
+# Store all at once with session isolation
+artifact_ids = await store.store_batch(items, session_id="product-catalog")
 ```
 
 ### Context Manager Usage
@@ -277,11 +430,52 @@ async with ArtifactStore() as store:
     artifact_id = await store.store(
         data=b"Temporary data",
         mime="text/plain",
-        summary="Auto-cleanup example"
+        summary="Auto-cleanup example",
+        session_id="temp_session"
     )
     # Store automatically closed on exit
 ```
 
+## 🧪 Testing
+
+### Run All Tests
+```bash
+# Comprehensive smoke test (64+ test scenarios)
+uv run examples/artifact_smoke_test.py
+
+# Usage examples with all providers
+uv run examples/artifact_usage_examples.py
+
+# Session operations demo (NEW)
+uv run examples/session_operations_demo.py
+```
+
+### Session Security Testing
+```bash
+# Run secure session operations demo
+uv run examples/session_operations_demo.py
+
+# Output shows:
+# ✅ Cross-session copy correctly blocked
+# ✅ Cross-session move correctly blocked  
+# ✅ Cross-session overwrite correctly blocked
+# 🛡️ ALL SECURITY TESTS PASSED!
+```
+
+### Development Setup
+```python
+from chuk_artifacts.config import development_setup
+
+store = development_setup()  # Uses memory providers
+```
+
+### Testing Setup
+```python
+from chuk_artifacts.config import testing_setup
+
+store = testing_setup("./test-artifacts")  # Uses filesystem
+```
+
 ## 🔧 Configuration
 
 ### Environment Variables
@@ -328,91 +522,41 @@ configure_redis_session("redis://prod-redis:6379/1")
 store = ArtifactStore()
 ```
 
-## 🧪 Testing
-
-### Run All Tests
-```bash
-# Comprehensive smoke test (64 test scenarios)
-uv run examples/artifact_smoke_test.py
-
-# Usage examples
-uv run examples/artifact_usage_examples.py
-```
-
-### Development Setup
-```python
-from chuk_artifacts.config import development_setup
-
-store = development_setup()  # Uses memory providers
-```
-
-### Testing Setup
-```python
-from chuk_artifacts.config import testing_setup
-
-store = testing_setup("./test-artifacts")  # Uses filesystem
-```
-
 ## 🚀 Performance
 
+- **High Throughput**: 3,000+ file operations per second
 - **Async/Await**: Non-blocking I/O for high concurrency
 - **Connection Pooling**: Efficient resource usage with aioboto3
-- **Metadata Caching**: Fast lookups with Redis
+- **Metadata Caching**: Sub-millisecond lookups with Redis
 - **Batch Operations**: Reduced overhead for multiple files
 - **Streaming**: Large file support with streaming reads/writes
+- **Session Listing**: Optimized prefix-based queries
+
+### Performance Benchmarks
+```
+✅ Created 50 files in 0.02 seconds (2,933 files/sec)
+✅ Listed 50 files in 0.006 seconds
+✅ Listed directory (50 files) in 0.005 seconds  
+✅ Read 10 files in 0.002 seconds (5,375 reads/sec)
+```
 
 ## 🔒 Security
 
+- **Session Isolation**: Strict boundaries prevent cross-session access
+- **No Cross-Session Operations**: Copy, move, overwrite blocked across sessions
 - **Presigned URLs**: Time-limited access without credential sharing
 - **Secure Defaults**: Conservative TTL and expiration settings
 - **Credential Isolation**: Environment-based configuration
 - **Error Handling**: No sensitive data in logs or exceptions
+- **Multi-Tenant Ready**: Perfect for SaaS applications
 
-## 🛠️ Advanced Features
-
-### Custom Providers
-```python
-# Create custom storage provider
-def my_custom_factory():
-    @asynccontextmanager
-    async def _ctx():
-        client = MyCustomClient()
-        try:
-            yield client
-        finally:
-            await client.close()
-    return _ctx
-
-store = ArtifactStore(s3_factory=my_custom_factory())
-```
-
-### Error Handling
-```python
-from chuk_artifacts import (
-    ArtifactNotFoundError,
-    ArtifactExpiredError, 
-    ProviderError
-)
-
-try:
-    data = await store.retrieve("invalid-id")
-except ArtifactNotFoundError:
-    print("Artifact not found or expired")
-except ProviderError as e:
-    print(f"Storage provider error: {e}")
-```
-
-### Validation and Monitoring
+### Security Validation
 ```python
-# Validate configuration
-config_status = await store.validate_configuration()
-print(f"Storage: {config_status['storage']['status']}")
-print(f"Session: {config_status['session']['status']}")
-
-# Get statistics
-stats = await store.get_stats()
-print(f"Provider: {stats['storage_provider']}")
-print(f"Bucket: {stats['bucket']}")
+# All these operations are blocked for security
+await store.copy_file(user_a_file, target_session_id="user_b")  # ❌ Blocked
+await store.move_file(user_a_file, new_session_id="user_b")     # ❌ Blocked  
+await store.write_file(content, session_id="user_b", 
+                      overwrite_artifact_id=user_a_file)       # ❌ Blocked
 ```
 
 ## 📝 API Reference
@@ -422,39 +566,37 @@ print(f"Bucket: {stats['bucket']}")
 #### `store(data, *, mime, summary, meta=None, filename=None, session_id=None, ttl=900)`
 Store artifact data with metadata.
 
-**Parameters:**
-- `data` (bytes): The artifact data
-- `mime` (str): MIME type (e.g., "text/plain", "image/png")
-- `summary` (str): Human-readable description
-- `meta` (dict, optional): Additional metadata
-- `filename` (str, optional): Original filename
-- `session_id` (str, optional): Session identifier for organization
-- `ttl` (int, optional): Metadata TTL in seconds (default: 900)
-
-**Returns:** `str` - Unique artifact identifier
-
 #### `retrieve(artifact_id)`
 Retrieve artifact data by ID.
 
-**Parameters:**
-- `artifact_id` (str): The artifact identifier
-
-**Returns:** `bytes` - The artifact data
-
 #### `metadata(artifact_id)`
 Get artifact metadata.
 
-**Returns:** `dict` - Metadata including size, MIME type, timestamps, etc.
+#### `exists(artifact_id)` / `delete(artifact_id)`
+Check existence or delete artifacts.
+
+### Session Operations (NEW)
+
+#### `list_by_session(session_id, limit=100)`
+List all artifacts in a session.
+
+#### `list_by_prefix(session_id, prefix="", limit=100)`
+List artifacts with filename prefix (directory-like).
+
+#### `get_directory_contents(session_id, directory_prefix="", limit=100)`
+Get files in a directory-like structure.
 
-#### `exists(artifact_id)`
-Check if artifact exists and hasn't expired.
+#### `copy_file(artifact_id, *, new_filename=None, target_session_id=None, new_meta=None)`
+Copy file within same session only (cross-session blocked).
 
-**Returns:** `bool`
+#### `move_file(artifact_id, *, new_filename=None, new_session_id=None, new_meta=None)`
+Move/rename file within same session only (cross-session blocked).
 
-#### `delete(artifact_id)`
-Delete artifact and its metadata.
+#### `read_file(artifact_id, *, encoding="utf-8", as_text=True)`
+Read file content directly as text or binary.
 
-**Returns:** `bool` - True if deleted, False if not found
+#### `write_file(content, *, filename, mime="text/plain", session_id=None, overwrite_artifact_id=None)`
+Write content to new file or overwrite existing (within same session).
 
 ### Presigned URLs
 
@@ -467,18 +609,11 @@ Generate URLs with predefined durations (15min/1hr/24hr).
 #### `presign_upload(session_id=None, filename=None, mime_type="application/octet-stream", expires=3600)`
 Generate presigned URL for upload.
 
-**Returns:** `tuple[str, str]` - (upload_url, artifact_id)
-
 ### Batch Operations
 
 #### `store_batch(items, session_id=None, ttl=900)`
 Store multiple artifacts efficiently.
 
-**Parameters:**
-- `items` (list): List of dicts with keys: data, mime, summary, meta, filename
-
-**Returns:** `list[str]` - List of artifact IDs
-
 ### Admin Operations
 
 #### `validate_configuration()`
@@ -487,13 +622,64 @@ Validate storage and session provider connectivity.
 #### `get_stats()`
 Get storage statistics and configuration info.
 
+## 🛠️ Advanced Features
+
+### Custom Providers
+```python
+# Create custom storage provider
+def my_custom_factory():
+    @asynccontextmanager
+    async def _ctx():
+        client = MyCustomClient()
+        try:
+            yield client
+        finally:
+            await client.close()
+    return _ctx
+
+store = ArtifactStore(s3_factory=my_custom_factory())
+```
+
+### Error Handling
+```python
+from chuk_artifacts import (
+    ArtifactNotFoundError,
+    ArtifactExpiredError, 
+    ProviderError,
+    ArtifactStoreError  # NEW: for session security violations
+)
+
+try:
+    await store.copy_file(artifact_id, target_session_id="other_session")
+except ArtifactStoreError as e:
+    print(f"Security violation: {e}")
+except ArtifactNotFoundError:
+    print("Artifact not found or expired")
+except ProviderError as e:
+    print(f"Storage provider error: {e}")
+```
+
+### Validation and Monitoring
+```python
+# Validate configuration
+config_status = await store.validate_configuration()
+print(f"Storage: {config_status['storage']['status']}")
+print(f"Session: {config_status['session']['status']}")
+
+# Get statistics
+stats = await store.get_stats()
+print(f"Provider: {stats['storage_provider']}")
+print(f"Bucket: {stats['bucket']}")
+```
+
 ## 🤝 Contributing
 
 1. Fork the repository
 2. Create a feature branch: `git checkout -b feature-name`
 3. Make your changes
 4. Run tests: `uv run examples/artifact_smoke_test.py`
-5. Submit a pull request
+5. Test session operations: `uv run examples/session_operations_demo.py`
+6. Submit a pull request
 
 ## 📄 License
 
@@ -507,6 +693,9 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## 🎯 Roadmap
 
+- [x] **Session-based security** with strict isolation
+- [x] **Directory-like operations** with prefix filtering
+- [x] **High-performance operations** (3,000+ ops/sec)
 - [ ] Azure Blob Storage provider
 - [ ] Google Cloud Storage provider
 - [ ] Encryption at rest
@@ -517,3 +706,5 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 ---
 
 **Made with ❤️ by the Chuk team**
+
+*Secure, fast, and reliable artifact storage for modern applications*

{chuk_artifacts-0.1.0.dist-info → chuk_artifacts-0.1.2.dist-info}/RECORD

@@ -5,19 +5,20 @@ chuk_artifacts/batch.py,sha256=I5WgWajuzrvqTCkQYYgpzrL1WduzxJchA3Ihv3Xvhcw,4264
 chuk_artifacts/config.py,sha256=MaUzHzKPoBUyERviEpv8JVvPybMzSksgLyj0b7AO3Sc,7664
 chuk_artifacts/core.py,sha256=rS5VWjen6aRlnAIJIhLi639VfZ2u8ORaFxrPJMfpPYE,8296
 chuk_artifacts/exceptions.py,sha256=f-s7Mg7c8vMXsbgqO2B6lMHdXcJQNvsESAY4GhJaV4g,814
-chuk_artifacts/metadata.py,sha256=CXC0j-zjKSOoACmyu6yKqcQpy35otwr-Y_3ogfcuKdE,9123
+chuk_artifacts/metadata.py,sha256=cBMMwCuyRtmJHjqHWuKMbK1G-kg_G4QpfqW-7RxhIzw,11858
 chuk_artifacts/models.py,sha256=_foXlkr0DprqgztDw5WtlDc-s1OouLgYNp4XM1Ghp-g,837
 chuk_artifacts/presigned.py,sha256=qonNg7WMd7VmOEXAzF6GssXuPs5be2s8IJhtuFul7JM,9638
 chuk_artifacts/provider_factory.py,sha256=T0IXx1C8gygJzp417oB44_DxEaZoZR7jcdwQy8FghRE,3398
-chuk_artifacts/store.py,sha256=QdNyik5EXg2NthHnWxUnG5JMM1L7v2jO7phCL5WmvGg,16719
+chuk_artifacts/session_operations.py,sha256=dolSkSnm4W_9ZElZJy25RmsKuLjUnnkfH8SvZWkbW5A,14232
+chuk_artifacts/store.py,sha256=0RKSAkSfTM1v-qg3ERv3-8VaRiBVMxdGy2qxjFVz9MY,19749
 chuk_artifacts/providers/__init__.py,sha256=3lN1lAy1ETT1mQslJo1f22PPR1W4CyxmsqJBclzH4NE,317
 chuk_artifacts/providers/filesystem.py,sha256=F4EjE-_ItPg0RWe7CqameVpOMjU-b7AigEBkm_ZoNrc,15280
 chuk_artifacts/providers/ibm_cos.py,sha256=K1-VAX4UVV9tA161MOeDXOKloQ0hB77jdw1-p46FwmU,4445
 chuk_artifacts/providers/ibm_cos_iam.py,sha256=VtwvCi9rMMcZx6i9l21ob6wM8jXseqvjzgCnAA82RkY,3186
 chuk_artifacts/providers/memory.py,sha256=B1C-tR1PcNz-UuDfGm1bhjPz3oITVATIMPekVbE7nm4,10487
 chuk_artifacts/providers/s3.py,sha256=eWhBhFSaobpRbazn7ySfU_7D8rm_xCfdSVqRtzXzXRY,2858
-chuk_artifacts-0.1.0.dist-info/licenses/LICENSE,sha256=SG9BmgtPBagPV0d-Fep-msdAGl-E1CeoBL7-EDRH2qA,1066
-chuk_artifacts-0.1.0.dist-info/METADATA,sha256=G_DqvAOc5JzpuPDDdMqA1ULhTk6J588gjVVvQ9_5H9A,13847
-chuk_artifacts-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_artifacts-0.1.0.dist-info/top_level.txt,sha256=1_PVMtWXR0A-ZmeH6apF9mPaMtU0i23JE6wmN4GBRDI,15
-chuk_artifacts-0.1.0.dist-info/RECORD,,
+chuk_artifacts-0.1.2.dist-info/licenses/LICENSE,sha256=SG9BmgtPBagPV0d-Fep-msdAGl-E1CeoBL7-EDRH2qA,1066
+chuk_artifacts-0.1.2.dist-info/METADATA,sha256=RYa5j8aK37uuKQeqSp9OKpP1KGU4PoJXLUStrwq_pZY,20975
+chuk_artifacts-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_artifacts-0.1.2.dist-info/top_level.txt,sha256=1_PVMtWXR0A-ZmeH6apF9mPaMtU0i23JE6wmN4GBRDI,15
+chuk_artifacts-0.1.2.dist-info/RECORD,,