pyegeria 5.4.4.1__py3-none-any.whl → 5.4.4.2__py3-none-any.whl

md_processing/dr-egeria-outbox/Business-Imperative-DrE-2025-09-11-21-21-15.md

@@ -0,0 +1,33 @@
+# Business-Imperative-DrE Attributes
+Auto-generated format for Business Imperative (Create).
+
+# Business-Imperative-DrE Report - created at 2025-09-11 21:21
+	Business-Imperative-DrE  found from the search string:  `All`
+
+<a id="d85814c3-dac7-4915-bdcf-751ef037d83e"></a>
+# Business-Imperative-DrE Name: Sustainability Reporting Imperative
+
+## Display Name
+Sustainability Reporting Imperative
+
+## Summary
+Comply with Legal and Expected Sustainability Norms and Regulations
+
+## Description
+As an international company, Coco Pharmaceuticals must comply with local regulatory requirements as well as meeting the expectations of our customers and shareholders. Sustainability reporting and improvements are important across stakeholders. We must therefore have and communicate an explicit and robust sustainability strategy with demonstrated outcomes.
+
+## Scope
+Enterprise
+
+## Importance
+Very important, with several implications.
+
+## Outcomes
+1. Ability to operate in each location.2. Market position3. Satisfied shareholders4. Happier and engaged employees
+
+## Qualified Name
+BusinessImperative::Sustainability Reporting Imperative
+
+## GUID
+d85814c3-dac7-4915-bdcf-751ef037d83e
+

md_processing/md_commands/governance_officer_commands.py

@@ -147,11 +147,13 @@ def process_gov_definition_upsert_command(egeria_client: EgeriaTech, txt: str, d
                 # Proceed with the update
                 update_body = set_update_body(object_type, parsed_output['attributes'])
                 update_body['properties'] = set_gov_prop_body(object_type, qualified_name, parsed_output['attributes'])
-                egeria_client.update_governance_definition(guid, body_slimmer(update_body))
+                update_body = body_slimmer(update_body)
+                egeria_client.update_governance_definition(guid, update_body)
                 if status := parsed_output['attributes'].get('Status', {}).get('value', None):
                     egeria_client.update_governance_definition_status(guid, status)
                 logger.success(f"Updated {object_type} `{display_name}` with GUID {guid}")
-                return egeria_client.get_governance_definition_by_guid(guid, output_format='MD')
+                return egeria_client.get_governance_definition_by_guid(guid, output_format='MD',
+                                                output_format_set = 'Business-Imperative-DrE')
 
             elif object_action == "Create":
                 if valid is False and exists:
@@ -187,6 +189,7 @@ def process_gov_definition_upsert_command(egeria_client: EgeriaTech, txt: str, d
 
     except Exception as e:
         logger.exception(f"Unexpected error: {e}")
+        print("Unexepected error occurred:\n {e}")
         return None
 
 

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -8,9 +8,11 @@ import re
 from typing import List, Optional
 
 from loguru import logger
+from pydantic import ValidationError
 from rich import print
 from rich.markdown import Markdown
 from rich.console import Console
+from pyegeria.utils import parse_to_dict
 
 from md_processing.md_processing_utils.common_md_utils import (get_current_datetime_string, get_element_dictionary,
                                                                update_element_dictionary,
@@ -26,7 +28,8 @@ from md_processing.md_processing_utils.common_md_utils import (update_element_di
 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, select_output_format_set
+from pyegeria import EgeriaTech, select_output_format_set, PyegeriaException, print_basic_exception, \
+    print_validation_error
 
 from pyegeria._globals import DEBUG_LEVEL
 
@@ -93,131 +96,157 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
 
     for attr in attributes:
         for key in attr:
-            # Run some checks to see if the attribute is appropriate to the operation and usage level
-            for_update = attr[key].get('inUpdate', True)
-            level = attr[key].get('level', 'Basic')
-            msg = (f"___\nProcessing `{key}` in `{object_action}` on a `{object_type}` "
-                   f"\n\twith usage level: `{EGERIA_USAGE_LEVEL}` and  attribute level `{level}` and for_update `"
-                   f"{for_update}`\n")
-            logger.trace(msg)
-            if for_update is False and object_action == "Update":
-                logger.trace(f"Attribute `{key}`is not allowed for `Update`", highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Basic" and level != "Basic":
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Advanced" and level in ["Expert", "Invisible"]:
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Expert" and level == "Invisible":
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-
-            if attr[key].get('input_required', False) is True:
-                if_missing = ERROR
-            else:
-                if_missing = INFO
-
-            # lab = [item.strip() for item in re.split(r'[;,\n]+',attr[key]['attr_labels'])]
-            lab = split_tb_string(attr[key]['attr_labels'])
-            labels: set = set()
-            labels.add(key.strip())
-            if key == 'Display Name':
-                labels.add(object_type.strip())
-            if lab is not None and lab != [""]:
-                labels.update(lab)
-
-            default_value = attr[key].get('default_value', None)
-
-            style = attr[key]['style']
-            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,
-                                                          default_value)
-            elif style == 'QN':
-                parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
-                                                    object_action, version, if_missing)
-                if key == 'Qualified Name' and parsed_attributes[key]['value'] and parsed_attributes[key][
-                    'exists'] is False:
-                    parsed_output['exists'] = False
-            elif style == 'ID':
-                parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
-                                                    object_action, version, if_missing)
-
-                parsed_output['guid'] = parsed_attributes[key].get('guid', None)
-                parsed_output['qualified_name'] = parsed_attributes[key].get('qualified_name', None)
-                parsed_output['exists'] = parsed_attributes[key]['exists']
-                if parsed_attributes[key]['valid'] is False:
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += parsed_attributes[key]['reason']
-
-            elif style == 'Reference Name':
-                parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
-                if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) and parsed_attributes[key][
-                    'exists'] is False):
-                    msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
-                    logger.error(msg)
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += msg
-                elif parsed_attributes[key]['valid'] is False:
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += parsed_attributes[key]['reason']
-
-            elif style == 'GUID':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
-            elif style == 'Ordered Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
-            elif style == 'Simple Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
-            elif style == 'Simple List':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
-                name_list = parsed_attributes[key]['value']
-                # attribute = re.split(r'[;,\n]+', name_list) if name_list is not None else None
-                attribute = split_tb_string(name_list)
-                parsed_attributes[key]['value'] = attribute
-                parsed_attributes[key]['name_list'] = name_list
-            elif style == 'Parent':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
-            elif style == 'Bool':
-                parsed_attributes[key] = proc_bool_attribute(txt, object_action, labels, if_missing, default_value)
-            elif style == "Dictionary List":
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
-                parsed_attributes[key]['list'] = json.loads(parsed_attributes[key]['value'])
-
+            try:
+                # Run some checks to see if the attribute is appropriate to the operation and usage level
+                for_update = attr[key].get('inUpdate', True)
+                level = attr[key].get('level', 'Basic')
+                msg = (f"___\nProcessing `{key}` in `{object_action}` on a `{object_type}` "
+                       f"\n\twith usage level: `{EGERIA_USAGE_LEVEL}` and  attribute level `{level}` and for_update `"
+                       f"{for_update}`\n")
+                logger.trace(msg)
+                if for_update is False and object_action == "Update":
+                    logger.trace(f"Attribute `{key}`is not allowed for `Update`", highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Basic" and level != "Basic":
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Advanced" and level in ["Expert", "Invisible"]:
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Expert" and level == "Invisible":
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
 
-            elif style == 'Reference Name List':
-                parsed_attributes[key] = proc_name_list(egeria_client, key, txt, labels, if_missing)
-                if (parsed_attributes[key].get("value", None) and (
-                        parsed_attributes[key]['exists'] is False or parsed_attributes[key]['valid'] is False)):
-                    msg = (f"A Reference Name in `{parsed_attributes[key].get('name_list', None)}` is specified but "
-                           f"does not exist")
+                if attr[key].get('input_required', False) is True:
+                    if_missing = ERROR
+                else:
+                    if_missing = INFO
+
+                # lab = [item.strip() for item in re.split(r'[;,\n]+',attr[key]['attr_labels'])]
+                lab = split_tb_string(attr[key]['attr_labels'])
+                labels: set = set()
+                labels.add(key.strip())
+                if key == 'Display Name':
+                    labels.add(object_type.strip())
+                if lab is not None and lab != [""]:
+                    labels.update(lab)
+
+                default_value = attr[key].get('default_value', None)
+
+                style = attr[key]['style']
+                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)
+                    if key in parsed_attributes and parsed_attributes[key] is not None:
+                            if parsed_attributes[key].get('value', None) is not None:
+                                if isinstance(parsed_attributes[key]['value'], dict):
+                                    parsed_attributes[key]['dict'] = json.dumps(parsed_attributes[key]['value'], indent=2)
+                            else:
+                                continue
+                    else:
+                        continue
+
+                elif style == 'Valid Value':
+                    parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
+                                                              attr[key].get('valid_values', None), if_missing,
+                                                              default_value)
+                elif style == 'QN':
+                    parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
+                                                        object_action, version, if_missing)
+                    if key == 'Qualified Name' and parsed_attributes[key]['value'] and parsed_attributes[key][
+                        'exists'] is False:
+                        parsed_output['exists'] = False
+                elif style == 'ID':
+                    parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
+                                                        object_action, version, if_missing)
+
+                    parsed_output['guid'] = parsed_attributes[key].get('guid', None)
+                    parsed_output['qualified_name'] = parsed_attributes[key].get('qualified_name', None)
+                    parsed_output['exists'] = parsed_attributes[key]['exists']
+                    if parsed_attributes[key]['valid'] is False:
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += parsed_attributes[key]['reason']
+
+                elif style == 'Reference Name':
+                    parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
+                    if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) and parsed_attributes[key][
+                        'exists'] is False):
+                        msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
+                        logger.error(msg)
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += msg
+                    elif parsed_attributes[key]['valid'] is False:
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += parsed_attributes[key]['reason']
+
+                elif style == 'GUID':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
+                elif style == 'Ordered Int':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
+                elif style == 'Simple Int':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
+                elif style == 'Simple List':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "list")
+                    name_list = parsed_attributes[key]['value']
+                    # attribute = re.split(r'[;,\n]+', name_list) if name_list is not None else None
+                    attribute = split_tb_string(name_list)
+                    parsed_attributes[key]['value'] = attribute
+                    parsed_attributes[key]['name_list'] = name_list
+                elif style == 'Parent':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                elif style == 'Bool':
+                    parsed_attributes[key] = proc_bool_attribute(txt, object_action, labels, if_missing, default_value)
+                elif style == "Dictionary List":
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                    parsed_attributes[key]['list'] = json.loads(parsed_attributes[key]['value'])
+
+
+                elif style == 'Reference Name List':
+                    parsed_attributes[key] = proc_name_list(egeria_client, key, txt, labels, if_missing)
+                    if (parsed_attributes[key].get("value", None) and (
+                            parsed_attributes[key]['exists'] is False or parsed_attributes[key]['valid'] is False)):
+                        msg = (f"A Reference Name in `{parsed_attributes[key].get('name_list', None)}` is specified but "
+                               f"does not exist")
+                        logger.error(msg)
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += msg
+                else:
+                    msg = f"Unknown attribute style: {style} for key `{key}`"
                     logger.error(msg)
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += msg
-            else:
-                msg = f"Unknown attribute style: {style} for key `{key}`"
-                logger.error(msg)
-                sys.exit(1)
+                    sys.exit(1)
+                    parsed_attributes[key]['valid'] = False
+                    parsed_attributes[key]['value'] = None
+                if key == "Display Name":
+                    display_name = parsed_attributes[key]['value']
+
+                value = parsed_attributes[key].get('value', None)
+
+                if value is not None:
+                    if isinstance(value, list):
+                        list_out = f"\n\t* {key}:\n\n"
+                        for item in value:
+                            list_out += f"\t{item}\n"
+                        parsed_output['display'] += list_out
+                    elif isinstance(value, dict):
+                        list_out = f"\n\t* {key}:\n\n"
+                        for k, v in value.items():
+                            list_out += f"\t{k}: \n\t\t{v}\n"
+                        parsed_output['display'] += list_out
+                    else:
+                        parsed_output['display'] += f"\n\t* {key}: \n`{value}`\n\t"
+            except PyegeriaException as e:
+                logger.error(f"PyegeriaException occurred: {e}")
+
+                print_basic_exception(e)
+
+            except ValidationError as e:
                 parsed_attributes[key]['valid'] = False
                 parsed_attributes[key]['value'] = None
