chuk-artifacts 0.1.3__py3-none-any.whl → 0.1.5__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,6 +21,10 @@ class AdminOperations:
     """Handles administrative and debugging operations."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
+        # canonical reference
+        self.artifact_store = artifact_store
+
+        # backward-compat/consistency with other ops modules
         self.store = artifact_store
 
     async def validate_configuration(self) -> Dict[str, Any]:
@@ -28,7 +33,7 @@ class AdminOperations:
         
         # Test session provider
         try:
-            session_ctx_mgr = self.store._session_factory()
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 # Test basic operations
                 test_key = f"test_{uuid.uuid4().hex}"
@@ -38,48 +43,119 @@ class AdminOperations:
                 if value == "test_value":
                     results["session"] = {
                         "status": "ok", 
-                        "provider": self.store._session_provider_name
+                        "provider": self.artifact_store._session_provider_name
                     }
                 else:
                     results["session"] = {
                         "status": "error", 
                         "message": "Session store test failed",
-                        "provider": self.store._session_provider_name
+                        "provider": self.artifact_store._session_provider_name
                     }
         except Exception as e:
             results["session"] = {
                 "status": "error", 
                 "message": str(e),
-                "provider": self.store._session_provider_name
+                "provider": self.artifact_store._session_provider_name
             }
         
         # Test storage provider
         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.head_bucket(Bucket=self.store.bucket)
+                await s3.head_bucket(Bucket=self.artifact_store.bucket)
             results["storage"] = {
                 "status": "ok", 
-                "bucket": self.store.bucket, 
-                "provider": self.store._storage_provider_name
+                "bucket": self.artifact_store.bucket, 
+                "provider": self.artifact_store._storage_provider_name
             }
         except Exception as e:
             results["storage"] = {
                 "status": "error", 
                 "message": str(e), 
-                "provider": self.store._storage_provider_name
+                "provider": self.artifact_store._storage_provider_name
+            }
+        
+        # Test session manager (chuk_sessions)
+        try:
+            # Try to allocate a test session
+            test_session = await self.artifact_store._session_manager.allocate_session(
+                user_id="test_admin_user"
+            )
+            # Validate it
+            is_valid = await self.artifact_store._session_manager.validate_session(test_session)
+            # Clean up
+            await self.artifact_store._session_manager.delete_session(test_session)
+            
+            if is_valid:
+                results["session_manager"] = {
+                    "status": "ok",
+                    "sandbox_id": self.artifact_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."""
+        base_stats = {
+            "storage_provider": self.artifact_store._storage_provider_name,
+            "session_provider": self.artifact_store._session_provider_name,
+            "bucket": self.artifact_store.bucket,
+            "max_retries": self.artifact_store.max_retries,
+            "closed": self.artifact_store._closed,
+            "sandbox_id": self.artifact_store.sandbox_id,
+            "session_ttl_hours": self.artifact_store.session_ttl_hours,
+        }
+        
+        # Add session manager stats from chuk_sessions
+        try:
+            session_stats = self.artifact_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.artifact_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 {
-            "storage_provider": self.store._storage_provider_name,
-            "session_provider": self.store._session_provider_name,
-            "bucket": self.store.bucket,
-            "max_retries": self.store.max_retries,
-            "closed": self.store._closed,
-            "sandbox_id": self.store.sandbox_id,
-            "session_ttl_hours": self.store.session_ttl_hours,
+            "sandbox_id": self.artifact_store.sandbox_id,
+            "session_prefix_pattern": self.artifact_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,16 +14,16 @@ 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
+        self.artifact_store = artifact_store
 
     async def get_metadata(self, artifact_id: str) -> Dict[str, Any]:
         """Get artifact metadata."""
@@ -42,15 +43,15 @@ class MetadataOperations:
             record = await self._get_record(artifact_id)
             
             # Delete from storage
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 await s3.delete_object(
-                    Bucket=self.store.bucket, 
+                    Bucket=self.artifact_store.bucket, 
                     Key=record["key"]
                 )
             
-            # Delete metadata
-            session_ctx_mgr = self.store._session_factory()
+            # Delete metadata from session provider
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 if hasattr(session, 'delete'):
                     await session.delete(artifact_id)
@@ -63,26 +64,27 @@ 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.artifact_store._session_manager.get_canonical_prefix(session_id)
             
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 if hasattr(s3, 'list_objects_v2'):
                     response = await s3.list_objects_v2(
-                        Bucket=self.store.bucket,
+                        Bucket=self.artifact_store.bucket,
                         Prefix=prefix,
                         MaxKeys=limit
                     )
                     
                     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.artifact_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,8 +157,8 @@ class MetadataOperations:
                 if key not in ["summary", "meta"] and value is not None:
                     record[key] = value
             
-            # Store updated record
-            session_ctx_mgr = self.store._session_factory()
+            # Store updated record using session provider
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, record.get("ttl", 900), json.dumps(record))
             
@@ -181,8 +183,8 @@ class MetadataOperations:
             new_ttl = current_ttl + additional_seconds
             record["ttl"] = new_ttl
             
-            # Store updated record with new TTL
-            session_ctx_mgr = self.store._session_factory()
+            # Store updated record with new TTL using session provider
+            session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, new_ttl, json.dumps(record))
             
@@ -193,16 +195,16 @@ 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()
+            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:
             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)