pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

md_processing/md_processing_utils/common_md_utils.py

@@ -3,16 +3,16 @@ This file contains general utility functions for processing Egeria Markdown
 """
 import os
 import re
-import sys
-import json
 from datetime import datetime
 from typing import Any
 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, body_slimmer)
-from pyegeria._globals import DEBUG_LEVEL
+
+from pyegeria import ServerClient, PyegeriaException
+from pyegeria.core.utils import (camel_to_title_case)
+from pyegeria.core._globals import DEBUG_LEVEL
 from md_processing.md_processing_utils.message_constants import message_types
 
 # Constants
@@ -34,10 +34,7 @@ EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
 EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
 EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
 EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
-LOG_FORMAT = "D <green> {time} </green> | {level} | {function} | {line} | {message} | {extra}"
-CONSOLE_LOG_FORMAT = "<green>{time}</green> | {message}"
 
-console = Console(width=EGERIA_WIDTH)
 GENERAL_GOVERNANCE_DEFINITIONS = ["Governance Definition", "Business Imperative", "Regulation Article", "Threat",
                                   "Governance Policy", "Governance Principle", "Governance Obligation",
                                   "Governance Approach",
@@ -54,20 +51,10 @@ GOVERNANCE_CONTROLS = ["Governance Control", "Governance Rule", "Service Level O
 ALL_GOVERNANCE_DEFINITIONS = GENERAL_GOVERNANCE_DEFINITIONS + GOVERNANCE_CONTROLS + ["Governance Strategy", "Regulation",
                                                 "Security Group", "GovernanceMetric",
                                                 "Naming Standard Rule", "TermsAndConditions", "Certification Type", "License Type"]
-
+console = Console(width=EGERIA_WIDTH)
 debug_level = DEBUG_LEVEL
 global COMMAND_DEFINITIONS
 
-def setup_log():
-    logger.remove()
-    logger.add(sys.stderr, level="SUCCESS", format=CONSOLE_LOG_FORMAT, colorize=True)
-    full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_INBOX_PATH, "data_designer_debug.log")
-    # logger.add(full_file_path, rotation="1 day", retention="1 week", compression="zip", level="TRACE", format=log_format,
-    #            colorize=True)
-    logger.add("debug_log", rotation="1 day", retention="1 week", compression="zip", level="INFO", format=LOG_FORMAT,
-               colorize=True)
-
-
 def split_tb_string(input: str)-> [Any]:
     """Split the string and trim the items"""
     l = [item.strip() for item in re.split(r'[;,\n]+',input)] if input is not None else None
@@ -229,23 +216,17 @@ def find_key_with_value(value: str) -> str | None:
 
 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
-
+    s = attributes.get('Search String', {}).get('value', None)
+    search_string = None if s =='*' else s
 
 
     body = {
         "class": "SearchStringRequestBody",
-        "searchString": attributes.get('Search String', {}).get('value', None),
+        "searchString": search_string,
         "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),
+        "limitResultsByStatus": attributes.get('Limit Results By Status', {}).get('value', []),
         "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),
@@ -253,13 +234,20 @@ def set_find_body(object_type: str, attributes: dict)->dict:
         "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:
+    """
+    Build the OUTER request body for a create action (NewElementRequestBody).
+
+    Notes on two-layer convention:
+    - Outer layer (this function): action wrapper with metadata like externalSource*, effectiveTime, anchor/parent hints, and an empty "properties" field.
+    - Inner layer: an element-type-specific Properties structure built by set_element_prop_body, set_product_body, set_data_field_body, etc.
+    Callers should build the inner body separately with the appropriate helper and then assign it to body["properties"].
+    """
     prop_name = object_type.replace(" ", "")
     body = {
         "class": "NewElementRequestBody",
@@ -275,6 +263,7 @@ def set_create_body(object_type: str, attributes: dict)->dict:
         "parentRelationshipTypeName": attributes.get('Parent Relationship Type Name', {}).get('value', None),
         "parentRelationshipProperties": attributes.get('Parent Relationship Properties', {}).get('value', None),
         "parentAtEnd1": attributes.get('Parent at End1', {}).get('value', True),
+        "anchorScopeGUID": attributes.get('Anchor Scope GUID', {}).get('guid', None),
         "properties": "",
         "initialStatus": attributes.get('Status', {}).get('value', "ACTIVE"),
         "initialClassifications": {}}
@@ -285,6 +274,13 @@ def set_create_body(object_type: str, attributes: dict)->dict:
 
 
 def set_update_body(object_type: str, attributes: dict)->dict:
+    """
+    Build the OUTER request body for an update action (UpdateElementRequestBody).
+
+    Two-layer convention:
+    - Outer layer (this function) provides action metadata and an empty "properties" slot.
+    - Inner layer must be constructed via element-specific helpers (e.g., set_element_prop_body) and assigned to the returned dict's "properties" key by the caller before invoking the client.
+    """
     return {
       "class" : "UpdateElementRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
@@ -293,12 +289,34 @@ def set_update_body(object_type: str, attributes: dict)->dict:
       "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),
+              "mergeUpdate": attributes.get('Merge Update', {}).get('value', True),
       "properties": "",
     }
+def set_rel_prop_body(object_type: str, attributes: dict)->dict:
+    prop_name = object_type.replace(" ", "")
+    display_name = attributes.get('Display Name', {}).get('value', None)
 
-def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    return {
+        "class": prop_name + "Properties",
+        "description": attributes['Description'].get('value', None),
+        "label": attributes.get('Label', {}).get('value', None) or attributes.get('Link Label', {}).get('value', None),
+        "typeName" : attributes.get('Type Name', {}).get('value', None),
+        "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
+        "effectiveTo": attributes.get('Effective To', {}).get('value', None),
+        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None),
+        }
 
+def set_element_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    """
+    Build the INNER element-specific Properties body to be placed under the outer body's "properties" key.
+
+    This returns the typed properties structure (e.g., "ReferenceableProperties" subtypes) appropriate for the object_type.
+    Usage example:
+    - outer = set_create_body(object_type, attributes)
+    - props = set_element_prop_body(object_type, qualified_name, attributes)
+    - outer["properties"] = props
+    - client.create_xxx(outer)
+    """
     prop_name = object_type.replace(" ", "")
     display_name = attributes.get('Display Name', {}).get('value', None)
 
@@ -320,7 +338,7 @@ def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict
         }
 
 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 = set_element_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)
@@ -330,7 +348,21 @@ def set_product_body(object_type: str, qualified_name: str, attributes: dict)->d
     prop_bod["nextVersion"] = attributes.get('Next Version Date', {}).get('value', [])
     return prop_bod
 
-
+def set_data_field_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    prop_bod = set_element_prop_body(object_type, qualified_name, attributes)
+    prop_bod["namespace"] = attributes.get('Namespace', {}).get('value', None)
+    prop_bod["aliases"] = attributes.get('Aliases', {}).get('value', [])
+    prop_bod["namePatterns"] = attributes.get('Name Patterns', {}).get('value', [])
+    prop_bod["defaultValue"] = attributes.get('Default Value', {}).get('value', None)
+    prop_bod["isNullable"] = attributes.get('Is Nullable', {}).get('value', None)
+    prop_bod["dataType"] = attributes.get('Data Type', {}).get('value', None)
+    prop_bod["units"] = attributes.get('Units', {}).get('value', None)
+    prop_bod["minimumLength"] = attributes.get('Minimum Length', {}).get('value', None)
+    prop_bod["length"] = attributes.get('Length', {}).get('value', None)
+    prop_bod["precision"] = attributes.get('Precision', {}).get('value', None)
+    prop_bod["orderedValues"] = attributes.get('Ordered Values', {}).get('value', [])
+    prop_bod["sortOrder"] = attributes.get('Sort Order', {}).get('value', None)
+    return prop_bod
 
 def set_update_status_body(object_type: str, attributes: dict)->dict:
     return {
@@ -343,7 +375,7 @@ def set_update_status_body(object_type: str, attributes: dict)->dict:
 
 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 = set_element_prop_body(object_type, qualified_name, attributes)
     prop_bod["domainIdentifier"] = attributes.get('Domain Identifier', {}).get('value', None)
     prop_bod["displayName"]= attributes.get('Display Name', {}).get('value', None)
     prop_bod['qualifiedName'] = qualified_name
@@ -355,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),
@@ -393,14 +425,22 @@ 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
 
 
 def set_rel_request_body(object_type: str, attributes: dict)->dict:
+    """
+    Build the OUTER request body for creating a relationship (NewRelationshipRequestBody).
+    The inner relationship properties must be assigned to the returned dict under the "properties" key,
+    commonly via set_rel_prop_body or set_rel_request_body_for_type.
+    """
     return {
       "class" : "NewRelationshipRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
@@ -422,9 +462,27 @@ def set_peer_gov_def_request_body(object_type: str, attributes: dict)->dict:
         }
     return rel_body
 
+def set_rel_request_body_for_type(object_type: str, attributes: dict)->dict:
+    """
+    Convenience helper that builds both layers (outer + inner) for a relationship of a known type.
+    It creates the outer NewRelationshipRequestBody via set_rel_request_body and fills rel_body["properties"]
+    with a typed properties structure under the "class" of f"{object_type}Properties".
+    """
+    rel_body = set_rel_request_body(object_type, attributes)
+    # class_prop = camel_to_title_case(object_type) + "Properties"
+    class_prop = f"{object_type}Properties"
+    rel_body["properties"] = {
+        "class" : class_prop,
+        "description": attributes.get('Description', {}).get('value', None),
+        "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
+        "effectiveTo": attributes.get('Effective To', {}).get('value', None),
+        "label": attributes.get('Label', {}).get('value', None),
+        }
+    return rel_body
+
 def set_delete_request_body(object_type: str, attributes: dict)->dict:
     return {
-        "class": "DeleteRequestBody",
+        "class": "DeleteElementRequestBody",
         "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),
@@ -463,10 +521,10 @@ 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 {}
+        body = {classification: {} for classification in classifications} if classifications else {}
     return body
 
-def set_collection_classifications(object_type: str, attributes: dict, obj_types: list[str])->dict:
+def set_object_classifications(object_type: str, attributes: dict, obj_types: list[str])->dict:
     classifications = attributes.get('Classifications', {}).get('name_list', None)
     obj = object_type.replace(" ", "")
     if object_type in obj_types:
@@ -480,4 +538,41 @@ def set_collection_classifications(object_type: str, attributes: dict, obj_types
     if classifications:
         for classification in classifications:
             body[classification] = {"class" : f"{classification}Properties"}
-    return body
+    return body
+
+def add_search_keywords(client: ServerClient, element_guid: str, keywords: list[str]):
+    """Add a search keyword to an element. Throw an exception if a problem is encountered.
+
+    Args:
+        client (ServerClient): The Egeria client instance.
+        element_guid (str): The GUID of the element to add the keyword to.
+        keyword (str): The search keyword to add.
+
+    Returns:
+        None
+    """
+    try:
+        for keyword in keywords:
+            client.add_search_keyword_to_element(element_guid, keyword)
+            print("Added keyword `{}` to element `{}`".format(keyword, element_guid))
+
+    except PyegeriaException as e:
+        context = {
+            "readon" : "Exception encountered executing add_search_keyword",
+            "element_guid": element_guid,
+            "keyword": keyword,
+            "exception": str(e)
+        }
+        raise PyegeriaException(context = context)
+
+def add_note_in_dr_e(client: ServerClient, qualified_name: str, display_name: str, journal_entry: str)-> str:
+    if journal_entry:
+        note_log_qn = f"{qualified_name}-NoteLog"
+        note_log_display_name = f"{display_name}-NoteLog"
+        note_display_name = f"{qualified_name}-Journal-Entry-{datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        journal_entry_guid = client.add_journal_entry(note_log_qn, qualified_name, note_log_display_name,
+                                                      note_display_name, journal_entry)
+        logger.info(f"Added journal entry `{journal_entry_guid}` to `{qualified_name}`")
+        return journal_entry_guid
+    else:
+        return None

md_processing/md_processing_utils/determine_width.py

@@ -0,0 +1,103 @@
+"""
+Determines the width of a markdown table
+"""
+
+import re
+import html
+from wcwidth import wcswidth
+
+def split_row(line: str) -> list[str]:
+    s = line.strip()
+    if s.startswith("|"):
+        s = s[1:]
+    if s.endswith("|"):
+        s = s[:-1]
+
+    parts = []
+    cur = []
+    escape = False
+    for ch in s:
+        if escape:
+            cur.append(ch)
+            escape = False
+        elif ch == "\\":
+            escape = True
+        elif ch == "|":
+            parts.append("".join(cur))
+            cur = []
+        else:
+            cur.append(ch)
+    parts.append("".join(cur))
+    return parts
+
+IMG_RE = re.compile(r'!\[([^\]]*)\]\([^)]+\)')
+LINK_RE = re.compile(r'\[([^\]]*)\]\([^)]+\)')
+CODE_TICKS_RE = re.compile(r'`([^`]*)`')
+EMPH_RE = re.compile(r'(\*\*|\*|__|_)')
+
+def visible_text(md: str) -> str:
+    s = md
+    s = IMG_RE.sub(lambda m: m.group(1), s)    # images → alt
+    s = LINK_RE.sub(lambda m: m.group(1), s)   # links → text
+    s = CODE_TICKS_RE.sub(lambda m: m.group(1), s)  # remove backticks
+    s = EMPH_RE.sub("", s)                    # remove emphasis markers
+
+    # unescape common backslash-escapes
+    s = (s
+         .replace("\\|", "|")
+         .replace("\\*", "*")
+         .replace("\\_", "_")
+         .replace("\\`", "`")
+         .replace("\\\\", "\\"))
+
+    s = html.unescape(s)  # & → &
+    return s.strip()
+
+def is_alignment_row(line: str) -> bool:
+    parts = split_row(line)
+    if not parts:
+        return False
+    def is_align_cell(c: str) -> bool:
+        c = c.strip()
+        return c != "" and all(ch in ":-" for ch in c)
+    return all(is_align_cell(p) for p in parts)
+
+def column_widths(md_table: str) -> list[int]:
+    lines = [ln for ln in md_table.splitlines() if ln.strip()]
+    if not lines:
+        return []
+
+    lines_wo_align = [ln for ln in lines if not is_alignment_row(ln)]
+
+    rows = [split_row(ln) for ln in lines_wo_align]
+    if not rows:
+        return []
+
+    max_cols = max(len(r) for r in rows)
+    for r in rows:
+        if len(r) < max_cols:
+            r.extend([""] * (max_cols - len(r)))
+
+    widths = [0] * max_cols
+    for r in rows:
+        for i, cell in enumerate(r):
+            text = visible_text(cell)
+            w = wcswidth(text)
+            if w < 0:  # non-printables fallback
+                w = len(text)
+            widths[i] = max(widths[i], w)
+    print(widths)
+    return widths
+
+# Example usage
+if __name__ == "__main__":
+    table = """
+| Attribute Name      | Input Required | Read Only | Generated | Default Value | Notes                                                                                                       | Unique Values | Valid Values                                                              |
+| ------------------- | -------------- | --------- | --------- | ------------- | ----------------------------------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------- |
+| Display Name        | True           | True      | False     | None          | Name of the  definition.                                                                                    | False         |                                                                           |
+| Summary             | False          | True      | False     | None          | Summary of the definition.                                                                                  | False         |                                                                           |
+| Description         | False          | True      | False     | None          | Description of the contents of the definition.                                                              | False         |                                                                           |
+| Category            | False          | True      | False     | None          | A user specified category name that can be used for example, to define product types or agreement types.    | False         |                                                                           |
+"""
+
+print(column_widths(table))  # e.g., [9, 28, 36] depending on characters

md_processing/md_processing_utils/extraction_utils.py

@@ -8,7 +8,7 @@ from md_processing.md_processing_utils.common_md_utils import (print_msg, find_k
                                                                update_element_dictionary)
 from md_processing.md_processing_utils.message_constants import INFO, EXISTS_REQUIRED
 from md_processing.md_processing_utils.md_processing_constants import debug_level
-from pyegeria._globals import NO_ELEMENTS_FOUND
+from pyegeria.core._globals import NO_ELEMENTS_FOUND
 from pyegeria.egeria_tech_client import EgeriaTech
 
 
@@ -74,45 +74,96 @@ 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
-    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()
+    Returns:
+        The cleaned value of the attribute, or None if not found.
+    """
 
