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

md_processing/md_commands/glossary_commands.py

@@ -6,11 +6,24 @@ import json
 import os
 import re
 from typing import List, Optional
-
+from loguru import logger
 from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
 
+from md_processing.md_processing_utils.common_md_proc_utils import (parse_upsert_command, parse_view_command,
+                                                                    sync_collection_memberships)
+from md_processing.md_processing_utils.common_md_utils import update_element_dictionary, setup_log, set_update_body, \
+    set_element_status_request_body, set_prop_body, set_delete_request_body, set_rel_request_body, set_peer_gov_def_request_body, \
+    set_rel_request_body, set_create_body, set_collection_classifications, set_product_body
+
+from md_processing.md_processing_utils.extraction_utils import (extract_command_plus, update_a_command)
+from md_processing.md_processing_utils.md_processing_constants import (load_commands, ERROR)
+from pyegeria import DEBUG_LEVEL, body_slimmer, to_pascal_case, PyegeriaException, print_basic_exception, print_exception_table
+from pyegeria.egeria_tech_client import EgeriaTech
+
+
+
 from md_processing.md_processing_utils.common_md_utils import (debug_level, print_msg, set_debug_level,
                                                                get_element_dictionary, update_element_dictionary,
                                                                setup_log)
@@ -28,8 +41,8 @@ from pyegeria import body_slimmer
 from pyegeria._globals import (NO_GLOSSARIES_FOUND, NO_ELEMENTS_FOUND, NO_CATEGORIES_FOUND)
 from pyegeria.egeria_tech_client import EgeriaTech
 
-EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
-console = Console(width=EGERIA_WIDTH)
+# EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
+# console = Console(width=EGERIA_WIDTH)
 setup_log()
 
 def update_term_categories(egeria_client: EgeriaTech, term_guid: str, categories_exist: bool,
@@ -109,369 +122,364 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
 
     command, object_type, object_action = extract_command_plus(txt)
     print(Markdown(f"# {command}\n"))
-    set_debug_level(directive)
-
-    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, ERROR)
-    print(Markdown(
-        f"{pre_command} `{object_action}` `{object_type}`  for glossary: `\'{glossary_name}\'` with directive: `"
-        f"{directive}` "))
-    language = process_simple_attribute(txt, ['Language'], INFO)
-    description = process_simple_attribute(txt, ['Description'], INFO)
-    usage = process_simple_attribute(txt, ['Usage'], INFO)
-    q_name = process_simple_attribute(txt, ['Qualified Name'], INFO)
-    valid = True
-
-    if glossary_name is None:
-        valid = False
-        known_q_name = None
-        known_guid = None
-        glossary_exists = False
-    else:
-        element_labels = GLOSSARY_NAME_LABELS
-        element_labels.append('Display Name')
-        known_q_name, known_guid, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                       element_labels, txt,
-                                                                                       object_action, None)
-    glossary_display = (f"\n* Command: `{command}`\n\t* Glossary Name: {glossary_name}\n\t"
-                        f"* Language: {language}\n\t* Description:\n{description}\n"
-                        f"* Usage: {usage}\n")
-
-    if object_action == 'Update':
-        guid = process_simple_attribute(txt, ['GUID', 'guid', 'Guid'])
-        glossary_display += f"* Qualified Name: `{q_name}`\n\t* GUID: {guid}\n\n"
-        if not glossary_exists:
-            msg = f"Glossary can't be updated; `{glossary_name}` not found"
-            print_msg("ERROR", msg, debug_level)
-            valid = False
-        else:
-            msg = f"Glossary can be updated; `{glossary_name}` found"
-            print_msg(ALWAYS, msg, debug_level)
-
-
-    elif object_action == "Create":
-        if glossary_exists:
-            msg = f"Glossary `{glossary_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 Glossary `{glossary_name}` with:\n"
-            print_msg("ALWAYS", msg, debug_level)
-
-    if directive == "display":
-        print(Markdown(glossary_display))
-        return None
-
-    elif directive == "validate":
-        if valid:
-            print(Markdown(glossary_display))
-        else:
-            msg = f"Validation failed for Glossary `{glossary_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(glossary_display))
-
-        return valid
 
-    elif directive == "process":
-        if valid:
-            print(Markdown(glossary_display))
-        else:
-            if glossary_exists and object_action == "Create":
-                msg = (f"Create failed because glossary `{glossary_name}` exists - changing `Create` to `Update` in "
-                       f"processed output \n")
-                print_msg(ERROR, msg, debug_level)
-                print(Markdown(glossary_display))
-                print(command_seperator)
-                return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
-            else:
-                return None
-        if object_action == "Update":
-            if not glossary_exists:
-                print(f"\n{ERROR}Glossary `{glossary_name}` does not exist! Updating result document with Create "
-                      f"object_action\n")
-                return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
-
-            body = {
-                "class": "ReferenceableRequestBody", "elementProperties": {
-                    "class": "GlossaryProperties", "qualifiedName": known_q_name, "description": description,
-                    "language": language, "usage": usage
-                    }
-                }
-            egeria_client.update_glossary(known_guid, body)
-            print_msg(ALWAYS, f"Updated Glossary `{glossary_name}` with GUID {known_guid}", debug_level)
-            update_element_dictionary(known_q_name, {
-                'guid': known_guid, 'display_name': glossary_name
-                })
-            return egeria_client.get_glossary_by_guid(known_guid, output_format='MD')
-        elif object_action == "Create":
-            glossary_guid = None
-
-            if glossary_exists:
-                print(f"\nGlossary `{glossary_name}` already exists and result document updated\n")
-                return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
-            else:
-                glossary_guid = egeria_client.create_glossary(glossary_name, description, language, usage)
-                glossary = egeria_client.get_glossary_by_guid(glossary_guid)
-                if glossary == NO_GLOSSARIES_FOUND:
-                    print(f"{ERROR}Just created with GUID {glossary_guid} but Glossary not found\n")
-                    return None
-                qualified_name = glossary['glossaryProperties']["qualifiedName"]
-                update_element_dictionary(qualified_name, {
-                    'guid': glossary_guid, 'display_name': glossary_name
-                    })
-                # return update_a_command(txt, object_action, 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='FORM')
-        else:
-            return None
-    else:
+    parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
+    if not parsed_output:
+        logger.error(f"No output for `{object_action}`")
         return None
 
+    valid = parsed_output['valid']
+    exists = parsed_output['exists']
 
-def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a glossary category create or update object_action by extracting key attributes such as
-    category name, qualified, description, and anchor glossary from the given txt..
-
-    :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)
-
-    command, object_type, object_action = extract_command_plus(txt)
-    print(Markdown(f"# {command}\n"))
-
-    category_name = process_simple_attribute(txt, ['Category Name', 'category_name', 'Cat'])
-    print(Markdown(f"{pre_command} `{command}` for category: `\'{category_name}\'` with directive: `{directive}` "))
-
-    owning_glossary_name = extract_attribute(txt, ['Owning Glossary', 'In Glossary'])
-    description = process_simple_attribute(txt, ['Description'])
-    q_name = process_simple_attribute(txt, ['Qualified Name'])
+    qualified_name = parsed_output.get('qualified_name', None)
+    guid = parsed_output.get('guid', None)
 
-    parent_category_name = process_simple_attribute(txt, PARENT_CATEGORY_LABELS, "INFO")
+    print(Markdown(parsed_output['display']))
 
-    element_labels = CATEGORY_NAME_LABELS
-    element_labels.append('Display Name')
-    # Check if category exists (and get qname and guid)
-    if category_name is None:
-        valid = False
-        known_q_name, known_guid, category_exists = None
-    else:
-        element_labels = CATEGORY_NAME_LABELS
-        element_labels.append('Display Name')
-        known_q_name, known_guid, valid, category_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                       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
+    logger.debug(json.dumps(parsed_output, indent=4))
 
-    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)
+    attributes = parsed_output['attributes']
 
-    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* 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'])
-
-        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)
+    display_name = attributes['Display Name'].get('value', None)
+    status = attributes.get('Status', {}).get('value', None)
+    #
 
     if directive == "display":
-        print(Markdown(category_display))
         return None
-
     elif directive == "validate":
         if valid:
-            print(Markdown(category_display))
+            print(Markdown(f"==> Validation of {command} completed successfully!\n"))
         else:
-            msg = f"Validation failed for {object_type} `{category_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(category_display))
+            msg = f"Validation failed for object_action `{command}`\n"
         return valid
 
     elif directive == "process":
-        if valid:
-            print(Markdown(category_display))
-        else:
-            if category_exists and object_action == "Create":
-                msg = (f"Create failed because category `{category_name}` exists - changing `Create` to `Update` in "
-                       f"processed output \n")
-                print_msg(ERROR, msg, debug_level)
-                print(Markdown(category_display))
-                return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
-            else:
-                return None
-
-        if object_action == "Update":
-            if not category_exists:
-                print(f"\n{ERROR}category `{category_name}` does not exist! Updating result document with Create "
-                      f"object_action\n")
-                return update_a_command(txt, object_action, 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
-                })
-
-            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
-
-            if category_exists:
-                msg = (f"Cannot create`{category_name}` because it already exists; result document written for "
-                       f"category update\n")
-                print_msg(WARNING, msg, debug_level)
-                return update_a_command(txt, object_action, 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_category_by_guid(category_guid)
-
-                if category_details == NO_CATEGORIES_FOUND:
-                    msg = f"Just created category with GUID {category_guid} but category not found"
-                    print_msg(ERROR, msg, debug_level)
+        try:
+            obj = "Glossary"
+            #   Set the property body for a glossary collection
+            #
+            prop_body = set_prop_body(obj, qualified_name, attributes)
+            prop_body["languager"] = attributes.get('Language', {}).get('value', None)
+            prop_body["usage"] = attributes.get('Usage', {}).get('value', None)
+
+            if object_action == "Update":
+                if not exists:
+                    msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
+                           f"{object_action}\n")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+                elif not valid:
                     return None
-
-                qualified_name = category_details['glossaryCategoryProperties']["qualifiedName"]
-                update_element_dictionary(qualified_name, {
-                    'guid': category_guid, 'display_name': category_name
-                    })
-                print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
-                if parent_valid and parent_guid:
-                    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
+                    print(Markdown(
+                        f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
 
-def update_category_parent(egeria_client, category_guid: str, parent_category_name: str = None) -> bool:
-    """
-    Updates the parent relationship for a category.
+                body = set_update_body(obj, attributes)
+                body['properties'] = prop_body
 
-    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.
+                egeria_client.update_collection(guid, body)
+                if status:
+                    egeria_client.update_collection_status(guid, status)
 
-    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
+                logger.success(f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___")
+                update_element_dictionary(qualified_name, {
+                    'guid': guid, 'display_name': display_name
+                    })
+                return egeria_client.get_collection_by_guid(guid, element_type='Glossary',
+                                                            output_format='MD', output_format_set = "DrE-Glossary")
 
-    Returns
-    -------
 
-    True if successful, False otherwise.
+            elif object_action == "Create":
+                if valid is False and exists:
+                    msg = (f"  Digital Product `{display_name}` already exists and result document updated changing "
+                           f"`Create` to `Update` in processed output\n\n___")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
 
-    """
-    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:
-            # 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)
+                    body = set_create_body(object_type,attributes)
+
+                    # if this is a root or folder (maybe more in the future), then make sure that the classification is set.
+                    body["initialClassifications"] = set_collection_classifications(object_type, attributes, ["Taxonomy", "CanonicalVocabulary"])
+                    if object_type == "Taxonomy":
+                        body["initialClassifications"]['Taxonomy']['organizingPrinciple'] = attributes.get('Organizing Principle', {}).get('value', None)
+                    elif object_type == "CanonicalVocabulary":
+                        body["initialClassifications"]['CanonicalVocabulary']['usage'] = attributes.get('Usage', {}).get('value', None)
+
+                    body["properties"] = prop_body
+
+                    guid = egeria_client.create_collection(body = body)
+                    if guid:
+                        update_element_dictionary(qualified_name, {
+                            'guid': guid, 'display_name': display_name
+                            })
+                        msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
+                        logger.success(msg)
+                        return egeria_client.get_collection_by_guid(guid, obj, output_format='MD')
+                    else:
+                        msg = f"Failed to create element `{display_name}` with GUID {guid}\n\n___"
+                        logger.error(msg)
+                        return None
 
-        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', '')
+        except PyegeriaException as e:
+            logger.error(f"Pyegeria error performing {command}: {e}")
+            print_basic_exception(e)
+            return None
+        except Exception as e:
+            logger.error(f"Error performing {command}: {e}")
+    else:
+        return None
 
-            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
+def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
+#     """
+#     Processes a glossary category create or update object_action by extracting key attributes such as
+#     category name, qualified, description, and anchor glossary from the given txt..
+#
+#     :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)
+#
+#     command, object_type, object_action = extract_command_plus(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     category_name = process_simple_attribute(txt, ['Category Name', 'category_name', 'Cat'])
+#     print(Markdown(f"{pre_command} `{command}` for category: `\'{category_name}\'` with directive: `{directive}` "))
+#
+#     owning_glossary_name = extract_attribute(txt, ['Owning Glossary', 'In Glossary'])
+#     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)
+#     if category_name is None:
+#         valid = False
+#         known_q_name, known_guid, category_exists = None
+#     else:
+#         element_labels = CATEGORY_NAME_LABELS
+#         element_labels.append('Display Name')
+#         known_q_name, known_guid, valid, category_exists = process_element_identifiers(egeria_client, object_type,
+#                                                                                        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)
+#
+#     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* 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'])
+#
+#         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 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} `{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:
+#             if category_exists and object_action == "Create":
+#                 msg = (f"Create failed because category `{category_name}` exists - changing `Create` to `Update` in "
+#                        f"processed output \n")
+#                 print_msg(ERROR, msg, debug_level)
+#                 print(Markdown(category_display))
+#                 return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
+#             else:
+#                 return None
+#
+#         if object_action == "Update":
+#             if not category_exists:
+#                 print(f"\n{ERROR}category `{category_name}` does not exist! Updating result document with Create "
+#                       f"object_action\n")
+#                 return update_a_command(txt, object_action, 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
+#                 })
+#
+#             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
+#
+#             if category_exists:
+#                 msg = (f"Cannot create`{category_name}` because it already exists; result document written for "
+#                        f"category update\n")
+#                 print_msg(WARNING, msg, debug_level)
+#                 return update_a_command(txt, object_action, 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_category_by_guid(category_guid)
+#
+#                 if category_details == NO_CATEGORIES_FOUND:
+#                     msg = f"Just created category with GUID {category_guid} but category not found"
+#                     print_msg(ERROR, msg, debug_level)
+#                     return None
+#
+#                 qualified_name = category_details['glossaryCategoryProperties']["qualifiedName"]
+#                 update_element_dictionary(qualified_name, {
+#                     'guid': category_guid, 'display_name': category_name
+#                     })
+#                 print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
+#                 if parent_valid and parent_guid:
+#                     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 update_category_parent(egeria_client, category_guid: str, parent_category_name: str = None) -> bool:
+    pass
+#     """
+#     Updates the parent relationship for a category.
+#
+#     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.
+#
+#     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
+#
+#     Returns
+#     -------
+#
+#     True if successful, False otherwise.
+#
+#     """
+#     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:
+#             # 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', '')
+#
+#             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
 
 
 def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
     """
     Processes a term create or update object_action by extracting key attributes such as
     term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
@@ -481,651 +489,580 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
     :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
-    categories_list = None
-    cats_exist = False
-    set_debug_level(directive)
-    known_q_name = None
-    command = extract_command(txt)
-    print(Markdown(f"# {command}\n"))
-
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-
-    term_name = process_simple_attribute(txt, ['Term Name', 'Display Name'], ERROR)
-    print(Markdown(f"{pre_command} `{command}` for term:`{term_name}` with directive: `{directive}`"))
-    summary = process_simple_attribute(txt, ['Summary'], INFO)
-    description = process_simple_attribute(txt, ['Description'], INFO)
-    abbreviation = process_simple_attribute(txt, ['Abbreviation'], INFO)
-    examples = process_simple_attribute(txt, ['Examples'], INFO)
-    usage = process_simple_attribute(txt, ['Usage'], INFO)
-    status = process_simple_attribute(txt, ['Status'])
-    status = status.upper() if status else 'DRAFT'
-    version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"], INFO)
-    q_name = process_simple_attribute(txt, ['Qualified Name'], INFO)
-
-    aliases = process_simple_attribute(txt, ['Aliases', 'Alias'], INFO)
-    if aliases:
-        alias_list = list(filter(None, re.split(r'[,\n]+', aliases.strip())))
-    else:
-        alias_list = None
-
-    # validate term name and get existing qualified_name and guid if they exist
-    if term_name is None:
-        valid = False
-        known_q_name, known_guid, term_exists = None
-    else:
-        element_labels = TERM_NAME_LABELS
-        element_labels.append('Display Name')
-        known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                   element_labels, txt, object_action,
-                                                                                   version)
-
-    # get the glossary qualified name this term is in
-    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, ERROR)
-    if glossary_name is None:
-        valid = False
-        known_glossary_guid = None
-        known_glossary_q_name = None
-        glossary_valid = False
-        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)
-        if not glossary_exists or known_glossary_guid is None:
-            glossary_valid = False
-            valid = False
-
-    # 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, cats_valid, cats_exist = process_name_list(egeria_client,
-                                                                                     'Glossary Categories', txt,
-                                                                                     CATEGORY_NAME_LABELS)
-        if cats_exist and cats_valid:
-            msg = f"Found valid glossary categories to classify the term:\n\t{term_name}"
-            print_msg("INFO", msg, debug_level)
-        else:
-            msg = "No valid glossary categories found."
-            print_msg("INFO", msg, debug_level)
-    else:
-        cats_exist = cats_valid = False
-        cat_q_name_list = None
-
-    if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
-        term_guid = process_simple_attribute(txt, GUID_LABELS)
-        update_description = process_simple_attribute(txt, ['Update Description'])
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {known_glossary_q_name}\n\t"
-                        f"* Term Name: {term_name}\n\t* Qualified Name: {q_name}\n\t* Aliases: {aliases}\n\t"
-                        f"* Categories: {categories}\n\t"
-                        f"* Summary: {summary}\n\t* Description: {description}\n\t"
-                        f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
-                        f"* Version: {version}\n\t* Status: {status}\n\t* GUID: {term_guid}"
-                        f"\n\t* Update Description: {update_description}\n")
-        if not term_exists:
-            msg = f"Update request invalid, Term {term_name} does not exist\n"
-            print_msg(ERROR, msg, debug_level)
-            valid = False
-
-    elif object_action == 'Create':  # if the object_action is create, check that it doesn't already exist
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {known_glossary_q_name}\n\t"
-                        f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}\n\t"
-                        f"* Qualified Name: {q_name}\n\t* Aliases: {aliases}\n\t* Description: {description}\n\t"
-                        f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
-                        f"* Version: {version}\n\t* Status: {status}\n")
-        if term_exists:
-            msg = f"Term `{term_name}` cannot be created since it already exists\n"
-            print_msg(ERROR, msg, debug_level)
-        else:
-            msg = f"It is valid to create Term `{term_name}`"
-            print_msg(ALWAYS, msg, debug_level)
-
-    if directive == "display":
-        print(Markdown(term_display))
-        return None
-    elif directive == "validate":
-        print(Markdown(term_display))
-        return valid
-    elif directive == "process":
-        try:
-            if not valid:  # First validate the term before we process it
-                if term_exists and object_action == "Create":
-                    msg = (f"Create failed because term `{term_name}` exists - changing `Create` to `Update` in "
-                           f"processed output \n")
-                    print_msg(ERROR, msg, debug_level)
-                    print(Markdown(term_display))
-                    return update_a_command(txt, object_action, object_type, known_q_name, known_guid)
-                else:
-                    return None
-
-            print(Markdown(term_display))
-            if object_action == "Update" and directive == "process":
-                if not term_exists:
-                    return None
-                body = {
-                    "class": "ReferenceableRequestBody", "elementProperties": {
-                        "displayName": term_name, "class": "GlossaryTermProperties", "qualifiedName": known_q_name,
-                        "aliases": alias_list, "summary": summary, "description": description,
-                        "abbreviation": abbreviation, "examples": examples, "usage": usage,
-                        "publishVersionIdentifier": version, "status": status
-                        }, "updateDescription": update_description
-                    }
-                egeria_client.update_term(known_guid, body_slimmer(body), is_merge_update=False)
-                # if cat_exist and cat_valid:
-                update_term_categories(egeria_client, known_guid, cats_exist, cat_q_name_list)
-                print_msg(ALWAYS,
-                          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, object_action, 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')
-
-            elif object_action == "Create":
-                if term_exists:
-                    msg = f"Term {term_name} exists so result document modifies term create to term update"
-                    print_msg(INFO, msg, debug_level)
-                    return update_a_command(txt, object_action, object_type, q_name, known_guid)
-                else:
-                    ## get the guid for the glossary from the name - first look in cache
-                    cached = get_element_dictionary().get(known_glossary_q_name, None)
-
-                    if cached is not None:
-                        glossary_guid = cached.get('guid', None)
-                        if glossary_guid is None:
-                            msg = f"Glossary GUID for {known_glossary_q_name} not found in cache"
-                            print_msg(WARNING, msg, debug_level)  # should this ever occur?
-                            return None
-                    else:
-                        glossary_guid = egeria_client.__get_guid__(qualified_name=known_glossary_q_name)
-                        if glossary_guid == NO_ELEMENTS_FOUND:
-                            msg = f"Glossary {known_glossary_q_name} not found"
-                            print_msg(WARNING, msg, debug_level)
-                            return None
-                    term_body = {
-                        "class": "ReferenceableRequestBody", "elementProperties": {
-                            "class": "GlossaryTermProperties", "qualifiedName": known_q_name, "displayName": term_name,
-                            "aliases": alias_list, "summary": summary, "description": description,
-                            "abbreviation": abbreviation, "examples": examples, "usage": usage,
-                            "publishVersionIdentifier": version
-                            # "additionalProperties":
-                            #     {
-                            #         "propertyName1": "xxxx",
-                            #         "propertyName2": "xxxx"
-                            #         }
-                            }, "initialStatus": status
-                        }
-                    term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, body_slimmer(term_body))
-                    if term_guid == NO_ELEMENTS_FOUND:
-                        print(f"{ERROR}Term {term_name} not created")
-                        return None
-                    if cats_exist and categories is not None:
-                        update_term_categories(egeria_client, term_guid, cats_exist, cat_q_name_list)
-                    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, object_action,
-                    # object_type, q_name, term_guid)
-        except Exception as e:
-            print(f"{ERROR}Error creating term {term_name}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None
-
 
-def process_create_term_term_relationship_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> \
-Optional[str]:
-    """ Relate two terms through the specified relationship. ."""
-    set_debug_level(directive)
-    valid = True
-    command = extract_command(txt)
+    command, object_type, object_action = extract_command_plus(txt)
     print(Markdown(f"# {command}\n"))
 
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-    term1_guid = None
-    term2_guid = None
-
-    term_relationship = process_simple_attribute(txt, ["Term Relationship", "Relationship Type"], "ERROR")
-    if term_relationship not in TERM_RELATIONSHPS:
-        valid = False
-
-    print(Markdown(
-        f"{pre_command} `{command}` for term relationship: `{term_relationship}` with directive: `{directive}` "))
-
-    term1_q_name, term1_guid, term1_valid, term1_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                      ["Term 1 Name", "Term 1"], txt,
-                                                                                      "Exists Required", None)
-
-    term2_q_name, term2_guid, term2_valid, term2_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                      ["Term 2 Name", "Term 2"], txt,
-                                                                                      "Exists Required", None)
-
-    request_display = (f"\n\t* Term 1 Qualified Name: {term1_q_name}\n\t* Term 2 Qualified Name {term2_q_name}\n\t"
-                       f"* Term Relationship: {term_relationship}")
-
-    if not (term1_valid and term2_valid and term1_exists and term2_exists):
-        valid = False
-
-    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
-            egeria_client.add_relationship_between_terms(term1_guid, term2_guid, term_relationship)
-            print_msg(ALWAYS, f"Relationship `{term_relationship}` created", debug_level)
-            update_md = (f"\n\n# Update Term-Term Relationship\n\n## Term 1 Name:\n\n{term1_q_name}"
-                         f"\n\n## Term 2 Name\n\n{term2_q_name}\n\n## Term Relationship:\n\n{term_relationship}")
-            return update_md
-
-
-        except Exception as e:
-            print(f"{ERROR}Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
+    parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
+    if not parsed_output:
+        logger.error(f"No output for `{object_action}`")
         return None
 
+    valid = parsed_output['valid']
+    exists = parsed_output['exists']
 
-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)
-    print(Markdown(f"# {command}\n"))
+    qualified_name = parsed_output.get('qualified_name', None)
+    guid = parsed_output.get('guid', None)
 
-    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}`"))
+    print(Markdown(parsed_output['display']))
 
-    glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary', "Glossary Name"])
-    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)
+    logger.debug(json.dumps(parsed_output, indent=4))
 
-    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)
+    attributes = parsed_output['attributes']
 
-    request_display = (f"\n\t* Search String: {search_string}\n\t* Glossary: {glossary}\n\t* Output Format: "
-                       f"{output_format}\n")
+    display_name = attributes['Display Name'].get('value', None)
+    status = attributes.get('Status', {}).get('value', None)
+    merge_update = attributes.get('Merge Update', {}).get('value', True)
+    #
 
     if directive == "display":
-        print(Markdown(request_display))
         return None
     elif directive == "validate":
-        print(Markdown(request_display))
+        if valid:
+            print(Markdown(f"==> Validation of {command} completed successfully!\n"))
+        else:
+            msg = f"Validation failed for object_action `{command}`\n"
         return valid
-    elif directive == "process":
-        try:
-            print(Markdown(request_display))
-            if not valid:  # First validate the term before we process it
-                return None
-
-            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 performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None
-
-
-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)
-    print(Markdown(f"# {command}\n"))
 
-    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}`"))
-
-    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\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
-
-    if directive == "display":
-        print(Markdown(request_display))
-        return None
-    elif directive == "validate":
-        print(Markdown(request_display))
-        return valid
     elif directive == "process":
         try:
-            print(Markdown(request_display))
-            if not valid:  # First validate the term before we process it
-                return None
-
-            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 performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-
-        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)
-    print(Markdown(f"# {command}\n"))
-
-    known_glossary_guid = ""
-
-    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"
+            obj = "GlossaryTerm"
+            #   Set the property body for a glossary collection
+            #
+            prop_body = set_prop_body(obj, qualified_name, attributes)
+            prop_body["aliases"] = attributes.get('Aliases', {}).get('value', None)
+            prop_body["summary"] = attributes.get('Summary', {}).get('value', None)
+            prop_body["examples"] = attributes.get('Examples', {}).get('value', None)
+            prop_body["abbreviation"] = attributes.get('Abbreviation', {}).get('value', None)
+            prop_body["usage"] = attributes.get('Usage', {}).get('value', None)
+            prop_body["user_defined_status"] = attributes.get('UserDefinedStatus', {}).get('value', None)
+            to_be_collection_guids = [attributes.get("Glossary", {}).get("guid_list", {}),
+                                      attributes.get("Folder", {}).get("guid_list", {})]
+            get_method = egeria_client.get_term_by_guid
+            collection_types = ["Glossary", "Folder"]
+
+            if object_action == "Update":
+                if not exists:
+                    msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
+                           f"{object_action}\n")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+                elif not valid:
+                    return None
+                else:
+                    print(Markdown(
+                        f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
+
+                body = set_update_body(obj, attributes)
+                body['properties'] = prop_body
+
+                egeria_client.update_glossary_term(guid, body)
+                if status:
+                    egeria_client.update_term_status(guid, status)
+                get_method = egeria_client.get_term_by_guid
+                collection_types = ["Glossary", "Folder"]
+                to_be_collection_guids = [attributes.get("Glossary",{}).get("guid_list",{}), attributes.get("Folder",{}).get("guid_list",{})]
+                sync_collection_memberships(egeria_client, guid, get_method,  collection_types,
+                                            to_be_collection_guids, merge_update)
+                logger.success(f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___")
+                update_element_dictionary(qualified_name, {
+                    'guid': guid, 'display_name': display_name
+                    })
+                return egeria_client.get_term_by_guid(guid, element_type='GlossaryTerm',
+                                                            output_format='MD', output_format_set="DrE-Term")
 
-    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)
+            elif object_action == "Create":
+                if valid is False and exists:
+                    msg = (f"  Digital Product `{display_name}` already exists and result document updated changing "
+                           f"`Create` to `Update` in processed output\n\n___")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
 
-            return glossary_structure_md
+                else:
+                    body = set_create_body(obj,attributes)
+
+                    # if this is a root or folder (maybe more in the future), then make sure that the classification is set.
+
+                    body["properties"] = prop_body
+
+                    guid = egeria_client.create_glossary_term(body = body)
+                    if guid:
+                        sync_collection_memberships(egeria_client, guid, get_method,
+                                                    collection_types, to_be_collection_guids, True)
+                        update_element_dictionary(qualified_name, {
+                            'guid': guid, 'display_name': display_name
+                            })
+                        msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
+                        logger.success(msg)
+                        return egeria_client.get_collection_by_guid(guid, obj, output_format='MD')
+                    else:
+                        msg = f"Failed to create element `{display_name}` with GUID {guid}\n\n___"
+                        logger.error(msg)
+                        return None
 
-        except Exception as e:
-            print(f"{ERROR}Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
+        except PyegeriaException as e:
+            logger.error(f"Pyegeria error performing {command}: {e}")
+            print_basic_exception(e)
             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)
-    print(Markdown(f"# {command}\n"))
-
-    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\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
-
-    if directive == "display":
-        print(request_display)
-        return None
-    elif directive == "validate":
-        print(request_display)
-        return valid
-    elif directive == "process":
-        try:
-            print(request_display)
-            if not valid:  # First validate the term before we process it
-                return None
-
-            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 glossary_list_md
-
         except Exception as e:
-            print(f"{ERROR}Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
+            logger.error(f"Error performing {command}: {e}")
     else:
         return None
+def process_create_term_term_relationship_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
+#     """ Relate two terms through the specified relationship. ."""
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     object_type = command.split(' ')[1].strip()
+#     object_action = command.split(' ')[0].strip()
+#     term1_guid = None
+#     term2_guid = None
+#
+#     term_relationship = process_simple_attribute(txt, ["Term Relationship", "Relationship Type"], "ERROR")
+#     if term_relationship not in TERM_RELATIONSHPS:
+#         valid = False
+#
+#     print(Markdown(
+#         f"{pre_command} `{command}` for term relationship: `{term_relationship}` with directive: `{directive}` "))
+#
+#     term1_q_name, term1_guid, term1_valid, term1_exists = process_element_identifiers(egeria_client, object_type,
+#                                                                                       ["Term 1 Name", "Term 1"], txt,
+#                                                                                       "Exists Required", None)
+#
+#     term2_q_name, term2_guid, term2_valid, term2_exists = process_element_identifiers(egeria_client, object_type,
+#                                                                                       ["Term 2 Name", "Term 2"], txt,
+#                                                                                       "Exists Required", None)
+#
+#     request_display = (f"\n\t* Term 1 Qualified Name: {term1_q_name}\n\t* Term 2 Qualified Name {term2_q_name}\n\t"
+#                        f"* Term Relationship: {term_relationship}")
+#
+#     if not (term1_valid and term2_valid and term1_exists and term2_exists):
+#         valid = False
+#
+#     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
+#             egeria_client.add_relationship_between_terms(term1_guid, term2_guid, term_relationship)
+#             print_msg(ALWAYS, f"Relationship `{term_relationship}` created", debug_level)
+#             update_md = (f"\n\n# Update Term-Term Relationship\n\n## Term 1 Name:\n\n{term1_q_name}"
+#                          f"\n\n## Term 2 Name\n\n{term2_q_name}\n\n## Term Relationship:\n\n{term_relationship}")
+#             return update_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_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     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', "Glossary Name"])
+#     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)
+#     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\t* Search String: {search_string}\n\t* Glossary: {glossary}\n\t* Output Format: "
+#                        f"{output_format}\n")
+#
+#     if directive == "display":
+#         print(Markdown(request_display))
+#         return None
+#     elif directive == "validate":
+#         print(Markdown(request_display))
+#         return valid
+#     elif directive == "process":
+#         try:
+#             print(Markdown(request_display))
+#             if not valid:  # First validate the term before we process it
+#                 return None
+#
+#             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 performing {command}: {e}")
+#             console.print_exception(show_locals=True)
+#             return None
+#     else:
+#         return None
+#
+#
+def process_category_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     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}`"))
+#
+#     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\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
+#
+#     if directive == "display":
+#         print(Markdown(request_display))
+#         return None
+#     elif directive == "validate":
+#         print(Markdown(request_display))
+#         return valid
+#     elif directive == "process":
+#         try:
+#             print(Markdown(request_display))
+#             if not valid:  # First validate the term before we process it
+#                 return None
+#
+#             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 performing {command}: {e}")
+#             console.print_exception(show_locals=True)
+#             return None
+#     else:
+#
+#         return None
+#
+#
+def process_glossary_structure_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     known_glossary_guid = ""
+#
+#     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]:
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#
+#     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\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
+#
+#     if directive == "display":
+#         print(request_display)
+#         return None
+#     elif directive == "validate":
+#         print(request_display)
+#         return valid
+#     elif directive == "process":
+#         try:
+#             print(request_display)
+#             if not valid:  # First validate the term before we process it
+#                 return None
+#
+#             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 glossary_list_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_details_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)
-    print(Markdown(f"# {command}\n"))
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-
-    term_identifier = process_simple_attribute(txt, TERM_NAME_LABELS, "ERROR")
-
-    print(Markdown(f"{pre_command} `{command}` for term:`{term_identifier}` with directive: `{directive}`"))
-
-    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
-    if output_format is None:
-        output_format = "REPORT"
-    else:
-        output_format = output_format.upper()
-
-    if output_format not in ["DICT", "REPORT"]:
-        valid = False
-        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
-
-    request_display = f"\n\t* Term Identifier: {term_identifier}\n\t* Output Format {output_format}"
-
-    if directive == "display":
-        print(request_display)
-        return None
-    elif directive == "validate":
-        print(request_display)
-        return valid
-    elif directive == "process":
-        try:
-            print(request_display)
-            if not valid:  # First validate the term before we process it
-                return None
-            output = egeria_client.get_term_details(term_identifier, output_format=output_format)
-            if output_format == "DICT":
-                output = f"```{json.dumps(output, indent=4)}```"
-            print_msg("ALWAYS", f"Wrote Term Details for term: `{term_identifier}`", debug_level)
-
-            return output
-
-        except Exception as e:
-            print(f"{ERROR}Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None
-
-
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#     object_type = command.split(' ')[1].strip()
+#     object_action = command.split(' ')[0].strip()
+#
+#     term_identifier = process_simple_attribute(txt, TERM_NAME_LABELS, "ERROR")
+#
+#     print(Markdown(f"{pre_command} `{command}` for term:`{term_identifier}` with directive: `{directive}`"))
+#
+#     output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+#     if output_format is None:
+#         output_format = "REPORT"
+#     else:
+#         output_format = output_format.upper()
+#
+#     if output_format not in ["DICT", "REPORT"]:
+#         valid = False
+#         print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
+#
+#     request_display = f"\n\t* Term Identifier: {term_identifier}\n\t* Output Format {output_format}"
+#
+#     if directive == "display":
+#         print(request_display)
+#         return None
+#     elif directive == "validate":
+#         print(request_display)
+#         return valid
+#     elif directive == "process":
+#         try:
+#             print(request_display)
+#             if not valid:  # First validate the term before we process it
+#                 return None
+#             output = egeria_client.get_term_details(term_identifier, output_format=output_format)
+#             if output_format == "DICT":
+#                 output = f"```{json.dumps(output, indent=4)}```"
+#             print_msg("ALWAYS", f"Wrote Term Details for term: `{term_identifier}`", debug_level)
+#
+#             return output
+#
+#         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_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
-    command = extract_command(txt)
-    print(Markdown(f"# {command}\n"))
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-
-    element_labels = TERM_NAME_LABELS
-    element_labels.append('Display Name')
-
-    term_name = process_simple_attribute(txt, element_labels, "ERROR")
-
-    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
-                                                                               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* Output Format {output_format}\n\t* GUID: {known_guid}\n"
-
-    if directive == "display":
-        print(request_display)
-        return None
-    elif directive == "validate":
-        print(request_display)
-        return 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 History for `{term_name}`\n\n"
-            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 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)
-    print(Markdown(f"# {command}\n"))
-    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
+    pass
+#     """ List terms as a markdown table. Filter based on optional search string. """
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#     object_type = command.split(' ')[1].strip()
+#     object_action = command.split(' ')[0].strip()
+#
+#     element_labels = TERM_NAME_LABELS
+#     element_labels.append('Display Name')
+#
+#     term_name = process_simple_attribute(txt, element_labels, "ERROR")
+#
+#     known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
+#                                                                                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* Output Format {output_format}\n\t* GUID: {known_guid}\n"
+#
+#     if directive == "display":
+#         print(request_display)
+#         return None
+#     elif directive == "validate":
+#         print(request_display)
+#         return 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 History for `{term_name}`\n\n"
+#             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 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]:
+    pass
+#     """ List term revision history as a markdown table or list."""
+#     set_debug_level(directive)
+#     valid = True
+#     command = extract_command(txt)
+#     print(Markdown(f"# {command}\n"))
+#     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