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

chuk_artifacts/metadata.py

@@ -1,311 +1,210 @@
 # -*- coding: utf-8 -*-
 # chuk_artifacts/metadata.py
 """
-Metadata operations: exists, metadata retrieval, deletion, and session-based operations.
-This is a WORKING implementation that actually implements the missing methods.
+Clean metadata operations for grid architecture.
 """
 
 from __future__ import annotations
 
-import logging, json
-from datetime import datetime
-from typing import Any, Dict, List
+import json
+import logging
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
-from .base import BaseOperations
-from .exceptions import (
-    ArtifactStoreError, ArtifactNotFoundError, ArtifactExpiredError, 
-    ProviderError
-)
+if TYPE_CHECKING:
+    from .store import ArtifactStore
+
+from .exceptions import ProviderError, SessionError
 
 logger = logging.getLogger(__name__)
 
 
-class MetadataOperations(BaseOperations):
-    """Handles metadata-related operations with working session-based listing."""
+class MetadataOperations:
+    """Clean metadata operations for grid architecture."""
+
+    def __init__(self, artifact_store: 'ArtifactStore'):
+        self.store = artifact_store
 
-    async def metadata(self, artifact_id: str) -> Dict[str, Any]:
+    async def get_metadata(self, artifact_id: str) -> Dict[str, Any]:
         """Get artifact metadata."""
         return await self._get_record(artifact_id)
 
     async def exists(self, artifact_id: str) -> bool:
-        """Check if artifact exists and hasn't expired."""
+        """Check if artifact exists."""
         try:
             await self._get_record(artifact_id)
             return True
-        except (ArtifactNotFoundError, ArtifactExpiredError):
+        except Exception:
             return False
 
     async def delete(self, artifact_id: str) -> bool:
-        """Delete artifact and its metadata."""
-        self._check_closed()
-        
+        """Delete artifact and metadata."""
         try:
             record = await self._get_record(artifact_id)
             
-            # Delete from object storage
-            storage_ctx_mgr = self.s3_factory()
+            # Delete from storage
+            storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
-                await s3.delete_object(Bucket=self.bucket, Key=record["key"])
+                await s3.delete_object(
+                    Bucket=self.store.bucket, 
+                    Key=record["key"]
+                )
             
-            # Delete metadata from session store
-            session_ctx_mgr = self.session_factory()
+            # Delete metadata
+            session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 if hasattr(session, 'delete'):
                     await session.delete(artifact_id)
-                else:
-                    logger.warning(
-                        "Session provider doesn't support delete operation",
-                        extra={"artifact_id": artifact_id, "provider": self.session_provider_name}
-                    )
             
