pyegeria 5.3.9.9.3__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

commands/cat/dr_egeria_md.py

@@ -2,27 +2,19 @@
 This is an ongoing experiment in parsing and playing with Freddie docs
 """
 import os
-from datetime import datetime
+import sys
 
-import click
-from rich import print
-from rich.console import Console
+from loguru import logger
 
-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)
+log_format = "{time} | {level} | {function} | {line} | {message} | {extra}"
+logger.remove()
+logger.add(sys.stderr, level="INFO", format=log_format, colorize=True)
+logger.add("debug_log.log", rotation="1 day", retention="1 week", compression="zip", level="TRACE", format=log_format,
+           colorize=True)
+import click
 
-from pyegeria import EgeriaTech
+from pyegeria.core._exceptions import PyegeriaException
+from md_processing.dr_egeria import process_md_file
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
@@ -39,180 +31,33 @@ 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_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,
+@click.option("--input-file", help="Markdown file to process.", default="dr_egeria_intro_part1.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("--output-folder", help="Output folder.", default="", required=False)
+@click.option("--directive", default="process", 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:
+@logger.catch
+def process_markdown_file(input_file: str, output_folder: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)
+        process_md_file(input_file, output_folder, directive, server, url, userid, user_pass)
+        logger.info(f"Called process_markdown_file with input file {input_file}")
+    except PyegeriaException as e:
+        logger.error(f"Error processing markdown file {input_file}: {e}")
+    except Exception as e:
+        logger.error(f"Unexpected error processing markdown file {input_file}: {e}")
 
 
 # def main():
@@ -231,11 +76,11 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
 #     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="")
+#         input_file = 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)
+#         process_markdown_file(input_file, directive, server, url, userid, user_pass)
 #     except KeyboardInterrupt:
 #         pass
 #
@@ -244,4 +89,4 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
 #     main()
 
 if __name__ == "__main__":
-    process_markdown_file()
+    process_markdown_file()

commands/cat/exp_list_glossaries.py

@@ -19,14 +19,11 @@ from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
 from rich.text import Text
-from rich_pixels import Pixels
+
 
 from pyegeria import (
     EgeriaTech,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table
 )
 
 disable_ssl_warnings = True
@@ -99,16 +96,17 @@ def display_glossaries(
         glossaries = m_client.find_glossaries(search_string)
         if type(glossaries) is list:
             sorted_glossary_list = sorted(
-                glossaries, key=lambda k: k["glossaryProperties"]["displayName"]
+                glossaries, key=lambda k: k["properties"]["qualifiedName"]
             )
             for glossary in sorted_glossary_list:
-                display_name = glossary["glossaryProperties"]["displayName"]
-                qualified_name = glossary["glossaryProperties"]["qualifiedName"]
+
+                display_name = glossary["properties"].get("displayName","---")
+                qualified_name = glossary["properties"].get("qualifiedName","---")
                 guid = glossary["elementHeader"]["guid"]
                 q_name = Text(f"{qualified_name}\n&\n{guid}", justify="center")
-                language = glossary["glossaryProperties"]["language"]
-                description = glossary["glossaryProperties"]["description"]
-                usage = glossary["glossaryProperties"]["usage"]
+                language = glossary["properties"].get("language","---")
+                description = glossary["properties"].get("description","---")
+                usage = glossary["properties"].get("usage","---")
                 text = "http://100.83.199.62:8088/superset/dashboard/p/xOgE56dLNaY/"
 
                 table.add_row(display_name, q_name, language, text)
@@ -118,10 +116,9 @@ def display_glossaries(
                 force_terminal=not jupyter,
             )
             console.print(table)
-            print("Visit my [link=https://www.willmcgugan.com]blog[/link]!")
 
-    except (InvalidParameterException, PropertyServerException) as e:
-        print_exception_response(e)
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
     finally:
         m_client.close_session()
 

commands/cat/get_asset_graph.py

@@ -3,293 +3,60 @@
 SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
-Display the status of cataloged platforms and servers.
+Display Asset Graph Information using generic functions.
 """
