pyegeria 5.4.0.23__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,

pyegeria/_client_new.py

@@ -476,7 +476,8 @@ class Client2:
         except (HTTPStatusError, httpx.HTTPStatusError, httpx.RequestError) as e:
             # context["caught_exception"] = e
             # context['HTTPStatusCode'] = e.response.status_code
-            additional_info = {"userid": self.user_id}
+            additional_info = {"userid": self.user_id, "reason": response.text}
+
             raise PyegeriaClientException(response, context, additional_info, e)
         #
         # except json.JSONDecodeError as e:
@@ -820,7 +821,7 @@ class Client2:
                 "class": "UpdateStatusRequestBody",
                 "status": status
                 }
-            validated_body = UpdateStatusRequestBody.validate_python(body)
+            validated_body = UpdateStatusRequestBody.model_validate(body)
         else:
             raise PyegeriaInvalidParameterException(additional_info={"reason": "invalid parameters"})
 

pyegeria/_exceptions_new.py

@@ -374,6 +374,11 @@ def print_exception_table(e: PyegeriaException):
 def print_basic_exception(e: PyegeriaException):
     """Prints the exception response"""
     related_code = e.related_http_code if hasattr(e, "related_http_code") else ""
+    http_reason = e.response.text if e.response else ""
+    table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
+    table.caption = e.pyegeria_code
+    table.add_column("Facet", justify="center")
+    table.add_column("Item", justify="left", width=80)
     related_response = e.response.json() if e.response else ""
     table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
     table.caption = e.pyegeria_code
@@ -382,6 +387,7 @@ def print_basic_exception(e: PyegeriaException):
 
     if isinstance(e, PyegeriaException):
         table.add_row("HTTP Code", str(e.response_code))
+        table.add_row("HTTP Reason", str(http_reason))
         table.add_row("Egeria Code", str(related_code))
         table.add_row("Caller Method", e.context.get("caller method", "---")) if e.context else ""
         table.add_row("Request URL", str(e.response_url))

pyegeria/_output_formats.py

@@ -163,7 +163,11 @@ GOVERNANCE_DEFINITIONS_COLUMNS = COMMON_COLUMNS + [
     Column(name="Scope", key='scope'),
     Column(name="Type", key='type_name'),
     ]
-
+GOVERNANCE_DEFINITIONS_BASIC =  [
+    Column(name="Type", key='type_name'),
+    Column(name='Qualified Name', key='qualified_name', format=True),
+    Column(name="GUID", key='guid', format=True),
+    ]
 COMMON_ANNOTATIONS = {
     "wikilinks": ["[[Commons]]"]
 }
@@ -406,7 +410,18 @@ output_format_sets = FormatSetDict({
             spec_params={"output_format":"DICT"},
         )
     ),
-
+    "Governance Basics": FormatSet(
+        heading="Basic Governance-Definitions Information",
+        description="Core Attributes useful to Governance-Definitions.",
+        aliases=["BasicGovernance"],
+        annotations={"wikilinks": ["[[Governance]]"]},
+        formats=[Format(types=["ALL"], columns=GOVERNANCE_DEFINITIONS_BASIC)],
+        action=ActionParameter(
+            function="GovernanceOfficer.find_governance_definitions",
+            user_params=["search_string"],
+            spec_params={},
+            )
+    ),
     "Governance Definitions": FormatSet(
         heading="Governance-Definitions Information",
         description="Attributes useful to Governance-Definitions.",

pyegeria/governance_officer.py

@@ -726,8 +726,6 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     async def _async_update_governance_definition(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
-        """ Update a governance definition."""
-
         """ Update the properties of a governance definition. Async Version.
 
         Parameters
@@ -793,7 +791,7 @@ class GovernanceOfficer(Client2):
         await self._async_update_element_body_request(url, GOV_DEF_PROPERTIES_LIST, body)
 
     @dynamic_catch
-    def _async_update_governance_definition(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
+    async def _async_update_governance_definition(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update a governance definition. Async Version."""
 
     def update_governance_definition(self, guid: str, body: dict | UpdateStatusRequestBody) -> None:

pyegeria/load_config.py

@@ -381,7 +381,7 @@ def load_app_config(env_file: str = None):
 
     # Logging section
     log = config_dict["Logging"]
-    log["console_filter_levels"] = _parse_list_env("PYEGERIA_CONSOLE_FILTER_LEVELS", log.get("console_filter_levels", ["ERROR"]))
+    log["console_filter_levels"] = _parse_list_env("PYEGERIA_CONSOLE_FILTER_LEVELS", log.get("console_filter_levels", ["ERROR","WARNING","INFO","SUCCESS"]))
     log["console_logging_enabled"] = _parse_list_env("PYEGERIA_CONSOLE_LOGGING_ENABLED", log.get("console_logging_enabled", ["pyegeria"]))
     log["console_logging_level"] = os.getenv("PYEGERIA_CONSOLE_LOG_LVL", log.get("console_logging_level", "INFO"))
     log["enable_logging"] = _parse_bool_env("PYEGERIA_ENABLE_LOGGING", log.get("enable_logging", False))

pyegeria/models.py

@@ -177,6 +177,33 @@ class OpenMetadataRootProperties(PyegeriaModel):
     type_name: str | None = None
     extended_properties: dict | None = None
 
+    @model_validator(mode='before')
+    @classmethod
+    def preprocess_data(cls, values):
+        """
+        This model validator performs pre-processing on the entire
+        input dictionary before field validation.
+        It converts any empty tuples to None and ensures a metadata key exists.
+
+        This is the modern equivalent of @root_validator(pre=True).
+        """
+        # Ensure the 'data' key exists before trying to access it.
+        if 'data' in values and isinstance(values['data'], dict):
+            # Convert empty tuples to None
+            processed_data = {}
+            for key, value in values['data'].items():
+                if isinstance(value, tuple) and not value:
+                    processed_data[key] = None
+                else:
+                    processed_data[key] = value
+            values['data'] = processed_data
+
+        # Ensure a 'metadata' key is always a dictionary.
+        if 'metadata' not in values:
+            values['metadata'] = {}
+
+        return values
+
 
 class RelationshipBeanProperties(PyegeriaModel):
     effective_from: datetime | None = None
@@ -311,7 +338,7 @@ class UpdateStatusRequestBody(PyegeriaModel):
 
 class GetRequestBody(PyegeriaModel):
     class_: Annotated[Literal["GetRequestBody"], Field(alias="class")]
-    # metadata_element_type_name: list[str] | None = None
+    metadata_element_type_name: str | None = None
     metadata_element_subtype_names: list[str] | None = None
     skip_relationships: list[str] | None = None
     include_only_relationships: list[str] | None = None

pyegeria/utils.py

@@ -140,7 +140,7 @@ def body_slimmer(body: dict) -> dict:
 
     slimmed = {}
     for key, value in body.items():
-        if value:
+        if value and not isinstance(value, tuple):
             if isinstance(value, dict):
                 # Recursively slim embedded dictionaries
                 slimmed_value = body_slimmer(value)

{pyegeria-5.4.0.23.dist-info → pyegeria-5.4.0.24.dist-info}/METADATA

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