-        label = label.strip()
-        pattern = rf"##\s*{re.escape(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)
+    for label in labels:
+        # Construct pattern for the current label - stops at next ##, ___ separator, or end of text
+        pattern = rf"## {re.escape(label)}\n(.*?)(?=^##|^_{3,}|\Z)"
+        match = re.search(pattern, text, re.DOTALL | re.MULTILINE)
         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)
+            extracted_text = match.group(1)
+
+            # Remove lines starting with '>' and lines that are only underscores/whitespace
+            filtered_lines = [
+                line for line in extracted_text.splitlines()
+                if not line.lstrip().startswith(">") and not re.match(r'^\s*_+\s*$', line)
+            ]
+            # 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
 
-            # 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
 
 
 def process_simple_attribute(txt: str, labels: set, if_missing: str = INFO) -> str | None:
@@ -142,7 +193,7 @@ def process_simple_attribute(txt: str, labels: set, if_missing: str = INFO) -> s
             msg = f"Missing attribute with labels `{labels}` "
         print_msg(if_missing, msg, debug_level)
         return None
-    return attribute
+    return attribute.strip()
 
 
 # def process_simple_attribute(txt: str, labels: list[str], if_missing: str = INFO) -> str | None:
@@ -412,8 +463,11 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
                 return q_name, guid, unique, exists
 
     # Haven't seen this element before
-    property_names = ['qualifiedName', 'name', 'displayName', 'title']
-    open_metadata_type_name = None
+    property_names = ['qualifiedName', 'displayName', 'title']
+    if element_type == "InformalTag":
+        open_metadata_type_name = element_type
+    else:
+        open_metadata_type_name = None
     details = egeria_client.get_elements_by_property_value(element_name, property_names, open_metadata_type_name)
     if isinstance(details, str):
         msg = f"{element_type} `{element_name}` not found in Egeria"
@@ -421,12 +475,19 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
         exists = False
         return None, None, unique, exists
     if len(details) > 1:
-        msg = (f"More than one element with name {element_name} found, please specify a "
-               f"**Qualified Name**")
-        print_msg("DEBUG-ERROR", msg, debug_level)
-        unique = False
-        exists = None
-        return element_name, None, unique, exists
+        if q_name is None:
+            q_name = egeria_client.__create_qualified_name__(element_type, element_name)
+            guid = egeria_client.__get_guid__(qualified_name=q_name)
+            update_element_dictionary(q_name, {'guid': guid})
+            exists = True if guid != "No elements found" else False
+            return q_name, guid, unique, exists
+        else:
+            msg = (f"More than one element with name {element_name} found, please specify a "
+                   f"**Qualified Name**")
+            print_msg("DEBUG-ERROR", msg, debug_level)
+            unique = False
+            exists = None
+            return element_name, None, unique, exists
 
     el_qname = details[0]["properties"].get('qualifiedName', None)
     el_guid = details[0]['elementHeader']['guid']