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

chuk_artifacts/admin.py

@@ -8,15 +8,19 @@ 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.store = artifact_store
 
     async def validate_configuration(self) -> Dict[str, Any]:
         """Validate store configuration and connectivity."""
@@ -24,7 +28,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,36 +38,36 @@ 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
             }
         
         return results
@@ -71,9 +75,11 @@ class AdminOperations(BaseOperations):
     async def get_stats(self) -> Dict[str, Any]:
         """Get storage statistics."""
         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
+            "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,
         }

chuk_artifacts/core.py

@@ -1,35 +1,35 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/core.py
 """
-core storage operations.
+Clean core storage operations - grid architecture only.
 """
 
 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.store = artifact_store
 
     async def store(
         self,
@@ -39,26 +39,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."""
-        if self.artifact_store._closed:
-            raise ArtifactStoreError("Store has been closed")
+        """Store artifact with grid key generation."""
+        if self.store._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
+        key = self.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.store.sandbox_id,
                 "key": key,
                 "mime": mime,
                 "summary": summary,
@@ -66,95 +68,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,
+                "storage_provider": self.store._storage_provider_name,
+                "session_provider": self.store._session_provider_name,
             }
-
-            # Cache metadata using session provider
-            session_ctx_mgr = self.artifact_store._session_factory()
+            
+            # Store metadata
+            session_ctx_mgr = self.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."""
-        if self.artifact_store._closed:
-            raise ArtifactStoreError("Store has been closed")
-        
-        start_time = time.time()
+        """Retrieve artifact data."""
+        if self.store._closed:
+            raise ArtifactStoreError("Store is closed")
         
         try:
             record = await self._get_record(artifact_id)
             
-            storage_ctx_mgr = self.artifact_store._s3_factory()
+            storage_ctx_mgr = self.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.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 +123,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.store.max_retries):
+            try:
+                storage_ctx_mgr = self.store._s3_factory()
+                async with storage_ctx_mgr as s3:
+                    await s3.put_object(
+                        Bucket=self.store.bucket,
+                        Key=key,
+                        Body=data,
+                        ContentType=mime,
+                        Metadata={
+                            "filename": filename or "",
+                            "session_id": session_id,
+                            "sandbox_id": self.store.sandbox_id,
+                        },
+                    )
+                return  # Success
+                
+            except Exception as e:
+                last_exception = e
+                if attempt < self.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()
+            session_ctx_mgr = self.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