pyegeria 5.4.0.dev3__py3-none-any.whl → 5.4.0.dev6__py3-none-any.whl

pyegeria/data_designer_omvs.py

@@ -577,7 +577,7 @@ r       replace_all_properties: bool, default = False
             return None
         collection_list = {"DictList": [], "SpecList": [], "CollectionDetails": []}
         if isinstance(data_structure_info, (dict, list)):
-            member_of_collections = data_structure_info['memberOfCollections']
+            member_of_collections = data_structure_info.get('memberOfCollections',"")
             if isinstance(member_of_collections, list):
                 for member_rel in member_of_collections:
                     props = member_rel["relatedElement"]["properties"]
@@ -624,7 +624,7 @@ r       replace_all_properties: bool, default = False
         return collection_list
 
 
-    def get_data_field_rel_elements_dict(self, field_struct: dict)-> dict | str:
+    def get_data_rel_elements_dict(self, el_struct: dict)-> dict | str:
         """return the lists of objects related to a data field"""
 
         parent_guids = []
@@ -653,11 +653,24 @@ r       replace_all_properties: bool, default = False
 
         member_of_data_spec_guids = []
         member_of_data_spec_names = []
-        member_of_data_specs_qnames = []
+        member_of_data_spec_qnames = []
+
+        member_data_field_guids = []
+        member_data_field_names = []
+        member_data_field_qnames = []
+
+        nested_data_classes_guids = []
+        nested_data_classes_names = []
+        nested_data_classes_qnames = []
+
+        specialized_data_classes_guids = []
+        specialized_data_classes_names = []
+        specialized_data_classes_qnames = []
+
 
 
         # terms
-        assigned_meanings = field_struct["assignedMeanings"]
+        assigned_meanings = el_struct.get("assignedMeanings", {})
         for meaning in assigned_meanings:
             assigned_meanings_guids.append(meaning['relatedElement']['elementHeader']['guid'])
             assigned_meanings_names.append(meaning['relatedElement']['properties']['displayName'])
@@ -665,26 +678,26 @@ r       replace_all_properties: bool, default = False
 
 
         # 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"]
+        other_related_elements = el_struct.get("otherRelatedElements",None)
+        if other_related_elements:
+            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 = el_struct.get("memberOfCollections",{})
         for collection in member_of_collections:
             c_type = collection["relatedElement"]["properties"].get("collectionType","") or ""
             guid = collection["relatedElement"]["elementHeader"]["guid"]
@@ -700,7 +713,33 @@ r       replace_all_properties: bool, default = False
                 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)
