chuk-artifacts 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

chuk_artifacts/admin.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/admin.py
 """
-Administrative and debugging operations
+Administrative and debugging operations.
+Now includes chuk_sessions integration.
 """
 
 from __future__ import annotations
@@ -20,7 +21,7 @@ class AdminOperations:
     """Handles administrative and debugging operations."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
-        self.store = artifact_store
+        self.artifact_store = artifact_store
 
     async def validate_configuration(self) -> Dict[str, Any]:
         """Validate store configuration and connectivity."""
@@ -70,11 +71,39 @@ class AdminOperations:
                 "provider": self.store._storage_provider_name
             }
         
+        # Test session manager (chuk_sessions)
+        try:
+            # Try to allocate a test session
+            test_session = await self.store._session_manager.allocate_session(
+                user_id="test_admin_user"
+            )
+            # Validate it
+            is_valid = await self.store._session_manager.validate_session(test_session)
+            # Clean up
+            await self.store._session_manager.delete_session(test_session)
+            
+            if is_valid:
+                results["session_manager"] = {
+                    "status": "ok",
+                    "sandbox_id": self.store.sandbox_id,
+                    "test_session": test_session
+                }
+            else:
+                results["session_manager"] = {
+                    "status": "error",
+                    "message": "Session validation failed"
+                }
+        except Exception as e:
+            results["session_manager"] = {
+                "status": "error",
+                "message": str(e)
+            }
+        
         return results
 
     async def get_stats(self) -> Dict[str, Any]:
         """Get storage statistics."""
-        return {
+        base_stats = {
             "storage_provider": self.store._storage_provider_name,
             "session_provider": self.store._session_provider_name,
             "bucket": self.store.bucket,
@@ -82,4 +111,47 @@ class AdminOperations:
             "closed": self.store._closed,
             "sandbox_id": self.store.sandbox_id,
             "session_ttl_hours": self.store.session_ttl_hours,
+        }
+        
+        # Add session manager stats from chuk_sessions
+        try:
+            session_stats = self.store._session_manager.get_cache_stats()
+            base_stats["session_manager"] = session_stats
+        except Exception as e:
+            base_stats["session_manager"] = {
+                "error": str(e),
+                "status": "unavailable"
+            }
+        
+        return base_stats
+
+    async def cleanup_all_expired(self) -> Dict[str, int]:
+        """Clean up all expired resources."""
+        results = {"timestamp": datetime.utcnow().isoformat() + "Z"}
+        
+        # Clean up expired sessions using chuk_sessions
+        try:
+            expired_sessions = await self.store._session_manager.cleanup_expired_sessions()
+            results["expired_sessions_cleaned"] = expired_sessions
+        except Exception as e:
+            results["session_cleanup_error"] = str(e)
+            results["expired_sessions_cleaned"] = 0
+        
+        # TODO: Add artifact cleanup based on TTL
+        # This would require scanning metadata to find expired artifacts
+        results["expired_artifacts_cleaned"] = 0  # Placeholder
+        
+        return results
+
+    async def get_sandbox_info(self) -> Dict[str, Any]:
+        """Get information about the current sandbox."""
+        return {
+            "sandbox_id": self.store.sandbox_id,
+            "session_prefix_pattern": self.store.get_session_prefix_pattern(),
+            "grid_architecture": {
+                "enabled": True,
+                "pattern": "grid/{sandbox_id}/{session_id}/{artifact_id}",
+                "mandatory_sessions": True,
+                "federation_ready": True
+            }
         }

chuk_artifacts/base.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/base.py
 """
-base class for operation modules
+Base class for operation modules.
+Updated to work with chuk_sessions integration.
 """
 
 from __future__ import annotations
@@ -17,10 +18,10 @@ logger = logging.getLogger(__name__)
 
 
 class BaseOperations:
-    """Fixed base class for all operation modules."""
+    """Base class for all operation modules."""
     
     def __init__(self, store: 'ArtifactStore'):
-        # FIXED: Renamed from self.store to self._artifact_store to avoid method name conflicts
+        # Store reference to artifact store
         self._artifact_store = store
     
     @property
@@ -47,6 +48,11 @@ class BaseOperations:
     def max_retries(self) -> int:
         return self._artifact_store.max_retries
     
+    @property
+    def session_manager(self):
+        """Access to chuk_sessions SessionManager."""
+        return self._artifact_store._session_manager
+    
     def _check_closed(self):
         """Check if store is closed and raise error if so."""
         if self._artifact_store._closed:

chuk_artifacts/batch.py

@@ -1,28 +1,32 @@
-# ===========================================================================
-# chuk_artifacts/batch.py - Batch operations
-# ===========================================================================
+# -*- coding: utf-8 -*-
+# chuk_artifacts/batch.py
 """
 Batch operations for multiple artifacts.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
 
