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

chuk_artifacts/presigned.py

@@ -2,6 +2,7 @@
 # chuk_artifacts/presigned.py
 """
 Presigned URL operations: download URLs, upload URLs, and upload registration.
+Now uses chuk_sessions for session management.
 """
 
 from __future__ import annotations
@@ -28,11 +29,11 @@ class PresignedURLOperations:
     """Handles all presigned URL operations."""
 
     def __init__(self, artifact_store: 'ArtifactStore'):
-        self.store = artifact_store
+        self.artifact_store = artifact_store
 
     async def presign(self, artifact_id: str, expires: int = _DEFAULT_PRESIGN_EXPIRES) -> str:
         """Generate a presigned URL for artifact download."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
@@ -40,11 +41,11 @@ class PresignedURLOperations:
         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:
                 url = await s3.generate_presigned_url(
                     "get_object",
-                    Params={"Bucket": self.store.bucket, "Key": record["key"]},
+                    Params={"Bucket": self.artifact_store.bucket, "Key": record["key"]},
                     ExpiresIn=expires,
                 )
                 
@@ -101,28 +102,28 @@ class PresignedURLOperations:
         expires: int = _DEFAULT_PRESIGN_EXPIRES
     ) -> tuple[str, str]:
         """Generate a presigned URL for uploading a new artifact."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
-        # Ensure session is allocated
+        # Ensure session is allocated using chuk_sessions
         if session_id is None:
-            session_id = await self.store._session_manager.allocate_session()
+            session_id = await self.artifact_store._session_manager.allocate_session()
         else:
-            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+            session_id = await self.artifact_store._session_manager.allocate_session(session_id=session_id)
         
         # Generate artifact ID and key path
         artifact_id = uuid.uuid4().hex
-        key = self.store.generate_artifact_key(session_id, artifact_id)
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
         
         try:
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 url = await s3.generate_presigned_url(
                     "put_object",
                     Params={
-                        "Bucket": self.store.bucket, 
+                        "Bucket": self.artifact_store.bucket, 
                         "Key": key,
                         "ContentType": mime_type
                     },
@@ -174,26 +175,26 @@ class PresignedURLOperations:
         ttl: int = _DEFAULT_TTL,
     ) -> bool:
         """Register metadata for an artifact uploaded via presigned URL."""
-        if self.store._closed:
+        if self.artifact_store._closed:
             raise ArtifactStoreError("Store is closed")
         
         start_time = time.time()
         
-        # Ensure session is allocated
+        # Ensure session is allocated using chuk_sessions
         if session_id is None:
-            session_id = await self.store._session_manager.allocate_session()
+            session_id = await self.artifact_store._session_manager.allocate_session()
         else:
-            session_id = await self.store._session_manager.allocate_session(session_id=session_id)
+            session_id = await self.artifact_store._session_manager.allocate_session(session_id=session_id)
         
         # Reconstruct the key path
-        key = self.store.generate_artifact_key(session_id, artifact_id)
+        key = self.artifact_store.generate_artifact_key(session_id, artifact_id)
         
         try:
             # Verify the object exists and get its size
-            storage_ctx_mgr = self.store._s3_factory()
+            storage_ctx_mgr = self.artifact_store._s3_factory()
             async with storage_ctx_mgr as s3:
                 try:
-                    response = await s3.head_object(Bucket=self.store.bucket, Key=key)
+                    response = await s3.head_object(Bucket=self.artifact_store.bucket, Key=key)
                     file_size = response.get('ContentLength', 0)
                 except Exception:
                     logger.warning(f"Artifact {artifact_id} not found in storage")
@@ -203,7 +204,7 @@ class PresignedURLOperations:
             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,
@@ -213,13 +214,13 @@ class PresignedURLOperations:
                 "sha256": None,  # We don't have the hash since we didn't upload it directly
                 "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,
                 "uploaded_via_presigned": True,  # Flag to indicate upload method
             }
 
             # Cache metadata using session provider
-            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))
 
@@ -288,7 +289,7 @@ class PresignedURLOperations:
     async def _get_record(self, artifact_id: str) -> Dict[str, Any]:
         """Get artifact metadata record."""
         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/store.py

@@ -7,6 +7,7 @@ Grid Architecture:
 - Mandatory session allocation (no anonymous artifacts)
 - Grid paths: grid/{sandbox_id}/{session_id}/{artifact_id}
 - Clean, focused implementation
+- Now uses chuk_sessions for session management
 """
 
 from __future__ import annotations
@@ -32,7 +33,9 @@ except ImportError:
 
 # Import exceptions
 from .exceptions import ArtifactStoreError, ProviderError
-from .session.session_manager import SessionManager
+
+# Import chuk_sessions instead of local session manager
+from chuk_sessions.session_manager import SessionManager
 
 # Configure structured logging
 logger = logging.getLogger(__name__)
@@ -64,6 +67,7 @@ class ArtifactStore:
     - Always allocate a session (no anonymous artifacts)
     - Grid paths only: grid/{sandbox_id}/{session_id}/{artifact_id}
     - Clean, focused implementation
+    - Uses chuk_sessions for session management
     """
 
     def __init__(
@@ -93,10 +97,9 @@ class ArtifactStore:
         self._session_factory = self._load_session_provider(session_provider)
         self._session_provider_name = session_provider
         
-        # Session manager (always enabled)
+        # Session manager (now using chuk_sessions)
         self._session_manager = SessionManager(
             sandbox_id=self.sandbox_id,
-            session_factory=self._session_factory,
             default_ttl_hours=session_ttl_hours,
         )
         
@@ -140,17 +143,14 @@ class ArtifactStore:
         ttl: int = _DEFAULT_TTL,
     ) -> str:
         """Store artifact with mandatory session allocation."""
-        # Always allocate/validate session
+        # Always allocate/validate session using chuk_sessions
         session_id = await self._session_manager.allocate_session(
             session_id=session_id,
             user_id=user_id,
         )
         
-        # Work around the naming conflict in CoreStorageOperations
-        # where self.store is the artifact store instance, not the method
-        core_store_method = getattr(self._core.__class__, 'store')
-        return await core_store_method(
-            self._core,
+        # Store using core operations
+        return await self._core.store(
             data=data,
             mime=mime,
             summary=summary,
@@ -181,18 +181,20 @@ class ArtifactStore:
         return await self._metadata.list_by_session(session_id, limit)
 
     # ─────────────────────────────────────────────────────────────────
-    # Session operations
+    # Session operations - now delegated to chuk_sessions
     # ─────────────────────────────────────────────────────────────────
 
     async def create_session(
         self,
         user_id: Optional[str] = None,
         ttl_hours: Optional[int] = None,
+        custom_metadata: Optional[Dict[str, Any]] = None,
     ) -> str:
         """Create a new session."""
         return await self._session_manager.allocate_session(
             user_id=user_id,
             ttl_hours=ttl_hours,
+            custom_metadata=custom_metadata,
         )
 
     async def validate_session(self, session_id: str) -> bool:
@@ -203,8 +205,32 @@ class ArtifactStore:
         """Get session information."""
         return await self._session_manager.get_session_info(session_id)
 
+    async def update_session_metadata(
+        self,
+        session_id: str,
+        metadata: Dict[str, Any]
+    ) -> bool:
+        """Update session metadata."""
+        return await self._session_manager.update_session_metadata(session_id, metadata)
+
+    async def extend_session_ttl(
+        self,
+        session_id: str,
+        additional_hours: int
+    ) -> bool:
+        """Extend session TTL."""
+        return await self._session_manager.extend_session_ttl(session_id, additional_hours)
+
+    async def delete_session(self, session_id: str) -> bool:
+        """Delete session."""
+        return await self._session_manager.delete_session(session_id)
+
+    async def cleanup_expired_sessions(self) -> int:
+        """Clean up expired sessions."""
+        return await self._session_manager.cleanup_expired_sessions()
+
     # ─────────────────────────────────────────────────────────────────
-    # Grid operations
+    # Grid operations - now delegated to chuk_sessions
     # ─────────────────────────────────────────────────────────────────
 
     def get_canonical_prefix(self, session_id: str) -> str:
@@ -215,6 +241,14 @@ class ArtifactStore:
         """Generate grid artifact key."""
         return self._session_manager.generate_artifact_key(session_id, artifact_id)
 
+    def parse_grid_key(self, grid_key: str) -> Optional[Dict[str, Any]]:
+        """Parse grid key to extract components."""
+        return self._session_manager.parse_grid_key(grid_key)
+
+    def get_session_prefix_pattern(self) -> str:
+        """Get session prefix pattern for this sandbox."""
+        return self._session_manager.get_session_prefix_pattern()
+
     # ─────────────────────────────────────────────────────────────────
     # File operations
     # ─────────────────────────────────────────────────────────────────
@@ -506,7 +540,13 @@ class ArtifactStore:
 
     async def get_stats(self) -> Dict[str, Any]:
         """Get storage statistics."""
-        return await self._admin.get_stats()
+        stats = await self._admin.get_stats()
+        
+        # Add session manager stats
+        session_stats = self._session_manager.get_cache_stats()
+        stats["session_manager"] = session_stats
+        
+        return stats
 
     # ─────────────────────────────────────────────────────────────────
     # Helpers

{chuk_artifacts-0.1.3.dist-info → chuk_artifacts-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-artifacts
-Version: 0.1.3
+Version: 0.1.5
 Summary: Chuk Artifacts provides a production-ready, modular artifact storage system that works seamlessly across multiple storage backends (memory, filesystem, AWS S3, IBM Cloud Object Storage) with Redis or memory-based metadata caching and strict session-based security.
 License: MIT
 Requires-Python: >=3.11
@@ -12,7 +12,7 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: aioboto3>=14.3.0
 Requires-Dist: redis>=6.2.0
 Requires-Dist: ibm-cos-sdk>=2.13.5
-Requires-Dist: chuk-sessions>=0.1.0
+Requires-Dist: chuk-sessions>=0.1.1
 Provides-Extra: websocket
 Requires-Dist: websockets>=10.0; extra == "websocket"
 Provides-Extra: dev

chuk_artifacts-0.1.5.dist-info/RECORD

@@ -0,0 +1,23 @@
+chuk_artifacts/__init__.py,sha256=-4S9FWKVcQSa2ZD3GVbmbpGZPcl0cTQN_TFZLSqV7lQ,3605
+chuk_artifacts/admin.py,sha256=lUgmKBPxJh-0FYrGWjkACXQOl8lbVEDPJaeGVsWZmC4,6071
+chuk_artifacts/base.py,sha256=BtuVnC9M8QI1znyTdBxjZ6knIKP_k0yUfLfh7inGJUc,2559
+chuk_artifacts/batch.py,sha256=x8ARrWJ24I9fAXXodzvh31uMxYrvwZCGGJhUCM4vMJ4,5099
+chuk_artifacts/config.py,sha256=MaUzHzKPoBUyERviEpv8JVvPybMzSksgLyj0b7AO3Sc,7664
+chuk_artifacts/core.py,sha256=hokH7cgGE2ZaEwlV8XMKOov3EMvcLS2HufdApLS6l3M,6699
+chuk_artifacts/exceptions.py,sha256=f-s7Mg7c8vMXsbgqO2B6lMHdXcJQNvsESAY4GhJaV4g,814
+chuk_artifacts/metadata.py,sha256=McyKLviBInpqh2eF621xhqb3Ix7QUj_nVc1gg_tUlqY,7830
+chuk_artifacts/models.py,sha256=_foXlkr0DprqgztDw5WtlDc-s1OouLgYNp4XM1Ghp-g,837
+chuk_artifacts/presigned.py,sha256=-GE8r0CfUZuPNA_jnSGTfX7kuws6kYCPe7C4y6FItdo,11491
+chuk_artifacts/provider_factory.py,sha256=T0IXx1C8gygJzp417oB44_DxEaZoZR7jcdwQy8FghRE,3398
+chuk_artifacts/store.py,sha256=3E_eh7JcgyW7-ikLSn_fFMUV4AwN5A0phkEmF0cMaxw,24779
+chuk_artifacts/providers/__init__.py,sha256=3lN1lAy1ETT1mQslJo1f22PPR1W4CyxmsqJBclzH4NE,317
+chuk_artifacts/providers/filesystem.py,sha256=F4EjE-_ItPg0RWe7CqameVpOMjU-b7AigEBkm_ZoNrc,15280
+chuk_artifacts/providers/ibm_cos.py,sha256=K1-VAX4UVV9tA161MOeDXOKloQ0hB77jdw1-p46FwmU,4445
+chuk_artifacts/providers/ibm_cos_iam.py,sha256=VtwvCi9rMMcZx6i9l21ob6wM8jXseqvjzgCnAA82RkY,3186
+chuk_artifacts/providers/memory.py,sha256=B1C-tR1PcNz-UuDfGm1bhjPz3oITVATIMPekVbE7nm4,10487
+chuk_artifacts/providers/s3.py,sha256=eWhBhFSaobpRbazn7ySfU_7D8rm_xCfdSVqRtzXzXRY,2858
+chuk_artifacts-0.1.5.dist-info/licenses/LICENSE,sha256=SG9BmgtPBagPV0d-Fep-msdAGl-E1CeoBL7-EDRH2qA,1066
+chuk_artifacts-0.1.5.dist-info/METADATA,sha256=LEDEBlXqdLSHIJDut0xjsBPBHlwLP2X8HfWshD2xyeg,21188
+chuk_artifacts-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_artifacts-0.1.5.dist-info/top_level.txt,sha256=1_PVMtWXR0A-ZmeH6apF9mPaMtU0i23JE6wmN4GBRDI,15
+chuk_artifacts-0.1.5.dist-info/RECORD,,

chuk_artifacts/session/session_manager.py

@@ -1,196 +0,0 @@
-# -*- 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)