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

chuk_artifacts/session/session_manager.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# chuk_artifacts/session/session_manager.py
+"""
+Clean session manager for grid architecture.
+
+Simple rules:
+- Always have a session (auto-allocate if needed)
+- Grid paths: grid/{sandbox_id}/{session_id}/{artifact_id}
+- No legacy compatibility, clean implementation
+"""
+
+from __future__ import annotations
+
+import uuid
+import time
+import json
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List, AsyncContextManager, Callable
+from dataclasses import dataclass, asdict
+
+from ..exceptions import SessionError, ArtifactStoreError
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_SESSION_TTL_HOURS = 24
+
+
+@dataclass
+class SessionMetadata:
+    """Session metadata for grid operations."""
+    session_id: str
+    sandbox_id: str
+    user_id: Optional[str] = None
+    created_at: str = None
+    expires_at: str = None
+    status: str = "active"
+    artifact_count: int = 0
+    total_bytes: int = 0
+    
+    def __post_init__(self):
+        if self.created_at is None:
+            self.created_at = datetime.utcnow().isoformat() + "Z"
+    
+    def is_expired(self) -> bool:
+        """Check if session has expired."""
+        if not self.expires_at:
+            return False
+        expires = datetime.fromisoformat(self.expires_at.replace("Z", ""))
+        return datetime.utcnow() > expires
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SessionMetadata':
+        return cls(**data)
+
+
+class SessionManager:
+    """Simple session manager for grid architecture."""
+    
+    def __init__(
+        self,
+        sandbox_id: str,
+        session_factory: Callable[[], AsyncContextManager],
+        default_ttl_hours: int = _DEFAULT_SESSION_TTL_HOURS,
+    ):
+        self.sandbox_id = sandbox_id
+        self.session_factory = session_factory
+        self.default_ttl_hours = default_ttl_hours
+        
+        # Simple in-memory cache
+        self._session_cache: Dict[str, SessionMetadata] = {}
+        self._cache_lock = asyncio.Lock()
+        
+        logger.info(f"SessionManager initialized for sandbox: {sandbox_id}")
+    
+    async def allocate_session(
+        self,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        ttl_hours: Optional[int] = None,
+    ) -> str:
+        """Allocate or validate a session."""
+        ttl_hours = ttl_hours or self.default_ttl_hours
+        
+        if session_id:
+            # Validate existing session
+            metadata = await self._get_session_metadata(session_id)
+            if metadata and not metadata.is_expired():
+                await self._touch_session(session_id)
+                return session_id
+        
+        # Create new session
+        if not session_id:
+            session_id = self._generate_session_id(user_id)
+        
+        expires_at = (datetime.utcnow() + timedelta(hours=ttl_hours)).isoformat() + "Z"
+        
+        metadata = SessionMetadata(
+            session_id=session_id,
+            sandbox_id=self.sandbox_id,
+            user_id=user_id,
+            expires_at=expires_at,
+        )
+        
+        await self._store_session_metadata(metadata)
+        
+        async with self._cache_lock:
+            self._session_cache[session_id] = metadata
+        
+        logger.info(f"Session allocated: {session_id} (user: {user_id})")
+        return session_id
+    
+    async def validate_session(self, session_id: str) -> bool:
+        """Check if session is valid."""
+        try:
+            metadata = await self._get_session_metadata(session_id)
+            if metadata and not metadata.is_expired():
+                await self._touch_session(session_id)
+                return True
+            return False
+        except Exception:
+            return False
+    
+    async def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session information."""
+        metadata = await self._get_session_metadata(session_id)
+        return metadata.to_dict() if metadata else None
+    
+    def get_canonical_prefix(self, session_id: str) -> str:
+        """Get grid path prefix."""
+        return f"grid/{self.sandbox_id}/{session_id}/"
+    
+    def generate_artifact_key(self, session_id: str, artifact_id: str) -> str:
+        """Generate grid artifact key."""
+        return f"grid/{self.sandbox_id}/{session_id}/{artifact_id}"
+    
+    def _generate_session_id(self, user_id: Optional[str] = None) -> str:
+        """Generate session ID."""
+        timestamp = int(time.time())
+        unique = uuid.uuid4().hex[:8]
+        
+        if user_id:
+            safe_user = "".join(c for c in user_id if c.isalnum())[:8]
+            return f"sess-{safe_user}-{timestamp}-{unique}"
+        else:
+            return f"sess-{timestamp}-{unique}"
+    
+    async def _get_session_metadata(self, session_id: str) -> Optional[SessionMetadata]:
+        """Get session metadata."""
+        # Check cache
+        async with self._cache_lock:
+            if session_id in self._session_cache:
+                return self._session_cache[session_id]
+        
+        # Query session provider
+        try:
+            session_ctx_mgr = self.session_factory()
+            async with session_ctx_mgr as session:
+                raw_data = await session.get(f"session:{session_id}")
+                if raw_data:
+                    data = json.loads(raw_data)
+                    metadata = SessionMetadata.from_dict(data)
+                    
+                    # Cache it
+                    async with self._cache_lock:
+                        self._session_cache[session_id] = metadata
+                    
+                    return metadata
+        except Exception as e:
+            logger.warning(f"Failed to get session {session_id}: {e}")
+        
+        return None
+    
+    async def _store_session_metadata(self, metadata: SessionMetadata) -> None:
+        """Store session metadata."""
+        try:
+            session_ctx_mgr = self.session_factory()
+            async with session_ctx_mgr as session:
+                key = f"session:{metadata.session_id}"
+                ttl_seconds = int((datetime.fromisoformat(metadata.expires_at.replace("Z", "")) - datetime.utcnow()).total_seconds())
+                data = json.dumps(metadata.to_dict())
+                
+                await session.setex(key, ttl_seconds, data)
+        except Exception as e:
+            raise SessionError(f"Session storage failed: {e}") from e
+    
+    async def _touch_session(self, session_id: str) -> None:
+        """Update last accessed time."""
+        metadata = await self._get_session_metadata(session_id)
+        if metadata:
+            # Simple touch - could update last_accessed if we add that field
+            await self._store_session_metadata(metadata)

chuk_artifacts/{session_operations.py → session/session_operations.py}

@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
-# chuk_artifacts/session_operations.py (SECURE VERSION)
+# chuk_artifacts/session/session_operations.py
 """
 Session-based file operations with strict session isolation.
-NO cross-session operations allowed for security.
 """
 
 from __future__ import annotations
@@ -11,8 +10,8 @@ import uuid, hashlib, json, logging
 from datetime import datetime
 from typing import Any, Dict, Optional, Union, List
 
-from .base import BaseOperations
-from .exceptions import (
+from ..base import BaseOperations
+from ..exceptions import (
     ArtifactStoreError, ArtifactNotFoundError, ArtifactExpiredError, 
     ProviderError, SessionError
 )
@@ -36,27 +35,6 @@ class SessionOperations(BaseOperations):
     ) -> Dict[str, Any]:
         """
         Move a file within the SAME session or rename it.
-        
-        Parameters
-        ----------
-        artifact_id : str
-            Source artifact ID
-        new_filename : str, optional
-            New filename (renames the file)
-        new_session_id : str, optional
-            Target session (BLOCKED - always raises error if different)
-        new_meta : dict, optional
-            Additional metadata to merge
-            
-        Returns
-        -------
-        dict
-            Updated artifact metadata
-            
-        Raises
-        ------
-        ArtifactStoreError
-            If trying to move across sessions (always blocked)
         """
         self._check_closed()
         
@@ -86,7 +64,7 @@ class SessionOperations(BaseOperations):
             
             if updates:
                 # Use the metadata operations to update
-                from .metadata import MetadataOperations
+                from ..metadata import MetadataOperations
                 metadata_ops = MetadataOperations(self._artifact_store)
                 return await metadata_ops.update_metadata(artifact_id, **updates)
             
@@ -96,12 +74,14 @@ class SessionOperations(BaseOperations):
             raise
         except Exception as e:
             logger.error(
-                "File move failed",
+                "File move failed for artifact %s: %s",
+                artifact_id,
+                str(e),
                 extra={
                     "artifact_id": artifact_id,
-                    "new_filename": new_filename,
+                    "new_file_name": new_filename,  # FIXED: Renamed from 'new_filename'
                     "new_session_id": new_session_id,
-                    "error": str(e)
+                    "operation": "move_file"
                 }
             )
             raise ProviderError(f"Move operation failed: {e}") from e
@@ -117,29 +97,6 @@ class SessionOperations(BaseOperations):
     ) -> str:
         """
         Copy a file WITHIN THE SAME SESSION only.
