pyegeria 5.4.0.23__py3-none-any.whl → 5.4.0.25__py3-none-any.whl

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -4,10 +4,11 @@ This file contains general utility functions for processing Egeria Markdown
 import json
 import os
 import sys
-from typing import List
+from typing import List, Optional
 
 from loguru import logger
 from rich import print
+from rich.markdown import Markdown
 from rich.console import Console
 
 from md_processing.md_processing_utils.common_md_utils import (get_current_datetime_string, get_element_dictionary,
@@ -15,16 +16,20 @@ from md_processing.md_processing_utils.common_md_utils import (get_current_datet
                                                                split_tb_string, str_to_bool, )
 from md_processing.md_processing_utils.extraction_utils import (process_simple_attribute, extract_attribute,
                                                                 get_element_by_name)
+from md_processing.md_processing_utils.common_md_utils import (update_element_dictionary, set_gov_prop_body, \
+                                                               set_update_body, set_create_body,
+                                                               set_peer_gov_def_request_body, set_rel_request_body,
+                                                               set_delete_request_body,set_rel_request_body,
+                                                               set_filter_request_body, setup_log,
+                                                               ALL_GOVERNANCE_DEFINITIONS, set_find_body)
+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 (get_command_spec)
 from md_processing.md_processing_utils.message_constants import (ERROR, INFO, WARNING, ALWAYS, EXISTS_REQUIRED)
-from pyegeria import EgeriaTech
+from pyegeria import EgeriaTech, select_output_format_set
+
 from pyegeria._globals import DEBUG_LEVEL
 
-log_format = "P {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,
-           colorize=True)
+
 # Constants
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
 EGERIA_USAGE_LEVEL = os.environ.get("EGERIA_USAGE_LEVEL", "Basic")
@@ -124,8 +129,12 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
             default_value = attr[key].get('default_value', None)
 
             style = attr[key]['style']
-            if style in ['Simple', 'Dictionary', 'Comment']:
+            if style in ['Simple', 'Comment']:
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == 'Dictionary':
+                parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing, default_value)
+                parsed_attributes[key]['name_list'] = json.dumps(parsed_attributes[key]['value'], indent=2)
+
             elif style == 'Valid Value':
                 parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
                                                           attr[key].get('valid_values', None), if_missing,
@@ -325,8 +334,12 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             default_value = attr[key].get('default_value', None)
 
             style = attr[key]['style']
-            if style in ['Simple', 'Dictionary', 'Comment']:
+            if style in ['Simple', 'Comment']:
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == 'Dictionary':
+                parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing,
+                                                           default_value)
+                parsed_attributes[key]['name_list'] = json.dumps(parsed_attributes[key]['value'], indent=2)
             elif style == 'Valid Value':
                 parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
                                                           attr[key].get('valid_values', None), if_missing,
@@ -401,7 +414,7 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             value = parsed_attributes[key].get('value', None)
 
             if value is not None:
-                # if the value is a dict, get the flattened name list
+                # if the value is a dict or list, get the stringifiedt
                 value = parsed_attributes[key].get('name_list', None) if isinstance(value, (dict, list)) else value
                 parsed_output['display'] += f"\n\t* {key}: `{value}`\n\t"
 
