pyegeria 5.3.8.8__py3-none-any.whl → 5.3.8.9__py3-none-any.whl

pyegeria/__init__.py

@@ -11,24 +11,10 @@ the server platform and servers.
 
 """
 
-from ._globals import (
-    INTEGRATION_GUIDS,
-    TEMPLATE_GUIDS,
-    default_time_out,
-    disable_ssl_warnings,
-    enable_ssl_check,
-    is_debug,
-    max_paging_size,
-    NO_ELEMENTS_FOUND,
-    NO_ASSETS_FOUND,
-    NO_SERVERS_FOUND,
-    NO_CATALOGS_FOUND,
-    NO_GLOSSARIES_FOUND,
-    NO_TERMS_FOUND,
-    NO_CATEGORIES_FOUND,
-    NO_ELEMENT_FOUND,
-    NO_PROJECTS_FOUND,
-)
+from ._globals import (INTEGRATION_GUIDS, TEMPLATE_GUIDS, default_time_out, disable_ssl_warnings, enable_ssl_check,
+                       is_debug, max_paging_size, NO_ELEMENTS_FOUND, NO_ASSETS_FOUND, NO_SERVERS_FOUND,
+                       NO_CATALOGS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_CATEGORIES_FOUND, NO_ELEMENT_FOUND,
+                       NO_PROJECTS_FOUND, )
 
 if disable_ssl_warnings:
     from urllib3 import disable_warnings
@@ -38,22 +24,10 @@ if disable_ssl_warnings:
 
 from ._client import Client
 from ._deprecated_gov_engine import GovEng
-from ._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
-)
-from ._validators import (
-    is_json,
-    validate_guid,
-    validate_name,
-    validate_public,
-    validate_search_string,
-    validate_server_name,
-    validate_url,
-    validate_user_id,
-)
+from ._exceptions import (InvalidParameterException, PropertyServerException, UserNotAuthorizedException,
+                          print_exception_response, )
+from ._validators import (is_json, validate_guid, validate_name, validate_public, validate_search_string,
+                          validate_server_name, validate_url, validate_user_id, )
 from .asset_catalog_omvs import AssetCatalog
 from .automated_curation_omvs import AutomatedCuration
 from .classification_manager_omvs import ClassificationManager
@@ -69,16 +43,8 @@ from .feedback_manager_omvs import FeedbackManager
 from .full_omag_server_config import FullServerConfig
 from .glossary_browser_omvs import GlossaryBrowser
 from .glossary_manager_omvs import GlossaryManager
-from .mermaid_utilities import (
-    construct_mermaid_web,
-    construct_mermaid_jup,
-    generate_process_graph,
-    load_mermaid,
-    parse_mermaid_code,
-    render_mermaid,
-    save_mermaid_graph,
-    save_mermaid_html,
-)
+from .mermaid_utilities import (construct_mermaid_web, construct_mermaid_jup, generate_process_graph, load_mermaid,
+                                parse_mermaid_code, render_mermaid, save_mermaid_graph, save_mermaid_html, )
 from .metadata_explorer_omvs import MetadataExplorer
 from .my_profile_omvs import MyProfile
 from .platform_services import Platform
@@ -91,12 +57,13 @@ from .utils import body_slimmer, print_response
 from .valid_metadata_omvs import ValidMetadataManager
 from .x_action_author_omvs import ActionAuthor
 from .md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
-                                  process_category_upsert_command,
-                                  get_current_datetime_string, process_per_proj_upsert_command, command_list,
-                                  render_markdown, process_provenance_command, process_blueprint_upsert_command,
-                                  process_solution_component_upsert_command,
-                                  process_term_list_command, process_glossary_list_command, process_category_list_command,
-                                  process_term_history_command)
+                                  process_category_upsert_command, get_current_datetime_string,
+                                  process_per_proj_upsert_command, command_list, render_markdown,
+                                  process_provenance_command, process_blueprint_upsert_command,
+                                  process_solution_component_upsert_command, process_term_list_command,
+                                  process_glossary_list_command, process_category_list_command,
+                                  process_term_history_command, process_glossary_structure_command,
+                                  process_term_revision_history_command)
 
 #
 # The following assignments were generated by the `create_tech_guid_lists.py` utility that uses the pyegeria functions
@@ -482,6 +449,5 @@ INTEGRATION_GUIDS['OpenLineageCataloguer'] = '3347ac71-8dd2-403a-bc16-75a71be64b
 INTEGRATION_GUIDS['ApacheAtlasExchange'] = '5721627a-2dd4-4f95-a274-6cfb128edb97'
 INTEGRATION_GUIDS['HarvestSurveys'] = 'fae162c3-2bfd-467f-9c47-2e3b63a655de'
 
-
 if __name__ == "__main__":
     print("Main-Init")

pyegeria/commands/cat/dr_egeria_md.py

@@ -13,7 +13,8 @@ from pyegeria import (extract_command, process_glossary_upsert_command, process_
                       get_current_datetime_string,
                       process_per_proj_upsert_command, command_list, EgeriaTech, process_blueprint_upsert_command,
                       process_solution_component_upsert_command, dr_egeria_state, process_term_list_command,
-                      process_category_list_command, process_glossary_list_command, process_term_history_command)
+                      process_category_list_command, process_glossary_list_command, process_term_history_command,
+                      process_glossary_structure_command, process_term_revision_history_command,)
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
@@ -89,21 +90,20 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
                 result = process_glossary_upsert_command(client, current_block, directive)
             elif potential_command in ["Create Category", "Update Category"]:
                 result = process_category_upsert_command(client, current_block, directive)
-            # elif potential_command in ["Set Parent Category", "UnSet Parent Category"]:
-            #     result = process_set_categories_parent_command(client, dr_egeria_state.get_element_dictionary(),
-            #                                                    current_block, directive)
             elif potential_command in ["Create Term", "Update Term"]:
                 result = process_term_upsert_command(client, current_block, directive)
             elif potential_command in ["List Term History", "Term History"]:
                 result = process_term_history_command(client, current_block, directive)
+            elif potential_command in ["List Term Update History", "List Term Revision History"]:
+                result = process_term_revision_history_command(client, current_block, directive)
             elif potential_command in ["List Terms", "List Glossary Terms"]:
                 result = process_term_list_command(client, current_block, directive)
             elif potential_command in ["List Categories", "List Glossary Categories"]:
-                result = process_category_list_command(client, dr_egeria_state.get_element_dictionary(), current_block,
-                                                       directive)
+                result = process_category_list_command(client, current_block, directive)
+            elif potential_command in ["List Glossary Structure"]:
+                result = process_glossary_structure_command(client, current_block, directive)
             elif potential_command in ["List Glossaries"]:
-                result = process_glossary_list_command(client, dr_egeria_state.get_element_dictionary(), current_block,
-                                                       directive)
+                result = process_glossary_list_command(client, current_block, directive)
             elif potential_command in ["Create Personal Project", "Update Personal Project"]:
                 result = process_per_proj_upsert_command(client, current_block, directive)
             elif potential_command in ["Create Blueprint", "Update Blueprint", "Create Solution Blueprint",

pyegeria/glossary_browser_omvs.py

@@ -640,11 +640,11 @@ class GlossaryBrowser(Client):
             output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
-            str: The parent category name or '---' if no parent
+            str: The parent category name or ' ' if no parent
         """
         parent_cat = self.get_category_parent(category_guid)
         if isinstance(parent_cat, str):
-            return '---'
+            return ' '
 
         # Return qualified name for FORM output, display name for REPORT and LIST output
         if output_format == 'FORM':
@@ -3107,6 +3107,109 @@ class GlossaryBrowser(Client):
 
         return response
 
+    def list_term_revision_history(self, term_guid: str, output_format: str = "DICT") -> list | str:
+        """
+        Retrieve the revision history for a term.
+
+        This method retrieves the revision logs associated with a term, and for each revision log,
+        retrieves the revision history. The results are formatted according to the specified output format.
+
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve the revision history for.
+        output_format : str, optional
+            The format in which to return the results. Can be "DICT", "MD", or "LIST".
+            Defaults to "DICT".
+
+        Returns
+        -------
+        list | str
+            If output_format is "DICT", returns a list of dictionaries containing the revision history.
+            If output_format is "MD", returns a markdown representation of the revision history.
+            If output_format is "LIST", returns a markdown table of the revision history.
+            If no revision logs are found, returns a string message "No revision logs found".
+        """
+        import re
+        validate_guid(term_guid)
+
+        # Get revision logs for the term
+        revision_logs = self.get_term_revision_logs(term_guid)
+        if isinstance(revision_logs, str):
+            return "No revision logs found"
+
+        # Process each revision log
+        all_entries = []
+        for log in revision_logs:
+            log_guid = log['elementHeader']['guid']
+            qualified_name = log.get('properties', {}).get('qualifiedName', '---')
+
+            # Get revision history for this log
+            history = self.get_term_revision_history(log_guid)
+            if isinstance(history, str):
+                continue
+
+            # Process each entry in the history
+            for entry in history:
+                # Extract update time from the title
+                title = entry.get('properties', {}).get('title', '---')
+
+                keyword_index = title.index('on')
+                update_time = title[keyword_index + 2:].strip()
+
+                entry_data = {
+                    'qualifiedName': qualified_name,
+                    'title': title,
+                    'text': entry.get('properties', {}).get('text', '---'),
+                    'updateTime': update_time  # Use extracted date/time or fall back to title
+                }
+                all_entries.append(entry_data)
+
+        # Sort entries by update time
+        sorted_entries = sorted(all_entries, key=lambda x: x['updateTime'] if x['updateTime'] != '---' else '', reverse=True)
+
+        # Return in the specified format
+        if output_format == "DICT":
+            return sorted_entries
+        elif output_format == "LIST":
+            # Create markdown table
+            if not sorted_entries:
+                return "No revision entries found"
+
+            # Get headers
+            headers = sorted_entries[0].keys()
+
+            # Create header row
+            header_row = " | ".join(headers)
+            separator_row = " | ".join(["---"] * len(headers))
+
+            # Create rows
+            rows = []
+            for entry in sorted_entries:
+                row = " | ".join(str(entry.get(header, "---")) for header in headers)
+                rows.append(row)
+
+            # Combine into table
+            markdown_table = f"{header_row}\n{separator_row}\n" + "\n".join(rows)
+            return markdown_table
+        elif output_format == "MD":
+            # Create markdown representation
+            if not sorted_entries:
+                return "No revision entries found"
+
+            md_output = "\n"
+
+            for entry in sorted_entries:
+                md_output += f"* Note Log Name: \n{entry['qualifiedName']}\n\n"
+                md_output += f"* Note Log Entry Title: \n{entry['title']}\n\n"
+                md_output += f"* Note Log Entry: \n\t{entry['text']}\n\n"
+                md_output += "---\n\n"
+
+            return md_output
+        else:
+            # Default to DICT format
+            return sorted_entries
+
 
     def list_full_term_history(self, term_guid: str, output_type: str = "DICT") -> list | str:
         """
@@ -3138,19 +3241,19 @@ class GlossaryBrowser(Client):
             return "No History Found"
         version_history = []
         for ver in history:
-            create_time = ver["elementHeader"]["versions"].get("createTime", "---")
-            update_time = ver["elementHeader"]["versions"].get("createTime", "---")
-            created_by = ver["elementHeader"]["versions"].get("createdBy", "---")
+            create_time = ver["elementHeader"]["versions"].get("createTime", " ")
+            update_time = ver["elementHeader"]["versions"].get("createTime", " ")
+            created_by = ver["elementHeader"]["versions"].get("createdBy", " ")
             updated_by = ver["elementHeader"]["versions"].get("updatedBy", "---")
             version = ver["elementHeader"]["versions"].get("version")
 
-            qualified_name = ver["glossaryTermProperties"].get("qualifiedName", '---')
-            display_name = ver["glossaryTermProperties"].get("displayName", '---')
-            summary = ver["glossaryTermProperties"].get("summary", '---')
-            description = ver["glossaryTermProperties"].get("description", '---')
-            examples = ver["glossaryTermProperties"].get("examples", '---')
-            usage = ver["glossaryTermProperties"].get("usage", '---')
-            version_identifier = ver["glossaryTermProperties"].get("versionIdentifier", '---')
+            qualified_name = ver["glossaryTermProperties"].get("qualifiedName", ' ')
+            display_name = ver["glossaryTermProperties"].get("displayName", ' ')
+            summary = ver["glossaryTermProperties"].get("summary", ' ')
+            description = ver["glossaryTermProperties"].get("description", ' ')
+            examples = ver["glossaryTermProperties"].get("examples", ' ')
+            usage = ver["glossaryTermProperties"].get("usage", ' ')
+            version_identifier = ver["glossaryTermProperties"].get("versionIdentifier", ' ')
 
             version_history.append({
                 "version": version, "displayName": display_name, "summary": summary, "created": create_time,
@@ -3178,6 +3281,8 @@ class GlossaryBrowser(Client):
             # Combine everything into a Markdown table string
             markdown_table = f"{header_row}\n{separator_row}\n" + "\n".join(rows)
             return markdown_table
+        else:
+            return None
 
     async def _async_find_glossary_terms(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
             effective_time: str = None, starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,

pyegeria/md_processing_utils.py

@@ -4,7 +4,7 @@ This file contains functions to parse and process Egeria Markdown (Freddie)
 
 
 """
-
+import json
 import os
 import re
 import sys
@@ -16,8 +16,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 
 from pyegeria import body_slimmer
-from pyegeria._globals import (NO_GLOSSARIES_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, \
-                               NO_CATEGORIES_FOUND)
+from pyegeria._globals import (NO_GLOSSARIES_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND)
 from pyegeria.dr_egeria_state import get_element_dictionary, update_element_dictionary, find_key_with_value
 from pyegeria.egeria_tech_client import EgeriaTech
 # from pyegeria.md_processing_helpers import process_q_name_list
@@ -27,12 +26,11 @@ EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
 console = Console(width=EGERIA_WIDTH)
 
 command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms",
-                "List Glossary Terms", "List Term History", "Term Journal Report", "List Glossary Structure",
-                "List Glossaries", "List Categories", "List Glossary Categories",
-                "Create Personal Project", "Update Personal Project", "Create Category",
-                "Update Category", "Create Solution Blueprint", "Update Solution Blueprint",
-                "Create Solution Component", "Update Solution Component", "Update Category Structure",
-                ]
+                "List Glossary Terms", "List Term History", "List Term Revision History", "List Term Update History",
+                "List Glossary Structure", "List Glossaries", "List Categories", "List Glossary Categories",
+                "Create Personal Project", "Update Personal Project", "Create Category", "Update Category",
+                "Create Solution Blueprint", "Update Solution Blueprint", "Create Solution Component",
+                "Update Solution Component", ]
 # verbosity - verbose, quiet, debug
 debug_level = "debug"
 message_types = {
@@ -51,7 +49,8 @@ GLOSSARY_NAME_LABELS = ["Glossary Name", "Glossary", "Glossaries", "Owning Gloss
 CATEGORY_NAME_LABELS = ["Glossary Category Name", "Glossary Category", "Glossary Categories", "Category Name",
                         "Category", "Categories"]
 PARENT_CATEGORY_LABELS = ["Parent Category Name", "Parent Category", "parent category name", "parent category"]
-CHILD_CATEGORY_LABELS = ["Child Categories", "Child Category", "child category names", "child categories", "Child Category Names"]
+CHILD_CATEGORY_LABELS = ["Child Categories", "Child Category", "child category names", "child categories",
+                         "Child Category Names"]
 TERM_NAME_LABELS = ["Glossary Term Name", "Glossary Term", "Glossary Terms", "Term Name", "Term", "Terms", "Term Names"]
 PROJECT_NAME_LABELS = ["Project Name", "Project", "Project Names", "Projects"]
 BLUEPRINT_NAME_LABELS = ["Solution Blueprint Name", "Solution Blueprint", "Solution Blueprints", "Blueprint Name",
@@ -65,8 +64,12 @@ SOLUTION_ACTOR_ROLE_LABELS = ["Solution Actor Role Name", "Solution Actor Role N
 SOLUTION_LINKING_ROLE_LABELS = ["Solution Linking Role Name", "Solution Linking Role Names", "Solution Linking Role",
                                 "Solution Linking Roles", "Linking Role Name", "Linking Role", "Linking Roles",
                                 "Linking Role Names"]
+OUTPUT_LABELS = ["Output", "Output Format"]
+SEARCH_LABELS = ['Search String', 'Filter']
 GUID_LABELS = ['GUID', 'guid']
 
+ELEMENT_OUTPUT_FORMATS = ["LIST", "DICT", "MD", "FORM", "REPORT"]
+
 
 def render_markdown(markdown_text: str) -> None:
     """Renders the given markdown text in the console."""
@@ -152,12 +155,13 @@ def update_term_categories(egeria_client: EgeriaTech, term_guid: str, categories
                 egeria_client.remove_term_from_category(term_guid, cat)
                 msg = f"Removed term {term_guid} from category {cat}"
                 print_msg("DEBUG-INFO", msg, debug_level)
-    else: # No categories specified - so remove any categories a term is in
+    else:  # No categories specified - so remove any categories a term is in
         for cat in current_categories:
             egeria_client.remove_term_from_category(term_guid, cat)
             msg = f"Removed term {term_guid} from category {cat}"
             print_msg("DEBUG-INFO", msg, debug_level)
 
+
 def extract_command_plus(block: str) -> tuple[str, str, str] | None:
     """
     Extracts a multi-word object and its associated action from the given block of text.
@@ -291,7 +295,7 @@ def print_msg(msg_level: str, msg: str, verbosity: str):
             sys.exit(1)
 
 
-def process_simple_attribute(txt: str, labels: [str], if_missing: str = INFO) -> str | None:
+def process_simple_attribute(txt: str, labels: list[str], 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.
        If it doesn`t exist, return None and print an error message with severity of if_missing.
@@ -531,17 +535,17 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
     unique = True
     return el_qname, el_guid, unique, exists
 
-    # Convert element_type to plural form for method name construction  # if element_type.endswith('y'):  #  #
-    # plural_type = f"{element_type[:-1]}ies"  # elif element_type.endswith('s'):  #     plural_type = f"{  #
+    # Convert element_type to plural form for method name construction  # if element_type.endswith('y'):  #  #  #
+    # plural_type = f"{element_type[:-1]}ies"  # elif element_type.endswith('s'):  #     plural_type = f"{  #  #
     # element_type}es"  # else:  #     plural_type = f"{element_type}s"  #  # # Construct method name  # method_name
     # = f"get_{plural_type}_by_name"  #  # # Check if the method exists on the client  # if hasattr(egeria_client,
     # method_name):  #     # Call the method  #     method = getattr(egeria_client, method_name)  #     result =  #
-    # method(element_name)  #     return result  # else:  #     # Method doesn't exist  #     return f"Method {  #
+    # method(element_name)  #     return result  # else:  #     # Method doesn't exist  #     return f"Method {  #  #
     # method_name} not found on client"
 
 
-def process_name_list(egeria_client: EgeriaTech, element_type: str, txt: str, element_labels: list[str]) -> tuple[str, list[
-    Any], bool | Any, bool | None | Any] | None:
+def process_name_list(egeria_client: EgeriaTech, element_type: str, txt: str, element_labels: list[str]) -> tuple[str,
+list[Any], bool | Any, bool | None | Any] | None:
     """
     Processes a list of names specified in the given text, retrieves details for each
     element based on the provided type, and generates a list of valid qualified names.
@@ -678,11 +682,11 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                 print_msg("ALWAYS", msg, debug_level)
 
                 # update with get blueprint by guid
-                return 'Would return get blueprint by guid and return md'  # egeria_client.get_term_by_guid(  #
+                return 'Would return get blueprint by guid and return md'  # egeria_client.get_term_by_guid(  #  #
                 # known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #
                 # known_guid, 'md')
 
             elif object_action == "Create":
@@ -711,7 +715,8 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
             return None
 
 
-def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> \
+Optional[str]:
     """
     Processes a solution componentt create or update command by extracting key attributes such as
     solution component name, description, version, solution component type etc from the given cell.
@@ -757,9 +762,8 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     if solution_blueprints:  # Find information about blueprints that include this component
         msg = "Checking for blueprints that include this solution component"
         print_msg("DEBUG-INFO", msg, debug_level)
-        solution_blueprints, bp_qname_list, bp_valid, bp_exist = process_name_list(egeria_client,
-                                                                                     'Solution Blueprints', txt,
-                                                                                   BLUEPRINT_NAME_LABELS)
+        solution_blueprints, bp_qname_list, bp_valid, bp_exist = process_name_list(egeria_client, 'Solution Blueprints',
+                                                                                   txt, BLUEPRINT_NAME_LABELS)
         if bp_exist and bp_valid:
             msg = f"Found valid blueprints that include this solution component:\n\t{solution_blueprints}"
             print_msg("INFO", msg, debug_level)
@@ -770,8 +774,8 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
         msg = f"Parent Components are missing"
         print_msg("INFO", msg, debug_level)
     else:
-        parent_components, parent_qname_list, parents_valid, parent_components_exist = process_name_list(
-            egeria_client, 'Parent Components', txt, COMPONENT_NAME_LABELS)
+        parent_components, parent_qname_list, parents_valid, parent_components_exist = process_name_list(egeria_client,
+            'Parent Components', txt, COMPONENT_NAME_LABELS)
         if parent_components_exist and parents_valid:
             msg = f"Found valid parent components that include this solution component:\n\t{parent_qname_list}"
             print_msg("INFO", msg, debug_level)
@@ -844,11 +848,11 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
                 msg = f"\nUpdated Solution Component `{display_name}` with GUID {known_guid}"
                 print_msg("ALWAYS", msg, debug_level)
                 # update with get solution component by guid
-                return 'Would return get Solution Component by guid and return md'  #  #
+                return 'Would return get Solution Component by guid and return md'  # #  #
                 # egeria_client.get_term_by_guid(known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #
                 # known_guid, 'md')
 
             elif object_action == "Create":
@@ -866,7 +870,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
                     msg = f"\nCreated Solution Component `{display_name}` with GUID {known_guid}"
                     print_msg("ALWAYS", msg, debug_level)
                     update_element_dictionary(known_q_name, {'guid': known_guid, 'display_name': display_name})
-                    return 'Would return get solution component by guid results as md'  #  #
+                    return 'Would return get solution component by guid results as md'  # #  #
                     # egeria_client.get_term_by_guid(term_guid, 'MD')
 
         except Exception as e:
@@ -960,9 +964,8 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
 
         if object_action == "Update":
             if not glossary_exists:
-                print(
-                    f"\n{ERROR}Glossary `{glossary_name}` does not exist! Updating result document with Create "
-                    f"command\n")
+                print(f"\n{ERROR}Glossary `{glossary_name}` does not exist! Updating result document with Create "
+                      f"command\n")
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
 
             body = {
@@ -996,6 +999,10 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 # return update_a_command(txt, command, object_type, qualified_name, glossary_guid)
                 print_msg(ALWAYS, f"Created Glossary `{glossary_name}` with GUID {glossary_guid}", debug_level)
                 return egeria_client.get_glossary_by_guid(glossary_guid, output_format='MD')
+        else:
+            return None
+    else:
+        return None
 
 
 def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
@@ -1022,7 +1029,6 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
 
     parent_category_name = process_simple_attribute(txt, PARENT_CATEGORY_LABELS, "INFO")
 
-
     element_labels = CATEGORY_NAME_LABELS
     element_labels.append('Display Name')
     # Check if category exists (and get qname and guid)
@@ -1036,7 +1042,6 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                                                                                        element_labels, txt,
                                                                                        object_action, None)
 
-
     # Check if owning glossary exists (and get qname)
     if owning_glossary_name is None:
         valid = False
@@ -1047,8 +1052,8 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
             egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, EXISTS_REQUIRED, None)
 
     if parent_category_name:
-        _, parent_guid, parent_valid, parent_exists = get_element_by_name(
-        egeria_client, 'Glossary Categories', parent_category_name)
+        _, parent_guid, parent_valid, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
+            parent_category_name)
     else:
         parent_guid = None
         parent_exists = False
@@ -1120,9 +1125,9 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 })
             print_msg(ALWAYS, f"Updated Category `{category_name}` with GUID {known_guid}", debug_level)
 
-            category_sync = update_category_parent(egeria_client, known_guid,
-                                                   parent_category_name)
-            print_msg(ALWAYS, f"Updated Category hierarchy for  `{category_name}` with outcome {category_sync}", debug_level)
+            category_sync = update_category_parent(egeria_client, known_guid, parent_category_name)
+            print_msg(ALWAYS, f"Updated Category hierarchy for  `{category_name}` with outcome {category_sync}",
+                      debug_level)
             return egeria_client.get_category_by_guid(known_guid, output_format='FORM')
 
         elif object_action == "Create":
@@ -1149,9 +1154,12 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
                 if parent_valid & parent_exists:
                     egeria_client.set_parent_category(parent_guid, category_guid)
-                    print_msg(ALWAYS, f"Set parent category for `{category_name}` to `{parent_category_name}`", debug_level)
+                    print_msg(ALWAYS, f"Set parent category for `{category_name}` to `{parent_category_name}`",
+                              debug_level)
                 else:
-                    print_msg(ERROR, f"Parent category `{parent_category_name}` not found or invalid for `{category_name}`", debug_level)
+                    print_msg(ERROR,
+                              f"Parent category `{parent_category_name}` not found or invalid for `{category_name}`",
+                              debug_level)
                 return egeria_client.get_category_by_guid(category_guid, output_format='FORM')
         return None
     return None
@@ -1189,8 +1197,8 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
 
         if isinstance(current_parent, str) and "No Parent Category found" in current_parent:
             # No parent currently set, need to set it
-            parent_q_name, parent_guid, parent_valid, parent_exists = get_element_by_name(
-                egeria_client, 'Glossary Categories', parent_category_name)
+            _, parent_guid, _, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
+                parent_category_name)
 
             if parent_exists and parent_guid:
                 egeria_client.set_parent_category(parent_guid, category_guid)
@@ -1210,12 +1218,14 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
                     egeria_client.remove_parent_category(current_parent_guid, category_guid)
 
                 # Then set the new parent
-                parent_q_name, parent_guid, parent_valid, parent_exists = get_element_by_name(
-                    egeria_client, 'Glossary Categories', parent_category_name)
+                _, parent_guid, _, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
+                    parent_category_name)
 
                 if parent_exists and parent_guid:
                     egeria_client.set_parent_category(parent_guid, category_guid)
-                    print_msg(ALWAYS, f"Updated parent category from `{current_parent_name}` to `{parent_category_name}`", debug_level)
+                    print_msg(ALWAYS,
+                              f"Updated parent category from `{current_parent_name}` to `{parent_category_name}`",
+                              debug_level)
                 else:
                     print_msg(ERROR, f"Parent category `{parent_category_name}` not found", debug_level)
                     outcome = False
@@ -1232,43 +1242,39 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
                 egeria_client.remove_parent_category(current_parent_guid, category_guid)
                 print_msg(ALWAYS, f"Removed parent category `{current_parent_name}`", debug_level)
 
-
     return outcome
 
 
-
-
 def process_term_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
     command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-    known_glossary_q = ""
-    known_glossary_guid = ""
-    glossary_exists = False
-    glossary_valid = False
-
 
-    search_string = process_simple_attribute(txt, ['Search String', 'Filter'])
+    search_string = process_simple_attribute(txt, SEARCH_LABELS)
     if search_string is None:
         search_string = '*'
     print(Markdown(f"{pre_command} `{command}` with search string:`{search_string}` with directive: `{directive}`"))
 
     glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary'])
     if glossary is not None:
-        _, glossary_guid, _, glossary_exists = get_element_by_name(
-        egeria_client, "Glossary", glossary)
+        _, glossary_guid, _, glossary_exists = get_element_by_name(egeria_client, "Glossary", glossary)
         msg = f"Found glossary `{glossary}` with GUID {glossary_guid}"
         print_msg(INFO, msg, debug_level)
     else:
-        glossary_guid= None
+        glossary_guid = None
         msg = f"No glossary found"
         print_msg(INFO, msg, debug_level)
 
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
+    if output_format is None:
+        output_format = "LIST"
+    elif output_format not in ELEMENT_OUTPUT_FORMATS:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
 
-    request_display = f"\n* Search String: {search_string}\n* Glossary: {glossary}\n"
+    request_display = (f"\n\t* Search String: {search_string}\n\t* Glossary: {glossary}\n\t* Output Format: "
+                       f"{output_format}\n")
 
     if directive == "display":
         print(Markdown(request_display))
@@ -1282,47 +1288,49 @@ def process_term_list_command(egeria_client: EgeriaTech, txt: str, directive: st
             if not valid:  # First validate the term before we process it
                 return None
 
-            md_table = egeria_client.find_glossary_terms(search_string,glossary_guid, output_format = "LIST")
+            term_list_md = f"\n# Term List for search string: `{search_string}`\n\n"
+            if output_format == "DICT":
+                struct = egeria_client.find_glossary_terms(search_string, glossary_guid, output_format=output_format)
+                term_list_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                term_list_md += egeria_client.find_glossary_terms(search_string, glossary_guid, output_format=output_format)
+            print_msg("ALWAYS", f"Wrote Term List for search string: `{search_string}`", debug_level)
+
+            return term_list_md
+
+
+            md_table = egeria_client.find_glossary_terms(search_string, glossary_guid, output_format=output_format)
 
+            print_msg("ALWAYS", f"Wrote Term list for search string `{search_string}`", debug_level)
             return md_table
 
         except Exception as e:
-            print(f"{ERROR}Error creating Glossary Term list: {e}")
+            print(f"{ERROR}Error performing {command}: {e}")
             console.print_exception(show_locals=True)
             return None
+    else:
+        return None
 
-def process_category_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                  directive: str = "display") -> Optional[str]:
+
+def process_category_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
     command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-    known_glossary_q = ""
-    known_glossary_guid = ""
-    glossary_exists = False
-    glossary_valid = False
-
 
-    search_string = process_simple_attribute(txt, ['Search String', 'Filter'])
+    search_string = process_simple_attribute(txt, SEARCH_LABELS, "INFO")
     if search_string is None:
         search_string = '*'
     print(Markdown(f"{pre_command} `{command}` with search string:`{search_string}` with directive: `{directive}`"))
 
-    # glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary'])
-    # if glossary is not None:
-    #     _, glossary_guid, _, glossary_exists = get_element_by_name(
-    #     egeria_client, "Glossary", glossary)
-    #     msg = f"Found glossary `{glossary}` with GUID {glossary_guid}"
-    #     print_msg(INFO, msg, debug_level)
-    # else:
-    #     glossary_guid= None
-    #     msg = f"No glossary found"
-    #     print_msg(INFO, msg, debug_level)
-
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    if output_format is None:
+        output_format = "LIST"
+    elif output_format not in ELEMENT_OUTPUT_FORMATS:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
 
-    request_display = f"\n* Search String: {search_string}\n"
+    request_display = f"\n\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
 
     if directive == "display":
         print(Markdown(request_display))
@@ -1335,36 +1343,102 @@ def process_category_list_command(egeria_client: EgeriaTech, element_dictionary:
             print(Markdown(request_display))
             if not valid:  # First validate the term before we process it
                 return None
-            md_table = egeria_client.find_glossary_categories(search_string, output_format = "LIST")
 
-            return md_table
+            cat_list_md = f"\n# Category List for search string: `{search_string}`\n\n"
+            if output_format == "DICT":
+                struct = egeria_client.find_glossary_categories(search_string, output_format=output_format)
+                cat_list_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                cat_list_md += egeria_client.find_glossary_categories(search_string, output_format=output_format)
+            print_msg("ALWAYS", f"Wrote Category List for search string: `{search_string}`", debug_level)
+
+            return cat_list_md
 
         except Exception as e:
-            print(f"{ERROR}Error creating Glossary Category list: {e}")
+            print(f"{ERROR}Error performing {command}: {e}")
             console.print_exception(show_locals=True)
             return None
+    else:
+
+        return None
 
-def process_glossary_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                  directive: str = "display") -> Optional[str]:
+
+def process_glossary_structure_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[
+    str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
     command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-    known_glossary_q = ""
+
     known_glossary_guid = ""
-    glossary_exists = False
-    glossary_valid = False
 
+    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, "ERROR")
 
-    search_string = process_simple_attribute(txt, ['Search String', 'Filter'])
+    _, known_glossary_guid, valid, _ = process_element_identifiers(egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt,
+        EXISTS_REQUIRED, None)
+
+    print(Markdown(f"{pre_command} `{command}` for glossary:`{glossary_name}` with directive: `{directive}`"))
+
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    if output_format is None:
+        output_format = "MD"
+    elif output_format not in ["DICT", "LIST", "MD"]:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
+
+    request_display = f"\n\t* Glossary name: {glossary_name}\n\t* Output Format: {output_format}\n"
+
+    if directive == "display":
+        print(Markdown(request_display))
+        return None
+    elif directive == "validate":
+        print(Markdown(request_display))
+        return str(valid)
+    elif directive == "process":
+        try:
+            print(Markdown(request_display))
+            if not valid:  # First validate the term before we process it
+                return None
+
+            glossary_structure_md = f"\n# Glossary Structure for `{glossary_name}`\n\n"
+            if output_format == "DICT":
+                struct = egeria_client.get_glossary_category_structure(known_glossary_guid, output_format=output_format)
+                glossary_structure_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                glossary_structure_md += egeria_client.get_glossary_category_structure(known_glossary_guid, output_format=output_format)
+            print_msg("ALWAYS", f"Wrote Glossary Structure for glossary: `{glossary_name}`", debug_level)
+
+            return glossary_structure_md
+
+        except Exception as e:
+            print(f"{ERROR}Error performing {command}: {e}")
+            console.print_exception(show_locals=True)
+            return None
+    else:
+        return None
+
+
+def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """ List terms as a markdown table. Filter based on optional search string. """
+    set_debug_level(directive)
+    valid = True
+    command = extract_command(txt)
+
+    search_string = process_simple_attribute(txt, SEARCH_LABELS, "INFO")
     if search_string is None:
         search_string = '*'
     print(Markdown(f"{pre_command} `{command}` with search string:`{search_string}` with directive: `{directive}`"))
+    if search_string is None:
+        search_string = '*'
 
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    if output_format is None:
+        output_format = "LIST"
+    elif output_format not in ELEMENT_OUTPUT_FORMATS:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
 
-    request_display = f"\n* Search String: {search_string}\n"
+    request_display = f"\n\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
 
     if directive == "display":
         print(request_display)
@@ -1378,14 +1452,23 @@ def process_glossary_list_command(egeria_client: EgeriaTech, element_dictionary:
             if not valid:  # First validate the term before we process it
                 return None
 
-            md_table = egeria_client.find_glossaries(search_string, output_format = "LIST")
+            glossary_list_md = f"\n# Glossary List for `{search_string}`\n\n"
+            if output_format == "DICT":
+                struct = egeria_client.find_glossaries(search_string, output_format=output_format)
+                glossary_list_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                glossary_list_md += egeria_client.find_glossaries(search_string, output_format=output_format)
+            print_msg("ALWAYS", f"Wrote Glossary List for search string: `{search_string}`", debug_level)
 
-            return md_table
+            return glossary_list_md
 
         except Exception as e:
-            print(f"{ERROR}Error creating Glossary list: {e}")
+            print(f"{ERROR}Error performing {command}: {e}")
             console.print_exception(show_locals=True)
             return None
+    else:
+        return None
+
 
 def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
@@ -1399,16 +1482,20 @@ def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive:
     element_labels.append('Display Name')
 
     term_name = process_simple_attribute(txt, element_labels, "ERROR")
-    print(Markdown(f"{pre_command} `{command}` for term: `\'{term_name}\'` with directive: `{directive}` "))
 
     known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
-                                                                               element_labels, txt, object_action,
-                                                                            )
+                                                                               element_labels, txt, object_action, )
 
     print(Markdown(f"{pre_command} `{command}` for term:`{term_name}` with directive: `{directive}`"))
 
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    if output_format is None:
+        output_format = "LIST"
+    elif output_format not in ["DICT", "LIST"]:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
 
-    request_display = f"\n\t* Term Name: {term_name}\n\t* Qualified Name: {known_q_name}\n\t* GUID: {known_guid}\n"
+    request_display = f"\n\t* Term Name: {term_name}\n\t* Output Format {output_format}\n\t* GUID: {known_guid}\n"
 
     if directive == "display":
         print(request_display)
@@ -1422,16 +1509,76 @@ def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive:
             if not valid:  # First validate the term before we process it
                 return None
             term_history_md = f"\n# Term History for `{term_name}`\n\n"
-            term_history_md += egeria_client.list_full_term_history(known_guid, 'LIST')
+            if output_format == "DICT":
+                struct = egeria_client.list_term_revision_history(known_guid, output_format=output_format)
+                term_history_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                term_history_md += egeria_client.list_full_term_history(known_guid, output_format)
+            print_msg("ALWAYS", f"Wrote Term History for term `{term_name}`", debug_level)
 
             return term_history_md
 
         except Exception as e:
-            print(f"{ERROR}Error creating Glossary list: {e}")
+            print(f"{ERROR}Error performing {command}: {e}")
             console.print_exception(show_locals=True)
             return None
+    else:
+        return None
 
 
+def process_term_revision_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[
+    str]:
+    """ List term revision history as a markdown table or list."""
+    set_debug_level(directive)
+    valid = True
+    command = extract_command(txt)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
+    known_q_name = None
+    known_guid = None
+
+    element_labels = TERM_NAME_LABELS
+
+    term_name = process_simple_attribute(txt, element_labels, "ERROR")
+    print(Markdown(f"{pre_command} `{command}` for term: `{term_name}` with directive: `{directive}` "))
+
+    known_q_name, known_guid, valid, _ = process_element_identifiers(egeria_client, object_type, element_labels, txt,
+                                                                     object_action, )
+    output_format = process_simple_attribute(txt, ['Output Format', 'Format'], 'INFO')
+    if output_format is None:
+        output_format = "LIST"
+    elif output_format not in ["DICT", "LIST", "MD"]:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
+
+    request_display = f"\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}\n"
+
+    if directive == "display":
+        print(request_display)
+        return None
+    elif directive == "validate":
+        print(request_display)
+        return str(valid)
+    elif directive == "process":
+        try:
+            print(request_display)
+            if not valid:  # First validate the term before we process it
+                return None
+            term_history_md = f"\n# Term Revision History for `{term_name}`\n\n"
+            if output_format == "DICT":
+                struct = egeria_client.list_term_revision_history(known_guid, output_format)
+                term_history_md += f"{json.dumps(struct, indent=4)}\n"
+            else:
+                term_history_md += egeria_client.list_term_revision_history(known_guid, output_format)
+            print_msg("ALWAYS", f"Wrote Term Revision History for term `{term_name}`", debug_level)
+            return term_history_md
+
+        except Exception as e:
+            print(f"{ERROR}Error performing {command}: {e}")
+            console.print_exception(show_locals=True)
+            return None
+    else:
+        return None
 
 
 def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
@@ -1493,9 +1640,8 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
     if categories:  # Find information about categoriess that classify this term
         msg = "Checking for categories that classify this term"
         print_msg("DEBUG-INFO", msg, debug_level)
-        categories_list, cat_q_name_list, cat_valid, cat_exist = process_name_list(egeria_client,
-                                                                                     'Glossary Categories', txt,
-                                                                                   CATEGORY_NAME_LABELS)
+        categories_list, cat_q_name_list, cat_valid, cat_exist = process_name_list(egeria_client, 'Glossary Categories',
+                                                                                   txt, CATEGORY_NAME_LABELS)
         if cat_exist and cat_valid:
             msg = f"Found valid glossary categories to classify the term:\n\t{term_name}"
             print_msg("INFO", msg, debug_level)
@@ -1561,7 +1707,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
                           f"\tUpdated Term `{term_name}` with GUID {known_guid}\n\tand categories `{categories}`",
                           debug_level)
                 return egeria_client.get_term_by_guid(known_guid,
-                                                       'md')  # return update_a_command(txt, command, object_type,
+                                                      'md')  # return update_a_command(txt, command, object_type,
                 # known_q_name, known_guid)
             elif object_action == "Update" and directive == "validate":  # is sthis reachable?
                 return egeria_client.get_term_by_guid(known_guid, 'md')
@@ -1608,7 +1754,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
                     update_element_dictionary(known_q_name, {'guid': term_guid, 'display_name': term_name})
                     print_msg(ALWAYS, f"Created term `{term_name}` with GUID {term_guid}", debug_level)
                     return egeria_client.get_term_by_guid(term_guid,
-                                                           'MD')  # return update_a_command(txt, command,
+                                                          'MD')  # return update_a_command(txt, command,
                     # object_type, q_name, term_guid)
         except Exception as e:
             print(f"{ERROR}Error creating term {term_name}: {e}")

{pyegeria-5.3.8.8.dist-info → pyegeria-5.3.8.9.dist-info}/METADATA

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

{pyegeria-5.3.8.8.dist-info → pyegeria-5.3.8.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyegeria/README.md,sha256=PwX5OC7-YSZUCIsoyHh1O-WBM2hE84sm3Bd4O353NOk,1464
-pyegeria/__init__.py,sha256=4226Kaq5Xf439GRkRu6ckhzSSJ8L30EbdZocdLfcBwE,30568
+pyegeria/__init__.py,sha256=tRz08uRCYvJVVOzgUESDxStAoaXHYDr7wLfL1s21moM,30681
 pyegeria/_client.py,sha256=lCWq8XJOFg3MnEO4ulMVuCJrW3uU4eWUCcbLEd90_LU,34673
 pyegeria/_deprecated_gov_engine.py,sha256=dWNcwVsE5__dF2u4QiIyQrssozzzOjBbLld8MdpmVCQ,17264
 pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
@@ -16,7 +16,7 @@ pyegeria/commands/cat/README.md,sha256=-aaAnIT2fcfU63vajgB-RzQk4l4yFdhkyVfSaTPiq
 pyegeria/commands/cat/__init__.py,sha256=5OCy4m_yZsnSxdy_gvkCyP_OkjvuWKimqUGHYCJc_qA,450
 pyegeria/commands/cat/dr_egeria_inbox/glossary_creation_experiment.ipynb,sha256=dbzNu90fCKNohOWVSRBOB1GLyd95x8Qw51I5AkaPtso,11552
 pyegeria/commands/cat/dr_egeria_jupyter.py,sha256=h9LmDmejmaPDlDuGNlVor-bqNnKPvSBhcC7JFWBdOEM,5710
-pyegeria/commands/cat/dr_egeria_md.py,sha256=plTcv6Rq-crQD-W7r4iMYJ3NithzXlsuJFfwsLrC9oU,11367
+pyegeria/commands/cat/dr_egeria_md.py,sha256=C3-4iVfHH1inrsbyc0YBrWkmIPyX04aTRQ3D-uiRnH8,11331
 pyegeria/commands/cat/exp_list_glossaries.py,sha256=dC6Bnfm3YSMTKPP146qeslIFRiZnGu5b7iDYE07p4iU,5817
 pyegeria/commands/cat/get_asset_graph.py,sha256=xnXJfpDTVH1TJ2TwE3dtjaXU36Di6-N6JAyhothzz2o,12461
 pyegeria/commands/cat/get_collection.py,sha256=kXPcP8u-SMWfrVyyBhNoxG8mcgB7EV_5i9N9w_IBU7o,5379
@@ -226,11 +226,11 @@ pyegeria/egeria_my_client.py,sha256=eOKLk2zdI6FHZnhAimfR_0yNdBjpUgD41dJZcJODcqE,
 pyegeria/egeria_tech_client.py,sha256=uycgYfCpb4jzFfaQ7I5JxbZ5PKsWdaWxLOJjbw6C2Zk,3817
 pyegeria/feedback_manager_omvs.py,sha256=0xBs0p54vmdfVYYgQ8pOanLC4fxfgTk1Z61Y6D1U7_I,152978
 pyegeria/full_omag_server_config.py,sha256=CQqLCy_3DZFvJZEOcGf50HWdFaWpiAIs6z-kKyjvpDA,47464
-pyegeria/glossary_browser_omvs.py,sha256=k0VfD9sB5CEf27cLxqpMheO5Rn5LcitcsQfKNEx4jbY,153382
+pyegeria/glossary_browser_omvs.py,sha256=N8qP7q5dNwmV3QxxseapnFdTjVVdyT7SkWrNA_W2pPI,157486
 pyegeria/glossary_manager_omvs.py,sha256=QojY-B0UMWzLoAzzLwPTScKhTQnYLdc4c9wkZljvokM,72206
 pyegeria/m_test.py,sha256=M5-M2ZczsAJLXWfSeqTTADHdx6Ku-y4PbQ4M21JthAE,7778
 pyegeria/md_processing_helpers.py,sha256=sV-ciVg_xOGVGTH_CMpH2B5k3V5jzdFp_XvnQQ5xafw,2131
-pyegeria/md_processing_utils.py,sha256=8TjD_ffnTMLEZEkb2npnZy59glboWFkaRh0OK_YN9cw,83314
+pyegeria/md_processing_utils.py,sha256=tEwi10Z--p5qv7YZNJJq0DJru3bOfJHHUSsSvNpZbTw,90012
 pyegeria/md_processing_utils_orig.py,sha256=64eVP86__zI4EdzwveskDyLiw6EyWJXZW4pqk9aLpuM,52486
 pyegeria/mermaid_utilities.py,sha256=sQqdFUWdNpHu9d3Tk9UVe80M-5bOzses0XcFYX5FF-E,54254
 pyegeria/metadata_explorer_omvs.py,sha256=xHnZTQKbd6XwOhYia-RiIisrvZcqHi0SL1l6OCf04Gk,86911
@@ -245,8 +245,8 @@ pyegeria/template_manager_omvs.py,sha256=chBljs1vy5wr9DRAtbvIt4Cob_7HxGfxLkCNlDT
 pyegeria/utils.py,sha256=GCt1C0bp0Xng1ahzbZhzV9qQwH7Dj93IaCt2dvWb-sg,5417
 pyegeria/valid_metadata_omvs.py,sha256=Xq9DqBQvBFFJzaFIRKcVZ2k4gJvSh9yeXs_j-O3vn1w,65050
 pyegeria/x_action_author_omvs.py,sha256=RcqSzahUKCtvb_3u_wyintAlc9WFkC_2v0E12TZs8lQ,6433
-pyegeria-5.3.8.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.3.8.8.dist-info/METADATA,sha256=pBubP-kEh2Sch13w9G8vU8BZoUzeyByX-qn5rgskY9o,2740
-pyegeria-5.3.8.8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyegeria-5.3.8.8.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
-pyegeria-5.3.8.8.dist-info/RECORD,,
+pyegeria-5.3.8.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyegeria-5.3.8.9.dist-info/METADATA,sha256=7eNN-nHxckL5g37fvQKaGD1Mn0Vjr1vD8iE8-9U5yZ4,2740
+pyegeria-5.3.8.9.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pyegeria-5.3.8.9.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
+pyegeria-5.3.8.9.dist-info/RECORD,,