-            if key == "Display Name":
-                display_name = parsed_attributes[key]['value']
-
-            value = parsed_attributes[key].get('value', None)
-
-            if value is not None:
-                # if the value is a dict, get the flattened name list
-                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"
+                print_validation_error(e)
 
 
     parsed_output['attributes'] = parsed_attributes
@@ -504,7 +533,8 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     attribute = extract_attribute(txt, labels)
 
-    attribute = default_value if attribute is None else attribute.replace('\n', '')
+    # attribute = default_value if attribute is None else attribute.replace('\n', '')
+    attribute = default_value if attribute is None else attribute
 
     if attribute is None:
         if if_missing == INFO or if_missing == WARNING:
@@ -519,8 +549,10 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     if attribute and simp_type == "int" :
         attribute = int(attribute)
-    elif attribute and simp_type == "list":
-        attribute = list(attribute)
+    # elif attribute and simp_type == "list":
+    #     if isinstance(attribute, str):
+    #         attribute = [piece.strip() for piece in re.split(r'[,\n]', attribute) if piece.strip()]
+
 
 
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
@@ -554,8 +586,8 @@ def proc_dictionary_attribute(txt: str, action: str, labels: set, if_missing: st
         default_value = None
 
     attr = extract_attribute(txt, labels)
-    attribute = json.loads(attr) if attr is not None else default_value
-
+    # attribute = json.loads(attr) if attr is not None else default_value
+    attribute = parse_to_dict(attr)
 
     if attribute is None:
         if if_missing == INFO or if_missing == WARNING:

md_processing/md_processing_utils/common_md_utils.py

@@ -387,7 +387,7 @@ def set_gov_prop_body(object_type: str, qualified_name: str, attributes: dict)->
     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["results"] = attributes.get('Results', {}).get('value', []) or []
     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),
