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

pyegeria/md_processing_utils.py

@@ -30,7 +30,7 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "List Glossary Structure", "List Glossaries", "List Categories", "List Glossary Categories",
                 "Create Personal Project", "Update Personal Project", "Create Category", "Update Category",
                 "Create Solution Blueprint", "Update Solution Blueprint", "Create Solution Component",
-                "Update Solution Component", ]
+                "Update Solution Component", "Create Term-Term Relationship", "Update Term-Term Relationship",]
 # verbosity - verbose, quiet, debug
 debug_level = "debug"
 message_types = {
@@ -69,7 +69,19 @@ SEARCH_LABELS = ['Search String', 'Filter']
 GUID_LABELS = ['GUID', 'guid']
 
 ELEMENT_OUTPUT_FORMATS = ["LIST", "DICT", "MD", "FORM", "REPORT"]
-
+TERM_RELATIONSHPS = [
+    "Synonym",
+    "Translation",
+    "PreferredTerm",
+    "TermISATYPEOFRelationship",
+    "TermTYPEDBYRelationship",
+    "Antonym",
+    "ReplacementTerm",
+    "ValidValue",
+    "TermHASARelationship",
+    "RelatedTerm",
+    "ISARelationship"
+]
 
 def render_markdown(markdown_text: str) -> None:
     """Renders the given markdown text in the console."""
@@ -535,8 +547,8 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
     unique = True
     return el_qname, el_guid, unique, exists
 
-    # Convert element_type to plural form for method name construction  # if element_type.endswith('y'):  #  #  #
-    # plural_type = f"{element_type[:-1]}ies"  # elif element_type.endswith('s'):  #     plural_type = f"{  #  #
+    # Convert element_type to plural form for method name construction  # if element_type.endswith('y'):  #  #  #  #
+    # plural_type = f"{element_type[:-1]}ies"  # elif element_type.endswith('s'):  #     plural_type = f"{  #  #  #
     # element_type}es"  # else:  #     plural_type = f"{element_type}s"  #  # # Construct method name  # method_name
     # = f"get_{plural_type}_by_name"  #  # # Check if the method exists on the client  # if hasattr(egeria_client,
     # method_name):  #     # Call the method  #     method = getattr(egeria_client, method_name)  #     result =  #
@@ -682,11 +694,11 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                 print_msg("ALWAYS", msg, debug_level)
 
                 # update with get blueprint by guid
-                return 'Would return get blueprint by guid and return md'  # egeria_client.get_term_by_guid(  #  #
+                return 'Would return get blueprint by guid and return md'  # egeria_client.get_term_by_guid(  #  #  #
                 # known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #  #
                 # known_guid, 'md')
 
             elif object_action == "Create":
@@ -707,12 +719,16 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                     update_element_dictionary(q_name, {'guid': new_guid, 'display_name': display_name})
                     return 'Would return get blueprint by guid results as md'  # egeria_client.get_term_by_guid(  #
                     # term_guid, 'MD')
+            else:
+                return None
 
         except Exception as e:
             msg = f"{ERROR}Error creating term {display_name}: {e}"
             print_msg("ERROR", msg, debug_level)
             console.print_exception(show_locals=True)
             return None
+    else:
+        return None
 
 
 def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> \
@@ -775,7 +791,10 @@ Optional[str]:
         print_msg("INFO", msg, debug_level)
     else:
         parent_components, parent_qname_list, parents_valid, parent_components_exist = process_name_list(egeria_client,
-            'Parent Components', txt, COMPONENT_NAME_LABELS)
+                                                                                                         'Parent '
+                                                                                                         'Components',
+                                                                                                         txt,
+                                                                                                         COMPONENT_NAME_LABELS)
         if parent_components_exist and parents_valid:
             msg = f"Found valid parent components that include this solution component:\n\t{parent_qname_list}"
             print_msg("INFO", msg, debug_level)
@@ -848,11 +867,11 @@ Optional[str]:
                 msg = f"\nUpdated Solution Component `{display_name}` with GUID {known_guid}"
                 print_msg("ALWAYS", msg, debug_level)
                 # update with get solution component by guid
-                return 'Would return get Solution Component by guid and return md'  # #  #
+                return 'Would return get Solution Component by guid and return md'  # #  #  #
                 # egeria_client.get_term_by_guid(known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_term_by_guid(  #  #  #
                 # known_guid, 'md')
 
             elif object_action == "Create":
@@ -870,7 +889,7 @@ Optional[str]:
                     msg = f"\nCreated Solution Component `{display_name}` with GUID {known_guid}"
                     print_msg("ALWAYS", msg, debug_level)
                     update_element_dictionary(known_q_name, {'guid': known_guid, 'display_name': display_name})
-                    return 'Would return get solution component by guid results as md'  # #  #
+                    return 'Would return get solution component by guid results as md'  # #  #  #
                     # egeria_client.get_term_by_guid(term_guid, 'MD')
 
         except Exception as e:
@@ -878,7 +897,8 @@ Optional[str]:
             print_msg("ERROR", msg, debug_level)
             console.print_exception(show_locals=True)
             return None
-
+    else:
+        return None
 
 def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
@@ -894,14 +914,15 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
     command, object_type, object_action = extract_command_plus(txt)
     set_debug_level(directive)
 
-    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS)
+    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'])
-    description = process_simple_attribute(txt, ['Description'])
-    usage = process_simple_attribute(txt, ['Usage'])
-    q_name = process_simple_attribute(txt, ['Qualified Name'])
+    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
@@ -1053,7 +1074,7 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
 
     if parent_category_name:
         _, parent_guid, parent_valid, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
-            parent_category_name)
+                                                                          parent_category_name)
     else:
         parent_guid = None
         parent_exists = False
@@ -1198,7 +1219,7 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
         if isinstance(current_parent, str) and "No Parent Category found" in current_parent:
             # No parent currently set, need to set it
             _, parent_guid, _, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
-                parent_category_name)
+                                                                   parent_category_name)
 
             if parent_exists and parent_guid:
                 egeria_client.set_parent_category(parent_guid, category_guid)
@@ -1219,7 +1240,7 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
 
                 # Then set the new parent
                 _, parent_guid, _, parent_exists = get_element_by_name(egeria_client, 'Glossary Categories',
-                    parent_category_name)
+                                                                       parent_category_name)
 
                 if parent_exists and parent_guid:
                     egeria_client.set_parent_category(parent_guid, category_guid)
@@ -1245,170 +1266,465 @@ def update_category_parent(egeria_client, category_guid: str, parent_category_na
     return outcome
 
 
-def process_term_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """ List terms as a markdown table. Filter based on optional search string. """
-    set_debug_level(directive)
+def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term create or update command by extracting key attributes such as
+    term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting glossary-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
+    categories_list = None
+    cats_exist = False
+    set_debug_level(directive)
+    known_q_name = None
     command = extract_command(txt)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
 
-    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}`"))
+    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)
 
-    glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary'])
-    if glossary is not None:
-        _, glossary_guid, _, glossary_exists = get_element_by_name(egeria_client, "Glossary", glossary)
-        msg = f"Found glossary `{glossary}` with GUID {glossary_guid}"
-        print_msg(INFO, msg, debug_level)
+    aliases = process_simple_attribute(txt, ['Aliases'], INFO)
+    if aliases:
+        alias_list = list(filter(None, re.split(r'[,\s]+', aliases.strip())))
     else:
-        glossary_guid = None
-        msg = f"No glossary found"
-        print_msg(INFO, msg, debug_level)
+        alias_list = None
 
-    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
-    if output_format is None:
-        output_format = "LIST"
-    elif output_format not in ELEMENT_OUTPUT_FORMATS:
+
+
+    # validate term name and get existing qualified_name and guid if they exist
+    if term_name is None:
         valid = False
-        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
+        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)
 
-    request_display = (f"\n\t* Search String: {search_string}\n\t* Glossary: {glossary}\n\t* Output Format: "
-                       f"{output_format}\n")
+    # 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)
+
+    # 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 command 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(request_display))
+        print(Markdown(term_display))
         return None
     elif directive == "validate":
-        print(Markdown(request_display))
+        print(Markdown(term_display))
         return valid
     elif directive == "process":
         try:
-            print(Markdown(request_display))
             if not valid:  # First validate the term before we process it
                 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, command, object_type,
+                # known_q_name, known_guid)
+            elif object_action == "Update" and directive == "validate":  # is sthis reachable?
+                return egeria_client.get_term_by_guid(known_guid, 'md')
 
-            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
+            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, command, 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, command,
+                    # object_type, q_name, term_guid)
         except Exception as e:
-            print(f"{ERROR}Error performing {command}: {e}")
+            print(f"{ERROR}Error creating term {term_name}: {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. """
+
+
+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)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
+    term1_guid = None
+    term2_guid = None
 
-    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:
+    term_relationship = process_simple_attribute(txt, ["Term Relationship"], "ERROR")
+    if term_relationship not in TERM_RELATIONSHPS:
         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"
+    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"], txt,
+                                                                     "Exists Required", None )
+
+    term2_q_name, term2_guid, term2_valid, term2_exists = process_element_identifiers(egeria_client, object_type, ["Term 2 Name"], 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(Markdown(request_display))
+        print(request_display)
         return None
     elif directive == "validate":
-        print(Markdown(request_display))
-        return valid
+        print(request_display)
+        return str(valid)
     elif directive == "process":
         try:
-            print(Markdown(request_display))
+            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
 
-            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)
-
-    known_glossary_guid = ""
 
-    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, "ERROR")
+def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
+    """
+    Processes a personal project create or update command by extracting key attributes such as
+    glossary name, language, description, and usage from the given cell.
 
-    _, known_glossary_guid, valid, _ = process_element_identifiers(egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt,
-        EXISTS_REQUIRED, None)
+    :param txt: A string representing the input cell to be processed for
+        extracting glossary-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.
+    """
+    command = extract_command(txt)
+    object = command.split()
+    object_type = f"{object[1]} {object[2]}"
+    object_action = object[0]
+    set_debug_level(directive)
 
-    print(Markdown(f"{pre_command} `{command}` for glossary:`{glossary_name}` with directive: `{directive}`"))
+    project_name = process_simple_attribute(txt, ['Project Name'])
+    description = process_simple_attribute(txt, ['Description'])
+    project_identifier = process_simple_attribute(txt, ['Project Identifier'])
+    project_status = process_simple_attribute(txt, ['Project Status'])
+    project_phase = process_simple_attribute(txt, ['Project Phase'])
+    project_health = process_simple_attribute(txt, ['Project Health'])
+    start_date = process_simple_attribute(txt, ['Start Date'])
+    planned_end_date = process_simple_attribute(txt, ['Planned End Date'])
+    print(Markdown(f"{pre_command} `\'{command}\'` for project: `{project_name}` with directive: `{directive}` "))
 
-    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    project_display = (f"\n* Command: {command}\n\t* Project: {project_name}\n\t"
+                       f"* Status: {project_status}\n\t* Description: {description}\n\t"
+                       f"* Phase: {project_phase}\n\t* Health: {project_health}\n\t"
+                       f"* Start Date: {start_date}\n\t* Planned End Date: {planned_end_date}\n")
+
+    def validate_project(obj_action: str) -> tuple[bool, bool, str, str]:
+        valid = True
+        msg = ""
+        known_guid = None
+        known_q_name = None
+
+        project_details = egeria_client.get_projects_by_name(project_name)
+        if project_details == NO_PROJECTS_FOUND:
+            project_exists = False
+        else:
+            project_exists = True
+
+        if project_name is None:
+            msg = f"* {ERROR}Project name is missing\n"
+            valid = False
+        if project_status is None:
+            msg += f"* {INFO}No Project status found\n"
+
+        if description is None:
+            msg += f"* {INFO}No Description found\n"
+
+        if project_identifier is None:
+            msg += f"* {INFO}No Project Identifier found\n"
+
+        if project_phase is None:
+            msg += f"* {INFO}No Project Phase found\n"
+
+        if project_health is None:
+            msg += f"* {INFO}No Project Health found\n"
+
+        if start_date is None:
+            msg += f"* {INFO}No Start Date found\n"
+        elif not is_valid_iso_date(start_date):
+            msg += f"* {ERROR}Start Date is not a valid ISO date of form  YYYY-MM-DD\n"
+            valid = False
+
+        if planned_end_date is None:
+            msg += f"* {INFO} No Planned End Date found\n"
+        elif not is_valid_iso_date(planned_end_date):
+            msg += f"* {ERROR}Planned End Date is not a valid ISO date of form  YYYY-MM-DD\n"
+            valid = False
+
+        if obj_action == "Update":
+            q_name = process_simple_attribute(txt, 'Qualified Name')
+
+            if not project_exists:
+                msg += f"* {ERROR}Project {project_name} does not exist\n"
+                valid = False
+            if len(project_details) > 1 and project_exists:
+                msg += f"* {ERROR}More than one project with name {project_name} found\n"
+                valid = False
+            if len(project_details) == 1:
+                known_guid = project_details[0]['elementHeader'].get('guid', None)
+                known_q_name = project_details[0]['glossaryProperties'].get('qualifiedName', None)
+            if q_name is None:
+                msg += f"* {INFO}Qualified Name is missing => can use known qualified name of {known_q_name}\n"
+                valid = True
+            elif q_name != known_q_name:
+                msg += (f"* {ERROR}Project {project_name} qualifiedName mismatch between {q_name} and {known_q_name}\n")
+                valid = False
+            if valid:
+                msg += project_display
+                msg += f"* -->Project {project_name} exists and can be updated\n"
+            else:
+                msg += f"* --> validation failed\n"
+            msg += '---'
+            print(Markdown(msg))
+            return valid, project_exists, known_guid, known_q_name
+
+        elif obj_action == "Create":
+            if project_exists:
+                msg += f"\n{ERROR}Project {project_name} already exists"
+            else:
+                msg += f"\n-->It is valid to create Project \'{project_name}\' with:\n"
+            print(Markdown(msg))
+            return valid, project_exists, known_guid, known_q_name
+
+    if directive == "display":
+        print(Markdown(project_display))
+        return None
+
+    elif directive == "validate":
+        is_valid, exists, known_guid, known_q_name = validate_project(object_action)
+        valid = is_valid if is_valid else None
+        return valid
+
+    elif directive == "process":
+        is_valid, exists, known_guid, known_q_name = validate_project(object_action)
+        if not is_valid:
+            return None
+        if object_action == "Update":
+            if not exists:
+                print(f"\n\n-->Project {project_name} does not exist")
+                return None
+
+            egeria_client.update_project(known_guid, known_q_name, project_identifier, project_name, description,
+                                         project_status, project_phase, project_health, start_date, planned_end_date,
+                                         False)
+            print_msg(ALWAYS, f"Updated Project `{project_name}` with GUID {known_guid}", debug_level)
+            return update_a_command(txt, command, object_type, known_q_name, known_guid)
+        elif object_action == "Create":
+            guid = None
+            if exists:
+                print(f"Project `{project_name}` already exists and update document created")
+                return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            else:
+                guid = egeria_client.create_project(None, None, None, False, project_name, description,
+                                                    "PersonalProject", project_identifier, True, project_status,
+                                                    project_phase, project_health, start_date, planned_end_date)
+                project_g = egeria_client.get_project_by_guid(guid)
+                if project_g == NO_GLOSSARIES_FOUND:
+                    print(f"Just created with GUID {guid} but Project not found")
+                    return None
+
+                q_name = project_g['projectProperties']["qualifiedName"]
+                update_element_dictionary(q_name, {'guid': guid, 'display_name': project_name})
+                print_msg(ALWAYS, f"Created project `{project_name}` with GUID {guid}", debug_level)
+                return update_a_command(txt, command, object_type, q_name, guid)
+
+
+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)
+
+    search_string = process_simple_attribute(txt, SEARCH_LABELS)
+    if search_string is None:
+        search_string = '*'
+    print(Markdown(f"{pre_command} `{command}` with search string:`{search_string}` with directive: `{directive}`"))
+
+    glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary'])
+    if glossary is not None:
+        _, glossary_guid, _, glossary_exists = get_element_by_name(egeria_client, "Glossary", glossary)
+        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 = "MD"
-    elif output_format not in ["DICT", "LIST", "MD"]:
+        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* Glossary name: {glossary_name}\n\t* Output Format: {output_format}\n"
+    request_display = (f"\n\t* Search String: {search_string}\n\t* Glossary: {glossary}\n\t* Output Format: "
+                       f"{output_format}\n")
 
     if directive == "display":
         print(Markdown(request_display))
         return None
     elif directive == "validate":
         print(Markdown(request_display))
-        return str(valid)
+        return 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"
+            term_list_md = f"\n# Term List for search string: `{search_string}`\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"
+                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:
-                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)
+                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 glossary_structure_md
+            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}")
@@ -1418,7 +1734,7 @@ def process_glossary_structure_command(egeria_client: EgeriaTech, txt: str, dire
         return None
 
 
-def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+def process_category_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
@@ -1428,8 +1744,6 @@ def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive
     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:
@@ -1441,82 +1755,82 @@ def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive
     request_display = f"\n\t* Search String: {search_string}\n\t* Output Format: {output_format}\n"
 
     if directive == "display":
-        print(request_display)
+        print(Markdown(request_display))
         return None
     elif directive == "validate":
-        print(request_display)
+        print(Markdown(request_display))
         return valid
     elif directive == "process":
         try:
-            print(request_display)
+            print(Markdown(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"
+            cat_list_md = f"\n# Category List for search string: `{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"
+                struct = egeria_client.find_glossary_categories(search_string, output_format=output_format)
+                cat_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)
+                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 glossary_list_md
+            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_term_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+def process_glossary_structure_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)
     valid = True
     command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
 
-    element_labels = TERM_NAME_LABELS
-    element_labels.append('Display Name')
+    known_glossary_guid = ""
 
-    term_name = process_simple_attribute(txt, element_labels, "ERROR")
+    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, "ERROR")
 
-    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
-                                                                               element_labels, txt, object_action, )
+    _, known_glossary_guid, valid, _ = process_element_identifiers(egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt,
+                                                                   EXISTS_REQUIRED, None)
 
-    print(Markdown(f"{pre_command} `{command}` for term:`{term_name}` with directive: `{directive}`"))
+    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 = "LIST"
-    elif output_format not in ["DICT", "LIST"]:
+        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* Term Name: {term_name}\n\t* Output Format {output_format}\n\t* GUID: {known_guid}\n"
+    request_display = f"\n\t* Glossary name: {glossary_name}\n\t* Output Format: {output_format}\n"
 
     if directive == "display":
-        print(request_display)
+        print(Markdown(request_display))
         return None
     elif directive == "validate":
-        print(request_display)
-        return valid
+        print(Markdown(request_display))
+        return str(valid)
     elif directive == "process":
         try:
-            print(request_display)
+            print(Markdown(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"
+
+            glossary_structure_md = f"\n# Glossary Structure for `{glossary_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"
+                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:
-                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)
+                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 term_history_md
+            return glossary_structure_md
 
         except Exception as e:
             print(f"{ERROR}Error performing {command}: {e}")
@@ -1526,52 +1840,49 @@ def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive:
         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."""
+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)
-    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}` "))
+    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 = '*'
 
-    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')
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
     if output_format is None:
         output_format = "LIST"
-    elif output_format not in ["DICT", "LIST", "MD"]:
+    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* Term Name: {term_name}\n\t* Output Format: {output_format}\n"
+    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 str(valid)
+        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 Revision History for `{term_name}`\n\n"
+
+            glossary_list_md = f"\n# Glossary List for `{search_string}`\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"
+                struct = egeria_client.find_glossaries(search_string, output_format=output_format)
+                glossary_list_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
+                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}")
@@ -1581,333 +1892,112 @@ def process_term_revision_history_command(egeria_client: EgeriaTech, txt: str, d
         return None
 
 
-def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a term create or update command by extracting key attributes such as
-    term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
-
-    :param txt: A string representing the input cell to be processed for
-        extracting glossary-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
-    categories_list = None
-    cats_exist = True
+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)
-    known_q_name = None
+    valid = True
     command = extract_command(txt)
     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'])
-    description = process_simple_attribute(txt, ['Description'])
-    abbreviation = process_simple_attribute(txt, ['Abbreviation'])
-    examples = process_simple_attribute(txt, ['Examples'])
-    usage = process_simple_attribute(txt, ['Usage'])
-    status = process_simple_attribute(txt, ['Status'])
-    status = status.upper() if status else 'DRAFT'
-    version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"])
-    q_name = process_simple_attribute(txt, ['Qualified Name'])
+    element_labels = TERM_NAME_LABELS
+    element_labels.append('Display Name')
 
-    # 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)
+    term_name = process_simple_attribute(txt, element_labels, "ERROR")
 
-    # 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)
+    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
+                                                                               element_labels, txt, object_action, )
 
-    # process categories, if present
-    categories = process_simple_attribute(txt, ['Glossary Categories', 'Glossary Category', 'Category', 'Categories'])
-    if categories:  # Find information about categoriess that classify this term
-        msg = "Checking for categories that classify this term"
-        print_msg("DEBUG-INFO", msg, debug_level)
-        categories_list, cat_q_name_list, cat_valid, cat_exist = process_name_list(egeria_client, 'Glossary Categories',
-                                                                                   txt, CATEGORY_NAME_LABELS)
-        if cat_exist and cat_valid:
-            msg = f"Found valid glossary categories to classify the term:\n\t{term_name}"
-            print_msg("INFO", msg, debug_level)
-        else:
-            msg = "No valid glossary categories found."
-            print_msg("INFO", msg, debug_level)
-    else:
-        cat_exist = cat_valid = False
-        cat_q_name_list = None
+    print(Markdown(f"{pre_command} `{command}` for term:`{term_name}` with directive: `{directive}`"))
 
-    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* 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
+    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)
 
-    elif object_action == 'Create':  # if the command 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* 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)
+    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(Markdown(term_display))
+        print(request_display)
         return None
     elif directive == "validate":
-        print(Markdown(term_display))
+        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
-            print(Markdown(term_display))
-            if object_action == "Update" and directive == "process":
-                if not term_exists:
-                    return None
-                body = {
-                    "class": "ReferenceableRequestBody", "elementProperties": {
-                        "class": "GlossaryTermProperties", "qualifiedName": known_q_name, "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))
-                # 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, command, object_type,
-                # known_q_name, known_guid)
-            elif object_action == "Update" and directive == "validate":  # is sthis reachable?
-                return egeria_client.get_term_by_guid(known_guid, 'md')
+            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)
 
-            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, command, 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)
+            return term_history_md
 
-                    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,
-                            "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, command,
-                    # object_type, q_name, term_guid)
         except Exception as e:
-            print(f"{ERROR}Error creating term {term_name}: {e}")
+            print(f"{ERROR}Error performing {command}: {e}")
             console.print_exception(show_locals=True)
             return None
+    else:
+        return None
 
 
-def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
-    """
-    Processes a personal project create or update command by extracting key attributes such as
-    glossary name, language, description, and usage from the given cell.
-
-    :param txt: A string representing the input cell to be processed for
-        extracting glossary-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.
-    """
-    command = extract_command(txt)
-    object = command.split()
-    object_type = f"{object[1]} {object[2]}"
-    object_action = object[0]
+def process_term_revision_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """ List term revision history as a markdown table or list."""
     set_debug_level(directive)
+    valid = True
+    command = extract_command(txt)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
+    known_q_name = None
+    known_guid = None
 
-    project_name = process_simple_attribute(txt, ['Project Name'])
-    description = process_simple_attribute(txt, ['Description'])
-    project_identifier = process_simple_attribute(txt, ['Project Identifier'])
-    project_status = process_simple_attribute(txt, ['Project Status'])
-    project_phase = process_simple_attribute(txt, ['Project Phase'])
-    project_health = process_simple_attribute(txt, ['Project Health'])
-    start_date = process_simple_attribute(txt, ['Start Date'])
-    planned_end_date = process_simple_attribute(txt, ['Planned End Date'])
-    print(Markdown(f"{pre_command} `\'{command}\'` for project: `{project_name}` with directive: `{directive}` "))
-
-    project_display = (f"\n* Command: {command}\n\t* Project: {project_name}\n\t"
-                       f"* Status: {project_status}\n\t* Description: {description}\n\t"
-                       f"* Phase: {project_phase}\n\t* Health: {project_health}\n\t"
-                       f"* Start Date: {start_date}\n\t* Planned End Date: {planned_end_date}\n")
-
-    def validate_project(obj_action: str) -> tuple[bool, bool, str, str]:
-        valid = True
-        msg = ""
-        known_guid = None
-        known_q_name = None
-
-        project_details = egeria_client.get_projects_by_name(project_name)
-        if project_details == NO_PROJECTS_FOUND:
-            project_exists = False
-        else:
-            project_exists = True
-
-        if project_name is None:
-            msg = f"* {ERROR}Project name is missing\n"
-            valid = False
-        if project_status is None:
-            msg += f"* {INFO}No Project status found\n"
-
-        if description is None:
-            msg += f"* {INFO}No Description found\n"
-
-        if project_identifier is None:
-            msg += f"* {INFO}No Project Identifier found\n"
-
-        if project_phase is None:
-            msg += f"* {INFO}No Project Phase found\n"
-
-        if project_health is None:
-            msg += f"* {INFO}No Project Health found\n"
-
-        if start_date is None:
-            msg += f"* {INFO}No Start Date found\n"
-        elif not is_valid_iso_date(start_date):
-            msg += f"* {ERROR}Start Date is not a valid ISO date of form  YYYY-MM-DD\n"
-            valid = False
-
-        if planned_end_date is None:
-            msg += f"* {INFO} No Planned End Date found\n"
-        elif not is_valid_iso_date(planned_end_date):
-            msg += f"* {ERROR}Planned End Date is not a valid ISO date of form  YYYY-MM-DD\n"
-            valid = False
+    element_labels = TERM_NAME_LABELS
 
-        if obj_action == "Update":
-            q_name = process_simple_attribute(txt, 'Qualified Name')
+    term_name = process_simple_attribute(txt, element_labels, "ERROR")
+    print(Markdown(f"{pre_command} `{command}` for term: `{term_name}` with directive: `{directive}` "))
 
-            if not project_exists:
-                msg += f"* {ERROR}Project {project_name} does not exist\n"
-                valid = False
-            if len(project_details) > 1 and project_exists:
-                msg += f"* {ERROR}More than one project with name {project_name} found\n"
-                valid = False
-            if len(project_details) == 1:
-                known_guid = project_details[0]['elementHeader'].get('guid', None)
-                known_q_name = project_details[0]['glossaryProperties'].get('qualifiedName', None)
-            if q_name is None:
-                msg += f"* {INFO}Qualified Name is missing => can use known qualified name of {known_q_name}\n"
-                valid = True
-            elif q_name != known_q_name:
-                msg += (f"* {ERROR}Project {project_name} qualifiedName mismatch between {q_name} and {known_q_name}\n")
-                valid = False
-            if valid:
-                msg += project_display
-                msg += f"* -->Project {project_name} exists and can be updated\n"
-            else:
-                msg += f"* --> validation failed\n"
-            msg += '---'
-            print(Markdown(msg))
-            return valid, project_exists, known_guid, known_q_name
+    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)
 
-        elif obj_action == "Create":
-            if project_exists:
-                msg += f"\n{ERROR}Project {project_name} already exists"
-            else:
-                msg += f"\n-->It is valid to create Project \'{project_name}\' with:\n"
-            print(Markdown(msg))
-            return valid, project_exists, known_guid, known_q_name
+    request_display = f"\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}\n"
 
     if directive == "display":
-        print(Markdown(project_display))
+        print(request_display)
         return None
-
     elif directive == "validate":
-        is_valid, exists, known_guid, known_q_name = validate_project(object_action)
-        valid = is_valid if is_valid else None
-        return valid
-
+        print(request_display)
+        return str(valid)
     elif directive == "process":
-        is_valid, exists, known_guid, known_q_name = validate_project(object_action)
-        if not is_valid:
-            return None
-        if object_action == "Update":
-            if not exists:
-                print(f"\n\n-->Project {project_name} does not exist")
+        try:
+            print(request_display)
+            if not valid:  # First validate the term before we process it
                 return None
-
-            egeria_client.update_project(known_guid, known_q_name, project_identifier, project_name, description,
-                                         project_status, project_phase, project_health, start_date, planned_end_date,
-                                         False)
-            print_msg(ALWAYS, f"Updated Project `{project_name}` with GUID {known_guid}", debug_level)
-            return update_a_command(txt, command, object_type, known_q_name, known_guid)
-        elif object_action == "Create":
-            guid = None
-            if exists:
-                print(f"Project `{project_name}` already exists and update document created")
-                return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            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:
-                guid = egeria_client.create_project(None, None, None, False, project_name, description,
-                                                    "PersonalProject", project_identifier, True, project_status,
-                                                    project_phase, project_health, start_date, planned_end_date)
-                project_g = egeria_client.get_project_by_guid(guid)
-                if project_g == NO_GLOSSARIES_FOUND:
-                    print(f"Just created with GUID {guid} but Project not found")
-                    return None
+                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
 
-                q_name = project_g['projectProperties']["qualifiedName"]
-                update_element_dictionary(q_name, {'guid': guid, 'display_name': project_name})
-                print_msg(ALWAYS, f"Created project `{project_name}` with GUID {guid}", debug_level)
-                return update_a_command(txt, command, object_type, q_name, guid)