pyegeria 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

pyegeria-0.3.4.data/scripts/gov_engine_status.py

@@ -0,0 +1,120 @@
+#!python
+"""
+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 Governance Actions
+"""
+
+import time
+import json
+import argparse
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from rich.table import Table
+from rich.live import Live
+from rich import box
+from rich import console
+
+from pyegeria.server_operations import ServerOps
+from pyegeria.gov_engine import GovEng
+
+disable_ssl_warnings = True
+
+good_platform1_url = "https://127.0.0.1:9443"
+good_platform2_url = "https://egeria.pdr-associates.com:7443"
+bad_platform1_url = "https://localhost:9443"
+
+# good_platform1_url = "https://127.0.0.1:30080"
+# good_platform2_url = "https://127.0.0.1:30081"
+# bad_platform1_url = "https://localhost:9443"
+
+good_user_1 = "garygeeke"
+good_user_2 = "erinoverview"
+bad_user_1 = "eviledna"
+bad_user_2 = ""
+
+good_server_1 = "active-metadata-store"
+good_server_2 = "simple-metadata-store"
+good_server_3 = "engine-host"
+good_server_4 = "engine-host"
+bad_server_1 = "coco"
+bad_server_2 = ""
+
+
+def display_gov_actions_status(server: str = good_server_3, url: str = good_platform1_url, username: str = good_user_1):
+    server_name = server
+    s_client = ServerOps(server_name, url, username)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Governance Engine Status @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Server: '{server_name}' running on {url}",
+            expand=True
+        )
+        # table.footer: f"Server {server_name} on Platform {good_platform1_url}"
+        table.add_column("Gov Engine")
+        table.add_column("Gov Engine Type")
+        table.add_column("Gov Engine Desc")
+        table.add_column("Engine Status")
+        table.add_column("Request Types")
+
+        gov_eng_status = s_client.get_governance_engine_summaries()
+        for engine in gov_eng_status:
+            gov_eng = engine["governanceEngineName"]
+            eng_type = engine["governanceEngineTypeName"]
+
+            eng_desc = engine["governanceEngineDescription"]
+            eng_req_type = json.dumps(engine["governanceRequestTypes"], indent = 2)
+            status = engine["governanceEngineStatus"]
+            if status in ("RUNNING"):
+                eng_status = f"[green]{status}"
+            elif status in ("FAILED"):
+                eng_status = f"[red]{status}"
+            else: eng_status = f"[yellow]{status}"
+
+            table.add_row(
+                gov_eng, eng_type, eng_desc, eng_status,eng_req_type
+            )
+
+        table.caption = f"Server {server_name} running on {url}"
+        return table
+
+    try:
+        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)
+        assert e.related_http_code != "200", "Invalid parameters"
+
+    finally:
+        s_client.close_session()
+
+
+if __name__ == "__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 "engine-host"
+    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_gov_actions_status(server=server, url=url, username=userid)

pyegeria-0.3.4.data/scripts/integration_daemon_status.py

