pyegeria 5.3.9.9.7__py3-none-any.whl → 5.4.0__py3-none-any.whl

commands/cat/dr_egeria_command_help.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+A simple display for glossary terms
+"""
+import argparse
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+from pyegeria import (
+    EgeriaTech,
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException, NO_CATEGORIES_FOUND,
+    )
+from commands.cat.glossary_actions import EGERIA_HOME_GLOSSARY_GUID
+from pyegeria._globals import NO_GLOSSARIES_FOUND
+
+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("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_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", "250"))
+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")
+
+
+def display_command_terms(
+    search_string: str = "*",
+    glossary_guid: str = EGERIA_HOME_GLOSSARY_GUID,
+    glossary_name: str = None,
+    view_server: str = EGERIA_VIEW_SERVER,
+    view_url: str = EGERIA_VIEW_SERVER_URL,
+    user_id: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+    output_format: str = "TABLE",
+):
+    """Display a table of glossary terms filtered by search_string and glossary, if specified. If no
+        filters then all terms are displayed. If glossary_guid or name is specified, then only terms from that
+        glossary are displayed.
+    Parameters
+    ----------
+    search_string : str, optional
+        The string to search for terms. Defaults to "*".
+    glossary_guid : str, optional
+        The unique identifier of the glossary. Defaults to None. If specified, then only terms from that glossary
+        are displayed. If both glossary_guid and glossary_name are provided then glossary_guid will take precedence.
+    glossary_name : str, optional
+        The display name of the glossary. Defaults to None. If specified, then only terms from that glossary
+        are displayed. If both glossary_guid and glossary_name are provided then glossary_guid will take precedence.
+        Note that the use of glossary display name relies on the qualified name conforming to convention. GUID is more
+        reliable.
+    view_server : str
+        The server where the glossary is hosted. Defaults to EGERIA_VIEW_SERVER.
+    view_url : str
+        The URL of the server where the glossary is hosted. Defaults to EGERIA_VIEW_SERVER_URL.
+    user_id : str
+        The user ID for authentication. Defaults to EGERIA_USER.
+    user_pass : str
+        The user password for authentication. Defaults to EGERIA_USER_PASSWORD.
+    jupyter : bool
+        Flag to indicate if the output should be formatted for Jupyter notebook. Defaults to EGERIA_JUPYTER.
+    width : int
+        The width of the console output. Defaults to EGERIA_WIDTH.
+        output_format: str, optional, default is 'JSON'
+        One of TABLE, FORM, REPORT
+    """
+
+    console = Console(
+        style="bold bright_white on black", width=width, force_terminal=not jupyter
+    )
+    try:
+        g_client = EgeriaTech(view_server, view_url, user_id, user_pass)
+        token = g_client.create_egeria_bearer_token(user_id, user_pass)
+        if (glossary_name is not None) and (glossary_name != "*"):
+            glossary_guid = g_client.get_guid_for_name(glossary_name)
+            if glossary_guid == NO_GLOSSARIES_FOUND:
+                console.print(
+                    f"\nThe glossary name {glossary_name} was not found. Please try using the glossary guid"
+                )
+                sys.exit(1)
+        elif (glossary_guid is not None) and (len(glossary_guid) < 10):
+                glossary_guid = None
+
+        if output_format == "LIST":
+            action = "LIST"
+        elif output_format == "REPORT":
+            action = "Report"
+        if output_format != "TABLE":
+            file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_OUTBOX_PATH)
+            file_name = f"Command-Help-{time.strftime('%Y-%m-%d-%H-%M-%S')}-{action}.md"
+            full_file_path = os.path.join(file_path, file_name)
+            os.makedirs(os.path.dirname(full_file_path), exist_ok=True)
+            output = g_client.find_glossary_terms(search_string, glossary_guid, output_format=output_format)
+            if output == "NO_TERMS_FOUND":
+                print(f"\n==> No commands found for search string '{search_string}'")
+                return
+            with open(full_file_path, 'w') as f:
+                f.write(output)
+            print(f"\n==> Terms output written to {full_file_path}")
+            return
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+        ) as e:
+        console.print_exception()
+
+
+
+    def generate_table(search_string: str, glossary_guid: str) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Glossary Definitions for Terms like  {search_string} @ {time.asctime()}",
+            style="bright_white on black",
+            # row_styles="bright_white on black",
+            header_style="bright_white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"View Server '{view_server}' @ Platform - {view_url}",
+            expand=True,
+        )
+        table.add_column("Term Name", width=20)
+        # table.add_column("Summary")
+        table.add_column("Description", width=40)
+        table.add_column("Usage", min_width=100)
+
+        terms = g_client.find_glossary_terms(
+            search_string,
+            glossary_guid,
+            starts_with=False,
+            ends_with=False,
+            status_filter=[],
+            page_size=500,
+        )
+
+        if type(terms) is str:
+            print(f"No commands found - this was not the command you were looking for?! - {search_string} : {glossary_guid} ")
+            sys.exit(0)
+        sorted_terms = sorted(
+            terms, key=lambda k: k["glossaryTermProperties"].get("displayName","---")
+        )
+        style = "bright_white on black"
+        if type(terms) is str:
+            return table
+        glossary_info = {}
+        for term in sorted_terms:
+            props = term.get("glossaryTermProperties", "None")
+            if props == "None":
+                return table
+
+            display_name = props.get("displayName","---")
+            qualified_name = props["qualifiedName"]
+            term_guid = term["elementHeader"]["guid"]
+            aliases = props.get("aliases", "---")
+            q_name = Text(
+                f"{qualified_name}\n&\n{term_guid}\n&\n{aliases}", style=style, justify="center"
+            )
+            abbrev = props.get("abbreviation", "---")
+            summary = props.get("summary", "---")
+            description = props.get("description",'---')
+            version = props.get("publishVersionIdentifier", "---")
+            example = props.get("example", "---")
+            usage = props.get("usage", "---")
+            # ex_us_out = Markdown(f"Example:\n{example}\n---\nUsage: \n{usage}")
+
+            classifications = term["elementHeader"]["classifications"]
+            glossary_guid = None
+            for c in classifications:
+                if c["classificationName"] == "Anchors":
+                    glossary_guid = c["classificationProperties"]["anchorScopeGUID"]
+
+            if glossary_guid and glossary_guid in glossary_info:
+                glossary_name = glossary_info[glossary_guid]
+            elif glossary_guid:
+                g = g_client.get_glossary_for_term(term_guid)
+                glossary_name = g["glossaryProperties"].get("displayName", "---")
+                glossary_info[glossary_guid] = glossary_name
+            else:
+                glossary_name = "---"
+
+            term_abb_ver_out = Markdown(f"{display_name}\n---\n{abbrev}\n---\n{version}")
+
+            term_status = term["elementHeader"].get("status","---")
+            table.add_row(
+                Markdown(display_name),
+                # summary,
+                Markdown(description),
+                Markdown(usage),
+                style="bold white on black",
+            )
+
+        g_client.close_session()
+        return table
+
+    try:
+        with console.pager(styles=True):
+            console.print(generate_table(search_string, glossary_guid))
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        console.print_exception()
+
+
+def main():
+    sus_guid = "f9b78b26-6025-43fa-9299-a905cc6d1575"
+    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("--guid", help="GUID of glossary to search")
+
+    args = parser.parse_args()
+
+    # server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    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
+    guid = args.guid if args.guid is not None else EGERIA_HOME_GLOSSARY_GUID
+
+    try:
+        search_string = Prompt.ask("Enter the command you are searching for:", default="*")
+
+        output_format = Prompt.ask("What output format do you want?", choices=["TABLE", "LIST", "REPORT"], default="TABLE")
+
+        display_command_terms(
+        search_string, guid, 'Egeria-Markdown', server, url,
+            userid, user_pass, output_format= output_format
+        )
+
+    except KeyboardInterrupt:
+        pass
+
+
+
+
+if __name__ == "__main__":
+    main()

commands/cat/dr_egeria_md.py

@@ -2,26 +2,44 @@
 This is an ongoing experiment in parsing and playing with Freddie docs
 """
 import os
