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

chuk_artifacts/session/session_operations.py

@@ -1,366 +0,0 @@
-# -*- coding: utf-8 -*-
-# chuk_artifacts/session/session_operations.py
-"""
-Session-based file operations with strict session isolation.
-"""
-
-from __future__ import annotations
-
-import uuid, hashlib, json, logging
-from datetime import datetime
-from typing import Any, Dict, Optional, Union, List
-
-from ..base import BaseOperations
-from ..exceptions import (
-    ArtifactStoreError, ArtifactNotFoundError, ArtifactExpiredError, 
-    ProviderError, SessionError
-)
-
-logger = logging.getLogger(__name__)
-
-_ANON_PREFIX = "anon"
-_DEFAULT_TTL = 900
-
-
-class SessionOperations(BaseOperations):
-    """Session-based file operations with strict session isolation."""
-
-    async def move_file(
-        self,
-        artifact_id: str,
-        *,
-        new_filename: str = None,
-        new_session_id: str = None,
-        new_meta: Dict[str, Any] = None
-    ) -> Dict[str, Any]:
-        """
-        Move a file within the SAME session or rename it.
-        """
-        self._check_closed()
-        
-        try:
-            # Get current metadata
-            record = await self._get_record(artifact_id)
-            current_session = record.get("session_id")
-            
-            # STRICT SECURITY: Block ALL cross-session moves
-            if new_session_id and new_session_id != current_session:
-                raise ArtifactStoreError(
-                    f"Cross-session moves are not permitted for security reasons. "
-                    f"Artifact {artifact_id} belongs to session '{current_session}', "
-                    f"cannot move to session '{new_session_id}'. Use copy operations within "
-                    f"the same session only."
-                )
-            
-            # Update metadata fields (only filename and meta allowed)
-            updates = {}
-            if new_filename:
-                updates["filename"] = new_filename
-            if new_meta:
-                existing_meta = record.get("meta", {})
-                existing_meta.update(new_meta)
-                updates["new_meta"] = existing_meta
-                updates["merge"] = True
-            
-            if updates:
-                # Use the metadata operations to update
-                from ..metadata import MetadataOperations
-                metadata_ops = MetadataOperations(self._artifact_store)
-                return await metadata_ops.update_metadata(artifact_id, **updates)
-            
-            return record
-            
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            raise
-        except Exception as e:
-            logger.error(
-                "File move failed for artifact %s: %s",
-                artifact_id,
-                str(e),
-                extra={
-                    "artifact_id": artifact_id,
-                    "new_file_name": new_filename,  # FIXED: Renamed from 'new_filename'
-                    "new_session_id": new_session_id,
-                    "operation": "move_file"
-                }
-            )
-            raise ProviderError(f"Move operation failed: {e}") from e
-
-    async def copy_file(
-        self,
-        artifact_id: str,
-        *,
-        new_filename: str = None,
-        target_session_id: str = None,
-        new_meta: Dict[str, Any] = None,
-        summary: str = None
-    ) -> str:
-        """
-        Copy a file WITHIN THE SAME SESSION only.
-        """
-        self._check_closed()
-        
-        try:
-            # Get original metadata first to check session
-            original_meta = await self._get_record(artifact_id)
-            original_session = original_meta.get("session_id")
-            
-            # STRICT SECURITY: Block ALL cross-session copies
-            if target_session_id and target_session_id != original_session:
-                raise ArtifactStoreError(
-                    f"Cross-session copies are not permitted for security reasons. "
-                    f"Artifact {artifact_id} belongs to session '{original_session}', "
-                    f"cannot copy to session '{target_session_id}'. Files can only be "
-                    f"copied within the same session."
-                )
-            
-            # Ensure target session is the same as source
-            copy_session = original_session  # Always use source session
-            
-            # Get original data
-            original_data = await self._retrieve_data(artifact_id)
-            
-            # Prepare copy metadata
-            copy_filename = new_filename or (
-                (original_meta.get("filename", "file") or "file") + "_copy"
-            )
-            copy_summary = summary or f"Copy of {original_meta.get('summary', 'artifact')}"
-            
-            # Merge metadata
-            copy_meta = {**original_meta.get("meta", {})}
-            if new_meta:
-                copy_meta.update(new_meta)
-            
-            # Add copy tracking
-            copy_meta["copied_from"] = artifact_id
-            copy_meta["copy_timestamp"] = datetime.utcnow().isoformat(timespec="seconds") + "Z"
-            copy_meta["copy_within_session"] = original_session
-            
-            # Store the copy using core operations
-            from ..core import CoreStorageOperations
-            core_ops = CoreStorageOperations(self._artifact_store)
-            
-            new_artifact_id = await core_ops.store(
-                data=original_data,
-                mime=original_meta["mime"],
-                summary=copy_summary,
-                filename=copy_filename,
-                session_id=copy_session,  # Always same session
-                meta=copy_meta
-            )
-            
-            logger.info(
-                "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",
-                    "operation": "copy_file"
-                }
-            )
-            
-            return new_artifact_id
-            
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            raise
-        except Exception as e:
-            logger.error(
-                "File copy failed for artifact %s: %s",
-                artifact_id,
-                str(e),
-                extra={
-                    "artifact_id": artifact_id,
-                    "new_file_name": new_filename,  # FIXED: Renamed from 'new_filename'
-                    "target_session_id": target_session_id,
-                    "operation": "copy_file"
-                }
-            )
-            raise ProviderError(f"Copy operation failed: {e}") from e
-
-    async def read_file(
-        self,
-        artifact_id: str,
-        *,
-        encoding: str = "utf-8",
-        as_text: bool = True
-    ) -> Union[str, bytes]:
-        """
-        Read file content directly.
-        """
-        self._check_closed()
-        
-        try:
-            data = await self._retrieve_data(artifact_id)
-            
-            if as_text:
-                try:
-                    return data.decode(encoding)
-                except UnicodeDecodeError as e:
-                    logger.warning(f"Failed to decode with {encoding}: {e}")
-                    raise ProviderError(f"Cannot decode file as text with {encoding} encoding") from e
-            else:
-                return data
-                
-        except (ArtifactNotFoundError, ArtifactExpiredError):
-            raise
-        except Exception as e:
-            logger.error(
-                "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
-
-    async def write_file(
-        self,
-        content: Union[str, bytes],
-        *,
-        filename: str,
-        mime: str = "text/plain",
-        summary: str = "",
-        session_id: str = None,
-        meta: Dict[str, Any] = None,
-        encoding: str = "utf-8",
-        overwrite_artifact_id: str = None
-    ) -> str:
-        """
-        Write content to a new file or overwrite existing WITHIN THE SAME SESSION.
-        """
-        self._check_closed()
-        
-        try:
-            # Convert content to bytes if needed
-            if isinstance(content, str):
-                data = content.encode(encoding)
-            else:
-                data = content
-            
-            # Handle overwrite case with session security check
-            if overwrite_artifact_id:
-                try:
-                    existing_meta = await self._get_record(overwrite_artifact_id)
-                    existing_session = existing_meta.get("session_id")
-                    
-                    # STRICT SECURITY: Can only overwrite files in the same session
-                    if session_id and session_id != existing_session:
-                        raise ArtifactStoreError(
-                            f"Cross-session overwrite not permitted. Artifact {overwrite_artifact_id} "
-                            f"belongs to session '{existing_session}', cannot overwrite from "
-                            f"session '{session_id}'. Overwrite operations must be within the same session."
-                        )
-                    
-                    # Use the existing session if no session_id provided
-                    session_id = session_id or existing_session
-                    
-                    # Delete old version (within same session)
-                    from ..metadata import MetadataOperations
-                    metadata_ops = MetadataOperations(self._artifact_store)
-                    await metadata_ops.delete(overwrite_artifact_id)
-                    
-                except (ArtifactNotFoundError, ArtifactExpiredError):
-                    pass  # Original doesn't exist, proceed with new creation
-            
-            # Store new content using core operations
-            from ..core import CoreStorageOperations
-            core_ops = CoreStorageOperations(self._artifact_store)
-            
-            write_meta = {**(meta or {})}
-            if overwrite_artifact_id:
-                write_meta["overwrote"] = overwrite_artifact_id
-                write_meta["overwrite_timestamp"] = datetime.utcnow().isoformat(timespec="seconds") + "Z"
-                write_meta["overwrite_within_session"] = session_id
-            
-            artifact_id = await core_ops.store(
-                data=data,
-                mime=mime,
-                summary=summary or f"Written file: {filename}",
-                filename=filename,
-                session_id=session_id,
-                meta=write_meta
-            )
-            
-            # FIXED: Use separate variables for logging to avoid 'filename' conflict
-            logger.info(
-                "File written successfully: %s (artifact_id: %s)",
-                filename,
-                artifact_id,
-                extra={
-                    "artifact_id": artifact_id,
-                    "file_name": filename,  # FIXED: Renamed from 'filename'
-                    "bytes": len(data),
-                    "overwrite": bool(overwrite_artifact_id),
-                    "session_id": session_id,
-                    "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 for %s: %s",
-                filename,
-                str(e),
-                extra={
-                    "file_name": filename,  # FIXED: Renamed from 'filename'
-                    "overwrite_artifact_id": overwrite_artifact_id,
-                    "session_id": session_id,
-                    "operation": "write_file"
-                }
-            )
-            raise ProviderError(f"Write operation failed: {e}") from e
-
-    async def get_directory_contents(
-        self,
-        session_id: str,
-        directory_prefix: str = "",
-        limit: int = 100
-    ) -> List[Dict[str, Any]]:
-        """
-        List files in a directory-like structure within a session.
-        """
-        try:
-            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 for session %s: %s",
-                session_id,
-                str(e),
-                extra={
-                    "session_id": session_id,
-                    "directory_prefix": directory_prefix,
-                    "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
-        core_ops = CoreStorageOperations(self._artifact_store)
-        return await core_ops.retrieve(artifact_id)
-
-    # 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.
-        """
-        record = await self._get_record(artifact_id)
-        actual_session = record.get("session_id")
-        
-        if expected_session_id and actual_session != expected_session_id:
-            raise ArtifactStoreError(
-                f"Session access violation: Artifact {artifact_id} belongs to "
-                f"session '{actual_session}', but access was attempted from "
-                f"session '{expected_session_id}'. Cross-session access is not permitted."
-            )
-        
-        return record

chuk_artifacts-0.1.3.dist-info/RECORD

@@ -1,26 +0,0 @@
-chuk_artifacts/__init__.py,sha256=-4S9FWKVcQSa2ZD3GVbmbpGZPcl0cTQN_TFZLSqV7lQ,3605
-chuk_artifacts/admin.py,sha256=9wF-xuxLpKcjJLgZS0rDSeXOAjj4lC9R2VtHpzBuKIA,2931
-chuk_artifacts/base.py,sha256=d3iA3AJR9wF0I3kmppkosPDxaMTgufqI6v_wW5fQfKY,2411
-chuk_artifacts/batch.py,sha256=I5WgWajuzrvqTCkQYYgpzrL1WduzxJchA3Ihv3Xvhcw,4264
-chuk_artifacts/config.py,sha256=MaUzHzKPoBUyERviEpv8JVvPybMzSksgLyj0b7AO3Sc,7664
-chuk_artifacts/core.py,sha256=V9s5YZt9UTA5Kj-1btK5dCB2o_1zeteK0Mo9VaPv4oQ,6488
-chuk_artifacts/exceptions.py,sha256=f-s7Mg7c8vMXsbgqO2B6lMHdXcJQNvsESAY4GhJaV4g,814
-chuk_artifacts/metadata.py,sha256=n_0oQg3DdZG03pmTutHlN2o0os-IJN2Fhwer1_qtY5s,7382
-chuk_artifacts/models.py,sha256=_foXlkr0DprqgztDw5WtlDc-s1OouLgYNp4XM1Ghp-g,837
-chuk_artifacts/presigned.py,sha256=9wGl403HxpfAXcUtkhCSjVCYJftv9uOpyfTs6gQhSZg,11215
-chuk_artifacts/provider_factory.py,sha256=T0IXx1C8gygJzp417oB44_DxEaZoZR7jcdwQy8FghRE,3398
-chuk_artifacts/store.py,sha256=S6sRDLUaHJmzPE4j642wrLFBKR68Wp7y4WWGI7B92tw,23290
-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/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_artifacts/session/session_manager.py,sha256=B-_2AfFM22Vu0ZefF2KJ6vVGPU7naP87Uv4H9sW7oqA,6873
-chuk_artifacts/session/session_operations.py,sha256=9BBXeYfz1AE_QS0iunK7aJH-rUC9a33GF_2DYbBJtdI,14174
-chuk_artifacts-0.1.3.dist-info/licenses/LICENSE,sha256=SG9BmgtPBagPV0d-Fep-msdAGl-E1CeoBL7-EDRH2qA,1066
-chuk_artifacts-0.1.3.dist-info/METADATA,sha256=e2qc0fXl9Y7oJvzBXaFAdUBg4qFNBlYe635vUiybw5U,21188
-chuk_artifacts-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_artifacts-0.1.3.dist-info/top_level.txt,sha256=1_PVMtWXR0A-ZmeH6apF9mPaMtU0i23JE6wmN4GBRDI,15
-chuk_artifacts-0.1.3.dist-info/RECORD,,