pyegeria 5.4.4.7__py3-none-any.whl → 5.4.5__py3-none-any.whl

md_processing/dr_egeria.py

@@ -12,8 +12,8 @@ from .md_commands.project_commands import process_link_project_dependency_comman
 
 log_format = "{time} | {level} | {function} | {line} | {message} | {extra}"
 logger.remove()
-logger.add(sys.stderr, level="INFO", format=log_format, colorize=True)
-logger.add("debug_log.log", rotation="1 day", retention="1 week", compression="zip", level="TRACE", format=log_format,
+logger.add(sys.stderr, level="ERROR", format=log_format, colorize=True)
+logger.add("debug_log.log", rotation="1 day", retention="1 week", compression="zip", level="INFO", format=log_format,
            colorize=True)
 
 from rich import print
@@ -226,7 +226,7 @@ def process_md_file(input_file: str, output_folder:str, directive: str, server:
                 result = process_link_agreement_item_command(client, current_block, directive)
             elif potential_command in ['Link Collection->Resource', 'Detach Collection->Resource']:
                 result = process_attach_collection_command(client, current_block, directive)
-            elif potential_command in ['Link Member->Collection', 'Detach Member->Collection', 'Add Member', 'Remove Member',
+            elif potential_command in ['Add Member->Collection', 'Detach Member->Collection', 'Add Member', 'Remove Member',
                                        'Add to Folder', 'Remove from Folder']:
                 result = process_add_to_collection_command(client, current_block, directive)
             elif potential_command in ['Link Subscriber->Subscription', 'Detach Subscriber->Subscription']:

md_processing/md_commands/data_designer_commands.py

@@ -453,6 +453,8 @@ def process_data_spec_upsert_command(egeria_client: EgeriaTech, txt: str, direct
     in_data_spec_valid = attributes.get('In Data Specification', {}).get('valid', None)
     in_data_spec_exists = attributes.get('In Data Specification', {}).get('exists', None)
     output_set = make_format_set_name_from_type(object_type)
+    object_type = "DataSpec"
+    print(Markdown(parsed_output['display']))
 
     if directive == "display":
 
@@ -480,7 +482,7 @@ def process_data_spec_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
                 body = set_update_body(object_type, attributes)
-                body['properties'] = set_element_prop_body("Data Spec", qualified_name, attributes)
+                body['properties'] = set_element_prop_body(object_type, qualified_name, attributes)
 
                 egeria_client.update_collection(guid, body)
                 if status:
@@ -490,7 +492,7 @@ def process_data_spec_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                 update_element_dictionary(qualified_name, {
                     'guid': guid, 'display_name': display_name
                 })
-                return egeria_client.get_collection_by_guid(guid, element_type='Data Specification',
+                return egeria_client.get_collection_by_guid(guid, element_type='Data-Specification-DrE',
                                                             output_format='MD', output_format_set=output_set)
 
             elif object_action == "Create":
@@ -670,6 +672,7 @@ def process_data_structure_upsert_command(egeria_client: EgeriaTech, txt: str,
     guid = parsed_output.get('guid', None)
     output_set = make_format_set_name_from_type(object_type)
 
+    print(Markdown(parsed_output['display']))
 
     if directive == "display":
         return None
@@ -731,6 +734,8 @@ def process_data_structure_upsert_command(egeria_client: EgeriaTech, txt: str,
 
                     update_data_collection_memberships(egeria_client, object_type, data_spec_guid_list, "DataSpec", guid,
                                                        display_name, merge_update)
+                    update_data_collection_memberships(egeria_client, object_type, data_dict_guid_list, "DataSpec",
+                                                       guid,display_name, merge_update)
                     core_props += f"## In Data Dictionary\n\n{data_dict_name_list}\n\n"
                     core_props += f"## In Data Specification\n\n{data_spec_name_list}\n\n"
                     logger.success(f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___")
@@ -764,13 +769,13 @@ def process_data_structure_upsert_command(egeria_client: EgeriaTech, txt: str,
 
                         if in_data_dictionary:
                             logger.info(f"Will add to data dictionary(s) `{in_data_dictionary}`")
-                            result = add_member_to_data_collections(egeria_client, in_data_dictionary, display_name,
-                                                                    guid)
+                            add_member_to_data_collections(egeria_client, data_dict_guid_list,
+                                                                    display_name,guid)
                             core_props += f"## In Data Dictionary\n\n{data_dict_name_list}\n\n"
 
                         if data_spec_guid_list:
-                            result = add_member_to_data_collections(egeria_client, data_spec_guid_list, display_name,
-                                                                    guid)
+                            add_member_to_data_collections(egeria_client, data_spec_guid_list,
+                                                                    display_name, guid)
                             core_props += f"## In Data Specifications\n\n`{data_spec_name_list}`\n\n"
 
                         logger.info(f"Created Element `{display_name}` with GUID {guid}\n\n___")

md_processing/md_commands/ext_ref_commands.py

@@ -223,11 +223,11 @@ def process_link_to_external_reference_command(egeria_client: EgeriaTech, txt: s
     attributes = parsed_output['attributes']
 
     element_guid = attributes.get('Element Name', {}).get('guid', None)
-    external_reference_guid = attributes.get('Media Reference', {}).get('guid', None)
+    external_reference_guid = attributes.get('External Reference', {}).get('guid', None)
 
     valid = parsed_output['valid']
     exists = element_guid is not None and external_reference_guid is not None
-    prop_body = set_rel_prop_body("MediaReference", attributes)
+    prop_body = set_rel_prop_body("ExternalReferenceLink", attributes)
 
     if directive == "display":
 
@@ -276,7 +276,7 @@ def process_link_to_external_reference_command(egeria_client: EgeriaTech, txt: s
                     return
 
                 else:
-                    body = set_rel_request_body_for_type("CitedDocumentLink", attributes)
+                    body = set_rel_request_body_for_type("ExternalReferencesLink", attributes)
                     body['properties'] = prop_body
 
                     egeria_client.link_external_reference(element_guid,

md_processing/md_commands/product_manager_commands.py

@@ -40,6 +40,7 @@ EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
 EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
 EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
 EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
+LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", None)
 
 load_commands('commands.json')
 debug_level = DEBUG_LEVEL
@@ -170,17 +171,32 @@ def process_collection_upsert_command(egeria_client: EgeriaTech, txt: str, direc
     exists = parsed_output['exists']
 
     qualified_name = parsed_output.get('qualified_name', None)
+
     guid = parsed_output.get('guid', None)
 
-    print(Markdown(parsed_output['display']))
+
 
     logger.debug(json.dumps(parsed_output, indent=4))
 
     attributes = parsed_output['attributes']
 
     display_name = attributes['Display Name'].get('value', None)
+    version = attributes['Version Identifier'].get('value', None)
     status = attributes.get('Status', {}).get('value', None)
     output_set = make_format_set_name_from_type(object_type)
+    if object_type in ["Root Collection", "Folder"]:
+        obj = "Collection"
+        if object_type == "Folder":
+            qn_prefix = "Folder"
+        elif object_type == "Root Collection":
+            qn_prefix = "Root"
+
+        qualified_name = egeria_client.__create_qualified_name__(qn_prefix, display_name, LOCAL_QUALIFIER,
+                                                                 version_identifier=version)
+
+    else:
+        obj = object_type
+    print(Markdown(parsed_output['display']))
 
     if directive == "display":
 
@@ -194,10 +210,7 @@ def process_collection_upsert_command(egeria_client: EgeriaTech, txt: str, direc
 
     elif directive == "process":
         try:
-            if object_type in ["Root Collection", "Folder"]:
-                obj = "Collection"
-            else:
-                obj = object_type
+
 
             if object_action == "Update":
                 if not exists:
@@ -791,6 +804,7 @@ def process_add_to_collection_command(egeria_client: EgeriaTech, txt: str,
             "source": source,
             "notes": notes,
             }
+        label = "Add Member"
         try:
             if object_action in["Detach", "Unlink", "Remove"]:
                 if not exists:
@@ -832,6 +846,7 @@ def process_add_to_collection_command(egeria_client: EgeriaTech, txt: str,
                     body = set_rel_request_body(object_type, attributes)
 
                     body['properties'] = prop_body
+                    body = body_slimmer(body)
                     egeria_client.add_to_collection(collection_guid,
                                                         element_guid, body)
                     msg = f"==>Linked `{element_guid}` to collection `{collection_guid}` \n"

md_processing/md_commands/view_commands.py

@@ -8,6 +8,7 @@ import time
 from typing import Optional
 
 from loguru import logger
+from pydantic import ValidationError
 from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
@@ -16,7 +17,7 @@ from md_processing.md_processing_utils.common_md_proc_utils import (parse_upsert
 from md_processing.md_processing_utils.common_md_utils import update_element_dictionary
 from md_processing.md_processing_utils.extraction_utils import (extract_command_plus, update_a_command)
 from md_processing.md_processing_utils.md_processing_constants import (load_commands, ERROR)
-from pyegeria import DEBUG_LEVEL, body_slimmer, print_basic_exception
+from pyegeria import DEBUG_LEVEL, body_slimmer, print_basic_exception, print_validation_error
 from pyegeria.egeria_tech_client import EgeriaTech, NO_ELEMENTS_FOUND
 from pyegeria.config import settings
 from pyegeria.logging_configuration import config_logging
@@ -202,8 +203,9 @@ def process_format_set_action(
                 return json.dumps(output, indent=4)
             elif isinstance(output, (str, list)) and output_format in ["REPORT", "LIST", "FORM"]:
                 return output ## used to include pre-amble
-            elif isinstance(output, (str, list)) and output_format == "HTML":
-                return output
+            elif isinstance(output, (str, list)) and output_format in ["HTML", "MERMAID"]:
+                return '\n\n'.join(output)
+
 
             elif isinstance(output, (str, list)) and output_format == "TABLE":
                 return "Table is not a legal output format for this command."
@@ -211,6 +213,8 @@ def process_format_set_action(
 
     except PyegeriaException as e:
         print_basic_exception(e)
+    except ValidationError as e:
+        print_validation_error(e)
 
 
 def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
@@ -226,6 +230,9 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
     print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
+    if parsed_output is None:
+        logger.error(f"No valid output found for command '{command}'.")
+        return None
 
     attributes = parsed_output['attributes']
 

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -37,6 +37,7 @@ from pyegeria._globals import DEBUG_LEVEL
 # Constants
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
 EGERIA_USAGE_LEVEL = os.environ.get("EGERIA_USAGE_LEVEL", "Advanced")
+LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", None)
 console = Console(width=EGERIA_WIDTH)
 
 debug_level = DEBUG_LEVEL
@@ -812,7 +813,7 @@ def proc_el_id(egeria_client: EgeriaTech, element_type: str, qn_prefix: str, ele
         logger.info(msg)
 
         if q_name is None and qualified_name is None:
-            q_name = egeria_client.__create_qualified_name__(qn_prefix, element_name, version_identifier=version)
+            q_name = egeria_client.__create_qualified_name__(qn_prefix, element_name, LOCAL_QUALIFIER, version)
             update_element_dictionary(q_name, {'display_name': element_name})
 
         elif qualified_name:

md_processing/md_processing_utils/md_processing_constants.py

@@ -212,7 +212,7 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "Link Subscriber->Subscription", "Detach Subscriber->Subscription",
                 "Link Collection->Resource", "Attach Collection->Resource",
                 "Unlink Collection->Resource", "Detach Collection->Resource",
-                "Add Member to Collection", "Add Member", "Member->Collection", 'Add Member', 'Add to Folder',
+                "Add Member to Collection", "Add Member", "Add Member->Collection", 'Add Member', 'Add to Folder',
                 "Remove Member from Collection", "Remove Member->Collection", ' Remove Member', 'Remove from Folder',
                 "View Governance Definitions", "View Gov Definitions",
                 "List Governance Definitions", "List Gov Definitions",

pyegeria/_output_formats.py

@@ -123,6 +123,7 @@ COMMON_COLUMNS = [
     Column(name='Status', key='status'),
 ]
 
+
 COMMON_METADATA_COLUMNS = [
     Column(name='GUID', key='guid', format=True),
     Column(name='Type Name', key='type_name'),
@@ -152,6 +153,12 @@ COMMON_FORMATS_ALL = Format(
     columns=COMMON_COLUMNS,
 )
 
+
+MERMAID_FORMAT = Format(
+    types = ["MERMAID"],
+    columns = [Column(name='Mermaid', key='mermaid')]
+)
+
 EXT_REF_COLUMNS = COMMON_COLUMNS + [
     Column(name='Reference Title', key='reference_title'),
     Column(name='Reference Abstract', key='reference_abstract'),
@@ -466,7 +473,7 @@ base_output_format_sets = FormatSetDict({
         aliases=["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                  "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         annotations=COMMON_ANNOTATIONS,
-        formats=[COLLECTION_DICT, COLLECTION_TABLE, COLLECTION_REPORT, COMMON_FORMATS_ALL],  # Reusing common formats
+        formats=[MERMAID_FORMAT, COLLECTION_DICT, COLLECTION_TABLE, COLLECTION_REPORT, COMMON_FORMATS_ALL],  # Reusing common formats
         action=ActionParameter(
             function="CollectionManager.find_collections",
             required_params=["search_string"],
@@ -523,7 +530,38 @@ base_output_format_sets = FormatSetDict({
             spec_params={"output_format": "DICT"},
         )
     ),
-    "Digital Products": FormatSet(
+    "Digital-Product-Catalog": FormatSet(
+        target_type="DigitalProductCatalog",
+        heading="Catalogs for Digital Products",
+        description="Attributes generic to all Digital Product Catalogs..",
+        aliases=["Product Catalog", "DataProductCatalog"],
+        annotations={"Wikilinks": ["[[Digital Products]]"]},
+        formats=[
+            Format(
+                types=["DICT", "TABLE", "LIST", "MD", "FORM"],
+                columns=COLLECTIONS_MEMBERS_COLUMNS
+            ),
+            Format(
+                types=["REPORT", "HTML"],
+                columns=COLLECTIONS_MEMBERS_COLUMNS + [
+                    Column(name="GUID", key='GUID'),
+                    Column(name="Mermaid", key='mermaid'),
+                ]),
+            Format(
+                types=["MERMAID"],
+                columns= [
+                    Column(name="Mermaid", key='mermaid'),
+                ])
+        ],
+        action=ActionParameter(
+            function="CollectionManager.find_collections",
+            required_params=["search_string"],
+            optional_params=OPTIONAL_PARAMS,
+            spec_params={"metadata_element_types": ["DigitalProductCatalog"]},
+        ),
+    ),
+
+    "Digital-Products": FormatSet(
         target_type="DigitalProduct",
         heading="Digital Product Information",
         description="Attributes useful to Digital Products.",
@@ -531,7 +569,7 @@ base_output_format_sets = FormatSetDict({
         annotations={},
         formats=[
             Format(
-                types=["REPORT", "DICT", "TABLE", "LIST"],
+                types=["FORM", "DICT", "TABLE", "LIST"],
                 columns=COMMON_COLUMNS + [
                     Column(name="Status", key='status'),
                     Column(name='Product Name', key='product_name'),
@@ -543,6 +581,27 @@ base_output_format_sets = FormatSetDict({
                     Column(name='Members', key='members', format=True),
                     Column(name='Uses Products', key='uses_digital_products'),
                     Column(name='Used by Products', key='used_by_digital_products'),
+                    Column(name='Product Manager', key='assigned_actors'),
+                    Column(name='License', key='governed_by'),
+                    Column(name='Solution Blueprint', key='solution_designs'),
+                ]),
+            Format(
+                types=[ "REPORT", "HTML"],
+                columns=COMMON_COLUMNS + [
+                    Column(name="Status", key='status'),
+                    Column(name='Product Name', key='product_name'),
+                    Column(name='Identifier', key='identifier'),
+                    Column(name='Maturity', key='maturity'),
+                    Column(name='Service Life', key='service_life'),
+                    Column(name='Next Version', key='next_version'),
+                    Column(name='Withdraw Date', key='withdraw_date'),
+                    Column(name='Members', key='members', format=True),
+                    Column(name='Uses Products', key='uses_digital_products'),
+                    Column(name='Used by Products', key='used_by_digital_products'),
+                    Column(name='Product Manager', key='assigned_actors'),
+                    Column(name='License', key='governed_by'),
+                    Column(name='Solution Blueprint', key='solution_designs'),
+                    Column(name="Mermaid",key = "mermaid")
                 ],
             )
         ],
@@ -630,11 +689,20 @@ base_output_format_sets = FormatSetDict({
         description="Attributes useful to Data Structures.",
         aliases=["Data Structure", "DataStructures", "Data Structures", "Data Struct", "DataStructure"],
         annotations={"wikilinks": ["[[Data Structure]]"]},
-        formats=[Format(types=["ALL"], columns=COMMON_COLUMNS +
+        formats=[Format(types=["FORM", "DICT", "LIST"], columns=COMMON_COLUMNS +
+                                               [
+                                                   Column(name="In Data Specifications", key='in_data_spec'),
+                                                   Column(name="In Data Dictionaries", key='in_data_dictionary'),
+                                                   Column(name="Member Data Fields", key='member_data_fields')                                               ]
+                        ),  # Reusing common formats and columns
+                Format(types=["REPORT"], columns=COMMON_COLUMNS +
                                                [
-                                                   Column(name="Member Of", key='member_of_collections')
+                                                   Column(name="In Data Specifications", key='in_data_spec'),
+                                                   Column(name="In Data Dictionaries", key='in_data_dictionary'),
+                                                   Column(name="Member Data Fields", key='member_data_fields'),
+                                                   Column(name="Mermaid", key='mermaid')
                                                ]
-                        )],  # Reusing common formats and columns
+                        )],
         action=ActionParameter(
             function="DataDesigner.find_data_structures",
             required_params=["search_string"],
@@ -642,13 +710,24 @@ base_output_format_sets = FormatSetDict({
         )
     ),
 
-    "DataField": FormatSet(
+    "Data Fields": FormatSet(
         target_type="Data Field",
         heading="Data Structure Information",
         description="Attributes useful to Data Structures.",
         aliases=["Data Field", "Data Fields", "DataFields"],
         annotations={"wikilinks": ["[[Data Field]]"]},
-        formats=[Format(types=["ALL"], columns=COMMON_COLUMNS)],  # Reusing common formats and columns
+        formats=[Format(types=["MD", "FORM", "DICT"], columns=COMMON_COLUMNS + [
+                                                        Column(name="In Data Dictionaries", key='in_data_dictionary'),
+                                                        Column(name="In Data Structure", key='in_data_structure')]),
+                 Format(types=["REPORT"], columns=COMMON_COLUMNS +
+                                                  [
+                                                      Column(name="In Data Structure", key='in_data_structure'),
+                                                      Column(name="In Data Dictionaries", key='in_data_dictionary'),
+                                                      Column(name="Member Data Fields", key='member_data_fields'),
+                                                      Column(name="Mermaid", key='mermaid')
+                                                  ]
+                        )],
+
         action=ActionParameter(
             function="DataDesigner.find_data_fields",
             required_params=["search_string"],
@@ -1090,7 +1169,7 @@ generated_format_sets = FormatSetDict({
                                              'metadata_element_types': ['DataDictionary']})),
     'Data-Field-DrE': FormatSet(target_type='Data-Field-DrE', heading='Data-Field-DrE Attributes',
                                 description='Auto-generated format for Data Field (Create).', formats=[
-            Format(types=['ALL'], columns=[Column(name='Display Name', key='display_name'),
+            Format(types=['ALL', 'MD'], columns=[Column(name='Display Name', key='display_name'),
                                            Column(name='Description', key='description'),
                                            Column(name='Category', key='category'),
                                            Column(name='Status', key='element_status'),

pyegeria/collection_manager.py

@@ -5567,6 +5567,39 @@ class CollectionManager(Client2):
                 uses_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
             added_props["uses_digital_products"] = uses_digital_products_list[:-2]
 
+        resources = element.get("resourceList", "")
+        if isinstance(resources, (list | dict)):
+            resource_list = ""
+            for resource in resources:
+                resource_list += f"{resource.get('properties',{}).get('qualifiedName', None)}, "
+            added_props["resource_list"] = resource_list[:-2] if resource_list else ""
+
+        actors = element.get("assignedActors", "")
+        if isinstance(actors, (list | dict)):
+            actor_list = ""
+            for actor in actors:
+                actor_type = actor['relatedElement']['elementHeader']['type']['typeName']
+                actor_qname = actor['relatedElement']['properties']['qualifiedName']
+                actor_list += actor_qname
+            added_props["actor_list"] = actor_list[:-2] if actor_list else ""
+
+        governed_by = element.get("governedBy", "")
+        if isinstance(governed_by, (list | dict)):
+            governed_by_list = ""
+            for gov in governed_by:
+                license_type = gov['relatedElement']['properties'].get('typeName',"")
+                license_type_qname = gov['relatedElement']['properties'].get('qualifiedName','')
+                governed_by_list += license_type_qname
+            added_props["governed_list"] = governed_by_list[:-2] if governed_by_list else ""
+
+        solution_designs = element.get("solutionDesigns", "")
+        if isinstance(solution_designs, (list | dict)):
+            solution_design_list = ""
+            for design in solution_designs:
+                solution_design_qname = design['relatedElement']['properties'].get('qualifiedName', "")
+                solution_design_list += solution_design_qname
+            added_props["solution_design_list"] = solution_design_list[:-2] if solution_design_list else ""
+
         return added_props
 
     def _extract_agreement_properties(self, element: dict, guid: str, output_format: str) -> dict:

pyegeria/data_designer.py

@@ -1277,23 +1277,21 @@ class DataDesigner(Client2):
             assigned_meanings_qnames.append(meaning['relatedElement']['properties']['qualifiedName'])
 
         # extract existing related data structure and data field elements
-        other_related_elements = el_struct.get("otherRelatedElements", None)
-        if other_related_elements:
-            for rel in other_related_elements:
+        part_of_data_struct = el_struct.get("partOfDataStructures", None)
+        if part_of_data_struct:
+            for rel in part_of_data_struct:
                 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)
+                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)
+        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:
@@ -1311,11 +1309,12 @@ class DataDesigner(Client2):
                     member_of_data_spec_names.append(name)
                     member_of_data_spec_qnames.append(qualifiedName)
 
-        member_data_fields = el_struct.get("memberDataFields", {})
+        member_data_fields = el_struct.get("containsDataFields", {})
         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"])
+            rel_el = data_field.get("relatedElement",{})
+            member_data_field_guids.append(rel_el["elementHeader"]["guid"])
+            member_data_field_names.append(rel_el["properties"]["displayName"])
+            member_data_field_qnames.append(rel_el["properties"]["qualifiedName"])
 
         data_classes = el_struct.get("assignedDataClasses", {})
         for data_class in data_classes:
@@ -1344,7 +1343,7 @@ class DataDesigner(Client2):
 
             "data_structure_guids": data_structure_guids,
             "data_structure_names": data_structure_names,
-            "data_structure_qnames": data_structure_qnames,
+            "in_data_structure": data_structure_qnames,
 
             "assigned_meanings_guids": assigned_meanings_guids,
             "assigned_meanings_names": assigned_meanings_names,
@@ -1368,15 +1367,15 @@ class DataDesigner(Client2):
 
             "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,
+            "in_data_dictionary": 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_spec_qnames": member_of_data_spec_qnames,
+            "in_data_spec": 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,
+            "member_data_fields": member_data_field_qnames,
 
             "mermaid": mermaid,
             }
@@ -4900,7 +4899,7 @@ class DataDesigner(Client2):
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            if isinstance(output_format_set, dict):
+            elif isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
         else:
             output_formats = None

pyegeria/external_references.py

@@ -577,8 +577,11 @@ class ExternalReferences(Client2):
             "effectiveTo": "{{$isoTimestamp}}"
           }
         }
+        {{baseURL}}/servers/{{viewServer}}/api/open-metadata/external-references/elements/660bfc21-12b5-4de1-a8f3-63239fbb58a0/external-references/850ffe6c-c551-497b-9b7a-6efcadcf2c88/attach
+        `https://localhost:9443/servers/qs-view-server/api/open-metadata/external-references/elements/660bfc21-12b5-4de1-a8f3-63239fbb58a0/external_references/850ffe6c-c551-497b-9b7a-6efcadcf2c88/attach
         """
-        url = url = (f"{self.command_root}/elements/{element_guid}/external_references/{ext_ref_guid}/attach")
+
+        url = url = (f"{self.command_root}/elements/{element_guid}/external-references/{ext_ref_guid}/attach")
         await self._async_new_relationship_request(url, "ExternalReferenceLinkProperties", body)
         logger.info(f"Linking element {element_guid} to ext. ref.  {ext_ref_guid}")
 

pyegeria/output_formatter.py

@@ -201,7 +201,7 @@ def make_md_attribute(attribute_name: str, attribute_value: str, output_type: st
             return '\n'
 
         output = f"## {attribute_title}\n{attribute_value}\n\n"
-    elif output_type == "REPORT":
+    elif output_type in ["REPORT", "MERMAID"]:
         if attribute_title in ['Mermaid Graph', 'Mermaid']:
             output = f"## Mermaid Graph\n\n```mermaid\n{attribute_value}\n```\n"
         elif attribute_value:
@@ -853,11 +853,18 @@ def extract_mermaid_only(elements: Union[Dict, List[Dict]]) -> Union[str, List[s
         String or list of strings containing mermaid graph data
     """
     if isinstance(elements, dict):
-        return elements.get('mermaidGraph', '___')
+        mer = elements.get('mermaidGraph', None)
+        if mer:
+            return f"\n```mermaid\n{mer}\n```"
+        else:
+            return "---"
+
 
     result = []
     for element in elements:
-        result.append(element.get('mermaidGraph', '___'))
+        mer = element.get('mermaidGraph', "---")
+        mer_out = f"\n\n```mermaid\n{mer}\n\n```" if mer else "---"
+        result.append(mer_out)
     return result
 
 def extract_basic_dict(elements: Union[Dict, List[Dict]]) -> Union[Dict, List[Dict]]:

{pyegeria-5.4.4.7.dist-info → pyegeria-5.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.4.4.7
+Version: 5.4.5
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance