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

pyegeria/__init__.py

@@ -91,12 +91,12 @@ 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_categories_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_set_categories_parent_command,
-                                  process_term_list_command, process_glossary_list_command,process_category_list_command,
-                                  process_term_history_command,)
+                                  process_solution_component_upsert_command,
+                                  process_term_list_command, process_glossary_list_command, process_category_list_command,
+                                  process_term_history_command)
 
 #
 # The following assignments were generated by the `create_tech_guid_lists.py` utility that uses the pyegeria functions

pyegeria/commands/cat/Dr-Egeria_md-orig.py

@@ -13,8 +13,8 @@ from pyegeria.md_processing_utils import (extract_command, process_glossary_upse
 
 import click
 from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
-                      process_categories_upsert_command,
-                      get_current_datetime_string, process_per_proj_upsert_command, commands,EgeriaTech
+                      process_category_upsert_command,
+                      get_current_datetime_string, process_per_proj_upsert_command, commands, EgeriaTech
                       )
 from datetime import datetime
 
@@ -116,13 +116,13 @@ def process_markdown_file(
                 prov_found = True
                 result = process_provenance_command(file_path, block)
             elif potential_command in ["Create Glossary", "Update Glossary"]:
-                result = process_glossary_upsert_command(client, element_dictionary, block, directive)
+                result = process_glossary_upsert_command(client, block, directive)
             elif potential_command in ["Create Category", "Update Category"]:
-                result = process_categories_upsert_command(client, element_dictionary, block, directive)
+                result = process_category_upsert_command(client, block, directive)
             elif potential_command in ["Create Term", "Update Term"]:
-                result = process_term_upsert_command(client, element_dictionary, block, directive)
+                result = process_term_upsert_command(client, block, directive)
             elif potential_command in ["Create Personal Project", "Update Personal Project"]:
-                result = process_per_proj_upsert_command(client, element_dictionary, block, directive)
+                result = process_per_proj_upsert_command(client, block, directive)
             else:
                 # If command is not recognized, copy the block as-is
                 result = None

pyegeria/commands/cat/dr_egeria_jupyter.py

@@ -79,14 +79,12 @@ def process_jupyter_notebook(
                         potential_command = extract_command(cell.source)
                         if potential_command in command_list:
                             if potential_command in ["Create Glossary", "Update Glossary"]:
-                                result = process_glossary_upsert_command(client, element_dictionary,
-                                                                         cell.source, directive)
+                                result = process_glossary_upsert_command(client, cell.source, directive)
 
                             elif potential_command in ["Create Term", "Update Term"]:
-                                result = process_term_upsert_command(client, element_dictionary,
-                                                                     cell.source, directive)
+                                result = process_term_upsert_command(client, cell.source, directive)
                             elif potential_command in ["Create Personal Project", "Update Personal Project"]:
-                                result = process_per_proj_upsert_command(client, element_dictionary, cell.source, directive)
+                                result = process_per_proj_upsert_command(client, cell.source, directive)
                             else:
                                 # If command is not recognized, copy the block as-is
                                 result = None

pyegeria/commands/cat/dr_egeria_md.py

@@ -9,8 +9,8 @@ from rich import print
 from rich.console import Console
 
 from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
-                      process_categories_upsert_command, process_provenance_command,
-                      process_set_categories_parent_command, get_current_datetime_string,
+                      process_category_upsert_command, process_provenance_command,
+                      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)
@@ -86,39 +86,31 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
                 prov_found = True
 
             elif potential_command in ["Create Glossary", "Update Glossary"]:
-                result = process_glossary_upsert_command(client, dr_egeria_state.get_element_dictionary(),
-                                                         current_block, directive)
+                result = process_glossary_upsert_command(client, current_block, directive)
             elif potential_command in ["Create Category", "Update Category"]:
-                result = process_categories_upsert_command(client, dr_egeria_state.get_element_dictionary(),
-                                                           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)
+                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, dr_egeria_state.get_element_dictionary(), current_block,
-                                                     directive)
+                result = process_term_upsert_command(client, current_block, directive)
             elif potential_command in ["List Term History", "Term History"]:
-                result = process_term_history_command(client, dr_egeria_state.get_element_dictionary(), current_block,
-                                                 directive)
+                result = process_term_history_command(client, current_block, directive)
             elif potential_command in ["List Terms", "List Glossary Terms"]:
-                result = process_term_list_command(client, dr_egeria_state.get_element_dictionary(), current_block,
-                                                     directive)
+                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)
+                                                       directive)
             elif potential_command in ["List Glossaries"]:
                 result = process_glossary_list_command(client, dr_egeria_state.get_element_dictionary(), current_block,
-                                                     directive)
+                                                       directive)
             elif potential_command in ["Create Personal Project", "Update Personal Project"]:
-                result = process_per_proj_upsert_command(client, dr_egeria_state.get_element_dictionary(),
-                                                         current_block, directive)
+                result = process_per_proj_upsert_command(client, current_block, directive)
             elif potential_command in ["Create Blueprint", "Update Blueprint", "Create Solution Blueprint",
                                        "Update Solution Blueprint"]:
-                result = process_blueprint_upsert_command(client, dr_egeria_state.get_element_dictionary(),
-                                                          current_block, directive)
+                result = process_blueprint_upsert_command(client, current_block, directive)
             elif potential_command in ["Create Solution Component", "Update Solution Component"]:
-                result = process_solution_component_upsert_command(client, dr_egeria_state.get_element_dictionary(),
-                                                                   current_block, directive)
+                result = process_solution_component_upsert_command(client, current_block, directive)
 
 
             else:

pyegeria/commands/cat/list_categories.py

@@ -136,7 +136,7 @@ def display_categories(
                 classification_props = category["elementHeader"]['classifications'][0].get('classificationProperties',None)
                 glossary_qualified_name = '---'
                 if classification_props is not None:
-                    glossary_guid = classification_props.get('anchorGUID','---')
+                    glossary_guid = classification_props.get('anchorScopeGUID','---')
                     glossary_qualified_name = (
                         m_client.get_glossary_by_guid(glossary_guid))['glossaryProperties']['qualifiedName']
                 cat_info = m_client.get_category_parent(category_guid)

pyegeria/commands/cat/list_terms.py

@@ -187,23 +187,23 @@ def display_glossary_terms(
             q_name = Text(
                 f"{qualified_name}\n&\n{term_guid}", style=style, justify="center"
             )
-            abbrev = Text(props.get("abbreviation", " "), style=style, justify="center")
-            summary = Text(props.get("summary", " "), style=style)
-            description = Markdown(props.get("description"))
+            abbrev = Text(props.get("abbreviation", "---"), style=style, justify="center")
+            summary = Text(props.get("summary", "---"), style=style)
+            description = Markdown(props.get("description",'---'))
             version = Text(
-                props.get("publishVersionIdentifier", " "),
+                props.get("publishVersionIdentifier", "---"),
                 style=style,
                 justify="center",
             )
-            example = props.get("example", " ")
-            usage = props.get("usage", " ")
+            example = props.get("example", "---")
+            usage = props.get("usage", "---")
             ex_us_out = Markdown(f"Example:\n{example}\n---\nUsage: \n{usage}")
 
             classifications = term["elementHeader"]["classifications"]
             glossary_guid = None
             for c in classifications:
                 if c["classificationName"] == "Anchors":
-                    glossary_guid = c["classificationProperties"]["anchorGUID"]
+                    glossary_guid = c["classificationProperties"]["anchorScopeGUID"]
 
             if glossary_guid and glossary_guid in glossary_info:
                 glossary_name = glossary_info[glossary_guid]

pyegeria/glossary_browser_omvs.py

@@ -847,16 +847,21 @@ class GlossaryBrowser(Client):
         # Get parent category
         parent_cat_md = self._get_parent_category_name(category_guid, output_format)
 
-        # Get subcategories
-        _, subcategory_list_md = self._get_subcategories_list(category_guid, output_format)
-
         # Get glossary information
         glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
-        return {
-            'in_glossary': glossary_qualified_name, 'parent_category': parent_cat_md,
-            'subcategories': subcategory_list_md
-            }
+        # Only include subcategories if output_format is not FORM, REPORT, or MD
+        if output_format not in ['FORM', 'REPORT', 'MD']:
+            # Get subcategories
+            _, subcategory_list_md = self._get_subcategories_list(category_guid, output_format)
+            return {
+                'in_glossary': glossary_qualified_name, 'parent_category': parent_cat_md,
+                'subcategories': subcategory_list_md
+                }
+        else:
+            return {
+                'in_glossary': glossary_qualified_name, 'parent_category': parent_cat_md
+                }
 
     def _generate_category_md(self, elements: list, elements_action: str, output_format: str) -> str:
         """
@@ -1528,6 +1533,7 @@ class GlossaryBrowser(Client):
 
         return response.json().get("elementList", "No categories found")
 
+
     def get_glossary_subcategories(self, glossary_category_guid: str, effective_time: str = None, start_from: int = 0,
             page_size: int = max_paging_size, for_lineage: bool = False,
             for_duplicate_processing: bool = False, ) -> dict | str:
@@ -1979,8 +1985,8 @@ class GlossaryBrowser(Client):
             self._async_get_categories_by_name(name, glossary_guid, status, start_from, page_size))
         return response
 
-    async def _async_get_categories_by_guid(self, glossary_category_guid: str, effective_time: str = None,
-            output_format: str = 'JSON', ) -> list | str:
+    async def _async_get_category_by_guid(self, glossary_category_guid: str, effective_time: str = None,
+                                          output_format: str = 'JSON', ) -> list | str:
         """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
 
@@ -2035,8 +2041,8 @@ class GlossaryBrowser(Client):
             return self.generate_categories_md(element, "GUID", output_format)
         return response.json().get("element", NO_CATEGORIES_FOUND)
 
-    def get_categories_by_guid(self, glossary_category_guid: str, effective_time: str = None,
-            output_format: str = 'JSON', ) -> list | str:
+    def get_category_by_guid(self, glossary_category_guid: str, effective_time: str = None,
+                             output_format: str = 'JSON', ) -> list | str:
         """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
 
@@ -2074,7 +2080,7 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_guid(glossary_category_guid, effective_time, output_format))
+            self._async_get_category_by_guid(glossary_category_guid, effective_time, output_format))
         return response
 
     async def _async_get_category_parent(self, glossary_category_guid: str, effective_time: str = None, ) -> list | str:
@@ -2849,7 +2855,7 @@ class GlossaryBrowser(Client):
         """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid, output_format))