@@ -0,0 +1,130 @@
+#!python
+"""
+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 time
+
+from rich import box
+from rich.live import Live
+from rich.table import Table
+from rich import console
+
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.server_operations import ServerOps
+
+disable_ssl_warnings = True
+
+good_platform1_url = "https://127.0.0.1:9443"
+good_platform2_url = "https://egeria.pdr-associates.com:7443"
+bad_platform1_url = "https://localhost:9443"
+
+good_user_1 = "garygeeke"
+good_user_2 = "erinoverview"
+bad_user_1 = "eviledna"
+bad_user_2 = ""
+
+good_server_1 = "active-metadata-store"
+good_server_2 = "simple-metadata-store"
+good_server_3 = "view-server"
+good_server_4 = "engine-host"
+bad_server_1 = "coco"
+bad_server_2 = ""
+
+
+def display_integration_daemon_status(server: str = good_server_4, url: str = good_platform1_url,
+                                      user: str = good_user_1):
+    s_client = ServerOps(server, url, user)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Integration Daemon Status @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Integration Daemon Status for Server '{server}' @ Platform - {url}",
+            expand=True
+        )
+        table.add_column("Connector Name")
+        table.add_column("Connector Status")
+
+        table.add_column("Last Refresh Time")
+        table.add_column("Minimum Refresh Interval (min)")
+        table.add_column("Target Element")
+        table.add_column("Exception Message")
+
+        daemon_status = s_client.get_integration_daemon_status()
+        connector_reports = daemon_status["integrationConnectorReports"]
+        for connector in connector_reports:
+            connector_name = connector["connectorName"]
+            connector_status = connector["connectorStatus"]
+            last_refresh_time = connector.get("lastRefreshTime","---")
+            refresh_interval = str(connector.get("minMinutesBetweenRefresh","---"))
+            target_element = " "
+            exception_msg = " "
+
+            if connector_name is None:
+                connector_name = "connector name"
+            if connector_status is None:
+                connector_status = "connector status"
+
+            if connector_status in ("RUNNING", "REFRESHING", "WAITING"):
+                connector_status = f"[green]{connector_status}"
+            elif connector_status in ("INITIALIZE FAILED","CONFIG_FAILED","FAILED"):
+                connector_status = f"[red]{connector_status}"
+            else:
+                connector_status = f"[yellow]{connector_status}"
+
+            # target= action.get("actionTargetElements","Empty")
+            # if type(target) is list:
+            #     target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
+            # else:
+            #     target_element = " "
+
+            table.add_row(
+                connector_name,connector_status,last_refresh_time,refresh_interval,
+                target_element, exception_msg
+            )
+        return table
+
+    try:
+        with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+            while True:
+                time.sleep(2)
+                live.update(generate_table())
+                live.console.pager()
+
+    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+        print_exception_response(e)
+        assert e.related_http_code != "200", "Invalid parameters"
+
+    finally:
+        s_client.close_session()
+
+
+if __name__ == "__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 "integration-daemon"
+    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_integration_daemon_status(server=server, url=url, user=userid)

pyegeria-0.3.4.data/scripts/list_asset_types.py

@@ -0,0 +1,114 @@
+#!python
+"""
+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 display for my profile
+"""
+
+import argparse
+import time
+
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    RegisteredInfo
+)
+
+disable_ssl_warnings = True
+
+good_platform1_url = "https://127.0.0.1:9443"
+good_platform2_url = "https://egeria.pdr-associates.com:7443"
+bad_platform1_url = "https://localhost:9443"
+
+# good_platform1_url = "https://127.0.0.1:30080"
+# good_platform2_url = "https://127.0.0.1:30081"
+# bad_platform1_url = "https://localhost:9443"
+
+good_user_1 = "garygeeke"
+good_user_2 = "erinoverview"
+bad_user_1 = "eviledna"
+bad_user_2 = ""
+
+good_server_1 = "active-metadata-store"
+good_server_2 = "simple-metadata-store"
+good_server_3 = "view-server"
+good_server_4 = "engine-host"
+bad_server_1 = "coco"
+bad_server_2 = ""
+
+
+def display_asset_types(server: str = good_server_3, url: str = good_platform1_url, username: str = good_user_2):
+    r_client = RegisteredInfo(good_platform1_url, good_user_2, "secret",
+                              server_name=good_server_3, )
+    token = r_client.create_egeria_bearer_token(good_user_2, "secret")
+    asset_types = r_client.list_asset_types()
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Asset Types for: {good_platform1_url} @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Asset Types from Server '{server}' @ Platform - {url}",
+            expand=True
+        )
+
+        table.add_column("Name")
+        table.add_column("Description")
+        table.add_column("SuperType")
+        table.add_column("Version")
+
+        name = " "
+        description = " "
+        version = " "
+        super_type = " "
+        if len(asset_types) > 0:
+            for a_type in asset_types:
+                name = a_type.get("name", "none")
+                description = a_type.get("description", "none")
+                version = a_type.get("version", " ")
+                super_type = a_type.get("superType", "none")
+                table.add_row(
+                    name, description, str(version), super_type
+                )
+        return table
+
+    try:
+        console = Console()
+        with console.pager():
+            console.print(generate_table())
+
+    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+        print_exception_response(e)
+        assert e.related_http_code != "200", "Invalid parameters"
+    finally:
+        r_client.close_session()
+
+
+if __name__ == "__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 "view-server"
+    url = args.url if args.url is not None else "https://localhost:9443"
+    userid = args.userid if args.userid is not None else 'erinoverview'
+    # guid = args.guid if args.guid is not None else None
+    guid = None
+
+    display_asset_types(server, url, userid)

pyegeria-0.3.4.data/scripts/multi-server_status.py

@@ -0,0 +1,123 @@
+#!python
+"""
+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
+"""
+
+import time
+import argparse
+
+from rich.box import Box
+
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from rich.table import Table
+from rich.live import Live
+from rich import print
+from rich.console import Group
+from rich.panel import Panel
+from rich import box, align
+from rich.layout import Layout
+import rich
+from pyegeria.server_operations import ServerOps
+
+disable_ssl_warnings = True
+
+good_platform1_url = "https://127.0.0.1:9443"
+good_platform2_url = "https://egeria.pdr-associates.com:9443"
+bad_platform1_url = "https://localhost:9443"
+
+
+good_user_1 = "garygeeke"
+good_user_2 = "erinoverview"
+bad_user_1 = "eviledna"
+bad_user_2 = ""
+
+good_server_1 = "active-metadata-store"
+good_server_2 = "simple-metadata-store"
+good_server_3 = "view-server"
+good_server_4 = "engine-host"
+bad_server_1 = "coco"
+bad_server_2 = ""
+
+
+def test_display_status(server: str = good_server_1, url: str = good_platform2_url, username: str = good_user_1):
+    layout = Layout()
+    print(layout)
+
+    print(layout)
+    p_client1 = ServerOps(server, "https://cray.local:9443", username)
+    p_client2 = ServerOps('ecosystem-monitor', "https://cray.local:9446", username)
+
+
+    def generate_table(p_client) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Server Status for Platform - {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            caption=f"Server Status for 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 len(known_server_list) == 0:
+            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",
+                          )
+        # p_client.close_session()
+        return table
+
+    try:
+        # panel_group = Group(
+        #     rich.align.Align(Panel(, generate_table(p_client2)), box.ROUNDED))
+        #
+        # )
+        layout.split_row(
+            Layout(Panel(generate_table(p_client1), box.ROUNDED)),
+            Layout(Panel(generate_table(p_client2), 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)
+        assert e.related_http_code != "200", "Invalid parameters"
+
+
+if __name__ == "__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://cray.local:9443"
+    userid = args.userid if args.userid is not None else 'garygeeke'
+
+    test_display_status(server, url, userid)

pyegeria-0.3.4.data/scripts/my_todos.py

@@ -0,0 +1,162 @@
+#!python
+"""
+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 of a user's todos
+"""
+
+import argparse
+import json
+import time
+
+from rich import box
+from rich.live import Live
+from rich.table import Table
+from rich import console
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.gov_engine import GovEng
+from pyegeria.my_profile_omvs import MyProfile
+disable_ssl_warnings = True
+
+good_platform1_url = "https://127.0.0.1:9443"
+good_platform2_url = "https://egeria.pdr-associates.com:7443"
+bad_platform1_url = "https://localhost:9443"
+
+# good_platform1_url = "https://127.0.0.1:30080"
+# good_platform2_url = "https://127.0.0.1:30081"
+# bad_platform1_url = "https://localhost:9443"
+
+good_user_1 = "garygeeke"
+good_user_2 = "erinoverview"
+bad_user_1 = "eviledna"
+bad_user_2 = ""
+
+good_server_1 = "active-metadata-store"
+good_server_2 = "simple-metadata-store"
+good_server_3 = "view-server"
+good_server_4 = "engine-host"
+bad_server_1 = "coco"
+bad_server_2 = ""
+
+
+def display_todos(server: str = good_server_4, url: str = good_platform1_url, user: str = good_user_1):
+    m_client = MyProfile(server, url, user_id=user)
+    token = m_client.create_egeria_bearer_token(user, "secret")
+
+    def add_rows(table: Table, guid: str, identity: str) -> None:
+        todo_items = m_client.get_assigned_actions(guid)
+        if type(todo_items) is str:
+            return
+
+        for item in todo_items:
+            assigned_actors = [" "]
+            if todo_items is None:
+                name = " "
+                type_name = " "
+                todo_guid = " "
+                created = " "
+                priority = " "
+                due = " "
+                completed = " "
+                status = " "
+                sponsor = " "
+            else:
+                props = item["properties"]
+                name = props["name"]
+                todo_type_name = props.get("toDoType", " ")
+                todo_guid = item["elementHeader"]["guid"]
+                created = props.get("creationTime", " ")
+                priority = str(props.get("priority", " "))
+                due = props.get("dueTime", " ")
+                completed = props.get("completionTime", " ")
+                status = props.get("status")
+
+                for actor in item["assignedActors"]:
+                    assigned_actors.append(actor.get("uniqueName", "NoOne"))
+                if status in ("WAITING", "OPEN"):
+                    status = f"[yellow]{status}"
+                elif status in ("INPROGRESS", "COMPLETE"):
+                    status = f"[green]{status}"
+                else:
+                    status = f"[red]{status}"
+
+            table.add_row(
+                str(identity), name, todo_type_name, todo_guid, created, priority, due,
+                completed, status, str(assigned_actors)
+            )
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Open ToDos for Platform {good_platform1_url} @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"ToDos for Server '{server}' @ Platform - {url}",
+            expand=True
+        )
+        table.add_column("Actor")
+        table.add_column("ToDo Name")
+        table.add_column("Type Name")
+        table.add_column("GUID")
+        table.add_column("Created")
+        table.add_column("Priority")
+        table.add_column("Due")
+        table.add_column("Completion")
+        table.add_column("Status")
+        table.add_column("Sponsor")
+
+        my_profile = m_client.get_my_profile()
+        my_guid = my_profile["elementHeader"]["guid"]
+        my_ids = my_profile["userIdentities"]
+        my_title = my_profile["profileProperties"].get("jobTitle", "No Title")
+        user_ids = []
+        for id in my_ids:
+            user_ids.append(id["userIdentity"]["properties"].get("userId", "NoOne"))
+        add_rows(table, my_guid, user_ids)
+
+        my_roles = my_profile["roles"]
+        if type(my_roles) is list:
+            for role in my_roles:
+                role_guid = role["elementHeader"]["guid"]
+                role_title = role["properties"].get("title","No Title")
+                add_rows(table,role_guid,role_title)
+
+        # m_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())
+                live.console.pager()
+
+    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+        print_exception_response(e)
+        assert e.related_http_code != "200", "Invalid parameters"
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the view server to connect to")
+    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 "view-server"
+    url = args.url if args.url is not None else "https://localhost:9443"
+    userid = args.userid if args.userid is not None else 'erinoverview'
+    print(f"Starting display_todos with {server}, {url}, {userid}")
+    display_todos(server=server, url=url, user=userid)