-        
-        Parameters
-        ----------
-        artifact_id : str
-            Source artifact ID
-        new_filename : str, optional
-            Filename for the copy (defaults to original + "_copy")
-        target_session_id : str, optional
-            Target session (BLOCKED - must be same as source session)
-        new_meta : dict, optional
-            Additional metadata to merge
-        summary : str, optional
-            New summary for the copy
-            
-        Returns
-        -------
-        str
-            New artifact ID of the copy
-            
-        Raises
-        ------
-        ArtifactStoreError
-            If trying to copy across sessions (always blocked)
         """
         self._check_closed()
         
@@ -180,7 +137,7 @@ class SessionOperations(BaseOperations):
             copy_meta["copy_within_session"] = original_session
             
             # Store the copy using core operations
-            from .core import CoreStorageOperations
+            from ..core import CoreStorageOperations
             core_ops = CoreStorageOperations(self._artifact_store)
             
             new_artifact_id = await core_ops.store(
@@ -193,12 +150,15 @@ class SessionOperations(BaseOperations):
             )
             
             logger.info(
-                "File copied within session",
+                "File copied within session: %s -> %s",
+                artifact_id,
+                new_artifact_id,
                 extra={
                     "source_artifact_id": artifact_id,
                     "new_artifact_id": new_artifact_id,
                     "session": copy_session,
-                    "security_level": "same_session_only"
+                    "security_level": "same_session_only",
+                    "operation": "copy_file"
                 }
             )
             
@@ -208,12 +168,14 @@ class SessionOperations(BaseOperations):
             raise
         except Exception as e:
             logger.error(
-                "File copy failed",
+                "File copy failed for artifact %s: %s",
+                artifact_id,
+                str(e),
                 extra={
                     "artifact_id": artifact_id,
-                    "new_filename": new_filename,
+                    "new_file_name": new_filename,  # FIXED: Renamed from 'new_filename'
                     "target_session_id": target_session_id,
-                    "error": str(e)
+                    "operation": "copy_file"
                 }
             )
             raise ProviderError(f"Copy operation failed: {e}") from e
@@ -227,9 +189,6 @@ class SessionOperations(BaseOperations):
     ) -> Union[str, bytes]:
         """
         Read file content directly.
-        
-        Note: This operation inherently respects session boundaries since
-        you can only read files you have artifact IDs for.
         """
         self._check_closed()
         
@@ -249,8 +208,10 @@ class SessionOperations(BaseOperations):
             raise
         except Exception as e:
             logger.error(
-                "File read failed",
-                extra={"artifact_id": artifact_id, "error": str(e)}
+                "File read failed for artifact %s: %s",
+                artifact_id,
+                str(e),
+                extra={"artifact_id": artifact_id, "operation": "read_file"}
             )
             raise ProviderError(f"Read operation failed: {e}") from e
 
@@ -268,35 +229,6 @@ class SessionOperations(BaseOperations):
     ) -> str:
         """
         Write content to a new file or overwrite existing WITHIN THE SAME SESSION.
