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

pyegeria/commands/tech/list_registered_services.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+A simple widget to retrieve the registered services.
+
+"""
+
+import argparse
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    RegisteredInfo,
+)
+
+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"))
+
+
+def display_registered_svcs(
+    service: str,
+    server: str,
+    url: str,
+    username: str,
+    password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    """Display the registered services list
+    Parameters
+    ----------
+    service : str, optional
+        The type of service to display information for. Default is "help".
+
+    server : str, optional
+        The server to connect to. Default is `default_server`.
+
+    url : str, optional
+        The platform URL. Default is `default_platform`.
+
+    username : str, optional
+        The username for authentication. Default is `default_user`.
+
+    password : str, optional
+        The password for authentication. Default is `default_password`.
+    """
+
+    def generate_table(svc_list) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Services for: {url} @ {time.asctime()}",
+            style="bold bright_white on black",
+            row_styles=["bold bright_white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Registered Services from Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+        table.add_column("Service Id")
+        table.add_column("Service Name")
+        table.add_column("Service  Development Status")
+        table.add_column("URL Marker")
+        table.add_column("Description")
+        table.add_column("Wiki", no_wrap=True)
+        table.add_column("Server Type")
+        table.add_column("Partner Service Name")
+        table.add_column("Partner Service Type")
+
+        if type(svc_list) is list:
+            for svc in svc_list:
+                svc_id = str(svc.get("serviceId", " "))
+                svc_name = svc.get("serviceName", "b")
+                svc_dev_status = svc.get("serviceDevelopmentStatus", " ")
+                svc_url_marker = svc.get("serviceUrlMarker", " ")
+                svc_description = svc.get("serviceDescription", " ")
+                svc_wiki = svc.get("serviceWiki", " ")
+                svc_partner_svc_name = svc.get("partnerServiceName", " ")
+                svc_partner_svc_type = svc.get("partnerServiceType", " ")
+
+                table.add_row(
+                    svc_id,
+                    svc_name,
+                    svc_dev_status,
+                    svc_url_marker,
+                    svc_description,
+                    svc_wiki,
+                    svc_partner_svc_name,
+                    svc_partner_svc_type,
+                )
+            return table
+        elif type(svc_list) is str:
+            help = """
+            The kinds of services that you can get more information include:
+                all.....................lists all registered services
+                access-services.........lists all registered access services
+                common-services.........lists all registered common services
+                engine-services.........lists all registered engine services
+                governance-services.....lists all registered governance services
+                integration-services....lists all registered integration services
+                view-services...........lists all registered view services
+                
+                Pass in a parameter from the left-hand column into the function to 
+                get more details on the specified service category.
+            """
+            console.print(help)
+
+        else:
+            print("Unknown service type")
+            sys.exit(1)
+
+    console = Console(width=width, force_terminal=not jupyter)
+    try:
+        a_client = RegisteredInfo(server, url, username)
+        # token = a_client.create_egeria_bearer_token(username, password)
+        svc_list = a_client.list_registered_svcs(service)
+
+        with console.pager(styles=True):
+            console.print(generate_table(svc_list))
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        console.print_exception(show_locals=True)
+    finally:
+        a_client.close_session()
+
+
+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="Password")
+
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_METADATA_STORE
+    url = args.url if args.url is not None else EGERIA_PLATFORM_URL
+    userid = args.userid if args.userid is not None else EGERIA_ADMIN_USER
+    password = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    try:
+        svc_kind = Prompt.ask(
+            "Enter the service type you are searching for:", default="all"
+        )
+        display_registered_svcs(svc_kind, server, url, userid, password=password)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/tech/list_related_elements.py

@@ -0,0 +1,207 @@
+"""This creates a templates guid file from the core metadata archive"""
+from jedi import Project
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+import os
+import argparse
+import time
+import sys
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    EgeriaTech,
+)
+
+console = Console()
+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", "220"))
+
+
+def list_related_elements(
+    element_guid: str,
+    om_type: str,
+    relationship_type: str,
+    server: str,
+    url: str,
+    username: str,
+    password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    c_client = EgeriaTech(server, url, user_id=username, user_pwd=password)
+    token = c_client.create_egeria_bearer_token()
+
+    if om_type is not None:
+        om_typedef = c_client.get_typedef_by_name(om_type)
+        if type(om_typedef) is str:
+            print(
+                f"The type name '{om_type}' is not known to the Egeria platform at {url} - {server}"
+            )
+            sys.exit(1)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            caption=f"Metadata Elements for: {url} - {server} @ {time.asctime()}",
+            style="bold bright_white on black",
+            row_styles=["bold bright_white on black"],
+            header_style="white on dark_blue",
+            title_style="bold bright_white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            title=f"Elements related to: '{element_guid}' ",
+            expand=True,
+            # width=500
+        )
+        table.add_column("Relationship GUID", width=38, no_wrap=True)
+        table.add_column("Rel Header", width=38, no_wrap=True)
+        table.add_column("Relationship Props")
+        table.add_column("Related GUID", width=38, no_wrap=True)
+        table.add_column("Properties")
+        table.add_column("Element Header")
+
+        elements = c_client.get_related_elements(
+            element_guid, relationship_type, om_type
+        )
+
+        if type(elements) is list:
+            for element in elements:
+                header = element["relationshipHeader"]
+                el_type = header["type"]["typeName"]
+                el_home = header["origin"]["homeMetadataCollectionName"]
+                el_create_time = header["versions"]["createTime"][:-10]
+                el_guid = header["guid"]
+                el_class = header.get("classifications", "---")
+                rel_header_md = (
+                    f"* Type: {el_type}\n"
+                    f"* Home: {el_home}\n"
+                    f"* Created: {el_create_time}\n"
+                )
+                rel_header_out = Markdown(rel_header_md)
+                rel_props = element.get("relationshipProperties", "---")
+
+                rel_props_md = ""
+                if type(rel_props) is list:
+                    for prop in rel_props.keys():
+                        rel_props_md += (
+                            f"* **{prop}**: {element['relationshipProperties'][prop]}\n"
+                        )
+                rel_props_out = Markdown(rel_props_md)
+
+                c_md = ""
+                if type(el_class) is list:
+                    for classification in el_class:
+                        classification_name = classification.get(
+                            "classificationName", "---"
+                        )
+                        c_md = f"* **{classification_name}**\n"
+                        class_props = classification.get(
+                            "classificationProperties", "---"
+                        )
+                        if type(class_props) is dict:
+                            for prop in class_props.keys():
+                                c_md += f"  * **{prop}**: {class_props[prop]}\n"
+                c_md_out = Markdown(c_md)
+
+                rel_element = element["relatedElement"]
+                rel_el_header = rel_element["elementHeader"]
+                rel_type = rel_el_header["type"]["typeName"]
+                rel_home = rel_el_header["origin"]["homeMetadataCollectionName"]
+                rel_guid = rel_el_header["guid"]
+
+                rel_el_header_md = f"* Type: {rel_type}\n" f"* Home: {rel_home}\n"
+                rel_el_header_out = Markdown(rel_el_header_md)
+
+                rel_el_props_md = ""
+                for prop in rel_element["properties"].keys():
+                    rel_el_props_md += (
+                        f"* **{prop}**: {rel_element['properties'][prop]}\n"
+                    )
+                rel_el_props_out = Markdown(rel_el_props_md)
+
+                table.add_row(
+                    el_guid,
+                    rel_header_out,
+                    rel_props_out,
+                    # el_q_name,
+                    rel_guid,
+                    rel_el_props_out,
+                    rel_el_header_out,
+                )
+
+            return table
+        else:
+            print("No instances found")
+            sys.exit(1)
+
+    try:
+        console = Console(width=width, force_terminal=not jupyter)
+
+        with console.pager(styles=True):
+            console.print(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+        print("\n\nPerhaps the type name isn't known")
+    finally:
+        c_client.close_session()
+
+
+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="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
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    password = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    try:
+        element_guid = Prompt.ask("Guid of base element").strip()
+        om_type = Prompt.ask(
+            "Enter the Open Metadata Type to find elements of", default=None
+        )
+        relationship_type = Prompt.ask("Enter the relationship type to follow")
+
+        om_type = om_type.strip() if type(om_type) is str else None
+        relationship_type = (
+            None if len(relationship_type) == 0 else relationship_type.strip()
+        )
+
+        list_related_elements(
+            element_guid, om_type, relationship_type, server, url, userid, password
+        )
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/tech/list_related_specification.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+List elements related to given element guid by the specified relationship type. Optionally filter by a specified
+open metadata type.
+
+"""
+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 pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    ClassificationManager,
+)
+
+console = Console()
+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"))
+
+
+def display_related_specification(
+    element_guid: str,
+    server: str,
+    url: str,
+    username: str,
+    password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    c_client = ClassificationManager(server, url, user_id=username, user_pwd=password)
+    token = c_client.create_egeria_bearer_token()
+    rel_el = c_client.get_related_elements(
+        element_guid, "SpecificationPropertyAssignment", None
+    )
+
+    if type(rel_el) is str:
+        print(f"\n\nDid not find related specifications for {element_guid}\n\n")
+        sys.exit(0)
+
+    related_elements: dict = {}
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Specifications related to: {element_guid}  @ {time.asctime()}",
+            style="bold bright_white on black",
+            row_styles=["bold bright_white on black"],
+            header_style="white on dark_blue",
+            title_style="bold bright_white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Elements from Server '{server}' @ Platform - {url}",
+            expand=True,  # width=500
+        )
+
+        table.add_column("Name", justify="center", style="bold bright_white")
+        table.add_column("Specification", justify="center", style="bold bright_white")
+
+        for element in rel_el:
+            relationship_props = element["relationshipProperties"]["propertyType"]
+            related_elements[relationship_props] = []
+
+        for element in rel_el:
+            relationship_props = element["relationshipProperties"]["propertyType"]
+
+            rel_element = element["relatedElement"]
+            el = rel_element["properties"]
+            re: dict = {}
+
+            re["case"] = el.get("isCaseSensitive", "---")
+            re["name"] = el.get("preferredValue", "---")
+            re["description"] = el.get("description", "---")
+            add = el.get("additionalProperties", "---")
+            if type(add) is str:
+                re["additional"] = add
+            else:
+                add_md = ""
+                for k in add.keys():
+                    add_md += f"* {k}: {add[k]}\n"
+                re["additional"] = Markdown(add_md)
+
+            related_elements[relationship_props].append(re)
+
+        for kind in related_elements.keys():
+            spec_table = Table(expand=False, show_lines=True)
+            spec_table.add_column("Name")
+            spec_table.add_column("Case Sensitive?")
+            spec_table.add_column("Description")
+            spec_table.add_column("Additional Properties")
+
+            for spec_row in related_elements[kind]:
+                name = spec_row["name"]
+                case = spec_row["case"]
+                desc = spec_row["description"]
+                additional_props = spec_row["additional"]
+                spec_table.add_row(name, case, desc, additional_props)
+
+            table.add_row(kind, spec_table)
+
+        return table
+
+    try:
+        console = Console(width=width, force_terminal=not jupyter)
+
+        with console.pager(styles=True):
+            console.print(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+        assert e.related_http_code != "200", "Invalid parameters"
+    finally:
+        c_client.close_session()
+
+
+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="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
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    password = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    guid = None
+
+    try:
+        element_guid = Prompt.ask("Enter an Element GUID find relationships for")
+
+        display_related_specification(element_guid, server, url, userid, password)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()