pyegeria 5.4.4.1__tar.gz → 5.4.4.2__tar.gz

{pyegeria-5.4.4.1 → pyegeria-5.4.4.2}/PKG-INFO

@@ -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.2/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
+

{pyegeria-5.4.4.1 → pyegeria-5.4.4.2}/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
 
 

{pyegeria-5.4.4.1 → pyegeria-5.4.4.2}/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:

{pyegeria-5.4.4.1 → pyegeria-5.4.4.2}/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
 

{pyegeria-5.4.4.1 → pyegeria-5.4.4.2}/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-5.4.4.1 → pyegeria-5.4.4.2}/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: