streamlit-octostar-utils 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

streamlit_octostar_utils/api_crafter/nifi.py

@@ -163,12 +163,16 @@ class NifiEntityProxy(object):
                     if child_entity.uid == uid_to_search:
                         found_entity = child_entity
                     else:
-                        found_entity = _recursive_search_expanded_proxy(child_entity._proxy, uid_to_search)
+                        found_entity = _recursive_search_expanded_proxy(
+                            child_entity._proxy, uid_to_search
+                        )
                 if found_entity:
                     return found_entity
 
         if not self._proxy:
-            main_entities = itertools.chain(*[b.entities for b in self.context.in_batches])
+            main_entities = itertools.chain(
+                *[b.entities for b in self.context.in_batches]
+            )
             main_entities = {e.record["entity_id"]: e for e in main_entities}
             if main_entities.get(self.uid):
                 self._proxy = main_entities.get(self.uid)
@@ -179,7 +183,9 @@ class NifiEntityProxy(object):
                     self._proxy = found_entity._proxy
                     return self._proxy
             ## TODO: Try to get the entity from the database with query_ontology()
-            raise AttributeError(f"Cannot find children with UUID {self.uid}! It may exist in the database?")
+            raise AttributeError(
+                f"Cannot find children with UUID {self.uid}! It may exist in the database?"
+            )
 
     def __getattr__(self, name):
         if name in self.__dict__:
@@ -213,24 +219,28 @@ class NifiFragmenter(object):
             raise ValueError("Must have at least 2 entities for fragmentation")
         identifier = str(uuid.uuid4())
         for i, entity in enumerate(fragments):
-            travel_dict(entity.request["nifi_attributes"], fragmenter_keylist.split("."), "w")(
-                {"identifier": identifier, "count": count, "index": i}
-            )
+            travel_dict(
+                entity.request["nifi_attributes"], fragmenter_keylist.split("."), "w"
+            )({"identifier": identifier, "count": count, "index": i})
             if "fragment" not in entity.request["config"]:
                 entity.request["config"]["fragment"] = {}
             if "fragments_stack" not in entity.request["config"]["fragment"]:
                 entity.request["config"]["fragment"]["fragments_stack"] = []
-            entity.request["config"]["fragment"]["fragments_stack"].insert(0, fragmenter_keylist)
-            entity.request["nifi_attributes"]["fragments_stack"] = entity.request["config"]["fragment"][
-                "fragments_stack"
-            ]
-            travel_dict(entity.request["config"]["fragment"], fragmenter_keylist.split("."), "w")(
-                {"identifier": identifier, "count": count, "index": i}
+            entity.request["config"]["fragment"]["fragments_stack"].insert(
+                0, fragmenter_keylist
             )
+            entity.request["nifi_attributes"]["fragments_stack"] = entity.request[
+                "config"
+            ]["fragment"]["fragments_stack"]
+            travel_dict(
+                entity.request["config"]["fragment"], fragmenter_keylist.split("."), "w"
+            )({"identifier": identifier, "count": count, "index": i})
 
     def push_defragment_strategy(fragment, defragmenter_config):
         pointer = fragment.request["config"]
-        last_fragmenter_keylist = fragment.request["config"]["fragment"]["fragments_stack"][0]
+        last_fragmenter_keylist = fragment.request["config"]["fragment"][
+            "fragments_stack"
+        ][0]
         for k in ("fragment." + last_fragmenter_keylist).split("."):
             if not pointer.get(k):
                 pointer[k] = {}
@@ -249,7 +259,7 @@ class NifiEntityBatch(object):
 
 class NifiContextManager(object):
     HEADLESS_PROCESSOR_NAME = "headless"
-
+    
     class SyncFlag(Enum):
         UPSERT_ENTITY_ALL = 0  # bool
         UPSERT_ENTITY_SPECIFIC_FIELDS = 1  # 'fields': list of record fields
@@ -270,7 +280,9 @@ class NifiContextManager(object):
     @property
     def ontology(self):
         if not self._ontology:
-            self._ontology = fetch_ontology_data.sync(ontology_name=self.ontology_name, client=self.client)
+            self._ontology = fetch_ontology_data.sync(
+                ontology_name=self.ontology_name, client=self.client
+            )
         return self._ontology
 
     def _config_get(entity, keylist):
@@ -339,7 +351,9 @@ class NifiContextManager(object):
         return self
 
     def get_workspaces_permissions(self, workspace_ids):
-        permissions_to_fetch = list(set(workspace_ids).difference(set(list(self.permissions.keys()))))
+        permissions_to_fetch = list(
+            set(workspace_ids).difference(set(list(self.permissions.keys())))
+        )
         if permissions_to_fetch:
             permissions = get_permissions.sync(permissions_to_fetch, client=self.client)
             self.permissions.update(permissions)
@@ -369,13 +383,18 @@ class NifiContextManager(object):
             entities.append(entity)
             for child_entity in entity.children_entities:
                 if not child_entity.drop_on_output:
-                    if child_entity.output_as_independent or child_entity.output_as_child:
+                    if (
+                        child_entity.output_as_independent
+                        or child_entity.output_as_child
+                    ):
                         if processor_name != NifiContextManager.HEADLESS_PROCESSOR_NAME:
                             child_entity.request["last_processor_name"] = processor_name
                     if child_entity.output_as_independent:
                         if not child_entity._proxy:
                             child_entity.fetch_proxy()
-                        entities.extend(_process_entity(child_entity._proxy, processor_name))
+                        entities.extend(
+                            _process_entity(child_entity._proxy, processor_name)
+                        )
             return entities
 
         entities = itertools.chain(*[b.entities for b in entity_batches])
@@ -386,7 +405,9 @@ class NifiContextManager(object):
             all_entities,
             key=lambda x: string_to_datetime(x.record.get("os_last_updated_at")),
         )
