streamlit-octostar-utils 0.4.2.dev1__py3-none-any.whl → 0.4.2.dev2__py3-none-any.whl

streamlit_octostar_utils/api_crafter/contents.py

@@ -11,6 +11,7 @@ Provides a FileIO-like interface for handling entity contents with support for:
 Storage Backends:
 - MemoryContents: In-memory buffer (like BytesIO)
 - WorkspaceAttachmentContents: Octostar workspace attachments with HTTP Range support
+- TemporaryAttachmentContents: Octostar temporary blob storage (user temp bucket)
 """
 
 from abc import ABC, abstractmethod
@@ -29,6 +30,7 @@ class ContentsLocation(Enum):
     """Enumeration of supported content storage locations."""
     MEMORY = "memory"
     WORKSPACE_ATTACHMENT = "workspace_attachment"
+    TEMPORARY_ATTACHMENT = "temporary_attachment"
 
 
 class Contents(ABC):
@@ -42,12 +44,10 @@ class Contents(ABC):
     
     def __init__(
         self,
-        mode: str = "rb",
         entity_type: Optional[str] = None,
         filetype: Optional[str] = None,
         **kwargs
     ):
-        self._mode = mode
         self._entity_type = entity_type
         self._filetype = filetype
         self._closed = False
@@ -105,15 +105,12 @@ class Contents(ABC):
         pass
     
     def readable(self) -> bool:
-        """Check if stream is readable."""
-        return 'r' in self._mode or '+' in self._mode
+        return True
     
     def writable(self) -> bool:
-        """Check if stream is writable."""
-        return 'w' in self._mode or 'a' in self._mode or '+' in self._mode
+        return True
     
     def seekable(self) -> bool:
-        """Check if stream is seekable."""
         return True
     
     @abstractmethod
@@ -126,16 +123,16 @@ class Contents(ABC):
         """Close the stream and release resources."""
         self._closed = True
     
+    @abstractmethod
+    def delete(self):
+        """Delete the contents from their storage backend."""
+        pass
+    
     @property
     def closed(self) -> bool:
         """Check if stream is closed."""
         return self._closed
     
-    @property
-    def mode(self) -> str:
-        """Get the file mode."""
-        return self._mode
-    
     @abstractmethod
     def truncate(self, size: Optional[int] = None) -> int:
         """
@@ -286,6 +283,8 @@ class Contents(ABC):
                 return MemoryContents._from_locator(locator)
             case ContentsLocation.WORKSPACE_ATTACHMENT.value:
                 return WorkspaceAttachmentContents._from_locator(locator, client)
+            case ContentsLocation.TEMPORARY_ATTACHMENT.value:
+                return TemporaryAttachmentContents._from_locator(locator, client)
             case _:
                 raise ValueError(f"Unknown contents location type: {location}")
     
@@ -336,24 +335,19 @@ class MemoryContents(Contents):
     
     def __init__(
         self,
-        mode: str = "r+b",
         entity_type: Optional[str] = None,
         filetype: Optional[str] = None,
         *,
         initial_data: Optional[bytes] = None,
         **kwargs
     ):
-        super().__init__(mode, entity_type, filetype, **kwargs)
+        super().__init__(entity_type, filetype, **kwargs)
         self._buffer = BytesIO(initial_data or b"")
     
     def read(self, size: int = -1) -> bytes:
-        if not self.readable():
-            raise IOError("Contents not readable")
         return self._buffer.read(size)
     
     def write(self, b: bytes) -> int:
-        if not self.writable():
-            raise IOError("Contents not writable")
         return self._buffer.write(b)
     
     def seek(self, offset: int, whence: int = SEEK_SET) -> int:
@@ -370,6 +364,10 @@ class MemoryContents(Contents):
             self._buffer.close()
             super().close()
     
+    def delete(self):
+        """Clear the in-memory buffer."""
+        self._buffer = BytesIO(b"")
+    
     def truncate(self, size: Optional[int] = None) -> int:
         return self._buffer.truncate(size)
     
@@ -435,7 +433,6 @@ class WorkspaceAttachmentContents(Contents):
     
     def __init__(
         self,
-        mode: str = "rb",
         entity_type: Optional[str] = None,
         filetype: Optional[str] = None,
         *,
@@ -446,7 +443,7 @@ class WorkspaceAttachmentContents(Contents):
         chunk_size: int = DEFAULT_CHUNK_SIZE,
         **kwargs
     ):
-        super().__init__(mode, entity_type, filetype, **kwargs)
+        super().__init__(entity_type, filetype, **kwargs)
         self._workspace_id = workspace_id
         self._entity_id = entity_id
         self._client = client