-            logger.info("Artifact deleted", extra={"artifact_id": artifact_id})
+            logger.info(f"Deleted artifact: {artifact_id}")
             return True
             
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            logger.warning("Attempted to delete non-existent artifact", extra={"artifact_id": artifact_id})
+        except Exception as e:
+            logger.error(f"Delete failed for {artifact_id}: {e}")
             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."""
+        try:
+            artifacts = []
+            prefix = f"grid/{self.store.sandbox_id}/{session_id}/"
+            
+            storage_ctx_mgr = self.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,
+                        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]
+                            try:
+                                record = await self._get_record(artifact_id)
+                                artifacts.append(record)
+                            except Exception:
+                                continue  # Skip if metadata missing
+                    
+                    return artifacts[:limit]
+            
+            logger.warning(f"Storage provider doesn't support listing")
+            return []
+            
+        except Exception as e:
+            logger.error(f"Session listing failed for {session_id}: {e}")
+            return []
+
+    async def list_by_prefix(
+        self,
+        session_id: str,
+        prefix: str = "",
+        limit: int = 100
+    ) -> List[Dict[str, Any]]:
+        """List artifacts with filename prefix filtering."""
+        try:
+            all_files = await self.list_by_session(session_id, limit * 2)
+            
+            if not prefix:
+                return all_files[:limit]
+            
+            # Filter by filename prefix
+            filtered = []
+            for file_meta in all_files:
+                filename = file_meta.get("filename", "")
+                if filename.startswith(prefix):
+                    filtered.append(file_meta)
+                    if len(filtered) >= limit:
+                        break
+            
+            return filtered
+            
         except Exception as e:
-            logger.error(
-                "Artifact deletion failed",
-                extra={"artifact_id": artifact_id, "error": str(e)}
-            )
-            raise ProviderError(f"Deletion failed: {e}") from e
+            logger.error(f"Prefix listing failed for session {session_id}: {e}")
+            return []
 
     async def update_metadata(
-        self, 
-        artifact_id: str, 
+        self,
+        artifact_id: str,
         *,
         summary: str = None,
         meta: Dict[str, Any] = None,
-        filename: str = None,
-        ttl: int = None,
-        # NEW: MCP-specific parameters
-        new_meta: Dict[str, Any] = None,
-        merge: bool = True
+        merge: bool = True,
+        **kwargs
     ) -> Dict[str, Any]:
-        """
-        Update artifact metadata with MCP server compatibility.
-        
-        Parameters
-        ----------
-        artifact_id : str
-            The artifact identifier
-        summary : str, optional
-            New summary description
-        meta : dict, optional
-            New or additional metadata fields (legacy parameter)
-        filename : str, optional
-            New filename
-        ttl : int, optional
-            New TTL for metadata
-        new_meta : dict, optional
-            New metadata fields (MCP server parameter)
-        merge : bool, optional
-            Whether to merge with existing metadata (True) or replace (False)
-            
-        Returns
-        -------
-        dict
-            Updated metadata record
-        """
-        self._check_closed()
-        
+        """Update artifact metadata."""
         try:
-            # Get existing record
+            # Get current record
             record = await self._get_record(artifact_id)
             
-            # Handle MCP server compatibility
-            metadata_update = new_meta or meta or {}
-            
-            # Update fields if provided
+            # Update fields
             if summary is not None:
                 record["summary"] = summary
-            if filename is not None:
-                record["filename"] = filename
-            if ttl is not None:
-                record["ttl"] = ttl
                 
-            # Handle metadata updates
-            if metadata_update:
-                existing_meta = record.get("meta", {})
-                if merge:
-                    # Merge with existing meta, allowing overwrites
-                    existing_meta.update(metadata_update)
-                    record["meta"] = existing_meta
+            if meta is not None:
+                if merge and "meta" in record:
+                    record["meta"].update(meta)
                 else:
-                    # Replace existing meta entirely
-                    record["meta"] = metadata_update
+                    record["meta"] = meta
             
-            # Update stored metadata
-            record["updated_at"] = datetime.utcnow().isoformat(timespec="seconds") + "Z"
+            # Update any other fields
+            for key, value in kwargs.items():
+                if key not in ["summary", "meta"] and value is not None:
+                    record[key] = value
             
-            session_ctx_mgr = self.session_factory()
+            # Store updated record
+            session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
-                final_ttl = ttl or record.get("ttl", 900)
-                await session.setex(artifact_id, final_ttl, json.dumps(record))
-            
-            logger.info(
-                "Artifact metadata updated", 
-                extra={
-                    "artifact_id": artifact_id, 
-                    "merge": merge,
-                    "updated_fields": list([
-                        k for k, v in [
-                            ("summary", summary), ("meta", metadata_update), 
-                            ("filename", filename), ("ttl", ttl)
-                        ] if v is not None
-                    ])
-                }
-            )
+                await session.setex(artifact_id, record.get("ttl", 900), json.dumps(record))
             
             return record
             
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            raise
         except Exception as e:
-            logger.error(
-                "Metadata update failed",
-                extra={"artifact_id": artifact_id, "error": str(e)}
-            )
+            logger.error(f"Metadata update failed for {artifact_id}: {e}")
             raise ProviderError(f"Metadata update failed: {e}") from e
 
-    async def extend_ttl(self, artifact_id: str, additional_seconds: int) -> Dict[str, Any]:
-        """Extend the TTL of an artifact's metadata."""
-        self._check_closed()
-        
+    async def extend_ttl(
+        self,
+        artifact_id: str,
+        additional_seconds: int
+    ) -> Dict[str, Any]:
+        """Extend artifact TTL."""
         try:
+            # Get current record
             record = await self._get_record(artifact_id)
+            
+            # Update TTL
             current_ttl = record.get("ttl", 900)
             new_ttl = current_ttl + additional_seconds
+            record["ttl"] = new_ttl
             
-            return await self.update_metadata(artifact_id, ttl=new_ttl)
+            # Store updated record with new TTL
+            session_ctx_mgr = self.store._session_factory()
+            async with session_ctx_mgr as session:
+                await session.setex(artifact_id, new_ttl, json.dumps(record))
+            
+            return record
             
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            raise
         except Exception as e:
-            logger.error(
-                "TTL extension failed",
-                extra={
-                    "artifact_id": artifact_id, 
-                    "additional_seconds": additional_seconds,
-                    "error": str(e)
-                }
-            )
+            logger.error(f"TTL extension failed for {artifact_id}: {e}")
             raise ProviderError(f"TTL extension failed: {e}") from e
 