+import sys
 from datetime import datetime
 
+from loguru import logger
+
+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 rich import print
 from rich.console import Console
+from md_processing.md_processing_utils.common_md_utils import setup_log
 
 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_solution_component_upsert_command, process_component_link_unlink_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,
-                           )
+                           process_information_supply_chain_upsert_command,
+                           process_information_supply_chain_link_unlink_command, process_sol_arch_list_command,
+                           process_digital_product_upsert_command, process_agreement_upsert_command,
+                           process_gov_definition_upsert_command, GOV_COM_LIST, GOV_LINK_LIST,
+                           process_gov_def_link_detach_command, process_gov_definition_list_command,
+                           process_gov_def_context_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_collection_list_command,
+                                                              process_data_structure_list_command,
+                                                              process_data_field_list_command,
+                                                              process_data_class_list_command,
                                                               process_data_field_upsert_command,
-                                                              process_data_structure_upsert_command)
-
+                                                              process_data_structure_upsert_command,
+                                                              process_data_class_upsert_command)
 from pyegeria import EgeriaTech
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
@@ -43,28 +61,33 @@ 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")
 
-
+setup_log()
 @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",
+@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}")
+    full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_INBOX_PATH, input_file)
+    logger.info("\n\n====================================================\n\n")
+    logger.info(f"Processing Markdown File: {full_file_path}")
     try:
         with open(full_file_path, 'r') as f:
             lines = f.readlines()
