pyegeria 5.3.9.9.3__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

commands/deprecated/old_get_asset_graph.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Display the status of cataloged platforms and servers.
+"""
+import argparse
+import os
+import sys
+
+from rich import print
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.tree import Tree
+
+from pyegeria import (
+    AssetCatalog,
+PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table    UserNotAuthorizedException, PyegeriaException,
+)
+
+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_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"))
+
+disable_ssl_warnings = True
+
+guid_list = []
+
+console = Console(width=EGERIA_WIDTH, force_terminal=(not EGERIA_JUPYTER))
+
+
+def asset_viewer(
+    asset_guid: str,
+    server_name: str,
+    platform_url: str,
+    user: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    def build_classifications(classification: dict) -> Markdown:
+        class_md = ""
+        for c in classification:
+            c_type = c["classificationName"]
+            if c_type == "Anchors":
+                continue
+            class_md += f"\n* Classification: {c_type}\n"
+            class_props = c.get("classificationProperties", "---")
+            if type(class_props) is dict:
+                for prop in class_props.keys():
+                    class_md += f"\t* {prop}: {class_props[prop]}\n"
+        if class_md == "":
+            output = None
+        else:
+            output = class_md
+        return output
+
+    def build_nested_elements(nested_element: dict) -> Markdown:
+        ne_md = " "
+        ne_header = nested_element["elementHeader"]
+        ne_created_by = ne_header["versions"]["createdBy"]
+        ne_created_at = ne_header["versions"]["createTime"]
+        ne_guid = ne_header["guid"]
+        guid_list.append(ne_guid)
+
+        ne_type = ne_header["type"]["typeName"]
+        ne_classifications = ne_header["classifications"]
+        ne_class_md = build_classifications(ne_classifications)
+        # ne_class_md = " " if ne_class_md is None else ne_class_md
+        ne_props = nested_element.get("properties", "---")
+        ne_prop_md = "\n"
+        if type(ne_props) is dict:
+            for prop in ne_props.keys():
+                ne_prop_md += f"\t* {prop}: {ne_props[prop]}\n"
+        ne_md = (
+            f"Nested Element of Type: {ne_type} with GUID:  {ne_guid} \n "
+            f"* created by {ne_created_by} at time {ne_created_at}\n"
+            f"\n* Properties:\n{ne_prop_md}\n"
+        )
+
+        if ne_class_md is not None:
+            ne_md += f"* {ne_class_md}"
+
+        output = Markdown(ne_md)
+        return output
+
+    try:
+        a_client = AssetCatalog(server_name, platform_url, user_id=user)
+
+        token = a_client.create_egeria_bearer_token(user, user_pass)
+        # asset_info = a_client.find_assets_in_domain(asset_name)
+        # if type(asset_info) is str:
+        #     print("\n No Assets Found - Exiting\n")
+        #     sys.exit(1)
+        #
+        # asset_guid = asset_info[0]['guid']
+
+        guid_list.append(asset_guid)
+
+        asset_graph = a_client.get_asset_graph(asset_guid, output_format="JSON")
+        if type(asset_graph) is not dict:
+            print(f"\n No Asset found for {asset_guid}")
+            sys.exit(1)
+
+        # print(f"\n{json.dumps(asset_graph, indent =2)}\n")
+
+        asset_display_name = asset_graph["properties"].get("displayName", "---")
+        asset_display_description = asset_graph["properties"].get(
+            "displayDescription", "---"
+        )
+        asset_name = asset_graph["properties"].get("name", "---")
+        asset_resource_name = asset_graph["properties"].get("resourceName", "---")
+        asset_resource_description = asset_graph["properties"].get(
+            "resourceDescription", "---"
+        )
+        qualified_name = asset_graph["properties"].get("qualifiedName", "---")
+
+        tree = Tree(
+            f"{asset_name} ({asset_guid})",
+            style="bold bright_white on black",
+            guide_style="bold bright_blue",
+        )
+        style = ""
+        asset_elements = asset_graph["elementHeader"]
+        asset_type = asset_elements["type"]["typeName"]
+        asset_deployed_imp_type = asset_graph["properties"].get(
+            "deployedImplementationType", "---"
+        )
+
+        asset_origin = asset_elements["origin"]["homeMetadataCollectionName"]
+        asset_creation = asset_elements["versions"]["createTime"]
+        asset_created_by = asset_elements["versions"]["createdBy"]
+        asset_classifications = asset_elements["classifications"]
+        asset_nested_elements = asset_graph.get("anchoredElements", "----")
+        asset_relationships = asset_graph["relationships"]
+        asset_class_md = build_classifications(asset_classifications)
+
+        additional_properties = asset_graph["properties"].get(
+            "additionalProperties", None
+        )
+        if additional_properties is not None:
+            add_prop_md = "\n* Additional Properties:\n"
+            for prop in additional_properties:
+                add_prop_md = (
+                    f"{add_prop_md}\n\t* {prop}: {additional_properties[prop]}\n"
+                )
+        else:
+            add_prop_md = ""
+
+        extended_properties = asset_graph["properties"].get("extendedProperties", None)
+        if extended_properties is not None:
+            prop_md = "\n* Extended Properties:\n"
+            for prop in extended_properties:
+                prop_md = f"{prop_md}\n\t* {prop}: {extended_properties[prop]}\n"
+        else:
+            prop_md = ""
+        core_md = (
+            f"**Type: {asset_type}  Created by: {asset_created_by} on {asset_creation}**\n"
+            f"* Deployed Implementation Type: {asset_deployed_imp_type}\n"
+            f"* Name: {asset_name}\n "
+            f"* Asset Resource Name: {asset_resource_name}\n"
+            f"* Asset Resource Description: {asset_resource_description}\n "
+            f"* Asset Display Name: {asset_display_name}\n"
+            f"* Asset Display Description: {asset_display_description}\n "
+            f"* Qualified Name: {qualified_name}\n "
+            f"* Asset Origin: {asset_origin}\n"
+            f" {prop_md}\n"
+            f" {add_prop_md}\n"
+        )
+        core_md = Markdown(core_md)
+
+        p1 = Panel.fit(core_md, style="bold bright_white")
+        l2 = tree.add(p1)
+        if asset_class_md is not None:
+            p2 = Panel.fit(
+                Markdown(asset_class_md),
+                style="bold bright_white",
+                title="Classifications",
+            )
+            l2 = tree.add(p2)
+
+        #
+        # Nested Assets
+        #
+        if type(asset_nested_elements) is list:
+            l2 = tree.add("Nested Elements", style="bold white")
+            for el in asset_nested_elements:
+                asset_ne_md = build_nested_elements(el)
+                p3 = Panel.fit(
+                    asset_ne_md, style="bold bright_white", title="Nested Elements"
+                )
+                l2.add(p3)
+
+        #
+        # Now work on the Relationships
+        #
+        for relationship in asset_relationships:
+            # Find the end guids - if one isn't in our list then display
+            rel_end1 = relationship["end1"]
+            rel_end1_type = rel_end1["type"]["typeName"]
+            rel_end1_guid = rel_end1["guid"]
+            rel_end1_unique_name = rel_end1.get("uniqueName", "---")
+
+            rel_end2 = relationship["end2"]
+            rel_end2_type = rel_end2["type"]["typeName"]
+            rel_end2_guid = rel_end2["guid"]
+            rel_end2_unique_name = rel_end2.get("uniqueName", "---")
+
+            if (rel_end1_guid not in guid_list) or (rel_end2_guid not in guid_list):
+                # rel_end1_class_md = build_classifications(rel_end1["classifications"])
+                # rel_end2_class_md = build_classifications(rel_end2["classifications"])
+
+                relationship_guid = relationship["guid"]
+                relationship_type = relationship["type"]["typeName"]
+                relationship_created_by = relationship["versions"]["createdBy"]
+                relationship_creation_time = relationship["versions"]["createTime"]
+                relationship_properties = relationship.get("properties", "--- ")
+                relationship_md = (
+                    f"Relationship Type {relationship_type}\n"
+                    f"* GUID: {relationship_guid}\n* Created by: {relationship_created_by} \n"
+                    f"* Creation Time: {relationship_creation_time}\n"
+                    f"* Properties: {relationship_properties}\n"
+                )
+
+                rel_md = (
+                    f"* Relationship Type: {relationship_type}\n"
+                    f"* Relationship GUID: {relationship_guid}\n"
+                    f"* Created by: {relationship_created_by} at time {relationship_creation_time}\n"
+                )
+                rel_end1_md = (
+                    f"* End1:\n"
+                    f"\t* Type: {rel_end1_type}\n"
+                    f"\t* GUID: {rel_end1_guid}\n"
+                    f"\t* Unique Name: {rel_end1_unique_name}\n"
+                )
+
+                # if rel_end1_class_md is not None:
+                #     rel_end1_md = rel_end1_class_md + rel_end1_md
+
+                rel_end2_md = (
+                    f"* End2:\n"
+                    f"\t* Type: {rel_end2_type}\n"
+                    f"\t* GUID: {rel_end2_guid}\n"
+                    f"\t* Unique Name: {rel_end2_unique_name}\n"
+                )
+
+                # if rel_end2_class_md is not None:
+                #     rel_end1_md = rel_end2_class_md + rel_end1_md
+                #
+                # for prop in relationship_properties.keys():
+                #     relationship_md += f"* {prop}: {relationship_properties[prop]}\n"
+
+                relationship_md += rel_end1_md + rel_end2_md
+
+                relationship_panel = Panel.fit(
+                    Markdown(relationship_md),
+                    style="bold bright_white",
+                    title="Asset Relationships",
+                )
+                tree.add(relationship_panel)
+        with console.screen():
+            print("\n\n")
+        print(tree)
+
+    except (
+        PyegeriaException
+    ) as e:
+        console.print_exception()
+        console.print(
+            "\n\n ======> Most likely the GUID you provided is either incorrect or not an asset\n[red bold]"
+        )
+
+
+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:
+        asset_guid = Prompt.ask("Enter the Asset GUID to view:", default="")
+        asset_viewer(asset_guid, server, url, userid, user_pass)
+    except KeyboardInterrupt as e:
+        # console.print_exception()
+        pass
+    except Exception as e:
+        console.print_exception()
+
+
+if __name__ == "__main__":
+    main()

commands/my/__init__.py

@@ -4,8 +4,6 @@ Copyright Contributors to the ODPi Egeria project.
 
 """
 from pyegeria import (
-    INTEGRATION_GUIDS,
-    TEMPLATE_GUIDS,
     default_time_out,
     disable_ssl_warnings,
     enable_ssl_check,

commands/my/list_my_profile.py

@@ -9,7 +9,6 @@ A simple display for my profile
 import argparse
 import os
 import sys
-import time
 
 from rich import box, print
 from rich.console import Console
@@ -18,13 +17,8 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.tree import Tree
 
-from pyegeria import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
-)
-from pyegeria.my_profile_omvs import MyProfile
+from pyegeria import print_basic_exception, PyegeriaException
+from pyegeria.omvs.my_profile import MyProfile
 
 disable_ssl_warnings = True
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
@@ -64,7 +58,7 @@ def display_my_profile(
 
         console = Console(width=width, force_terminal=not jupyter, soft_wrap=True)
 
-        profile_props = my_profiles.get("profileProperties", "---")
+        profile_props = my_profiles.get("properties", "---")
         name = profile_props["fullName"]
 
         tree = Tree(
@@ -93,14 +87,14 @@ def display_my_profile(
         id_list_md = ""
         for identities in my_profiles["userIdentities"]:
             id_list_md += (
-                f"* {identities['userIdentity']['properties']['userId']}\n"
-                f"* {identities['userIdentity']['elementHeader']['guid']}\n"
+                f"* {identities['relatedElement']['properties']['userId']}\n"
+                f"* {identities['relatedElement']['elementHeader']['guid']}\n"
             )
         t2 = tree.add(Panel(Markdown(id_list_md), title="Identities", expand=False))
 
-        contact_methods = my_profiles["contactMethods"]
+        contact_methods = my_profiles["contactDetails"]
         for method in contact_methods:
-            contact = method["properties"]
+            contact = method['relatedElement']["properties"]
             contact_methods_md = ""
             for key in contact.keys():
                 contact_methods_md += f"* {key}: {contact[key]}\n"
@@ -110,32 +104,31 @@ def display_my_profile(
                 )
             )
 
-        my_roles = my_profiles["roles"]
-        table = Table(
-            title=f" Roles of {name}",
-            show_lines=True,
-            box=box.ROUNDED,
-            expand=True,
-        )
-        table.add_column("Role Type")
-        table.add_column("Role")
-        table.add_column("Role GUID")
-        for a_role in my_roles:
-            my_role_props = a_role["properties"]
-            role_type = my_role_props["typeName"]
-            role = my_role_props.get("title", " ")
-            role_guid = a_role["elementHeader"]["guid"]
-            table.add_row(role_type, role, role_guid)
-        t4 = tree.add(Panel(table, title="Roles", expand=False), expanded=True)
+        my_roles = my_profiles.get("performsRoles","No roles found")
+        if isinstance(my_roles, dict|list):
+            table = Table(
+                title=f" Roles of {name}",
+                show_lines=True,
+                box=box.ROUNDED,
+                expand=True,
+            )
+            table.add_column("Role Type")
+            table.add_column("Role")
+            table.add_column("Role GUID")
+            for a_role in my_roles:
+                my_role_props = a_role['relatedElement']["properties"]
+                role_type = my_role_props["typeName"]
+                role = my_role_props.get("displayName", " ")
+                role_guid = a_role['relatedElement']["elementHeader"]["guid"]
+                table.add_row(role_type, role, role_guid)
+            t4 = tree.add(Panel(table, title="Roles", expand=False), expanded=True)
 
         print(tree)
 
     except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
+        PyegeriaException,
     ) as e:
-        print_exception_response(e)
+        print_basic_exception(e)
     finally:
         m_client.close_session()
 

commands/my/list_my_roles.py

@@ -17,13 +17,7 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from pyegeria import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
-)
-from pyegeria.my_profile_omvs import MyProfile
+from pyegeria.omvs.my_profile import MyProfile
 
 disable_ssl_warnings = True
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")

