pyegeria 5.3.7.8__py3-none-any.whl → 5.3.8.1__py3-none-any.whl

pyegeria/md_processing_utils.py

@@ -5,44 +5,57 @@ This file contains functions to parse and process Egeria Markdown (Freddie)
 
 """
 
-import json
-from jupyter_notebook_parser import JupyterNotebookParser
-import nbformat
-from typing import List, Optional
-
 import os
 import re
+import sys
+from datetime import datetime
+from typing import List, Optional
 
-from rich import box, print
+from prompt_toolkit.filters import Always
+from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
 
 from pyegeria import body_slimmer
-from pyegeria._globals import NO_TERMS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND
+from pyegeria._globals import (NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND,
+                               NO_PROJECTS_FOUND, \
+                               NO_CATEGORIES_FOUND)
 from pyegeria.egeria_tech_client import EgeriaTech
+
 # from pyegeria.md_processing_helpers import process_q_name_list
 from pyegeria.project_manager_omvs import ProjectManager
-from pyegeria.glossary_manager_omvs import GlossaryManager
-from pyegeria.shared_state import get_element_dictionary, update_element_dictionary
+from pyegeria.shared_state import get_element_dictionary, update_element_dictionary, find_key_with_value
 
-from datetime import datetime
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
 console = Console(width=EGERIA_WIDTH)
 
-command_list = ["Provenance",
-                "Create Glossary", "Update Glossary",
-                "Create Term", "Update Term",
-                "Create Personal Project", "Update Personal Project",
-                "Create Category", "Update Category",
-                "Create Solution Blueprint", "Update Solution Blueprint",
-                "Create Solution Component", "Update Solution Component",]
-
-ERROR = "ERROR-> "
-INFO = "INFO- "
-WARNING = "WARNING-> "
+command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term",
+                "Create Personal Project", "Update Personal Project", "Create Category", "Update Category",
+                "Create Solution Blueprint", "Update Solution Blueprint", "Create Solution Component",
+                "Update Solution Component", ]
+# verbosity - verbose, quiet, debug
+debug_level = "verbose"
+message_types = {
+    "INFO": "INFO-", "WARNING": "WARNING->", "ERROR": "ERROR->", "DEBUG-INFO": "DEBUG-INFO->",
+    "DEBUG-WARNING": "DEBUG-WARNING->", "DEBUG-ERROR": "DEBUG-ERROR->", "ALWAYS": "\n\n==> "
+    }
+ALWAYS = "ALWAYS"
+ERROR = "ERROR"
+INFO = "INFO"
+WARNING = "WARNING"
 pre_command = "\n---\n==> Processing command:"
-
-
+command_seperator = Markdown("\n---\n")
+
+GLOSSARY_NAME_LABELS = ["Glossary Name", "Glossary", "Glossaries", "Owning Glossary", "In Glossary"]
+CATEGORY_NAME_LABELS = [ "Glossary Category Name", "Glossary Category", "Glossary Categories", "Category Name", "Category", "Categories"]
+TERM_NAME_LABELS= ["Glossary Term Name", "Glossary Term", "Glossary Terms", "Term Name", "Term", "Terms", "Term Names"]
+PROJECT_NAME_LABELS = ["Project Name", "Project", "Project Names", "Projects"]
+BLUEPRINT_NAME_LABELS = ["Solution Blueprint Name", "Solution Blueprint", "Solution Blueprints", "Blueprint Name", "Blueprint", "Blueprints"]
+COMPONENT_NAME_LABELS = ["Solution Component Name", "Solution Component", "Solution Components", "Component Name", "Component", "Components", "Parent Components", "Parent Component"]
+SOLUTION_ROLE_LABELS = ["Solution Role Name", "Solution Role", "Solution Roles", "Role Name", "Role", "Roles"]
+SOLUTION_ACTOR_ROLE_LABELS = [ "Solution Actor Role Name", "Solution Actor Role Names","Solution Actor Role", "Solution Actor Roles", "Actor Role Name", "Actor Role", "Actor Roles", "Actor Role Names"]
+SOLUTION_LINKING_ROLE_LABELS = [ "Solution Linking Role Name", "Solution Linking Role Names", "Solution Linking Role", "Solution Linking Roles", "Linking Role Name", "Linking Role", "Linking Roles", "Linking Role Names"]
+GUID_LABELS = ['GUID','guid']
 
 def render_markdown(markdown_text: str) -> None:
     """Renders the given markdown text in the console."""
@@ -64,9 +77,30 @@ def get_current_datetime_string():
     return now
 
 
-def add_term_to_categories(egeria_client: GlossaryManager, term_guid: str, categories_exist: bool,
-                           categories_list: List[str], element_dictionary: dict) -> None:
+def add_term_to_categories(egeria_client: EgeriaTech, term_guid: str, categories_exist: bool,
+                           categories_list: List[str]) -> None:
+    """
+    Adds a term to specified categories in a glossary.
+
+    This function associates a term, identified by its GUID, with one or more
+    categories. It uses the provided EgeriaTech client to assign the term
+    to the categories. If the GUID of a category is not readily available, it
+    is retrieved either from a pre-loaded dictionary or through a client lookup.
+
+    Args:
+        egeria_client (EgeriaTech): The client to interact with the glossary.
+        term_guid (str): The GUID of the term to be associated with categories.
+        categories_exist (bool): Flag indicating whether the categories already
+                                 exist.
+        categories_list (List[str]): A list of category names to associate with
+                                     the term.
+
+    Returns:
+        None
+    """
     if categories_exist is True and categories_list is not None:
+        if type(categories_list) is str:
+            categories_list = categories_list.split(",").trim()
         for category in categories_list:
             cat_guid = None
             cat_el = category.strip()
@@ -79,24 +113,63 @@ def add_term_to_categories(egeria_client: GlossaryManager, term_guid: str, categ
             egeria_client.add_term_to_category(term_guid, cat_guid)
 
 
-def extract_command_plus(block: str) -> tuple[str, str] | None:
+def extract_command_plus(block: str) -> tuple[str, str, str] | None:
+    """
+    Extracts a multi-word object and its associated action from the given block of text.
+
+    This function searches for a pattern in the format of `#...##` or `#...\n`
+    inside the provided string `block`. The matched pattern is split into
+    two parts: the action and the object type. The action is expected to
+    be the first part, while the rest is treated as the object type. If
+    no match is found, the function returns None.
+
+    Args:
+        block: A string containing the block of text to search for the
+            command and action.
+
+    Returns:
+        A tuple containing the command, the object type and the object action if a
+        match is found. Otherwise, returns None.
+    """
     match = re.search(r"#(.*?)(?:##|\n|$)", block)  # Using a non capturing group
     if match:
         clean_match = match.group(1).strip()
-        parts = clean_match.split(' ')
-        object_action = parts[0].strip()
+        if ' ' in clean_match:
+            parts = clean_match.split(' ')
+            object_action = parts[0].strip()
         # Join the rest of the parts to allow object_type to be one or two words
-        object_type = ' '.join(parts[1:]).strip()
-        return object_type, object_action
+            object_type = ' '.join(parts[1:]).strip()
+        else:
+            object_type = clean_match.split(' ')[1].strip()
+            object_action = clean_match.split(' ')[0].strip()
+
+        return clean_match, object_type, object_action
     return None
 
+
 def extract_command(block: str) -> str | None:
+    """
+    Extracts a command from a block of text that is contained between a single hash ('#') and
+    either a double hash ('##'), a newline character, or the end of the string.
+
+    The function searches for a specific pattern within the block of text and extracts the
+    content that appears immediately after a single hash ('#'). Ensures that the extracted
+    content is appropriately trimmed of leading or trailing whitespace, if present.
+
+    Args:
+        block: A string representing the block of text to process. Contains the content
+            in which the command and delimiters are expected to be present.
+
+    Returns:
+        The extracted command as a string if a match is found, otherwise None.
+    """
     match = re.search(r"#(.*?)(?:##|\n|$)", block)  # Using a non capturing group
     if match:
         return match.group(1).strip()
     return None
 
-def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
+
+def extract_attribute(text: str, labels: [str]) -> str | None:
     """
         Extracts the glossary name from a string.
 
@@ -110,17 +183,93 @@ def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
     # Iterate over the list of labels
     for label in labels:
         # Construct pattern for the current label
-        pattern = rf"## {re.escape(label)}\n(.*?)(?:#|---|$)"
+        pattern = rf"## {re.escape(label)}\n(.*?)(?:#|___|$)" # modified from --- to enable embedded tables
         match = re.search(pattern, text, re.DOTALL)
         if match:
             # Extract matched text and replace consecutive \n with a single \n
             extracted_text = re.sub(r'\n+', '\n', match.group(1).strip())
             if not extracted_text.isspace() and extracted_text:
