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

pyegeria/commands/cat/list_tech_types.py

@@ -0,0 +1,140 @@
+#!/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 display for my profile
+"""
+import os
+import argparse
+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,
+    print_exception_response,
+    AutomatedCuration,
+)
+
+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_tech_types(
+    search_string: str,
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    a_client = AutomatedCuration(server, url, username)
+    token = a_client.create_egeria_bearer_token(username, user_pass)
+    tech_list = a_client.find_technology_types(search_string, page_size=0)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Technology Types for: {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"Technology Types from Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+
+        table.add_column("Name")
+        table.add_column("Qualified Name")
+        table.add_column("Category")
+        table.add_column("Description")
+
+        name = " "
+        description = " "
+        version = " "
+        super_type = " "
+        if type(tech_list) is list:
+            for item in tech_list:
+                if "deployedImplementationType" not in item["qualifiedName"]:
+                    continue
+                qualified_name = item.get("qualifiedName", " ")
+                name = item.get("name", "none")
+                category = item.get("category", "none")
+                description = item.get("description", "none")
+
+                table.add_row(name, qualified_name, category, description)
+            return table
+        else:
+            print("Unknown technology type")
+            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)
+        assert e.related_http_code != "200", "Invalid parameters"
+    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="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_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:
+        search_string = Prompt.ask(
+            "Enter the technology you are searching for:", default="*"
+        )
+        display_tech_types(search_string, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/cat/list_terms.py

@@ -0,0 +1,242 @@
+#!/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 display for glossary terms
+"""
+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 rich.text import Text
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    EgeriaTech,
+)
+from pyegeria.commands.cat.glossary_actions import EGERIA_HOME_GLOSSARY_GUID
+
+disable_ssl_warnings = True
+
+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"))
+EGERIA_HOME_GLOSSARY_GUID = os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None)
+
+
+def display_glossary_terms(
+    search_string: str = "*",
+    glossary_guid: str = EGERIA_HOME_GLOSSARY_GUID,
+    glossary_name: str = None,
+    view_server: str = EGERIA_VIEW_SERVER,
+    view_url: str = EGERIA_VIEW_SERVER_URL,
+    user_id: str = EGERIA_USER,
+    user_pass: str = EGERIA_USER_PASSWORD,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    """Display a table of glossary terms filtered by search_string and glossary, if specified. If no
+        filters then all terms are displayed. If glossary_guid or name is specified, then only terms from that
+        glossary are displayed.
+    Parameters
+    ----------
+    search_string : str, optional
+        The string to search for terms. Defaults to "*".
+    glossary_guid : str, optional
+        The unique identifier of the glossary. Defaults to None. If specified, then only terms from that glossary
+        are displayed. If both glossary_guid and glossary_name are provided then glossary_guid will take precedence.
+    glossary_name : str, optional
+        The display name of the glossary. Defaults to None. If specified, then only terms from that glossary
+        are displayed. If both glossary_guid and glossary_name are provided then glossary_guid will take precedence.
+        Note that the use of glossary display name relies on the qualified name conforming to convention. GUID is more
+        reliable.
+    view_server : str
+        The server where the glossary is hosted. Defaults to EGERIA_VIEW_SERVER.
+    view_url : str
+        The URL of the server where the glossary is hosted. Defaults to EGERIA_VIEW_SERVER_URL.
+    user_id : str
+        The user ID for authentication. Defaults to EGERIA_USER.
+    user_pass : str
+        The user password for authentication. Defaults to EGERIA_USER_PASSWORD.
+    jupyter : bool
+        Flag to indicate if the output should be formatted for Jupyter notebook. Defaults to EGERIA_JUPYTER.
+    width : int
+        The width of the console output. Defaults to EGERIA_WIDTH.
+    """
+
+    console = Console(
+        style="bold bright_white on black", width=width, force_terminal=not jupyter
+    )
+    g_client = EgeriaTech(view_server, view_url, user_id, user_pass)
+    token = g_client.create_egeria_bearer_token()
+    if (glossary_name is not None) and (glossary_name != "*"):
+        glossary_guid = g_client.get_guid_for_name(glossary_name)
+        if glossary_guid == "No elements found":
+            console.print(
+                f"\nThe glossary name {glossary_name} was not found. Please try using the glossary guid"
+            )
+            sys.exit(0)
+
+    def generate_table(search_string: str, glossary_guid: str = None) -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Glossary Definitions for Terms like  {search_string} @ {time.asctime()}",
+            style="bright_white on black",
+            # row_styles="bright_white on black",
+            header_style="bright_white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"View Server '{view_server}' @ Platform - {view_url}",
+            expand=True,
+        )
+        table.add_column("Term Name")
+        table.add_column("Qualified Name / GUID", width=38, no_wrap=True)
+        table.add_column("Abbreviation")
+        table.add_column("Summary")
+        table.add_column("Description")
+        table.add_column("Version Id")
+        table.add_column("Glossary")
+        table.add_column("Status")
+        table.add_column("Example")
+
+        terms = g_client.find_glossary_terms(
+            search_string,
+            glossary_guid,
+            starts_with=False,
+            ends_with=False,
+            status_filter=[],
+            page_size=500,
+        )
+
+        if type(terms) is str:
+            print(f"No terms found!")
+            sys.exit(0)
+        sorted_terms = sorted(
+            terms, key=lambda k: k["glossaryTermProperties"]["displayName"]
+        )
+        style = "bright_white on black"
+        if type(terms) is str:
+            return table
+        glossary_info = {}
+        for term in sorted_terms:
+            props = term.get("glossaryTermProperties", "None")
+            if props == "None":
+                return table
+
+            display_name = Text(props["displayName"], style=style, justify="center")
+            qualified_name = props["qualifiedName"]
+            term_guid = term["elementHeader"]["guid"]
+            q_name = Text(
+                f"{qualified_name}\n&\n{term_guid}", style=style, justify="center"
+            )
+            abbrev = Text(props.get("abbreviation", " "), style=style, justify="center")
+            summary = Text(props.get("summary", " "), style=style)
+            description = Text(props.get("description", " "), style=style)
+            version = Text(
+                props.get("publishVersionIdentifier", " "),
+                style=style,
+                justify="center",
+            )
+            example = Text(props.get("example", " "), style=style)
+
+            classifications = term["elementHeader"]["classifications"]
+            glossary_guid = None
+            for c in classifications:
+                if c["classificationName"] == "Anchors":
+                    glossary_guid = c["classificationProperties"]["anchorGUID"]
+
+            if glossary_guid and glossary_guid in glossary_info:
+                glossary_name = glossary_info[glossary_guid]
+            elif glossary_guid:
+                g = g_client.get_glossary_for_term(term_guid)
+                glossary_name = g["glossaryProperties"].get("displayName", "---")
+                glossary_info[glossary_guid] = glossary_name
+            else:
+                glossary_name = "---"
+
+            term_status = term["elementHeader"]["status"]
+            table.add_row(
+                display_name,
+                q_name,
+                abbrev,
+                summary,
+                description,
+                version,
+                glossary_name,
+                term_status,
+                example,
+                style="bold white on black",
+            )
+
+        g_client.close_session()
+        return table
+
+    try:
+        with console.pager(styles=True):
+            console.print(generate_table(search_string, glossary_guid))
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        console.print_exception()
+
+
+def main():
+    sus_guid = "f9b78b26-6025-43fa-9299-a905cc6d1575"
+    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("--guid", help="GUID of glossary 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_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
+    guid = args.guid if args.guid is not None else EGERIA_HOME_GLOSSARY_GUID
+
+    try:
+        search_string = Prompt.ask("Enter the term you are searching for:", default="*")
+        glossary_name = Prompt.ask(
+            "Enter the name of the glossary to search or '*' for all glossaries:",
+            default="*",
+        )
+        display_glossary_terms(
+            search_string, guid, glossary_name, server, url, userid, user_pass
+        )
+
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/cat/list_todos.py

@@ -0,0 +1,189 @@
+#!/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 os
+import argparse
+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,
+)
+from pyegeria.my_profile_omvs import MyProfile
+
+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_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+
+def display_to_dos(
+    search_string: str,
+    status_filter: str,
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    m_client = MyProfile(server, url, user_id=username)
+    token = m_client.create_egeria_bearer_token(username, user_pass)
+
+    def generate_table(search_string: str = "*") -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Open ToDos for Platform {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("Name")
+        table.add_column("Type Name")
+        table.add_column("GUID", no_wrap=True)
+        table.add_column("Created")
+        table.add_column("Priority")
+        table.add_column("Due")
+        table.add_column("Completion")
+        table.add_column("Status")
+        table.add_column("Sponsor")
+        table.add_column("Assigned")
+
+        todo_items = m_client.find_to_do(search_string, status=status_filter)
+
+        if type(todo_items) is str:
+            name = " "
+            type_name = " "
+            created = " "
+            priority = " "
+            due = " "
+            completed = " "
+
+            status = " "
+            sponsor = " "
+            assigned_out = ""
+        else:
+            for item in todo_items:
+                guid = item["elementHeader"]["guid"]
+                props = item["properties"]
+                name = props["name"]
+                type_name = props.get("toDoType", " ")
+                created = props.get("creationTime", " ")[:-19]
+                priority = str(props.get("priority", " "))
+                due = props.get("dueTime", "          ")[:-19]
+                completed = props.get("completionTime", "           ")[:-10]
+                status = props.get("toDoStatus", "---")
+
+                assigned_out = ""
+                assigned_actors = item.get("assignedActors", "---")
+                if type(assigned_actors) is list:
+                    assigned_md = ""
+                    for actor in assigned_actors:
+                        assigned_md += f"* {actor['uniqueName'].split(',')[0]}\n"
+                    assigned_out = Markdown(assigned_md)
+
+                sponsor = "erinoverview"
+                if status in ("WAITING", "OPEN"):
+                    status = f"[yellow]{status}"
+                elif status in ("IN_PROGRESS", "COMPLETE"):
+                    status = f"[green]{status}"
+                else:
+                    status = f"[red]{status}"
+
+                table.add_row(
+                    name,
+                    type_name,
+                    guid,
+                    created,
+                    priority,
+                    due,
+                    completed,
+                    status,
+                    sponsor,
+                    assigned_out,
+                )
+
+        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())
+        console = Console(width=width, force_terminal=not jupyter)
+        with console.pager():
+            console.print(generate_table(search_string))
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        m_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="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_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:
+        search_string = Prompt.ask("Enter the ToDo you are searching for", default="*")
+        status_filter = Prompt.ask(
+            "Enter an optional status filter ['OPEN','IN_PROGRESS','WAITING','COMPLETE',"
+            "'ABANDONED', 'None']",
+            default=None,
+        )
+        display_to_dos(search_string, status_filter, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()