-    async def list_by_session(self, session_id: str, limit: int = 100) -> List[Dict[str, Any]]:
-        """
-        List artifacts for a specific session.
-        
-        WORKING IMPLEMENTATION: Uses storage provider listing when available,
-        falls back to warning for providers that don't support it.
-        """
-        self._check_closed()
-        
+    async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
+        """Get artifact metadata record."""
         try:
-            artifacts = []
-            
-            # Try to use storage provider listing capabilities
-            storage_ctx_mgr = self.s3_factory()
-            async with storage_ctx_mgr as s3:
-                # Check if storage provider supports listing
-                if hasattr(s3, 'list_objects_v2'):
-                    try:
-                        # List objects with session prefix
-                        prefix = f"sess/{session_id}/"
-                        
-                        response = await s3.list_objects_v2(
-                            Bucket=self.bucket,
-                            Prefix=prefix,
-                            MaxKeys=limit
-                        )
-                        
-                        # Extract artifact IDs from keys and get their metadata
-                        for obj in response.get('Contents', []):
-                            key = obj['Key']
-                            # Extract artifact ID from key pattern: sess/{session_id}/{artifact_id}
-                            parts = key.split('/')
-                            if len(parts) >= 3:
-                                artifact_id = parts[2]
-                                try:
-                                    record = await self._get_record(artifact_id)
-                                    artifacts.append(record)
-                                except (ArtifactNotFoundError, ArtifactExpiredError):
-                                    continue  # Skip expired/missing metadata
-                                    
-                        logger.info(
-                            f"Successfully listed {len(artifacts)} artifacts for session {session_id}"
-                        )
-                        return artifacts[:limit]
-                        
-                    except Exception as list_error:
-                        logger.warning(
-                            f"Storage provider listing failed: {list_error}. "
-                            f"Provider: {self.storage_provider_name}"
-                        )
-                        # Fall through to empty result with warning
-                        
-                else:
-                    logger.warning(
-                        f"Storage provider {self.storage_provider_name} doesn't support list_objects_v2"
-                    )
-            
-            # If we get here, listing isn't supported
-            logger.warning(
-                f"Session listing not fully supported with {self.storage_provider_name} provider. "
-                f"Returning empty list. For full session listing, use filesystem or S3-compatible storage."
-            )
-            return []
-            
+            session_ctx_mgr = self.store._session_factory()
+            async with session_ctx_mgr as session:
+                raw = await session.get(artifact_id)
         except Exception as e:
-            logger.error(
-                "Session artifact listing failed",
-                extra={"session_id": session_id, "error": str(e)}
-            )
-            # Return empty list rather than failing completely
-            logger.warning(f"Returning empty list due to error: {e}")
-            return []
-
-    async def list_by_prefix(
-        self, 
-        session_id: str, 
-        prefix: str = "", 
-        limit: int = 100
-    ) -> List[Dict[str, Any]]:
-        """
-        List artifacts in a session with filename prefix filtering.
+            raise SessionError(f"Session error for {artifact_id}: {e}") from e
+        
+        if raw is None:
+            raise ProviderError(f"Artifact {artifact_id} not found")
         
-        WORKING IMPLEMENTATION: Gets session artifacts and filters by filename prefix.
-        """
         try:
-            # Get all artifacts in the session first
-            artifacts = await self.list_by_session(session_id, limit * 2)  # Get more to filter
-            
-            if not prefix:
-                return artifacts[:limit]
-                
-            # Filter by filename prefix
-            filtered = []
-            for artifact in artifacts:
-                filename = artifact.get("filename", "")
-                if filename.startswith(prefix):
-                    filtered.append(artifact)
-                    if len(filtered) >= limit:
-                        break
-                        
-            logger.info(
-                f"Filtered {len(filtered)} artifacts from {len(artifacts)} total with prefix '{prefix}'"
-            )
-            return filtered
-            
-        except Exception as e:
-            logger.error(
-                "Prefix-based listing failed",
-                extra={
-                    "session_id": session_id,
-                    "prefix": prefix,
-                    "error": str(e)
-                }
-            )
-            # Return empty list rather than failing
-            return []
+            return json.loads(raw)
+        except json.JSONDecodeError as e:
+            raise ProviderError(f"Corrupted metadata for {artifact_id}") from e

chuk_artifacts/presigned.py

@@ -8,9 +8,11 @@ from __future__ import annotations
 
 import uuid, time, logging, json
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .store import ArtifactStore
 
