streamlit-octostar-utils 0.5.0.dev2__tar.gz → 0.5.0.dev4__tar.gz

{streamlit_octostar_utils-0.5.0.dev2 → streamlit_octostar_utils-0.5.0.dev4}/PKG-INFO

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

{streamlit_octostar_utils-0.5.0.dev2 → streamlit_octostar_utils-0.5.0.dev4}/pyproject.toml

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

{streamlit_octostar_utils-0.5.0.dev2 → streamlit_octostar_utils-0.5.0.dev4}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -1,4 +1,5 @@
 from copy import deepcopy
+import hashlib
 import uuid
 from functools import wraps
 from contextlib import contextmanager
@@ -72,7 +73,7 @@ class NifiEntityModel(BaseModel):
             relationships: List[str]
             label_keys: List[str]
 
-        jwt: str
+        jwt: Optional[str] = None
         ontology_name: str
         ontology_info: OntologyInfoModel
         entity_timestamp: Optional[str]
@@ -388,6 +389,66 @@ class NifiFragmenter(object):
         ]
         return parent_fn(tree, child_results)
 
+    _FRAGMENTS_NAMESPACE = b"octostar.pipeline.fragments"
+
+    @staticmethod
+    def _create_deterministic_uuid(namespace: bytes, data: bytes):
+        return str(
+            uuid.uuid5(
+                uuid.UUID(bytes=hashlib.md5(namespace).digest()),
+                hashlib.md5(data).hexdigest(),
+            )
+        )
+
+    @staticmethod
+    def create_fragment_uuid(os_entity_uid, stable_fragment_identifier, processor_name, os_workspace):
+        """Create a deterministic UUID for a fragment.
+
+        The UUID is stable across re-runs for the same entity, fragment
+        identifier, processor, and workspace -- enabling idempotent fragment
+        creation while ensuring uniqueness across workspaces.
+
+        Args:
+            os_entity_uid: The parent entity UID.
+            stable_fragment_identifier: A unique and stable identifier within
+                the fragmentation (e.g. page range, keyframe number, face index).
+            processor_name: Name of the NiFi processor.
+            os_workspace: The workspace UID the fragment will be written to.
+
+        Returns:
+            A deterministic UUID string.
+        """
+        return NifiFragmenter._create_deterministic_uuid(
+            NifiFragmenter._FRAGMENTS_NAMESPACE,
+            (processor_name + "::" + os_workspace + "::" + os_entity_uid + "::" + stable_fragment_identifier).encode("utf-8"),
+        )
+
+    @staticmethod
+    def resolve_source_entity_uid(entity, fragment_root_source=None) -> str:
+        """Resolve the source_entity_uid to use for child fragments.
+
+        When fragment_root_source is set (a fragment name or stack index),
+        the UID is looked up via entity.get_fragment_root_uid() -- this is
+        necessary when the current entity is a clone that may not be persisted.
+        Otherwise falls back to the entity's own UID.
+
+        Args:
+            entity: A NifiEntity or NifiEntityProxy.
+            fragment_root_source: None to use the entity's own UID, an int
+                to index into the fragments stack, or a string fragmenter
+                keylist name.
+
+        Returns:
+            The resolved source entity UID string.
+        """
+        if fragment_root_source is None:
+            return entity.record["os_entity_uid"]
+        try:
+            idx = int(fragment_root_source)
+            return entity.get_fragment_root_uid(idx)
+        except (ValueError, TypeError):
+            return entity.get_fragment_root_uid(fragment_root_source)
+
 
 class NifiEntityBatch(object):
     def __init__(self, entities, config, config_key):
@@ -1125,6 +1186,48 @@ class NifiEntity(object):
         self.children.append(child_entity_proxy)
         return child_entity_proxy
 
+    def prepare_contents(
+        self,
+        file: Union[Contents, bytes],
+        entity_type: str,
+        filetype: str,
+        temp_blob_key: Optional[str] = None,
+    ) -> Contents:
+        """Build a Contents object from raw bytes, mirroring the same
+        MemoryContents / TemporaryAttachmentContents logic used internally.
+
+        Thread-safe: each call creates independent objects keyed by
+        *temp_blob_key* (for large blobs) and does not mutate the entity tree.
+        The returned Contents can later be passed to ``add_child_fragment``
+        or ``add_child_file`` to skip the redundant bytes→Contents conversion.
+
+        Args:
+            file: A Contents object (returned as-is) or raw bytes.
+            entity_type: Concept / entity type for the contents metadata.
+            filetype: MIME type for the contents metadata.
+            temp_blob_key: Unique key for the temporary blob when the data
+                exceeds the in-memory threshold.  Defaults to a random UUID.
+        """
+        if isinstance(file, Contents):
+            return file
+        if len(file) <= MAX_IN_MEMORY_SIZE_BYTES:
+            return MemoryContents(
+                entity_type=entity_type,
+                filetype=filetype,
+                initial_data=file,
+            )
+        temp_filename = temp_blob_key or f"tmp_{uuid.uuid4()}"
+        temp_contents = TemporaryAttachmentContents(
+            entity_type=entity_type,
+            filetype=filetype,
+            filename=temp_filename,
+            client=self.context.client,
+        )
+        temp_contents.truncate(0)
+        temp_contents.write(file)
+        temp_contents.flush()
+        return temp_contents
+
     def _add_child_attachable(
         self,
         os_workspace,
@@ -1152,24 +1255,11 @@ class NifiEntity(object):
         )
         if isinstance(file, Contents):
             child_entity._contents = file
-        elif len(file) <= MAX_IN_MEMORY_SIZE_BYTES:
-            child_entity._contents = MemoryContents(
-                entity_type=os_entity_type,
-                filetype=filetype,
-                initial_data=file,
-            )
         else:
-            temp_filename = f"tmp_{child_entity.record['os_entity_uid']}"
-            temp_contents = TemporaryAttachmentContents(
-                entity_type=os_entity_type,
-                filetype=filetype,
-                filename=temp_filename,
-                client=self.context.client,
+            child_entity._contents = self.prepare_contents(
+                file, os_entity_type, filetype,
+                temp_blob_key=f"tmp_{child_entity.record['os_entity_uid']}",
             )
-            temp_contents.truncate(0)
-            temp_contents.write(file)
-            temp_contents.flush()
-            child_entity._contents = temp_contents
         child_entity.sync_params = recursive_update_dict(
             child_entity.sync_params,
             {NifiContextManager.SyncFlag.WRITE_CONTENTS: True},