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

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

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

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

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

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

@@ -5,18 +5,16 @@ from contextlib import contextmanager
 import json
 import jwt
 from typing import List, Union, Optional, Callable
-import base64
 from pydantic import BaseModel, ConfigDict, Field
 import itertools
-import asyncio
 from enum import Enum
-from typing import Dict, Any
+from typing import Dict, Any, Literal
 from datetime import datetime, timezone, timedelta
 from fastapi import Request
 from fastapi.responses import JSONResponse
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
-from octostar.utils.workspace import read_file, upsert_entities, write_file
+from octostar.utils.workspace import upsert_entities, write_file
 from octostar.utils.ontology import fetch_ontology_data
 from octostar.utils.workspace.permissions import get_permissions, PermissionLevel
 from octostar.client import make_client
@@ -26,26 +24,25 @@ 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, TemporaryAttachmentContents, ContentsLocation
+from .contents import Contents, WorkspaceAttachmentContents, TemporaryAttachmentContents, ContentsLocation
+
+
+class RelationshipName(BaseModel):
+    name: str
+    type: Literal["mtm", "otm"]
+
 
 RELATIONSHIP_ENTITY_NAME = "os_relationship"
 LOCAL_RELATIONSHIP_ENTITY_NAME = "os_workspace_relationship"
 FILE_ENTITY_NAME = "os_file"
-GENERIC_RELATIONSHIP_NAME = "related_to"
-FILE_RELATIONSHIP_NAME = "generator_of"
-TAG_RELATIONSHIP_NAME = "has_tag"
 TAG_ENTITY_NAME = "os_tag"
-
-
-def safe_async_run(coro):
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            return asyncio.ensure_future(coro)
-        else:
-            return asyncio.run(coro)
-    except RuntimeError:
-        return asyncio.run(coro)
+FRAGMENT_ENTITY_NAME = "os_fragment"
+GENERIC_RELATIONSHIP = RelationshipName(name="related_to", type="mtm")
+FILE_RELATIONSHIP = RelationshipName(name="generator_of", type="mtm")
+TAG_RELATIONSHIP = RelationshipName(name="has_tag", type="mtm")
+FRAGMENT_RELATIONSHIP = RelationshipName(name="is_fragment_of", type="otm")
+PREVIOUS_FRAGMENT_RELATIONSHIP = RelationshipName(name="has_previous_fragment", type="otm")
+NEXT_FRAGMENT_RELATIONSHIP = RelationshipName(name="has_next_fragment", type="otm")
 
 
 class NifiProxyEntityModel(BaseModel):
@@ -397,10 +394,6 @@ class NifiContextManager(object):
 
     @contextmanager
     def reindex_lock(self, entities: List[Union[dict, "NifiEntity"]], timeout: int = 7200):
-        """Lock entities to prevent reindexing during processing.
-        
-        Sets do_not_reindex_at to a future time on entry, resets on exit.
-        """
         if not entities:
             yield
             return
@@ -579,8 +572,7 @@ class NifiContextManager(object):
                             target["os_workspace"],
                             target["os_concept"],
                             target,
-                            os_relationship_name=rel["os_relationship_name"],
-                            os_relationship_type=rel_type,
+                            relationship=RelationshipName(name=rel["os_relationship_name"], type=rel_type),
                         )
                         child_entity.record = {**child_entity.record, **target}
                         child_entity.record["entity_id"] = child_entity.record[
@@ -961,6 +953,47 @@ class NifiEntity(object):
         self.children.append(child_entity_proxy)
         return child_entity_proxy
 
+    def _add_child_attachable(
+        self,
+        os_workspace,
+        filename,
+        filetype,
+        file: Union[Contents, bytes],
+        fields={},
+        relationship: RelationshipName = FILE_RELATIONSHIP,
+        os_entity_uid=None,
+        os_relationship_uid=None,
+        os_entity_type=FILE_ENTITY_NAME,
+    ):
+        child_entity, child_rel = self.add_child_entity(
+            os_workspace,
+            os_entity_type,
+            {
+                **fields,
+                "os_item_name": filename,
+                "os_item_content_type": filetype,
+                "os_has_attachment": True,
+            },
+            relationship,
+            os_entity_uid,
+            os_relationship_uid,
+        )
+        if isinstance(file, Contents):
+            child_entity._contents = 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,
+                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
+
     def add_mtm_relationship(
         self,
         os_entity_uid_from,
@@ -974,7 +1007,7 @@ class NifiEntity(object):
     ):
         return self._add_entity(
             os_relationship_workspace,
-            (LOCAL_RELATIONSHIP_ENTITY_NAME if os_relationship_workspace else RELATIONSHIP_ENTITY_NAME),
+            LOCAL_RELATIONSHIP_ENTITY_NAME,
             {
                 **relationship_fields,
                 "os_entity_uid_from": os_entity_uid_from,
@@ -1009,33 +1042,22 @@ class NifiEntity(object):
         os_workspace,
         entity_type,
         fields,
-        os_relationship_name=GENERIC_RELATIONSHIP_NAME,
-        os_relationship_type="mtm",
+        relationship: RelationshipName = GENERIC_RELATIONSHIP,
         os_entity_uid=None,
         os_relationship_uid=None,
+        relationship_fields={},
     ):
         child_entity = self._add_entity(os_workspace, entity_type, fields, os_entity_uid)
-        if os_relationship_type == "mtm":
-            child_rel = self.add_mtm_relationship(
-                self.record["os_entity_uid"],
-                self.record["os_concept"],
-                child_entity.record["os_entity_uid"],
-                child_entity.record["os_concept"],
-                os_relationship_name,
-                os_workspace,
-                {},
-                os_relationship_uid,
-            )
-        elif os_relationship_type == "otm":
-            child_rel = self.add_otm_relationship(
-                self.record["os_entity_uid"],
-                self.record["os_concept"],
-                child_entity.record["os_entity_uid"],
-                child_entity.record["os_concept"],
-                os_relationship_name,
-            )
-        else:
-            raise ValueError(f"os_relationship_type is invalid! {os_relationship_type}")
+        child_rel = self._add_relationship(
+            os_workspace,
+            self.record["os_entity_uid"],
+            self.record["os_concept"],
+            child_entity.record["os_entity_uid"],
+            child_entity.record["os_concept"],
+            relationship,
+            relationship_fields,
+            os_relationship_uid,
+        )
         return child_entity, child_rel
 
     def add_child_file(
@@ -1046,49 +1068,86 @@ class NifiEntity(object):
         filetype,
         file: Union[Contents, bytes],
         fields={},
-        os_relationship_name=FILE_RELATIONSHIP_NAME,
-        os_relationship_type="mtm",
+        relationship: RelationshipName = FILE_RELATIONSHIP,
         os_entity_uid=None,
         os_relationship_uid=None,
+        os_entity_type=FILE_ENTITY_NAME,
     ):
-        child_entity, child_rel = self.add_child_entity(
+        return self._add_child_attachable(
             os_workspace,
-            FILE_ENTITY_NAME,
-            {
-                **fields,
-                "os_item_name": filename,
-                "os_item_content_type": filetype,
-                "os_has_attachment": True,
-                "os_parent_folder": os_parent_folder,
-            },
-            os_relationship_name,
-            os_relationship_type,
+            filename,
+            filetype,
+            file,
+            {**fields, "os_parent_folder": os_parent_folder},
+            relationship,
             os_entity_uid,
             os_relationship_uid,
+            os_entity_type
         )
-        if isinstance(file, Contents):
-            child_entity._contents = file
+
+    def _add_relationship(self, os_workspace, from_uid, from_type, to_uid, to_type, rel, relationship_fields={}, rel_uid=None):
+        if rel.type == "mtm":
+            return self.add_mtm_relationship(from_uid, from_type, to_uid, to_type, rel.name, os_workspace, relationship_fields, rel_uid)
+        elif rel.type == "otm":
+            return self.add_otm_relationship(from_uid, from_type, to_uid, to_type, rel.name)
         else:
-            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,
+            raise ValueError(f"relationship.type is invalid! {rel.type}")
+
+    def add_child_fragment(
+        self,
+        os_workspace,
+        source_entity_uid,
+        filename,
+        filetype,
+        file: Union[Contents, bytes],
+        fields={},
+        relationship: RelationshipName = FRAGMENT_RELATIONSHIP,
+        os_entity_uid=None,
+        os_relationship_uid=None,
+        os_entity_type=FRAGMENT_ENTITY_NAME,
+        previous_fragment_uid=None,
+        previous_fragment_relationship_uid=None,
+        previous_fragment_relationship=PREVIOUS_FRAGMENT_RELATIONSHIP,
+        next_fragment_uid=None,
+        next_fragment_relationship_uid=None,
+        next_fragment_relationship=NEXT_FRAGMENT_RELATIONSHIP,
+    ):
+        child_entity, child_rel = self._add_child_attachable(
+            os_workspace,
+            filename,
+            filetype,
+            file,
+            {**fields, "source_entity_uid": source_entity_uid},
+            relationship,
+            os_entity_uid,
+            os_relationship_uid,
+            os_entity_type,
+        )
+        prev_rel, next_rel = None, None
+        fragment_uid = child_entity.record["os_entity_uid"]
+        fragment_type = child_entity.record["os_concept"]
+        if previous_fragment_uid:
+            prev_rel = previous_fragment_relationship or PREVIOUS_FRAGMENT_RELATIONSHIP
+            self._add_relationship(
+                os_workspace, fragment_uid, fragment_type,
+                previous_fragment_uid, os_entity_type,
+                previous_fragment_relationship, {}, previous_fragment_relationship_uid,
             )
-            temp_contents.flush()
-            child_entity._contents = temp_contents
-        child_entity.request["contents_pointer"] = child_entity._contents.to_locator()
-        return child_entity, child_rel
+        if next_fragment_uid:
+            next_rel = next_fragment_relationship or NEXT_FRAGMENT_RELATIONSHIP
+            self._add_relationship(
+                os_workspace, fragment_uid, fragment_type,
+                next_fragment_uid, os_entity_type,
+                next_fragment_relationship, {}, next_fragment_relationship_uid,
+            )
+        return child_entity, child_rel, prev_rel, next_rel
 
     def add_tag(self, os_workspace, name, group, order, color, fields={}):
         return self.add_child_entity(
             os_workspace,
-            "os_tag",
-            {**fields,"name": name, "group": group, "order": order, "color": color},
-            TAG_RELATIONSHIP_NAME,
-            "mtm",
+            TAG_ENTITY_NAME,
+            {**fields, "name": name, "group": group, "order": order, "color": color},
+            TAG_RELATIONSHIP,
         )
 
     def add_annotations(