+        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, output_format))
 
         return response
 

pyegeria/md_processing_utils.py

@@ -9,7 +9,7 @@ import os
 import re
 import sys
 from datetime import datetime
-from typing import List, Optional
+from typing import List, Optional, Any
 
 from rich import print
 from rich.console import Console
@@ -31,8 +31,8 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "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", "Set Parent Category",
-                "UnSet Parent Category", "Unset Parent Category"]
+                "Create Solution Component", "Update Solution Component", "Update Category Structure",
+                ]
 # verbosity - verbose, quiet, debug
 debug_level = "debug"
 message_types = {
@@ -45,12 +45,13 @@ INFO = "INFO"
 WARNING = "WARNING"
 pre_command = "\n---\n==> Processing command:"
 command_seperator = Markdown("\n---\n")
+EXISTS_REQUIRED = "Exists Required"
 
 GLOSSARY_NAME_LABELS = ["Glossary Name", "Glossary", "Glossaries", "Owning Glossary", "In Glossary"]
 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 Category Name", "Child Category", "child category name", "child category"]
+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",
@@ -219,7 +220,7 @@ def extract_command(block: str) -> str | None:
     return None
 
 
-def extract_attribute(text: str, labels: [str]) -> str | None:
+def extract_attribute(text: str, labels: list[str]) -> str | None:
     """
         Extracts the attribute value from a string.
 
@@ -228,7 +229,7 @@ def extract_attribute(text: str, labels: [str]) -> str | None:
             labels: List of equivalent labels to search for
 
         Returns:
-            The glossary name, or None if not found.
+            The value of the attribute, or None if not found.
 
         Note:
             Lines beginning with '>' are ignored.
@@ -251,6 +252,8 @@ def extract_attribute(text: str, labels: [str]) -> str | None:
             if not extracted_text.isspace() and extracted_text:
                 return extracted_text  # Return the cleaned text - I removed the title casing
 
+    return None
+
 
 def print_msg(msg_level: str, msg: str, verbosity: str):
     """
@@ -375,14 +378,14 @@ def process_provenance_command(file_path: str, txt: [str]) -> str:
     return f"\n# Provenance:\n{existing_prov}\n{output}\n"
 
 
-def process_element_identifiers(egeria_client: EgeriaTech, element_type: str, element_labels: [str], txt: str,
+def process_element_identifiers(egeria_client: EgeriaTech, element_type: str, element_labels: list[str], txt: str,
                                 action: str, version: str = None) -> tuple[str, str, bool, bool]:
     """
     Processes element identifiers by extracting display name and qualified name from the input text,
     checking if the element exists in Egeria, and validating the information.
 
-    Parameters:
-        element_labels:
+    Parameters
+    ----------
     egeria_client: EgeriaTech
         Client object for interacting with Egeria.
     element_type: str
@@ -441,7 +444,7 @@ def process_element_identifiers(egeria_client: EgeriaTech, element_type: str, el
             update_element_dictionary(q_name, {'display_name': element_name})
         elif qualified_name:
             update_element_dictionary(qualified_name, {'display_name': element_name})
-    elif action == "Exists Required":
+    elif action == EXISTS_REQUIRED:
         if not exists:
             msg = f"Required {element_type} `{element_name}` does not exist"
             print_msg("DEBUG-ERROR", msg, debug_level)
@@ -537,10 +540,10 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
     # method_name} not found on client"
 
 
-def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str, element_labels: [str]) -> tuple[
-    str | None, list | None, bool, bool]:
+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 qualified names specified in the given text, retrieves details for each
+    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.
 
     The function reads a text block, extracts a list of element names according to the specified
@@ -552,8 +555,8 @@ def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str,
 
         egeria_client (EgeriaTech): The client instance to connect and query elements from an
             external system.
-        element_type (str): The type of element, such as schema or attribute, to process.
-        txt (str): The raw input text containing element names to be processed.
+        Element_type (str): The type of element, such as schema or attribute, to process.
+        Txt (str): The raw input text containing element names to be processed.
         element_labels: a list of equivalent label names to use in processing the element.
 
     Returns:
@@ -604,8 +607,7 @@ def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str,
         return elements, new_element_list, valid, exists
 
 
-def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                     directive: str = "display") -> Optional[str]:
+def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a blueprint create or update command by extracting key attributes such as
     blueprint name, description, and version from the given cell.
@@ -676,11 +678,11 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
                 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_terms_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_terms_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":
@@ -699,7 +701,7 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
                     print_msg("ALWAYS", msg, debug_level)
 
                     update_element_dictionary(q_name, {'guid': new_guid, 'display_name': display_name})
-                    return 'Would return get blueprint by guid results as md'  # egeria_client.get_terms_by_guid(  #
+                    return 'Would return get blueprint by guid results as md'  # egeria_client.get_term_by_guid(  #
                     # term_guid, 'MD')
 
         except Exception as e:
@@ -709,8 +711,7 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
             return None
 
 
-def process_solution_component_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, 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.
@@ -756,9 +757,9 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
     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_q_name_list(egeria_client,
+        solution_blueprints, bp_qname_list, bp_valid, bp_exist = process_name_list(egeria_client,
                                                                                      'Solution Blueprints', txt,
-                                                                                     BLUEPRINT_NAME_LABELS)
+                                                                                   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)
@@ -769,7 +770,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
         msg = f"Parent Components are missing"
         print_msg("INFO", msg, debug_level)
     else:
-        parent_components, parent_qname_list, parents_valid, parent_components_exist = process_q_name_list(
+        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}"
@@ -844,10 +845,10 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                 print_msg("ALWAYS", msg, debug_level)
                 # update with get solution component by guid
                 return 'Would return get Solution Component by guid and return md'  #  #
-                # egeria_client.get_terms_by_guid(known_guid, '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_terms_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 +867,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                     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'  #  #
-                    # egeria_client.get_terms_by_guid(term_guid, 'MD')
+                    # egeria_client.get_term_by_guid(term_guid, 'MD')
 
         except Exception as e:
             msg = f"Error creating term {display_name}: {e}"
@@ -875,8 +876,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
             return None
 
 
-def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                    directive: str = "display") -> Optional[str]:
+def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a glossary create or update command by extracting key attributes such as
     glossary name, language, description, and usage from the given text.
@@ -886,13 +886,11 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
     :param directive: an optional string indicating the directive to be used - display, validate or execute
     :return: A string summarizing the outcome of the processing.
     """
-    # command = extract_command(txt)
-    # object_type = command.split(' ')[1].strip()
-    # object_action = command.split(' ')[0].strip()
+
     command, object_type, object_action = extract_command_plus(txt)
     set_debug_level(directive)
 
-    glossary_name = process_simple_attribute(txt, ['Glossary Name', 'Display Name'])
+    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS)
     print(Markdown(
         f"{pre_command} `{object_action}` `{object_type}`  for glossary: `\'{glossary_name}\'` with directive: `"
         f"{directive}` "))
@@ -903,7 +901,9 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
 
     if glossary_name is None:
         valid = False
-        known_q_name, known_guid, glossary_exists = None
+        known_q_name = None
+        known_guid = None
+        glossary_exists = False
     else:
         element_labels = GLOSSARY_NAME_LABELS
         element_labels.append('Display Name')
@@ -998,8 +998,7 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
                 return egeria_client.get_glossary_by_guid(glossary_guid, output_format='MD')
 
 
-def process_categories_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                      directive: str = "display") -> Optional[str]:
+def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a glossary category create or update command by extracting key attributes such as
     category name, qualified, description, and anchor glossary from the given txt..