-                return extracted_text  # Return the cleaned text
+                return extracted_text.title()  # Return the cleaned text
+
 
+def print_msg(msg_level: str, msg: str, verbosity: str):
+    """
+    Prints a message based on its type and verbosity level.
+
+    This function handles the output of messages depending on the specified
+    verbosity level and message type. It uses predefined message types and
+    formats the output accordingly.
+
+    Args:
+        msg_type: The type of the message, such as 'WARNING', 'ERROR', 'INFO', or
+            'ALWAYS'.
+        msg: The content of the message to display.
+        verbosity: The verbosity level, which determines how the message is
+            displayed ('verbose', 'quiet', or 'debug').
+    """
+    msg_level = msg_level.upper()
+    record = f"{message_types[msg_level]} {msg}"
+    if msg_level in ("WARNING", "ERROR", "INFO"):
+        record = f"* {record}"
+
+    match verbosity.lower():
+        case "verbose":
+            if msg_level in ("WARNING", "ERROR", "INFO", "ALWAYS"):
+                print(record)
+        case "quiet":
+            if msg_level in ("WARNING", "ERROR", "ALWAYS"):
+                print(record)
+        case "debug":
+            print(record)
+        case _:
+            print("Invalid verbosity level - exiting\n")
+            sys.exit(1)
+
+def process_simple_attribute(txt: str, labels: [str], if_missing: str = INFO) -> str | None:
+    """Process a simple attribute based on the provided labels and if_missing value.
+       Extract the attribute value from the text and return it if it exists.
+       If it doesn`t exist, return None and print an error message with severity of if_missing.
+
+       Parameters:
+       ----------
+       txt: str
+         The block of command text to extract attributes from.
+       labels: list
+         The possible attribute labels to search for. The first label will be used in messages.
+       if_missing: str, default is INFO
+         Can be one of "WARNING", "ERROR", "INFO". The severity of the missing attribute.
+    """
+    if if_missing not in ["WARNING", "ERROR", "INFO"]:
+        print_msg("ERROR", "Invalid severity for missing attribute", debug_level)
+        return None
 
+    attribute = extract_attribute(txt, labels)
+
+    if attribute is None:
+        msg = f"Missing {labels[0]} attribute"
+        print_msg(if_missing, msg, debug_level)
+        return None
+    return attribute
 
 def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid: str) -> str:
+    """
+    Updates a command by modifying the input text with corresponding actions, GUID, and qualified name.
+    The function processes the provided command based on the given parameters, updating the relevant
+    sections in the text, including command actions, GUID, qualified name, and optionally the status
+    of the attributes. It ensures that proper formatting and necessary fields are present in the text.
+
+    Args:
+        txt (str): The input text containing the content to be updated.
+        command (str): The command to be processed (e.g., "Create Term", "Update Term").
+        obj_type (str): The object type related to the command (e.g., "Term", "Category").
+        q_name (str): The qualified name to be added or updated in the text.
+        u_guid (str): The unique identifier (GUID) to be added or updated in the text. If not provided,
+            it defaults to an empty string.
+
+    Returns:
+        str: The updated text containing the modifications based on the provided command.
+
+    """
     u_guid = u_guid if u_guid else " "
     verb = command.split(' ')[0].strip()
     action = "Update" if (verb == "Create" and u_guid is not None) else "Create"
@@ -132,12 +281,6 @@ def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid:
     if "GUID" not in txt:
         txt += f"\n## GUID\n{u_guid}\n"
 
-    # if (command in {"Update Term", "Update Category", 'Update Glossary'}) and ("Update Description" not in txt):
-    #     txt += '\n** Update Description\n\n\n'
-    # elif "Update Description" in txt:
-    #     pattern = r"(## Update Description\n).*?(#)"
-    #     replacement = r"\1\n\n\2"
-    #     txt += re.sub(pattern, replacement, txt)
 
     status = extract_attribute(txt, ["Status"])
     if command in ["Create Term", "Update Term"] and status is None:
@@ -146,6 +289,7 @@ def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid:
         txt = re.sub(pattern, replacement, txt)
     return txt
 
+
 def process_provenance_command(file_path: str, txt: [str]) -> str:
     """This commands processes a provenence command by pre-pending the current file name and time to the provenance
     output"""
@@ -157,24 +301,27 @@ def process_provenance_command(file_path: str, txt: [str]) -> str:
         # Extract matched text and replace consecutive \n with a single \n
         extracted_text = re.sub(r'\n+', '\n', match.group(1).strip())
         if not extracted_text.isspace() and extracted_text:
-            existing_prov =  extracted_text  # Return the cleaned text
+            existing_prov = extracted_text  # Return the cleaned text
         else:
             existing_prov = None
     print(f"txt is: {txt}, existing_prov: {existing_prov}")
     existing_prov = existing_prov if existing_prov else " "
     return f"\n# Provenance:\n{existing_prov}\n{output}\n"
 
-def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt: str, action: str, version: str=None) \
-        -> tuple[str, str, str, bool, bool]:
+
+def process_element_identifiers(egeria_client: EgeriaTech, element_type: str, element_labels: [str], txt: str, action: str,
+                                version: str = None) -> tuple[str, str, bool, bool]:
     """
     Processes element identifiers by extracting display name and qualified name from the input text,
     checking if the element exists in Egeria, and validating the information.
 
     Parameters:
+        element_labels:
     egeria_client: EgeriaTech
         Client object for interacting with Egeria.
     element_type: str
         type of element to process (e.g., 'blueprint', 'category', 'term')
+    element_labels: a list of equivalent label names to use in processing the element.
     txt: str
         A string representing the input text to be processed for extracting element identifiers.
     action: str
@@ -186,46 +333,63 @@ def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt
         A tuple containing:
         - qualified_name: Empty string or element identifier
         - guid: Empty string or additional element information
-        - msg: Information or error messages about the processing
         - Valid: Boolean indicating if the element information is valid
         - Exists: Boolean indicating if the element exists in Egeria
     """
-    msg = ""
-    guid = None
     valid = True
-    exists = False
-    unique: bool | None = None
-    display_name = extract_attribute(txt, ["Display Name"])
 
+    element_name = extract_attribute(txt, element_labels)
     qualified_name = extract_attribute(txt, ["Qualified Name"])
+
+
     if qualified_name:
-        q_name, guid, msg, unique, exists  = get_element_by_name(egeria_client,element_type,qualified_name)
-        # Qualified name could be different if it is being updated
+        q_name, guid, unique, exists = get_element_by_name(egeria_client, element_type,
+                                                           qualified_name)  # Qualified name could be different if it is being updated
     else:
-         q_name, guid, msg, unique, exists = get_element_by_name(egeria_client,element_type,display_name)
+        q_name, guid, unique, exists = get_element_by_name(egeria_client, element_type, element_name)
     if unique is False:
-        msg += f"{ERROR} Multiple elements named  {display_name} found\n"
+        msg = f"Multiple elements named  {element_name} found"
+        print_msg("DEBUG-ERROR", msg, debug_level)
         valid = False
+
     if action == "Update" and not exists:
-        msg += f"* {ERROR}Element {display_name} does not exist\n"
+        msg = f"Element {element_name} does not exist"
+        print_msg("DEBUG-ERROR", msg, debug_level)
         valid = False
+
     elif action == "Update" and exists:
-        msg += f"* {INFO}Element {display_name} exists\n"
+        msg = f"Element {element_name} exists"
+        print_msg("DEBUG-INFO", msg, debug_level)
+
     elif action == "Create" and exists:
-        msg += f"* {ERROR}Element {display_name} already exists\n"
+        msg = f"Element {element_name} already exists"
+        print_msg("DEBUG-ERROR", msg, debug_level)
         valid = False
+
     elif action == "Create" and not exists:
-        msg += f"* {INFO}Element {display_name} does not exist and can be created\n"
-        if q_name is None:
-            q_name = egeria_client.__create_qualified_name__(element_type, display_name,
-                                                             version_identifier=version)
-            update_element_dictionary(q_name, {'display_name': display_name})
+        msg = f"{element_type} `{element_name}` does not exist"
+        print_msg("DEBUG-INFO", msg, debug_level)
+
+        if q_name is None and qualified_name is None:
+            q_name = egeria_client.__create_qualified_name__(element_type, element_name, version_identifier=version)
+            update_element_dictionary(q_name, {'display_name': element_name})
+        elif qualified_name:
+            update_element_dictionary(qualified_name, {'display_name': element_name})
+    elif action == "Exists Required":
+        if not exists:
+            msg = f"Required {element_type} `{element_name}` does not exist"
+            print_msg("DEBUG-ERROR", msg, debug_level)
+            valid = False
+        else:
+            msg = f"Required {element_type} `{element_name}` exists"
+            print_msg("DEBUG-INFO", msg, debug_level)
+            valid = True
 
-    return q_name, guid, msg, valid, exists
+    return q_name, guid, valid, exists
 
 
-def get_element_by_name(egeria_client, element_type: str, element_name: str)\
-        ->tuple[str | None, str | None, str, bool | None, bool | None]:
+def get_element_by_name(egeria_client, element_type: str, element_name: str) -> tuple[
+    str | None, str | None, bool | None, bool | None]:
     """
     Generalized function to retrieve an element by name based on its type.
 
@@ -238,92 +402,111 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str)\
         The name of the element to retrieve.
 
     Returns:
-        tuple of qualified_name, guid, msg, uniqye, exists
+        tuple of qualified_name, guid, uniqye, exists
     """
     unique = None
+
     element_dict = get_element_dictionary()
-    if element_name in element_dict: # use information from element_dictionary
-        guid = element_dict[element_name].get('guid',None)
+    q_name = find_key_with_value(element_name)
+    if q_name:  # use information from element_dictionary
+        guid = element_dict[q_name].get('guid', None)
         unique = True
-        exists = False
-        if guid is not None: # Found complete entry in element_dictionary
-            return element_name, guid, 'Found qualified name', unique, exists
-        else: # Missing guid from element_dictionary
+        exists = True
+        if guid is not None:  # Found complete entry in element_dictionary
+            msg = f'Found {element_type} qualified name and guid in element_dictionary for `{element_name}`'
+            print_msg("DEBUG-INFO", msg, debug_level)
+            return q_name, guid, unique, exists
+
+        else:  # Missing guid from element_dictionary
             guid = egeria_client.get_element_guid_by_unique_name(element_name)
             if guid == NO_ELEMENTS_FOUND:
-                exists = False
-                msg = f"{INFO}No {element_type} guid found with name {element_name}\n"
-                return element_name, None, msg, unique, exists
+                guid = None
+                msg = f"No {element_type} guid found with name {element_name} in Egeria"
+                print_msg("DEBUG-INFO", msg, debug_level)
+
+                return q_name, guid, unique, exists
             else:
                 exists = True
-                update_element_dictionary(element_name, {'guid': guid})
-                return element_name, guid, 'Found qualified name', unique, exists
+                update_element_dictionary(q_name, {'guid': guid})
+                msg = f"Found guid value of {guid} for  {element_name} in Egeria"
+                print_msg("DEBUG-INFO", msg, debug_level)
+
+                return q_name, guid, unique, exists
 
     # Haven't seen this element before
     property_names = ['qualifiedName', 'name', 'displayName']
     open_metadata_type_name = None
-    details =  egeria_client.get_elements_by_property_value(
-        element_name, property_names, open_metadata_type_name
-        )
+    details = egeria_client.get_elements_by_property_value(element_name, property_names, open_metadata_type_name)
     if isinstance(details, str):
-        msg = f"{INFO}{element_type} `{element_name}` not found\n"
+        msg = f"{element_type} `{element_name}` not found in Egeria"
+        print_msg("DEBUG-INFO", msg, debug_level)
         exists = False
-        return element_name, None, msg, unique, exists
+        return None, None, unique, exists
     if len(details) > 1:
-        msg = (f"{ERROR}More than one element with name {element_name} found, please specify a "
-                f"**Qualified Name**\n")
-        unique= False
+        msg = (f"More than one element with name {element_name} found, please specify a "
+               f"**Qualified Name**")
+        print_msg("DEBUG-ERROR", msg, debug_level)
+        unique = False
         exists = None
-        return element_name, None, msg, unique, exists
+        return element_name, None, unique, exists
 
     el_qname = details[0]["properties"].get('qualifiedName', None)
     el_guid = details[0]['elementHeader']['guid']
     el_display_name = details[0]["properties"].get('displayName', None)
     update_element_dictionary(el_qname, {
-        'guid': el_guid,
-        'displayName': el_display_name
+        'guid': el_guid, 'displayName': el_display_name
         })
-    msg = f"{INFO}Found {element_type} `{element_name}`\n"
+    msg = f"Found {element_type} `{el_display_name}` with qualified name `{el_qname}`"
+    print_msg("DEBUG-INFO", msg, debug_level)
     exists = True
     unique = True
-    return el_qname, el_guid, msg, 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"{element_type}es"
-    # else:
-    #     plural_type = f"{element_type}s"
-    #
-    # # Construct method name
-    # method_name = f"get_{plural_type}_by_name"
-    #
-    # # Check if the method exists on the client
-    # if hasattr(egeria_client, method_name):
-    #     # Call the method
-    #     method = getattr(egeria_client, method_name)
-    #     result = method(element_name)
-    #     return result
-    # else:
-    #     # Method doesn't exist
-    #     return f"Method {method_name} not found on client"
-
-
-
-def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str) -> tuple[
-    str | None, list | None, str | None, bool, bool]:
-    msg = ""
-    known_guid = None
+    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"{
+    # element_type}es"  # else:  #     plural_type = f"{element_type}s"  #  # # Construct method name  # method_name
+    # = f"get_{plural_type}_by_name"  #  # # Check if the method exists on the client  # if hasattr(egeria_client,
+    # method_name):  #     # Call the method  #     method = getattr(egeria_client, method_name)  #     result =
+    # method(element_name)  #     return result  # else:  #     # Method doesn't exist  #     return f"Method {
+    # method_name} not found on client"
+
+
+def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str, element_labels: [str]) -> tuple[
+    str | None, list | None, bool, bool]:
+    """
+    Processes a list of qualified names specified in the given text, retrieves details for each
+    element based on the provided type, and generates a list of valid qualified names.
+
+    The function reads a text block, extracts a list of element names according to the specified
+    element type, looks them up using the provided Egeria client, and classifies them as valid or
+    invalid. It returns the processed names, a list of qualified names, and validity and existence
+    flags.
+
+    Args:
+
+        egeria_client (EgeriaTech): The client instance to connect and query elements from an
+            external system.
+        element_type (str): The type of element, such as schema or attribute, to process.
+        txt (str): The raw input text containing element names to be processed.
+        element_labels: a list of equivalent label names to use in processing the element.
+
+    Returns:
+        tuple[str | None, list | None, bool, bool]: A tuple containing:
+            - Concatenated valid input names as a single string (or None if empty).
+            - A list of known qualified names extracted from the processed elements.
+            - A boolean indicating whether all elements are valid.
+            - A boolean indicating whether all elements exist.
+    """
     valid = True
-    exists = False
+    exists = True
     elements = ""
     new_element_list = []
 
-    elements_txt = extract_attribute(txt, [element_type])
+    elements_txt = extract_attribute(txt, element_labels)
 
     if elements_txt is None:
-        msg += f"* {INFO}No {element_type}s found\n"
+        msg = f"No {element_type} found"
+        print_msg("DEBUG-INFO", msg, debug_level)
 
     else:
         element_list = re.split(r'[,\n]+', elements_txt)
@@ -332,30 +515,31 @@ def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str)
             element_el = element.strip()
 
             # Get the element using the generalized function
-            known_q_name, known_guid, status_msg, el_valid, el_exists = get_element_by_name(
-                egeria_client, element_type, element_el)
-            msg += status_msg
+            known_q_name, known_guid, el_valid, el_exists = get_element_by_name(egeria_client, element_type, element_el)
+            # print_msg("DEBUG-INFO", status_msg, debug_level)
+
             if el_exists and el_valid:
-                elements = f"{element_el}, {elements}"  # list of the input names
+                elements = f"{element_el} {elements}"  # list of the input names
                 new_element_list.append(known_q_name)  # list of qualified names
             elif not el_exists:
-                msg += f"* {INFO}No {element_type} `{element_el}` found\n"
+                msg = f"No {element_type} `{element_el}` found"
+                print_msg("DEBUG-INFO", msg, debug_level)
                 valid = False
-            valid = valid if el_valid is None else valid and el_valid
+            valid = valid if el_valid is None else (valid and el_valid)
             exists = exists and el_exists
 
         if elements:
-            elements += "\n"
-            msg += f"* {INFO}Found {element_type}s: {elements}"
+            # elements += "\n"
+            msg = f"Found {element_type}: {elements}"
+            print_msg("DEBUG-INFO", msg, debug_level)
         else:
-            msg += f"* {INFO}List contains one or more invalid elements.\n"
-        return elements, new_element_list, msg, valid, exists
-
-
+            msg = f" Name list contains one or more invalid qualified names."
+            print_msg("DEBUG-INFO", msg, debug_level)
+        return elements, new_element_list, valid, exists
 
 
 def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                directive: str = "display") -> Optional[str]:
+                                     directive: str = "display") -> Optional[str]:
     """
     Processes a blueprint create or update command by extracting key attributes such as
     blueprint name, description, and version from the given cell.
@@ -372,111 +556,95 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
     Returns: str
         A string summarizing the outcome of the processing.
     """
-    object_type, object_action = extract_command_plus(txt)
-    element_display = ""
-    valid = True
-    msg =""
+    command, object_type, object_action = extract_command_plus(txt)
 
-    display_name = extract_attribute(txt, ['Display Name','Blueprint Name'])
-    description = extract_attribute(txt, ['Description'])
-    version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
+    display_name = process_simple_attribute(txt, ['Display Name', 'Blueprint Name'],ERROR)
+    description = process_simple_attribute(txt, ['Description'])
+    version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"])
 
-    print(Markdown(f"{pre_command} {object_action} `{object_type}` for Blueprint: `\'{display_name}\'` with directive: `{directive}`\n"))
+    print(Markdown(
+        f"{pre_command} {object_action} `{object_type}` for Blueprint: `\'{display_name}\'` with directive: `"
+        f"{directive}`\n"))
     if display_name is None:
-        msg += f"* {ERROR}Display name is missing\n"
         valid = False
         q_name, known_guid, exists = None
     else:
-        q_name, known_guid, status_msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
-        msg+= status_msg
-
-    if description is None:
-        msg += f"* {INFO}Description is missing\n"
-
-    if version is None:
-        msg += f"* {INFO}Term version is missing\n"
-
-    update_description = extract_attribute(txt, ['Update Description'])
-    if update_description is None:
-        msg += f"* {INFO}Update Description is missing\n"
-        update_description = "---"
+        element_labels = BLUEPRINT_NAME_LABELS
+        element_labels.append('Display Name')
+        q_name, known_guid, valid, exists = process_element_identifiers(egeria_client, object_type, element_labels,
+                                                                                    txt, object_action, version)
 
     element_display = (f"\n* Command: {object_action} {object_type}\n\t* Blueprint: {display_name}\n\t"
                        f"* Description: {description}\n\t"
                        f"* Version: {version}\n\t* Qualified Name:{q_name}\n\t* GUID: {known_guid} "
-                       f"\n\t* Update Description: {update_description}\n")
-
-    # if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
-    #     if not exists:
-    #         msg += f"* {ERROR}Element {display_name} does not exist\n"
-    #         valid = False
-
-    # elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
-    #     if exists:
-    #         msg += f"\n{WARNING}Element \'{display_name}\' already exists.\n"
-    #     elif not valid:
-    #         msg += f"\n-->Validation checks failed in creating element \'{display_name}\' with: {element_display}\n"
-    #     else: # valid to create - update element_dictionary
-    #         msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
-    #         if known_q_name is None:
-    #             known_q_name = egeria_client.__create_qualified_name__(object_type, display_name)
-    #             element_dictionary[known_q_name] = {'display_name': display_name}
-    if valid:
-        msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
+                       # f"\n\t* Update Description: {update_description}\n"
+                       )
 
+    if valid:
+        msg = f"\n-->It is valid to **{object_action}** element \'{display_name}\'\n"
+        print_msg("ALWAYS", msg, debug_level)
     if directive == "display":
         print(Markdown(element_display))
         return None
     elif directive == "validate":
-        print(Markdown(msg))
         print(Markdown(element_display))
         return valid
 
     elif directive == "process":
-        print(Markdown(msg))
+        print(Markdown(element_display))
         try:
-            if not valid:  # First validate the term before we process it
+            if not valid:  # First validate the element before we process it
+                msg = "\nInvalid input found - please review the errors and warnings above\n"
+                print_msg("ERROR", msg, debug_level)
                 return None
 
             if object_action == "Update" and directive == "process":
                 if not exists:
-                    print(f"\n-->Blueprint {display_name} does not exist")
+                    msg = f"\n-->Update failed - Blueprint {display_name} does not exist"
+                    print_msg("ERROR", msg, debug_level)
                     return None
 
                 # call update blueprint here
 
-                print(f"\n-->Updated Blueprint {display_name} with GUID {known_guid}")
+                msg = f"\nUpdated Blueprint `{display_name}` with GUID {known_guid}"
+                print_msg("ALWAYS", msg, debug_level)
+
                 # update with get blueprint by guid
-                return 'Would return get blueprint by guid and return md' #egeria_client.get_terms_by_guid(known_guid, 'md')
+                return 'Would return get blueprint by guid and return md'  # egeria_client.get_terms_by_guid(
+                # known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md' #egeria_client.get_terms_by_guid(known_guid, 'md')
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_terms_by_guid(
+                # known_guid, 'md')
 
             elif object_action == "Create":
                 if exists:
-                    print(f"\n{WARNING}Blueprint {display_name} exists and result document updated")
-                    return update_a_command(txt, f"{object_type}{object_action}",
-                    object_type, q_name, known_guid)
+                    msg = f"\n{WARNING}Blueprint {display_name} exists and result document updated"
+                    print_msg("WARNING", msg, debug_level)
+                    return update_a_command(txt, f"{object_type}{object_action}", object_type, q_name, known_guid)
                 else:
-                   # create the blueprint
-                    #term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, term_body)
+                    # create the blueprint
+                    # term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, term_body)
                     # if term_guid == NO_ELEMENTS_FOUND:
                     #     print(f"{ERROR}Term {term_name} not created")
                     #     return None
-                    new_guid= f"guid:{get_current_datetime_string()}"
-                    print(f"\n-->Created Blueprint {display_name} with GUID {new_guid}")
+                    new_guid = f"guid:{get_current_datetime_string()}"
+                    msg = f"\nCreated Blueprint `{display_name}`with GUID {new_guid}"
+                    print_msg("ALWAYS", msg, debug_level)
+
                     update_element_dictionary(q_name, {'guid': new_guid, 'display_name': display_name})
-                    return 'Would return get blueprint by guid results as md' #egeria_client.get_terms_by_guid(term_guid, 'MD')
+                    return 'Would return get blueprint by guid results as md'  # egeria_client.get_terms_by_guid(
+                    # term_guid, 'MD')
 
         except Exception as e:
-            print(f"{ERROR}Error creating term {display_name}: {e}")
+            msg = f"{ERROR}Error creating term {display_name}: {e}"
+            print_msg("ERROR", msg, debug_level)
             console.print_exception(show_locals=True)
             return None
 
 
-
 def process_solution_component_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
-                                     directive: str = "display") -> Optional[str]:
+                                              directive: str = "display") -> Optional[str]:
     """
     Processes a solution componentt create or update command by extracting key attributes such as
     solution component name, description, version, solution component type etc from the given cell.
@@ -493,56 +661,55 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
     Returns: str
         A string summarizing the outcome of the processing.
     """
-    object_type, object_action = extract_command_plus(txt)
-    element_display = ""
-    bp_exist = True
     bp_qname_list = []
-    parent_qname_list = []
+    command, object_type, object_action = extract_command_plus(txt)
 
-    display_name = extract_attribute(txt, ['Display Name', 'Solution Component Name'])
-    description = extract_attribute(txt, ['Description'])
-    version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
-    solution_component_type = extract_attribute(txt, ['Solution Component Type'])
-    planned_deployed_implementation_type = extract_attribute(txt, ['Planned Deployment Implementation Type'])
-    solution_blueprints = extract_attribute(txt, ['Solution Blueprints'])
-    parent_components = extract_attribute(txt, ['Parent Components'])
+    display_name = process_simple_attribute(txt,['Display Name', 'Solution Component Name'] , ERROR)
+    description = process_simple_attribute(txt, ['Description'])
+    version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"])
+    solution_component_type = process_simple_attribute(txt, ['Solution Component Type'])
+    planned_deployed_implementation_type = process_simple_attribute(txt, ['Planned Deployment Implementation Type'])
+    solution_blueprints = process_simple_attribute(txt, ['Solution Blueprints'])
+    parent_components = process_simple_attribute(txt, ['Parent Components'])
 
     print(Markdown(
-        f"{pre_command}  {object_action} `{object_type}` for Solution Component: `\'{display_name}\'` with directive: `{directive}`\n"))
-
-    known_q_name, known_guid, msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
-
-    if description is None:
-        msg += f"* {INFO}Description is missing\n"
-
-    if version is None:
-        msg += f"* {INFO}Term version is missing\n"
-
-    update_description = extract_attribute(txt, ['Update Description'])
-    if update_description is None:
-        msg += f"* {INFO}Update Description is missing\n"
-        update_description = "---"
-
-    if solution_component_type is None:
-        msg += f"* {INFO}Solution Component Type is missing\n"
-
-    if planned_deployed_implementation_type is None:
-        msg += f"* {INFO}Planned Deployed Implementation Type is missing\n"
-
-    if solution_blueprints is None:
-        msg += f"* {INFO}No Solution Blueprints found\n"
-
-    else: # Find information about blueprints that include this component
-        solution_blueprints, bp_qname_list, msg, valid, exists = process_q_name_list(egeria_client,
-                                            'Solution Blueprints', txt)
+        f"{pre_command}  {object_action} `{object_type}` for Solution Component: `\'{display_name}\'` with directive: "
+        f"`{directive}`\n"))
 
+    if display_name is None:
+        valid = False
+        q_name, known_guid, exists = None
+    else:
+        element_labels = COMPONENT_NAME_LABELS
+        element_labels.append('Display Name')
+        known_q_name, known_guid, valid, exists = process_element_identifiers(egeria_client, object_type, element_labels, txt,
+                                                                              object_action, version)
+
+    if solution_blueprints:  # Find information about blueprints that include this component
+        msg = "Checking for blueprints that include this solution component"
+        print_msg("DEBUG-INFO", msg, debug_level)
+        solution_blueprints, bp_qname_list, bp_valid, bp_exist = process_q_name_list(egeria_client,
+                                                                                     'Solution Blueprints', txt, BLUEPRINT_NAME_LABELS)
+        if bp_exist and bp_valid:
+            msg = f"Found valid blueprints that include this solution component:\n\t{solution_blueprints}"
+            print_msg("INFO", msg, debug_level)
+        else:
+            msg = f"No valid blueprints that include this solution component found."
+            print_msg("INFO", msg, debug_level)
     if parent_components is None:
-        msg += f"* {INFO}Parent Components are missing\n"
+        msg = f"Parent Components are missing"
+        print_msg("INFO", msg, debug_level)
     else:
-        parent_components, parent_qname_list, msg, valid, exists = process_q_name_list(egeria_client,
-                                            'Solution Component', parent_components)
+        parent_components, parent_qname_list, parents_valid, parent_components_exist = process_q_name_list(
+            egeria_client, 'Parent Components', txt, COMPONENT_NAME_LABELS)
+        if parent_components_exist and parents_valid:
+            msg = f"Found valid parent components that include this solution component:\n\t{parent_qname_list}"
+            print_msg("INFO", msg, debug_level)
+        else:
+            msg = f"No valid parent components that include this solution component found."
+            print_msg("INFO", msg, debug_level)
 
-    element_display = (f"\n* Command: {object_action} {object_type}\n\t* Display Name: {display_name}\n\t"
+    element_display = (f"* Command: {object_action} {object_type}\n\t* Display Name: {display_name}\n\t"
                        f"* Description: {description}\n\t"
                        f"* Version Identifier: {version}\n\t"
                        f"* Solution Component Type {solution_component_type}\n\t"
@@ -550,77 +717,96 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                        f"* Solution_Blueprints: {solution_blueprints}\n\t"
                        f"* Parent Components: {parent_components}\n\t"
                        f"* Qualified Name:{known_q_name}\n\t* GUID: {known_guid} "
-                       f"\n\t* Update Description: {update_description}\n")
+                       # f"\n\t* Update Description: {update_description}"
+                       )
 
     if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
         if not exists:
-            msg += f"* {ERROR}Element {display_name} does not exist\n"
+            msg = f"Element {display_name} does not exist with input:\n"
+            print_msg("ERROR", msg, debug_level)
             valid = False
-            # element_dictionary[known_q_name] = {'display_name': display_name, 'guid': known_guid}
+        elif not valid:
+            msg = (f"\n-->Validation checks failed in updating {object_type} \'{display_name}\' with: \n"
+                   f"{element_display}")
+            print_msg("ERROR", msg, debug_level)
+        else:  # it exists and is valid
+            msg = f"\n-->It is valid to update {object_type} \'{display_name}\' with: \n"
+            print_msg("ALWAYS", msg, debug_level)
+            if known_q_name is None:
+                known_q_name = egeria_client.__create_qualified_name__(object_type, display_name,
+                                                                       version_identifier=version)
+            update_element_dictionary(known_q_name, {'display_name': display_name, 'guid': known_guid})
 
     elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
         if exists:
-            msg += f"\n{WARNING}Element \'{display_name}\' already exists.\n"
+            msg = f"{object_type} `{display_name}` already exists."
+            print_msg("ERROR", msg, debug_level)
+            valid = False
         elif not valid:
-            msg += f"\n-->Validation checks failed in creating element \'{display_name}\' with: {element_display}\n"
+            msg = f"\n-->Validation checks failed in creating element \'{display_name}\' with: \n"
+            print_msg("ERROR", msg, debug_level)
         else:  # valid to create - update element_dictionary
-            msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
+            msg = f"\n-->It is valid to create element \'{display_name}\' with: \n"
+            print_msg("ALWAYS", msg, debug_level)
             if known_q_name is None:
                 known_q_name = egeria_client.__create_qualified_name__(object_type, display_name,
                                                                        version_identifier=version)
             update_element_dictionary(known_q_name, {'display_name': display_name})
-
+    print(Markdown(element_display))
     if directive == "display":
-        print(Markdown(element_display))
         return None
     elif directive == "validate":
-        print(Markdown(msg))
-        print(Markdown(element_display))
         return valid
 
     elif directive == "process":
-        print(Markdown(msg))
         try:
             if not valid:  # First validate the term before we process it
                 return None
 
             if object_action == "Update" and directive == "process":
                 if not exists:
-                    print(f"\n-->Solution Component {display_name} does not exist")
+                    msg = (f"\n-->Solution Component {display_name} does not exist")
+                    print_msg("ERROR", msg, debug_level)
                     return None
 
                 # call update solution component here
 
-                print(f"\n-->Updated Solution Component {display_name} with GUID {known_guid}")
+                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'  # egeria_client.get_terms_by_guid(known_guid, 'md')
+                return 'Would return get Solution Component by guid and return md'  #
+                # egeria_client.get_terms_by_guid(known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
-                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_terms_by_guid(known_guid, 'md')
+                return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_terms_by_guid(
+                # known_guid, 'md')
 
             elif object_action == "Create":
                 if exists:
-                    print(f"\n{WARNING}Blueprint {display_name} exists and result document updated")
-                    return update_a_command(txt, f"{object_type}{object_action}",
-                                            object_type, known_q_name, known_guid)
+                    f"\n{WARNING}Component {display_name} exists and result document updated"
+                    print_msg("WARNING", msg, debug_level)
+                    return update_a_command(txt, f"{object_type}{object_action}", object_type, known_q_name, known_guid)
                 else:
-                    # create the blueprint
+                    # create the solution component
                     # term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, term_body)
                     # if term_guid == NO_ELEMENTS_FOUND:
                     #     print(f"{ERROR}Term {term_name} not created")
                     #     return None
 
-                    print(f"\n-->Created Solution Component {display_name} with GUID {known_guid}")
+                    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'  # egeria_client.get_terms_by_guid(term_guid, 'MD')
+                    return 'Would return get solution component by guid results as md'  #
+                    # egeria_client.get_terms_by_guid(term_guid, 'MD')
 
         except Exception as e:
-            print(f"{ERROR}Error creating term {display_name}: {e}")
+            msg = f"Error creating term {display_name}: {e}"
+            print_msg("ERROR", msg, debug_level)
             console.print_exception(show_locals=True)
             return None
 
 
-def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dictionary: dict, txt: str,
+def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
                                     directive: str = "display") -> Optional[str]:
     """
     Processes a glossary create or update command by extracting key attributes such as
@@ -631,94 +817,80 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
     :param directive: an optional string indicating the directive to be used - display, validate or execute
     :return: A string summarizing the outcome of the processing.
     """
-    command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
-
-    glossary_name = extract_attribute(txt, ['Glossary Name','Display Name'])
-    print(Markdown(f"{pre_command} `{command}` for glossary: `\'{glossary_name}\'` with directive: `{directive}` "))
-    language = extract_attribute(txt, ['Language'])
-    description = extract_attribute(txt, ['Description'])
-    usage = extract_attribute(txt, ['Usage'])
-
-    glossary_display = (f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t"
+    # command = extract_command(txt)
+    # object_type = command.split(' ')[1].strip()
+    # object_action = command.split(' ')[0].strip()
+    command, object_type, object_action = extract_command_plus(txt)
+
+    glossary_name = process_simple_attribute(txt, ['Glossary Name', 'Display Name'])
+    print(Markdown(f"{pre_command} `{object_action}` `{object_type}`  for glossary: `\'{glossary_name}\'` with directive: `{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'])
+
+    if glossary_name is None:
+        valid = False
+        known_q_name, known_guid, glossary_exists = None
+    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")
+                        f"* Usage: {usage}\n"
+                        )
 
     if object_action == 'Update':
-        q_name = extract_attribute(txt, ['Qualified Name'])
-        guid = extract_attribute(txt, ['GUID', 'guid', 'Guid'])
-        glossary_display += f"* Qualified Name: {q_name}\n\t* GUID: {guid}\n\n"
-
-    def validate_glossary(obj_action: str) -> tuple[bool, bool, Optional[str], Optional[str]]:
-
-        valid = True
-        msg = ""
-
-        known_q_name, known_guid, msg, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
-
-        if glossary_name is None:
-            msg = f"* {ERROR}Glossary name is missing\n"
+        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
-        if language is None:
-            msg += f"* {ERROR}Language is missing\n"
-            valid = False
-        if description is None:
-            msg += f"* {INFO}Description is missing\n"
-
-        if obj_action == "Update":
-
-            if not glossary_exists:
-                msg += f"* {ERROR}Glossary {glossary_name} does not exist\n"
-                valid = False
-
-            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}Glossary `{glossary_name}` qualifiedName mismatch between {q_name} and {known_q_name}\n")
-                valid = False
-            if valid:
-                msg += glossary_display
-                msg += f"* -->Glossary `{glossary_name}` exists and can be updated\n"
-                update_element_dictionary(known_q_name, {'display_name': glossary_name, 'guid': known_guid})
-            else:
-                msg += f"* --> validation failed\n"
-
-            print(Markdown(msg))
-            return valid, glossary_exists, known_guid, known_q_name
+        else:
+            msg = f"Glossary can be updated; `{glossary_name}` found"
+            print_msg(ALWAYS, msg, debug_level)
 
-        elif obj_action == "Create":
-            if glossary_exists:
-                msg += f"{ERROR}Glossary {glossary_name} already exists\n"
 
-            elif valid:
-                msg += f"-->It is valid to create Glossary \'{glossary_name}\' with:\n"
-                msg += glossary_display
-                expected_q_name = egeria_client.__create_qualified_name__('Glossary', glossary_name)
-                update_element_dictionary(expected_q_name, {'display_name': glossary_name})
+    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)
 
-            print(Markdown(msg))
-            return valid, glossary_exists, known_guid, known_q_name
 
     if directive == "display":
         print(Markdown(glossary_display))
         return None
 
     elif directive == "validate":
-        is_valid, exists, known_guid, known_q_name = validate_glossary(object_action)
-        valid = is_valid if is_valid else None
+        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":
-        is_valid, exists, known_guid, known_q_name = validate_glossary(object_action)
-        if not is_valid:
+        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 None
+
         if object_action == "Update":
-            if not exists:
+            if not glossary_exists:
                 print(
-                    f"\n{ERROR}Glossary {glossary_name} does not exist! Updating result document with Create command\n")
+                    f"\n{ERROR}Glossary `{glossary_name}` does not exist! Updating result document with Create command\n")
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
 
             body = {
@@ -728,17 +900,16 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                     }
                 }
             egeria_client.update_glossary(known_guid, body)
-            print(f"\n-->Updated Glossary {glossary_name} with GUID {known_guid}")
+            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 update_a_command(txt, command, object_type, known_q_name, known_guid)
             return egeria_client.get_glossary_by_guid(known_guid, output_format='MD')
         elif object_action == "Create":
             glossary_guid = None
 
-            if exists:
-                print(f"\nGlossary {glossary_name} already exists and result document updated\n")
+            if glossary_exists:
+                print(f"\nGlossary `{glossary_name}` already exists and result document updated\n")
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
             else:
                 glossary_guid = egeria_client.create_glossary(glossary_name, description, language, usage)
@@ -751,10 +922,11 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                     'guid': glossary_guid, 'display_name': glossary_name
                     })
                 # return update_a_command(txt, command, object_type, qualified_name, glossary_guid)
-                return egeria_client.get_glossary_by_guid(glossary_guid, output_format = 'MD')
+                print_msg(ALWAYS, f"Created Glossary `{glossary_name}` with GUID {glossary_guid}", debug_level)
+                return egeria_client.get_glossary_by_guid(glossary_guid, output_format='MD')
 
 
-def process_categories_upsert_command(egeria_client: GlossaryManager, element_dictionary: dict, txt: str,
+def process_categories_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
                                       directive: str = "display") -> Optional[str]:
     """
     Processes a glossary category create or update command by extracting key attributes such as
@@ -765,168 +937,131 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
     :param directive: an optional string indicating the directive to be used - display, validate or execute
     :return: A string summarizing the outcome of the processing.
     """
-    command = extract_command(txt)
-    object_type = command.split(' ')[1].strip()
-    object_action = command.split(' ')[0].strip()
+    valid = True
 
-    category_name = extract_attribute(txt, ['Category Name', 'category_name', 'Cat'])
+    # command = extract_command(txt)
+    # object_type = command.split(' ')[1].strip()
+    # object_action = command.split(' ')[0].strip()
+    command, object_type, object_action = extract_command_plus(txt)
+
+    category_name = process_simple_attribute(txt, ['Category Name', 'category_name', 'Cat'])
     print(Markdown(f"{pre_command} `{command}` for category: `\'{category_name}\'` with directive: `{directive}` "))
-    owning_glossary_qn = extract_attribute(txt, ['Owning Glossary', '[In Glossary'])
-    description = extract_attribute(txt, ['Description'])
-    q_name = extract_attribute(txt, ['Qualified Name'])
 
-    category_display = (f"\n* Command: {command}\n\t* Category: {category_name}\n\t* In Glossary: {owning_glossary_qn}\n\t"
-                        f"* Description:\n{description}\n\t* Qualified Name: {q_name}\n\t")
-    update_description = None
+    owning_glossary_name = extract_attribute(txt, ['Owning Glossary', 'In Glossary'])
+    description = process_simple_attribute(txt, ['Description'])
+    q_name = process_simple_attribute(txt, ['Qualified Name'])
 
-    if object_action == 'Update':
-        guid = extract_attribute(txt, ['GUID','guid','Guid'])
-        update_description = extract_attribute(txt, 'Update Description')
-        category_display += (f"* GUID: {guid}\n\n"
-                             f"* Update Description: \n {update_description}\n\t")
-
-    def validate_category(obj_action: str) -> tuple[bool, bool, Optional[str], Optional[str], Optional[str]]:
-        valid = True
-        msg = ""
-        known_category_guid = None
-        known_q_name = None
-        glossary_guid = None
+    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)
 
-        category_details = egeria_client.get_categories_by_name(category_name)
-        if category_details == NO_CATEGORIES_FOUND:
-            category_exists = False
-        else:
-            category_exists = True
 
-        if owning_glossary_qn is None:
-            msg += f"* {ERROR}Owning Glossary Qualified Name is missing\n"
-            valid = False
+    # 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)
 
-        elif owning_glossary_qn in get_element_dictionary():  # Check to see if we already know about this glossary
-            element_dict = get_element_dictionary()
-            glossary_name = element_dict[owning_glossary_qn].get('display_name', None)
-            glossary_guid = element_dict[owning_glossary_qn].get('guid', None)
+    category_display = (
+        f"\n* Command: {command}\n\t* Category: {category_name}\n\t* In Glossary: {owning_glossary_name}\n\t"
+        f"* Description:\n{description}\n\t* Qualified Name: {q_name}\n\t")
 
-        else:
-            # need to ask Egeria if it knows the Glossary Name
-            glossary = egeria_client.get_glossaries_by_name(owning_glossary_qn)
-            if glossary == NO_GLOSSARIES_FOUND:
-                msg += f"* {ERROR}Glossary `{owning_glossary_qn}` does not exist\n\n"
-                valid = False
-            else:
-                msg += f"* {INFO}Glossary `{owning_glossary_qn}` exists\n\n"
-                glossary_guid = glossary[0]['elementHeader'].get('guid', None)
-                glossary_name = glossary[0]['glossaryProperties'].get('displayName', None)
-                glossary_qn = glossary[0]['glossaryProperties'].get('qualifiedName', None)
-                if glossary_qn != owning_glossary_qn: # we were given the right qualified name - maybe a display_name
-                    msg += f"* {ERROR}Glossary `{owning_glossary_qn}` is known by qualifiedName `{glossary_qn}`\n\n"
-                    valid = False
-                else:
-                    update_element_dictionary(owning_glossary_qn, {
-                        'guid': glossary_guid, 'display_name': glossary_name
-                        })
 
-        if category_name is None:
-            msg = f"* {ERROR}Category name is missing\n"
+    if object_action == 'Update':
+        guid = process_simple_attribute(txt, ['GUID', 'guid', 'Guid'])
+        # update_description = process_simple_attribute(txt, 'Update Description')
+        category_display += (f"* GUID: {guid}\n\n")
+        if not category_exists:
+            msg = f"Category {category_name} can't be updated; {category_name} not found."
+            print_msg(ERROR, msg, debug_level)
             valid = False
+        else:
+            msg = f"Glossary can be updated; {category_name} found"
+            print_msg(ALWAYS, msg, debug_level)
 
-        if description is None:
-            msg += f"* {INFO}Description is missing\n"
-
-        if len(category_details) > 1 and category_exists:
-            msg += f"* {ERROR}More than one category with name `{category_name}` found\n"
+    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
-        if len(category_details) == 1:
-            known_category_guid = category_details[0]['elementHeader'].get('guid', None)
-            known_q_name = category_details[0]['glossaryCategoryProperties'].get('qualifiedName', None)
-
-        if obj_action == "Update":
-            if not category_exists:
-                msg += f"* {ERROR}category `{category_name}` does not exist\n"
-                valid = False
-            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}category `{category_name}` qualifiedName mismatch between {q_name} and {known_q_name}\n")
-                valid = False
-            if valid:
-                msg += category_display
-                msg += f"* -->category `{category_name}` exists and can be updated\n"
-                update_element_dictionary(known_q_name, {'display_name': glossary_name, 'guid': known_category_guid})
-            else:
-                msg += f"* --> validation failed\n"
-
-            print(Markdown(msg))
-            return valid, category_exists, known_category_guid, known_q_name, glossary_guid
-
-        elif obj_action == "Create":
-            if category_exists:
-                msg += f"{ERROR}category `{category_name}` already exists\n"
-
-            elif valid:
-                msg += f"-->It is valid to create category `{category_name}` with:\n"
-                msg += category_display
-                expected_q_name = egeria_client.__create_qualified_name__('Category', category_name)
-                update_element_dictionary(expected_q_name, {'display_name': category_name})
-
-            print(Markdown(msg))
-            return valid, category_exists, known_category_guid, known_q_name, glossary_guid
+        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":
-        is_valid, exists, known_guid, known_q_name, glossary_guid = validate_category(object_action)
-        valid = is_valid if is_valid else None
+        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":
-        is_valid, exists, known_guid, known_q_name, glossary_guid = validate_category(object_action)
-        if not is_valid:
-            print(f"{ERROR}Validation checks failed in creating category `{category_name}`")
+        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 None
 
         if object_action == "Update":
-            if not exists:
-                print(
-                    f"\n{ERROR}category `{category_name}` does not exist! Updating result document with Create "
-                    f"command\n")
+            if not category_exists:
+                print(f"\n{ERROR}category `{category_name}` does not exist! Updating result document with Create "
+                      f"command\n")
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
 
-            egeria_client.update_category(glossary_guid, category_name, description, known_q_name, None,
-                                          update_description)
-            print(f"\n-->Updated category `{category_name}`with GUID {known_guid}")
+            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_element_dictionary(known_q_name, {
                 'guid': known_guid, 'display_name': category_name
                 })
-            # return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            print_msg(ALWAYS, f"Updated Category `{category_name}` with GUID {known_guid}", debug_level)
             return egeria_client.get_categories_by_guid(known_guid, output_format='FORM')
 
         elif object_action == "Create":
-            is_root = False
+            is_root = True
 
-            if exists:
-                print(f"\ncategory `{category_name}` already exists and result document updated\n")
+            if category_exists:
+                msg = f"Cannot create`{category_name}` because it already exists; result document written for category update\n"
+                print_msg(WARNING, msg, debug_level)
                 return update_a_command(txt, command, object_type, known_q_name, known_guid)
             else:
-                category_guid = egeria_client.create_category(glossary_guid, category_name, description, is_root)
-                category = egeria_client.get_categories_by_guid(category_guid)
+                category_guid = egeria_client.create_category(known_glossary_guid, category_name, description, is_root)
+                category_details = egeria_client.get_categories_by_guid(category_guid)
 
-                if category == NO_CATEGORIES_FOUND:
-                    print(f"{ERROR}Just created with GUID {category_guid} but category not found\n")
+                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['glossaryCategoryProperties']["qualifiedName"]
+
+                qualified_name = category_details['glossaryCategoryProperties']["qualifiedName"]
                 update_element_dictionary(qualified_name, {
                     'guid': category_guid, 'display_name': category_name
                     })
-                # return update_a_command(txt, command, object_type, qualified_name, category_guid)
+                print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
                 return egeria_client.get_categories_by_guid(category_guid, output_format='MD')
 
 
-def process_term_upsert_command(egeria_client: GlossaryManager, element_dictionary: dict, txt: str,
+def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
                                 directive: str = "display") -> Optional[str]:
     """
     Processes a term create or update command by extracting key attributes such as
@@ -937,276 +1072,154 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
     :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
 
+    known_q_name = None
     command = extract_command(txt)
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    term_name = extract_attribute(txt, ['Term Name','Display Name'])
-    summary = extract_attribute(txt, ['Summary'])
-    description = extract_attribute(txt, ['Description'])
-    abbreviation = extract_attribute(txt, ['Abbreviation'])
-    examples = extract_attribute(txt, ['Examples'])
-    usage = extract_attribute(txt, ['Usage'])
-    status = extract_attribute(txt, ['Status'])
-    version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
-    categories = extract_attribute(txt, ['Categories'])
-    q_name = extract_attribute(txt, ['Qualified Name'])
-    # q_name = q_name if q_name else " "
-
-    categories_list = None
-    cats_exist = True
-
-    glossary_qn = extract_attribute(txt, ['In Glossary','Owning Glossary'])
-
-    print(Markdown(f"{pre_command} `{command}` for term: `\'{term_name}\'` with directive: `{directive}`"))
-
-    def validate_term(obj_action: str) -> tuple[bool, bool, Optional[str], Optional[str]]:
-        nonlocal version, status, categories, categories_list, cats_exist, q_name, glossary_qn
-        valid = True
-        msg = ""
-        known_term_guid = None
-        known_q_name = None
-
-        # If the user has specified a qualified_name then use it to look for matching terms.
-        # If not, use the display_name.
-        if q_name:
-            term_details = egeria_client.get_terms_by_name(q_name)
-        else:
-            term_details = egeria_client.get_terms_by_name(term_name)
-
-        if term_details == NO_TERMS_FOUND:
-            term_exists = False
-        else:
-            term_exists = True
-
-        if status is None:
-            msg += f"* {INFO}Term status is missing - will default to DRAFT\n"
-            status = 'DRAFT'
-
-
-        if term_name is None:
-            msg = f"* {ERROR}Term name is missing\n"
-            valid = False
-        if glossary_qn is None:
-            msg += f"* {ERROR}Glossary qualified name is missing\n"
-            valid = False
-        else:
-            print(f"* {INFO}Glossary qualified name is `{glossary_qn}`")
-            element_dict = get_element_dictionary()
-            if glossary_qn not in element_dict:
-                glossary = egeria_client.get_glossaries_by_name(glossary_qn) #assuming q_name?
-                if isinstance(glossary,str):
-                    msg += f"* {ERROR}Glossary `{glossary_qn}` is unknown\n "
-                    valid = False
-                elif len(glossary) != 1:
-                    msg += f"* {ERROR}Glossary `{glossary_qn}` is ambiguous or not found\n "
-                    valid = False
-                else:
-                    glossary_qn = glossary[0]['glossaryProperties'].get('qualifiedName', None)
-                    if glossary_qn is None:
-                        msg += f"* {ERROR}Glossary `{glossary_qn}` has no qualifiedName\n "
-                        valid = False
-                    else:
-                        update_element_dictionary(glossary_qn, {
-                        'guid': glossary[0]['elementHeader'].get('guid', None),
-                        'display_name': glossary[0]['glossaryProperties'].get('displayName', None)
-                        })
+    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'])
+
+    # 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)
 
 
-        if categories is None:
-            msg += f"* {INFO} No categories found\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, cat_valid, cat_exist = process_q_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:
-            categories_list = re.split(r'[,\n]+', categories)
-            categories = ""
-            new_cat_list = []
-            for category in categories_list:
-                category_el = category.strip()
-                element_dict = get_element_dictionary()
-                if category_el not in element_dict:
-                    cat = egeria_client.get_categories_by_name(category_el) # assuming qualified name?
-                    if isinstance(cat,str):
-                        msg += (f"* {WARNING}Category `{category_el}` not found -> "
-                                f"categories for this term won't be processed!\n")
-                        cats_exist = False
-                        break
-                    cat_qname = cat[0]['glossaryCategoryProperties'].get('qualifiedName', None)
-                    category = cat_qname # use the qualified name if found
-                    if cat_qname not in element_dict:
-                        cat_guid = cat[0]['elementHeader']['guid']
-                        cat_display_name = cat[0]['glossaryCategoryProperties'].get('displayName', None)
-                        update_element_dictionary(cat_qname, {
-                            'guid' : cat_guid,
-                            'displayName': cat_display_name
-                            })
-                categories = f"{category}, {categories}"
-                new_cat_list.append(category)
-            if cats_exist:
-                categories +='\n'
-                categories_list = new_cat_list
-            else:
-                categories = None
-
-
-        if summary is None:
-            msg += f"* {INFO}Term summary is missing\n"
-
-        if description is None:
-            msg += f"* {INFO}Term description is missing\n"
-
-        if abbreviation is None:
-            msg += f"* {INFO}Term abbreviation is missing\n"
-        if examples is None:
-            msg += f"* {INFO}Term examples is missing\n"
-        if usage is None:
-            msg += f"* {INFO}Term usage is missing\n"
-        if version is None:
-            msg += f"* {INFO}Term version is missing\n"
-            # version = "0.0.1"
-
-
-        if obj_action == "Update":  # check to see if provided information exists and is consistent with existing info
-            if not term_exists:
-                msg += f"* {ERROR}Term {term_name} does not exist\n"
-                valid = False
-
-            if len(term_details) > 1 and term_exists:
-                msg += (f"* {ERROR}More than one term with name {term_name} found, please specify a "
-                        f"**Qualified Name**\n")
-                valid = False
-            elif len(term_details) == 1:
-                known_term_guid = term_details[0]['elementHeader'].get('guid', None)
-                known_q_name = term_details[0]['glossaryTermProperties'].get('qualifiedName', None)
-            if q_name != known_q_name:
-                msg += (f"* {ERROR}Term {term_name} qualifiedName mismatch between {q_name} and {known_q_name}\n")
-                valid = False
-            else:
-                msg += f"\n--> * Term {term_name} exists and can be updated\n"
-                msg += term_display
-                update_element_dictionary(known_q_name, {'display_name': term_name, 'guid': known_term_guid})
-
-            print(Markdown(msg))
-            return valid, term_exists, known_term_guid, known_q_name
-
-        elif obj_action == 'Create':  # if the command is create, check that it doesn't already exist
-            if term_exists:
-                msg += f"\n{WARNING}Term \'{term_name}\' already exists.\n"
-            elif not valid:
-                msg += f"\n-->Validation checks failed in creating Term \'{term_name}\' with: {term_display}\n"
-            else:
-                msg += f"\n-->It is valid to create Term \'{term_name}\' with: {term_display}\n"
-                if q_name is None:
-                    expected_q_name = egeria_client.__create_qualified_name__('Term',
-                                                                              term_name, version_identifier=version)
-                    update_element_dictionary(expected_q_name, {'display_name': term_name})
-                else:
-                    update_element_dictionary(q_name, {'display_name': term_name})
-            print(Markdown(msg))
-            return valid, term_exists, known_term_guid, known_q_name
+            msg = "No valid glossary categories found."
+            print_msg("INFO", msg, debug_level)
+    else:
+        cat_exist = cat_valid = False
+        cat_q_name_list = None
 
-    # Continue processing the upsert
-    if object_action == "Update":
-        term_guid = extract_attribute(txt, 'GUID')
-        term_guid = term_guid if term_guid else None
 
 
-        update_description = extract_attribute(txt, 'Update Description')
-        update_description = update_description if update_description else " "
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
+    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}\n\t* Qualified Name: "
-                        f"{q_name}"
+                        f"* Version: {version}\n\t* Status: {status}\n\t* GUID: {term_guid}"
                         f"\n\t* Update Description: {update_description}\n")
-    else:
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
+        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* 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":
-        is_valid, exists, known_guid, known_q_name = validate_term(object_action)
-        valid = is_valid if is_valid else None
+        print(Markdown(term_display))
         return valid
     elif directive == "process":
         try:
-            is_valid, exists, known_guid, known_q_name = validate_term(object_action)
-            if not is_valid:  # First validate the term before we process it
+            if not valid:  # First validate the term before we process it
                 return None
 
             if object_action == "Update" and directive == "process":
-                if not exists:
-                    print(f"\n-->Term {term_name} does not exist")
+                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
+                    "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 cats_exist is True and categories_list is not None:
-                #     for category in categories_list:
-                #         cat_guid = element_dictionary.get(f"category.{category}", None)
-                #         if cat_guid is None:
-                #             cat_guid = egeria_client.__get_guid__(display_name=category)
-                #         egeria_client.add_term_to_category(known_guid, cat_guid)
-                add_term_to_categories(
-                    egeria_client, known_guid, cats_exist , categories_list,
-                    element_dictionary)
-                print(f"\n-->Updated Term {term_name} with GUID {known_guid} and categories {categories_list}")
-                return egeria_client.get_terms_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":
+                if cat_exist and cat_valid:
+                    add_term_to_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_terms_by_guid(known_guid,
+                                                       'md')  # return update_a_command(txt, command, object_type,
+                # known_q_name, known_guid)
+            elif object_action == "Update" and directive == "validate": # is sthis reachable?
                 return egeria_client.get_terms_by_guid(known_guid, 'md')
 
             elif object_action == "Create":
-                guid = None
-                if q_name is None:
-                    q_name = egeria_client.__create_qualified_name__("Term",term_name,
-                                                                     version_identifier=version)
-                if exists:
-                    print(f"\n{WARNING}Term {term_name} exists and result document updated")
+                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 locally
-                    glossary = get_element_dictionary().get(glossary_qn, None)
+                    ## get the guid for the glossary from the name - first look in cache
+                    cached = get_element_dictionary().get(known_glossary_q_name, None)
 
-                    if glossary is not None:
-                        glossary_guid = glossary.get('guid', None)
+                    if cached is not None:
+                        glossary_guid = cached.get('guid', None)
                         if glossary_guid is None:
-                            print(f"{ERROR}Glossary reference {glossary_qn} not found")
+                            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=glossary_qn)
+                        glossary_guid = egeria_client.__get_guid__(qualified_name=known_glossary_q_name)
                         if glossary_guid == NO_ELEMENTS_FOUND:
-                            print(f"{ERROR}Glossary {glossary_qn} not 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": q_name,
-                            "displayName": term_name,
-                            "summary": summary,
-                            "description": description,
-                            "abbreviation": abbreviation,
-                            "examples": examples,
-                            "usage": usage,
-                            "publishVersionIdentifier": version
+                            "class": "GlossaryTermProperties", "qualifiedName": known_q_name, "displayName": term_name,
+                            "summary": summary, "description": description, "abbreviation": abbreviation,
+                            "examples": examples, "usage": usage, "publishVersionIdentifier": version
                             # "additionalProperties":
                             #     {
                             #         "propertyName1": "xxxx",
@@ -1214,23 +1227,23 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
                             #         }
                             }, "initialStatus": status
                         }
-                    term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, term_body)
+                    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:
-                        add_term_to_categories(
-                        egeria_client, term_guid, cats_exist, categories_list,
-                        element_dictionary)
-                    print(f"\n-->Created Term {term_name} with GUID {term_guid}")
-                    update_element_dictionary(q_name, {'guid': term_guid, 'display_name': term_name})
-                    return egeria_client.get_terms_by_guid(term_guid, 'MD')
-                    # return update_a_command(txt, command, object_type, q_name, term_guid)
+                        add_term_to_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_terms_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}")
             console.print_exception(show_locals=True)
             return None
 
+
 def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dictionary: dict, txt: str,
                                     directive: str = "display") -> str | None:
     """
@@ -1247,14 +1260,14 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
     object_type = f"{object[1]} {object[2]}"
     object_action = object[0]
 
-    project_name = extract_attribute(txt, ['Project Name'])
-    description = extract_attribute(txt, ['Description'])
-    project_identifier = extract_attribute(txt, ['Project Identifier'])
-    project_status = extract_attribute(txt, ['Project Status'])
-    project_phase = extract_attribute(txt, ['Project Phase'])
-    project_health = extract_attribute(txt, ['Project Health'])
-    start_date = extract_attribute(txt, ['Start Date'])
-    planned_end_date = extract_attribute(txt, ['Planned End Date'])
+    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"
@@ -1305,7 +1318,7 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
             valid = False
 
         if obj_action == "Update":
-            q_name = extract_attribute(txt, 'Qualified Name')
+            q_name = process_simple_attribute(txt, 'Qualified Name')
 
             if not project_exists:
                 msg += f"* {ERROR}Project {project_name} does not exist\n"
@@ -1360,12 +1373,12 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
             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(f"\n-->Updated Project {project_name} with GUID {known_guid}")
+            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")
+                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,
@@ -1378,4 +1391,5 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
 
                 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)