chuk-artifacts 0.2.2__py3-none-any.whl → 0.4__py3-none-any.whl

chuk_artifacts/providers/memory.py

@@ -36,6 +36,7 @@ class _MemoryS3Client:
             If None, creates isolated per-instance storage.
         """
         self._store: Dict[str, Dict[str, Any]] = shared_store if shared_store is not None else {}
+        self._is_shared_store = shared_store is not None
         self._lock = asyncio.Lock()
         self._closed = False
         
@@ -231,8 +232,11 @@ class _MemoryS3Client:
     async def close(self):
         """Clean up resources and mark client as closed."""
         if not self._closed:
-            async with self._lock:
-                self._store.clear()
+            # Only clear the store if it's NOT shared
+            # If it's shared, other clients may still need the data
+            if not self._is_shared_store:
+                async with self._lock:
+                    self._store.clear()
             self._closed = True
 
     # ------------------------------------------------------------
@@ -253,6 +257,10 @@ class _MemoryS3Client:
                 "total_objects": total_objects,
                 "total_bytes": total_bytes,
                 "closed": self._closed,
+                "is_shared_store": self._is_shared_store,
+                "store_id": id(self._store),  # Memory address for debugging
+                "client_id": id(self),        # Client instance ID
+                "store_keys": list(self._store.keys())[:5],  # First 5 keys for debugging
             }
 
     @classmethod
@@ -263,17 +271,32 @@ class _MemoryS3Client:
 
 # ---- public factory -------------------------------------------------------
 
+# Global shared storage for memory provider when used as default
+_default_shared_store: Dict[str, Dict[str, Any]] = {}
+
 def factory(shared_store: Optional[Dict[str, Dict[str, Any]]] = None) -> Callable[[], AsyncContextManager]:
     """
     Return a **zero-arg** factory that yields an async-context client.
     
+    Key behavior for memory provider:
+    - If shared_store is provided, uses that specific storage
+    - If shared_store is None, ALWAYS uses the global shared storage
+    - This ensures all memory clients in the same process share data
+    - Prevents issues where ArtifactStore operations can't see each other's data
+    
     Parameters
     ----------
     shared_store : dict, optional
         If provided, all clients created by this factory will share
-        the same storage dict. Useful for testing scenarios where
-        you need multiple clients to see the same data.
+        the same storage dict. If None, will use a global shared store
+        to ensure consistency across operations within the same process.
     """
+    
+    # CRITICAL: Always use global shared storage when none specified
+    # This prevents the common issue where each ArtifactStore operation
+    # gets a different isolated storage and can't see each other's data
+    if shared_store is None:
+        shared_store = _default_shared_store
 
     @asynccontextmanager
     async def _ctx():
@@ -307,6 +330,11 @@ async def clear_all_memory_stores():
     Emergency cleanup function that clears all active memory stores.
     Useful for test teardown.
     """
+    # Clear the global shared store
+    global _default_shared_store
+    _default_shared_store.clear()
+    
+    # Close all active instances
     instances = list(_MemoryS3Client._instances)
     for instance in instances:
         try:

chuk_artifacts/store.py

@@ -12,7 +12,9 @@ Grid Architecture:
 
 from __future__ import annotations
 
-import os, logging, uuid
+import os
+import logging
+import uuid
 from datetime import datetime
 from typing import Any, Dict, List, Callable, AsyncContextManager, Optional, Union
 from chuk_sessions.session_manager import SessionManager
@@ -37,7 +39,6 @@ except ImportError:
 from .exceptions import ArtifactStoreError, ProviderError
 
 # Import chuk_sessions instead of local session manager
-from chuk_sessions.session_manager import SessionManager
 
 # Configure structured logging
 logger = logging.getLogger(__name__)
@@ -161,6 +162,32 @@ class ArtifactStore:
             session_id=session_id,
             ttl=ttl,
         )
+    
+    async def update_file(
+        self,
+        artifact_id: str,
+        *,
+        data: Optional[bytes] = None,
+        meta: Optional[Dict[str, Any]] = None,
+        filename: Optional[str] = None,
+        summary: Optional[str] = None,
+        mime: Optional[str] = None,
+    ) -> bool:
+        """
+        Update an artifact's content, metadata, filename, summary, or mime type.
+        All parameters are optional. At least one must be provided.
+        """
+        if not any([data, meta, filename, summary, mime]):
+            raise ValueError("At least one update parameter must be provided.")
+
+        return await self._core.update_file(
+            artifact_id=artifact_id,
+            new_data=data,
+            meta=meta,
+            filename=filename,
+            summary=summary,
+            mime=mime,
+        )
 
     async def retrieve(self, artifact_id: str) -> bytes:
         """Retrieve artifact data."""
@@ -606,4 +633,50 @@ class ArtifactStore:
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
+        await self.close()
+
+    async def get_sandbox_info(self) -> Dict[str, Any]:
+        """
+        Get sandbox information and metadata.
+        
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary containing sandbox information including:
+            - sandbox_id: The current sandbox identifier
+            - bucket: The storage bucket name
+            - storage_provider: The storage provider type
+            - session_provider: The session provider type
+            - session_ttl_hours: Default session TTL
+            - grid_prefix_pattern: The grid path pattern for this sandbox
+            - created_at: Timestamp of when this info was retrieved
+        """
+        from datetime import datetime
+        
+        # Get session manager stats if available
+        session_stats = {}
+        try:
+            session_stats = self._session_manager.get_cache_stats()
+        except Exception:
+            pass  # Session manager might not have stats
+        
+        # Get storage stats if available
+        storage_stats = {}
+        try:
+            storage_stats = await self._admin.get_stats()
+        except Exception:
+            pass  # Storage might not have stats
+        
+        return {
+            "sandbox_id": self.sandbox_id,
+            "bucket": self.bucket,
+            "storage_provider": self._storage_provider_name,
+            "session_provider": self._session_provider_name,
+            "session_ttl_hours": self.session_ttl_hours,
+            "max_retries": self.max_retries,
+            "grid_prefix_pattern": self.get_session_prefix_pattern(),
+            "created_at": datetime.utcnow().isoformat() + "Z",
+            "session_stats": session_stats,
+            "storage_stats": storage_stats,
+            "closed": self._closed,
+        }