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

pyegeria/md_processing_utils.py

@@ -4,20 +4,19 @@ This file contains functions to parse and process Egeria Markdown (Freddie)
 
 
 """
-
+import json
 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
 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", "Set Parent Category",
-                "UnSet Parent Category", "Unset Parent Category"]
+                "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 = {
@@ -45,12 +43,14 @@ 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",
@@ -64,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."""
@@ -151,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.
@@ -219,7 +224,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 +233,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 +256,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):
     """
@@ -288,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.
@@ -375,14 +382,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 +448,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)
@@ -528,19 +535,19 @@ 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_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 +559,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 +611,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 +682,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_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":
@@ -709,8 +715,8 @@ 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 +762,8 @@ 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', 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)
@@ -769,8 +774,8 @@ 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(
-            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)
@@ -843,11 +848,11 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                 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":
@@ -865,7 +870,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                     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:
@@ -875,8 +880,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 +890,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 +905,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')
@@ -960,9 +964,8 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
 
         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,10 +999,13 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
                 # 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_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 +1017,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 +1027,8 @@ 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)
@@ -1040,17 +1046,27 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
     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 +1113,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 +1140,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,151 +1152,129 @@ 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]:
-    """
-    Processes a set_parent_category command by extracting key attributes such as
-    parent and child category names from the given text.
 
-    :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.
+def update_category_parent(egeria_client, category_guid: str, parent_category_name: str = None) -> bool:
     """
-    valid = True
-    set_debug_level(directive)
+    Updates the parent relationship for a category.
 
-    command, object_type, object_action = extract_command_plus(txt)
+    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.
 
-    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_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"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_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)
+                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)
 
-    if directive == "display":
-        print(Markdown(category_display))
-        return None
+    return outcome
 
-    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
     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))
@@ -1286,47 +1288,49 @@ def process_term_list_command(egeria_client: EgeriaTech, element_dictionary: dic
             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))
@@ -1339,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:
 
-def process_glossary_list_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+        return None
+
+
+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")
+
+    _, 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 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}`"))
+    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)
@@ -1382,17 +1452,25 @@ 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, 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
@@ -1404,16 +1482,20 @@ def process_term_history_command(egeria_client: EgeriaTech, element_dictionary:
     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)
@@ -1427,20 +1509,79 @@ def process_term_history_command(egeria_client: EgeriaTech, element_dictionary:
             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, 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 +1633,15 @@ 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,
-                                                                                     '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)
@@ -1567,7 +1707,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                           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')
@@ -1614,7 +1754,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                     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}")
@@ -1622,8 +1762,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.