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

commands/ops/list_archives.py

@@ -22,40 +22,27 @@ from rich.table import Table
 
 from pyegeria import (
     ClassificationManager,
-    InvalidParameterException,
-    ProjectManager,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+    PyegeriaException,
+    print_basic_exception,
+    settings,
+    config_logging
 )
 
-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"))
 
+app_config = settings.Environment
+config_logging()
+console = Console(width = app_config.console_width)
 
 def display_archive_list(
     server: str,
     url: str,
     username: str,
     user_pass: str,
-    save_output: bool,
-    jupyter: bool = EGERIA_JUPYTER,
-    width: int = EGERIA_WIDTH,
+    save_output: bool = False,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width
 ) -> object:
     c_client = ClassificationManager(server, url, user_id=username)
     token = c_client.create_egeria_bearer_token(username, user_pass)
@@ -78,12 +65,10 @@ def display_archive_list(
         # table.add_column("Creator")
         # table.add_column("Description")
 
-        open_metadata_type_name = None
+        metadata_element_type_name = None
         property_value = "omarchive"
         property_names = ["fileExtension"]
-        archives = c_client.get_elements_by_property_value(
-            property_value, property_names, open_metadata_type_name
-        )
+        archives = c_client.get_elements_by_property_value(property_value, property_names, metadata_element_type_name)
 
         if type(archives) != list:
             raise ValueError("--> No archives found")
@@ -93,7 +78,7 @@ def display_archive_list(
             )
 
             for archive in sorted_archives:
-                name = archive["properties"].get("name", "---")
+                name = archive["properties"].get("displayName", "---")
                 path_name = archive["properties"].get("pathName", "---")
                 description = archive["properties"].get("description", "---")
                 creation_date_epoch = (
@@ -107,10 +92,6 @@ def display_archive_list(
         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(
             record=True, width=width, force_terminal=not jupyter, soft_wrap=True
         )
@@ -120,15 +101,13 @@ def display_archive_list(
             console.save_html("archives.html")
 
     except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
+        PyegeriaException,
         ValueError,
     ) as e:
         if type(e) is str:
             print(e)
         else:
-            print_exception_response(e)
+            console.print_exception(show_locals=True)
     except KeyboardInterrupt:
         pass
     finally:
@@ -145,8 +124,8 @@ def main():
     # parser.add_argument("--sponsor", help="Name of sponsor to search")
     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
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_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
 

commands/ops/list_catalog_targets.py

@@ -10,6 +10,7 @@ List catalog targets
 """
 import argparse
 import os
+import sys
 import time
 
 from rich import box
@@ -18,40 +19,32 @@ from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
 
+
 from pyegeria import (
-    INTEGRATION_GUIDS,
-    AutomatedCuration,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+    EgeriaTech,
+    PyegeriaException,
+    print_basic_exception,
+    settings,
+    config_logging
 )
 
-EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
-EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
-EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
-EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "view-server")
-EGERIA_VIEW_SERVER_URL = os.environ.get(
-    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
-)
-EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
-EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
-EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
-EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
-EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+app_config = settings.Environment
+config_logging()
+console = Console(width = app_config.console_width)
 
 
 def display_catalog_targets(
     connector: str,
-    view_server: str = EGERIA_VIEW_SERVER,
-    view_url: str = EGERIA_VIEW_SERVER_URL,
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
     user: str = EGERIA_USER,
     user_pass: str = EGERIA_USER_PASSWORD,
     paging: bool = True,
-    jupyter: bool = EGERIA_JUPYTER,
-    width: int = EGERIA_WIDTH,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width,
 ):
     """Display catalog targets for the specified connector as a table.
 
@@ -100,7 +93,7 @@ def display_catalog_targets(
 
         if type(cat_targets) is list:
             for target in cat_targets:
-                target_name = target.get("catalogTargetName", "---")
+                target_name = target['properties'].get("catalogTargetName", "---")
                 target_source = target.get("metadataSourceQualifiedName", "---")
                 target_rel = target.get("relationshipGUID", "---")
                 target_sync = target.get("permittedSynchronization")
@@ -144,26 +137,28 @@ def display_catalog_targets(
         return table
 
     try:
-        a_client = AutomatedCuration(view_server, view_url, user)
+        a_client = EgeriaTech(view_server, view_url, user)
         token = a_client.create_egeria_bearer_token(user, user_pass)
         connector = connector.strip()
-        if connector not in INTEGRATION_GUIDS.keys():
-            raise Exception
 
-        connector_guid = INTEGRATION_GUIDS[connector]
+
+        connector_guid = a_client.get_connector_guid(connector)
+        if connector_guid is None or connector_guid == "No connector found":
+            console.print(f"\n\n===> No connector found with name '{connector}'\n\n")
+            sys.exit(1)
+
         cat_targets = a_client.get_catalog_targets(connector_guid)
         console = Console(force_terminal=not jupyter, width=width, soft_wrap=True)
         with console.pager(styles=True):
             console.print(generate_table(), soft_wrap=True)
 
+
+    except PyegeriaException as e:
+        print(f"\n\n===> Perhaps integration connector {connector} is not known?\n\n")
+        print_basic_exception(e)
     except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
+        Exception
     ) as e:
-        print_exception_response(e)
-    except Exception as e:
-        print(f"\n\n===> Perhaps integration connector {connector} is not known?\n\n")
         console.print_exception()
     finally:
         a_client.close_session()
@@ -180,20 +175,18 @@ def main():
 
     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_VIEW_SERVER_URL
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_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
-    jupyter = args.jupyter if args.jupyter is not None else EGERIA_JUPYTER
-    width = args.width if args.width is not None else EGERIA_WIDTH
+    jupyter = args.jupyter if args.jupyter is not None else app_config.egeria_jupyter
+    width = args.width if args.width is not None else app_config.console_width
 
     try:
         connector = Prompt.ask(
             "Enter the Integration Connector to list catalog targets for"
         ).strip()
-        display_catalog_targets(
-            connector, server, url, userid, user_pass, jupyter, width=width
-        )
+        display_catalog_targets(connector, server, url, userid, user_pass, jupyter, width=width)
 
     except KeyboardInterrupt:
         pass

commands/ops/load_archive.py

@@ -9,30 +9,35 @@ This script refreshed an integration daemon.
 """
 
 import os
+import sys
 
 import click
-
-from pyegeria import AutomatedCuration, EgeriaTech
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+from pyegeria import EgeriaTech, PyegeriaAPIException
+from pyegeria.core.config import settings
+from pyegeria.core.logging_configuration import config_logging
+from pyegeria.core._exceptions import (
+    PyegeriaException, print_basic_exception
 )
 
-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_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_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+app_settings = settings
+app_config = app_settings.Environment
+config_logging()
 
 
 @click.command("load-archive")
@@ -42,13 +47,13 @@ EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
     help="Full path on the Metadata Server to the archive file to load",
 )
 @click.option(
-    "--server_name", default=EGERIA_METADATA_STORE, help="Egeria metadata store to load"
+    "--server_name", default=app_config.egeria_metadata_store, help="Egeria metadata store to load"
 )
 @click.option(
-    "--view-server", default=EGERIA_VIEW_SERVER, help="Egeria view server to connect to"
+    "--view-server", default=app_config.egeria_view_server, help="Egeria view server to connect to"
 )
 @click.option(
-    "--url", default=EGERIA_PLATFORM_URL, help="URL of Egeria platform to connect to"
+    "--url", default=app_config.egeria_platform_url, help="URL of Egeria platform to connect to"
 )
 @click.option("--userid", default=EGERIA_USER, help="Egeria admin user")
 @click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria admin password")
@@ -59,18 +64,22 @@ def load_archive(file_name, server_name, view_server, url, userid, password, tim
     try:
         s_client = EgeriaTech(view_server, url, userid, password)
         token = s_client.create_egeria_bearer_token()
-        server_guid = None
+        server_guid = s_client.__get_guid__(display_name = server_name, property_name = "resourceName", tech_type = "MetadataStore")
         file_name = file_name.strip()
+        if server_guid == "No elements found":
+            print("Didn't find the metadata store")
+            sys.exit(0)
+
         s_client.add_archive_file(file_name, server_guid, server_name, time_out=timeout)
 
         click.echo(f"Loaded archive: {file_name}")
 
-    except (InvalidParameterException, PropertyServerException) as e:
+    except (PyegeriaException, PyegeriaAPIException) as e:
         print(
-            f"Perhaps there was a timeout? If so, the command will complete despite the exception\n"
-            f"===> You can check by rerunning the command in a few minutes"
+            "Perhaps there was a timeout? If so, the command will complete despite the exception\n" 
+            "===> You can check by rerunning the command in a few minutes"
         )
-        print_exception_response(e)
+        print_basic_exception(e)
 
 
 if __name__ == "__main__":

commands/ops/{monitor_engine_activity_c.py → monitor_active_engine_activity.py}

@@ -18,50 +18,34 @@ import time
 from rich import box
 from rich.console import Console
 from rich.live import Live
-from rich.markdown import Markdown
 from rich.table import Table
 
 from pyegeria import (
-    AutomatedCuration,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
+    EgeriaTech,
+    PyegeriaException,
+    print_basic_exception,
+    settings,
+    config_logging
 )
 
-EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
-EGERIA_KAFKA_ENDPOINT = os.environ.get("EGERIA_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_ENGINE_HOST = os.environ.get("EGERIA_ENGINE_HOST", "engine-host")
-EGERIA_ENGINE_HOST_URL = os.environ.get(
-    "EGERIA_ENGINE_HOST_URL", "https://localhost:9443"
-)
-EGERIA_INTEGRATION_DAEMON = os.environ.get(
-    "EGERIA_INTEGRATION_DAEMON", "integration_daemon"
-)
-EGERIA_ADMIN_USER = os.environ.get("EGERIA_ADMIN_USER", "garygeeke")
-EGERIA_ADMIN_PASSWORD = os.environ.get("EGERIA_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
+app_config = settings.Environment
+config_logging()
+console = Console(width = app_config.console_width)
 
 
-def display_engine_activity_c(
+def display_engine_activity(
     row_limit: int = 0,
-    view_server: str = EGERIA_VIEW_SERVER,
-    view_url: str = EGERIA_VIEW_SERVER_URL,
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
     user: str = EGERIA_USER,
     user_pass: str = EGERIA_USER_PASSWORD,
     paging: bool = True,
-    jupyter: bool = EGERIA_JUPYTER,
-    width: int = EGERIA_WIDTH,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width,
 ):
     """Display governance engine activity as a table.
 
@@ -84,7 +68,7 @@ def display_engine_activity_c(
     width : int
         The width of the console for table printing.
     """
-    g_client = AutomatedCuration(view_server, view_url, user, user_pwd=user_pass)
+    g_client = EgeriaTech(view_server, view_url, user, user_pwd=user_pass)
     token = g_client.create_egeria_bearer_token()
 
     def generate_table() -> Table:
@@ -102,15 +86,17 @@ def display_engine_activity_c(
             expand=True,
         )
         table.add_column("Requested Time")
-        table.add_column("Core Info")
-        table.add_column("Target Elements")
-
+        table.add_column("Start Time")
+        table.add_column("Action GUID", no_wrap=True)
+        table.add_column("Engine Name")
+        table.add_column("Request Type")
         table.add_column("Action Status")
+        table.add_column("Target Element")
         table.add_column("Completion Time")
-        table.add_column("Core Results")
-        # table.add_column("Completion Message")
+        table.add_column("Process Name")
+        table.add_column("Completion Message")
 
-        action_status = g_client.get_engine_actions()
+        action_status = g_client.get_active_engine_actions()
 
         if type(action_status) is str:
             requested_time = " "
@@ -133,10 +119,9 @@ def display_engine_activity_c(
                 if row_limit > 0 and row_count >= row_limit:
                     break
                 row_count += 1
-                requested_time = action.get("requestedTime", " ")[:-10]
-                start_time = action.get("startTime", " ")[:-10]
-                completion_time = action.get("completionTime", " ")[:-10]
-                completion_guards = action.get("completionGuards", " ")
+                requested_time = action.get("requestedTime", " ")
+                start_time = action.get("startTime", " ")
+                completion_time = action.get("completionTime", " ")
 
                 engine_name = action["governanceEngineName"]
                 request_type = action["requestType"]
@@ -148,57 +133,42 @@ def display_engine_activity_c(
                     "ACTIVATING",
                 ):
                     action_status = f"[yellow]{action['actionStatus']}"
-                elif action["actionStatus"] in ("IN_PROGRESS", "ACTIONED"):
+                elif action["actionStatus"] in ("IN_PROGRESS", "COMPLETED"):
                     action_status = f"[green]{action['actionStatus']}"
                 else:
                     action_status = f"[red]{action['actionStatus']}"
 
-                request_parameters_md = " "
-                request_parameters = action.get("requestParameters", "Empty")
-                if type(request_parameters) is dict:
-                    for key, value in request_parameters.items():
-                        request_parameters_md += f"\t* {key}: {value}\n"
-
                 targets = action.get("actionTargetElements", "Empty")
                 if type(targets) is list:
+                    tgt_tab = Table()
+                    tgt_tab.add_column("name")
+                    tgt_tab.add_column("guid", no_wrap=True)
+                    tgt_tab.add_column("type_name")
                     targets_md = ""
                     for target in targets:
                         t_name = target["actionTargetName"]
                         t_guid = target["actionTargetGUID"]
                         t_type = target["targetElement"]["type"]["typeName"]
-                        targets_md += (
-                            f"* Target Name: {t_name}\n"
-                            f"   * Target GUID: {t_guid}\n"
-                            f"   * Target Type: {t_type}\n"
-                        )
-
+                        tgt_tab.add_row(t_name, t_guid, t_type)
                     # target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
-                    target_element = Markdown(f"{targets_md} ---\n")
+                    target_element = tgt_tab
                 else:
                     target_element = " "
 
-                process_name = action.get("processName", "Null")
+                process_name = action.get("processName", " ")
                 completion_message = action.get("completionMessage", " ")
-                core_results_md = (
-                    f"* Completion Guards: {completion_guards}\n"
-                    f"* Completion Message: {completion_message}"
-                )
-                core_results_out = Markdown(core_results_md)
-                core_info_md = (
-                    f"* Start Time: {start_time}\n* Engine Name: {engine_name}\n* GUID: {action_guid}\n"
-                    f"* Request Type: {request_type}\n"
-                    f"* Process Name: {process_name}\n"
-                    f"---\n"
-                    f"* Request Parameters: \n{request_parameters_md}\n"
-                )
-                core_info_out = Markdown(core_info_md)
+
                 table.add_row(
                     requested_time,
-                    core_info_out,
-                    target_element,
+                    start_time,
+                    action_guid,
+                    engine_name,
+                    request_type,
                     action_status,
+                    target_element,
                     completion_time,
-                    core_results_out,
+                    process_name,
+                    completion_message,
                 )
         else:
             print("Egeria integration daemon not running")
@@ -223,11 +193,9 @@ def display_engine_activity_c(
                     live.update(generate_table())
 
     except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
+        PyegeriaException
     ) as e:
-        print_exception_response(e)
+        print_basic_exception(e)
     except KeyboardInterrupt:
         pass
     finally:
@@ -246,12 +214,13 @@ def main_live():
 
     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_VIEW_SERVER_URL
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_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
     rowlimit = int(args.rowlimit) if args.rowlimit is not None else 0
-    display_engine_activity_c(
+
+    display_engine_activity(
         rowlimit, server, url, user=userid, user_pass=user_pass, paging=False
     )
 
@@ -268,13 +237,13 @@ def main_paging():
 
     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_VIEW_SERVER_URL
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_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
     rowlimit = int(args.rowlimit) if args.rowlimit is not None else 0
 
-    display_engine_activity_c(
+    display_engine_activity(
         rowlimit, server, url, user=userid, user_pass=user_pass, paging=True
     )