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

commands/cli/egeria_tech.py

@@ -53,7 +53,7 @@ from commands.tech.list_solution_components import solution_component_list
 from commands.tech.list_solution_roles import solution_role_list
 from commands.tech.list_tech_templates import display_templates_spec
 from commands.tech.list_valid_metadata_values import display_metadata_values
-from commands.tech.generic_actions import delete_element
+from commands.tech.element_actions import delete_element
 
 @tui()
 @click.version_option("0.0.1", prog_name="egeria_ops")
@@ -360,17 +360,8 @@ def show_elements_by_classification_by_prop(
     """Show elements by classification and property value"""
     c = ctx.obj
     if extended:
-        find_elements_by_prop_value_x(
-            om_type,
-            property_value,
-            [property_names],
-            c.view_server,
-            c.view_server_url,
-            c.userid,
-            c.password,
-            c.jupyter,
-            c.width,
-        )
+        find_elements_by_prop_value_x(om_type, property_value, [property_names], c.view_server, c.view_server_url,
+                                      c.userid, c.password, c.jupyter, c.width)
     else:
         find_elements_by_prop_value(
             om_type,
@@ -404,17 +395,8 @@ def show_elements_by_classification_by_prop(
 def show_related_elements(ctx, element_guid, om_type, rel_type):
     """Show all elements related to specified guid"""
     c = ctx.obj
-    list_related_elements(
-        element_guid,
-        om_type,
-        rel_type,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    list_related_elements(element_guid, om_type, rel_type, c.view_server, c.view_server_url, c.userid, c.password,
+                          c.jupyter, c.width)
 
 
 @show_elements.command("related-elements_by_prop")
@@ -491,9 +473,7 @@ def show_tech_types(ctx, search_string):
     """
 
     c = ctx.obj
-    display_tech_types(
-        search_string, c.view_server, c.view_server_url, c.userid, c.password
-    )
+    display_tech_types(search_string, c.view_server, c.view_server_url, c.userid, c.password)
 
 
 @show_tech.command("tech-details")
@@ -507,15 +487,7 @@ def show_tech_details(ctx, tech_name):
            tech-name is a valid technology name (see 'show tech-types')
     """
     c = ctx.obj
-    tech_details_viewer(
-        tech_name,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    tech_details_viewer(tech_name, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
 @show_tech.command("tech-type-templates")
@@ -552,7 +524,7 @@ def show_asset_types(ctx):
 @show_info.command("registered-services")
 @click.option(
     "--services",
-    type=click.Choice(
+    type_name = click.Choice(
         [
             "all",
             "access-services",
@@ -571,15 +543,7 @@ def show_asset_types(ctx):
 def show_registered_services(ctx, services):
     """Show information about a registered services"""
     c = ctx.obj
-    display_registered_svcs(
-        services,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    display_registered_svcs(services, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
 @show_info.command("relationship-types")
@@ -592,16 +556,8 @@ def show_registered_services(ctx, services):
 def show_relationship_types(ctx, rel_type):
     """Show information about the specified relationship type"""
     c = ctx.obj
-    display_relationship_types(
-        rel_type,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        False,
-        c.jupyter,
-        c.width,
-    )
+    display_relationship_types(rel_type, c.view_server, c.view_server_url, c.userid, c.password, False, c.jupyter,
+                               c.width)
 
 
 @show_tech.command("tech-templates")
@@ -701,15 +657,7 @@ def list_element_info(ctx):
 def get_element_info(ctx, om_type):
     """Display graph of elements for an Open Metadata Type"""
     c = ctx.obj
-    display_elements(
-        om_type,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    display_elements(om_type, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
 @show_elements.command("elements")
@@ -752,15 +700,7 @@ def list_all_om_type_elements(ctx, om_type, extended):
 def list_supply_chains(ctx, search_string):
     """Display supply chains"""
     c = ctx.obj
-    supply_chain_viewer(
-        search_string,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    supply_chain_viewer(search_string, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
 @show_supply_chains.command("blueprints")
@@ -769,22 +709,14 @@ def list_supply_chains(ctx, search_string):
 def list_blueprints(ctx, search_string):
     """Display solution blueprints"""
     c = ctx.obj
-    blueprint_list(
-        search_string,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    blueprint_list(search_string, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
-@show_supply_chains.command("solution-roles")
+@show_supply_chains.command("solution-perspectives")
 @click.option("--search-string", default="*", help="Search string")
 @click.pass_context
 def list_solution_roles(ctx, search_string):
-    """Display solution roles"""
+    """Display solution perspectives"""
     c = ctx.obj
     solution_role_list(
         search_string,
@@ -803,15 +735,7 @@ def list_solution_roles(ctx, search_string):
 def list_solution_components(ctx, search_string):
     """Display solution componentss"""
     c = ctx.obj
-    solution_component_list(
-        search_string,
-        c.view_server,
-        c.view_server_url,
-        c.userid,
-        c.password,
-        c.jupyter,
-        c.width,
-    )
+    solution_component_list(search_string, c.view_server, c.view_server_url, c.userid, c.password, c.jupyter, c.width)
 
 
 #

commands/{cat → deprecated}/list_data_designer.py

@@ -1,3 +1,4 @@
+
 #!/usr/bin/env python3
 """
 SPDX-License-Identifier: Apache-2.0
@@ -24,10 +25,7 @@ from rich.markdown import Markdown
 
 from pyegeria import (
     EgeriaTech,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table
     NO_ELEMENTS_FOUND
 )
 

commands/{cat → deprecated}/list_data_structures_full.py

@@ -19,10 +19,7 @@ from rich.text import Text
 
 from pyegeria import (
     EgeriaTech,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response, NO_ELEMENTS_FOUND,
+PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table NO_ELEMENTS_FOUND,
     )
 
 disable_ssl_warnings = True
@@ -89,7 +86,7 @@ def display_data_struct(
             action = "Dict"
         elif output_format == "MERMAID":
             action = "Mermaid"
-        filter = search_string.strip() if search_string != "*" else None
+        filter_string = search_string.strip() if search_string != "*" else None
 
         body = {
             "class": "FilterRequestBody",
@@ -100,7 +97,7 @@ def display_data_struct(
             "limitResultsByStatus": ["ACTIVE"],
             "sequencingOrder": "PROPERTY_ASCENDING",
             "sequencingProperty": "qualifiedName",
-            "filter": filter
+            "filter": filter_string
             }
 
         if output_format != "TABLE":

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")