+from __future__ import annotations
 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 commands.cat.run_report import list_generic
+from pyegeria.core.config import settings
 from pyegeria import (
-    AssetCatalog,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
+    PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table, PyegeriaException
 )
 
-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_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
-EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
 
-disable_ssl_warnings = True
+
+app_config = settings.Environment
 
 guid_list = []
 
-console = Console(width=EGERIA_WIDTH, force_terminal=(not EGERIA_JUPYTER))
+console = Console(width=app_config.console_width, force_terminal=(not app_config.egeria_jupyter))
 
 
 def asset_viewer(
-    asset_guid: str,
-    server_name: str,
-    platform_url: str,
-    user: str,
-    user_pass: str,
-    jupyter: bool = EGERIA_JUPYTER,
-    width: int = EGERIA_WIDTH,
+    output_format: str = "TABLE",
+    asset_guid: str = None,
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
+    user: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width,
+    prompt_missing: bool = False,
+    write_file: bool = False,
+    render_table: bool = False,
+    table_caption: str | None = None,
+    use_pager: bool = True,
 ):
-    def build_classifications(classification: dict) -> Markdown:
-        class_md = ""
-        for c in classification:
-            c_type = c["classificationName"]
-            if c_type == "Anchors":
-                continue
-            class_md += f"\n* Classification: {c_type}\n"
-            class_props = c.get("classificationProperties", "---")
-            if type(class_props) is dict:
-                for prop in class_props.keys():
-                    class_md += f"\t* {prop}: {class_props[prop]}\n"
-        if class_md == "":
-            output = None
-        else:
-            output = class_md
-        return output
-
-    def build_nested_elements(nested_element: dict) -> Markdown:
-        ne_md = " "
-        ne_header = nested_element["elementHeader"]
-        ne_created_by = ne_header["versions"]["createdBy"]
-        ne_created_at = ne_header["versions"]["createTime"]
-        ne_guid = ne_header["guid"]
-        guid_list.append(ne_guid)
-
-        ne_type = ne_header["type"]["typeName"]
-        ne_classifications = ne_header["classifications"]
-        ne_class_md = build_classifications(ne_classifications)
-        # ne_class_md = " " if ne_class_md is None else ne_class_md
-        ne_props = nested_element.get("properties", "---")
-        ne_prop_md = "\n"
-        if type(ne_props) is dict:
-            for prop in ne_props.keys():
-                ne_prop_md += f"\t* {prop}: {ne_props[prop]}\n"
-        ne_md = (
-            f"Nested Element of Type: {ne_type} with GUID:  {ne_guid} \n "
-            f"* created by {ne_created_by} at time {ne_created_at}\n"
-            f"\n* Properties:\n{ne_prop_md}\n"
-        )
-
-        if ne_class_md is not None:
-            ne_md += f"* {ne_class_md}"
-
-        output = Markdown(ne_md)
-        return output
-
     try:
