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

chuk_artifacts/admin.py

@@ -1,22 +1,27 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/admin.py
 """
-Administrative and debugging operations
+Administrative and debugging operations.
+Now includes chuk_sessions integration.
 """
 
 from __future__ import annotations
 
 import uuid, logging
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any, Dict, TYPE_CHECKING
 
-from .base import BaseOperations
+if TYPE_CHECKING:
+    from .store import ArtifactStore
 
 logger = logging.getLogger(__name__)
 
 
-class AdminOperations(BaseOperations):
-    """FIXED: Handles administrative and debugging operations."""
+class AdminOperations:
+    """Handles administrative and debugging operations."""
+
+    def __init__(self, artifact_store: 'ArtifactStore'):
+        self.artifact_store = artifact_store
 
     async def validate_configuration(self) -> Dict[str, Any]:
         """Validate store configuration and connectivity."""
@@ -24,7 +29,7 @@ class AdminOperations(BaseOperations):
         
         # Test session provider
         try:
-            session_ctx_mgr = self.session_factory()
+            session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 # Test basic operations
                 test_key = f"test_{uuid.uuid4().hex}"
@@ -34,46 +39,119 @@ class AdminOperations(BaseOperations):
                 if value == "test_value":
                     results["session"] = {
                         "status": "ok", 
-                        "provider": self.session_provider_name
+                        "provider": self.store._session_provider_name
                     }
                 else:
                     results["session"] = {
                         "status": "error", 
                         "message": "Session store test failed",
-                        "provider": self.session_provider_name
+                        "provider": self.store._session_provider_name
                     }
         except Exception as e:
             results["session"] = {
                 "status": "error", 
                 "message": str(e),
-                "provider": self.session_provider_name
+                "provider": self.store._session_provider_name
             }
         
         # Test storage provider
         try:
-            storage_ctx_mgr = self.s3_factory()
+            storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
-                await s3.head_bucket(Bucket=self.bucket)
+                await s3.head_bucket(Bucket=self.store.bucket)
             results["storage"] = {
                 "status": "ok", 
-                "bucket": self.bucket, 
-                "provider": self.storage_provider_name
+                "bucket": self.store.bucket, 
+                "provider": self.store._storage_provider_name
             }
         except Exception as e:
             results["storage"] = {
                 "status": "error", 
                 "message": str(e), 
-                "provider": self.storage_provider_name
+                "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."""
+        base_stats = {
+            "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,
+        }
+        
+        # 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 {
-            "storage_provider": self.storage_provider_name,
-            "session_provider": self.session_provider_name,
-            "bucket": self.bucket,
-            "max_retries": self.max_retries,
-            "closed": self._artifact_store._closed,  # FIXED: Updated reference
+            "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

@@ -1,35 +1,36 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/core.py
 """
-core storage operations.
+Clean core storage operations - grid architecture only.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
 
-import uuid, hashlib, time, asyncio, logging, json
+import uuid
+import hashlib
+import time
+import asyncio
+import json
+import logging
 from datetime import datetime
 from typing import Any, Dict, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .store import ArtifactStore
 
-from .exceptions import (
-    ArtifactStoreError, ArtifactNotFoundError, ArtifactExpiredError, 
-    ArtifactCorruptedError, ProviderError, SessionError
-)
+from .exceptions import ArtifactStoreError, ProviderError, SessionError
 
 logger = logging.getLogger(__name__)
 
-_ANON_PREFIX = "anon"
 _DEFAULT_TTL = 900
 
 
 class CoreStorageOperations:
-    """core storage operations without BaseOperations inheritance."""
+    """Clean core storage operations with grid architecture."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
-        self.artifact_store = artifact_store  # Renamed to avoid conflicts
-        logger.info(f"CoreStorageOperations initialized with store: {type(artifact_store)}")
+        self.artifact_store = artifact_store
 
     async def store(
         self,
@@ -39,26 +40,28 @@ class CoreStorageOperations:
         summary: str,
         meta: Dict[str, Any] | None = None,
         filename: str | None = None,
-        session_id: str | None = None,
+        session_id: str,  # Required - no more optional sessions
         ttl: int = _DEFAULT_TTL,
     ) -> str:
-        """Store artifact data with metadata."""
+        """Store artifact with grid key generation."""
         if self.artifact_store._closed:
-            raise ArtifactStoreError("Store has been closed")
+            raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         artifact_id = uuid.uuid4().hex
         
-        scope = session_id or f"{_ANON_PREFIX}_{artifact_id}"
-        key = f"sess/{scope}/{artifact_id}"
-
+        # Generate grid key using chuk_sessions
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
+        
         try:
-            # Store in object storage with retries
-            await self._store_with_retry(data, key, mime, filename, scope)
-
+            # Store in object storage
+            await self._store_with_retry(data, key, mime, filename, session_id)
+            
             # Build metadata record
             record = {
-                "scope": scope,
+                "artifact_id": artifact_id,
+                "session_id": session_id,
+                "sandbox_id": self.artifact_store.sandbox_id,
                 "key": key,
                 "mime": mime,
                 "summary": summary,
@@ -66,95 +69,54 @@ class CoreStorageOperations:
                 "filename": filename,
                 "bytes": len(data),
                 "sha256": hashlib.sha256(data).hexdigest(),
-                "stored_at": datetime.utcnow().isoformat(timespec="seconds") + "Z",
+                "stored_at": datetime.utcnow().isoformat() + "Z",
                 "ttl": ttl,
                 "storage_provider": self.artifact_store._storage_provider_name,
                 "session_provider": self.artifact_store._session_provider_name,
             }
-
-            # Cache metadata using session provider
+            
+            # Store metadata
             session_ctx_mgr = self.artifact_store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, ttl, json.dumps(record))