@@ -575,11 +572,7 @@ class WorkspaceAttachmentContents(Contents):
         self._position = 0
     
     def read(self, size: int = -1) -> bytes:
-        if not self.readable():
-            raise IOError("Contents not readable")
-        
-        # If writable or already fully loaded, use buffer
-        if self.writable() or self._fully_loaded:
+        if self._fully_loaded:
             if not self._buffer:
                 self._load_full()
             return self._buffer.read(size)
@@ -613,9 +606,6 @@ class WorkspaceAttachmentContents(Contents):
         return data
     
     def write(self, b: bytes) -> int:
-        if not self.writable():
-            raise IOError("Contents not writable")
-        
         if not self._buffer:
             self._load_full()
         
@@ -684,10 +674,8 @@ class WorkspaceAttachmentContents(Contents):
     
     def close(self):
         if not self._closed:
-            # Flush any pending writes before closing
             if self._modified:
                 self.flush()
-            
             if self._buffer:
                 self._buffer.close()
             if self._http_client:
@@ -695,6 +683,15 @@ class WorkspaceAttachmentContents(Contents):
                 self._http_client = None
             super().close()
     
+    def delete(self):
+        """Delete the entity from the workspace using delete_entity()."""
+        from octostar.utils.workspace import delete_entity
+        
+        delete_entity.sync(
+            os_entity_uid=self._entity_id,
+            client=self._client
+        )
+    
     def truncate(self, size: Optional[int] = None) -> int:
         if not self._buffer:
             self._load_full()
@@ -758,3 +755,160 @@ class WorkspaceAttachmentContents(Contents):
             entity_id=entity_id,
             client=client
         )
+
+
+class TemporaryAttachmentContents(Contents):
+    """
+    Contents implementation for Octostar temporary blob storage.
+    
+    Uses octostar-api utilities (read_temporary_blob, write_temporary_blob,
+    delete_temporary_blob) to store files in the user's temporary S3 bucket.
+    
+    Temporary blobs are keyed by filename (not workspace/entity), and are not
+    associated with any workspace entity. Use WorkspaceAttachmentContents for that.
+    """
+    
+    def __init__(
+        self,
+        entity_type: Optional[str] = None,
+        filetype: Optional[str] = None,
+        *,
+        filename: str,
+        client,
+        initial_data: Optional[bytes] = None,
+        **kwargs
+    ):
+        super().__init__(entity_type, filetype, **kwargs)
+        self._filename = filename
+        self._client = client
+        
+        self._buffer: Optional[BytesIO] = None
+        self._fully_loaded = False
+        self._modified = False
+        
+        if initial_data is not None:
+            self._buffer = BytesIO(initial_data)
+            self._fully_loaded = True
+    
+    def _load_full(self):
+        """Load the entire blob into memory using read_temporary_blob()."""
+        if self._fully_loaded:
+            return
+        
+        from octostar.utils.workspace import read_temporary_blob
+        
+        data = read_temporary_blob.sync(
+            filename=self._filename,
+            decode=False,
+            client=self._client
+        )
+        self._buffer = BytesIO(data or b"")
+        self._fully_loaded = True
+    
+    def read(self, size: int = -1) -> bytes:
+        if not self._buffer:
+            self._load_full()
+        return self._buffer.read(size)
+    
+    def write(self, b: bytes) -> int:
+        if not self._buffer:
+            self._load_full()
+        n = self._buffer.write(b)
+        self._modified = True
+        return n
+    
+    def seek(self, offset: int, whence: int = SEEK_SET) -> int:
+        if not self._buffer:
+            self._load_full()
+        return self._buffer.seek(offset, whence)
+    
+    def tell(self) -> int:
+        if not self._buffer:
+            self._load_full()
+        return self._buffer.tell()
+    
+    def flush(self):
+        """Flush the internal buffer and write to temp bucket if modified."""
+        if self._buffer:
+            self._buffer.flush()
+        
+        if not self._modified or not self._buffer:
+            return
+        
+        from octostar.utils.workspace import write_temporary_blob
+        
+        current_pos = self._buffer.tell()
+        self._buffer.seek(0, SEEK_SET)
+        data = self._buffer.read()
+        self._buffer.seek(current_pos, SEEK_SET)
+        
+        write_temporary_blob.sync(
+            filename=self._filename,
+            file=data,
+            client=self._client
+        )
+        self._modified = False
+    
+    def close(self):
+        if not self._closed:
+            if self._modified:
+                self.flush()
+            if self._buffer:
+                self._buffer.close()
+            super().close()
+    
+    def delete(self):
+        """Delete the blob from the temporary bucket."""
+        from octostar.utils.workspace import delete_temporary_blob
+        
+        delete_temporary_blob.sync(
+            filename=self._filename,
+            client=self._client
+        )
+    
+    def truncate(self, size: Optional[int] = None) -> int:
+        if not self._buffer:
+            self._load_full()
+        self._modified = True
+        return self._buffer.truncate(size)
+    
+    def getvalue(self) -> bytes:
+        if not self._buffer or not self._fully_loaded:
+            self._load_full()
+        return self._buffer.getvalue()
+    
+    def to_locator(self) -> Dict[str, Any]:
+        """
+        Serialize to locator with filename.
+        
+        Returns:
+            {"location": "temporary_attachment", "filename": "..."}
+        """
+        locator = {
+            "location": ContentsLocation.TEMPORARY_ATTACHMENT.value,
+            "filename": self._filename
+        }
+        if self._entity_type:
+            locator["entity_type"] = self._entity_type
+        if self._filetype:
+            locator["filetype"] = self._filetype
+        return locator
+    
+    @staticmethod
+    def _from_locator(locator: Dict[str, Any], client=None) -> 'TemporaryAttachmentContents':
+        """
+        Create TemporaryAttachmentContents from a locator dictionary.
+        
+        Args:
+            locator: Locator dictionary with filename
+            client: Octostar client
+            
+        Returns:
+            New TemporaryAttachmentContents instance
+        """
+        return TemporaryAttachmentContents(
+            entity_type=locator.get("entity_type"),
+            filetype=locator.get("filetype"),
+            filename=locator["filename"],
+            client=client
+        )