-        a_client = AssetCatalog(server_name, platform_url, user_id=user)
-
-        token = a_client.create_egeria_bearer_token(user, user_pass)
-        # asset_info = a_client.find_assets_in_domain(asset_name)
-        # if type(asset_info) is str:
-        #     print("\n No Assets Found - Exiting\n")
-        #     sys.exit(1)
-        #
-        # asset_guid = asset_info[0]['guid']
-
-        guid_list.append(asset_guid)
-
-        asset_graph = a_client.get_asset_graph(asset_guid)
-        if type(asset_graph) is not dict:
-            print(f"\n No Asset found for {asset_guid}")
-            sys.exit(1)
-
-        # print(f"\n{json.dumps(asset_graph, indent =2)}\n")
-
-        asset_display_name = asset_graph["properties"].get("displayName", "---")
-        asset_display_description = asset_graph["properties"].get(
-            "displayDescription", "---"
-        )
-        asset_name = asset_graph["properties"].get("name", "---")
-        asset_resource_name = asset_graph["properties"].get("resourceName", "---")
-        asset_resource_description = asset_graph["properties"].get(
-            "resourceDescription", "---"
-        )
-        qualified_name = asset_graph["properties"].get("qualifiedName", "---")
-
-        tree = Tree(
-            f"{asset_name} ({asset_guid})",
-            style="bold bright_white on black",
-            guide_style="bold bright_blue",
-        )
-        style = ""
-        asset_elements = asset_graph["elementHeader"]
-        asset_type = asset_elements["type"]["typeName"]
-        asset_deployed_imp_type = asset_graph["properties"].get(
-            "deployedImplementationType", "---"
-        )
-
-        asset_origin = asset_elements["origin"]["homeMetadataCollectionName"]
-        asset_creation = asset_elements["versions"]["createTime"]
-        asset_created_by = asset_elements["versions"]["createdBy"]
-        asset_classifications = asset_elements["classifications"]
-        asset_nested_elements = asset_graph.get("anchoredElements", "----")
-        asset_relationships = asset_graph["relationships"]
-        asset_class_md = build_classifications(asset_classifications)
+        list_generic(report_spec="Asset-Graph", output_format=output_format, view_server=view_server,
+                 view_url=view_url, user=user, user_pass=user_pass, params={"asset_guid": asset_guid},
+                 render_table=render_table, write_file = write_file, table_caption=table_caption, use_pager=use_pager,
+                     width=width, jupyter=jupyter, prompt_missing=prompt_missing)
 
-        additional_properties = asset_graph["properties"].get(
-            "additionalProperties", None
-        )
-        if additional_properties is not None:
-            add_prop_md = "\n* Additional Properties:\n"
-            for prop in additional_properties:
-                add_prop_md = (
-                    f"{add_prop_md}\n\t* {prop}: {additional_properties[prop]}\n"
-                )
-        else:
-            add_prop_md = ""
+    except PyegeriaAPIException as e:
+        if e.response_egeria_msg_id == "OMAG-REPOSITORY-HANDLER-404-001":
+            print(e.response_egeria_msg)
+            return
 
-        extended_properties = asset_graph["properties"].get("extendedProperties", None)
-        if extended_properties is not None:
-            prop_md = "\n* Extended Properties:\n"
-            for prop in extended_properties:
-                prop_md = f"{prop_md}\n\t* {prop}: {extended_properties[prop]}\n"
-        else:
-            prop_md = ""
-        core_md = (
-            f"**Type: {asset_type}  Created by: {asset_created_by} on {asset_creation}**\n"
-            f"* Deployed Implementation Type: {asset_deployed_imp_type}\n"
-            f"* Name: {asset_name}\n "
-            f"* Asset Resource Name: {asset_resource_name}\n"
-            f"* Asset Resource Description: {asset_resource_description}\n "
-            f"* Asset Display Name: {asset_display_name}\n"
-            f"* Asset Display Description: {asset_display_description}\n "
-            f"* Qualified Name: {qualified_name}\n "
-            f"* Asset Origin: {asset_origin}\n"
-            f" {prop_md}\n"
-            f" {add_prop_md}\n"
-        )
-        core_md = Markdown(core_md)
-
-        p1 = Panel.fit(core_md, style="bold bright_white")
-        l2 = tree.add(p1)
-        if asset_class_md is not None:
-            p2 = Panel.fit(
-                Markdown(asset_class_md),
-                style="bold bright_white",
-                title="Classifications",
-            )
-            l2 = tree.add(p2)
-
-        #
-        # Nested Assets
-        #
-        if type(asset_nested_elements) is list:
-            l2 = tree.add("Nested Elements", style="bold white")
-            for el in asset_nested_elements:
-                asset_ne_md = build_nested_elements(el)
-                p3 = Panel.fit(
-                    asset_ne_md, style="bold bright_white", title="Nested Elements"
-                )
-                l2.add(p3)
-
-        #
-        # Now work on the Relationships
-        #
-        for relationship in asset_relationships:
-            # Find the end guids - if one isn't in our list then display
-            rel_end1 = relationship["end1"]
-            rel_end1_type = rel_end1["type"]["typeName"]
-            rel_end1_guid = rel_end1["guid"]
-            rel_end1_unique_name = rel_end1.get("uniqueName", "---")
-
-            rel_end2 = relationship["end2"]
-            rel_end2_type = rel_end2["type"]["typeName"]
-            rel_end2_guid = rel_end2["guid"]
-            rel_end2_unique_name = rel_end2.get("uniqueName", "---")
-
-            if (rel_end1_guid not in guid_list) or (rel_end2_guid not in guid_list):
-                # rel_end1_class_md = build_classifications(rel_end1["classifications"])
-                # rel_end2_class_md = build_classifications(rel_end2["classifications"])
-
-                relationship_guid = relationship["guid"]
-                relationship_type = relationship["type"]["typeName"]
-                relationship_created_by = relationship["versions"]["createdBy"]
-                relationship_creation_time = relationship["versions"]["createTime"]
-                relationship_properties = relationship.get("properties", "--- ")
-                relationship_md = (
-                    f"Relationship Type {relationship_type}\n"
-                    f"* GUID: {relationship_guid}\n* Created by: {relationship_created_by} \n"
-                    f"* Creation Time: {relationship_creation_time}\n"
-                    f"* Properties: {relationship_properties}\n"
-                )
-
-                rel_md = (
-                    f"* Relationship Type: {relationship_type}\n"
-                    f"* Relationship GUID: {relationship_guid}\n"
-                    f"* Created by: {relationship_created_by} at time {relationship_creation_time}\n"
-                )
-                rel_end1_md = (
-                    f"* End1:\n"
-                    f"\t* Type: {rel_end1_type}\n"
-                    f"\t* GUID: {rel_end1_guid}\n"
-                    f"\t* Unique Name: {rel_end1_unique_name}\n"
-                )
-
-                # if rel_end1_class_md is not None:
-                #     rel_end1_md = rel_end1_class_md + rel_end1_md
-
-                rel_end2_md = (
-                    f"* End2:\n"
-                    f"\t* Type: {rel_end2_type}\n"
-                    f"\t* GUID: {rel_end2_guid}\n"
-                    f"\t* Unique Name: {rel_end2_unique_name}\n"
-                )
-
-                # if rel_end2_class_md is not None:
-                #     rel_end1_md = rel_end2_class_md + rel_end1_md
-                #
-                # for prop in relationship_properties.keys():
-                #     relationship_md += f"* {prop}: {relationship_properties[prop]}\n"
-
-                relationship_md += rel_end1_md + rel_end2_md
-
-                relationship_panel = Panel.fit(
-                    Markdown(relationship_md),
-                    style="bold bright_white",
-                    title="Asset Relationships",
-                )
-                tree.add(relationship_panel)
-        with console.screen():
-            print("\n\n")
-        print(tree)
-
-    except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
-    ) as e:
-        console.print_exception()
-        console.print(
-            "\n\n ======> Most likely the GUID you provided is either incorrect or not an asset\n[red bold]"
-        )
+    except (PyegeriaException, PyegeriaClientException) as e:
+        print_basic_exception(e)
 
 
 def main():
@@ -301,13 +68,16 @@ def main():
     parser.add_argument("--password", help="User Password")
     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
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_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
     try:
         asset_guid = Prompt.ask("Enter the Asset GUID to view:", default="")
-        asset_viewer(asset_guid, server, url, userid, user_pass)
+        output_format = Prompt.ask("Enter the output format:", default="TABLE")
+        asset_viewer(output_format, asset_guid, server, url, userid,
+                     user_pass, prompt_missing=True, write_file=True, render_table=True,
+                     table_caption="Asset Graph")
     except KeyboardInterrupt as e:
         # console.print_exception()
         pass