-import uuid, hashlib, json, logging
+import uuid, hashlib, json, logging, asyncio
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
-from .base import BaseOperations
-from .exceptions import ArtifactStoreError
+if TYPE_CHECKING:
+    from .store import ArtifactStore
+
+from .exceptions import ArtifactStoreError, ProviderError, SessionError
 
 logger = logging.getLogger(__name__)
 
-_ANON_PREFIX = "anon"
 _DEFAULT_TTL = 900
 
 
-class BatchOperations(BaseOperations):
+class BatchOperations:
     """Handles batch operations for multiple artifacts."""
 
+    def __init__(self, artifact_store: 'ArtifactStore'):
+        self.artifact_store = artifact_store
+
     async def store_batch(
         self,
         items: List[Dict[str, Any]],
@@ -30,7 +34,14 @@ class BatchOperations(BaseOperations):
         ttl: int = _DEFAULT_TTL,
     ) -> List[str]:
         """Store multiple artifacts in a batch operation."""
-        self._check_closed()
+        if self.artifact_store._closed:
+            raise ArtifactStoreError("Store is closed")
+        
+        # Ensure session is allocated using chuk_sessions
+        if session_id is None:
+            session_id = await self.artifact_store._session_manager.allocate_session()
+        else:
+            session_id = await self.artifact_store._session_manager.allocate_session(session_id=session_id)
         
         artifact_ids = []
         failed_items = []
@@ -38,18 +49,19 @@ class BatchOperations(BaseOperations):
         for i, item in enumerate(items):
             try:
                 artifact_id = uuid.uuid4().hex
-                scope = session_id or f"{_ANON_PREFIX}_{artifact_id}"
-                key = f"sess/{scope}/{artifact_id}"
+                key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
                 
                 # Store in object storage
                 await self._store_with_retry(
                     item["data"], key, item["mime"], 
-                    item.get("filename"), scope
+                    item.get("filename"), session_id
                 )
                 
                 # Prepare metadata record
                 record = {
-                    "scope": scope,
+                    "artifact_id": artifact_id,
+                    "session_id": session_id,
+                    "sandbox_id": self.artifact_store.sandbox_id,
                     "key": key,
                     "mime": item["mime"],
                     "summary": item["summary"],
@@ -57,14 +69,16 @@ class BatchOperations(BaseOperations):
                     "filename": item.get("filename"),
                     "bytes": len(item["data"]),
                     "sha256": hashlib.sha256(item["data"]).hexdigest(),
-                    "stored_at": datetime.utcnow().isoformat(timespec="seconds") + "Z",
+                    "stored_at": datetime.utcnow().isoformat() + "Z",
                     "ttl": ttl,
-                    "storage_provider": self.storage_provider_name,
-                    "session_provider": self.session_provider_name,
+                    "storage_provider": self.artifact_store._storage_provider_name,
+                    "session_provider": self.artifact_store._session_provider_name,
+                    "batch_operation": True,
+                    "batch_index": i,
                 }
                 
                 # Store metadata via session provider
-                session_ctx_mgr = self.session_factory()
+                session_ctx_mgr = self.artifact_store._session_factory()
                 async with session_ctx_mgr as session:
                     await session.setex(artifact_id, ttl, json.dumps(record))
                 
@@ -80,28 +94,30 @@ class BatchOperations(BaseOperations):
         
         return artifact_ids
 
-    async def _store_with_retry(self, data: bytes, key: str, mime: str, filename: str, scope: str):
+    async def _store_with_retry(self, data: bytes, key: str, mime: str, filename: str, session_id: str):
         """Store data with retry logic (copied from core for batch operations)."""