-        self.out_entities = list({e.record["entity_id"]: e for e in all_entities}.values())
+        self.out_entities = list(
+            {e.record["entity_id"]: e for e in all_entities}.values()
+        )
         self.sync_entities()
         return [entity for entity in self.jsonify(self.out_entities)["content"]]
 
@@ -394,19 +415,23 @@ class NifiContextManager(object):
         error_response = DefaultErrorRoute.format_error(exc)
         entity.request["exception"]["code"] = error_response.status_code
         entity.request["exception"]["body"] = json.loads(error_response.body)["message"]
-        travel_dict(entity.request["nifi_attributes"], ["invokehttp", "response", "body"], "w")(
-            entity.request["exception"]["body"]
-        )
-        travel_dict(entity.request["nifi_attributes"], ["invokehttp", "response", "code"], "w")(
-            entity.request["exception"]["code"]
-        )
+        travel_dict(
+            entity.request["nifi_attributes"], ["invokehttp", "response", "body"], "w"
+        )(entity.request["exception"]["body"])
+        travel_dict(
+            entity.request["nifi_attributes"], ["invokehttp", "response", "code"], "w"
+        )(entity.request["exception"]["code"])
         entity.request["nifi_attributes"]["raised_exc"] = True
 
     def sync_entities(self):
         if not self.lazy_sync:
             entities = self.out_entities
         else:
-            entities = [e for e in self.out_entities if e.record["entity_id"] in self.nonlazy_sync_ids]
+            entities = [
+                e
+                for e in self.out_entities
+                if e.record["entity_id"] in self.nonlazy_sync_ids
+            ]
         if not entities:
             return
         reserved_fields = [
@@ -436,16 +461,18 @@ class NifiContextManager(object):
         for entity in entities:
             if entity.sync_params.get(NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS):
                 concept_name = entity.record["entity_type"]
-                rels_to_fetch = entity.sync_params.get(NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS, [])
+                rels_to_fetch = entity.sync_params.get(
+                    NifiContextManager.SyncFlag.FETCH_RELATIONSHIPS, []
+                )
                 for rel in rels_to_fetch:
                     if rel not in fetch_relationships_entities:
                         fetch_relationships_entities[rel] = []
                     fetch_relationships_entities[rel].append(entity)
                 if concept_name not in fetch_concept_relationships:
                     fetch_concept_relationships[concept_name] = set()
-                fetch_concept_relationships[concept_name] = fetch_concept_relationships[concept_name].union(
-                    set(rels_to_fetch)
-                )
+                fetch_concept_relationships[concept_name] = fetch_concept_relationships[
+                    concept_name
+                ].union(set(rels_to_fetch))
         for k in fetch_concept_relationships.keys():
             fetch_concept_relationships[k] = list(fetch_concept_relationships[k])
         # UPSERT ENTITIES
@@ -491,7 +518,7 @@ class NifiContextManager(object):
             file.request["is_temporary"] = False
             file.request["entity_timestamp"] = file.record["os_last_updated_at"]
         # FETCH RELATIONSHIPS
-        """
+        '''
         if fetch_relationships_entities:
             relationship_mappings_info = relationship_mappings.sync_detailed(
                 client=self.client
@@ -547,7 +574,7 @@ class NifiContextManager(object):
                             child_rel.request["entity_timestamp"] = rel.get(
                                 "os_last_updated_at"
                             )
-        """
+        '''
         # CLEAN SYNC PARAMS
         for entity in entities:
             entity.sync_params = {}
@@ -556,10 +583,15 @@ class NifiContextManager(object):
         for entity in entities:
             fields = set()
 
-            if entity.sync_params.get(NifiContextManager.SyncFlag.UPSERT_ENTITY_ALL) or entity.request["is_temporary"]:
+            if (
+                    entity.sync_params.get(NifiContextManager.SyncFlag.UPSERT_ENTITY_ALL)
+                    or entity.request["is_temporary"]
+            ):
                 fields = fields.union(set(list(entity.record.keys())))
 
-            if entity.sync_params.get(NifiContextManager.SyncFlag.UPSERT_ENTITY_SPECIFIC_FIELDS):
+            if entity.sync_params.get(
+                    NifiContextManager.SyncFlag.UPSERT_ENTITY_SPECIFIC_FIELDS
+            ):
                 fields = fields.union(
                     set(
                         entity.sync_params.get(
@@ -570,7 +602,9 @@ class NifiContextManager(object):
                     )
                 )
             if fields:
-                entities_to_upsert.append((entity, [f for f in list(fields) if f not in reserved_fields]))
+                entities_to_upsert.append(
+                    (entity, [f for f in list(fields) if f not in reserved_fields])
+                )
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_val is not None:
@@ -584,7 +618,9 @@ class NifiContextManager(object):
             for entity in entities:
                 if isinstance(entity, NifiEntityProxy):
                     children.extend(entity.children_entities)
-                    children.extend(_recursive_collect_proxies(entity.children_entities))
+                    children.extend(
+                        _recursive_collect_proxies(entity.children_entities)
+                    )
             return children
 
         all_proxies = _recursive_collect_proxies(entities)
@@ -597,21 +633,15 @@ class NifiContextManager(object):
 
 
 class NifiEntity(object):
-    def __init__(self, context, request, record, annotations, all_independent_uids, children=[], contents=None):
+    def __init__(
+        self, context, request, record, annotations, all_independent_uids, children=[], contents=None
+    ):
         self.context = context
         self.request = request
         self.record = record
         self.annotations = annotations
-        assert (
-            self.record.get("os_entity_uid")
-            and self.record.get("entity_id")
-            and self.record["os_entity_uid"] == self.record["entity_id"]
-        )
-        assert (
-            self.record.get("os_concept")
-            and self.record.get("entity_type")
-            and self.record["os_concept"] == self.record["entity_type"]
-        )
+        assert self.record.get("os_entity_uid") and self.record.get("entity_id") and self.record["os_entity_uid"] == self.record["entity_id"]
+        assert self.record.get("os_concept") and self.record.get("entity_type") and self.record["os_concept"] == self.record["entity_type"]
         if "entity_label" not in self.record:
             self.record["entity_label"] = self.label
         children = [c for c in children if isinstance(c, (str, dict))]
@@ -631,7 +661,9 @@ class NifiEntity(object):
         child_types = [c["entity_type"] for c in proxy_entity_children] + [
             c["record"]["entity_type"] for c in full_entity_children
         ]
-        output_as_child = [False] * len(proxy_entity_children) + [True] * len(full_entity_children)
+        output_as_child = [False] * len(proxy_entity_children) + [True] * len(
+            full_entity_children
+        )
         output_as_independent = [uid in all_independent_uids for uid in child_uids]
         full_entity_children = [
             NifiEntity(
@@ -645,7 +677,9 @@ class NifiEntity(object):
             )
             for c in full_entity_children
         ]
-        proxy_otm_children = [NifiOTMRelationshipProxy(**otm_child) for otm_child in proxy_otm_children]
+        proxy_otm_children = [
+            NifiOTMRelationshipProxy(**otm_child) for otm_child in proxy_otm_children
+        ]
         child_proxies = [None] * len(proxy_entity_children) + full_entity_children
         self.children = [
             NifiEntityProxy(
@@ -673,18 +707,21 @@ class NifiEntity(object):
 
     @property
     def sync_params(self):
-        return {NifiContextManager.SyncFlag[k]: v for k, v in (self.request.get("sync_params") or {}).items()}
+        return {
+            NifiContextManager.SyncFlag[k]: v
+            for k, v in (self.request.get("sync_params") or {}).items()
+        }
 
     @sync_params.setter
     def sync_params(self, new_params):
         self.request["sync_params"] = {
-            (k.name if isinstance(k, NifiContextManager.SyncFlag) else k): v for k, v in new_params.items()
+            (k.name if isinstance(k, NifiContextManager.SyncFlag) else k): v
+            for k, v in new_params.items()
         }
 
     @property
     def metadata(self):
         return self.annotations
-
     @metadata.setter
     def metadata(self, new_metadata):
         self.annotations = new_metadata
@@ -707,7 +744,9 @@ class NifiEntity(object):
         contents_pointer = deepcopy(self.request["contents_pointer"])
         ptr_location = contents_pointer.get("location")
         if ptr_location == "attachment" and not contents_pointer.get("pointer"):
-            contents_pointer["pointer"] = f"{self.record['os_workspace']}/{self.record['os_entity_uid']}"
+            contents_pointer["pointer"] = (
+                f"{self.record['os_workspace']}/{self.record['os_entity_uid']}"
+            )
         return self.request["contents_pointer"]
 
     @contents_pointer.setter
@@ -727,7 +766,9 @@ class NifiEntity(object):
         return list(
             filter(
                 lambda x: isinstance(x, NifiOTMRelationshipProxy)
-                or is_child_concept_fn(x.entity_type, RELATIONSHIP_ENTITY_NAME, self.context.ontology),
+                or is_child_concept_fn(
+                    x.entity_type, RELATIONSHIP_ENTITY_NAME, self.context.ontology
+                ),
                 self.children,
             )
         )
@@ -746,12 +787,18 @@ class NifiEntity(object):
         )
         if (
             self.record.get("os_workspace")
-            and (permissions.get(self.record.get("os_workspace")) or PermissionLevel.NONE) >= PermissionLevel.WRITE
+            and (
+                permissions.get(self.record.get("os_workspace")) or PermissionLevel.NONE
+            )
+            >= PermissionLevel.WRITE
         ):
             return self.record["os_workspace"]
         elif (
             self.request.get("fallback_os_workspace")
-            and (permissions.get(self.request.get("fallback_os_workspace")) or PermissionLevel.NONE)
+            and (
+                permissions.get(self.request.get("fallback_os_workspace"))
+                or PermissionLevel.NONE
+            )
             >= PermissionLevel.WRITE
         ):
             return self.request["fallback_os_workspace"]
@@ -760,7 +807,7 @@ class NifiEntity(object):
 
     @property
     def label(self):
-        label_keys = self.request["ontology"]["label_keys"]
+        label_keys = self.request["ontology_info"]["label_keys"]
         label = " ".join([(self.record.get(field) or "") for field in label_keys]).strip()
         if not label:
             label = None
@@ -785,10 +832,14 @@ class NifiEntity(object):
         entity_type = None
         if isinstance(self, NifiEntityProxy):
             entity_type = self.entity_type
-            return entity_type == type or is_child_concept_fn(entity_type, type, self.context.ontology)
+            return entity_type == type or is_child_concept_fn(
+                entity_type, type, self.context.ontology
+            )
         else:
             entity_type = self.record["entity_type"]
-            return entity_type == type or type in self.request["ontology_info"]["parents"]
+            return (
+                entity_type == type or type in self.request["ontology_info"]["parents"]
+            )
 
     def is_fragmented(self) -> bool:
         return bool(self.request["config"].get("fragment", {}).get("fragments_stack"))
@@ -804,7 +855,7 @@ class NifiEntity(object):
                     if _is_sub_fragment_recursive(value):
                         return True
             return False
-
+        
         if not self.is_fragmented():
             return True
         fragment = entity.request.get("config", {}).get("fragment", {})
@@ -831,7 +882,10 @@ class NifiEntity(object):
                 else:
                     proxy_entity_children.append(child)
         proxy_entity_children = list({c.uid: c for c in proxy_entity_children}.values())
-        proxy_entity_children = [{"entity_id": c.uid, "entity_type": c.entity_type} for c in proxy_entity_children]
+        proxy_entity_children = [
+            {"entity_id": c.uid, "entity_type": c.entity_type}
+            for c in proxy_entity_children
+        ]
         proxy_otm_children = list(
             {
                 c.record["os_entity_uid_from"]
@@ -847,7 +901,9 @@ class NifiEntity(object):
             full_entity_children,
             key=lambda x: string_to_datetime(x.record.get("os_last_updated_at")),
         )
-        full_entity_children = list({c.uid: c.to_json() for c in full_entity_children}.values())
+        full_entity_children = list(
+            {c.uid: c.to_json() for c in full_entity_children}.values()
+        )
         children = full_entity_children + proxy_entity_children + proxy_otm_children
         return {
             "request": self.request,
@@ -862,9 +918,9 @@ class NifiEntity(object):
         random_id = str(uuid.uuid4())
         username = self.jwt_data["username"]
         if entity_type == self.record["entity_type"]:
-            ont_parents = self.request["ontology"]["parents"]
-            ont_relationships = self.request["ontology"]["relationships"]
-            ont_label_keys = self.request["ontology"]["label_keys"]
+            ont_parents = self.request["ontology_info"]["parents"]
+            ont_relationships = self.request["ontology_info"]["relationships"]
+            ont_label_keys = self.request["ontology_info"]["label_keys"]
         else:
             ont_parents = self.context.ontology["concepts"][entity_type]["parents"]
             ont_relationships = self.context.ontology["concepts"][entity_type]["relationships"]
@@ -931,7 +987,11 @@ 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
+                if os_relationship_workspace
+                else RELATIONSHIP_ENTITY_NAME
+            ),
             {
                 **relationship_fields,
                 "os_entity_uid_from": os_entity_uid_from,
@@ -1013,7 +1073,9 @@ class NifiEntity(object):
             os_relationship_type,
         )
         child_entity._contents = file
-        child_entity.request["contents_pointer"] = NifiEntityModel.RequestModel.ContentsPointerModel(location="local")
+        child_entity.request["contents_pointer"] = (
+            NifiEntityModel.RequestModel.ContentsPointerModel(location="local")
+        )
         return child_entity, child_rel
 
     def add_tag(self, os_workspace, name, group, order, color):
@@ -1026,20 +1088,21 @@ class NifiEntity(object):
         )
 
     def add_metadata(
-        self,
-        json,
-        merge_method: Callable[[Any, Any], Any],
-        recurse: Union[bool, int] = False,
+        self, json, merge_method: Callable[[Any, Any], Any], recurse: Union[bool, int] = False,
     ):
         if not self.metadata:
             self.metadata = {}
-        self.metadata = recursive_update_dict(self.metadata, json, merge_method, recurse)
+        self.metadata = recursive_update_dict(
+            self.metadata, json, merge_method, recurse
+        )
 
     def propagate_metadata(self, to_entity, fields=None, merge_method=lambda _, v2: v2):
         metadata_to_propagate = deepcopy(self.metadata)
         if fields:
             metadata_to_propagate = {k: v for k, v in self.metadata if k in fields}
-        to_entity.metadata = recursive_update_dict(to_entity.metadata, metadata_to_propagate, merge_method)
+        to_entity.metadata = recursive_update_dict(
+            to_entity.metadata, metadata_to_propagate, merge_method
+        )
 
 
 def more_recent_than(record_a, record_b):
@@ -1098,10 +1161,19 @@ class NifiRoute(Route):
             query_params = request.query_params
             processor_suffix = query_params["processor_suffix"]
             body = await request.json()
-            processor_name = "processor." + self.processor_name + "." + op.replace("-", "_") + "." + processor_suffix
+            processor_name = (
+                "processor."
+                + self.processor_name
+                + "."
+                + op.replace("-", "_")
+                + "."
+                + processor_suffix
+            )
             if op not in self.endpoints.keys():
                 raise StarletteHTTPException(401, f"Route {op} is forbidden for NiFi.")
-            task_id = await self.celery_executor.send_task(self.endpoints[op], args=[body, processor_name])
+            task_id = await self.celery_executor.send_task(
+                self.endpoints[op], args=[body, processor_name]
+            )
             return task_id
 
     @staticmethod

streamlit_octostar_utils/ontology/inheritance.py

@@ -2,7 +2,9 @@ def is_child_concept(type, parent_type, ontology):
     return type == parent_type or parent_type in ontology["concepts"][type]["parents"]
 
 def get_label_keys(type, ontology):
-    parents = list(set(ontology["concepts"][type]["parents"]).add(type))
+    parents = set(ontology["concepts"][type]["parents"])
+    parents.add(type)
+    parents = list(parents)
     parents.reverse()
     label_keys = {} # for guaranteed insertion order
     for parent in parents:
@@ -10,4 +12,4 @@ def get_label_keys(type, ontology):
             if not label_key:
                 continue
             label_keys[label_key] = None
-    return list(label_keys.keys())
+    return list(label_keys.keys())

{streamlit_octostar_utils-0.2.11.dist-info → streamlit_octostar_utils-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.2.11
+Version: 0.2.12
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.2.11.dist-info → streamlit_octostar_utils-0.2.12.dist-info}/RECORD

@@ -2,7 +2,7 @@ streamlit_octostar_utils/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-Y
 streamlit_octostar_utils/api_crafter/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 streamlit_octostar_utils/api_crafter/celery.py,sha256=BXOTGN9egdD75qf-PkccLGAoniilB9PZ_NRchFIjWdw,30051
 streamlit_octostar_utils/api_crafter/fastapi.py,sha256=RKQrStPzG1I1pxsPJvGs_DRrnjlMJbVmu9ObMF2LgZ0,14368
-streamlit_octostar_utils/api_crafter/nifi.py,sha256=IPWP5KasbQxx4G3Vwkh8gBMq0Lkz86EeZNzBJLU_vqg,44607
+streamlit_octostar_utils/api_crafter/nifi.py,sha256=6PSWIFKjv8nzlFGH9IFRI3VrYsISNjDIPyi1RvLJoKk,45810
 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
 streamlit_octostar_utils/api_crafter/parser/entities_parser.py,sha256=zOQoN-p1Gz6ZzxvoX4M1b4Fi3mfmQr5zaNUcp_8gCjw,30016
@@ -28,7 +28,7 @@ streamlit_octostar_utils/octostar/context.py,sha256=TpucK48EbeVy4vDqKd9UULEtr1JO
 streamlit_octostar_utils/octostar/permissions.py,sha256=G5nZQLR-k-5_Xeto4nDTb32828Ga-SHm1mvSB9tz-t4,1565
 streamlit_octostar_utils/ontology/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 streamlit_octostar_utils/ontology/expand_entities.py,sha256=bBt32Dnts3VSzu13QQtPyfYe05IRodD9WfnhNTiBg_w,22749
-streamlit_octostar_utils/ontology/inheritance.py,sha256=1yQ-o1uiVrqHDjLfFTz2oY2DXPF-7sSBG6Dfwcc_W98,548
+streamlit_octostar_utils/ontology/inheritance.py,sha256=8GA2an1hbHfa6p993tIyfFLrewJHRUIFOw7dmvL8geU,583
 streamlit_octostar_utils/ontology/validation.py,sha256=0cXxEq8vQ63qxn4WianTioTcsmpsg4jEXVyI4R6x1gE,1051
 streamlit_octostar_utils/style/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 streamlit_octostar_utils/style/common.py,sha256=TKfjV9-sIoJChGM7Ewg3uPsz5sMmPxFwmc0o3L4D8Qo,1496
@@ -36,7 +36,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.2.11.dist-info/METADATA,sha256=wSZhgOw-dcpP-5eXNB6uHBB4JWdP3vkbP6LzsK1Io54,2330
-streamlit_octostar_utils-0.2.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-streamlit_octostar_utils-0.2.11.dist-info/licenses/LICENSE,sha256=dkwVPyV03fPHHtERnF6RnvRXcll__tud9gWca1RcgnQ,1073
-streamlit_octostar_utils-0.2.11.dist-info/RECORD,,
+streamlit_octostar_utils-0.2.12.dist-info/METADATA,sha256=F_7r20YG6UyKEMKxD4yxdm6vs7xbBeW0hakEMAI6kwg,2330
+streamlit_octostar_utils-0.2.12.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+streamlit_octostar_utils-0.2.12.dist-info/licenses/LICENSE,sha256=dkwVPyV03fPHHtERnF6RnvRXcll__tud9gWca1RcgnQ,1073
+streamlit_octostar_utils-0.2.12.dist-info/RECORD,,