pyegeria 0.8.4.9__py3-none-any.whl → 0.8.4.10__py3-none-any.whl

examples/widgets/ops/monitor_coco_status.py

@@ -0,0 +1,103 @@
+#!/usr/bin/python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple server status display for the Coco Pharmaceuticals Configuration
+"""
+
+import argparse
+import time
+
+from rich import box
+from rich import print
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.server_operations import ServerOps
+
+disable_ssl_warnings = True
+
+
+def display_status(server: str, url: str, username: str):
+    layout = Layout()
+
+    p_client1 = ServerOps("Core Catalog", "https://localhost:9443", username)
+    p_client2 = ServerOps('Datalake Catalog', "https://localhost:9444", username)
+    p_client3 = ServerOps('DevCatalog', "https://localhost:9445", username)
+
+    def generate_table(p_client) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Server Status for {p_client.server_name}- {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            caption=f"Server Status for Platform - '{p_client.platform_url}'",
+            # show_lines=True,
+        )
+
+        table.add_column("Known Server")
+        table.add_column("Status")
+        known_server_list = p_client.get_known_servers()
+        active_server_list = p_client.get_active_server_list()
+        if type(known_server_list) is str:
+            return table
+
+        for server in known_server_list:
+            if server in active_server_list:
+                status = "Active"
+            else:
+                status = "Inactive"
+
+            table.add_row(server,
+                          "[red]Inactive" if status == "Inactive" else "[green]Active",
+                          )
+        return table
+
+    try:
+        layout.split_row(
+            Layout(Panel(generate_table(p_client1), box.ROUNDED)),
+            Layout(Panel(generate_table(p_client2), box.ROUNDED)),
+            Layout(Panel(generate_table(p_client3), box.ROUNDED))
+        )
+        with Live(layout, refresh_per_second=4, screen=True) as live:
+            while True:
+                time.sleep(2)
+                live.update(layout)
+
+    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        p_client1.close_session()
+        p_client2.close_session()
+        p_client3.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")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else "active-metadata-store"
+    url = args.url if args.url is not None else "https://localhost:9443"
+    userid = args.userid if args.userid is not None else 'garygeeke'
+
+    display_status(server, url, userid)
+
+if __name__ == "__main__":
+    main()

examples/widgets/ops/monitor_engine_activity.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display for Engine Actions
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from pyegeria import AutomatedCuration
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    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_ENGINE_HOST = os.environ.get("INTEGRATION_ENGINE_HOST", "engine-host")
+EGERIA_ENGINE_HOST_URL = os.environ.get(
+    "INTEGRATION_ENGINE_HOST_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_engine_activity(
+    server: str,
+    url: str,
+    user: str,
+    user_pass: str,
+    paging: bool,
+    jupyter: bool = EGERIA_JUPYTER,
+    width=EGERIA_WIDTH,
+):
+    g_client = AutomatedCuration(server, url, user, user_pwd=user_pass)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Engine Action Status for Platform {url} @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold 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"Engine Status for Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+        table.add_column("Requested Time")
+        table.add_column("Start Time")
+        table.add_column("Action GUID", no_wrap=True)
+        table.add_column("Engine Name")
+        table.add_column("Request Type")
+        table.add_column("Action Status")
+        table.add_column("Target Element")
+        table.add_column("Completion Time")
+        table.add_column("Process Name")
+        table.add_column("Completion Message")
+
+        token = g_client.create_egeria_bearer_token()
+        action_status = g_client.get_engine_actions()
+
+        if type(action_status) is str:
+            requested_time = " "
+            start_time = " "
+            completion_time = " "
+            engine_name = " "
+            request_type = " "
+            action_status = " "
+            target_element = " "
+            process_name = " "
+            completion_message = " "
+        elif type(action_status) is list:
+            sorted_action_status = sorted(
+                action_status,
+                key=lambda i: i.get("requestedTime", time.asctime()),
+                reverse=True,
+            )
+            for action in sorted_action_status:
+                requested_time = action.get("requestedTime", " ")
+                start_time = action.get("startTime", " ")
+                completion_time = action.get("completionTime", " ")
+
+                engine_name = action["governanceEngineName"]
+                request_type = action["requestType"]
+                action_guid = action["elementHeader"]["guid"]
+                if action["actionStatus"] in (
+                    "REQUESTED",
+                    "APPROVED",
+                    "WAITING",
+                    "ACTIVATING",
+                ):
+                    action_status = f"[yellow]{action['actionStatus']}"
+                elif action["actionStatus"] in ("IN_PROGRESS", "ACTIONED"):
+                    action_status = f"[green]{action['actionStatus']}"
+                else:
+                    action_status = f"[red]{action['actionStatus']}"
+
+                targets = action.get("actionTargetElements", "Empty")
+                if type(targets) is list:
+                    tgt_tab = Table()
+                    tgt_tab.add_column("name")
+                    tgt_tab.add_column("guid", no_wrap=True)
+                    tgt_tab.add_column("type_name")
+                    targets_md = ""
+                    for target in targets:
+                        t_name = target["actionTargetName"]
+                        t_guid = target["actionTargetGUID"]
+                        t_type = target["targetElement"]["type"]["typeName"]
+                        tgt_tab.add_row(t_name, t_guid, t_type)
+                    # target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
+                    target_element = tgt_tab
+                else:
+                    target_element = " "
+
+                process_name = action.get("processName", " ")
+                completion_message = action.get("completionMessage", " ")
+
+                table.add_row(
+                    requested_time,
+                    start_time,
+                    action_guid,
+                    engine_name,
+                    request_type,
+                    action_status,
+                    target_element,
+                    completion_time,
+                    process_name,
+                    completion_message,
+                )
+        else:
+            print("Egeria integration daemon not running")
+            sys.exit()
+
+        return table
+
+    try:
+        if paging is True:
+            console = Console(width=width, force_terminal=not jupyter)
+            with console.pager():
+                console.print(generate_table())
+        else:
+            with Live(
+                generate_table(),
+                refresh_per_second=1,
+                screen=True,
+                vertical_overflow="visible",
+            ) as live:
+                while True:
+                    time.sleep(2)
+                    live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        g_client.close_session()
+
+
+def main_live():
+    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")
+
+    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_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
+
+    display_engine_activity(
+        server=server, url=url, user=userid, user_pass=user_pass, paging=False
+    )
+
+
+def main_paging():
+    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")
+
+    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_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
+
+    display_engine_activity(
+        server=server, url=url, user=userid, user_pass=user_pass, paging=True
+    )
+
+
+if __name__ == "__main__":
+    main_live()
+
+if __name__ == "__main_paging__":
+    main_paging()

examples/widgets/ops/monitor_engine_activity_c.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display for Engine Actions
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+
+from pyegeria import AutomatedCuration
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("EGERIA_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_ENGINE_HOST = os.environ.get("EGERIA_ENGINE_HOST", "engine-host")
+EGERIA_ENGINE_HOST_URL = os.environ.get(
+    "EGERIA_ENGINE_HOST_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON", "integration-daemon"
+)
+EGERIA_ADMIN_USER = os.environ.get("EGERIA_ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("EGERIA_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_engine_activity_c(
+    server: str,
+    url: str,
+    user: str,
+    user_pass: str,
+    paging: bool,
+    jupyter: bool = EGERIA_JUPYTER,
+    width=EGERIA_WIDTH,
+):
+    g_client = AutomatedCuration(server, url, user, user_pwd=user_pass)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Engine Action Status for Platform {url} @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold 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"Engine Status for Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+        table.add_column("Requested Time")
+        table.add_column("Core Info")
+        table.add_column("Target Elements")
+
+        table.add_column("Action Status")
+        table.add_column("Completion Time")
+        table.add_column("Core Results")
+        # table.add_column("Completion Message")
+
+        token = g_client.create_egeria_bearer_token()
+        action_status = g_client.get_engine_actions()
+
+        if type(action_status) is str:
+            requested_time = " "
+            start_time = " "
+            completion_time = " "
+            engine_name = " "
+            request_type = " "
+            action_status = " "
+            target_element = " "
+            process_name = " "
+            completion_message = " "
+        elif type(action_status) is list:
+            sorted_action_status = sorted(
+                action_status,
+                key=lambda i: i.get("requestedTime", time.asctime()),
+                reverse=True,
+            )
+            for action in sorted_action_status:
+                requested_time = action.get("requestedTime", " ")[:-10]
+                start_time = action.get("startTime", " ")[:-10]
+                completion_time = action.get("completionTime", " ")[:-10]
+                completion_guards = action.get("completionGuards", " ")
+
+                engine_name = action["governanceEngineName"]
+                request_type = action["requestType"]
+                action_guid = action["elementHeader"]["guid"]
+                if action["actionStatus"] in (
+                    "REQUESTED",
+                    "APPROVED",
+                    "WAITING",
+                    "ACTIVATING",
+                ):
+                    action_status = f"[yellow]{action['actionStatus']}"
+                elif action["actionStatus"] in ("IN_PROGRESS", "ACTIONED"):
+                    action_status = f"[green]{action['actionStatus']}"
+                else:
+                    action_status = f"[red]{action['actionStatus']}"
+
+                request_parameters_md = " "
+                request_parameters = action.get("requestParameters", "Empty")
+                if type(request_parameters) is dict:
+                    for key, value in request_parameters.items():
+                        request_parameters_md += f"\t* {key}: {value}\n"
+
+                targets = action.get("actionTargetElements", "Empty")
+                if type(targets) is list:
+                    targets_md = ""
+                    for target in targets:
+                        t_name = target["actionTargetName"]
+                        t_guid = target["actionTargetGUID"]
+                        t_type = target["targetElement"]["type"]["typeName"]
+                        targets_md += (
+                            f"* Target Name: {t_name}\n"
+                            f"   * Target GUID: {t_guid}\n"
+                            f"   * Target Type: {t_type}\n"
+                        )
+
+                    # target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
+                    target_element = Markdown(f"{targets_md} ---\n")
+                else:
+                    target_element = " "
+
+                process_name = action.get("processName", "Null")
+                completion_message = action.get("completionMessage", " ")
+                core_results_md = (
+                    f"* Completion Guards: {completion_guards}\n"
+                    f"* Completion Message: {completion_message}"
+                )
+                core_results_out = Markdown(core_results_md)
+                core_info_md = (
+                    f"* Start Time: {start_time}\n* Engine Name: {engine_name}\n* GUID: {action_guid}\n"
+                    f"* Request Type: {request_type}\n"
+                    f"* Process Name: {process_name}\n"
+                    f"---\n"
+                    f"* Request Parameters: \n{request_parameters_md}\n"
+                )
+                core_info_out = Markdown(core_info_md)
+                table.add_row(
+                    requested_time,
+                    core_info_out,
+                    target_element,
+                    action_status,
+                    completion_time,
+                    core_results_out,
+                )
+        else:
+            print("Egeria integration daemon not running")
+            sys.exit()
+
+        return table
+
+    try:
+        if paging is True:
+            console = Console(width=width, force_terminal=not jupyter)
+            with console.pager():
+                console.print(generate_table())
+        else:
+            with Live(
+                generate_table(),
+                refresh_per_second=1,
+                screen=True,
+                vertical_overflow="visible",
+            ) as live:
+                while True:
+                    time.sleep(2)
+                    live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        g_client.close_session()
+
+
+def main_live():
+    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")
+
+    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_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
+
+    display_engine_activity_c(
+        server=server, url=url, user=userid, user_pass=user_pass, paging=False
+    )
+
+
+def main_paging():
+    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")
+
+    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_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
+
+    display_engine_activity_c(
+        server=server, url=url, user=userid, user_pass=user_pass, paging=True
+    )
+
+
+if __name__ == "__main__":
+    main_live()
+
+if __name__ == "__main_paging__":
+    main_paging()