streamlit_octostar_utils/api_crafter/nifi.py

@@ -26,7 +26,7 @@ from ..core.dict import recursive_update_dict, travel_dict, jsondict_hash
 from ..core.timestamp import now, string_to_datetime
 from .fastapi import DefaultErrorRoute, Route
 from ..ontology.inheritance import is_child_concept as is_child_concept_fn, get_label_keys
-from .contents import Contents, MemoryContents, WorkspaceAttachmentContents, ContentsLocation
+from .contents import Contents, MemoryContents, WorkspaceAttachmentContents, TemporaryAttachmentContents, ContentsLocation
 
 RELATIONSHIP_ENTITY_NAME = "os_relationship"
 LOCAL_RELATIONSHIP_ENTITY_NAME = "os_workspace_relationship"
@@ -453,11 +453,14 @@ class NifiContextManager(object):
         fetch_concept_relationships = {}
         # FIND FILES TO WRITE
         for entity in entities:
-            if entity.is_child_concept("os_file"):
+            if entity.is_child_concept("os_attachable"):
                 has_write_flag = entity.sync_params.get(NifiContextManager.SyncFlag.WRITE_CONTENTS)
-                is_temp_with_pointer = entity.request.get("is_temporary") and entity.contents_pointer
-                if has_write_flag or is_temp_with_pointer:
-                    if entity.contents:  # Contents instance check
+                is_temporary = entity.request.get("is_temporary")
+                if is_temporary:
+                    if entity._contents and not isinstance(entity._contents, WorkspaceAttachmentContents):
+                        files_to_write.append(entity)
+                elif has_write_flag:
+                    if entity.contents:
                         files_to_write.append(entity)
         # FIND ENTITIES TO UPSERT
         self._find_entities_to_upsert(entities, entities_to_upsert, reserved_fields)
@@ -487,8 +490,7 @@ class NifiContextManager(object):
                 for file in files_to_write:
                     if not file.contents:
                         continue
-                    
-                    # Pass Contents instance directly — write_file uses duck typing
+                    old_contents = file._contents
                     new_file_record = write_file.sync(
                         file.write_os_workspace,
                         "./" + file.record["os_item_name"],
@@ -517,6 +519,11 @@ class NifiContextManager(object):
                         "entity_type": file.record["os_concept"],
                         "filetype": file.record["os_item_content_type"]
                     }