-        import asyncio
-        
         last_exception = None
         
-        for attempt in range(self.max_retries):
+        for attempt in range(self.artifact_store.max_retries):
             try:
-                storage_ctx_mgr = self.s3_factory()
+                storage_ctx_mgr = self.artifact_store._s3_factory()
                 async with storage_ctx_mgr as s3:
                     await s3.put_object(
-                        Bucket=self.bucket,
+                        Bucket=self.artifact_store.bucket,
                         Key=key,
                         Body=data,
                         ContentType=mime,
-                        Metadata={"filename": filename or "", "scope": scope},
+                        Metadata={
+                            "filename": filename or "", 
+                            "session_id": session_id,
+                            "sandbox_id": self.artifact_store.sandbox_id,
+                        },
                     )
                 return  # Success
                 
             except Exception as e:
                 last_exception = e
-                if attempt < self.max_retries - 1:
+                if attempt < self.artifact_store.max_retries - 1:
                     wait_time = 2 ** attempt  # Exponential backoff
                     logger.warning(
                         f"Batch storage attempt {attempt + 1} failed, retrying in {wait_time}s",
@@ -109,7 +125,6 @@ class BatchOperations(BaseOperations):
                     )
                     await asyncio.sleep(wait_time)
                 else:
-                    logger.error(f"All {self.max_retries} batch storage attempts failed")
+                    logger.error(f"All {self.artifact_store.max_retries} batch storage attempts failed")
         
-        raise last_exception
-
+        raise last_exception

chuk_artifacts/core.py

@@ -2,6 +2,7 @@
 # chuk_artifacts/core.py
 """
 Clean core storage operations - grid architecture only.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
@@ -29,7 +30,7 @@ class CoreStorageOperations:
     """Clean core storage operations with grid architecture."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
-        self.store = artifact_store
+        self.artifact_store = artifact_store
 
     async def store(
         self,
@@ -43,14 +44,14 @@ class CoreStorageOperations:
         ttl: int = _DEFAULT_TTL,
     ) -> str:
         """Store artifact with grid key generation."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         artifact_id = uuid.uuid4().hex
         
-        # Generate grid key
-        key = self.store.generate_artifact_key(session_id, artifact_id)
+        # Generate grid key using chuk_sessions
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
         
         try:
             # Store in object storage
@@ -60,7 +61,7 @@ class CoreStorageOperations:
             record = {
                 "artifact_id": artifact_id,
                 "session_id": session_id,
-                "sandbox_id": self.store.sandbox_id,
+                "sandbox_id": self.artifact_store.sandbox_id,
                 "key": key,
                 "mime": mime,
                 "summary": summary,
@@ -70,12 +71,12 @@ class CoreStorageOperations:
                 "sha256": hashlib.sha256(data).hexdigest(),
                 "stored_at": datetime.utcnow().isoformat() + "Z",
                 "ttl": ttl,
-                "storage_provider": self.store._storage_provider_name,
-                "session_provider": self.store._session_provider_name,
+                "storage_provider": self.artifact_store._storage_provider_name,
+                "session_provider": self.artifact_store._session_provider_name,
             }
             
             # Store metadata
-            session_ctx_mgr = self.store._session_factory()
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, ttl, json.dumps(record))
             
@@ -102,16 +103,16 @@ class CoreStorageOperations:
 
     async def retrieve(self, artifact_id: str) -> bytes:
         """Retrieve artifact data."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         try:
             record = await self._get_record(artifact_id)
             
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 response = await s3.get_object(
-                    Bucket=self.store.bucket, 
+                    Bucket=self.artifact_store.bucket, 
                     Key=record["key"]
                 )
                 
@@ -146,26 +147,26 @@ class CoreStorageOperations:
         """Store with retry logic."""
         last_exception = None
         
-        for attempt in range(self.store.max_retries):
+        for attempt in range(self.artifact_store.max_retries):
             try:
-                storage_ctx_mgr = self.store._s3_factory()
+                storage_ctx_mgr = self.artifact_store._s3_factory()
                 async with storage_ctx_mgr as s3:
                     await s3.put_object(
-                        Bucket=self.store.bucket,
+                        Bucket=self.artifact_store.bucket,
                         Key=key,
                         Body=data,
                         ContentType=mime,
                         Metadata={
                             "filename": filename or "",
                             "session_id": session_id,
-                            "sandbox_id": self.store.sandbox_id,
+                            "sandbox_id": self.artifact_store.sandbox_id,
                         },
                     )
                 return  # Success
                 
             except Exception as e:
                 last_exception = e
-                if attempt < self.store.max_retries - 1:
+                if attempt < self.artifact_store.max_retries - 1:
                     wait_time = 2 ** attempt
                     await asyncio.sleep(wait_time)
         
@@ -174,7 +175,7 @@ class CoreStorageOperations:
     async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
         """Get artifact metadata."""
         try:
-            session_ctx_mgr = self.store._session_factory()
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 raw = await session.get(artifact_id)
         except Exception as e:

chuk_artifacts/metadata.py

@@ -2,6 +2,7 @@
 # chuk_artifacts/metadata.py
 """
 Clean metadata operations for grid architecture.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
@@ -13,13 +14,13 @@ from typing import Any, Dict, List, Optional, TYPE_CHECKING
 if TYPE_CHECKING:
     from .store import ArtifactStore
 
-from .exceptions import ProviderError, SessionError
+from .exceptions import ProviderError, SessionError, ArtifactNotFoundError
 
 logger = logging.getLogger(__name__)
 
 
 class MetadataOperations:
-    """Clean metadata operations for grid architecture."""
+    """Clean metadata operations for grid architecture using chuk_sessions."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
         self.store = artifact_store
@@ -49,7 +50,7 @@ class MetadataOperations:
                     Key=record["key"]
                 )
             
-            # Delete metadata
+            # Delete metadata from session provider
             session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 if hasattr(session, 'delete'):
@@ -63,10 +64,11 @@ class MetadataOperations:
             return False
 
     async def list_by_session(self, session_id: str, limit: int = 100) -> List[Dict[str, Any]]:
-        """List artifacts in a session using grid prefix."""
+        """List artifacts in a session using grid prefix from chuk_sessions."""
         try:
             artifacts = []
-            prefix = f"grid/{self.store.sandbox_id}/{session_id}/"
+            # Use the session manager's canonical prefix instead of building our own
+            prefix = self.store._session_manager.get_canonical_prefix(session_id)
             
             storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
@@ -79,10 +81,10 @@ class MetadataOperations:
                     
                     for obj in response.get('Contents', []):
                         key = obj['Key']
-                        # Extract artifact ID from key
-                        parts = key.split('/')
-                        if len(parts) >= 4:  # grid/sandbox/session/artifact_id
-                            artifact_id = parts[3]
+                        # Parse the grid key using chuk_sessions
+                        parsed = self.store._session_manager.parse_grid_key(key)
+                        if parsed and parsed.get('artifact_id'):
+                            artifact_id = parsed['artifact_id']
                             try:
                                 record = await self._get_record(artifact_id)
                                 artifacts.append(record)
@@ -155,7 +157,7 @@ class MetadataOperations:
                 if key not in ["summary", "meta"] and value is not None:
                     record[key] = value
             
-            # Store updated record
+            # Store updated record using session provider
             session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, record.get("ttl", 900), json.dumps(record))
@@ -181,7 +183,7 @@ class MetadataOperations:
             new_ttl = current_ttl + additional_seconds
             record["ttl"] = new_ttl
             
-            # Store updated record with new TTL
+            # Store updated record with new TTL using session provider
             session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, new_ttl, json.dumps(record))
@@ -193,7 +195,7 @@ class MetadataOperations:
             raise ProviderError(f"TTL extension failed: {e}") from e
 
     async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
-        """Get artifact metadata record."""
+        """Get artifact metadata record from session provider."""
         try:
             session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
@@ -202,7 +204,7 @@ class MetadataOperations:
             raise SessionError(f"Session error for {artifact_id}: {e}") from e
         
         if raw is None:
-            raise ProviderError(f"Artifact {artifact_id} not found")
+            raise ArtifactNotFoundError(f"Artifact {artifact_id} not found")
         
         try:
             return json.loads(raw)

chuk_artifacts/presigned.py