+                    member_of_data_spec_qnames.append(qualifiedName)
+
+        member_data_fields = el_struct.get("memberDataFields", {})
+        for data_field in member_data_fields:
+            member_data_field_guids.append(data_field["elementHeader"]["guid"])
+            member_data_field_names.append(data_field["properties"]["displayName"])
+            member_data_field_qnames.append(data_field["properties"]["qualifiedName"])
+
+        data_classes = el_struct.get("assignedDataClasses", {})
+        for data_class in data_classes:
+            data_class_guids.append(data_class['relatedElement']["elementHeader"]["guid"])
+            data_class_names.append(data_class['relatedElement']["properties"]["displayName"])
+            data_class_qnames.append(data_class['relatedElement']["properties"]["qualifiedName"])
+
+        nested_data_classes = el_struct.get("nestedDataClasses", {})
+        for nested_data_class in nested_data_classes:
+            nested_data_classes_guids.append(nested_data_class['relatedElement']["elementHeader"]["guid"])
+            nested_data_classes_names.append(nested_data_class['relatedElement']["properties"]["displayName"])
+            nested_data_classes_qnames.append(nested_data_class['relatedElement']["properties"]["qualifiedName"])
+
+        specialized_data_classes = el_struct.get("specializedDataClasses", {})
+        for nested_data_class in specialized_data_classes:
+            specialized_data_classes_guids.append(nested_data_class['relatedElement']["elementHeader"]["guid"])
+            specialized_data_classes_names.append(nested_data_class['relatedElement']["properties"]["displayName"])
+            specialized_data_classes_qnames.append(nested_data_class['relatedElement']["properties"]["qualifiedName"])
+
+        mermaid = el_struct.get("mermaidGraph", {})
 
         return {"parent_guids": parent_guids,
                 "parent_names": parent_names,
@@ -718,6 +757,14 @@ r       replace_all_properties: bool, default = False
                 "data_class_names": data_class_names,
                 "data_class_qnames": data_class_qnames,
 
+                "nested_data_class_guids": nested_data_classes_guids,
+                "nested_data_class_names": nested_data_classes_names,
+                "nested_data_class_qnames": nested_data_classes_qnames,
+
+                "specialized_data_class_guids": specialized_data_classes_guids,
+                "specialized_data_class_names": specialized_data_classes_names,
+                "specialized_data_class_qnames": specialized_data_classes_qnames,
+
                 "external_references_guids": external_references_guids,
                 "external_references_names": external_references_names,
                 "external_references_qnames": external_references_qnames,
@@ -728,7 +775,13 @@ r       replace_all_properties: bool, default = False
 
                 "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,
+                "member_of_data_spec_qnames": member_of_data_spec_qnames,
+
+                "member_data_field_guids": member_data_field_guids,
+                "member_data_field_names": member_data_field_names,
+                "member_data_field_qnames": member_data_field_qnames,
+
+                "mermaid" : mermaid,
             }
 
 
@@ -737,8 +790,17 @@ r       replace_all_properties: bool, default = False
 
         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)
+            return None
+        return self.get_data_rel_elements_dict(data_field_entry)
+
+    def get_data_class_rel_elements(self, guid:str)-> dict | str:
+        """return the lists of objects related to a data class"""
+
+        data_class_entry = self.get_data_class_by_guid(guid, output_format="JSON")
+        if isinstance(data_class_entry, str):
+            return None
+        return self.get_data_rel_elements_dict(data_class_entry)
+
 
 
     async def _async_link_member_data_field(self, parent_data_struct_guid: str, member_data_field_guid: str,
@@ -2526,6 +2588,8 @@ r       replace_all_properties: bool, default = False
             }
 
         """
+        if filter == "*":
+            filter = None
         starts_with_s = str(starts_with).lower()
         ends_with_s = str(ends_with).lower()
         ignore_case_s = str(ignore_case).lower()
@@ -2643,7 +2707,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()
         ends_with_s = str(ends_with).lower()
@@ -3391,7 +3456,7 @@ r       replace_all_properties: bool, default = False
         """
         replace_all_properties_s = str(replace_all_properties).lower()
 
-        url = (f"{base_path(self, self.view_server)}/data-class/{data_class_guid}/update?"
+        url = (f"{base_path(self, self.view_server)}/data-classes/{data_class_guid}/update?"
                f"replaceAllProperties={replace_all_properties_s}")
 
         await self._async_make_request("POST", url, body_slimmer(body))
@@ -3609,7 +3674,7 @@ r       replace_all_properties: bool, default = False
         """
 
         url = (f"{base_path(self, self.view_server)}/data-classes/{parent_data_class_guid}"
-               f"/member-data-classes/{child_data_class_guid}/detach")
+               f"/nested-data-classes/{child_data_class_guid}/detach")
 
         if body is None:
             await self._async_make_request("POST", url)
@@ -3708,7 +3773,7 @@ r       replace_all_properties: bool, default = False
         """
 
         url = (f"{base_path(self, self.view_server)}/data-classes/{parent_data_class_guid}"
-               f"/specializeddata-classes/{child_data_class_guid}/attach")
+               f"/specialized-data-classes/{child_data_class_guid}/attach")
 
         if body is None:
             await self._async_make_request("POST", url)
