pyegeria 5.3.9.9.7__py3-none-any.whl → 5.4.0.dev2__py3-none-any.whl

pyegeria/data_designer_omvs.py

@@ -8,8 +8,10 @@ This module provides access to the data-designer OMVS module.
 """
 
 import asyncio
+from os import terminal_size
 
 from httpx import Response
+from prompt_toolkit import data_structures
 
 from pyegeria._client import Client, max_paging_size
 from pyegeria._globals import NO_ELEMENTS_FOUND
@@ -569,6 +571,176 @@ r       replace_all_properties: bool, default = False
         loop.run_until_complete(
             self._async_update_data_structure_w_body(data_struct_guid, body, replace_all_properties))
 
+    def get_data_memberships(self, data_get_fcn: callable, data_struct_guid: str) -> dict | None:
+        data_structure_info = data_get_fcn(data_struct_guid, output_format="JSON")
+        if data_structure_info == "No elements found":
+            return None
+        collection_list = {"DictList": [], "SpecList": [], "CollectionDetails": []}
+        if isinstance(data_structure_info, (dict, list)):
+            member_of_collections = data_structure_info['memberOfCollections']
+            if isinstance(member_of_collections, list):
+                for member_rel in member_of_collections:
+                    props = member_rel["relatedElement"]["properties"]
+                    qname = props.get('qualifiedName', None)
+                    guid = member_rel['relatedElement']['elementHeader']['guid']
+                    description = props.get('description', None)
+                    collection_type = props.get('collectionType', None)
+                    if collection_type == "Data Dictionary":
+                        collection_list["DictList"].append(guid)
+                    elif collection_type == "Data Specification":
+                        collection_list["SpecList"].append(guid)
+                    collection_list["CollectionDetails"].append({"guid":guid, "description":description,
+                                                             "collectionType":collection_type, "qualifiedName":qname})
+            else:
+                return None
+            return collection_list
+        else:
+            return None
+
+    def get_data_memberships_with_dict(self, data_field_elements: dict) -> dict:
+        collection_list = {"DictList_guid": [], "DictList_qn": [], "SpecList_guid": [], "SpecList_qn": [], "CollectionDetails": []}
+        if isinstance(data_field_elements, (dict, list)):
+
+            for member_rel in data_field_elements:
+                type_name = ""
+                props = member_rel["relatedElement"]["properties"]
+                qname = props.get('qualifiedName', None)
+                guid = member_rel['relatedElement']['elementHeader']['guid']
+                description = props.get('description', None)
+                collection_type = props.get('collectionType', None)
+                classifications = member_rel["relatedElement"]["elementHeader"]["classifications"]
+                for classification in classifications:
+                    type_name = classification["type"]['typeName']
+                    if type_name == "DataDictionary":
+                        collection_list["DictList_guid"].append(guid)
+                        collection_list["DictList_qn"].append(qname)
+                    elif type_name == "DataSpec":
+                        collection_list["SpecList_guid"].append(guid)
+                        collection_list["SpecList_qn"].append(qname)
+                collection_list["CollectionDetails"].append({"typeName":type_name, "guid":guid, "description":description,
+                                                                "collectionType": collection_type,
+                                                                "qualifiedName": qname
+                                                                })
+        return collection_list
+
+
+    def get_data_field_rel_elements_dict(self, field_struct: dict)-> dict | str:
+        """return the lists of objects related to a data field"""
+
+        parent_guids = []
+        parent_names = []
+        parent_qnames = []
+
+        data_structure_guids = []
+        data_structure_names = []
+        data_structure_qnames = []
+
+        assigned_meanings_guids = []
+        assigned_meanings_names = []
+        assigned_meanings_qnames = []
+
+        data_class_guids = []
+        data_class_names = []
+        data_class_qnames = []
+
+        external_references_guids = []
+        external_references_names = []
+        external_references_qnames = []
+
+        member_of_data_dicts_guids = []
+        member_of_data_dicts_names = []
+        member_of_data_dicts_qnames = []
+
+        member_of_data_spec_guids = []
+        member_of_data_spec_names = []
+        member_of_data_specs_qnames = []
+
+
+        # terms
+        assigned_meanings = field_struct["assignedMeanings"]
+        for meaning in assigned_meanings:
+            assigned_meanings_guids.append(meaning['relatedElement']['elementHeader']['guid'])
+            assigned_meanings_names.append(meaning['relatedElement']['properties']['displayName'])
+            assigned_meanings_qnames.append(meaning['relatedElement']['properties']['qualifiedName'])
+
+
+        # extract existing related data structure and data field elements
+        other_related_elements = field_struct["otherRelatedElements"]
+
+        for rel in other_related_elements:
+            related_element = rel["relatedElement"]
+            type = related_element["elementHeader"]["type"]["typeName"]
+            guid = related_element["elementHeader"]["guid"]
+            qualified_name = related_element["properties"].get("qualifiedName","") or ""
+            display_name = related_element["properties"].get("displayName","") or ""
+            if type == "DataStructure":
+                data_structure_guids.append(guid)
+                data_structure_names.append(display_name)
+                data_structure_qnames.append(qualified_name)
+
+            elif type == "DataField":
+                parent_guids.append(guid)
+                parent_names.append(display_name)
+                parent_qnames.append(qualified_name)
+
+
+        member_of_collections = field_struct["memberOfCollections"]
+        for collection in member_of_collections:
+            c_type = collection["relatedElement"]["properties"].get("collectionType","") or ""
+            guid = collection["relatedElement"]["elementHeader"]["guid"]
+            name = collection["relatedElement"]["properties"].get("name","") or ""
+            qualifiedName = collection['relatedElement']["properties"].get("qualifiedName","") or ""
+            classifications = collection["relatedElement"]["elementHeader"]["classifications"]
+            for classification in classifications:
+                type_name = classification["type"]['typeName']
+                if type_name == "DataDictionary":
+                    member_of_data_dicts_guids.append(guid)
+                    member_of_data_dicts_names.append(name)
+                    member_of_data_dicts_qnames.append(qualifiedName)
+                elif type_name == "DataSpec":
+                    member_of_data_spec_guids.append(guid)
+                    member_of_data_spec_names.append(name)
+                    member_of_data_specs_qnames.append(qualifiedName)
+
+        return {"parent_guids": parent_guids,
+                "parent_names": parent_names,
+                "parent_qnames": parent_qnames,
+
+                "data_structure_guids": data_structure_guids,
+                "data_structure_names": data_structure_names,
+                "data_structure_qnames": data_structure_qnames,
+
+                "assigned_meanings_guids": assigned_meanings_guids,
+                "assigned_meanings_names": assigned_meanings_names,
+                "assigned_meanings_qnames": assigned_meanings_qnames,
+
+                "data_class_guids": data_class_guids,
+                "data_class_names": data_class_names,
+                "data_class_qnames": data_class_qnames,
+
+                "external_references_guids": external_references_guids,
+                "external_references_names": external_references_names,
+                "external_references_qnames": external_references_qnames,
+
+                "member_of_data_dicts_guids": member_of_data_dicts_guids,
+                "member_of_data_dicts_names": member_of_data_dicts_names,
+                "member_of_data_dicts_qnames": member_of_data_dicts_qnames,
+
+                "member_of_data_spec_guids": member_of_data_spec_guids,
+                "member_of_data_spec_names": member_of_data_spec_names,
+                "member_of_data_specs_qnames": member_of_data_specs_qnames,
+            }
+
+
+    def get_data_field_rel_elements(self, guid:str)-> dict | str:
+        """return the lists of objects related to a data field"""
+
+        data_field_entry = self.get_data_field_by_guid(guid, output_format="JSON")
+        if isinstance(data_field_entry, str):
+            return NO_ELEMENTS_FOUND
+        return self.get_data_field_rel_elements_dict(data_field_entry)
+
+
     async def _async_link_member_data_field(self, parent_data_struct_guid: str, member_data_field_guid: str,
                                             body: dict = None) -> None:
         """