@@ -425,9 +425,12 @@ def update_gov_body_for_type(object_type: str, body: dict, attributes: dict) ->
         body['namePatterns'] = attributes.get('Name Patterns', {}).get('value', [])
         return body
     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', {})
+        entitlements = attributes.get('Entitlementss', {}).get('value', {}) if attributes.get('Entitlementss',None) else None
+        restrictions = attributes.get('Restrictions', {}).get('value', {}) if attributes.get('Restrictions',None) else None
+        obligations = attributes.get('Obligations', {}).get('value', {}) if attributes.get('Obligations',None) else None
+        body['entitlements'] = entitlements
+        body['restrictions'] = restrictions
+        body['obligations'] = obligations
 
         return body
 

md_processing/md_processing_utils/extraction_utils.py

@@ -2,6 +2,7 @@
 This file contains functions for extracting data from text for Egeria Markdown processing
 """
 import re
+import json
 from typing import Any
 
 from md_processing.md_processing_utils.common_md_utils import (print_msg, find_key_with_value, get_element_dictionary,
@@ -74,56 +75,94 @@ def extract_command(block: str) -> str | None:
     return None
 
 
-def extract_attribute(text: str, labels: set) -> str | None:
+# def extract_attribute(text: str, labels: set) -> str | None:
+#     """
+#         Extracts the attribute value from a string.
+#
+#         Args:
+#             text: The input string.
+#             labels: List of equivalent labels to search for
+#
+#         Returns:
+#             The value of the attribute, or None if not found.
+#
+#         Note:
+#             Lines beginning with '>' are ignored.
+#         """
+#     # Iterate over the list of labels
+#     for label in labels:
+#         # Construct pattern for the current label
+#         # text = re.sub(r'\s+', ' ', text).strip() # just added
+#         # text = re.sub(r'\n\n+', '\n\n', text).strip()
+#
+#         # Replace multiple spaces or tabs with a single space
+#         normalized = re.sub(r'\s+', ' ', text)
+#         # Collapse multiple blank lines into a single one
+#         normalized = re.sub(r'\n\s*\n', '\n', normalized).strip()
+#
+#         # label = label.strip()
+#         # pattern = rf"##\s*{re.escape(label)}\s*\n(?:\s*\n)*?(.*?)(?:#|___|$)"
+#         # Normalize the label
+#         normalized_label = re.sub(r'\s+', ' ', label.strip())
+#
+#         # Construct the regex pattern
+#         pattern = rf"##\s*{re.escape(normalized_label)}\s*\n(?:\s*\n)*?(.*?)(?:#|___|$)"
+#         # pattern = rf"##\s+{re.escape(label)}\n(.*?)(?:#|___|$)"  # modified from --- to enable embedded tables
+#         match = re.search(pattern, text, re.DOTALL)
+#         if match:
+#             # Extract matched text
+#             matched_text = match.group(1)
+#
+#             # Filter out lines beginning with '>'
+#             filtered_lines = [line for line in matched_text.split('\n') if not line.strip().startswith('>')]
+#             filtered_text = '\n'.join(filtered_lines)
+#
+#             # Replace consecutive \n with a single \n
+#             extracted_text = re.sub(r'\n+', '\n', filtered_text)
+#             if not extracted_text.isspace() and extracted_text:
+#                 return extracted_text.strip()  # Return the cleaned text - I removed the title casing
+#
+#     return None
+
+
+from typing import Optional, List
+
+def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
     """
-        Extracts the attribute value from a string.
+    def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
 
-        Args:
-            text: The input string.
-            labels: List of equivalent labels to search for
+    Extracts the attribute value from a string while:
+    - Preserving single newlines within the matched text.
+    - Removing lines starting with '>'.
 
-        Returns:
-            The value of the attribute, or None if not found.
+    Args:
+        text: The input string containing labeled sections.
+        labels: List of equivalent labels to search for.
 
-        Note:
-            Lines beginning with '>' are ignored.
-        """
-    # Iterate over the list of labels
+    Returns:
+        The cleaned value of the attribute, or None if not found.
+    """
     for label in labels:
         # Construct pattern for the current label
-        # text = re.sub(r'\s+', ' ', text).strip() # just added
-        # text = re.sub(r'\n\n+', '\n\n', text).strip()
-
-        # Replace multiple spaces or tabs with a single space
-        normalized = re.sub(r'\s+', ' ', text)
-        # Collapse multiple blank lines into a single one
-        normalized = re.sub(r'\n\s*\n', '\n', normalized).strip()
-
-        # label = label.strip()
-        # pattern = rf"##\s*{re.escape(label)}\s*\n(?:\s*\n)*?(.*?)(?:#|___|$)"
-        # Normalize the label
-        normalized_label = re.sub(r'\s+', ' ', label.strip())
-
-        # Construct the regex pattern
-        pattern = rf"##\s*{re.escape(normalized_label)}\s*\n(?:\s*\n)*?(.*?)(?:#|___|$)"
-        # pattern = rf"##\s+{re.escape(label)}\n(.*?)(?:#|___|$)"  # modified from --- to enable embedded tables
-        match = re.search(pattern, text, re.DOTALL)
+        pattern = rf"## {re.escape(label)}\n(.*?)(?=^##|\Z)"  # Captures content until the next '##' or end of text
+        match = re.search(pattern, text, re.DOTALL | re.MULTILINE)
         if match:
             # Extract matched text
-            matched_text = match.group(1)
+            extracted_text = match.group(1)
 
-            # Filter out lines beginning with '>'
-            filtered_lines = [line for line in matched_text.split('\n') if not line.strip().startswith('>')]
-            filtered_text = '\n'.join(filtered_lines)
+            # Remove lines starting with '>'
+            filtered_lines = [line for line in extracted_text.splitlines() if not line.lstrip().startswith(">")]
 
-            # Replace consecutive \n with a single \n
-            extracted_text = re.sub(r'\n+', '\n', filtered_text)
-            if not extracted_text.isspace() and extracted_text:
-                return extracted_text.strip()  # Return the cleaned text - I removed the title casing
+            # Join the lines back, preserving single newlines
+            cleaned_text = "\n".join(filtered_lines).strip()
 
+            if cleaned_text:
+                return cleaned_text  # Return the cleaned and formatted text
     return None
 
 
+
+
 def process_simple_attribute(txt: str, labels: set, if_missing: str = INFO) -> str | None:
     """Process a simple attribute based on the provided labels and if_missing value.
        Extract the attribute value from the text and return it if it exists.

pyegeria/governance_officer.py

@@ -787,9 +787,6 @@ class GovernanceOfficer(Client2):
             f"{guid}/update")
         await self._async_update_element_body_request(url, GOV_DEF_PROPERTIES_LIST, body)
 
-    @dynamic_catch
-    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:
         """ Update the properties of a governance definition.
@@ -899,7 +896,7 @@ class GovernanceOfficer(Client2):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/governance-defnitions/"
             f"{guid}/update-status")
 
-        await self._async_update_status_request(url, status, body)
+        # await self._async_update_status_request(url, status, body)
 
     def update_governance_definition_status(self, guid: str, status: str = None,
                                             body: dict | UpdateStatusRequestBody = None) -> None:

pyegeria/utils.py

@@ -246,6 +246,116 @@ def flatten_dict_to_string(d: dict) -> str:
 # The decorator logic, which applies @logger.catch dynamically
 
 
+import json
+import re
+
+
+# def parse_to_dict(input_str: str):
+#     """
+#     Check if a string is valid JSON or a name:value list without braces and convert to a dictionary.
+#
+#     Args:
+#         input_str: The input string to parse.
+#
+#     Returns:
+#         dict: A dictionary converted from the input string.
+#         None: If the input is neither valid JSON nor a valid name:value list.
+#     """
+#
+#     if input_str is None:
+#         return None
+#
+#     # Check if the input string is valid JSON
+#     try:
+#         result = json.loads(input_str)
+#         if isinstance(result, dict):  # Ensure it's a dictionary
+#             return result
+#     except json.JSONDecodeError:
+#         pass
+#
+#     # Check if input string looks like a name:value list
+#     # Supports both comma and newline as separators
+#     pattern = r'^(\s*("[^"]+"|\'[^\']+\'|[a-zA-Z0-9_-]+)\s*:\s*("[^"]+"|\'[^\']+\'|[a-zA-Z0-9 _-]*)\s*)' \
+#               r'(\s*[,|\n]\s*("[^"]+"|\'[^\']+\'|[a-zA-Z0-9_-]+)\s*:\s*("[^"]+"|\'[^\']+\'|[a-zA-Z0-9 _-]*)\s*)*$'
+#     if re.match(pattern, input_str.strip()):
+#         try:
+#             # Split by ',' or '\n' and process key-value pairs
+#             pairs = [pair.split(":", 1) for pair in re.split(r'[,|\n]+', input_str.strip())]
+#             return {key.strip().strip('\'"'): value.strip().strip('\'"') for key, value in pairs}
+#         except Exception:
+#             return None
+#
+#     # If neither pattern matches, return None
+#     return None
+
+
+def parse_to_dict(input_str: str) -> dict | None:
+    """
+    Parse input strings into a dictionary, handling both JSON and key-value pairs.
+    Recovers from malformed JSON (e.g., where commas are missing between key-value pairs)
+    and supports multiline values.
+
+    Args:
+        input_str (str): The input string to parse.
+
+    Returns:
+        dict: A parsed dictionary if validation is successful, or None if the string cannot be parsed.
+    """
+    if not input_str:
+        return None
+
+    # Attempt to parse valid JSON
+    try:
+        result = json.loads(input_str)
+        if isinstance(result, dict):
+            return result
+    except json.JSONDecodeError:
+        pass
+
+    # Fix malformed JSON or attempt alternate parsing for "key: value" patterns
+    try:
+        # Step 1: Inject missing commas where they are omitted between key-value pairs
+        fixed_input = re.sub(
+            r'("\s*:[^,}\n]+)\s*("(?![:,}\n]))',  # Find missing commas (key-value-value sequences)
+            r'\1,\2',  # Add a comma between the values
+            input_str
+        )
+
+        # Attempt to parse the fixed string as JSON
+        try:
+            result = json.loads(fixed_input)
+            if isinstance(result, dict):
+                return result
+        except json.JSONDecodeError:
+            pass
+
+        # Step 2: Handle key-value format fallback (supports multiline strings)
+        # Matches `key: value` pairs, including multiline quoted values
+        key_value_pattern = re.compile(r'''
+            (?:"([^"]+)"|'([^']+)'|([a-zA-Z0-9_-]+))  # Key: quoted "key", 'key', or unquoted key
+            \s*:\s*                                   # Key-value separator
+            (?:"((?:\\.|[^"\\])*?)"|'((?:\\.|[^'\\])*?)'|([^\n,]+))  # Value: quoted or unquoted
+        ''', re.VERBOSE | re.DOTALL)
+
+        matches = key_value_pattern.findall(input_str)
+
+        # Build dictionary from matches
+        result_dict = {}
+        for match in matches:
+            key = next((group for group in match[:3] if group), "").strip()
+            value = next((group for group in match[3:] if group), "").strip()
+            result_dict[key] = value
+
+        if result_dict:
+            return result_dict
+    except Exception as e:
+        # Log or handle parsing exception if needed
+        pass
+
+    # If all parsing attempts fail, return None
+    return None
+
+
 def dynamic_catch(func: T) -> T:
     if app_settings.get("enable_logger_catchh", False):
         return logger.catch(func)  # Apply the logger.catch decorator

{pyegeria-5.4.4.1.dist-info → pyegeria-5.4.4.2.dist-info}/METADATA

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

{pyegeria-5.4.4.1.dist-info → pyegeria-5.4.4.2.dist-info}/RECORD

@@ -3,6 +3,7 @@ commands/__init__.py,sha256=-_1ApX0GIzkVNl1NajyGMIz7fHbwZfN5DVnBQAOiScA,1174
 commands/cat/Dr-Egeria_md-orig.py,sha256=ZX20BvRo0fIFisvy5Z-VJDLVyKbQoud89-CUV2S66tU,7336
 commands/cat/README.md,sha256=-aaAnIT2fcfU63vajgB-RzQk4l4yFdhkyVfSaTPiqRY,967
 commands/cat/__init__.py,sha256=l4CImkjEiTQKS7QR-RQwzHIgRpfP032Mn_NZEuIILwg,98
+commands/cat/debug_log.2025-09-10_13-48-37_153090.log.zip,sha256=Wx_eCPrVj_km3sNYZu6fe4KlMUTkiuGJ3SSWmD4mOyU,13471
 commands/cat/dr_egeria_command_help.py,sha256=_HOJd1IplnYhoQm1cwsROS9SxVKILLUf9YNlGMvvdF4,15359
 commands/cat/dr_egeria_jupyter.py,sha256=rfLVV_84Q8Pqcq1flmijKvZ7sEZFy7JAcAP_NAbb46Y,5656
 commands/cat/dr_egeria_md.py,sha256=zz-XtRW0sfBOG8kA51OFR5uKQ7JULGoOgXeJBXQBqTM,4889
@@ -4291,28 +4292,29 @@ md_processing/data/commands-working.json,sha256=uCo_azcuuYqGm7QffJeCGj7PyZuZRGdu
 md_processing/data/commands.json,sha256=RIHRggidx9qPwBDVmXagoY0AkVcG-sL0yobl7aiGmHI,1712477
 md_processing/data/generated_format_sets.json,sha256=TXvGK_Gm5ieq9i6u9M1j4CaNPzoV2m0hisKK2fWCtIM,98502
 md_processing/data/generated_format_sets.py,sha256=ZUWlUi5BHdetUQP-Hx8nQqzd3mCEubsJQXjvPmqhY3M,54980
+md_processing/dr-egeria-outbox/Business-Imperative-DrE-2025-09-11-21-21-15.md,sha256=2_SfdjR5fJXNTzM4Yx2po7vf5t4VmX2GsUedPaRujrQ,1176
 md_processing/dr_egeria.py,sha256=OlzP8LkXqZ79lxsWOnz8zOpcOdhpLp7m_PDE0fi-YPs,19963
 md_processing/dr_egeria_inbox/glossary_creation_experiment.ipynb,sha256=dbzNu90fCKNohOWVSRBOB1GLyd95x8Qw51I5AkaPtso,11552
 md_processing/md_commands/__init__.py,sha256=ssEojzFlSYtY2bHqqOoKo8PFaANZ_kq_gIbtlXnuc2s,93
 md_processing/md_commands/data_designer_commands.py,sha256=oUXM6wvyictQZVzSH43GJdmy5Zm7nWogWuoCNo8Yskw,64389
 md_processing/md_commands/ext_ref_commands.py,sha256=uxVMz3QSJbMxMVYYaDQs9YlBH65Jsw0Wa0oJFcn5GnQ,24546
 md_processing/md_commands/glossary_commands.py,sha256=BEWcJYCWybTvbqcZD7_IFbBKiMpX6b55avrn1nckqO4,33811
-md_processing/md_commands/governance_officer_commands.py,sha256=NCYrx6k1q_duVoF0bMdbyLMjHOn7Xvc0-c50a4NWcGA,21990
+md_processing/md_commands/governance_officer_commands.py,sha256=ixM-Su3q6XF-MKkVJb8R0wXfgM_ZAiucCINS_LkjgXY,22178
 md_processing/md_commands/old_solution_architect_commands.py,sha256=Hk-_-2aJWoG8LYzTmf84z3rakN9kIQWEM9HM9_lz6xw,55157
 md_processing/md_commands/product_manager_commands.py,sha256=aLagu4Tljd0gITdmvxXIe_sMGcJVkNTrncigG5TXFmo,45749
 md_processing/md_commands/project_commands.py,sha256=s9-n_a0lUU-oAZMYeaW6Nq_Tii9nG4hVIuBuf3q-heI,17762
 md_processing/md_commands/solution_architect_commands.py,sha256=4Ghb8j2wlDdWtHoSCrx5jCJFEJfqII4mnFJ_tqduRKI,52569
 md_processing/md_commands/view_commands.py,sha256=dvRD0Vjv1w9FTfV5W-4EMQBTk2NAUJlIP2jQ411kHS4,11815
 md_processing/md_processing_utils/__init__.py,sha256=LxAmxlcji26ziKV4gGar01d95gL9vgToRIeJW8N-Ifs,80
-md_processing/md_processing_utils/common_md_proc_utils.py,sha256=TWQyypm9xNSf1sipnjEWQqyuaShRSldbooBBd42gODo,56637
-md_processing/md_processing_utils/common_md_utils.py,sha256=dWoJEpp-yF-CPThZ1I5hMM0CSXkqfXBkgxH8rklZz8A,26452
+md_processing/md_processing_utils/common_md_proc_utils.py,sha256=wZQvmFLryko-Of-MaZ9BspejTSW27V9y6Azoaeb-w0o,58607
+md_processing/md_processing_utils/common_md_utils.py,sha256=X8Kzva-sRyM6RZ6RbkUeP4fJaVhif0q6z7WhP-hhdm8,26711
 md_processing/md_processing_utils/debug_log,sha256=dDkHai9YpY-9k9-DSFzbaMgZ-AavFw-Vxk2Q1r_34Ls,43746
 md_processing/md_processing_utils/debug_log.2025-09-09_11-10-03_528597.zip,sha256=2hK1jdCdG7aR9FPxFdtmU_OxHBNYLA2vlr-OPqR6sXs,1863
 md_processing/md_processing_utils/determine_width.py,sha256=nzinSuSF9SeuVOfKXsg-l1cqLkNYKZnF6HYfJpft44A,4236
 md_processing/md_processing_utils/dr-egeria-help-2025-09-09T11:10:03.md,sha256=x_J_baA18EsMHW_O-EZiNkXAQ3MEwta8ZLsKPil55O8,166018
 md_processing/md_processing_utils/dr-egeria-help-2025-09-10T14:49:49.md,sha256=qnu8YS-7Ra0GQtPPiCKb4PpQBcJAmfaG50ufFpr9b-s,175356
 md_processing/md_processing_utils/dr-egeria-help-2025-09-10T14:57:46.md,sha256=1gBIR4iuBsAXpGdg4nPgFHOGcLcDCZbNvvg-9cHD4fM,55188
-md_processing/md_processing_utils/extraction_utils.py,sha256=bTeoiAC0DcNl5LjYuXkyk8V3cLhAshp_IFPMeROq7Qk,20930
+md_processing/md_processing_utils/extraction_utils.py,sha256=nCtsnx_iSNV-h1StZ54GQLzSIqfx3hCNnmdDTWUKC10,22350
 md_processing/md_processing_utils/gen_format_sets.py,sha256=R5IvrajER0Xj9kZ99UxRS5Zoa5dAVPcLwCI7kf2iUak,16476
 md_processing/md_processing_utils/generate_dr_help.py,sha256=MJWlr_22Y9pjWqQbfSLb6C-t1GlQNlbWXkCmDnphfME,7419
 md_processing/md_processing_utils/generate_md_cmd_templates.py,sha256=SVdtlA6Nc9JIN-pORGbf-_shEP7egReuVejEcMjxRYM,5797
@@ -4348,7 +4350,7 @@ pyegeria/external_references.py,sha256=XPJxE57d4e7ooasSZiYTpoppo43z1oLYvthD58__v
 pyegeria/feedback_manager_omvs.py,sha256=0xBs0p54vmdfVYYgQ8pOanLC4fxfgTk1Z61Y6D1U7_I,152978
 pyegeria/full_omag_server_config.py,sha256=CQqLCy_3DZFvJZEOcGf50HWdFaWpiAIs6z-kKyjvpDA,47464
 pyegeria/glossary_manager.py,sha256=LsemH2bC1jj6mquLxZMXsoZY77D8gTdWKXNs9Gee6mQ,110173
-pyegeria/governance_officer.py,sha256=3c-8PFUzWzPHc7OOX-Kt7vVaj4rSttCvOsgXSDX3POw,100217
+pyegeria/governance_officer.py,sha256=d-hflvrMt-7hH6j47OicoolpU8rf6uzV-IZRgWL485Y,100023
 pyegeria/load_config.py,sha256=XDwPAHB3MvGRuoP8kg1lJJAI4BgMWZ3TYxfxYROgJj4,1188
 pyegeria/load_config_orig.py,sha256=lOM37vdIBcYfLQFTLP5bDuNc7vTFGBNYPfqHtWGNvA4,11624
 pyegeria/logging_configuration.py,sha256=BxTQRN-7OOdk5t1f1xSn8gKU8iT-MfWEgbn6cYWrRsY,7674
@@ -4367,11 +4369,11 @@ pyegeria/runtime_manager_omvs.py,sha256=bVAFJPRnIbTxdzmDHx7XgJBlyh_ZyHiKeUGqFT1O
 pyegeria/server_operations.py,sha256=dTqUEmX1B77b0x61OSU0aonsW8KwIpfzb3eioRpwaiI,16832
 pyegeria/solution_architect.py,sha256=hZQOEtenUGfTGYtI7kD0zI_Nf2IBy-RMNoasfp8BgGs,236903
 pyegeria/template_manager_omvs.py,sha256=chBljs1vy5wr9DRAtbvIt4Cob_7HxGfxLkCNlDTM-rQ,42755
-pyegeria/utils.py,sha256=qgiYEdCRrrL6SpX1sceZQVYR40-rfFAhUJEhsubcx80,6889
+pyegeria/utils.py,sha256=dh7PyRPjMZkVSGodRwJxqgCndL4TvKK4g891f0rZ3HI,10762
 pyegeria/valid_metadata_omvs.py,sha256=Xq9DqBQvBFFJzaFIRKcVZ2k4gJvSh9yeXs_j-O3vn1w,65050
 pyegeria/x_action_author_omvs.py,sha256=RcqSzahUKCtvb_3u_wyintAlc9WFkC_2v0E12TZs8lQ,6433
-pyegeria-5.4.4.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.4.4.1.dist-info/METADATA,sha256=YzOue9FT_FkpqffG-4ZxbbZbWq-A0lzdbjpbjz4Sxbw,6292
-pyegeria-5.4.4.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pyegeria-5.4.4.1.dist-info/entry_points.txt,sha256=HAS-LHaaBfkaZ19XU9g5mXwn2uj2HK99isdijI-VIDk,6353
-pyegeria-5.4.4.1.dist-info/RECORD,,
+pyegeria-5.4.4.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyegeria-5.4.4.2.dist-info/METADATA,sha256=7akG9oixZL63LJlSGv_hLTNy2lbfLvvtcA_PJ1hKmr8,6292
+pyegeria-5.4.4.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pyegeria-5.4.4.2.dist-info/entry_points.txt,sha256=HAS-LHaaBfkaZ19XU9g5mXwn2uj2HK99isdijI-VIDk,6353
+pyegeria-5.4.4.2.dist-info/RECORD,,