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

pyegeria/commands/my/list_my_profile.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple display for my profile
+"""
+import os
+import argparse
+import time
+import sys
+
+from rich import box, print
+from rich.console import Console
+from rich.table import Table
+from rich.tree import Tree
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.my_profile_omvs import MyProfile
+
+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_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", "150"))
+
+
+def display_my_profile(
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    try:
+        m_client = MyProfile(server, url, user_id=username, user_pwd=user_pass)
+        token = m_client.create_egeria_bearer_token(username, user_pass)
+        my_profiles = m_client.get_my_profile()
+        if type(my_profiles) is str:
+            print(f"No profiles found for {username}")
+            sys.exit(1)
+
+        console = Console(width=width, force_terminal=not jupyter, soft_wrap=True)
+
+        profile_props = my_profiles.get("profileProperties", "---")
+        name = profile_props["fullName"]
+
+        tree = Tree(
+            Panel(f"Profile of {name}", title="Personal Profile"),
+            expanded=True,
+            style="bright_white on black",
+            guide_style="bold bright_blue",
+        )
+
+        profile_props_md = f"\n* GUID: {my_profiles['elementHeader']['guid']}\n"
+        if type(profile_props) is dict:
+            for key in profile_props.keys():
+                if type(profile_props[key]) is str:
+                    profile_props_md += f"* {key}: {profile_props[key]}\n"
+                elif type(profile_props[key]) is dict:
+                    p_md = "\n* Additional Details:\n"
+                    for k in profile_props[key].keys():
+                        p_md += f"\t* {k}: {profile_props[key][k]}\n"
+                    profile_props_md += p_md
+            t1 = tree.add(
+                Panel(
+                    Markdown(profile_props_md), title="Profile Properties", expand=False
+                )
+            )
+
+        id_list_md = ""
+        for identities in my_profiles["userIdentities"]:
+            id_list_md += (
+                f"* {identities['userIdentity']['properties']['userId']}\n"
+                f"* {identities['userIdentity']['elementHeader']['guid']}\n"
+            )
+        t2 = tree.add(Panel(Markdown(id_list_md), title="Identities", expand=False))
+
+        contact_methods = my_profiles["contactMethods"]
+        for method in contact_methods:
+            contact = method["properties"]
+            contact_methods_md = ""
+            for key in contact.keys():
+                contact_methods_md += f"* {key}: {contact[key]}\n"
+            t3 = tree.add(
+                Panel(
+                    Markdown(contact_methods_md), title="Contact Methods", expand=False
+                )
+            )
+
+        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)
+
+        print(tree)
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    finally:
+        m_client.close_session()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+
+    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
+
+    display_my_profile(server, url, userid, user_pass)
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/my/list_my_roles.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+List the roles for a given user.
+"""
+import os
+import argparse
+import time
+import sys
+
+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
+
+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_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_my_roles(
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    m_client = MyProfile(server, url, user_id=username, user_pwd=user_pass)
+    token = m_client.create_egeria_bearer_token(username, user_pass)
+    my_profiles = m_client.get_my_profile()
+    if type(my_profiles) is str:
+        print(f"No profiles found for {username}")
+        sys.exit(1)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"My Profile Information {url} @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"My Profile from Server '{server}' @ Platform - {url}\n Press 'q' to Quit",
+            expand=True,
+        )
+
+        table.add_column("Name")
+        table.add_column("Job Title")
+        table.add_column("userId")
+        table.add_column("myGUID")
+        table.add_column("Role Type")
+        table.add_column("Role")
+        table.add_column("Role GUID")
+
+        if len(my_profiles) == 0:
+            name = " "
+            job_title = " "
+            user_id = " "
+            my_guid = " "
+            role_type = " "
+            role = " "
+            role_guid = " "
+        else:
+            name = my_profiles["profileProperties"]["fullName"]
+            job_title = my_profiles["profileProperties"]["jobTitle"]
+            id_list = " "
+            for identities in my_profiles["userIdentities"]:
+                id_list = (
+                    f"{identities['userIdentity']['properties']['userId']} {id_list}"
+                )
+
+            my_guid = my_profiles["elementHeader"]["guid"]
+
+            my_roles = my_profiles["roles"]
+            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(
+                    name, job_title, str(id_list), my_guid, role_type, role, role_guid
+                )
+
+        m_client.close_session()
+        return table
+
+    try:
+        # with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+        #     while True:
+        #         time.sleep(2)
+        #         live.update(generate_table())
+        console = Console(width=width, force_terminal=not jupyter)
+        with console.pager():
+            console.print(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+        assert e.related_http_code != "200", "Invalid parameters"
+
+
+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
+
+    display_my_roles(server, url, userid, user_pass)
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/my/monitor_my_todos.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display of a user's todos
+"""
+import os
+import argparse
+import time
+
+from rich import box
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.console import Console
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.my_profile_omvs import MyProfile
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+disable_ssl_warnings = True
+
+
+def display_my_todos(
+    server: str,
+    url: str,
+    user: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    console = Console(width=width, force_terminal=not jupyter)
+
+    m_client = MyProfile(server, url, user_id=user)
+    token = m_client.create_egeria_bearer_token(user, user_pass)
+
+    def add_rows(table: Table, guid: str, identity: str) -> None:
+        todo_items = m_client.get_assigned_actions(guid)
+        if type(todo_items) is str:
+            return
+
+        for item in todo_items:
+            assigned_actors = ''
+            if todo_items is None:
+                name = " "
+                type_name = " "
+                todo_guid = " "
+                created = " "
+                priority = " "
+                due = " "
+                completed = " "
+                status = " "
+                sponsor = " "
+            else:
+                props = item["properties"]
+                name = props["name"]
+                todo_type_name = props.get("toDoType", " ")
+                todo_guid = item["elementHeader"].get("guid", "---")
+                created = props.get("creationTime", "---")
+                priority = str(props.get("priority", "---"))
+                due = props.get("dueTime", " ")
+                completed = props.get("completionTime", "---")
+                status = props.get("toDoStatus")
+
+                for actor in item["assignedActors"]:
+                    assigned_actors+=f"{actor.get("uniqueName", "NoOne")}\n"
+                assigned_actors_out = Markdown(assigned_actors)
+                if status in ("WAITING", "OPEN"):
+                    status = f"[yellow]{status}"
+                elif status in ("INPROGRESS", "COMPLETE"):
+                    status = f"[green]{status}"
+                else:
+                    status = f"[red]{status}"
+
+            table.add_row(
+                str(identity),
+                name,
+                todo_type_name,
+                todo_guid,
+                created,
+                priority,
+                due,
+                completed,
+                status,
+                assigned_actors_out,
+            )
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Open ToDos for Platform {url} @ {time.asctime()}",
+            # style = "black on grey66",
+            header_style="white on dark_blue",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"ToDos for Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+        table.add_column("Actor")
+        table.add_column("ToDo Name")
+        table.add_column("Type Name")
+        table.add_column("GUID")
+        table.add_column("Created")
+        table.add_column("Priority")
+        table.add_column("Due")
+        table.add_column("Completion")
+        table.add_column("Status")
+        table.add_column("Sponsor")
+
+        my_profile = m_client.get_my_profile()
+        my_guid = my_profile["elementHeader"].get("guid", "---")
+        my_ids = my_profile["userIdentities"]
+        my_title = my_profile["profileProperties"].get("jobTitle", "No Title")
+        user_ids = []
+        for id in my_ids:
+            user_ids.append(id["userIdentity"]["properties"].get("userid", "NoOne"))
+            add_rows(
+                table,
+                id["userIdentity"]["elementHeader"]["guid"],
+                id["userIdentity"]["properties"]["userId"],
+            )
+
+        add_rows(table, my_guid, user_ids)
+
+        # user_id_guid = my_profile["userIdentity"]["guid"]
+        # user_id_name = my_profile["userIdentity"]["properties"]["userid"]
+        # add_rows(table, user_id_guid, user_id_name)
+
+        my_roles = my_profile["roles"]
+        if type(my_roles) is list:
+            for role in my_roles:
+                role_guid = role["elementHeader"]["guid"]
+                role_id = role["properties"].get("roleId", "No Role Id")
+                add_rows(table, role_guid, role_id)
+
+        # m_client.close_session()
+        return table
+
+    try:
+        with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+            while True:
+                time.sleep(2)
+                live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        m_client.close_session()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the view server to connect to")
+    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 "peterprofile"
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    try:
+        print(f"Starting display_todos with {server}, {url}, {userid}")
+        display_my_todos(server=server, url=url, user=userid, user_pass=user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/commands/my/monitor_open_todos.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display for Open To Dos
+"""
+import os
+import argparse
+import time
+import sys
+from rich import box
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.console import Console
+
+from pyegeria import EgeriaTech
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+from pyegeria.my_profile_omvs import MyProfile
+
+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_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_todos(
+    server: str,
+    url: str,
+    user: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    console = Console(width=width, force_terminal=not jupyter)
+
+    m_client = EgeriaTech(server, url, user_id=user)
+    token = m_client.create_egeria_bearer_token(user, user_pass)
+
+    def generate_table(search_string: str = "*") -> Table:
+        """Make a new table."""
+        table = Table(
+            header_style="bright_white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            title=f"Open ToDos for Platform {url} @ {time.asctime()}",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"ToDos for Server '{server}' @ Platform - {url}",
+            expand=True,
+        )
+
+        table.add_column("Name")
+        table.add_column("Type Name")
+
+        table.add_column("Created")
+        table.add_column("Priority")
+        table.add_column("Due")
+        table.add_column("Completion")
+        table.add_column("Status")
+        table.add_column("Assigned Actors")
+
+        todo_items = m_client.find_to_do("*", starts_with=True)
+        if type(todo_items) is str:
+            print("===> No To Do items found")
+            sys.exit()
+        if todo_items is None:
+            name = " "
+            type_name = " "
+            created = " "
+            priority = " "
+            due = " "
+            completed = " "
+            status = " "
+            assigned = " "
+        else:
+            for item in todo_items:
+                props = item["properties"]
+                name = props["name"]
+                type_name = props.get("toDoType", " ")
+                created = props.get("creationTime", " ")
+                priority = str(props.get("priority", " "))
+                due = props.get("dueTime", " ")
+                completed = props.get("completionTime", " ")
+                status = props.get("toDoStatus", "---")
+                assigned_actors = item["assignedActors"]
+
+                assigned = ""
+                if type(assigned_actors) is list:
+                    for actor in assigned_actors:
+                        actor_guid = actor["guid"]
+                        assigned += f"{m_client.get_actor_for_guid(actor_guid)} \n ({actor_guid}"
+                assigned_out = Markdown(assigned)
+
+                if status in ("WAITING", "OPEN"):
+                    status = f"[yellow]{status}"
+                elif status in ("INPROGRESS", "COMPLETE"):
+                    status = f"[green]{status}"
+                else:
+                    status = f"[red]{status}"
+
+                table.add_row(
+                    name,
+                    type_name,
+                    created,
+                    priority,
+                    due,
+                    completed,
+                    status,
+                    assigned_out,
+                )
+
+        return table
+
+    try:
+        with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+            while True:
+                time.sleep(2)
+                live.update(generate_table())
+                live.console.pager()
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        m_client.close_session()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the view server to connect to")
+    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
+    display_todos(server=server, url=url, user=userid, user_pass=user_pass)
+
+
+if __name__ == "__main__":
+    main()