@@ -74,7 +97,7 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
 
     final_output = []
     prov_found = False
-    prov_output = (f"\n# Provenance\n\n* Results from processing file {file_path} on "
+    prov_output = (f"\n# Provenance\n\n* Results from processing file {input_file} on "
                    f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n")
     h1_blocks = []
     current_block = ""
@@ -91,7 +114,7 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
         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)
+                result = process_provenance_command(input_file, current_block)
                 prov_found = True
 
             elif potential_command in ["Create Glossary", "Update Glossary"]:
@@ -121,8 +144,27 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
             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 ["View Solution Blueprints", "View Blueprint", "View Solution Blueprint"]:
+                result = process_sol_arch_list_command(client, current_block, "Solution Blueprints", directive)
+            elif potential_command in ["View Solution Component", "View Solution Components"]:
+                result = process_sol_arch_list_command(client, current_block, "Solution Components", directive)
+            elif potential_command in ["View Solution Roles", "View Solution Role"]:
+                result = process_sol_arch_list_command(client, current_block, "Solution Roles", directive)
+            elif potential_command in ["View Information Supply Chain", "View Information Supply Chains"]:
+                result = process_sol_arch_list_command(client, current_block, "Information Supply Chains", 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 ["Link Solution Components", "Link Solution Component Peers", "Wire Solution Components",
+                                       "Unlink Solution Components", "Detach Solution Components", "Detach Solution Component Peers"]:
+                result = process_component_link_unlink_command(client, current_block, directive)
+            elif potential_command in ["Create Information Supply Chain", "Update Information Supply Chain"]:
+                result = process_information_supply_chain_upsert_command(client, current_block, directive)
+
+            elif potential_command in ["Link Information Supply Chain Peers", "Link Information Supply Chains",
+                                       "Link Supply Chains", "Unlink Information Supply Chain Peers",
+                                       "Unlink Information Supply Chains", "Unlink Supply Chains"]:
+                result = process_information_supply_chain_link_unlink_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)
@@ -133,13 +175,36 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
                 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)
+            elif potential_command in ["Create Data Class", "Update Data Class"]:
+                result = process_data_class_upsert_command(client, current_block, directive)
+            elif potential_command in ["View Data Dictionaries", "View Data Dictionary", "View Data Specifications",
+                                       "View Data Specs"]:
+                result = process_data_collection_list_command(client, current_block, directive)
+            elif potential_command in ["View Data Structures", "View Data Structure"]:
+                result = process_data_structure_list_command(client, current_block, directive)
+            elif potential_command in ["View Data Fields", "View Data Field"]:
+                result = process_data_field_list_command(client, current_block, directive)
+            elif potential_command in ["View Data Classes", "View Data Class"]:
+                result = process_data_class_list_command(client, current_block, directive)
+            elif potential_command in ["Create Digital Product", "Create Data Product","Update Digital Product", "Update Data Product"]:
+                result = process_digital_product_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create Agreement", "Create Data Sharing Agreement", "Update Agreement", "Update Data Sharing Agreement"]:
+                result = process_agreement_upsert_command(client, current_block, directive)
+            elif potential_command in GOV_COM_LIST:
+                result = process_gov_definition_upsert_command(client, current_block, directive)
+            elif potential_command in ['View Governance Definitions', 'List Governance Definitions',
+                                       'View Gov Definitions', 'List Gov Definitions']:
+                result = process_gov_definition_list_command(client, current_block, directive)
+            elif potential_command in ['View Governance Definition Context', 'List Governance Definition Context',
+                                       'View Gov Definition Context', 'List Gov Definition Context']:
+                result = process_gov_def_context_command(client, current_block, directive)
+
 
 
             else:
                 # If object_action is not recognized, keep the block as-is
                 result = None
+                print(f"\n===> Unknown command: {potential_command}")
             # print(json.dumps(dr_egeria_state.get_element_dictionary(), indent=4))
             if result:
                 if directive == "process":
@@ -197,9 +262,13 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
 
     try:
         if updated:
-            path, filename = os.path.split(file_path)  # Get both parts
+            path, filename = os.path.split(input_file)  # 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
+            
+            if output_folder:
+                new_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_OUTBOX_PATH, output_folder, new_filename)
+            else:
+                new_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_OUTBOX_PATH, new_filename)
             os.makedirs(os.path.dirname(new_file_path), exist_ok=True)
 
             with open(new_file_path, 'w') as f2:
@@ -210,6 +279,7 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
         else:
             if directive != 'display':
                 click.echo("\nNo updates detected. New File not created.")
+                logger.error("===> Unknown Command? <===")
 
     except (Exception):
         console.print_exception(show_locals=True)
@@ -231,11 +301,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 +314,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/glossary_actions.py

@@ -315,7 +315,7 @@ def remove_term_from_category(server, url, userid, password, timeout, term_guid,
 @click.option("--glossary_name", help="Name of Glossary", required=True)
 @click.option("--file_name", help="Name of CSV file", required=True)
 @click.option(
-    "--file_path", help="Path of CSV file", default=EGERIA_GLOSSARY_PATH, required=False
+    "--input_file", help="Path of CSV file", default=EGERIA_GLOSSARY_PATH, required=False
 )
 @click.option(
     "--verbose",
@@ -380,7 +380,7 @@ def import_terms_csv(
 )
 @click.option("--file_name", help="Name of CSV file", required=True)
 @click.option(
-    "--file_path", help="Path of CSV file", default=EGERIA_GLOSSARY_PATH, required=False
+    "--input_file", help="Path of CSV file", default=EGERIA_GLOSSARY_PATH, required=False
 )
 @click.option("--server", default=EGERIA_VIEW_SERVER, help="Egeria view server to use")
 @click.option(

commands/cat/list_collections.py

@@ -87,14 +87,21 @@ def display_collections(
             action = "Report"
         elif output_format == "DICT":
             action = "Dict"
+        elif output_format == "HTML":
+            action = "html"
+        elif output_format == "LIST":
+            action = "List"
 
         if output_format != "TABLE":
             file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_OUTBOX_PATH)
-            file_name = f"Terms-{time.strftime('%Y-%m-%d-%H-%M-%S')}-{action}.md"
+            if output_format == "HTML":
+                file_name = f"Collections-{time.strftime('%Y-%m-%d-%H-%M-%S')}-{action}.html"
+            else:
+                file_name = f"Collections-{time.strftime('%Y-%m-%d-%H-%M-%S')}-{action}.md"
             full_file_path = os.path.join(file_path, file_name)
             os.makedirs(os.path.dirname(full_file_path), exist_ok=True)
             output = m_client.find_collections(
-                search_string.strip(), None, False, ends_with=False, ignore_case=True,
+                search_string.strip(), None, True, False, ignore_case=True,
                 output_format=output_format
                 )
             if output == NO_ELEMENTS_FOUND:
@@ -129,24 +136,31 @@ def display_collections(
         table.add_column("Members")
 
         collections = m_client.find_collections(
-            search_string.strip(), None, False, ends_with=False, ignore_case=True,
+            search_string.strip(), None, True, False, ignore_case=True,
             output_format = "DICT"
         )
         if type(collections) is list:
             sorted_collection_list = sorted(
-                collections, key=lambda k: k["name"]
+                collections, key=lambda k: k["display_name"]
             )
             for collection in sorted_collection_list:
-                display_name = collection["name"]
-                qualified_name = collection["qualifiedName"]
-                guid = collection["guid"]
+                display_name = collection["display_name"]
+                qualified_name = collection["qualified_name"]
+                guid = collection["GUID"]
                 q_name = Text(f"{qualified_name}\n&\n{guid}", justify="center")
                 description = collection.get("description",'---')
                 collection_type = collection.get("collectionType", "---")
                 classifications = collection.get("classifications", "---")
+
                 classifications_md = Markdown(classifications)
-                members = "\n* ".join(collection.get("members", []))
-                members_md = Markdown(members)
+                members_struct = m_client.get_member_list(collection_guid=guid)
+                member_list = ""
+                if isinstance(members_struct, list):
+                    for member in members_struct:
+                        member_list = member_list + f"- {member.get('qualifiedName','---')}\n"
+
+                # members = "\n* ".join(collection.get("members", []))
+                members_md = Markdown(member_list)
 
                 table.add_row(
                     display_name,
@@ -193,7 +207,7 @@ def main():
         search_string = Prompt.ask(
             "Enter the collection you are searching for or '*' for all:", default="*"
         ).strip()
-        output_format = Prompt.ask("What output format do you want?", choices=["DICT", "TABLE", "FORM", "REPORT"], default="TABLE")
+        output_format = Prompt.ask("What output format do you want?", choices=["DICT", "TABLE", "FORM", "REPORT", "HTML", "LIST"], default="TABLE")
 
         display_collections(search_string, server, url, userid, user_pass, output_format = output_format)