pyegeria 0.7.27__tar.gz → 0.7.28__tar.gz

{pyegeria-0.7.27 → pyegeria-0.7.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyegeria
-Version: 0.7.27
+Version: 0.7.28
 Summary: A python client for Egeria
 Home-page: https://github.com/odpi/egeria-python
 License: Apache 2.0

pyegeria-0.7.28/examples/widgets/cat/get_tech_type_elements.py

@@ -0,0 +1,174 @@
+#!/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 sys
+import time
+import argparse
+import os
+
+from rich import json
+from rich.panel import Panel
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    AutomatedCuration,
+)
+from rich.table import Table
+from rich.live import Live
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.tree import Tree
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.text import Text
+from rich import print
+
+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
+console = Console(width=200)
+
+guid_list = []
+
+
+def tech_viewer(
+    tech_name: 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 = "\n"
+        for c in classification:
+            c_type = c["classificationName"]
+            if c_type == "Anchors":
+                continue
+            class_md += f"* Classification: {c_type}\n"
+            class_props = c.get("classificationProperties", None)
+            if class_props is None:
+                continue
+            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
+
+    try:
+        console = Console(width=width, force_terminal=not jupyter)
+
+        a_client = AutomatedCuration(server_name, platform_url, user_id=user)
+
+        token = a_client.create_egeria_bearer_token(user, user_pass)
+        tech_elements = a_client.get_technology_type_elements(
+            tech_name, get_templates=False
+        )
+        if type(tech_elements) is str:
+            console.print(f"No elements found for {tech_name}")
+            sys.exit(1)
+
+        tree = Tree(
+            f"Deployed Technology Type: {tech_name}",
+            style="bold bright_white on black",
+            guide_style="bold bright_blue",
+        )
+        note: str = " "
+        for element in tech_elements:
+            header = element["elementHeader"]
+            tech_type = header["type"]["typeName"]
+            tech_collection = header["origin"]["homeMetadataCollectionName"]
+            tech_created_by = header["versions"]["createdBy"]
+            tech_created_at = header["versions"]["createTime"]
+            tech_guid = header["guid"]
+            tech_classifications = header["classifications"]
+            class_md = build_classifications(tech_classifications)
+
+            referenceables = element["referenceableProperties"]
+            tech_qualified_name = referenceables["qualifiedName"]
+            extended = referenceables["extendedProperties"]
+            ex_md: str = ""
+            for key, value in extended.items():
+                ex_md += f"* {key}: {value}\n"
+
+            note = (
+                f"* Qualified Name: {tech_qualified_name}\n"
+                f"* GUID: {tech_guid}\n"
+                f"* Created by: {tech_created_by}\n"
+                f"* Created at: {tech_created_at}\n"
+                f"* Home Collection: {tech_collection}\n"
+                f"{class_md}\n"
+                f"{ex_md}\n"
+            )
+
+            interfaces = extended.get("connectorInterfaces", None)
+            if interfaces is not None:
+                interface_type_name = interfaces["typeName"]
+                interface_array_cnt = interfaces["arrayCount"]
+                note += f"* Interface Type: {interface_type_name}\n"
+                for i in range(0, int(interface_array_cnt)):
+                    note += (
+                        f"\t* Type: {interfaces['arrayValues']['propertyValueMap'][str(i)]['typeName']}"
+                        f"\tName: {interfaces['arrayValues']['propertiesAsStrings'][str(i)]}\n"
+                    )
+            note_md = Panel.fit(Markdown(note), style="bold bright_white")
+            t = tree.add(note_md)
+
+        print(tree)
+
+    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:
+        tech_name = Prompt.ask(
+            "Enter the Asset Name to view:", default="Apache Kafka Server"
+        )
+        tech_viewer(tech_name, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

{pyegeria-0.7.27 → pyegeria-0.7.28}/examples/widgets/cat/list_glossary.py

@@ -28,25 +28,35 @@ from pyegeria.glossary_browser_omvs import GlossaryBrowser
 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'))
-
-
-def display_glossary_terms(search_string: str, guid: str, server: str, url: str, username: str, user_password: str,
-                           jupyter: bool = EGERIA_JUPYTER, width: int = EGERIA_WIDTH):
+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_glossary_terms(
+    search_string: str,
+    guid: str,
+    server: str,
+    url: str,
+    username: str,
+    user_password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
     g_client = GlossaryBrowser(server, url)
     token = g_client.create_egeria_bearer_token(username, user_password)
 
-    def generate_table(search_string: str = '*') -> Table:
+    def generate_table(search_string: str = "*") -> Table:
         """Make a new table."""
         table = Table(
             title=f"Glossary Definitions for Terms like  {search_string} @ {time.asctime()}",
@@ -58,7 +68,7 @@ def display_glossary_terms(search_string: str, guid: str, server: str, url: str,
             show_lines=True,
             box=box.ROUNDED,
             caption=f"Glossary View Server '{server}' @ Platform - {url}",
-            expand=True
+            expand=True,
         )
         table.add_column("Display Name")
         table.add_column("Qualified Name")
@@ -67,13 +77,23 @@ def display_glossary_terms(search_string: str, guid: str, server: str, url: str,
         table.add_column("Summary")
         table.add_column("Description")
 
-        terms = g_client.find_glossary_terms(search_string, guid, starts_with=False,
-                                             ends_with=False, status_filter=[], page_size=500)
+        terms = g_client.find_glossary_terms(
+            search_string,
+            guid,
+            starts_with=False,
+            ends_with=False,
+            status_filter=[],
+            page_size=500,
+        )
+
+        sorted_terms = sorted(
+            terms, key=lambda k: k["glossaryTermProperties"]["displayName"]
+        )
         style = "bright_white on black"
         if type(terms) is str:
             return table
 
-        for term in terms:
+        for term in sorted_terms:
             props = term.get("glossaryTermProperties", "None")
             if props == "None":
                 return table
@@ -85,7 +105,12 @@ def display_glossary_terms(search_string: str, guid: str, server: str, url: str,
             description = Text(props.get("description", " "), style=style)
 
             table.add_row(
-                display_name, qualified_name, abbrev, summary, description, style="bold white on black"
+                display_name,
+                qualified_name,
+                abbrev,
+                summary,
+                description,
+                style="bold white on black",
             )
 
         g_client.close_session()
@@ -96,12 +121,17 @@ def display_glossary_terms(search_string: str, guid: str, server: str, url: str,
         #     while True:
         #         time.sleep(2)
         #         live.update(generate_table(search_string))
-        console = Console(style="bold bright_white on black", width=width, force_terminal=not jupyter)
+        console = Console(
+            style="bold bright_white on black", width=width, force_terminal=not jupyter
+        )
         with console.pager(styles=True):
             console.print(generate_table(search_string))
 
-
-    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
         console.print_exception()
 
 
@@ -126,7 +156,7 @@ def main():
     try:
         search_string = Prompt.ask("Enter the term you are searching for:", default="*")
         display_glossary_terms(search_string, guid, server, url, userid, user_pass)
-    except(KeyboardInterrupt):
+    except KeyboardInterrupt:
         pass
 
 

{pyegeria-0.7.27 → pyegeria-0.7.28}/examples/widgets/cat/list_projects.py

@@ -29,23 +29,34 @@ from pyegeria import (
 from pyegeria import ProjectManager, 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_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_project_list(project_name: str, server: str, url: str,
-                         username: str, user_pass: str, save_output: bool, jupyter: bool = EGERIA_JUPYTER,
-                         width: int = EGERIA_WIDTH):
+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_project_list(
+    project_name: str,
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    save_output: bool,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
     p_client = ProjectManager(server, url, user_id=username)
     token = p_client.create_egeria_bearer_token(username, user_pass)
     c_client = ClassificationManager(server, url, token)
@@ -58,7 +69,7 @@ def display_project_list(project_name: str, server: str, url: str,
             show_lines=True,
             box=box.ROUNDED,
             caption=f"Project list for Server '{server}' @ Platform - {url}",
-            expand=True
+            expand=True,
         )
 
         table.add_column("Project Name")
@@ -74,7 +85,6 @@ def display_project_list(project_name: str, server: str, url: str,
         table.add_column("End Date")
         table.add_column("Contracts")
 
-
         projects = p_client.find_projects(project_name)
 
         if projects is None:
@@ -92,12 +102,16 @@ def display_project_list(project_name: str, server: str, url: str,
         elif type(projects) == str:
             raise ValueError("-->This is not a known project")
         else:
-            for project in projects:
+            sorted_projects = sorted(
+                projects, key=lambda k: k["properties"].get("name", "---")
+            )
+
+            for project in sorted_projects:
                 classification = ""
-                guid = project['elementHeader']['guid']
+                guid = project["elementHeader"]["guid"]
                 props = project["properties"]
                 name = props.get("name", "None")
-                p_class = project['elementHeader'].get("classifications")
+                p_class = project["elementHeader"].get("classifications")
                 if p_class:
                     for classif in p_class:
                         classification += f"* {classif.get('classificationName')}\n"
@@ -109,28 +123,43 @@ def display_project_list(project_name: str, server: str, url: str,
                 description = props.get("description", " ")
                 start = props.get("startDate", " ")[0:10]
                 end = props.get("plannedEndDate", " ")
-                additional_properties = project.get('additionalProperties')
+                additional_properties = project.get("additionalProperties")
                 if additional_properties is not None:
                     props = json.dumps(additional_properties)
 
-                governed_by = c_client.get_related_elements(guid,'GovernedBy')
+                governed_by = c_client.get_related_elements(guid, "GovernedBy")
                 if type(governed_by) is list:
                     for gov in governed_by:
-                        rel_guid = gov['relatedElement']['elementHeader']['guid']
-                        rel_title = gov['relatedElement']['properties'].get('title','---')
-                        certified_partner= f"{rel_title}: \n"
-                        certified = c_client.get_related_elements(rel_guid, "Certification")
+                        rel_guid = gov["relatedElement"]["elementHeader"]["guid"]
+                        rel_title = gov["relatedElement"]["properties"].get(
+                            "title", "---"
+                        )
+                        certified_partner = f"{rel_title}: \n"
+                        certified = c_client.get_related_elements(
+                            rel_guid, "Certification"
+                        )
                         if type(certified) is list:
-                           for rel_elem in certified:
-                                p_name = rel_elem['relatedElement']['properties']['name']
+                            for rel_elem in certified:
+                                p_name = rel_elem["relatedElement"]["properties"][
+                                    "name"
+                                ]
                                 certified_partner += f"* {p_name}\n"
                 else:
                     certified_partner = "---"
 
-
                 table.add_row(
-                    name, description, classification, qualified_name, identifier, phase, health, status, start,
-                    end, certified_partner)
+                    name,
+                    description,
+                    classification,
+                    qualified_name,
+                    identifier,
+                    phase,
+                    health,
+                    status,
+                    start,
+                    end,
+                    certified_partner,
+                )
 
         p_client.close_session()
         return table
@@ -140,13 +169,20 @@ def display_project_list(project_name: str, server: str, url: str,
         #     while True:
         #         time.sleep(2)
         #         live.update(generate_table())
-        console = Console(record=True,width=width, force_terminal=not jupyter, soft_wrap=True)
+        console = Console(
+            record=True, width=width, force_terminal=not jupyter, soft_wrap=True
+        )
         with console.pager():
             console.print(generate_table(project_name), soft_wrap=True)
         if save_output:
             console.save_html("projects.html")
 
-    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException, ValueError) as e:
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+        ValueError,
+    ) as e:
         if type(e) is str:
             print(e)
         else:

{pyegeria-0.7.27 → pyegeria-0.7.28}/examples/widgets/cat/list_user_ids.py

@@ -14,33 +14,38 @@ from pyegeria import (
     PropertyServerException,
     UserNotAuthorizedException,
     print_exception_response,
-   ClassificationManager
+    ClassificationManager,
 )
 
 
 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_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 list_user_ids(server: str,
-                       url: str, username: str, password: str, jupyter:bool=EGERIA_JUPYTER, width:int = EGERIA_WIDTH
+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 list_user_ids(
+    server: str,
+    url: str,
+    username: str,
+    password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
 ):
-
     c_client = ClassificationManager(server, url, user_id=username, user_pwd=password)
     token = c_client.create_egeria_bearer_token()
-    elements = c_client.get_elements('UserIdentity')
+    elements = c_client.get_elements("UserIdentity")
 
     def generate_table() -> Table:
         """Make a new table."""
@@ -61,27 +66,38 @@ def list_user_ids(server: str,
         table.add_column("Job Title")
         table.add_column("UserId")
         table.add_column("Created")
-        table.add_column("GUID", width = 38,no_wrap=True)
+        table.add_column("GUID", width=38, no_wrap=True)
         table.add_column("Qualified Name")
 
-
         if type(elements) is list:
-            for element in elements:
-                header = element['elementHeader']
-                el_q_name = element['properties'].get('qualifiedName',"---")
-                el_create_time = header['versions']['createTime'][:-10]
-                el_guid = header['guid']
-                el_user_id = element['properties'].get('userId',"---")
-                full_name = ''
-                job = ''
-
-                profile = c_client.get_related_elements(el_guid, 'ProfileIdentity')
+            sorted_elements = sorted(
+                elements, key=lambda i: i["properties"].get("userId", "---")
+            )
+            for element in sorted_elements:
+                header = element["elementHeader"]
+                el_q_name = element["properties"].get("qualifiedName", "---")
+                el_create_time = header["versions"]["createTime"][:-10]
+                el_guid = header["guid"]
+                el_user_id = element["properties"].get("userId", "---")
+                full_name = ""
+                job = ""
+
+                profile = c_client.get_related_elements(el_guid, "ProfileIdentity")
                 if type(profile) is list:
                     for rel in profile:
-                        full_name = rel['relatedElement']['properties'].get('fullName','---')
-                        job = rel['relatedElement']['properties'].get('jobTitle','---')
-
-                table.add_row(full_name, job, el_user_id, el_create_time, el_guid, el_q_name,)
+                        full_name = rel["relatedElement"]["properties"].get(
+                            "fullName", "---"
+                        )
+                        job = rel["relatedElement"]["properties"].get("jobTitle", "---")
+
+                table.add_row(
+                    full_name,
+                    job,
+                    el_user_id,
+                    el_create_time,
+                    el_guid,
+                    el_q_name,
+                )
 
             return table
         else:
@@ -94,7 +110,11 @@ def list_user_ids(server: str,
         with console.pager(styles=True):
             console.print(generate_table())
 
-    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
         print_exception_response(e)
         print("Perhaps the type name isn't known")
     finally:
@@ -117,12 +137,9 @@ def main():
 
     try:
         list_user_ids(server, url, userid, password)
-    except(KeyboardInterrupt):
+    except KeyboardInterrupt:
         pass
 
 
 if __name__ == "__main__":
     main()
-
-
-