pyegeria 5.2.1__py3-none-any.whl → 5.3__py3-none-any.whl

commands/tech/list_elements_by_property_value_x.py

@@ -0,0 +1,201 @@
+"""List elements"""
+
+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 (
+    EgeriaTech,
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+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("EGERIA_VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_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 find_elements_by_prop_value_x(
+    om_type: str,
+    property_value: str,
+    property_names: [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()
+
+    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)
+    elements = c_client.find_elements_by_property_value(
+        property_value, property_names, om_type
+    )
+
+    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"Find Elements for Open Metadata Type: {om_type}, property value: {property_value}, "
+            f"properties: {property_names} - Extended",
+            expand=True,
+            width=width,
+        )
+
+        table.add_column("Qualified Name")
+        table.add_column("Type")
+        table.add_column("Created")
+        table.add_column("Home Store")
+        table.add_column("GUID", width=38, no_wrap=True)
+        table.add_column("Properties")
+        table.add_column("Feedback", min_width=30)
+        table.add_column("Public Comments")
+
+        if type(elements) is list:
+            for element in elements:
+                header = element["elementHeader"]
+                el_q_name = element["properties"].get("qualifiedName", "---")
+                el_type = header["type"]["typeName"]
+                el_home = header["origin"]["homeMetadataCollectionName"]
+                el_create_time = header["versions"]["createTime"][:-18]
+                el_guid = header["guid"]
+
+                el_props_md = ""
+                for prop in element["properties"].keys():
+                    el_props_md += f"* **{prop}**: {element['properties'][prop]}\n"
+
+                el_props_out = Markdown(el_props_md)
+
+                tags = c_client.get_attached_tags(el_guid)
+                tags_md = "Tags:\n"
+                if type(tags) is list:
+                    for tag in tags:
+                        tags_md += (
+                            f"* tag: {tag.get('name','')}\n"
+                            f"\t description: {tag.get('description','---')}\n"
+                            f"\t assigned by: {tag.get('user','---')}\n"
+                        )
+
+                else:
+                    tags_md = ""
+
+                likes = c_client.get_attached_likes(el_guid)
+                likes_md = "Likes:\b"
+                if type(likes) is list:
+                    for like in likes:
+                        likes_md += (
+                            f"* tag: {like['name']}\n"
+                            f"* description: {like['description']}\n"
+                            f"* assigned by: {like['user']}\n"
+                            f"\n"
+                        )
+
+                else:
+                    likes_md = ""
+
+                if len(tags_md) > 0 and len(likes_md) > 0:
+                    feedback_out = f"{tags_md}\n --- \n{likes_md}"
+                else:
+                    feedback_out = ""
+
+                comments_out = " "
+
+                table.add_row(
+                    el_q_name,
+                    el_type,
+                    el_create_time,
+                    el_home,
+                    el_guid,
+                    el_props_out,
+                    feedback_out,
+                    comments_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:
+        om_type = Prompt.ask(
+            "Enter the Open Metadata Type to find elements of", default="Referenceable"
+        )
+        property_value = Prompt.ask("Enter the property value to search for")
+        property_names = Prompt.ask(
+            "Enter a comma seperated list of properties to search"
+        )
+        find_elements_by_prop_value_x(
+            om_type, property_value, [property_names], server, url, userid, password
+        )
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

{pyegeria/commands → commands}/tech/list_elements_for_classification.py

@@ -1,32 +1,34 @@
 """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 os
 import sys
+import time
+
+from jedi import Project
 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 (
+    EgeriaTech,
     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 = os.environ.get("EGERIA_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 = os.environ.get("EGERIA_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")
@@ -159,7 +161,7 @@ def main():
 
     try:
         om_type = Prompt.ask(
-            "Enter the Open Metadata Type to find elements of:", default="Project"
+            "Enter the Open Metadata Type to find elements of:", default="Referenceable"
         )
         classification = Prompt.ask("Enter the classification to filter by: ")
         list_classified_elements(om_type, classification, server, url, userid, password)

{pyegeria/commands → commands}/tech/list_gov_action_processes.py

@@ -12,29 +12,28 @@ import os
 import sys
 import time
 
-from rich import box
-from rich import print
+from rich import box, print
 from rich.console import Console
 from rich.prompt import Prompt
 from rich.table import Table
 
 from pyegeria import (
+    EgeriaTech,
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
+    ValidMetadataManager,
     print_exception_response,
-    EgeriaTech,
 )
-from pyegeria import ValidMetadataManager
 
 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 = os.environ.get("EGERIA_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 = os.environ.get("EGERIA_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")

commands/tech/list_information_supply_chains.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+A simple viewer for Information Supply Chains
+
+"""
+
+import argparse
+import os
+import time
+
+from rich import box, print
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    save_mermaid_graph,
+    save_mermaid_html,
+)
+from pyegeria._exceptions import print_exception_response
+from pyegeria.solution_architect_omvs import SolutionArchitect
+
+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("EGERIA_VIEW_SERVER", "qs-view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_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", "150"))
+EGERIA_MERMAID_FOLDER = os.environ.get("EGERIA_MERMAID_FOLDER", "work/mermaid_graphs")
+
+
+def supply_chain_viewer(
+    search_string: str,
+    server_name: str,
+    platform_url: str,
+    user: str,
+    user_password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+    timeout: int = 30,
+):
+    """A Supply Chain viewer"""
+    client = SolutionArchitect(server_name, platform_url, user, user_password)
+    token = client.create_egeria_bearer_token()
+
+    def generate_table() -> Table | str:
+        table = Table(
+            title=f"Supply Chains matching  {search_string} @ {time.asctime()}",
+            style="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 '{server_name}' @ Platform - {platform_url}",
+            expand=True,
+        )
+        table.add_column("Supply Chain Name")
+        table.add_column("Qualified Name \n/\n GUID", justify = 'center', width=38, no_wrap=False)
+        table.add_column("Purposes")
+        table.add_column("Scope\n/\n Mermaid Link", justify = 'center')
+        table.add_column("Description", justify = 'center')
+        table.add_column("Segments", justify = 'center')
+
+        supply_chains = client.find_information_supply_chains(search_string )
+        if isinstance(supply_chains, list) is False:
+            return "No Supply Chains found"
+
+        for sc in supply_chains:
+            if sc is None:
+                continue
+            sc_name = sc["properties"].get("displayName", "---")
+            sc_qname = sc["properties"].get("qualifiedName", "---")
+            sc_guid = sc["elementHeader"]["guid"]
+            sc_purpose = sc["properties"].get("purposes", "---")
+            if isinstance(sc_purpose, list):
+                sc_purpose_str = "\n* ".join(sc_purpose)
+            else:
+                sc_purpose_str = sc_purpose
+            sc_scope = sc["properties"].get("scope", "---")
+            sc_desc = sc["properties"].get("description", "---")
+            sc_unique_name = f"{sc_qname}\n\n\t\t/\n\n{sc_guid}"
+            sc_mermaid = sc.get("mermaidGraph", "---")
+            if sc_mermaid != "---":
+                link = save_mermaid_html(
+                    sc_name, sc_mermaid, f"{EGERIA_MERMAID_FOLDER}/supply-chains"
+                )
+                sc_mermaid_link = Text(f"file://:{link}", style="blue link " + link)
+                sc_scope = Text(f"{sc_scope}\n\n/\n\n{sc_mermaid_link}",  justify = "center")
+
+
+            sc_segments = sc.get("segments", "---")
+            if sc_segments != "---":
+                first_segment = True
+                sc_segments_md = ""
+                for segment in sc_segments:
+                    seg_prop = segment['properties']
+                    if first_segment:
+                        first_segment = False
+                    else:
+                        sc_segments_md += "----\n\n"  # add a seperator from previous segment
+
+                    for key in seg_prop.keys():
+                        sc_segments_md += f"* **{key}**: {seg_prop[key]}\n"
+                sc_segments_md = Markdown(sc_segments_md)
+            else:
+                sc_segments_md = "---"
+
+            table.add_row(sc_name, sc_unique_name, sc_purpose_str, sc_scope, sc_desc, sc_segments_md)
+
+        return table
+
+    try:
+        console = Console(width=width, force_terminal=not jupyter)
+        with console.pager():
+            console.print(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+
+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 a search string:", default="*")
+        supply_chain_viewer(search_string, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

{pyegeria/commands → commands}/tech/list_registered_services.py

@@ -20,18 +20,18 @@ from rich.table import Table
 from pyegeria import (
     InvalidParameterException,
     PropertyServerException,
-    UserNotAuthorizedException,
     RegisteredInfo,
+    UserNotAuthorizedException,
 )
 
 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 = os.environ.get("EGERIA_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 = os.environ.get("EGERIA_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")