@@ -3807,7 +3872,7 @@ r       replace_all_properties: bool, default = False
         """
 
         url = (f"{base_path(self, self.view_server)}/data-classes/{parent_data_class_guid}"
-               f"/specializeddata-classes/{child_data_class_guid}/detach")
+               f"/specialized-data-classes/{child_data_class_guid}/detach")
 
         if body is None:
             await self._async_make_request("POST", url)
@@ -4091,6 +4156,7 @@ r       replace_all_properties: bool, default = False
             }
 
         """
+
         starts_with_s = str(starts_with).lower()
         ends_with_s = str(ends_with).lower()
         ignore_case_s = str(ignore_case).lower()
@@ -4208,7 +4274,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()
@@ -4444,7 +4511,7 @@ r       replace_all_properties: bool, default = False
         else:
             response: Response = await self._async_make_request("POST", url)
 
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        elements = response.json().get("element", NO_ELEMENTS_FOUND)
         if type(elements) is str:
             return NO_ELEMENTS_FOUND
         if output_format != 'JSON':  # return other representations
@@ -5123,15 +5190,20 @@ r       replace_all_properties: bool, default = False
         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", [])
+        associated_elements = self.get_data_rel_elements_dict(element)
+        data_specs = associated_elements.get("member_of_data_spec_qnames", [])
+        # data_structures = associated_elements.get("member_of_data_struct_qnames", [])
+        assigned_meanings = associated_elements.get("assigned_meanings_qnames", [])
+        parent_names = associated_elements.get("parent_qnames", [])
+        member_data_fields = associated_elements.get("member_data_field_qnames", [])
+
+        mermaid = element.get('mermaidGraph', "") or ""
+        # mermaid_md = "```mermaid\n" + mermaid + "\n```"
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
-            'qualified_name': qualified_name, 'namespace': namespace, 'version_identifier': version_id
+             'GUID': guid, 'display_name': display_name, 'qualified_name': qualified_name, 'description': description, 'data_fields': member_data_fields,
+            'data_specification': data_specs,  'namespace': namespace, 'version_identifier': version_id, 'properties': properties,
+            'extended_properties': extended_properties, 'additional_properties': additional_properties, 'mermaid': mermaid
             }
 
     def _extract_data_class_properties(self, element: dict) -> dict:
@@ -5150,9 +5222,37 @@ r       replace_all_properties: bool, default = False
         description = properties.get("description", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
 
+        data_type = properties.get('dataType', "") or ""
+        match_property_names = properties.get('matchPropertyNames', []) or []
+        match_threshold = properties.get('matchThreshold', 0)
+        allow_duplicate_values = properties.get('allowDuplicateValues', False)
+        is_case_sensitive = properties.get('isCaseSensitive', False)
+        is_nullable = properties.get('isNullable', False)
+
+        # 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
+        associated_elements = self.get_data_rel_elements_dict(element)
+        data_dictionaries = associated_elements.get("member_of_data_dicts_qnames", [])
+        assigned_meanings = associated_elements.get("assigned_meanings_qnames", [])
+        parent_names = associated_elements.get("parent_qnames", [])
+        nested_data_classes = associated_elements.get("nested_data_class_qnames", [])
+        specialized_data_classes = associated_elements.get("specialized_data_class_qnames", [])
+        mermaid = element.get('mermaidGraph', "") or ""
+
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
-            'qualified_name': qualified_name
+             'GUID': guid,'display_name': display_name, 'qualified_name': qualified_name,'description': description,
+            'assigned_meanings': assigned_meanings,
+             'data_type': data_type, 'match_property_names': match_property_names,
+            'match_threshold': match_threshold, 'allow_duplicate_values': allow_duplicate_values,
+            'is_case_sensitive': is_case_sensitive, 'is_nullable': is_nullable,
+            'properties': properties, 'parent_names': parent_names, 'nested_data_classes': nested_data_classes,
+            'specialized_data_classes': specialized_data_classes,
+            'extended_properties': extended_properties,
+            'additional_properties': additional_properties, 'data_dictionaries': data_dictionaries,
+             'mermaid': mermaid
             }
 
     def _extract_data_field_properties(self, element: dict) -> dict:
@@ -5179,25 +5279,26 @@ r       replace_all_properties: bool, default = False
         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", {})
         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",[])
+        associated_elements = self.get_data_rel_elements_dict(element)
+        data_dictionaries = associated_elements.get("member_of_data_dicts_qnames",[])
+        data_structures = associated_elements.get("data_structure_qnames",[])
+        assigned_meanings = associated_elements.get("assigned_meanings_qnames",[])
+        parent_names = associated_elements.get("parent_qnames",[])
+        data_class = associated_elements.get("data_class_qnames",[])
+        mermaid = element.get('mermaidGraph', "") or ""
 
         return {
-            'display_name': display_name, 'description': description, 'assigned_meanings': assigned_meanings,
-            'qualified_name': qualified_name, 'data_type': data_type, 'guid': guid, 'properties': properties,
+            'GUID': guid,'display_name': display_name, 'qualified_name': qualified_name,'description': description,
+            'assigned_meanings': assigned_meanings,
+             'data_type': data_type, 'data_class': data_class,  '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
+            'additional_properties': additional_properties,'data_dictionaries': data_dictionaries, 'data_structures': data_structures, 'mermaid': mermaid
             }
 
     def generate_basic_structured_output(self, elements, filter, output_format) -> str | list:
@@ -5243,10 +5344,10 @@ r       replace_all_properties: bool, default = False
         Returns:
             Formatted output as string or list of dictionaries
         """
-        if output_format in ["MD", "FORM", "REPORT", "LIST"]:
+        if output_format in ["MD", "FORM", "REPORT", "LIST", "MERMAID"]:
             # Define columns for LIST format
             columns = [{'name': 'Structure Name', 'key': 'display_name'},
-                {'name': 'Qualified Name', 'key': 'qualified_name'}, {'name': 'Namespace', 'key': 'namespace'},
+                {'name': 'Qualified Name', 'key': 'qualified_name','format': True}, {'name': 'Namespace', 'key': 'namespace'},
                 {'name': 'Version', 'key': 'version_identifier'},
                 {'name': 'Description', 'key': 'description', 'format': True}]
 
@@ -5268,10 +5369,10 @@ r       replace_all_properties: bool, default = False
         Returns:
             Formatted output as string or list of dictionaries
         """
-        if output_format in ["MD", "FORM", "REPORT", "LIST"]:
+        if output_format in ["DICT", "MD", "FORM", "REPORT", "LIST", "MERMAID"]:
             # Define columns for LIST format
             columns = [{'name': 'Class Name', 'key': 'display_name'},
-                {'name': 'Qualified Name', 'key': 'qualified_name'},
+                {'name': 'Qualified Name', 'key': 'qualified_name','format': True},
                 {'name': 'Description', 'key': 'description', 'format': True}]
 
             return generate_output(elements=elements, search_string=filter, entity_type="Data Class",
@@ -5292,10 +5393,10 @@ r       replace_all_properties: bool, default = False
         Returns:
             Formatted output as a string or list of dictionaries
         """
-        if output_format in ["MD", "FORM", "REPORT", "LIST", "DICT"]:
+        if output_format in ["MD", "FORM", "REPORT", "LIST", "DICT", "MERMAID"]:
             # Define columns for LIST format
             columns = [{'name': 'Field Name', 'key': 'display_name'},
-                {'name': 'Qualified Name', 'key': 'qualified_name'}, {'name': 'Data Type', 'key': 'data_type'},
+                {'name': 'Qualified Name', 'key': 'qualified_name','format': True}, {'name': 'Data Type', 'key': 'data_type'},
                 {'name': 'Description', 'key': 'description', 'format': True}]
 
             return generate_output(elements=elements, search_string=filter, entity_type="Data Field",

pyegeria/glossary_browser_omvs.py

@@ -90,7 +90,7 @@ class GlossaryBrowser(Client):
             category_qualified_names = cat_md_qn.rstrip(',')
 
         result = {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
+            'GUID': guid, 'properties': properties, 'display_name': display_name, 'description': description,
             'language': language, 'usage': usage, 'qualified_name': qualified_name
         }
 
@@ -312,7 +312,7 @@ class GlossaryBrowser(Client):
         aliases = ", ".join(properties.get("aliases", "")) or ""
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'aliases': aliases,
+            'GUID': guid, 'properties': properties, 'display_name': display_name, 'aliases': aliases,
             'summary': summary, 'description': description, 'examples': examples, 'usage': usage,
             'version identifier': pub_version, 'qualified_name': qualified_name, 'status': status
             }
@@ -626,7 +626,7 @@ class GlossaryBrowser(Client):
         qualified_name = properties.get("qualifiedName", "") or ""
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
+            'GUID': guid, 'properties': properties, 'display_name': display_name, 'description': description,
             'qualified_name': qualified_name
             }
 
@@ -1051,7 +1051,6 @@ class GlossaryBrowser(Client):
             "class": "SearchStringRequestBody", "searchString": search_string, "effectiveTime": effective_time,
             "typeName": type_name,
             }
-        body = body_slimmer(body)
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
                f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
@@ -2176,11 +2175,11 @@ class GlossaryBrowser(Client):
                 parent_guid = parent['elementHeader']['guid']
                 parent_name = parent['glossaryCategoryProperties'].get('displayName', '---')
                 parent_info = {
-                    'guid': parent_guid, 'name': parent_name
+                    'GUID': parent_guid, 'name': parent_name
                     }
 
             return {
-                'guid': category_guid, 'name': display_name, 'qualifiedName': qualified_name,
+                'GUID': category_guid, 'name': display_name, 'qualifiedName': qualified_name,
                 'description': description, 'parent': parent_info, 'children': children
                 }
 

pyegeria/output_formatter.py

@@ -27,6 +27,7 @@ def make_preamble(obj_type: str, search_string: str, output_format: str = 'MD')
               depending on the output format.
     """
     # search_string = search_string if search_string else "All Elements"
+    elements_md = ""
     elements_action = "Update " + obj_type
     if output_format == "FORM":
         preamble = f"\n# Update {obj_type} Form - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
@@ -34,7 +35,7 @@ def make_preamble(obj_type: str, search_string: str, output_format: str = 'MD')
             preamble +=  f"\t {obj_type} found from the search string:  `{search_string}`\n\n"
         return preamble, elements_action
     elif output_format == "REPORT":
-        elements_md = (f"# {obj_type} Report - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+        elements_md += (f"# {obj_type} Report - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
                        f"\t{obj_type}  found from the search string:  `{search_string}`\n\n")
         elements_action = None
         return elements_md, elements_action
@@ -56,17 +57,28 @@ def make_md_attribute(attribute_name: str, attribute_value: str, output_type: st
     output = ""
     if isinstance(attribute_value,str):
         attribute_value = attribute_value.strip() if attribute_value else ""
-    attribute_title = attribute_name.title() if attribute_name else ""
+    elif isinstance(attribute_value,list):
+        attribute_value = ",\n".join(attribute_value)
+    if attribute_name:
+        if attribute_name.upper() == "GUID":
+            attribute_title = attribute_name.upper()
+        else:
+            attribute_title = attribute_name.title()
+    else:
+        attribute_title = ""
+
     if output_type in ["FORM", "MD"]:
+        if attribute_name.lower() == "mermaid":
+            return "\n"
         output = f"## {attribute_title}\n{attribute_value}\n\n"
     elif output_type == "REPORT":
-        if attribute_title == 'Mermaid Graph':
+        if attribute_title in ['Mermaid Graph', 'Mermaid']:
             output = f"## Mermaid Graph\n```mermaid\n{attribute_value}\n```\n"
         elif attribute_value:
             output = f"## {attribute_title}\n{attribute_value}\n\n"
     return output
 
-def format_for_markdown_table(text: str) -> str:
+def format_for_markdown_table(text: str, guid: str = None) -> str:
     """
     Format text for markdown tables by replacing newlines with spaces and escaping pipe characters.
     No truncation is applied to allow full-length text display regardless of console width.
@@ -80,9 +92,13 @@ def format_for_markdown_table(text: str) -> str:
     if not text:
         return ""
     # Replace newlines with spaces and escape pipe characters
-    return text.replace("\n", " ").replace("|", "\\|")
+    t = text.replace("\n", " ").replace("|", "\\|")
+    if '::' in t and guid:
+        t = f" [{t}](#{guid}) "
+    return t
 
-def generate_entity_md(elements: List[Dict], 
+
+def generate_entity_md(elements: List[Dict],
                       elements_action: str, 
                       output_format: str, 
                       entity_type: str,
@@ -112,28 +128,29 @@ def generate_entity_md(elements: List[Dict],
         # Get additional properties if function is provided
         additional_props = {}
         if get_additional_props_func:
-            additional_props = get_additional_props_func(element, props['guid'], output_format)
+            additional_props = get_additional_props_func(element,props['GUID'], output_format)
+
 
         # Format header based on output format
         if output_format in ['FORM', 'MD']:
             elements_md += f"# {elements_action}\n\n"
             elements_md += f"## {entity_type} Name \n\n{props['display_name']}\n\n"
         elif output_format == 'REPORT':
-            elements_md += f"# {entity_type} Name: {props['display_name']}\n\n"
+            elements_md += f'<a id="{props["GUID"]}"></a>\n\n# {entity_type} Name: {props["display_name"]}\n\n'
         else:
             elements_md += f"## {entity_type} Name \n\n{props['display_name']}\n\n"
 
         # Add common attributes
         for key, value in props.items():
-            if key not in ['guid', 'properties', 'display_name']:
+            if key not in [ 'properties', 'display_name']:
                 elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
 
         # Add additional properties
         for key, value in additional_props.items():
             elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
 
-        # Add GUID
-        elements_md += make_md_attribute("GUID", props['guid'], output_format)
+        # # Add GUID
+        # elements_md += make_md_attribute("GUID",props['GUID'], output_format)
 
         # Add separator if not the last element
         if element != elements[-1]:
@@ -186,7 +203,7 @@ def generate_entity_md_table(elements: List[Dict],
         # Get additional properties if function is provided
         additional_props = {}
         if get_additional_props_func:
-            additional_props = get_additional_props_func(element, props['guid'], output_format)
+            additional_props = get_additional_props_func(element,props['GUID'], output_format)
 
         # Build row
         row = "| "
@@ -202,7 +219,7 @@ def generate_entity_md_table(elements: List[Dict],
 
             # Format the value if needed
             if 'format' in column and column['format']:
-                value = format_for_markdown_table(value)
+                value = format_for_markdown_table(value, props['GUID'])
 
             row += f"{value} | "
 
@@ -240,7 +257,7 @@ def generate_entity_dict(elements: List[Dict],
         # Get additional properties if function is provided
         additional_props = {}
         if get_additional_props_func:
-            additional_props = get_additional_props_func(element, props['guid'], output_format)
+            additional_props = get_additional_props_func(element,props['GUID'], output_format)
 
         # Create entity dictionary
         entity_dict = {}
@@ -308,6 +325,8 @@ def extract_basic_dict(elements: Union[Dict, List[Dict]]) -> Union[Dict, List[Di
 
     result = []
     for element in elements:
+        if element is None:
+            continue
         body = {'guid': element['elementHeader']['guid']}
         for key in element['properties']:
             body[key] = element['properties'][key]