-
+            
             duration_ms = int((time.time() - start_time) * 1000)
             logger.info(
-                "Artifact stored successfully",
+                "Artifact stored",
                 extra={
                     "artifact_id": artifact_id,
+                    "session_id": session_id,
+                    "key": key,
                     "bytes": len(data),
-                    "mime": mime,
                     "duration_ms": duration_ms,
-                    "storage_provider": self.artifact_store._storage_provider_name,
                 }
             )
-
+            
             return artifact_id
-
-        except Exception as e:
-            duration_ms = int((time.time() - start_time) * 1000)
-            logger.error(
-                "Artifact storage failed",
-                extra={
-                    "artifact_id": artifact_id,
-                    "error": str(e),
-                    "duration_ms": duration_ms,
-                    "storage_provider": self.artifact_store._storage_provider_name,
-                },
-                exc_info=True
-            )
             
-            if "session" in str(e).lower() or "redis" in str(e).lower():
-                raise SessionError(f"Metadata caching failed: {e}") from e
+        except Exception as e:
+            logger.error(f"Storage failed for {artifact_id}: {e}")
+            if "session" in str(e).lower():
+                raise SessionError(f"Metadata storage failed: {e}") from e
             else:
-                raise ProviderError(f"Storage operation failed: {e}") from e
-
-    async def _store_with_retry(self, data: bytes, key: str, mime: str, filename: str, scope: str):
-        """Store data with retry logic."""
-        last_exception = None
-        
-        for attempt in range(self.artifact_store.max_retries):
-            try:
-                storage_ctx_mgr = self.artifact_store._s3_factory()
-                async with storage_ctx_mgr as s3:
-                    await s3.put_object(
-                        Bucket=self.artifact_store.bucket,
-                        Key=key,
-                        Body=data,
-                        ContentType=mime,
-                        Metadata={"filename": filename or "", "scope": scope},
-                    )
-                return  # Success
-                
-            except Exception as e:
-                last_exception = e
-                if attempt < self.artifact_store.max_retries - 1:
-                    wait_time = 2 ** attempt  # Exponential backoff
-                    logger.warning(
-                        f"Storage attempt {attempt + 1} failed, retrying in {wait_time}s",
-                        extra={"error": str(e), "attempt": attempt + 1}
-                    )
-                    await asyncio.sleep(wait_time)
-                else:
-                    logger.error(f"All {self.artifact_store.max_retries} storage attempts failed")
-        
-        raise last_exception
+                raise ProviderError(f"Storage failed: {e}") from e
 
     async def retrieve(self, artifact_id: str) -> bytes:
-        """Retrieve artifact data directly."""
+        """Retrieve artifact data."""
         if self.artifact_store._closed:
-            raise ArtifactStoreError("Store has been closed")
-        
-        start_time = time.time()
+            raise ArtifactStoreError("Store is closed")
         
         try:
             record = await self._get_record(artifact_id)
             
             storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
-                response = await s3.get_object(Bucket=self.artifact_store.bucket, Key=record["key"])
+                response = await s3.get_object(
+                    Bucket=self.artifact_store.bucket, 
+                    Key=record["key"]
+                )
                 
-                # Handle different response formats from different providers
+                # Handle different response formats
                 if hasattr(response["Body"], "read"):
                     data = await response["Body"].read()
                 elif isinstance(response["Body"], bytes):
@@ -162,54 +124,67 @@ class CoreStorageOperations:
                 else:
                     data = bytes(response["Body"])
                 
-                # Verify integrity if SHA256 is available
+                # Verify integrity
                 if "sha256" in record and record["sha256"]:
-                    computed_hash = hashlib.sha256(data).hexdigest()
-                    if computed_hash != record["sha256"]:
-                        raise ArtifactCorruptedError(
-                            f"SHA256 mismatch: expected {record['sha256']}, got {computed_hash}"
-                        )
-                
-                duration_ms = int((time.time() - start_time) * 1000)
-                logger.info(
-                    "Artifact retrieved successfully",
-                    extra={
-                        "artifact_id": artifact_id,
-                        "bytes": len(data),
-                        "duration_ms": duration_ms,
-                    }
-                )
+                    computed = hashlib.sha256(data).hexdigest()
+                    if computed != record["sha256"]:
+                        raise ProviderError(f"SHA256 mismatch: {record['sha256']} != {computed}")
                 
                 return data
                 
-        except (ArtifactNotFoundError, ArtifactExpiredError, ArtifactCorruptedError):
-            raise
         except Exception as e:
-            duration_ms = int((time.time() - start_time) * 1000)
-            logger.error(
-                "Artifact retrieval failed",
-                extra={
-                    "artifact_id": artifact_id,
-                    "error": str(e),
-                    "duration_ms": duration_ms,
-                }
-            )
+            logger.error(f"Retrieval failed for {artifact_id}: {e}")
             raise ProviderError(f"Retrieval failed: {e}") from e
 
+    async def _store_with_retry(
+        self, 
+        data: bytes, 
+        key: str, 
+        mime: str, 
+        filename: str, 
+        session_id: str
+    ):
+        """Store with retry logic."""
+        last_exception = None
+        
+        for attempt in range(self.artifact_store.max_retries):
+            try:
+                storage_ctx_mgr = self.artifact_store._s3_factory()
+                async with storage_ctx_mgr as s3:
+                    await s3.put_object(
+                        Bucket=self.artifact_store.bucket,
+                        Key=key,
+                        Body=data,
+                        ContentType=mime,
+                        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.artifact_store.max_retries - 1:
+                    wait_time = 2 ** attempt
+                    await asyncio.sleep(wait_time)
+        
+        raise last_exception
+
     async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
-        """Retrieve artifact metadata from session provider."""
+        """Get artifact metadata."""
         try:
             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 provider error retrieving {artifact_id}: {e}") from e
+            raise SessionError(f"Session error for {artifact_id}: {e}") from e
         
         if raw is None:
-            raise ArtifactNotFoundError(f"Artifact {artifact_id} not found or expired")
+            raise ProviderError(f"Artifact {artifact_id} not found")
         
         try:
             return json.loads(raw)
         except json.JSONDecodeError as e:
-            logger.error(f"Corrupted metadata for artifact {artifact_id}: {e}")
-            raise ArtifactCorruptedError(f"Corrupted metadata for artifact {artifact_id}") from e
+            raise ProviderError(f"Corrupted metadata for {artifact_id}") from e