@@ -1125,6 +1297,8 @@ r       replace_all_properties: bool, default = False
             the requesting user is not authorized to issue this request.
 
         """
+        if filter == "*":
+            filter = None
 
         body = {"filter": filter}
         starts_with_s = str(starts_with).lower()
@@ -1918,9 +2092,9 @@ r       replace_all_properties: bool, default = False
         Parameters
         ----------
         parent_data_field_guid: str
-            - the GUID of the parent data class the nested data class will be connected to.
+            - the GUID of the parent data field the nested data field will be connected to.
         nested_data_field_guid: str
-            - the GUID of the nested data class to be connected.
+            - the GUID of the nested data field to be connected.
         body: dict, optional
             - a dictionary containing additional properties.
 
@@ -1977,9 +2151,9 @@ r       replace_all_properties: bool, default = False
         Parameters
         ----------
         parent_data_field_guid: str
-            - the GUID of the parent data class the nested data class will be connected to.
+            - the GUID of the parent data field the nested data field will be connected to.
         nested_data_field_guid: str
-            - the GUID of the nested data class to be connected.
+            - the GUID of the nested data field to be connected.
         body: dict, optional
             - a dictionary containing additional properties.
 
@@ -2708,7 +2882,7 @@ r       replace_all_properties: bool, default = False
         if type(elements) is str:
             return NO_ELEMENTS_FOUND
         if output_format != 'JSON':  # return other representations
-            return self.generate_data_field_output(elements, filter, output_format)
+            return self.generate_data_field_output(elements, None, output_format)
         return elements
 
     def get_data_field_by_guid(self, guid: str, body: str = None, output_format: str = "DICT") -> list | str:
@@ -4944,6 +5118,17 @@ r       replace_all_properties: bool, default = False
         namespace = properties.get("namespace", "") or ""
         version_id = properties.get("versionIdentifier", "") or ""
 
+        # Get data type from extendedProperties and additionalProperties if available
+        extended_properties = properties.get("extendedProperties", {})
+        additional_properties = properties.get("additionalProperties", {})
+
+        # Now lets get the related elements
+        related_elements = self.get_data_field_rel_elements_dict(element)
+        data_dictionaries = related_elements.get("member_of_data_dicts_qnames", [])
+        data_structures = related_elements.get("data_structure_qnames", [])
+        assigned_meanings = related_elements.get("assigned_meanings_qnames", [])
+        parent_names = related_elements.get("parent_qnames", [])
+
         return {
             'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
             'qualified_name': qualified_name, 'namespace': namespace, 'version_identifier': version_id
@@ -4986,13 +5171,33 @@ r       replace_all_properties: bool, default = False
         description = properties.get("description", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
 
-        # Get data type from extendedProperties if available
+        is_nullable = properties.get('isNullable', False)
+        data_type = properties.get('dataType', "") or ""
+        minimum_length = properties.get('minimumLength', 0)
+        length = properties.get('length', 0)
+        precision = properties.get('precision', 0)
+        ordered_values = properties.get('orderedValues', False)
+        sort_order = properties.get('sortOrder', "") or ""
+
+
+
+        # Get data type from extendedProperties and additionalProperties if available
         extended_properties = properties.get("extendedProperties", {})
-        data_type = extended_properties.get("dataType", "")
+        additional_properties = properties.get("additionalProperties", {})
+
+        # Now lets get the related elements
+        related_elements = self.get_data_field_rel_elements_dict(element)
+        data_dictionaries = related_elements.get("member_of_data_dicts_qnames",[])
+        data_structures = related_elements.get("data_structure_qnames",[])
+        assigned_meanings = related_elements.get("assigned_meanings_qnames",[])
+        parent_names = related_elements.get("parent_qnames",[])
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
-            'qualified_name': qualified_name, 'data_type': data_type
+            'display_name': display_name, 'description': description, 'assigned_meanings': assigned_meanings,
+            'qualified_name': qualified_name, 'data_type': data_type, 'guid': guid, 'properties': properties,
+            'is_nullable': is_nullable, 'minimum_length': minimum_length, 'length': length, 'precision': precision,
+            'ordered_values': ordered_values, 'sort_order': sort_order, 'parent_names': parent_names, 'extended_properties': extended_properties,
+            'additional_properties': additional_properties,'data_dictionaries': data_dictionaries, 'data_structures': data_structures
             }
 
     def generate_basic_structured_output(self, elements, filter, output_format) -> str | list:
@@ -5100,5 +5305,8 @@ r       replace_all_properties: bool, default = False
             return self.generate_basic_structured_output(elements, filter, output_format)
 
 
+
+
+
 if __name__ == "__main__":
     print("Data Designer")