@@ -464,6 +477,50 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
+@logger.catch
+def proc_dictionary_attribute(txt: str, action: str, labels: set, if_missing: str = INFO, default_value=None,
+                          simp_type: str = None) -> dict:
+    """Process a dictionary attribute based on the provided labels and if_missing value.
+       Extract the attribute value from the text and store it in a dictionary along with valid.
+       If it doesn`t exist, mark the dictionary entry as invalid and print an error message with severity of if_missing.
+
+       Parameters:
+       ----------
+       txt: str
+         The block of object_action text to extract attributes from.
+       labels: list
+         The possible attribute labels to search for. The first label will be used in messages.
+       if_missing: str, default is INFO
+         Can be one of "WARNING", "ERROR", "INFO". The severity of the missing attribute.
+       default_value: default is None
+        The default value to return if the attribute is missing.
+    """
+    valid = True
+
+    if if_missing not in ["WARNING", "ERROR", "INFO"]:
+        msg = "Invalid severity for missing attribute"
+        logger.error(msg)
+        return {"status": ERROR, "reason": msg, "value": None, "valid": False}
+
+    if default_value == "":
+        default_value = None
+
+    attr = extract_attribute(txt, labels)
+    attribute = json.loads(attr) if attr is not None else default_value
+
+
+    if attribute is None:
+        if if_missing == INFO or if_missing == WARNING:
+            msg = f"Optional attribute with labels: `{labels}` missing"
+            valid = True
+            logger.info(msg)
+        else:
+            msg = f"Missing attribute with labels `{labels}` "
+            valid = False
+            logger.error(msg)
+        return {"status": if_missing, "reason": msg, "value": None, "valid": valid, "exists": False}
+
+    return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
 @logger.catch
 def proc_valid_value(txt: str, action: str, labels: set, valid_values: [], if_missing: str = INFO,
@@ -524,8 +581,11 @@ def proc_valid_value(txt: str, action: str, labels: set, valid_values: [], if_mi
             logger.error(msg)
         return {"status": if_missing, "reason": msg, "value": None, "valid": valid, "exists": False}
     else:
+        # Todo: look at moving validation into pydantic or another style...
+        if "Status" in labels:
+            attribute = attribute.upper()
         if attribute not in v_values:
-            msg = f"Invalid value for attribute `{labels}`"
+            msg = f"Invalid value for attribute `{labels}` attribute is `{attribute}`"
             logger.warning(msg)
             return {"status": WARNING, "reason": msg, "value": attribute, "valid": False, "exists": True}
 
@@ -651,7 +711,7 @@ def proc_el_id(egeria_client: EgeriaTech, element_type: str, qn_prefix: str, ele
         logger.error(msg)
         identifier_output = {"status": ERROR, "reason": msg, "value": element_name, "valid": False, "exists": False, }
 
-    elif action in ["Update", "View"] and exists:
+    elif action in ["Update", "View", "Link", "Detach"] and exists:
         msg = f"Element {element_name} exists"
         logger.info(msg)
         identifier_output = {
@@ -923,3 +983,101 @@ def update_term_categories(egeria_client: EgeriaTech, term_guid: str, categories
 
 
 
+
+@logger.catch
+def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a generic output request by extracting attributes (including Output Format and
+    Output Format Set) and dynamically invoking the find function specified by the
+    output_format_set, following the approach used in commands/cat/list_format_set.
+
+    This is modeled on process_gov_definition_list_command but uses the dynamic
+    dispatch via the output format set rather than directly calling a specific
+    egeria_client method.
+
+    :param egeria_client: EgeriaTech composite client instance
+    :param txt: The command text (e.g., parsed from a markdown cell)
+    :param directive: display | validate | process
+    :return: Markdown string for processed output or None
+    """
+    command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
+
+    parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
+
+    valid = parsed_output['valid']
+    print(Markdown(f"Performing {command}"))
+    print(Markdown(parsed_output['display']))
+
+    attr = parsed_output.get('attributes', {})
+
+    search_string = attr.get('Search String', {}).get('value', '*')
+    output_format = attr.get('Output Format', {}).get('value', 'LIST')
+    output_format_set = attr.get('Output Format Set', {}).get('value', object_type)
+
+    if directive == "display":
+        return None
+    elif directive == "validate":
+        # Validate that the format set exists and has an action
+        fmt = select_output_format_set(output_format_set, "ANY") if valid else None
+        if valid and fmt and fmt.get("action"):
+            print(Markdown(f"==> Validation of {command} completed successfully!\n"))
+            return True
+        else:
+            msg = f"Validation failed for object_action `{command}`"
+            logger.error(msg)
+            return False
+
+    elif directive == "process":
+        try:
+            if not valid:
+                msg = f"Validation failed for {object_action} `{object_type}`"
+                logger.error(msg)
+                return None
+
+            # Resolve the find function from the output format set
+            fmt = select_output_format_set(output_format_set, output_format)
+            if not fmt:
+                logger.error(f"Output format set '{output_format_set}' not found or not compatible with '{output_format}'.")
+                return None
+            action = fmt.get("action", {})
+            func_spec = action.get("function")
+            if not func_spec or "." not in func_spec:
+                func_spec = f"EgeriaTech.find_{object_type.replace(' ', '_').lower()}"
+
+
+            # Extract method name and get it from the composite client
+            _, method_name = func_spec.split(".", 1)
+            if not hasattr(egeria_client, method_name):
+                logger.error(f"Method '{method_name}' not available on EgeriaTech client.")
+                return None
+            method = getattr(egeria_client, method_name)
+
+            # Build body and params
+            list_md = f"\n# `{object_type}` with filter: `{search_string}`\n\n"
+            body = set_find_body(object_type, attr)
+
+            params = {
+                'search_string': search_string,
+                'body': body,
+                'output_format': output_format,
+                'output_format_set': output_format_set,
+            }
+
+            # Call the resolved method
+            struct = method(**params)
+
+            if output_format.upper() == "DICT":
+                list_md += f"```\n{json.dumps(struct, indent=4)}\n```\n"
+            else:
+                list_md += struct
+            logger.info(f"Wrote `{object_type}` for search string: `{search_string}` using format set '{output_format_set}'")
+
+            return list_md
+
+        except Exception as e:
+            logger.error(f"Error performing {command}: {e}")
+            console.print_exception(show_locals=True)
+            return None
+    else:
+        return None

md_processing/md_processing_utils/common_md_utils.py

@@ -11,7 +11,7 @@ from loguru import logger
 from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
-from pyegeria.utils import (camel_to_title_case)
+from pyegeria.utils import (camel_to_title_case, body_slimmer)
 from pyegeria._globals import DEBUG_LEVEL
 from md_processing.md_processing_utils.message_constants import message_types
 
@@ -38,11 +38,22 @@ LOG_FORMAT = "D <green> {time} </green> | {level} | {function} | {line} | {messa
 CONSOLE_LOG_FORMAT = "<green>{time}</green> | {message}"
 
 console = Console(width=EGERIA_WIDTH)
-GENERAL_GOVERNANCE_DEFINITIONS = ["Business Imperative", "Regulation Article", "Threat", "Governance Principle",
-                                  "Governance Obligation", "Governance Approach", "Governance Processing Purpose"]
+GENERAL_GOVERNANCE_DEFINITIONS = ["Governance Definition", "Business Imperative", "Regulation Article", "Threat",
+                                  "Governance Policy", "Governance Principle", "Governance Obligation",
+                                  "Governance Approach",
+                                  "Governance Processing Purpose"]
+GOVERNANCE_DRIVERS = ["Governance Driver", "Governance Strategy", "Governance Imperative", "Regulation",
+                     "Regulation Article", "Threat"]
+GOVERNANCE_POLICIES = ["Governance Policy", "Governance Principle", "Governance Obligation", "Governance Approach"]
 
-GOVERNANCE_CONTROLS = ["Governance Rule", "Service Level Objective", "Governance Process",
-                       "Governance Responsibility", "Governance Procedure", "Security Access Control"]
+
+GOVERNANCE_CONTROLS = ["Governance Control", "Governance Rule", "Service Level Objective", "Governance Action",
+                        "Security Access Control", "Governance Procedure","Governance Responsibility",
+                       "Subject Area Definition", "Data Processing Purposes", "Methodology"]
+
+ALL_GOVERNANCE_DEFINITIONS = GENERAL_GOVERNANCE_DEFINITIONS + GOVERNANCE_CONTROLS + ["Governance Strategy", "Regulation",
+                                                "Security Group", "GovernanceMetric",
+                                                "Naming Standard Rule", "TermsAndConditions", "Certification Type", "License Type"]
 
 debug_level = DEBUG_LEVEL
 global COMMAND_DEFINITIONS
@@ -216,13 +227,46 @@ def find_key_with_value(value: str) -> str | None:
     return None  # If value not found
 
 
+def set_find_body(object_type: str, attributes: dict)->dict:
+    prop_name = object_type.replace(" ", "")
+
+    start = attributes.get('Start From', {}).get('value', 0)
+    start_from = int(start) if start else 0
+    page = attributes.get('Page Size', {}).get('value', 0)
+    page_size = int(page) if page else 0
+    depth = attributes.get('Graph Query Depth', {}).get('value', 0)
+    depth = int(depth) if depth else 0
+
+
+
+    body = {
+        "class": "SearchStringRequestBody",
+        "searchString": attributes.get('Search String', {}).get('value', None),
+        "startsWith": attributes.get('Start With', {}).get('value', True),
+        "endWith": attributes.get('End With', {}).get('value', False),
+        "ignoreCase": attributes.get('Ignore Case', {}).get('value', False),
+        "limitResultsByStatus": attributes.get('Limit Results By Status', {}).get('value', False),
+        "startFrom": int(attributes.get('Start From', {}).get('value', 0)),
+        "pageSize": int(attributes.get('Page Size', {}).get('value', 0)),
+        # "metadataElementSubtypeNames": attributes.get('Metadata Element Subtype Name', {}).get('value', None),
+        "metadataElementTypeName": attributes.get('Metadata Element Type Name', {}).get('value', None),
+        "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+        "governanceZoneFilter" : attributes.get('Governance Zone Filter', {}).get('value', None),
+        "graphQueryDepth": int(attributes.get('Graph Query Depth', {}).get('value', 0)),
+        "initialStatus": attributes.get('Status', {}).get('value', "ACTIVE"),
+        "initialClassifications": {}}
+
+    return body
+
+
 def set_create_body(object_type: str, attributes: dict)->dict:
     prop_name = object_type.replace(" ", "")
     body = {
-        "class": "NewGovernanceDefinitionRequestBody",
+        "class": "NewElementRequestBody",
         "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
         "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
         "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+        "governanceZoneFilter" : attributes.get('Governance Zone Filter', {}).get('value', None),
         "forLineage": attributes.get('For Lineage', {}).get('value', False),
         "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
         "anchorGUID": attributes.get('Anchor ID', {}).get('guid', None),
@@ -245,6 +289,7 @@ def set_update_body(object_type: str, attributes: dict)->dict:
       "class" : "UpdateElementRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
       "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+      "governanceZoneFilter": attributes.get('Governance Zone Filter', {}).get('value', None),
       "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
       "forLineage": attributes.get('For Lineage', {}).get('value', False),
       "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
@@ -261,35 +306,66 @@ def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict
         "displayName": attributes['Display Name'].get('value', None),
         "qualifiedName" : qualified_name,
         "description": attributes['Description'].get('value', None),
-        "status": attributes.get('Status', {}).get('value', "ACTIVE"),
+        "category": attributes.get('Category', {}).get('value', None),
+        "identifier": attributes.get('Identifier', {}).get('value', None),
         "userDefinedStatus": attributes.get('User Defined Status', {}).get('value', None),
         "versionIdentifier": attributes.get('Version Identifier', {}).get('value', None),
         "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
         "effectiveTo": attributes.get('Effective To', {}).get('value', None),
         "additionalProperties": attributes.get('Additional Properties', {}).get('value', None),
-        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None)
+        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None),
+        "supportLevel": attributes.get('Support Level', {}).get('value', None),
+        "serviceLevels": attributes.get('Service Levels', {}).get('value', None),
         }
 
+def set_product_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    prop_bod = set_prop_body(object_type, qualified_name, attributes)
+    prop_bod["identifier"] = attributes.get('Identifier', {}).get('value', None)
+    prop_bod["productName"] = attributes.get('Product Name', {}).get('value', None)
+    prop_bod["maturity"] = attributes.get('Maturity', {}).get('value', None)
+    prop_bod["serviceLife"] = attributes.get('Service Life', {}).get('value', None)
+    prop_bod["introductionDate"] = attributes.get('Introduction Date', {}).get('value', [])
+    prop_bod["withdrawalDate"] = attributes.get('Withdrawal Date', {}).get('value', [])
+    prop_bod["nextVersion"] = attributes.get('Next Version Date', {}).get('value', [])
+    return prop_bod
+
+
+
+def set_update_status_body(object_type: str, attributes: dict)->dict:
+    return {
+      "class" : "UpdateStatusRequestBody",
+      "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+      "forLineage": attributes.get('For Lineage', {}).get('value', False),
+      "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
+      "mergeUpdate": attributes.get('Merge Update', {}).get('value', True),
+    }
+
 def set_gov_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
     prop_name = object_type.replace(" ", "")
     prop_bod = set_prop_body(object_type, qualified_name, attributes)
     prop_bod["domainIdentifier"] = attributes.get('Domain Identifier', {}).get('value', None)
-    # prop_bod["documentIdentifier"] =  attributes.get('Document Identifier', {}).get('value', None)
-    prop_bod["title"]= attributes.get('Display Name', {}).get('value', None)
-    prop_bod['documentIdentifier'] = qualified_name
+    prop_bod["displayName"]= attributes.get('Display Name', {}).get('value', None)
+    prop_bod['qualifiedName'] = qualified_name
     prop_bod["versionIdentifier"] = attributes.get('Version Identifier', {}).get('value', None)
     prop_bod["summary"] = attributes.get('Summary', {}).get('value', None)
+    prop_bod["description"] = attributes.get('Description', {}).get('value', None)
+
     prop_bod["scope"] = attributes.get('Scope', {}).get('value', None)
     prop_bod["importance"] = attributes.get('Importance', {}).get('value', None)
     prop_bod["implications"] = attributes.get('Implication', {}).get('value', [])
     prop_bod["outcomes"] = attributes.get('Outcomes', {}).get('value', [])
     prop_bod["results"] = attributes.get('Results', {}).get('value', [])
+    prop_bod["effectiveFrom"] = attributes.get('Effective From', {}).get('value', None),
+    prop_bod["effectiveTo"] = attributes.get('Effective To', {}).get('value', None),
+    prop_bod["additionalProperties"] = attributes.get('Additional Properties', {}).get('value', None),
+    prop_bod["extendedProperties"] = attributes.get('Extended Properties', {}).get('value', None)
 
-    body = update_body_for_type(object_type, prop_bod, attributes)
+
+    body = update_gov_body_for_type(object_type, prop_bod, attributes)
     return body
     
 
-def update_body_for_type(object_type: str, body: dict, attributes: dict) -> dict:
+def update_gov_body_for_type(object_type: str, body: dict, attributes: dict) -> dict:
     gov_def_name = object_type.replace(" ", "")
     if object_type in GENERAL_GOVERNANCE_DEFINITIONS:
         return body
@@ -298,7 +374,7 @@ def update_body_for_type(object_type: str, body: dict, attributes: dict) -> dict
         return body
 
     elif object_type == "Regulation":
-        body['source'] = attributes.get('Source', {}).get('value', None)
+        body['regulationSource'] = attributes.get('Regulation Source', {}).get('value', None)
         body['regulators'] = attributes.get('Regulators', {}).get('value', [])
         return body
 
@@ -308,17 +384,24 @@ def update_body_for_type(object_type: str, body: dict, attributes: dict) -> dict
     elif object_type == "Security Group":
         body['distinguishedName'] = attributes.get('Distinguished Name', {}).get('value', None)
         return body
+    elif object_type == "GovernanceMetric":
+        body['measurement'] = attributes.get('Measurement', {}).get('value', None)
+        body['target'] = attributes.get('Target', {}).get('value', None)
+        return body
     elif object_type == "Naming Standard Rule":
         body['namePatterns'] = attributes.get('Name Patterns', {}).get('value', [])
         return body
-    elif object_type in ["Certification Type", "License Type"]:
-        body['details'] = attributes.get('Details', {}).get('value', None)
+    elif object_type in ["TermsAndConditions", "Certification Type", "License Type"]:
+        body['entitlements'] = attributes.get('Entitlementss', {}).get('value', {})
+        body['restrictions'] = attributes.get('Restrictions', {}).get('value', {})
+        body['obligations'] = attributes.get('Obligations', {}).get('value', {})
+
         return body
 
 
 def set_rel_request_body(object_type: str, attributes: dict)->dict:
     return {
-      "class" : "RelationshipRequestBody",
+      "class" : "NewRelationshipRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
       "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
       "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
@@ -338,9 +421,9 @@ def set_peer_gov_def_request_body(object_type: str, attributes: dict)->dict:
         }
     return rel_body
 
-def set_metadata_source_request_body(object_type: str, attributes: dict)->dict:
+def set_delete_request_body(object_type: str, attributes: dict)->dict:
     return {
-        "class": "MetadataSourceRequestBody",
+        "class": "DeleteRequestBody",
         "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
         "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
         "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
@@ -348,6 +431,8 @@ def set_metadata_source_request_body(object_type: str, attributes: dict)->dict:
         "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
         }
 
+
+
 def set_filter_request_body(object_type: str, attributes: dict)->dict:
     return {
             "class": "FilterRequestBody",
@@ -371,14 +456,27 @@ def set_element_status_request_body(object_type: str, attributes: dict)->dict:
         "forLineage": attributes.get('For Lineage', {}).get('value', False),
         "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
     }
-def set_collection_property_body(object_type: str, qualified_name:str, attributes: dict)->dict:
-    body = set_prop_body("Collection", qualified_name,attributes)
-    body["category"] = attributes.get('Category', {}).get('value', None)
-    return body
 
-def set_collection_classifications(object_type: str, attributes: dict)->dict:
-    collection_classifications = attributes.get('Collection Classifications', {}).get('name_list', None)
-    if collection_classifications is None:
-        collection_classifications = object_type
-    body = {classification: {} for classification in collection_classifications} if collection_classifications else {}
+
+def set_classifications(object_type: str, attributes: dict)->dict:
+    classifications = attributes.get('Classifications', {}).get('name_list', None)
+    body = None
+    if classifications:
+        body = {classification: {} for classification in classifications} if cclassifications else {}
     return body
+
+def set_collection_classifications(object_type: str, attributes: dict, obj_types: list[str])->dict:
+    classifications = attributes.get('Classifications', {}).get('name_list', None)
+    obj = object_type.replace(" ", "")
+    if object_type in obj_types:
+        if classifications:
+            if object_type not in classifications:
+                classifications.append(obj)
+        else:
+            classifications = [obj]
+
+    body = {}
+    if classifications:
+        for classification in classifications:
+            body[classification] = {"class" : f"{classification}Properties"}
+    return body

md_processing/md_processing_utils/extraction_utils.py

@@ -91,7 +91,7 @@ def extract_attribute(text: str, labels: set) -> str | None:
     # Iterate over the list of labels
     for label in labels:
         # Construct pattern for the current label
-        # text = re.sub(r'\s+', ' ', text).strip()
+        # text = re.sub(r'\s+', ' ', text).strip() # just added
         text = re.sub(r'\n\n+', '\n\n', text).strip()
 
         label = label.strip()
@@ -395,7 +395,7 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
             return q_name, guid, unique, exists
 
         else:  # Missing guid from element_dictionary
-            guid = egeria_client.get_element_guid_by_unique_name(element_name)
+            guid = egeria_client.__get_guid__(qualified_name=q_name)
             if guid == NO_ELEMENTS_FOUND:
                 guid = None
                 exists = False

md_processing/md_processing_utils/md_processing_constants.py

@@ -51,9 +51,10 @@ TERM_RELATIONSHPS = ["Synonym", "Translation", "PreferredTerm", "TermISATYPEOFRe
                      "ISARelationship"]
 
 # List of supported md_commands
-GOV_LINK_LIST = [ "Link Governance Drivers", "Detach Governance Drivers",
-                "Link Governance Policies", "Detach Governance Policies",
-                "Link Governance Controls", "Detach Governance Controls",]
+GOV_LINK_LIST = [ "Link Governance Drivers", "Link Drivers", "Detach Governance Drivers", "Detach Drivers",
+                "Link Governance Policies", "Link Policies", "Detach Governance Policies", "Detach Policies",
+                "Link Governance Controls", "Link Controls", "Detach Governance Controls", "Detach Controls",
+                ]
 
 GOV_COM_LIST = [ "Create Business Imperative", "Update Business Imperative",
                 "Create Regulation Article Definition", "Update Regulation Article Definition",
@@ -130,20 +131,21 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "View Dataa Classes", "View Data Class", "Create Data Class", "Update Data Class",
                 "Create Digital Product", "Create Data Product", "Update Digital Product", "Update Data Product",
                 "Create Agreement", "Update Agreement",
-                "Link Digital Products", "Link Data Products", "Detach Digital Products", "Detach Data Products",
-                # "Create Data Sharing Agreement", "Update Data Sharing Agreement",
+                "Link Digital Products", "Link Product-Product", "Detach Digital Products", "Detach Product-Product",
+                "Create Data Sharing Agreement", "Update Data Sharing Agreement",
                 "Create Digital Subscription", "Create Product Subscription", "Update Digital Subscription", "Update Product Subscription",
-                "Attach Agreement Items", "Detach Agreement Items",
+                "Link Agreement->Item", "Detach Agreement->Item",
                 "Attach Contract", "Detach Contract",
-                "Attach Subscriber", "Detach Subscriber",
-                "Link Collection to Resource", "Attach Collection to Resource",
-                "Unlink Collection From Resource", "Detach Collection From Resource",
+                "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",
-                "Remove Member from Collection","Remove Member from Collection",
+                "Remove Member from Collection","Remove Member->Collection",
                  "View Governance Definitions", "View Gov Definitions",
                  "List Governance Definitions", "List Gov Definitions",
                 "View Governance Definition Context","List Governance Definition Context",
                 "View Governance Def Context", "List Governance Def Context",
+                "View Report",
                 # "Create Business Imperative", "Update Business Imperative",
                 # "Create Regulation Article Definition", "Update Regulation Article Definition",
                 # "Create Threat Definition", "Update Threat Definition",
@@ -173,6 +175,8 @@ command_list.extend(GOV_COM_LIST)
 command_list.extend(GOV_LINK_LIST)
 command_list.extend(COLLECTIONS_LIST)
 command_list.extend(SIMPLE_COLLECTIONS)
+command_list.extend(["Link Governance Response", "Detach Governance Response",
+                  "Link Governance Mechanism", "Detach Governance Mechanism"])
 
 pre_command = "\n---\n==> Processing object_action:"
 command_seperator = Markdown("\n---\n")

pyegeria/__init__.py

@@ -30,7 +30,7 @@ from ._client_new import Client2
 from ._exceptions_new import (PyegeriaInvalidParameterException,PyegeriaAPIException, PyegeriaException,
                               PyegeriaUnauthorizedException, PyegeriaClientException, PyegeriaUnknownException,
                               PyegeriaConnectionException, PyegeriaNotFoundException,
-                              print_exception_table, print_basic_exception)
+                              print_exception_table, print_basic_exception, print_validation_error)
 from .load_config import load_app_config, get_app_config
 from .logging_configuration import config_logging, console_log_filter, init_logging
 from ._exceptions import (InvalidParameterException, PropertyServerException, UserNotAuthorizedException,