-        
-        Parameters
-        ----------
-        content : str or bytes
-            Content to write
-        filename : str
-            Filename for the new file
-        mime : str, optional
-            MIME type (default: text/plain)
-        summary : str, optional
-            File summary
-        session_id : str, optional
-            Session for the file
-        meta : dict, optional
-            Additional metadata
-        encoding : str, optional
-            Text encoding for string content (default: utf-8)
-        overwrite_artifact_id : str, optional
-            If provided, overwrite this existing artifact (must be in same session)
-            
-        Returns
-        -------
-        str
-            Artifact ID of the written file
-            
-        Raises
-        ------
-        ArtifactStoreError
-            If trying to overwrite a file in a different session
         """
         self._check_closed()
         
@@ -325,7 +257,7 @@ class SessionOperations(BaseOperations):
                     session_id = session_id or existing_session
                     
                     # Delete old version (within same session)
-                    from .metadata import MetadataOperations
+                    from ..metadata import MetadataOperations
                     metadata_ops = MetadataOperations(self._artifact_store)
                     await metadata_ops.delete(overwrite_artifact_id)
                     
@@ -333,7 +265,7 @@ class SessionOperations(BaseOperations):
                     pass  # Original doesn't exist, proceed with new creation
             
             # Store new content using core operations
-            from .core import CoreStorageOperations
+            from ..core import CoreStorageOperations
             core_ops = CoreStorageOperations(self._artifact_store)
             
             write_meta = {**(meta or {})}
@@ -351,28 +283,35 @@ class SessionOperations(BaseOperations):
                 meta=write_meta
             )
             
+            # FIXED: Use separate variables for logging to avoid 'filename' conflict
             logger.info(
-                "File written successfully",
+                "File written successfully: %s (artifact_id: %s)",
+                filename,
+                artifact_id,
                 extra={
                     "artifact_id": artifact_id,
-                    "filename": filename,
+                    "file_name": filename,  # FIXED: Renamed from 'filename'
                     "bytes": len(data),
                     "overwrite": bool(overwrite_artifact_id),
                     "session_id": session_id,
-                    "security_level": "session_isolated"
+                    "security_level": "session_isolated",
+                    "operation": "write_file"
                 }
             )
             
             return artifact_id
             
         except Exception as e:
+            # FIXED: Use separate variables for logging to avoid 'filename' conflict
             logger.error(
-                "File write failed",
+                "File write failed for %s: %s",
+                filename,
+                str(e),
                 extra={
-                    "filename": filename,
+                    "file_name": filename,  # FIXED: Renamed from 'filename'
                     "overwrite_artifact_id": overwrite_artifact_id,
                     "session_id": session_id,
-                    "error": str(e)
+                    "operation": "write_file"
                 }
             )
             raise ProviderError(f"Write operation failed: {e}") from e
@@ -385,52 +324,34 @@ class SessionOperations(BaseOperations):
     ) -> List[Dict[str, Any]]:
         """
         List files in a directory-like structure within a session.
-        
-        This operation is inherently session-safe since it requires
-        explicit session_id parameter.
         """
         try:
-            from .metadata import MetadataOperations
+            from ..metadata import MetadataOperations
             metadata_ops = MetadataOperations(self._artifact_store)
             return await metadata_ops.list_by_prefix(session_id, directory_prefix, limit)
         except Exception as e:
             logger.error(
-                "Directory listing failed",
+                "Directory listing failed for session %s: %s",
+                session_id,
+                str(e),
                 extra={
                     "session_id": session_id,
                     "directory_prefix": directory_prefix,
-                    "error": str(e)
+                    "operation": "get_directory_contents"
                 }
             )
             raise ProviderError(f"Directory listing failed: {e}") from e
 
     async def _retrieve_data(self, artifact_id: str) -> bytes:
         """Helper to retrieve artifact data using core operations."""
-        from .core import CoreStorageOperations
+        from ..core import CoreStorageOperations
         core_ops = CoreStorageOperations(self._artifact_store)
         return await core_ops.retrieve(artifact_id)
 
-    # NEW: Session security validation helper
+    # Session security validation helper
     async def _validate_session_access(self, artifact_id: str, expected_session_id: str = None) -> Dict[str, Any]:
         """
         Validate that an artifact belongs to the expected session.
-        
-        Parameters
-        ----------
-        artifact_id : str
-            Artifact to check
-        expected_session_id : str, optional
-            Expected session ID (if None, just returns the session)
-            
-        Returns
-        -------
-        dict
-            Artifact metadata
-            
-        Raises
-        ------
-        ArtifactStoreError
-            If artifact belongs to different session
         """
         record = await self._get_record(artifact_id)
         actual_session = record.get("session_id")