pyegeria 5.3.5.3__tar.gz → 5.3.6.1__tar.gz

{pyegeria-5.3.5.3 → pyegeria-5.3.6.1}/PKG-INFO

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

pyegeria-5.3.5.3/pyegeria/commands/cat/freddie_jupyter.py → pyegeria-5.3.6.1/pyegeria/commands/cat/freddie_jup.py

@@ -2,7 +2,7 @@
 This is an ongoing experiment in parsing and playing with Freddie docs
 """
 import json
-
+import marko
 from jupyter_notebook_parser import JupyterNotebookParser
 import nbformat
 import os

pyegeria-5.3.6.1/pyegeria/commands/cat/freddie_jupyter.py

@@ -0,0 +1,131 @@
+"""
+This is an ongoing experiment in parsing and playing with Freddie docs
+"""
+import json
+
+from jupyter_notebook_parser import JupyterNotebookParser
+import nbformat
+import os
+import re
+from pyegeria import EgeriaTech
+from rich import box, print
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+from rich.table import Table
+from freddie_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
+                        get_current_datetime_string, process_per_proj_upsert_command, commands)
+import click
+from pyegeria import EgeriaTech, body_slimmer, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    print_exception_response,
+)
+from datetime import datetime
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_WIDTH = os.environ.get("EGERIA_WIDTH", 220)
+EGERIA_JUPYTER = os.environ.get("EGERIA_JUPYTER", False)
+EGERIA_HOME_GLOSSARY_GUID = os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None)
+EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
+EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
+EGERIA_FREDDIE_INBOX_PATH = os.environ.get("EGERIA_FREDDIE_INBOX_PATH", "pyegeria/commands/cat/freddies-inbox")
+EGERIA_FREDDIE_OUTBOX_PATH = os.environ.get("EGERIA_FREDDIE_OUTBOX_PATH", "pyegeria/commands/cat/freddies-outbox")
+
+console = Console(width=int(EGERIA_WIDTH))
+
+
+
+@click.command("process-jupyter")
+@click.option("--file-path", help="File path to notebook",
+              default="glossary_creation_experiment.ipynb")
+@click.option("--directive", default="display-only", help="How to process the file")
+@click.option("--server", default=EGERIA_VIEW_SERVER, help="Egeria view server to use.")
+@click.option(
+    "--url", default=EGERIA_VIEW_SERVER_URL, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--user_pass", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+def process_jupyter_notebook(
+        file_path: str,
+        directive: str,
+        server: str,
+        url: str,
+        userid: str,
+        user_pass: str,
+        ):
+    client = EgeriaTech(server, url, user_id=userid)
+    token = client.create_egeria_bearer_token(userid, user_pass)
+
+    element_dictionary = {}
+
+    try:
+        updated = False
+        full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_FREDDIE_INBOX_PATH, file_path)
+        click.echo(f"Processing notebook: {full_file_path}")
+        with open(full_file_path, 'r') as f:
+            nb = nbformat.read(f, as_version=4)
+            for cell in nb.cells:
+                if cell.cell_type == 'markdown':
+                    if cell.source.strip().startswith('#'):
+                        potential_command = extract_command(cell.source)
+                        if potential_command in commands:
+                            if potential_command in ["Create Glossary", "Update Glossary"]:
+                                result = process_glossary_upsert_command(client, element_dictionary,
+                                                                         cell.source, directive)
+
+                            elif potential_command in ["Create Term", "Update Term"]:
+                                result = process_term_upsert_command(client, element_dictionary,
+                                                                     cell.source, directive)
+                            elif potential_command in ["Create Personal Project", "Update Personal Project"]:
+                                result = process_per_proj_upsert_command(client, element_dictionary, cell.source, directive)
+                            else:
+                                # If command is not recognized, copy the block as-is
+                                result = None
+
+                            if result:
+                                if directive == "process":
+                                    updated = True
+                                    cell.source = result
+                                    # print(json.dumps(element_dictionary, indent=4))
+                            elif directive == "process":
+                                # Handle case with errors (skip this block but notify the user)
+                                print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"
+                                      f"\tPlease correct and try again. \n")
+
+
+        if updated:
+            path, filename = os.path.split(file_path)  # Get both parts
+            new_filename = f"processed-{get_current_datetime_string()}-{filename}"  # Create the new filename
+            new_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_FREDDIE_OUTBOX_PATH, new_filename)  # Construct the new path
+            os.makedirs(os.path.dirname(new_file_path), exist_ok=True)
+
+
+            with open(new_file_path, 'w') as f2:
+                nbformat.write(nb, f2)
+            click.echo(f"\n==>Notebook written to {new_file_path}")
+        else:
+            click.echo("\nNo updates detected. New file not created.")
+
+    except Exception as e:
+        print_exception_response(e)
+        return
+
+
+if __name__ == "__main__":
+    process_jupyter_notebook()

{pyegeria-5.3.5.3 → pyegeria-5.3.6.1}/pyegeria/commands/cat/freddie_md.py

@@ -17,13 +17,13 @@ from freddie_utils import (extract_command, process_glossary_upsert_command, pro
                         get_current_datetime_string, process_per_proj_upsert_command, commands)
 
 import click
-from pyegeria import EgeriaTech, body_slimmer, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND
+from pyegeria import EgeriaTech, body_slimmer, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND
 from pyegeria._exceptions import (
     InvalidParameterException,
     PropertyServerException,
     print_exception_response,
 )
-import datetime
+from datetime import datetime
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
@@ -44,9 +44,10 @@ EGERIA_WIDTH = os.environ.get("EGERIA_WIDTH", 220)
 EGERIA_JUPYTER = os.environ.get("EGERIA_JUPYTER", False)
 EGERIA_HOME_GLOSSARY_GUID = os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None)
 EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
-EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-workspaces")
-EGERIA_FREDDIE_INBOX_PATH = os.environ.get("EGERIA_FREDDIE_INBOX_PATH", "exchange/loading-bay/freddies-inbox")
-EGERIA_FREDDIE_OUTBOX_PATH = os.environ.get("EGERIA_FREDDIE_OUTBOX_PATH", "exchange/distribution-hub/freddies-outbox")
+EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
+EGERIA_FREDDIE_INBOX_PATH = os.environ.get("EGERIA_FREDDIE_INBOX_PATH", "pyegeria/commands/cat/freddies-inbox")
+EGERIA_FREDDIE_OUTBOX_PATH = os.environ.get("EGERIA_FREDDIE_OUTBOX_PATH", "pyegeria/commands/cat/freddies-outbox")
+
 console = Console(width=int(EGERIA_WIDTH))
 
 
@@ -54,7 +55,7 @@ console = Console(width=int(EGERIA_WIDTH))
 @click.command("process-markdown-file", help="Process a markdown file and return the output as a string.")
 @click.option("--file-path", help="File path to markdown file",
               default="glossary_exp.md")
-@click.option("--directive", default="display", help="How to process the file")
+@click.option("--directive", default="display-only", help="How to process the file")
 @click.option("--server", default=EGERIA_VIEW_SERVER, help="Egeria view server to use.")
 @click.option(
     "--url", default=EGERIA_VIEW_SERVER_URL, help="URL of Egeria platform to connect to"
@@ -69,6 +70,7 @@ def process_markdown_file(
         userid: str,
         user_pass: str,
         ):
+
     client = EgeriaTech(server, url, user_id=userid)
     token = client.create_egeria_bearer_token(userid, user_pass)
 
@@ -82,9 +84,12 @@ def process_markdown_file(
         print(f"Error: File not found at path: {full_file_path}")
         return {}  # Return empty dict if file not found
 
+    final_output = (f"\n# Results from processing file {file_path} on "
+                    f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n---\n")
     h1_blocks = []
     current_block = ""
     in_h1_block = False
+    element_dictionary = {}
 
     for line in lines:
         line = line.strip()  # Remove leading/trailing whitespace
@@ -100,57 +105,55 @@ def process_markdown_file(
             in_h1_block = False
         elif in_h1_block:  # Add line to the current H1 block
             current_block += "\n" + line
+        else:
+            # Add non-H1 blocks directly to the final output
+            final_output += line
 
     if current_block:  # Add the last H1 block
         h1_blocks.append(current_block)
 
-    processed_blocks = ''
+    # Process each identified H1 block
     for block in h1_blocks:
-        potential_command = extract_command(block)
+        potential_command = extract_command(block)  # Extract potential command
 
         if potential_command in commands:
+            # Process the block based on the command
             if potential_command in ["Create Glossary", "Update Glossary"]:
-                result = process_glossary_upsert_command(client, block, directive)
-                if result:
-                     if directive == "process":
-                        updated = True
-                        processed_blocks += f'\n---\n{result} \n---\n'
-                else:
-                    print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"
-                          f"\tPlease correct and try again. \n")
-                    continue
-            if potential_command in ["Create Term", "Update Term"]:
-                result = process_term_upsert_command(client, block, directive)
-                if result:
-                    if directive == "process":
-                        updated = True
-                        processed_blocks += f'\n---\n{result} \n---\n\n'
-                else:
-                    print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"
-                          f"\tPlease correct and try again. \n")
-                    continue
-
-            if potential_command in ["Create Personal Project", "Update Personal Project"]:
-                result = process_per_proj_upsert_command(client, block, directive)
-                if result:
-                    if directive == "process":
-                        updated = True
-                        processed_blocks += f'\n---\n{result} \n---\n\n'
-                else:
-                    print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"
-                          f"\tPlease correct and try again. \n")
-                    continue
-
+                result = process_glossary_upsert_command(client, element_dictionary, block, directive)
+            elif potential_command in ["Create Term", "Update Term"]:
+                result = process_term_upsert_command(client, element_dictionary, block, directive)
+            elif potential_command in ["Create Personal Project", "Update Personal Project"]:
+                result = process_per_proj_upsert_command(client, element_dictionary, block, directive)
+            else:
+                # If command is not recognized, copy the block as-is
+                result = None
+
+            if result:
+                if directive == "process":
+                    updated = True
+                    final_output += f"\n---\n{result}\n---\n\n"
+                    # print(json.dumps(element_dictionary, indent=4))
+            elif directive == "process":
+                # Handle case with errors (skip this block but notify the user)
+                print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"
+                      f"\tPlease correct and try again. \n")
+                final_output += f"\n---\n{block}\n---\n\n"
+        else:
+            # If no command is detected, add the block to the final output as-is
+            final_output += f"\n---\n{block}\n---\n\n"
+
+    # Write the final_output to a new file if updated
     if updated:
         path, filename = os.path.split(file_path)  # Get both parts
         new_filename = f"processed-{get_current_datetime_string()}-{filename}"  # Create the new filename
         new_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_FREDDIE_OUTBOX_PATH, new_filename)  # Construct the new path
         os.makedirs(os.path.dirname(new_file_path), exist_ok=True)
 
-
         with open(new_file_path, 'w') as f2:
-            f2.write(processed_blocks)
-        click.echo(f"\n==>Notebook written to {new_file_path}")
+            f2.write(final_output)
+        click.echo(f"\n==> Notebook written to {new_file_path}")
+    else:
+        click.echo("\nNo updates detected. New File not created.")
 
 
 

{pyegeria-5.3.5.3 → pyegeria-5.3.6.1}/pyegeria/commands/cat/freddie_utils.py

@@ -30,6 +30,7 @@ commands = ["Create Glossary", "Update Glossary",
 ERROR = "ERROR-> "
 INFO = "INFO- "
 WARNING = "WARNING-> "
+pre_command = "\n---\n==> Processing command:"
 
 def is_valid_iso_date(date_text) -> bool:
     """Checks if the given string is a valid ISO date."""
@@ -65,22 +66,30 @@ def extract_attribute (text: str, label: str) -> str | None:
         """
     pattern = r"## " + re.escape(label) + r"\n(.*?)(?:##|$)"  # Construct pattern
     match = re.search(pattern, text, re.DOTALL)