+                    if isinstance(old_contents, TemporaryAttachmentContents):
+                        try:
+                            old_contents.delete()
+                        except Exception:
+                            pass
             # UPSERT ENTITIES
             if entities_to_upsert:
                 new_entities = upsert_entities.sync(
@@ -1062,9 +1069,16 @@ class NifiEntity(object):
         if isinstance(file, Contents):
             child_entity._contents = file
         else:
-            child_entity._contents = MemoryContents(
-                entity_type=FILE_ENTITY_NAME, filetype=filetype, initial_data=file
+            temp_filename = f"tmp_{child_entity.record['os_entity_uid']}"
+            temp_contents = TemporaryAttachmentContents(
+                entity_type=FILE_ENTITY_NAME,
+                filetype=filetype,
+                filename=temp_filename,
+                client=self.context.client,
+                initial_data=file,
             )
+            temp_contents.flush()
+            child_entity._contents = temp_contents
         child_entity.request["contents_pointer"] = child_entity._contents.to_locator()
         return child_entity, child_rel
 

{streamlit_octostar_utils-0.4.2.dev1.dist-info → streamlit_octostar_utils-0.4.2.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.4.2.dev1
+Version: 0.4.2.dev2
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.4.2.dev1.dist-info → streamlit_octostar_utils-0.4.2.dev2.dist-info}/RECORD

@@ -1,9 +1,9 @@
 streamlit_octostar_utils/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 streamlit_octostar_utils/api_crafter/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 streamlit_octostar_utils/api_crafter/celery.py,sha256=IFxeJlxn1C6bP-7bhRlHMGhRJY0Ab8TwB2eUj1DLjaM,33501
-streamlit_octostar_utils/api_crafter/contents.py,sha256=QIcV--VR9inbSWkyR1Qr_imdh8RUPJlx9HWctBlb6m8,24431
+streamlit_octostar_utils/api_crafter/contents.py,sha256=htnCnDqnLx2o0dIk2xioLJ3SSzhqm3n0viJsxyG78pk,29273
 streamlit_octostar_utils/api_crafter/fastapi.py,sha256=7J_GqXouvX0Y7pIpsgO5q14StJDArtGdXhTAvXeIjGI,14372
-streamlit_octostar_utils/api_crafter/nifi.py,sha256=WTEWO1pQQo7dYA1fjM8e2hKawxilbiR-BV6uNNrBMo4,47691
+streamlit_octostar_utils/api_crafter/nifi.py,sha256=He5Hjd0QpUQmE8WF0wXu9WY5xsWMtZOd0JxKbixSFtw,48290
 streamlit_octostar_utils/api_crafter/parallelism.py,sha256=YDQ5aQ6w4bwI_UAydQOOLYQr3svuweMAH-Jdf5jpYPI,29388
 streamlit_octostar_utils/api_crafter/parser/__init__.py,sha256=YeYWF6sdQiCFV_RKNW2t9Vs6KJExE2pbXxWTe_DOayY,107
 streamlit_octostar_utils/api_crafter/parser/combine_fields.py,sha256=ddc44xkajw8MU0peAX_263DL7rPXbTKbHUjpOhRgvyU,8790
@@ -39,7 +39,7 @@ streamlit_octostar_utils/threading/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzp
 streamlit_octostar_utils/threading/async_task_manager.py,sha256=q7N6YZwUvIYMzkSHmsJNheNVCv93c03H6Hyg9uH8pvk,4747
 streamlit_octostar_utils/threading/session_callback_manager.py,sha256=LvZVP4g6tvKtYmI13f2j1sX_7hm61Groqp5xJine9_k,3973
 streamlit_octostar_utils/threading/session_state_hot_swapper.py,sha256=6eeCQI6A42hp4DmW2NQw2rbeR-k9N8DhfBKQdN_fbLU,811
-streamlit_octostar_utils-0.4.2.dev1.dist-info/METADATA,sha256=GgxzBi03rid-K4rP9j-8nGo0tV4zxJlKVbAZx0JZWl4,2413
-streamlit_octostar_utils-0.4.2.dev1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-streamlit_octostar_utils-0.4.2.dev1.dist-info/licenses/LICENSE,sha256=dkwVPyV03fPHHtERnF6RnvRXcll__tud9gWca1RcgnQ,1073
-streamlit_octostar_utils-0.4.2.dev1.dist-info/RECORD,,
+streamlit_octostar_utils-0.4.2.dev2.dist-info/METADATA,sha256=5sx_MMyva6Wx2TZY_5IEhlrRnQh0RMweOzokzTv4ua8,2413
+streamlit_octostar_utils-0.4.2.dev2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+streamlit_octostar_utils-0.4.2.dev2.dist-info/licenses/LICENSE,sha256=dkwVPyV03fPHHtERnF6RnvRXcll__tud9gWca1RcgnQ,1073
+streamlit_octostar_utils-0.4.2.dev2.dist-info/RECORD,,