commands/my/monitor_my_todos.py

@@ -18,13 +18,7 @@ from rich.live import Live
 from rich.markdown import Markdown
 from rich.table import Table
 
-from pyegeria import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
-)
-from pyegeria.my_profile_omvs import MyProfile
+from pyegeria.omvs.my_profile import MyProfile
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")

commands/my/monitor_open_todos.py

@@ -20,13 +20,12 @@ from rich.markdown import Markdown
 from rich.table import Table
 
 from pyegeria import EgeriaTech
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+from pyegeria.core._exceptions import (
+    PyegeriaInvalidParameterException,
+    PyegeriaAPIException as PropertyServerException,
+    PyegeriaUnauthorizedException as UserNotAuthorizedException,
+    print_basic_exception as print_exception_response,
 )
-from pyegeria.my_profile_omvs import MyProfile
 
 disable_ssl_warnings = True
 
@@ -145,7 +144,7 @@ def display_todos(
                 live.console.pager()
 
     except (
-        InvalidParameterException,
+        PyegeriaInvalidParameterException,
         PropertyServerException,
         UserNotAuthorizedException,
     ) as e:

commands/my/todo_actions.py

@@ -15,10 +15,9 @@ from datetime import datetime
 import click
 
 from pyegeria import MyProfile
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    print_exception_response,
+from pyegeria.core._exceptions import (
+    PyegeriaAPIException as PropertyServerException,
+    print_basic_exception as print_exception_response,
 )
 
 erins_guid = "dcfd7e32-8074-4cdf-bdc5-9a6f28818a9d"
@@ -160,7 +159,7 @@ def delete_todo(server, url, userid, password, timeout, todo_guid):
 @click.option("--timeout", default=60, help="Number of seconds to wait")
 @click.option(
     "--new-status",
-    type=click.Choice(
+    type_name = click.Choice(
         ["OPEN", "IN_PROGRESS", "WAITING", "COMPLETE", "ABANDONED"],
         case_sensitive="False",
     ),

commands/ops/__init__.py

@@ -5,8 +5,6 @@ Copyright Contributors to the ODPi Egeria project.
 
 """
 from pyegeria import (
-    INTEGRATION_GUIDS,
-    TEMPLATE_GUIDS,
     default_time_out,
     disable_ssl_warnings,
     enable_ssl_check,

commands/ops/gov_server_actions.py

@@ -8,18 +8,13 @@ This script restarts an integration daemon.
 
 """
 
-import os
-
 import click
-from rich import print, print_json
-from rich.console import Console
-
-from pyegeria import INTEGRATION_GUIDS, AutomatedCuration, EgeriaTech
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+
+from pyegeria import AutomatedCuration, EgeriaTech
+from pyegeria.core._exceptions import (
+    PyegeriaInvalidParameterException as PyegeriaInvalidParameterException,
+    PyegeriaAPIException as PyegeriaAPIException,
+    print_basic_exception as print_exception_response,
 )
 
 
@@ -36,17 +31,18 @@ def add_catalog_target(
 ) -> str:
     """Add catalog targets to the specified integration connector"""
     try:
-        if integration_connector not in INTEGRATION_GUIDS.keys():
-            click.echo("Integration connector is not known")
-
         c = ctx.obj
         a_client = AutomatedCuration(
             c.view_server, c.view_server_url, c.userid, c.password
         )
         token = a_client.create_egeria_bearer_token()
 
+        integ_connector_guid = a_client.get_connector_guid(integration_connector)
+        if not integ_connector_guid or c.catalog_targets == 'No connector found':
+            raise PyegeriaInvalidParameterException('No Connector found')
+
         guid = a_client.add_catalog_target(
-            INTEGRATION_GUIDS[integration_connector],
+            integ_connector_guid,
             metadata_element_guid,
             catalog_target_name,
         )
@@ -55,7 +51,7 @@ def add_catalog_target(
             f"Added catalog target to {integration_connector} with a return guid of {guid}"
         )
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
 
 
@@ -77,7 +73,7 @@ def remove_catalog_target(ctx, relationship_guid: str):
             f"Removed catalog target with relationship guid of {relationship_guid}"
         )
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
 
 
@@ -101,7 +97,7 @@ def update_catalog_target(ctx, relationship_guid: str, catalog_target_name: str)
             f"{catalog_target_name} with a return guid of {guid}"
         )
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
 
 
@@ -121,7 +117,7 @@ def refresh_gov_eng_config(ctx, engine_host_guid: str):
 
         click.echo(f"Refreshed server {c.engine_host}")
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
     finally:
         p_client.close_session()
@@ -142,7 +138,7 @@ def start_server(ctx, server):
 
         click.echo(f"Started server {server}")
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
     finally:
         p_client.close_session()
@@ -172,7 +168,7 @@ def stop_server(ctx, server):
     try:
         p_client.shutdown_server(None, server)
         click.echo(f"Stopped server {server}")
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaInvalidParameterException, PyegeriaAPIException) as e:
         print_exception_response(e)
     finally:
         p_client.close_session()