-from .base import BaseOperations
 from .exceptions import (
     ArtifactStoreError, ArtifactNotFoundError, ArtifactExpiredError, 
     ProviderError, SessionError
@@ -18,28 +20,31 @@ from .exceptions import (
 
 logger = logging.getLogger(__name__)
 
-_ANON_PREFIX = "anon"
 _DEFAULT_TTL = 900
 _DEFAULT_PRESIGN_EXPIRES = 3600
 
 
-class PresignedURLOperations(BaseOperations):
+class PresignedURLOperations:
     """Handles all presigned URL operations."""
 
+    def __init__(self, artifact_store: 'ArtifactStore'):
+        self.store = artifact_store
+
     async def presign(self, artifact_id: str, expires: int = _DEFAULT_PRESIGN_EXPIRES) -> str:
         """Generate a presigned URL for artifact download."""
-        self._check_closed()
+        if self.store._closed:
+            raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
         try:
             record = await self._get_record(artifact_id)
             
-            storage_ctx_mgr = self.s3_factory()
+            storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
                 url = await s3.generate_presigned_url(
                     "get_object",
-                    Params={"Bucket": self.bucket, "Key": record["key"]},
+                    Params={"Bucket": self.store.bucket, "Key": record["key"]},
                     ExpiresIn=expires,
                 )
                 
@@ -96,22 +101,28 @@ class PresignedURLOperations(BaseOperations):
         expires: int = _DEFAULT_PRESIGN_EXPIRES
     ) -> tuple[str, str]:
         """Generate a presigned URL for uploading a new artifact."""
-        self._check_closed()
+        if self.store._closed:
+            raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
+        # Ensure session is allocated
+        if session_id is None:
+            session_id = await self.store._session_manager.allocate_session()
+        else:
+            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+        
         # Generate artifact ID and key path
         artifact_id = uuid.uuid4().hex
-        scope = session_id or f"{_ANON_PREFIX}_{artifact_id}"
-        key = f"sess/{scope}/{artifact_id}"
+        key = self.store.generate_artifact_key(session_id, artifact_id)
         
         try:
-            storage_ctx_mgr = self.s3_factory()
+            storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
                 url = await s3.generate_presigned_url(
                     "put_object",
                     Params={
-                        "Bucket": self.bucket, 
+                        "Bucket": self.store.bucket, 
                         "Key": key,
                         "ContentType": mime_type
                     },
@@ -163,20 +174,26 @@ class PresignedURLOperations(BaseOperations):
         ttl: int = _DEFAULT_TTL,
     ) -> bool:
         """Register metadata for an artifact uploaded via presigned URL."""
-        self._check_closed()
+        if self.store._closed:
+            raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
+        # Ensure session is allocated
+        if session_id is None:
+            session_id = await self.store._session_manager.allocate_session()
+        else:
+            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+        
         # Reconstruct the key path
-        scope = session_id or f"{_ANON_PREFIX}_{artifact_id}"
-        key = f"sess/{scope}/{artifact_id}"
+        key = self.store.generate_artifact_key(session_id, artifact_id)
         
         try:
             # Verify the object exists and get its size
-            storage_ctx_mgr = self.s3_factory()
+            storage_ctx_mgr = self.store._s3_factory()
             async with storage_ctx_mgr as s3:
                 try:
-                    response = await s3.head_object(Bucket=self.bucket, Key=key)
+                    response = await s3.head_object(Bucket=self.store.bucket, Key=key)
                     file_size = response.get('ContentLength', 0)
                 except Exception:
                     logger.warning(f"Artifact {artifact_id} not found in storage")
@@ -184,7 +201,9 @@ class PresignedURLOperations(BaseOperations):
             
             # 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,
@@ -192,15 +211,15 @@ class PresignedURLOperations(BaseOperations):
                 "filename": filename,
                 "bytes": file_size,
                 "sha256": None,  # We don't have the hash since we didn't upload it directly
-                "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.store._storage_provider_name,
+                "session_provider": self.store._session_provider_name,
                 "uploaded_via_presigned": True,  # Flag to indicate upload method
             }
 
             # Cache metadata using session provider
-            session_ctx_mgr = self.session_factory()
+            session_ctx_mgr = self.store._session_factory()
             async with session_ctx_mgr as session:
                 await session.setex(artifact_id, ttl, json.dumps(record))
 
@@ -264,4 +283,21 @@ class PresignedURLOperations(BaseOperations):
             ttl=ttl
         )
         
-        return upload_url, artifact_id
+        return upload_url, artifact_id
+
+    async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
+        """Get artifact metadata record."""
+        try:
+            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 error for {artifact_id}: {e}") from e
+        
+        if raw is None:
+            raise ArtifactNotFoundError(f"Artifact {artifact_id} not found")
+        
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError as e:
+            raise ProviderError(f"Corrupted metadata for {artifact_id}") from e