@@ -1011,9 +1010,7 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
     """
     valid = True
     set_debug_level(directive)
-    # command = extract_command(txt)
-    # object_type = command.split(' ')[1].strip()
-    # object_action = command.split(' ')[0].strip()
+
     command, object_type, object_action = extract_command_plus(txt)
 
     category_name = process_simple_attribute(txt, ['Category Name', 'category_name', 'Cat'])
@@ -1023,6 +1020,9 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
     description = process_simple_attribute(txt, ['Description'])
     q_name = process_simple_attribute(txt, ['Qualified Name'])
 
+    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,21 +1036,32 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
                                                                                        element_labels, txt,
                                                                                        object_action, None)
 
+
     # Check if owning glossary exists (and get qname)
     if owning_glossary_name is None:
         valid = False
         known_glossary_q_name, known_glossary__guid, glossary_exists = None
+
     else:
         known_glossary_q_name, known_glossary_guid, valid, owning_glossary_exists = process_element_identifiers(
-            egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, "Exists Required", None)
+            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)
+    else:
+        parent_guid = None
+        parent_exists = False
+        parent_valid = False
 
     category_display = (
         f"\n* Command: {command}\n\t* Category: {category_name}\n\t* In Glossary: {owning_glossary_name}\n\t"
-        f"* Description:\n{description}\n\t* Qualified Name: {q_name}\n\t")
+        f"* Description:\n{description}\n\t* Parent Category: {parent_category_name}\n\t"
+        f"* Qualified Name: {q_name}\n\t")
 
     if object_action == 'Update':
         guid = process_simple_attribute(txt, ['GUID', 'guid', 'Guid'])
-        # update_description = process_simple_attribute(txt, 'Update Description')
+
         category_display += (f"* GUID: {guid}\n\n")
         if not category_exists:
             msg = f"Category {category_name} can't be updated; {category_name} not found."
@@ -1097,14 +1108,22 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
                       f"command\n")
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
 
+            # Update the basic category properties
             egeria_client.update_category(known_guid, category_name, description, known_q_name, None)
             msg = f"->Updated category `{category_name}`with GUID {known_guid}"
             print_msg(ALWAYS, msg, debug_level)
+
+            # Update parent-child relationships
+
             update_element_dictionary(known_q_name, {
                 'guid': known_guid, 'display_name': category_name
                 })
             print_msg(ALWAYS, f"Updated Category `{category_name}` with GUID {known_guid}", debug_level)
-            return egeria_client.get_categories_by_guid(known_guid, output_format='FORM')
+
+            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":
             is_root = True
@@ -1116,7 +1135,7 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
             else:
                 category_guid = egeria_client.create_category(known_glossary_guid, category_name, description, is_root)
-                category_details = egeria_client.get_categories_by_guid(category_guid)
+                category_details = egeria_client.get_category_by_guid(category_guid)
 
                 if category_details == NO_CATEGORIES_FOUND:
                     msg = f"Just created category with GUID {category_guid} but category not found"
@@ -1128,121 +1147,98 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
                     'guid': category_guid, 'display_name': category_name
                     })
                 print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
-                return egeria_client.get_categories_by_guid(category_guid, output_format='DR')
+                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)
+                else:
+                    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
 
 
-def process_set_categories_parent_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                          directive: str = "display") -> Optional[str]:
+def update_category_parent(egeria_client, category_guid: str, parent_category_name: str = None) -> bool:
     """
