pyegeria 0.2.4__py3-none-any.whl → 5.3.0.dev3__py3-none-any.whl

pyegeria/commands/cat/glossary_actions.py

@@ -0,0 +1,362 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+Execute Glossary actions.
+
+"""
+import csv
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from rich import box
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+import click
+
+
+from pyegeria import EgeriaTech, body_slimmer
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    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("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_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", 200)
+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)
+
+
+@click.command("create-glossary")
+@click.option("--name", help="Name of Glossary", required=True)
+@click.option("--language", help="Language of Glossary", default="English")
+@click.option(
+    "--description",
+    help="Description of Glossary",
+    default="A description goes here",
+)
+@click.option(
+    "--usage",
+    help="Purpose of glossary",
+    default="Definitions",
+)
+@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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def create_glossary(
+    server: str,
+    url: str,
+    userid: str,
+    password: str,
+    timeout: int,
+    name: str,
+    language: str,
+    description: str,
+    usage: str,
+) -> None:
+    """Create a new Glossary"""
+
+    try:
+        m_client = EgeriaTech(server, url, userid, password)
+        token = m_client.create_egeria_bearer_token()
+
+        existing_glossary = m_client.find_glossaries(name)
+        if type(existing_glossary) is list:
+            click.echo(
+                f"\nFound {len(existing_glossary)} existing Glossaries with a similar name!\n"
+            )
+            for glossary in existing_glossary:
+                if (
+                    glossary["glossaryProperties"]["qualifiedName"]
+                    == "Glossary:" + name
+                ):
+                    click.echo(
+                        (
+                            f"\tFound existing glossary: {glossary['glossaryProperties']['qualifiedName']} with id of {glossary['elementHeader']['guid']}\n"
+                            "Exiting\n"
+                        )
+                    )
+                    sys.exit(0)
+                else:
+                    click.echo(
+                        "Found glossaries with similar names but different qualifiedNames...proceeding\n"
+                    )
+
+        glossary_guid = m_client.create_glossary(name, description, language, usage)
+        print(f"New glossary {name} created with id of {glossary_guid}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("delete-glossary")
+@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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+@click.argument("glossary-guid")
+def delete_glossary(server, url, userid, password, timeout, glossary_guid):
+    """Delete the glossary specified"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        m_client.delete_glossary(glossary_guid)
+
+        click.echo(f"Deleted glossary: {glossary_guid}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("create-term")
+@click.option("--glossary-name", help="Name of Glossary", required=True)
+@click.option("--term-name", help="Name of Term", required=True)
+@click.option(
+    "--summary",
+    help="Summary definition",
+    default="Summary goes here",
+)
+@click.option(
+    "--description",
+    help="Full description",
+    default="Description goes here",
+)
+@click.option("--abbrev", help="Abbreviation", default=None)
+@click.option("--examples", help="Example usage", default=None)
+@click.option("--usage", help="Usage notes", default=None)
+@click.option("--version", help="Version", default="1.0")
+@click.option(
+    "--status",
+    help="Status",
+    type=click.Choice(
+        ["DRAFT", "ACTIVE", "DEPRECATED", "OBSOLETE", "OTHER"], case_sensitive=False
+    ),
+    default="DRAFT",
+)
+@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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def create_term(
+    server,
+    url,
+    userid,
+    password,
+    glossary_name,
+    term_name,
+    summary,
+    description,
+    abbrev,
+    examples,
+    usage,
+    version,
+    status,
+    timeout: int = 120,
+) -> str:
+    """Create a new term"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        body = {
+            "class": "ReferenceableRequestBody",
+            "elementProperties": {
+                "class": "GlossaryTermProperties",
+                "qualifiedName": f"GlossaryTerm: {term_name} - {datetime.now().isoformat()}",
+                "displayName": term_name,
+                "summary": summary,
+                "description": description,
+                "abbreviation": abbrev,
+                "examples": examples,
+                "usage": usage,
+                "publishVersionIdentifier": version,
+            },
+            "initialStatus": status,
+        }
+        exists = False
+        glossary_info = m_client.find_glossaries(glossary_name)
+        if type(glossary_info) is list:
+            for glossary in glossary_info:
+                if glossary["glossaryProperties"]["displayName"] == glossary_name:
+                    exists = True
+                    glossary_guid = glossary["elementHeader"]["guid"]
+
+        if not exists:
+            click.echo(f"The glossary name {glossary_name} was not found..exiting\n")
+            sys.exit(0)
+
+        term_guid = m_client.create_controlled_glossary_term(
+            glossary_guid, body_slimmer(body)
+        )
+
+        click.echo(
+            f"Successfully created term {term_name} with GUID {term_guid}, in glossary {glossary_name}.\n"
+        )
+        return term_guid
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("delete-term")
+@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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+@click.argument("term-guid")
+def delete_term(server, url, userid, password, timeout, term_guid):
+    """Delete a glossary term"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        term_guid = term_guid.strip()
+        term_info = m_client.get_terms_by_guid(term_guid)
+
+        m_client.delete_term(term_guid)
+
+        click.echo(
+            f"Deleted term with GUID: {term_guid} and Display Name: {term_info['glossaryTermProperties']['displayName']}"
+        )
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("import-terms")
+@click.option("--glossary_name", help="Name of Glossary", required=True)
+@click.option("--file_name", help="Path of CSV file", required=True)
+@click.option(
+    "--file_path", help="Path of CSV file", default=EGERIA_GLOSSARY_PATH, required=False
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=True,
+    help="If set, result descriptions are provided",
+)
+@click.option(
+    "--upsert",
+    is_flag=True,
+    default=True,
+    help="If set, terms will be updated if they exist; otherwise they would be appended",
+)
+@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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def import_terms(
+    glossary_name: str,
+    file_path: str,
+    file_name: str,
+    verbose: bool,
+    upsert: bool,
+    server: str,
+    url: str,
+    userid: str,
+    password: str,
+    timeout: int,
+):
+    """Load terms from file into the glossary specified"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        result = m_client.load_terms_from_file(
+            glossary_name,
+            file_name,
+            file_path=file_path,
+            upsert=upsert,
+            verbose=verbose,
+        )
+
+        click.echo(
+            f"Loaded terms from  into glossary: {glossary_name} from {file_name}"
+        )
+        if verbose:
+            print(f"\n Verbose output:\n{json.dumps(result, indent = 2)}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("export-terms")
+@click.option(
+    "--glossary_guid",
+    help="GUID of Glossary to export",
+    required=True,
+)
+@click.option("--file_name", help="Path of CSV file", required=True)
+@click.option(
+    "--file_path", 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(
+    "--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("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def export_terms(
+    glossary_guid: str, file_name, file_path, server, url, userid, password, timeout
+):
+    """Export the glossary specified"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        result = m_client.export_glossary_to_csv(glossary_guid, file_name, file_path)
+
+        click.echo(
+            f"Exported {result} terms  from glossary: {glossary_guid} into {file_name}"
+        )
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()

pyegeria/commands/cat/list_assets.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+List assets
+
+"""
+import argparse
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    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_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("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", "200"))
+
+
+disable_ssl_warnings = True
+
+
+def display_assets(
+    search_string: str,
+    server: str,
+    url: str,
+    username: str,
+    user_password: str,
+    time_out: int = 60,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    console = Console(width=width, force_terminal=not jupyter, soft_wrap=True)
+    if (search_string is None) or (len(search_string) < 3):
+        raise ValueError(
+            "Invalid Search String - must be greater than four characters long"
+        )
+    g_client = AssetCatalog(server, url, username)
+    token = g_client.create_egeria_bearer_token(username, user_password)
+
+    def generate_table(search_string: str = None) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Assets containing the string  {search_string} @ {time.asctime()}",
+            header_style="white on dark_blue",
+            style="bold white on black",
+            row_styles=["bold white on black"],
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"View Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+        table.add_column("Display Name / Qualified Name / GUID", width=36)
+        table.add_column("Type Name")
+        table.add_column("Technology Type")
+        # table.add_column("Qualified Name",max_width=15)
+        table.add_column("Matching Elements")
+
+        assets = g_client.find_in_asset_domain(
+            search_string,
+            starts_with=True,
+            ends_with=False,
+            ignore_case=True,
+            page_size=100,
+            time_out=time_out,
+        )
+        if type(assets) is str:
+            return table
+
+        for element in assets:
+            properties = element["properties"]
+            header = element["elementHeader"]
+            nested = element.get("matchingElements", "---")
+            qualified_name = properties["qualifiedName"]
+            display_name = Text(f"{properties.get("displayName", "---")}\n\n{qualified_name}\n\n"
+                                f"{header['guid']}", justify="center")
+
+            type_name = header["type"]["typeName"]
+            tech_type = properties.get("deployedImplementationType", "---")
+
+            match_tab = Table(expand=True)
+            match_tab.add_column("Type Name")
+            match_tab.add_column("GUID", width=36)
+            match_tab.add_column("Properties")
+
+            for match_t in nested:
+                match = match_t["elementHeader"]
+                match_type_name = match["type"]["typeName"]
+                matching_guid = match["guid"]
+                match_props = match_t["properties"]
+                match_details_md = ""
+                for key in match_props.keys():
+                    match_details_md += f"* {key}: {match_props[key]}\n"
+                match_details_out = Markdown(match_details_md)
+                match_tab.add_row(match_type_name, matching_guid, match_details_out)
+
+            table.add_row(display_name, type_name, tech_type, match_tab)
+
+        g_client.close_session()
+        return table
+
+    try:
+        # with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+        #     while True:
+        #         time.sleep(2)
+        #         live.update(generate_table())
+
+        with console.pager(styles=True):
+            console.print(generate_table(search_string), soft_wrap=True)
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        console.print_exception()
+        sys.exit(1)
+
+    except ValueError as e:
+        console.print(
+            f"\n\n====> Invalid Search String - must be greater than four characters long"
+        )
+        sys.exit(1)
+
+
+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:
+        search_string = Prompt.ask("Enter an asset search string:", default="")
+        display_assets(search_string, server, url, userid, user_pass, time_out)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()