streamlit-octostar-utils 0.4.2.dev16__tar.gz → 0.4.2.dev18__tar.gz

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/PKG-INFO

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

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/pyproject.toml

@@ -5,7 +5,7 @@ include = '\.pyi?$'
 
 [tool.poetry]
 name = "streamlit-octostar-utils"
-version = "0.4.2-dev.16"
+version = "0.4.2-dev.18"
 description = ""
 license = "MIT"
 authors = ["Octostar"]

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/streamlit_octostar_utils/api_crafter/celery.py

@@ -28,7 +28,7 @@ logging.getLogger("pottery").setLevel(logging.WARNING)
 from celery.app.defaults import DEFAULTS as CELERY_DEFAULTS
 import urllib
 
-from .fastapi import Route, CommonModels, DefaultErrorRoute
+from .fastapi import Route, CommonModels, DefaultErrorRoute, RemoteTraceback
 
 
 class RedisFileLock:
@@ -700,7 +700,12 @@ class CeleryExecutor(object):
 
     async def get_task_result(self, task_id, remove=False):
         def _try_get_task_data(celery_app, task_id):
-            celery_app.AsyncResult(task_id).get()  # will raise if the task raised an exception
+            async_result = celery_app.AsyncResult(task_id)
+            if async_result.state in ("FAILURE", "RETRY", "REVOKED"):
+                exc = async_result.result
+                if not isinstance(exc, BaseException):
+                    exc = RuntimeError(str(exc))
+                raise exc from RemoteTraceback(async_result.traceback)
 
         def _read_task_data(out_folder, task_id):
             serialized_data = CelerySerialized(folder=out_folder, redis_client=self.redis_client)

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/streamlit_octostar_utils/api_crafter/contents.py

@@ -29,6 +29,7 @@ class ContentsLocation(Enum):
     MEMORY = "memory"
     WORKSPACE_ATTACHMENT = "workspace_attachment"
     TEMPORARY_ATTACHMENT = "temporary_attachment"
+    REFERENCE = "reference"
 
 
 class Contents(ABC):
@@ -283,6 +284,8 @@ class Contents(ABC):
                 return WorkspaceAttachmentContents._from_locator(locator, client)
             case ContentsLocation.TEMPORARY_ATTACHMENT.value:
                 return TemporaryAttachmentContents._from_locator(locator, client)
+            case ContentsLocation.REFERENCE.value:
+                return ReferenceContents._from_locator(locator, client)
             case _:
                 raise ValueError(f"Unknown contents location type: {location}")
     
@@ -954,3 +957,100 @@ class TemporaryAttachmentContents(Contents):
             filename=locator["filename"],
             client=client
         )
+
+
+class ReferenceContents(Contents):
+    """
+    Contents that delegates reads to one source and writes to another.
+
+    Useful for fragments that share their parent's attachment but need their
+    own write target for content syncing.  When the sync system calls
+    ``read()``, the data is read from ``read_source``. On ``write()``, the data is written to ``write_target``.
+
+    ``read_source`` is **not owned** by this instance — it will not be closed
+    or deleted, since it may be shared across multiple fragments.
+    """
+
+    def __init__(
+        self,
+        entity_type: Optional[str] = None,
+        filetype: Optional[str] = None,
+        *,
+        read_source: Optional[Contents] = None,
+        write_target: Optional[Contents] = None,
+        **kwargs
+    ):
+        super().__init__(entity_type, filetype, **kwargs)
+        self._read_source = read_source
+        self._write_target = write_target
+
+    # ==================== FileIO Interface ====================
+
+    def read(self, size: int = -1) -> bytes:
+        if self._read_source:
+            return self._read_source.read(size)
+        return b""
+
+    def write(self, b: bytes) -> int:
+        if self._write_target:
+            return self._write_target.write(b)
+        raise IOError("ReferenceContents has no write_target configured")
+
+    def seek(self, offset: int, whence: int = SEEK_SET) -> int:
+        if self._read_source:
+            return self._read_source.seek(offset, whence)
+        return 0
+
+    def tell(self) -> int:
+        if self._read_source:
+            return self._read_source.tell()
+        return 0
+
+    def flush(self):
+        if self._write_target:
+            self._write_target.flush()
+
+    def close(self):
+        if not self._closed:
+            if self._write_target:
+                self._write_target.close()
+            super().close()
+
+    def delete(self):
+        if self._write_target:
+            self._write_target.delete()
+
+    def truncate(self, size: Optional[int] = None) -> int:
+        if self._write_target:
+            return self._write_target.truncate(size)
+        return 0
+
+    def getvalue(self) -> bytes:
+        if self._read_source:
+            return self._read_source.getvalue()
+        return b""
+
+    # ==================== Locator Interface ====================
+
+    def to_locator(self) -> Dict[str, Any]:
+        locator: Dict[str, Any] = {
+            "location": ContentsLocation.REFERENCE.value,
+            "read_source": self._read_source.to_locator() if self._read_source else None,
+            "write_target": self._write_target.to_locator() if self._write_target else None,
+        }
+        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) -> 'ReferenceContents':
+        read_source = Contents.from_locator(locator.get("read_source"), client)
+        write_target = Contents.from_locator(locator.get("write_target"), client)
+        return ReferenceContents(
+            entity_type=locator.get("entity_type"),
+            filetype=locator.get("filetype"),
+            read_source=read_source,
+            write_target=write_target,
+        )

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/streamlit_octostar_utils/api_crafter/fastapi.py

@@ -267,6 +267,11 @@ class ErrorLogFilter(logging.Filter):
         return True
 
 
+class RemoteTraceback(Exception):
+    """Holds a formatted traceback string from a remote worker process."""
+    pass
+
+
 class DefaultErrorRoute:
     DEFAULT_STATUS_CODE_MAPPINGS = {
         StarletteHTTPException: lambda exc: exc.status_code,
@@ -329,7 +334,11 @@ class DefaultErrorRoute:
         if len(message) > MAX_ERROR_MESSAGE_BYTES:
             message = message[-MAX_ERROR_MESSAGE_BYTES:]
         try:
-            tcbk = "\n".join(traceback.format_exception(exc))
+            remote_cause = getattr(exc, "__cause__", None)
+            if isinstance(remote_cause, RemoteTraceback):
+                tcbk = str(remote_cause)
+            else:
+                tcbk = "\n".join(traceback.format_exception(exc))
             if len(tcbk) > MAX_ERROR_TRACEBACK_BYTES:
                 tcbk = tcbk[-MAX_ERROR_TRACEBACK_BYTES:]
         except:

{streamlit_octostar_utils-0.4.2.dev16 → streamlit_octostar_utils-0.4.2.dev18}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -489,7 +489,7 @@ class NifiContextManager(object):
                     old_contents.delete()
                 except Exception:
                     pass
-            new_entity = target.last_flush_result or {}
+            new_entity = target.last_flush_result
             if new_entity:
                 file.record = {**record, **new_entity}
                 file.record["entity_id"] = file.record["os_entity_uid"]