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

pyegeria/commands/ops/table_integ_daemon_status.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+A simple status display for the Integration Daemon.
+
+
+"""
+import os
+import time
+from typing import Union
+
+import nest_asyncio
+from rich import box
+from rich.table import Table
+from textual.widgets import DataTable
+
+from pyegeria import EgeriaTech
+from pyegeria._exceptions 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_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+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 add_row(
+    table: Union[Table, DataTable],
+    connector_name: str,
+    connector_status: str,
+    last_refresh_time: str,
+    refresh_interval: str,
+    targets_out,
+    exception_msg,
+) -> Table | DataTable:
+    table.add_row(
+        connector_name,
+        connector_status,
+        last_refresh_time,
+        refresh_interval,
+        targets_out,
+        exception_msg,
+    )
+    return table
+
+
+def display_integration_daemon_status(
+    integ_server: str = EGERIA_INTEGRATION_DAEMON,
+    integ_url: str = EGERIA_INTEGRATION_DAEMON_URL,
+    view_server: str = EGERIA_VIEW_SERVER,
+    view_url: str = EGERIA_VIEW_SERVER_URL,
+    user: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    paging: bool = True,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+    sort: bool = True,
+    data_table: bool = False,
+) -> Table | DataTable:
+    """Returns a table representing the status of connectors running on the specified Integration Daemon OMAG Server.
+    This routine is meant to be used in a python script or Jupyter Notebook where the resulting table is rendered
+    in either a Rich Console or a Textual Application.
+
+    Parameters
+    ----------
+    integ_server : str, optional
+        The name of the integration daemon server. Default is EGERIA_INTEGRATION_DAEMON.
+
+    integ_url : str, optional
+        The URL of the integration daemon server. Default is EGERIA_INTEGRATION_DAEMON_URL.
+
+    view_server : str, optional
+        The name of the view server. Default is EGERIA_VIEW_SERVER.
+
+    view_url : str, optional
+        The URL of the view server. Default is EGERIA_VIEW_SERVER_URL.
+
+    user : str, optional
+        The username for authentication. Default is EGERIA_USER.
+
+    user_pass : str, optional
+        The password for authenticated access. Default is EGERIA_USER_PASSWORD.
+
+    paging : bool, optional
+        Determines whether to use paging or a live monitor for console output. Default is True.
+
+    jupyter : bool, optional
+        Determines whether running in a Jupyter environment. Default is EGERIA_JUPYTER.
+
+    width : int, optional
+        The width of the console display. Default is EGERIA_WIDTH.
+
+    sort : bool, optional
+        Determines whether to sort the connector reports. Default is True.
+    data_table: bool, optional, default is False.
+        If True, a Textual DataTable widget is returned. If false, a Rich table is returned..
+
+    Returns
+    -------
+
+    Either a Rich Table or a Textual DataTable depending on the status of data_table
+    """
+
+    s_client = EgeriaTech(view_server, view_url, user, user_pass)
+    nest_asyncio.apply()
+
+    def generate_table() -> Table:
+        """Make a new table."""
+
+        if data_table:
+            table = DataTable()
+            table.add_columns(
+                "Connector Name",
+                "Status",
+                "Last Refresh Time",
+                "Min Refresh (Mins)",
+                "Target Element",
+                "Exception Message",
+            )
+        else:
+            table = Table(
+                title=f"Integration Daemon Status @ {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"Integration Daemon Status for Server '{integ_server}' @ Platform - {integ_url}",
+                expand=True,
+            )
+            table.add_column("Connector Name", min_width=15)
+            table.add_column("Status", max_width=6)
+            table.add_column("Last Refresh Time", min_width=12)
+            table.add_column("Min Refresh (mins)", max_width=6)
+            table.add_column("Target Element", min_width=20)
+            table.add_column("Exception Message", min_width=10)
+
+        # Now get the integration connector report
+        token = s_client.create_egeria_bearer_token()
+        daemon_status = s_client.get_server_report(None, integ_server)
+
+        reports = daemon_status["integrationConnectorReports"]
+        if sort is True:
+            connector_reports = sorted(
+                reports, key=lambda x: x.get("connectorName", "---")
+            )
+        else:
+            connector_reports = reports
+
+        for connector in connector_reports:
+            connector_name = connector.get("connectorName", "---")
+            connector_status = connector.get("connectorStatus", "---")
+            connector_guid = connector.get("connectorGUID", "---")
+            last_refresh_time = connector.get("lastRefreshTime", "---")[:-10]
+            refresh_interval = str(connector.get("minMinutesBetweenRefresh", "---"))
+            exception_msg = " "
+            if connector_guid != "---":
+                targets = s_client.get_catalog_targets(connector_guid)
+                tgt_tab = Table()
+                tgt_tab.add_column("Target")
+                tgt_tab.add_column("UniqueName")
+                tgt_tab.add_column("Relationship GUID", no_wrap=True)
+
+                if type(targets) == list:
+                    targets_md = True
+                    for target in targets:
+                        t_name = target["catalogTargetName"]
+                        # t_sync = target["permittedSynchronization"]
+                        t_unique_name = target["catalogTargetElement"]["uniqueName"]
+                        t_rel_guid = target["relationshipGUID"]
+                        # targets_m += f"* Target Name: __{t_name}__\n* Sync: {t_sync}\n* Unique Name: {t_unique_name}\n\n"
+                        tgt_tab.add_row(t_name, t_unique_name, t_rel_guid)
+                    # targets_md = Markdown(targets_m)
+                else:
+                    targets_md = False
+            else:
+                targets_md = False
+            if targets_md is False:
+                targets_out = ""
+            else:
+                targets_out = tgt_tab
+
+            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}"
+
+            add_row(
+                table,
+                connector_name,
+                connector_status,
+                last_refresh_time,
+                refresh_interval,
+                targets_out,
+                exception_msg,
+            )
+        return table
+
+    try:
+        return generate_table()
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        s_client.close_session()

pyegeria/commands/ops/x_engine_actions.py

@@ -0,0 +1,76 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+Execute engine actions.
+
+"""
+
+import click
+
+# from ops_config import Config, pass_config
+from pyegeria import EgeriaTech
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    print_exception_response,
+)
+
+
+@click.command("stop")
+@click.option("--server", help="OMAG Server to stop")
+@click.pass_context
+def stop_server(ctx, server):
+    """Stop an OMAG server daemon"""
+    c = ctx.obj
+    p_client = EgeriaTech(c.view_server, c.view_server_url, c.userid, c.password)
+    token = p_client.create_egeria_bearer_token()
+    try:
+        server_guid = p_client.get_guid_for_name(server)
+
+        p_client.shutdown_server(server_guid)
+        click.echo(f"Stopped server {server}")
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        p_client.close_session()
+
+
+@click.command("start")
+@click.option("--server", help="OMAG Server to start")
+def start_server(ctx, server):
+    """Start or restart an OMAG server from its known configuration"""
+    c = ctx.obj
+    p_client = EgeriaTech(c.view_server, c.view_server_url, c.userid, c.password)
+    token = p_client.create_egeria_bearer_token()
+    try:
+        server_guid = p_client.get_element_guid_by_unique_name(server, "name")
+        p_client.activate_server_with_stored_config(server_guid)
+
+        click.echo(f"Started server {server}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        p_client.close_session()
+
+
+@click.command("refresh")
+@click.pass_context
+def refresh(ctx):
+    """Start or restart an engine-host from its known configuration"""
+    c = ctx.obj
+    p_client = EgeriaTech(c.view_server, c.view_server_url, c.userid, c.password)
+    token = p_client.create_egeria_bearer_token()
+    try:
+        engine_host_guid = p_client.get_guid_for_name(c.engine_host)
+        p_client.refresh_gov_eng_config(engine_host_guid)
+
+        click.echo(f"Refreshed server {c.engine_host}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        p_client.close_session()

pyegeria/commands/tech/README.md

@@ -0,0 +1,24 @@
+<!-- SPDX-License-Identifier: CC-BY-4.0 -->
+<!-- Copyright Contributors to the Egeria project. -->
+
+# Developer
+
+These widgets display different kinds of information useful to developers. Widgets
+will continue to be added over time to cover more facets. Useful developer information
+can also be found on [Egeria Project](https://egeria-project.org) and in [Egeria Explorers](https://egeria-project.org/release-notes/june-2024/?h=brain#egeria-explorers).
+
+* get_guid_info.py - lists information about the metadata element specified by the Egeria guid.
+* get_tech_details.py - shows a tree view showing the Egeria support for a particular technology (e.g PostgreSQL Server).
+* list_asset_types.py - provides a tree view of a collection with all nested collections and items within the collection.
+* list_registered_services.py - lists the services available on an Egeria platform.
+* list_relationship_types.py - list the relationships details for a specified Egeria type.
+* list_tech_templates.py - list template details for technology types
+* list_tech_types.py - list the technology types that Egeria currently supports
+* list_valid_metadata_values.py - list valid metadata values for a particular property and category.
+
+
+
+
+----
+License: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/),
+Copyright Contributors to the Egeria project.

pyegeria/commands/tech/get_element_info.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+SPDX-Lic
+ense-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+A simple display of elements for an Open Metadata Type in tree form.
+"""
+import argparse
+import json
+import os
+import sys
+
+from rich import print, box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+from rich.prompt import Prompt
+from rich.text import Text
+from rich.tree import Tree
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    Client,
+    ClassificationManager,
+)
+
+
+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_elements(
+    om_type: str,
+    server: str,
+    url: str,
+    username: str,
+    user_password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    c = ClassificationManager(server, url, user_id=username, user_pwd=user_password)
+
+    bearer_token = c.create_egeria_bearer_token(username, user_password)
+
+    try:
+        console = Console(
+            width=width, force_terminal=not jupyter, style="bold white on black"
+        )
+        r = c.get_elements(om_type)
+        if type(r) is not list:
+            print(f"\n\n\tno elements found: {r}")
+            sys.exit(1)
+
+        tree = Tree(
+            f"Elements for Open Metadata Type:{om_type}\n* There are {len(r)} elements",
+            style="bold bright_white on black",
+            guide_style="bold bright_blue",
+        )
+        t = tree.add(f"Elements for {om_type}", style="bold bright_white on black")
+        for element in r:
+            header = element["elementHeader"]
+            el_type = header["type"]["typeName"]
+            el_home = header["origin"]["homeMetadataCollectionName"]
+            el_create_time = header["versions"]["createTime"]
+            el_guid = header["guid"]
+
+            el_md = (
+                f"#### Element Basics\n"
+                f"* **Type**: {el_type}\n"
+                f"* **Home**: {el_home}\n"
+                f"* **Created**: {el_create_time}\n"
+                f"* **GUID**: {el_guid}\n ---\n"
+            )
+            for prop in element["properties"].keys():
+                el_md += f"* **{prop}**: {element['properties'][prop]}\n"
+
+            el_out = Markdown(el_md)
+            p = Panel.fit(
+                el_out,
+                title=element["properties"]["qualifiedName"],
+                style="bold white on black",
+            )
+            t = tree.add(p)
+
+        print(tree)
+
+        c.close_session()
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+        ValueError,
+    ) as e:
+        if type(e) is str:
+            console.print_exception()
+        else:
+            # console.print_exception(show_locals=True)
+            console.print(f"\n ===> Looks like the type {om_type} isn't known...\n")
+
+
+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("--sponsor", help="Name of sponsor to search")
+    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
+
+    try:
+        om_type = Prompt.ask(
+            "Enter the Open Metadata Type to find Elements for", default=None
+        )
+        display_elements(om_type, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/tech/get_guid_info.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+SPDX-Lic
+ense-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 glossary terms
+"""
+import argparse
+import json
+import os
+
+from rich import print
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.text import Text
+from rich.tree import Tree
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    Client,
+    ClassificationManager,
+)
+
+
+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_guid(
+    guid: str,
+    server: str,
+    url: str,
+    username: str,
+    user_password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    c = Client(server, url, user_id=username)
+    url = (
+        f"{url}/servers/{server}/open-metadata/repository-services/users/{username}/"
+        f"instances/entity/{guid}"
+    )
+    # c =  ClassificationManager(server, url)
+
+    bearer_token = c.create_egeria_bearer_token(username, user_password)
+
+    try:
+        console = Console(
+            width=width, force_terminal=not jupyter, style="bold white on black"
+        )
+        r = c.make_request("GET", url)
+        if r.status_code == 200:
+            pass
+        # r = c.retrieve_instance_for_guid(guid)
+        e = r.json()["entity"]
+        p = e["properties"]["instanceProperties"]
+
+        type_name = Text(f"Type is: {e['type']['typeDefName']}")
+        metadataCollection = Text(
+            f"Metadadata Collection: {e['metadataCollectionName']}"
+        )
+        created = Text(f"Created at: {e['createTime']}")
+        details = Text(f"Details: {json.dumps(p, indent=2)}")
+
+        tree = Tree(
+            f"{guid}",
+            style="bold bright_white on black",
+            guide_style="bold bright_blue",
+        )
+
+        tree = tree.add(type_name)
+        tree.add(metadataCollection)
+        tree.add(created)
+        tree.add(Panel(details, title="Element Details", expand=False))
+        print(tree)
+
+        c.close_session()
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+        ValueError,
+    ) as e:
+        if type(e) is str:
+            console.print_exception()
+        else:
+            # console.print_exception(show_locals=True)
+            console.print(f"\n ===> Looks like the GUID isn't known...\n")
+
+
+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("--sponsor", help="Name of sponsor to search")
+    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_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    try:
+        guid = Prompt.ask("Enter the GUID to retrieve", default=None)
+        display_guid(guid, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()