-    if match:
-        return match.group(1).strip()
+    if match and not match.group(1).isspace():
+        txt =match.group(1).strip()
+        return txt
     return None
 
 def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid: str)->str:
     u_guid = u_guid if u_guid else " "
-    txt = txt.replace(f"{command}", f'**Update {obj_type}**\n')  # update the command
+    verb = command.split(' ')[0].strip()
+    action = "Update" if (verb == "Create" and u_guid is not None) else "Create"
+    txt = txt.replace(f"{command}", f'**{action} {obj_type}**\n')  # update the command
     txt = txt.replace('<GUID>', f'**GUID**\n{u_guid}')  # update with GUID
     txt = txt.replace('<Qualified Name>', f"**Qualified Name**\n{q_name}")
+    if "Qualified Name" not in txt:
+        txt += f"\n## **Qualified Name**\n{q_name}\n"
+    if "GUID" not in txt:
+        txt += f"\n## **GUID**\n{u_guid}\n"
     # if command == "Update Term":
     #     txt = txt.replace('Update Description', f"**Update Description**\n")
     return txt
 
 
 
-def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display" ) -> str | None:
+def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
+                                    directive: str = "display" ) -> str | None:
     """
     Processes a glossary create or update command by extracting key attributes such as
     glossary name, language, description, and usage from the given cell.
@@ -95,15 +104,17 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
     object_action = command.split(' ')[0].strip()
 
     glossary_name = extract_attribute(txt, 'Glossary Name')
-    print(f"\n==> Processing command: {command} for glossary: {glossary_name} with directive: {directive} ")
+    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: {glossary_name}\n\t"
-                        f"* Language: {language}\n\t* Description: {description}\n\t"
-                        f"* Usage: {usage}")
+                        f"* Language: {language}\n\t* Description:\n{description}\n"
+                        f"* Usage: {usage}\n"
+                        f"* Qualified Name: <Qualified Name>\n"
+                        f"* GUID: <GUID>\n\n")
 
-    def validate_glossary(obj_action: str) -> tuple[bool, bool, str]:
+    def validate_glossary(obj_action: str) -> tuple[bool, bool, str | None, str | None]:
         valid = True
         msg = ""
         known_glossary_guid = None
@@ -124,18 +135,25 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
         if description is None:
             msg += f"* {INFO}Description is missing\n"
 
+        if len(glossary_details) > 1 and glossary_exists:
+            msg += f"* {ERROR}More than one glossary with name {glossary_name} found\n"
+            valid = False
+        if len(glossary_details) == 1:
+            known_glossary_guid = glossary_details[0]['elementHeader'].get('guid', None)
+            known_q_name = glossary_details[0]['glossaryProperties'].get('qualifiedName', None)
+
         if obj_action == "Update":
             q_name = extract_attribute(txt, 'Qualified Name')
 
             if not glossary_exists:
                 msg += f"* {ERROR}Glossary {glossary_name} does not exist\n"
                 valid = False
-            if len(glossary_details) > 1 and glossary_exists:
-                msg += f"* {ERROR}More than one glossary with name {glossary_name} found\n"
-                valid = False
-            if len(glossary_details) == 1:
-                known_glossary_guid = glossary_details[0]['elementHeader'].get('guid', None)
-                known_q_name = glossary_details[0]['glossaryProperties'].get('qualifiedName',None)
+            # if len(glossary_details) > 1 and glossary_exists:
+            #     msg += f"* {ERROR}More than one glossary with name {glossary_name} found\n"
+            #     valid = False
+            # if len(glossary_details) == 1:
+            #     known_glossary_guid = glossary_details[0]['elementHeader'].get('guid', None)
+            #     known_q_name = glossary_details[0]['glossaryProperties'].get('qualifiedName',None)
             if q_name is None:
                 msg += f"* {INFO}Qualified Name is missing => can use known qualified name of {known_q_name}\n"
                 valid = True
@@ -147,16 +165,18 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 msg += f"* -->Glossary {glossary_name} exists and can be updated\n"
             else:
                 msg += f"* --> validation failed\n"
-            msg+='---'
+
             print(Markdown(msg))
             return valid, glossary_exists, known_glossary_guid, known_q_name
 
         elif obj_action == "Create":
             if glossary_exists:
-                msg += f"{ERROR}Glossary {glossary_name} already exists"
-                valid = False
-            else:
+                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
+
             print(Markdown(msg))
             return valid, glossary_exists, known_glossary_guid, known_q_name
 
@@ -175,8 +195,9 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
             return None
         if object_action == "Update":
             if not exists:
-                print(f"\n-->Glossary {glossary_name} does not exist")
-                return None
+                print(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 = {
                 "class": "ReferenceableRequestBody",
                 "elementProperties":
@@ -190,26 +211,32 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 }
             egeria_client.update_glossary(known_guid, body)
             print(f"\n-->Updated Glossary {glossary_name} with GUID {known_guid}")
+            element_dictionary[f"glossary.{glossary_name}"] = {'guid' : known_guid,
+                                                               'q_name' : known_q_name
+                                                              }
             return update_a_command(txt, command, object_type, known_q_name, known_guid)
         elif object_action == "Create" :
             guid = None
-            q_name = f"Glossary:{glossary_name}:{get_current_datetime_string()}"
 
             if exists:
-                print(f"Glossary {glossary_name} already 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:
                 guid = egeria_client.create_glossary(glossary_name, description,
                                                      language, usage)
                 glossary = egeria_client.get_glossary_by_guid(guid)
                 if glossary == NO_GLOSSARIES_FOUND:
-                    print(f"Just created with GUID {guid} but Glossary not found")
+                    print(f"{ERROR}Just created with GUID {guid} but Glossary not found\n")
                     return None
-                q_name = glossary['glossaryProperties']["qualifiedName"]
-                return update_a_command(txt, command, object_type, q_name, guid)
+                qualified_name = glossary['glossaryProperties']["qualifiedName"]
+                element_dictionary[f"glossary.{glossary_name}"] = {
+                    'guid': guid,
+                    'q_name': qualified_name
+                    }
+                return update_a_command(txt, command, object_type, qualified_name, guid)
 
 
-def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display" ) -> str | None:
+def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str, directive: str = "display" ) -> str | None:
     """
     Processes a term create or update command by extracting key attributes such as
     term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
@@ -234,9 +261,10 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
     status = extract_attribute(txt, 'Status')
     glossary_name = extract_attribute(txt, 'Glossary Name')
 
-    print(f"\n==> Processing command: {command} for Term {term_name} with directive: {directive}")
+    print(Markdown(f"{pre_command} `{command}` for term: `{term_name}` with directive: `{directive}`"))
 
-    def validate_term(obj_action: str) -> tuple[bool, bool, str]:
+    def validate_term(obj_action: str) -> tuple[bool, bool, str | None, str | None]:
+        nonlocal version
         valid = True
         msg = ""
         known_term_guid = None
@@ -256,8 +284,25 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
             valid = False
         if status is None:
             msg += f"* {INFO}Term status is missing - will default to DRAFT"
-        if obj_action == "Update":  # check to see if provided information exists and is consistent with existing info
 
+        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 - will default to 0.0.1\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
@@ -274,19 +319,20 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
             else:
                 msg += f"--> * Term {term_name} exists and can be updated\n"
                 msg += term_display
-                msg += '\n---\n'
+
             print(Markdown(msg))
-            return valid, term_exists, known_term_guid
+            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"{WARNING}Term \'{term_name}\' already exists\n"
-
+                msg += f"\n{WARNING}Term \'{term_name}\' already exists, response document updated.\n"
+            elif not valid:
+                msg += f"\n-->Validation checks failed in creating Term \'{term_name}\' with: {term_display}\n"
             else:
-                msg += f"-->It is valid to create Term \'{term_name}\' with: {term_display}\n"
-            msg += '\n---\n'
+                msg += f"\n-->It is valid to create Term \'{term_name}\' with: {term_display}\n"
+
             print(Markdown(msg))
-            return valid, term_exists, known_term_guid
+            return valid, term_exists, known_term_guid, known_q_name
 
     if object_action == "Update":
         term_guid = extract_attribute(txt, 'GUID')
@@ -311,11 +357,11 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
         print(Markdown(term_display))
         return None
     elif directive == "validate":
-        is_valid, exists, known_guid = validate_term(object_action)
+        is_valid, exists, known_guid, known_q_name = validate_term(object_action)
         valid = is_valid if is_valid else None
         return valid
     elif directive == "process":
-        is_valid, exists, known_guid = validate_term(object_action)
+        is_valid, exists, known_guid, known_q_name = validate_term(object_action)
         if not is_valid:  # First validate the term before we process it
             return None
 
@@ -328,7 +374,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
                 "elementProperties":
                     {
                         "class": "GlossaryTermProperties",
-                        "qualifiedName": q_name,
+                        "qualifiedName": known_q_name,
                         "summary": summary,
                         "description": description,
                         "abbreviation": abbreviation,
@@ -341,20 +387,28 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
                 }
             egeria_client.update_term(known_guid, body)
             print(f"\n-->Updated Term {term_name} with GUID {known_guid}")
-            return update_a_command(txt, command, object_type, q_name, known_guid)
+            return update_a_command(txt, command, object_type, known_q_name, known_guid)
 
         elif object_action == "Create" :
             guid = None
             q_name = f"GlossaryTerm:{term_name}:{get_current_datetime_string()}"
             if exists:
-                print(f"\n-->Term {term_name} exists and document updated")
-                return update_a_command(txt, command, object_type, q_name, guid)
+                print(f"\n{ERROR}Term {term_name} exists and result document updated")
+                return update_a_command(txt, command, object_type, q_name, known_guid)
             else:
-                ## get the guid for the glossary from the name
-                glossary_guid = egeria_client.__get_guid__(property_name="displayName", display_name=glossary_name)
-                if glossary_guid == NO_ELEMENTS_FOUND:
-                    print(f"Glossary {glossary_name} not found")
-                    return None
+                ## get the guid for the glossary from the name - first look locally
+                glossary = element_dictionary.get(f"glossary.{glossary_name}",None)
+
+                if glossary is not None:
+                    glossary_guid = glossary.get('guid', None)
+                    if glossary_guid is None:
+                        print(f"{ERROR}Glossary reference {glossary_name} not found")
+                        return None
+                else:
+                    glossary_guid = egeria_client.__get_guid__(property_name="displayName", display_name=glossary_name)
+                    if glossary_guid == NO_ELEMENTS_FOUND:
+                        print(f"{ERROR}Glossary {glossary_name} not found")
+                        return None
                 term_body = {
                     "class": "ReferenceableRequestBody",
                     "elementProperties":
@@ -377,10 +431,15 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
                     "initialStatus": status
                     }
                 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 Term {term_name} with GUID {term_guid}")
+                element_dictionary[f"term.{term_name}"] = {'guid': term_guid, 'q_name': q_name}
                 return update_a_command(txt, command, object_type, q_name, term_guid)
 
-def process_per_proj_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display" ) -> str | None:
+
+def process_per_proj_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str, directive: str = "display" ) -> str | None:
     """
     Processes a personal project create or update command by extracting key attributes such as
     glossary name, language, description, and usage from the given cell.
@@ -403,7 +462,7 @@ def process_per_proj_upsert_command(egeria_client: EgeriaTech, txt: str, directi
     project_health = extract_attribute(txt, 'Project Health')
     start_date = extract_attribute(txt, 'Start Date')
     planned_end_date = extract_attribute(txt, 'Planned End Date')
-    print(f"\n==> Processing command: {command} for project: {project_name} with directive: {directive} ")
+    print(Markdown(f"{pre_command} `{command}` for project: `{project_name}` with directive: `{directive}` "))
 
     project_display = (f"\n* Command: {command}\n\t* Project: {project_name}\n\t"
                         f"* Status: {project_status}\n\t* Description: {description}\n\t"
@@ -512,9 +571,8 @@ def process_per_proj_upsert_command(egeria_client: EgeriaTech, txt: str, directi
             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")
+                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,
@@ -526,5 +584,7 @@ def process_per_proj_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                 if project_g == NO_GLOSSARIES_FOUND:
                     print(f"Just created with GUID {guid} but Project not found")
                     return None
-                q_name = project_g['prjectProperties']["qualifiedName"]
+
+                q_name = project_g['projectProperties']["qualifiedName"]
+                element_dictionary[f"project.{project_name}"] = {'guid': guid, 'q_name': q_name}
                 return update_a_command(txt, command, object_type, q_name, guid)