-    Processes a set_parent_category command by extracting key attributes such as
-    parent and child category names from the given text.
+    Updates the parent relationship for a category.
 
-    :param txt: A string representing the input cell to be processed for
-        extracting category-related attributes.
-    :param directive: an optional string indicating the directive to be used - display, validate or execute
-    :return: A string summarizing the outcome of the processing.
-    """
-    valid = True
-    set_debug_level(directive)
+    If a parent category is specified, it will check if a parent is currently set.
+    If a parent category was set and is the same as the parent category specified, no change is needed.
+    If a parent category was set and is different from the parent_category_name, the parent category is updated.
+    If parent_category_name is None or empty and an existing parent category was set, the parent category is removed.
 
-    command, object_type, object_action = extract_command_plus(txt)
-
-    parent_category_name = process_simple_attribute(txt, PARENT_CATEGORY_LABELS, "ERROR")
-    child_category_name = process_simple_attribute(txt, CHILD_CATEGORY_LABELS, "ERROR")
-    print(Markdown(f"{pre_command} `{command}` for parent category: `\'{parent_category_name}\'` \n\t"
-                   f"and child category: `\'{child_category_name}\'` \nwith directive: `{directive}` "))
+    Parameters
+    ----------
+    egeria_client: EgeriaTech
+        The Egeria client to use for API calls
+    category_guid: str
+        The GUID of the category to update
+    parent_category_name: str, optional
+        The name of the parent category to set, or None to remove the parent
 
-    if parent_category_name is None or child_category_name is None:
-        valid = False
-    else:
-        parent_cat_q_name, parent_cat_guid, parent_cat_valid, parent_cat_exists = (
-            get_element_by_name(egeria_client, 'Glossary Categories', parent_category_name))
-        child_cat_q_name, child_cat_guid, child_cat_valid, child_cat_exists = (
-            get_element_by_name(egeria_client, 'Glossary Categories', child_category_name))
+    Returns
+    -------
 
-    # Check if category exists (and get qname and guid)
+    True if successful, False otherwise.
 
-    if parent_cat_exists and child_cat_exists:
-        valid = True
-        msg = f" Both categories {parent_category_name} and {child_category_name} exist\n"
-        print_msg(INFO, msg, debug_level)
-        if parent_cat_guid and child_cat_guid:
-            msg = f" Both categories {parent_category_name} and {child_category_name} have GUIDs\n"
-            print_msg(INFO, msg, debug_level)
+    """
+    outcome = True
+    # Handle parent category updates
+    if parent_category_name:
+        # Check if a parent is currently set
+        current_parent = egeria_client.get_category_parent(category_guid)
+
+        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)
+
+            if parent_exists and parent_guid:
+                egeria_client.set_parent_category(parent_guid, category_guid)
+                print_msg(ALWAYS, f"Set parent category of category to `{parent_category_name}`", debug_level)
+            else:
+                print_msg(ERROR, f"Parent category `{parent_category_name}` not found", debug_level)
+                outcome = False
         else:
-            msg = f" Both categories {parent_category_name} and {child_category_name} do not have GUIDs\n"
-            print_msg(ERROR, msg, debug_level)
-            valid = False
+            # Parent is set, check if it's the same
+            current_parent_name = current_parent.get('glossaryCategoryProperties', {}).get('qualifiedName', '')
+
+            if current_parent_name != parent_category_name:
+                # Different parent, need to update
+                # First remove the current parent
+                current_parent_guid = current_parent.get('elementHeader', {}).get('guid', '')
+                if current_parent_guid:
+                    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)
+
+                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)
+                else:
+                    print_msg(ERROR, f"Parent category `{parent_category_name}` not found", debug_level)
+                    outcome = False
+    elif parent_category_name is None or parent_category_name == '':
+        # Check if a parent is currently set and remove it if needed
+        current_parent = egeria_client.get_category_parent(category_guid)
 
+        if not isinstance(current_parent, str) or "No Parent Category found" not in current_parent:
+            # Parent is set, need to remove it
+            current_parent_guid = current_parent.get('elementHeader', {}).get('guid', '')
+            current_parent_name = current_parent.get('glossaryCategoryProperties', {}).get('qualifiedName', '')
 
-    else:
-        valid = False
-        msg = f"Both categories {parent_category_name} and {child_category_name} do NOT exist\n"
-        print_msg(ERROR, msg, debug_level)
-
-    category_display = (f"\n* Command: {command}\n\t* Parent Category: {parent_category_name}\n\t\t"
-                        f"* Qualified Name: {parent_cat_q_name}\n\t\t* GUID: {parent_cat_guid}\n\t"
-                        f"* Child Category:\n{child_category_name}\n\t\t* Qualified Name: {child_cat_q_name}\n\t\t"
-                        f"* GUID: {child_cat_guid}\n")
-
-    # if object_action == 'Remove Parent Category':
-    #     parent_guid = process_simple_attribute(txt, ['GUID', 'guid', 'Guid'])
-    #
-    #     category_display += (f"* GUID: {guid}\n\n")
-    #     if not category_exists:
-    #         msg = f"Category {category_name} can't be updated; {category_name} not found."
-    #         print_msg(ERROR, msg, debug_level)
-    #         valid = False
-    #     else:
-    #         msg = f"Glossary can be updated; {category_name} found"
-    #         print_msg(ALWAYS, msg, debug_level)
-    #
-    # elif object_action == "Create":
-    #     if category_exists:
-    #         msg = f"Category {category_name} can't be created because it already exists.\n"
-    #         print_msg("ERROR", msg, debug_level)
-    #         valid = False
-    #     elif valid:
-    #         msg = f"It is valid to create Category `{category_name}` with:\n"
-    #         print_msg("ALWAYS", msg, debug_level)
+            if current_parent_guid:
+                egeria_client.remove_parent_category(current_parent_guid, category_guid)
+                print_msg(ALWAYS, f"Removed parent category `{current_parent_name}`", debug_level)
+
+
+    return outcome
 
-    if directive == "display":
-        print(Markdown(category_display))
-        return None
 
-    elif directive == "validate":
-        if valid:
-            print(Markdown(category_display))
-        else:
-            msg = f"Validation failed for {object_type} `{parent_category_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(category_display))
-        return valid
 
-    elif directive == "process":
-        if valid:
-            print(Markdown(category_display))
-        else:
-            msg = f"* --> Validation failed for {object_type} `{parent_category_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(category_display))
-            return None
 
-        if object_action in ["Set", "Set Parent"]:
-            egeria_client.set_parent_category(parent_cat_guid, child_cat_guid)
-            print_msg(ALWAYS, f"Set parent category of `{child_category_name}` to `{parent_category_name}`",
-                      debug_level)
-            output_txt = txt.replace("Set Parent", "UnSet Parent")
-            return output_txt
-
-        elif object_action in ["UnSet", "UnSet Parent", "Unset Parent", "Unset", "Remove Parent"]:
-            egeria_client.remove_parent_category(parent_cat_guid, child_cat_guid)
-            print_msg(ALWAYS, f"UnSet parent category `{child_category_name}` from {parent_category_name}", debug_level)
-            output_txt = txt.replace("UnSet Parent", "Set Parent")
-            return output_txt
-
-def process_term_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+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
@@ -1296,7 +1292,7 @@ def process_term_list_command(egeria_client: EgeriaTech, element_dictionary: dic
             return None
 
 def process_category_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+                                  directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
@@ -1349,7 +1345,7 @@ def process_category_list_command(egeria_client: EgeriaTech, element_dictionary:
             return None
 
 def process_glossary_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+                                  directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
@@ -1391,8 +1387,7 @@ def process_glossary_list_command(egeria_client: EgeriaTech, element_dictionary:
             console.print_exception(show_locals=True)
             return None
 
-def process_term_history_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+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. """
     set_debug_level(directive)
     valid = True
@@ -1439,8 +1434,7 @@ def process_term_history_command(egeria_client: EgeriaTech, element_dictionary:
 
 
 
-def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a term create or update command by extracting key attributes such as
     term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
@@ -1492,16 +1486,16 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
         glossary_exists = False
     else:
         known_glossary_q_name, known_glossary_guid, glossary_valid, glossary_exists = process_element_identifiers(
-            egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, "Exists Required", None)
+            egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, EXISTS_REQUIRED, None)
 
     # process categories, if present
     categories = process_simple_attribute(txt, ['Glossary Categories', 'Glossary Category', 'Category', 'Categories'])
     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_q_name_list(egeria_client,
+        categories_list, cat_q_name_list, cat_valid, cat_exist = process_name_list(egeria_client,
                                                                                      'Glossary Categories', txt,
-                                                                                     CATEGORY_NAME_LABELS)
+                                                                                   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)
@@ -1566,11 +1560,11 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                 print_msg(ALWAYS,
                           f"\tUpdated Term `{term_name}` with GUID {known_guid}\n\tand categories `{categories}`",
                           debug_level)
-                return egeria_client.get_terms_by_guid(known_guid,
+                return egeria_client.get_term_by_guid(known_guid,
                                                        '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_terms_by_guid(known_guid, 'md')
+                return egeria_client.get_term_by_guid(known_guid, 'md')
 
             elif object_action == "Create":
                 if term_exists:
@@ -1622,8 +1616,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
             return None
 
 
-def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dictionary: dict, txt: str,
-                                    directive: str = "display") -> str | None:
+def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
     """
     Processes a personal project create or update command by extracting key attributes such as
     glossary name, language, description, and usage from the given cell.

pyegeria/md_processing_utils_orig.py

@@ -629,7 +629,7 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                 'guid': known_guid, 'display_name': category_name
                 }
             # return update_a_command(txt, command, object_type, known_q_name, known_guid)
-            return egeria_client.get_categories_by_guid(known_guid, output_format='FORM')
+            return egeria_client.get_category_by_guid(known_guid, output_format='FORM')
 
         elif object_action == "Create":
             is_root = False
@@ -639,7 +639,7 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
             else:
                 category_guid = egeria_client.create_category(glossary_guid, category_name, description, is_root)
-                category = egeria_client.get_categories_by_guid(category_guid)
+                category = egeria_client.get_category_by_guid(category_guid)
 
                 if category == NO_CATEGORIES_FOUND:
                     print(f"{ERROR}Just created with GUID {category_guid} but category not found\n")
@@ -649,7 +649,7 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                     'guid': category_guid, 'display_name': category_name
                     }
                 # return update_a_command(txt, command, object_type, qualified_name, category_guid)
-                return egeria_client.get_categories_by_guid(category_guid, output_format='MD')
+                return egeria_client.get_category_by_guid(category_guid, output_format='MD')
 
 
 def process_term_upsert_command(egeria_client: GlossaryManager, element_dictionary: dict, txt: str,

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

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

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

@@ -1,5 +1,5 @@
 pyegeria/README.md,sha256=PwX5OC7-YSZUCIsoyHh1O-WBM2hE84sm3Bd4O353NOk,1464
-pyegeria/__init__.py,sha256=bBbo9UZL2e2MdAu7mrKPZ1tDzXojJbw43gkeOcrO3Lg,30609
+pyegeria/__init__.py,sha256=4226Kaq5Xf439GRkRu6ckhzSSJ8L30EbdZocdLfcBwE,30568
 pyegeria/_client.py,sha256=lCWq8XJOFg3MnEO4ulMVuCJrW3uU4eWUCcbLEd90_LU,34673
 pyegeria/_deprecated_gov_engine.py,sha256=dWNcwVsE5__dF2u4QiIyQrssozzzOjBbLld8MdpmVCQ,17264
 pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
@@ -11,12 +11,12 @@ pyegeria/classification_manager_omvs.py,sha256=n55-62Mby-_5pxPGaz3nkjM9NWlY4PzSl
 pyegeria/collection_manager_omvs.py,sha256=xNuF3Ki6Rg-TehdbFGS8exSOUXpkQ3X63__OdXuCkc8,101746
 pyegeria/commands/README.md,sha256=hJdOWhZ5eCfwTkY4Tx6De6Y1XVo7cbaddQEvjqppvls,2036
 pyegeria/commands/__init__.py,sha256=R2o66ctVicTZ8B5VSPtc7EDRKNiNclzFbYX0o2Zg2dQ,1120
-pyegeria/commands/cat/Dr-Egeria_md-orig.py,sha256=fwhDZ36MAaiyvlBALX68HmHUJNgOWLMNVUgcyjs-yGM,7667
+pyegeria/commands/cat/Dr-Egeria_md-orig.py,sha256=M88fR52MYKUDSNmGKaJ12lO3PC-gKuNIswBOtR4eimk,7584
 pyegeria/commands/cat/README.md,sha256=-aaAnIT2fcfU63vajgB-RzQk4l4yFdhkyVfSaTPiqRY,967
 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=U-3m9BMoCXj2fvuawr3PTc2HQWAXThqQ3sIXjyCWv6s,5912
-pyegeria/commands/cat/dr_egeria_md.py,sha256=7Sx64F9mlgBzgKLPXYwReKJDHOJAFxNICVQ3Ttb90DQ,12189
+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/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
@@ -25,7 +25,7 @@ pyegeria/commands/cat/get_project_structure.py,sha256=5uxWMqNve592OT73GRCO2KoBkg
 pyegeria/commands/cat/get_tech_type_elements.py,sha256=IznytHXwDOFriGM6mypV9wuEeM-vT2s66cUzf-IROog,6147
 pyegeria/commands/cat/glossary_actions.py,sha256=zK26fNiv-lpWUP8tHC3wTmdQ6L0_XxlmuNGUyrnSclc,19606
 pyegeria/commands/cat/list_assets.py,sha256=CdJ2coKvvQv2VwJO0Sp9Eg9Fu_uvpC21tgjrdtT9Yz4,6315
-pyegeria/commands/cat/list_categories.py,sha256=3IhRSpklyhcR5NZ7qkrxVavgd5nGJawy4fo_4-m1UZs,7896
+pyegeria/commands/cat/list_categories.py,sha256=Csdrb59oqu77GBDfjZvnEc1B-nqVGb36BrUbY9XvOXg,7901
 pyegeria/commands/cat/list_cert_types.py,sha256=HmrTks0SSYgSMsYz3LqfX5kwDQ6D9KMcynoR_xlWtnE,7137
 pyegeria/commands/cat/list_collections.py,sha256=kCxl5OuBAGtctHNVmttOe4aJ6r37cGdCFnK1i7A90ls,5996
 pyegeria/commands/cat/list_deployed_catalogs.py,sha256=VdN6R9kRVWX-fGIgubOigvMVPzhF-hKQepHHlS-w-D8,8258
@@ -36,7 +36,7 @@ pyegeria/commands/cat/list_glossaries.py,sha256=D2ovkffSmnO-NQ7y-Jw0aDBtK2j06CQz
 pyegeria/commands/cat/list_projects.py,sha256=NzWTuepTGUEyxK-eWvuUxtBgCtNWubVwmz2eqm2UN1c,7997
 pyegeria/commands/cat/list_tech_type_elements.py,sha256=-9omj5en9dSP1xMSljYVHyfXsuhuE1bO2IFj_bZPhAs,6873
 pyegeria/commands/cat/list_tech_types.py,sha256=uqZcXHCzAznhEG6WWeM5j-spwUh8ycygFqpVDeXOG-0,4653
-pyegeria/commands/cat/list_terms.py,sha256=BLz98FXUl2FUDhSw5G44jETtxAAP_p0AIpd0-yO7a0w,12164
+pyegeria/commands/cat/list_terms.py,sha256=HPZ_S_5EwJezdgf8UY1dZiDbN5P9aD88pI_rBHftm1M,12185
 pyegeria/commands/cat/list_todos.py,sha256=NitCw0uyVVjmN1hxb1W-I4FbOsa8wQxW2ICyOElHyc8,6556
 pyegeria/commands/cat/list_user_ids.py,sha256=X5Q-YNEp38saPYDuy9VwdQC5Qpa4HyC3WvAdbyp_P6M,5108
 pyegeria/commands/cli/__init__.py,sha256=hpTVSMP2gnPRhcAZPdeUEsQ-eaDySlXlk239dNWYmng,292
@@ -226,12 +226,12 @@ 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=SztYpk4O-wBhRopz12q2s04xmnkfYDeeDe6jPdp_BOQ,153037
+pyegeria/glossary_browser_omvs.py,sha256=k0VfD9sB5CEf27cLxqpMheO5Rn5LcitcsQfKNEx4jbY,153382
 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=ekExZifDL6sKda81QaiP-RyWwk1yKRRQqwV8o7zv3vk,84207
-pyegeria/md_processing_utils_orig.py,sha256=WGoVpsV03wwgv9YwDDHZ0EO4-opN8BdoISt4ZhkYGuQ,52492
+pyegeria/md_processing_utils.py,sha256=8TjD_ffnTMLEZEkb2npnZy59glboWFkaRh0OK_YN9cw,83314
+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
 pyegeria/my_profile_omvs.py,sha256=d0oJYCJG7pS9BINPuGciVa00ac0jwPHNANXDCLginEc,34720
@@ -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.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.3.8.5.dist-info/METADATA,sha256=O6XwOakIP5DOc2RfVaUAuocL13Ebq5WChGS8RnU3ftU,2740
-pyegeria-5.3.8.5.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyegeria-5.3.8.5.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
-pyegeria-5.3.8.5.dist-info/RECORD,,
+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,,