pyegeria 5.4.0.22__py3-none-any.whl → 5.4.0.24__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")
@@ -923,3 +928,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,7 +306,7 @@ 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),
         "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),
@@ -270,26 +315,51 @@ def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict
         "extendedProperties": attributes.get('Extended Properties', {}).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', [])
+
+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 +368,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 +378,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 +415,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),
@@ -371,14 +448,23 @@ 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)
+
+
+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)->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 {}
-    return body
+    classifications = attributes.get('Classifications', {}).get('name_list', None)
+
+    if object_type in ["Folder", "Root"]:
+        if object_type not in classifications:
+            classifications.append(object_type)
+
+    body = None
+    if classifications:
+        body = {classification: {} for classification in classifications} if cclassifications else {}
+    return body

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",
@@ -131,8 +132,8 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "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",
-                "Create Digital Subscription", "Create Product Subscription", "Update Digital Subscription", "Update Product Subscription",
+                "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",
                 "Attach Contract", "Detach Contract",
                 "Attach Subscriber", "Detach Subscriber",
@@ -173,6 +174,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,
@@ -40,7 +40,7 @@ from ._validators import (is_json, validate_guid, validate_name, validate_public
 from .asset_catalog_omvs import AssetCatalog
 from .automated_curation_omvs import AutomatedCuration
 from .classification_manager_omvs import ClassificationManager
-from .collection_manager_omvs import CollectionManager
+from .collection_manager import CollectionManager
 from .core_omag_server_config import CoreServerConfig
 from .create_tech_guid_lists import build_global_guid_lists
 from .egeria_cat_client import EgeriaCat
@@ -52,7 +52,7 @@ from .feedback_manager_omvs import FeedbackManager
 from .full_omag_server_config import FullServerConfig
 from .glossary_browser_omvs import GlossaryBrowser
 from .glossary_manager_omvs import GlossaryManager
-from .governance_officer_omvs import GovernanceOfficer
+from .governance_officer import GovernanceOfficer
 from .mermaid_utilities import (construct_mermaid_web, construct_mermaid_jup, generate_process_graph, load_mermaid,
                                 parse_mermaid_code, render_mermaid, save_mermaid_graph, save_mermaid_html, )
 from .metadata_explorer_omvs import MetadataExplorer