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

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.

md_processing/md_processing_utils/generate_md_cmd_templates.py

@@ -88,8 +88,8 @@ def main():
             command_output = io.StringIO()
 
             # Write command header
-            command_output.write(f"# **{command}**\n>\t{command_description}\n")
-            print(f"\n## {command_verb} **{command}**\n>\t{command_description}")
+            command_output.write(f"# {command}\n>\t{command_description}\n")
+            print(f"\n## {command_verb} {command}\n>\t{command_description}")
 
             # Process command attributes
             attributes = values['Attributes']
@@ -99,8 +99,8 @@ def main():
                         continue
                     user_specified = value.get('user_specified', 'true') in ["true", "True"]
 
-                    command_output.write(f"\n## **{key}**\n")
-                    print(f"\n### **{key}**")
+                    command_output.write(f"\n## {key}\n")
+                    print(f"\n### {key}")
 
                     command_output.write(f">\t**Input Required**: {value.get('input_required', 'false')}\n\n")
                     print(f">\tInput Required: {value.get('input_required', 'false')}")

pyegeria/_output_formats.py

@@ -443,7 +443,7 @@ base_output_format_sets = FormatSetDict({
         formats=[
             Format(
 
-                types=["DICT", "FORM", "LIST", "TABLE"],
+                types=["DICT", "FORM", "REPORT","LIST", "TABLE"],
                 columns= [
                     Column(name='Term Name', key='display_name'),
                     Column(name='Description', key='description'),

pyegeria/glossary_manager.py

@@ -2828,11 +2828,11 @@ class GlossaryManager(CollectionManager):
         response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, element_type, body,  output_format, output_format_set))
         return response
 
-    async def _async_find_glossary_terms(self, search_string: str, starts_with: bool = False,
+    async def _async_find_glossary_terms(self, search_string: str, starts_with: bool = True,
                                      ends_with: bool = False, ignore_case: bool = False, type_name: str = "GlossaryTerm",
                                      classification_names: list[str] = None, start_from: int = 0,
                                      page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict = None, body: dict = None) -> list | str:
+                                     output_format_set: str | dict = "Glossary-Term-DrE", body: dict = None) -> list | str:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
                f"by-search-string")
         response = await self._async_find_request(url, _type= type_name,

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.dist-info → pyegeria-5.4.4.2.dist-info}/METADATA

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

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

@@ -3,12 +3,8 @@ 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-01_07-02-58_818650.log.zip,sha256=oHriwvdtAjCF1lZUBteGc_nRqxbeWZZMdztdtXwFku4,60996
-commands/cat/debug_log.2025-09-02_07-44-39_567276.log.zip,sha256=3lJErYJjfrd8GNSVLeql3khPKO2ACnqQAqD7z2smx-U,21285
-commands/cat/debug_log.2025-09-03_07-45-21_986388.log.zip,sha256=aXrkTdBn_pFsGrwiIKTij96NyQhqn0uRRE_EsyA_atw,215221
-commands/cat/debug_log.2025-09-04_08-21-58_788009.log.zip,sha256=o8y66Asnj2waUhGfBHK4DP_4md9yQzWLAPqLOKRqFo4,27616
-commands/cat/debug_log.2025-09-05_09-37-53_062579.log.zip,sha256=ACgO0jq3PyP4CpDBSxzdjVcy8lBvMX-M3Xwnfjg-CMo,3131
-commands/cat/dr_egeria_command_help.py,sha256=z4EmOKNW_-5XS6eHFqIrq_9y4iyIiV3x_8B7nZjkncw,15677
+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
 commands/cat/exp_list_glossaries.py,sha256=dC6Bnfm3YSMTKPP146qeslIFRiZnGu5b7iDYE07p4iU,5817
@@ -4293,31 +4289,35 @@ md_processing/.obsidian/plugins/obsidian-sample-plugin/versions.json,sha256=BUEx
 md_processing/.obsidian/workspace.json,sha256=NLVJEOtsowljw7Ka035ReHLPu4iitk2ZsuSDN6zUAFY,4282
 md_processing/__init__.py,sha256=cEB6Fq334zRFybe2gLQgmfvMW_6s489JRD-j9Apoowg,7325
 md_processing/data/commands-working.json,sha256=uCo_azcuuYqGm7QffJeCGj7PyZuZRGdu7kKf4XWmMoA,1162560
-md_processing/data/commands.json,sha256=lezFy4RADLboQyW6e3s4nLzHkxsGR5orKSGtrEinrok,1690730
+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/debug_log,sha256=s9mvtRMiX8mAE_1DYeyEWJQc_m-SMZt48KQ9u4qCT14,144
+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/extraction_utils.py,sha256=bTeoiAC0DcNl5LjYuXkyk8V3cLhAshp_IFPMeROq7Qk,20930
+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=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=SbWtR3T1Y6VUpdcLzjbPA-601Sg-QzxdDYIXVoqjgCc,5813
+md_processing/md_processing_utils/generate_md_cmd_templates.py,sha256=SVdtlA6Nc9JIN-pORGbf-_shEP7egReuVejEcMjxRYM,5797
 md_processing/md_processing_utils/generate_md_templates.py,sha256=DMnMQ7_LbmQCS8aG-ppHGTu25obOSn4ZzSg7V21k9jo,3547
 md_processing/md_processing_utils/md_processing_constants.py,sha256=m-Vq0qPMkyF3riGcHWNid1_uRXPhCto8UdRxBKS3WvE,19458
 md_processing/md_processing_utils/message_constants.py,sha256=UBf18obM83umM6zplR7ychre4xLRbBnTzidHDZ2gNvM,548
@@ -4330,7 +4330,7 @@ pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
 pyegeria/_exceptions_new.py,sha256=srmrlqoWy7VvOJOhPcYFKW32MCIovgEg5J7PrYDxzQA,19706
 pyegeria/_globals.py,sha256=qSU5hM4uuJZPp-YapEEKxfcdgH9hauc6R7gRkELLroY,1132
 pyegeria/_output_format_models.py,sha256=p9fTYaIa5KyTMIR4-JAbE9g66_gGMPTnUqjIq20Zr1o,14494
-pyegeria/_output_formats.py,sha256=sWqLi6wtY71V93TUfP5CRPPF7e2WmztI1eYVMe6S8eQ,101106
+pyegeria/_output_formats.py,sha256=nVp-4JiYdHjz-kb7Z9c1lxRpo8BpkT4m18nclxUABvw,101115
 pyegeria/_validators.py,sha256=pNxND0dN2qvyuGE52N74l1Ezfrh2p9Hao2ziR_t1ENI,7425
 pyegeria/asset_catalog_omvs.py,sha256=P6FceMP0FgakGSOt3ePxpEbsF7nnypzo1aQahjdL_94,29021
 pyegeria/automated_curation_omvs.py,sha256=tzwCyXL0Hx8UjryBBWcPoEuBRajXZpLuwPQ1vuOg2yc,130349
@@ -4349,8 +4349,8 @@ pyegeria/egeria_tech_client.py,sha256=TjuwE9APWQZ4cRsxM0MoVrsikF8e4vkISDt_ra93tY
 pyegeria/external_references.py,sha256=XPJxE57d4e7ooasSZiYTpoppo43z1oLYvthD58__vNA,77641
 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=9mJpzxPN1l2OykXVVhQaS6IaQQluFIkUJ5QMmUibJ8g,110159
-pyegeria/governance_officer.py,sha256=3c-8PFUzWzPHc7OOX-Kt7vVaj4rSttCvOsgXSDX3POw,100217
+pyegeria/glossary_manager.py,sha256=LsemH2bC1jj6mquLxZMXsoZY77D8gTdWKXNs9Gee6mQ,110173
+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
@@ -4369,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.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.4.4.dist-info/METADATA,sha256=o5o636_ex1SCceKNx8t-BeH1Ceq7_ZwDXO4-sCBXC_0,6290
-pyegeria-5.4.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pyegeria-5.4.4.dist-info/entry_points.txt,sha256=HAS-LHaaBfkaZ19XU9g5mXwn2uj2HK99isdijI-VIDk,6353
-pyegeria-5.4.4.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,,