@@ -2,6 +2,7 @@
 # chuk_artifacts/presigned.py
 """
 Presigned URL operations: download URLs, upload URLs, and upload registration.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
@@ -28,11 +29,11 @@ class PresignedURLOperations:
     """Handles all presigned URL operations."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
-        self.store = artifact_store
+        self.artifact_store = artifact_store
 
     async def presign(self, artifact_id: str, expires: int = _DEFAULT_PRESIGN_EXPIRES) -> str:
         """Generate a presigned URL for artifact download."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
@@ -40,11 +41,11 @@ class PresignedURLOperations:
         try:
             record = await self._get_record(artifact_id)
             
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 url = await s3.generate_presigned_url(
                     "get_object",
-                    Params={"Bucket": self.store.bucket, "Key": record["key"]},
+                    Params={"Bucket": self.artifact_store.bucket, "Key": record["key"]},
                     ExpiresIn=expires,
                 )
                 
@@ -101,28 +102,28 @@ class PresignedURLOperations:
         expires: int = _DEFAULT_PRESIGN_EXPIRES
     ) -> tuple[str, str]:
         """Generate a presigned URL for uploading a new artifact."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
-        # Ensure session is allocated
+        # Ensure session is allocated using chuk_sessions
         if session_id is None:
-            session_id = await self.store._session_manager.allocate_session()
+            session_id = await self.artifact_store._session_manager.allocate_session()
         else:
-            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+            session_id = await self.artifact_store._session_manager.allocate_session(session_id=session_id)
         
         # Generate artifact ID and key path
         artifact_id = uuid.uuid4().hex
-        key = self.store.generate_artifact_key(session_id, artifact_id)
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
         
         try:
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 url = await s3.generate_presigned_url(
                     "put_object",
                     Params={
-                        "Bucket": self.store.bucket, 
+                        "Bucket": self.artifact_store.bucket, 
                         "Key": key,
                         "ContentType": mime_type
                     },
@@ -174,26 +175,26 @@ class PresignedURLOperations:
         ttl: int = _DEFAULT_TTL,
     ) -> bool:
         """Register metadata for an artifact uploaded via presigned URL."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
-        # Ensure session is allocated
+        # Ensure session is allocated using chuk_sessions
         if session_id is None:
-            session_id = await self.store._session_manager.allocate_session()
+            session_id = await self.artifact_store._session_manager.allocate_session()
         else:
-            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+            session_id = await self.artifact_store._session_manager.allocate_session(session_id=session_id)
         
         # Reconstruct the key path
-        key = self.store.generate_artifact_key(session_id, artifact_id)
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
         
         try:
             # Verify the object exists and get its size
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 try:
-                    response = await s3.head_object(Bucket=self.store.bucket, Key=key)
+                    response = await s3.head_object(Bucket=self.artifact_store.bucket, Key=key)
                     file_size = response.get('ContentLength', 0)
                 except Exception:
                     logger.warning(f"Artifact {artifact_id} not found in storage")
@@ -203,7 +204,7 @@ class PresignedURLOperations:
             record = {
                 "artifact_id": artifact_id,
                 "session_id": session_id,
-                "sandbox_id": self.store.sandbox_id,
+                "sandbox_id": self.artifact_store.sandbox_id,
                 "key": key,
                 "mime": mime,
                 "summary": summary,
@@ -213,13 +214,13 @@ class PresignedURLOperations:
                 "sha256": None,  # We don't have the hash since we didn't upload it directly
                 "stored_at": datetime.utcnow().isoformat() + "Z",
                 "ttl": ttl,
-                "storage_provider": self.store._storage_provider_name,
-                "session_provider": self.store._session_provider_name,
+                "storage_provider": self.artifact_store._storage_provider_name,
+                "session_provider": self.artifact_store._session_provider_name,
                 "uploaded_via_presigned": True,  # Flag to indicate upload method
             }
 
             # Cache metadata using session provider
-            session_ctx_mgr = self.store._session_factory()
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, ttl, json.dumps(record))
 
@@ -288,7 +289,7 @@ class PresignedURLOperations:
     async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
         """Get artifact metadata record."""
         try:
-            session_ctx_mgr = self.store._session_factory()
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 raw = await session.get(artifact_id)
         except Exception as e: