pyegeria 5.2.1.1__py3-none-any.whl → 5.3__py3-none-any.whl

commands/cat/Dr-Egeria_md-orig.py

@@ -0,0 +1,166 @@
+"""
+This is an ongoing experiment in parsing and playing with Freddie docs
+"""
+import json
+import os
+from rich import print
+from rich.console import Console
+
+from pyegeria.md_processing_utils import (commands,
+                                          process_provenance_command)
+
+import click
+from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
+                      process_category_upsert_command,
+                      get_current_datetime_string, process_per_proj_upsert_command, EgeriaTech
+                      )
+import commands
+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", "../../")
+EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
+EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
+
+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_test1.md")
+@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_markdown_file(
+        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)
+
+    updated = False
+    full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_INBOX_PATH, file_path)
+    print(f"Processing Markdown File: {full_file_path}")
+    try:
+        with open(full_file_path, 'r') as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        print(f"Error: File not found at path: {full_file_path}")
+        return {}  # Return empty dict if file not found
+
+    final_output =""
+    prov_output = (f"\n* Results from processing file {file_path} on "
+                    f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n")
+    h1_blocks = []
+    current_block = ""
+    in_h1_block = False
+    element_dictionary = {}
+
+    for line in lines:
+        line = line.strip()  # Remove leading/trailing whitespace
+
+        if line.startswith("# ") and not in_h1_block:  # Start of a new H1 block
+            if current_block:
+                h1_blocks.append(current_block)
+            current_block = line
+            in_h1_block = True
+        elif line.startswith("---") and in_h1_block:  # End of the current H1 block
+            h1_blocks.append(current_block)
+            current_block = ""
+            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)
+    prov_found = False
+    # Process each identified H1 block
+    for block in h1_blocks:
+        potential_command = extract_command(block)  # Extract potential object_action
+
+        if potential_command in commands:
+            # Process the block based on the object_action
+            if potential_command == "Provenance":
+                prov_found = True
+                result = process_provenance_command(file_path, block)
+            elif potential_command in ["Create Glossary", "Update Glossary"]:
+                result = process_glossary_upsert_command(client, block, directive)
+            elif potential_command in ["Create Category", "Update Category"]:
+                result = process_category_upsert_command(client, block, directive)
+            elif potential_command in ["Create Term", "Update Term"]:
+                result = process_term_upsert_command(client, block, directive)
+            elif potential_command in ["Create Personal Project", "Update Personal Project"]:
+                result = process_per_proj_upsert_command(client, block, directive)
+            else:
+                # If object_action is not recognized, copy the block as-is
+                result = None
+
+            if result:
+                if directive == "process":
+                    updated = True
+                    final_output += f"\n---\n{result}\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"
+        else:
+            # If no object_action is detected, add the block to the final output as-is
+            final_output += f"\n---\n{block}\n"
+
+
+    # Write the final_output to a new file if updated
+    try:
+        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_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(final_output)
+                if not prov_found:
+                    prov_output += f"\n# Provenance:\n{prov_output}\n"
+                f2.write(prov_output)
+            click.echo(f"\n==> Notebook written to {new_file_path}")
+        else:
+            click.echo("\nNo updates detected. New File not created.")
+
+    except (Exception):
+        console.print_exception(show_locals=True)
+
+
+if __name__ == "__main__":
+    process_markdown_file()

commands/cat/__init__.py

@@ -0,0 +1,23 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+"""
+from pyegeria import (
+    INTEGRATION_GUIDS,
+    TEMPLATE_GUIDS,
+    default_time_out,
+    disable_ssl_warnings,
+    enable_ssl_check,
+    is_debug,
+    max_paging_size,
+    NO_ELEMENTS_FOUND,
+    NO_ASSETS_FOUND,
+    NO_SERVERS_FOUND,
+    NO_CATALOGS_FOUND,
+    NO_GLOSSARIES_FOUND,
+    NO_TERMS_FOUND,
+    NO_CATEGORIES_FOUND,
+    NO_ELEMENT_FOUND,
+)
+
+

commands/cat/dr_egeria_jupyter.py

@@ -0,0 +1,122 @@
+"""
+This is an ongoing experiment in parsing and playing with Freddie docs
+"""
+
+import nbformat
+import os
+from rich import print
+from rich.console import Console
+
+from pyegeria.egeria_tech_client import EgeriaTech
+from pyegeria.md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
+                                          get_current_datetime_string, process_per_proj_upsert_command, command_list,
+                                          )
+import click
+
+from pyegeria._exceptions import (
+    print_exception_response,
+)
+
+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", "../../")
+EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
+EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_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_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 command_list:
+                            if potential_command in ["Create Glossary", "Update Glossary"]:
+                                result = process_glossary_upsert_command(client, cell.source, directive)
+
+                            elif potential_command in ["Create Term", "Update Term"]:
+                                result = process_term_upsert_command(client, cell.source, directive)
+                            elif potential_command in ["Create Personal Project", "Update Personal Project"]:
+                                result = process_per_proj_upsert_command(client, cell.source, directive)
+                            else:
+                                # If object_action 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_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()

commands/cat/dr_egeria_md.py

@@ -0,0 +1,247 @@
+"""
+This is an ongoing experiment in parsing and playing with Freddie docs
+"""
+import os
+from datetime import datetime
+
+import click
+from rich import print
+from rich.console import Console
+
+from md_processing import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
+                           process_category_upsert_command, process_provenance_command, get_current_datetime_string,
+                           process_per_proj_upsert_command, command_list, process_blueprint_upsert_command,
+                           process_solution_component_upsert_command, process_term_list_command,
+                           process_category_list_command, process_glossary_list_command, process_term_history_command,
+                           process_glossary_structure_command, process_term_revision_history_command,
+                           process_create_term_term_relationship_command, process_term_details_command,
+                           )
+from md_processing.md_commands.data_designer_commands import (process_data_spec_upsert_command,
+                                                              process_data_dict_upsert_command,
+                                                              process_data_dict_list_command,
+                                                              process_data_field_upsert_command,
+                                                              process_data_structure_upsert_command)
+
+from pyegeria import EgeriaTech
+
+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", "../../")
+EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
+EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
+
+
+@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_test1.md", required=True,
+              prompt=False)
+@click.option("--directive", default="display", help="How to process the file",
+              type=click.Choice(["display", "validate", "process"], case_sensitive=False), prompt=False, )
+@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_markdown_file(file_path: str, directive: str, server: str, url: str, userid: str, user_pass: str, ) -> None:
+    """
+    Process a markdown file by parsing and executing Dr. Egeria md_commands. Write output to a new file.
+    """
+    cmd_list = command_list
+    console = Console(width=int(EGERIA_WIDTH))
+    client = EgeriaTech(server, url, user_id=userid)
+    token = client.create_egeria_bearer_token(userid, user_pass)
+
+    updated = False
+    full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_INBOX_PATH, file_path)
+    print(f"Processing Markdown File: {full_file_path}")
+    try:
+        with open(full_file_path, 'r') as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        print(f"Error: File not found at path: {full_file_path}")
+        return {}  # Return empty dict if file not found
+
+    final_output = []
+    prov_found = False
+    prov_output = (f"\n# Provenance\n\n* Results from processing file {file_path} on "
+                   f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n")
+    h1_blocks = []
+    current_block = ""
+    in_h1_block = False
+
+    # Helper function to process the current block
+    def process_current_block(current_block):
+        nonlocal updated, final_output, prov_found, prov_output, h1_blocks, in_h1_block
+
+        if not current_block:
+            return  # No block to process
+
+        potential_command = extract_command(current_block)  # Extract object_action
+        if potential_command in cmd_list:
+            # Process the block based on the object_action
+            if potential_command == "Provenance":
+                result = process_provenance_command(file_path, current_block)
+                prov_found = True
+
+            elif potential_command in ["Create Glossary", "Update Glossary"]:
+                result = process_glossary_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Category", "Update Category"]:
+                result = process_category_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Term", "Update Term"]:
+                result = process_term_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Term-Term Relationship", "Update Term-Term Relationship"]:
+                result = process_create_term_term_relationship_command(client, current_block, directive)
+            elif potential_command in ["List Term History", "Term History"]:
+                result = process_term_history_command(client, current_block, directive)
+            elif potential_command in ["List Term Details"]:
+                result = process_term_details_command(client, current_block, directive)
+            elif potential_command in ["List Term Update History", "List Term Revision History"]:
+                result = process_term_revision_history_command(client, current_block, directive)
+            elif potential_command in ["List Terms", "List Glossary Terms"]:
+                result = process_term_list_command(client, current_block, directive)
+            elif potential_command in ["List Categories", "List Glossary Categories"]:
+                result = process_category_list_command(client, current_block, directive)
+            elif potential_command in ["List Glossary Structure"]:
+                result = process_glossary_structure_command(client, current_block, directive)
+            elif potential_command in ["List Glossaries"]:
+                result = process_glossary_list_command(client, current_block, directive)
+            elif potential_command in ["Create Personal Project", "Update Personal Project"]:
+                result = process_per_proj_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Blueprint", "Update Blueprint", "Create Solution Blueprint",
+                                       "Update Solution Blueprint"]:
+                result = process_blueprint_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Solution Component", "Update Solution Component"]:
+                result = process_solution_component_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Data Spec", "Create Data Specification", "Update Data Spec",
+                                       "Update Data Specification"]:
+                result = process_data_spec_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Data Dict", "Create Data Dictionary", "Update Data Spec",
+                                       "Update Data Dictionary"]:
+                result = process_data_dict_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Data Field", "Update Data Field"]:
+                result = process_data_field_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Data Structure", "Update Data Structure"]:
+                result = process_data_structure_upsert_command(client, current_block, directive)
+            elif potential_command in ["View Data Dictionaries", "View Data Dictionary"]:
+                result = process_data_dict_list_command(client, current_block, directive)
+
+
+            else:
+                # If object_action is not recognized, keep the block as-is
+                result = None
+            # print(json.dumps(dr_egeria_state.get_element_dictionary(), indent=4))
+            if result:
+                if directive == "process":
+                    updated = True
+                    final_output.append(result)  # print(json.dumps(dr_egeria_state.get_element_dictionary(), indent=4))
+                elif directive == "validate":
+                    pass  # print(json.dumps(dr_egeria_state.get_element_dictionary(), indent=4))
+            elif directive == "process":
+                # Handle 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.append(current_block)
+                final_output.append('\n___\n')
+        else:
+            # If there is no object_action, append the block as-is
+            final_output.append(current_block)
+
+    # Main parsing loop
+    for line in lines:
+        line = line.strip()  # Remove leading/trailing whitespace
+
+        # Handle a new H1 block (starting with `# `)
+        if line.startswith("# "):
+            if in_h1_block:
+                # Process the current block before starting a new one
+                process_current_block(current_block)
+
+            # Start a new H1 block
+            current_block = line
+            in_h1_block = True
+
+        # Handle the end of a block (line starts with `---`)
+        elif line.startswith("___"):
+            if in_h1_block:
+                # Process the current block when it ends with `---`
+                current_block += f"\n{line}"
+                process_current_block(current_block)
+                current_block = ""  # Clear the block
+                in_h1_block = False
+
+        # Add lines to the current H1 block
+        elif in_h1_block:
+            current_block += f"\n{line}"
+
+        # Append non-H1 content directly to the output
+        else:
+            final_output.append(line)
+
+    # Ensure the final H1 block is processed if the file doesn't end with `---`
+    if in_h1_block:
+        process_current_block(current_block)
+
+    # Join the final output list into a single string
+    final_output = "\n".join(final_output)
+
+    try:
+        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_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(final_output)
+                if not prov_found:
+                    f2.write(prov_output)
+            click.echo(f"\n==> Output written to {new_file_path}")
+        else:
+            if directive != 'display':
+                click.echo("\nNo updates detected. New File not created.")
+
+    except (Exception):
+        console.print_exception(show_locals=True)
+
+
+# def main():
+#     parser = argparse.ArgumentParser()
+#     parser.add_argument("--server", help="Name of the server to display status for")
+#     parser.add_argument("--url", help="URL Platform to connect to")
+#     parser.add_argument("--userid", help="User Id")
+#     parser.add_argument("--password", help="User Password")
+#     parser.add_argument("--time_out", help="Time Out")
+#
+#     args = parser.parse_args()
+#
+#     server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+#     url = args.url if args.url is not None else EGERIA_PLATFORM_URL
+#     userid = args.userid if args.userid is not None else EGERIA_USER
+#     user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+#     time_out = args.time_out if args.time_out is not None else 60
+#     try:
+#         file_path = Prompt.ask("Markdown File name to process:", default="")
+#         directive = Prompt.ask("Processing Directive:", choices=[ "display", "validate", "process"],
+#         default="validate")
+#
+#         process_markdown_file(file_path, directive, server, url, userid, user_pass)
+#     except KeyboardInterrupt:
+#         pass
+#
+#
+# if __name__ == "__main__":
+#     main()
+
+if __name__ == "__main__":
+    process_markdown_file()

{pyegeria/commands → commands}/cat/exp_list_glossaries.py

@@ -21,12 +21,11 @@ from rich.table import Table
 from rich.text import Text
 from rich_pixels import Pixels
 
-
 from pyegeria import (
+    EgeriaTech,
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
-    EgeriaTech,
     print_exception_response,
 )
 
@@ -35,11 +34,11 @@ disable_ssl_warnings = True
 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("VIEW_SERVER", "view-server")
+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("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
 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")

{pyegeria/commands → commands}/cat/get_asset_graph.py

@@ -9,28 +9,28 @@ import argparse
 import os
 import sys
 
+from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.tree import Tree
-from rich import print
 
 from pyegeria import (
+    AssetCatalog,
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
-    AssetCatalog,
 )
 
 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("VIEW_SERVER", "view-server")
+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("INTEGRATION_DAEMON", "integration-daemon")
+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"
 )

{pyegeria/commands → commands}/cat/get_collection.py

@@ -9,6 +9,7 @@ A simple viewer for collections - provide the root and we display the hierarchy
 
 import argparse
 import os
+
 from rich import print
 from rich.panel import Panel
 from rich.prompt import Prompt
@@ -17,23 +18,21 @@ from rich.tree import Tree
 
 from pyegeria import (
     CollectionManager,
-    UserNotAuthorizedException,
-    PropertyServerException,
     InvalidParameterException,
-)
-from pyegeria._exceptions import (
-    print_exception_response,
-)
+    PropertyServerException,
+    UserNotAuthorizedException, NO_ELEMENTS_FOUND,
+    )
+from pyegeria._exceptions import print_exception_response
 
 disable_ssl_warnings = True
 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("VIEW_SERVER", "view-server")
+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("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
 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")
@@ -112,7 +111,7 @@ def collection_viewer(
         PropertyServerException,
         UserNotAuthorizedException,
     ) as e:
-        if e.exception_error_message_parameters[1] == "No elements found":
+        if e.exception_error_message_parameters[1] == NO_ELEMENTS_FOUND:
             print("The collection was not found.")
         else:
             print_exception_response(e)