pyegeria 0.3.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyegeria-0.4.0.data/scripts/view_asset_graph.py

@@ -0,0 +1,236 @@
+#!python
+"""
+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
+
+from rich import json
+from rich.panel import Panel
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    AssetCatalog
+)
+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
+
+disable_ssl_warnings = True
+console = Console(width=200)
+
+platform = "https://127.0.0.1:9443"
+user = "erinoverview"
+view_server = "view-server"
+
+guid_list = []
+
+def asset_viewer(asset_name: str, server_name:str, platform_url:str, user:str):
+
+    def build_classifications(classification: dict) -> Markdown:
+
+        class_md = "-"
+        for c in classification:
+            c_type = c["classificationName"]
+            if c_type == "Anchors":
+                continue
+            class_md += f"* Classification: {c_type}\n"
+            class_props = c["classificationProperties"]
+            for prop in class_props.keys():
+                class_md += f"* {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_created_by = nested_element["versions"]["createdBy"]
+        ne_created_at = nested_element["versions"]["createTime"]
+        ne_guid = nested_element["guid"]
+        guid_list.append(ne_guid)
+
+        ne_type = nested_element["type"]["typeName"]
+        ne_classifications = nested_element["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["properties"]
+
+        ne_prop_md = ""
+        for prop in ne_props.keys():
+            ne_prop_md += f"* {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"{ne_prop_md}\n")
+        if ne_class_md is not None:
+            ne_md += f"* {ne_class_md}"
+
+        output = Markdown(ne_md)
+        return output
+
+    try:
+
+        console = Console(width=200)
+
+        a_client = AssetCatalog(view_server, platform,
+                                     user_id=user)
+
+        token = a_client.create_egeria_bearer_token(user, "secret")
+        asset_info = a_client.find_assets_in_domain(asset_name)
+        asset_guid = asset_info[0]['guid']
+        guid_list.append(asset_guid)
+
+        asset_graph = a_client.get_asset_graph(asset_guid)
+        if type(asset_graph) is not dict:
+            print(f"\n No Asset found for {asset_name}")
+            sys.exit(1)
+
+        # print(f"\n{json.dumps(asset_graph, indent =2)}\n")
+        tree = Tree(f"{asset_name} ({asset_guid})", style = "bold bright_white",guide_style="bold bright_blue")
+        style = ""
+
+        asset_name = asset_graph["displayName"]
+        qualified_name = asset_graph["qualifiedName"]
+        resource_name = asset_graph["resourceName"]
+
+        asset_type = asset_graph["type"]["typeName"]
+        asset_origin = asset_graph["origin"]["homeMetadataCollectionName"]
+        asset_creation = asset_graph["versions"]["createTime"]
+        asset_created_by = asset_graph["versions"]["createdBy"]
+        asset_classifications = asset_graph["classifications"]
+        asset_nested_elements = asset_graph["anchoredElements"]
+        asset_relationships = asset_graph["relationships"]
+        asset_class_md = build_classifications(asset_classifications)
+
+
+        asset_properties = asset_graph["extendedProperties"]
+        prop_md = ""
+        for prop in asset_properties:
+            prop_md = f"{prop_md}* {prop}: {asset_properties[prop]}\n"
+
+        core_md = (f"**Type: {asset_type} Created by: {asset_created_by} on {asset_creation}**\n"
+               f"* Qualified Name: {qualified_name}\n "
+               f"* Resource Name: {resource_name}\n"
+               f"* Display Name: {asset_name}\n"
+               f"* Asset Origin: {asset_origin}\n{prop_md}"
+               )
+        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")
+            l2 = tree.add(p2)
+
+        #
+        # Nested Assets
+        #
+        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["uniqueName"]
+
+            rel_end2 = relationship["end2"]
+            rel_end2_type = rel_end2["type"]["typeName"]
+            rel_end2_guid = rel_end2["guid"]
+            rel_end2_unique_name = rel_end2["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_md + rel_end1_class_md
+
+                rel_end2_md = (
+                    f"* End1:\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_md + rel_end2_class_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")
+                tree.add(relationship_panel)
+
+
+        print("\n\n")
+        print(tree)
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException
+    ) as e:
+        print_exception_response(e)
+
+
+if __name__ == "__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")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else "view-server"
+    url = args.url if args.url is not None else "https://localhost:9443"
+    userid = args.userid if args.userid is not None else 'erinoverview'
+
+    asset_name = Prompt.ask("Enter the Asset Name to view:", default="TransMorg-Clinical-Trials-Weeklies")
+    asset_viewer(asset_name,server, url, userid)

pyegeria-0.3.8.data/scripts/multi-server_status.py → pyegeria-0.4.0.data/scripts/view_coco_status.py

@@ -3,13 +3,21 @@
 SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
-An example of displaying the status of two platforms concurrently.
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple server status display for the Coco Pharmaceuticals Configuration
 """
 
-import time
 import argparse
+import time
 
-from rich.box import Box
+from rich import box
+from rich import print
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
 
 from pyegeria._exceptions import (
     InvalidParameterException,
@@ -17,44 +25,19 @@ from pyegeria._exceptions import (
     UserNotAuthorizedException,
     print_exception_response,
 )
-from rich.table import Table
-from rich.live import Live
-from rich import print
-from rich.console import Group
-from rich.panel import Panel
-from rich import box, align
-from rich.layout import Layout
-import rich
 from pyegeria.server_operations import ServerOps
 
 disable_ssl_warnings = True
 
-good_platform1_url = "https://127.0.0.1:9443"
-good_platform2_url = "https://egeria.pdr-associates.com:9443"
-bad_platform1_url = "https://localhost:9443"
-
 
-good_user_1 = "garygeeke"
-good_user_2 = "erinoverview"
-bad_user_1 = "eviledna"
-bad_user_2 = ""
-
-good_server_1 = "active-metadata-store"
-good_server_2 = "simple-metadata-store"
-good_server_3 = "view-server"
-good_server_4 = "engine-host"
-bad_server_1 = "coco"
-bad_server_2 = ""
-
-
-def test_display_status(server: str = good_server_1, url: str = good_platform2_url, username: str = good_user_1):
+def test_display_status(server: str, url: str, username: str):
     layout = Layout()
     print(layout)
 
     print(layout)
-    p_client1 = ServerOps(server, "https://cray.local:9443", username)
-    p_client2 = ServerOps('ecosystem-monitor', "https://cray.local:9446", username)
-
+    p_client1 = ServerOps("Core Catalog", "https://localhost:9443", username)
+    p_client2 = ServerOps('Datalake Catalog', "https://localhost:9444", username)
+    p_client3 = ServerOps('DevCatalog', "https://localhost:9445", username)
 
     def generate_table(p_client) -> Table:
         """Make a new table."""
@@ -83,24 +66,19 @@ def test_display_status(server: str = good_server_1, url: str = good_platform2_u
             table.add_row(server,
                           "[red]Inactive" if status == "Inactive" else "[green]Active",
                           )
-        # p_client.close_session()
         return table
 
     try:
-        # panel_group = Group(
-        #     rich.align.Align(Panel(, generate_table(p_client2)), box.ROUNDED))
-        #
-        # )
         layout.split_row(
             Layout(Panel(generate_table(p_client1), box.ROUNDED)),
-            Layout(Panel(generate_table(p_client2), box.ROUNDED))
+            Layout(Panel(generate_table(p_client2), box.ROUNDED)),
+            Layout(Panel(generate_table(p_client3), box.ROUNDED))
         )
         with Live(layout, refresh_per_second=4, screen=True) as live:
             while True:
                 time.sleep(2)
                 live.update(layout)
 
-
     except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
         print_exception_response(e)
         assert e.related_http_code != "200", "Invalid parameters"

pyegeria-0.3.8.data/scripts/collection_viewer.py → pyegeria-0.4.0.data/scripts/view_collection.py

@@ -7,43 +7,25 @@ A simple viewer for collections - provide the root and we display the hierarchy
 
 """
 
-import time
 import argparse
 
-from rich.box import Box
-from rich.markdown import Markdown
+from rich import print
+from rich.panel import Panel
 from rich.prompt import Prompt
-
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-    print_exception_response,
-)
-from rich.table import Table
-from rich.live import Live
 from rich.text import Text
 from rich.tree import Tree
-from rich.markdown import Markdown
 
-from rich import print
-from rich.console import Group
-from rich.panel import Panel
-from rich import box, align
-from rich.layout import Layout
-import rich
 from pyegeria import CollectionManager, UserNotAuthorizedException, PropertyServerException, InvalidParameterException
+from pyegeria._exceptions import (
+    print_exception_response,
+)
 
 disable_ssl_warnings = True
 
-platform = "https://127.0.0.1:9443"
-user = "erinoverview"
-view_server = "view-server"
 
-
-def collection_viewer(root: str, server_name:str, platform_url:str, user:str):
-
-    def walk_collection_hierarchy(collection_client: CollectionManager, root_collection_name: str, tree: Tree) -> Tree:
+def collection_viewer(root: str, server_name: str, platform_url: str, user: str):
+    """ A simple collection viewer"""
+    def walk_collection_hierarchy(collection_client: CollectionManager, root_collection_name: str, tree: Tree) -> None:
         """Recursively build a Tree with collection contents."""
         members = collection_client.get_member_list(root_collection_name)
         if members:
@@ -56,7 +38,7 @@ def collection_viewer(root: str, server_name:str, platform_url:str, user:str):
                 text_collection_type = Text(f"* Collection Type: {member['collectionType']}", "cyan")
                 text_description = Text(f"* Description: {member['description']}", "cyan")
                 p = Panel.fit(f"[white]{text_collection_name}[green]\n{text_qualified_name}\n{text_guid}\n"
-                          f"{text_collection_type}\n{text_description}")
+                              f"{text_collection_type}\n{text_description}")
                 tt = tree.add(p, style=style)
 
                 children = collection_client.get_collection_members(member['guid'])
@@ -64,14 +46,13 @@ def collection_viewer(root: str, server_name:str, platform_url:str, user:str):
                     branch = tt.add(f"[bold magenta]Members", style=style, guide_style=style)
                     walk_collection_hierarchy(collection_client, member['qualifiedName'], branch),
 
-
     try:
         tree = Tree(f"[bold bright green]{root}", guide_style="bold bright_blue")
-        c_client = CollectionManager(view_server, platform,
+        c_client = CollectionManager(server_name, platform_url,
                                      user_id=user)
 
         token = c_client.create_egeria_bearer_token(user, "secret")
-        walk_collection_hierarchy(c_client,root,tree)
+        walk_collection_hierarchy(c_client, root, tree)
         print(tree)
 
     except (
@@ -95,4 +76,4 @@ if __name__ == "__main__":
     userid = args.userid if args.userid is not None else 'erinoverview'
 
     root_collection = Prompt.ask("Enter the Root Collection to start from:", default="Digital Products Root")
-    collection_viewer(root_collection,server, url, userid)
+    collection_viewer(root_collection, server, url, userid)

pyegeria-0.3.8.data/scripts/engine_action_status.py → pyegeria-0.4.0.data/scripts/view_eng_action_status.py

@@ -11,52 +11,32 @@ A simple status display for Engine Actions
 
 import argparse
 import json
-import time
 import sys
+import time
 
 from rich import box
-from rich.live import Live
-from rich.table import Table
 from rich.console import Console
+from rich.table import Table
+from rich.live import Live
 
+from pyegeria import AutomatedCuration
 from pyegeria import (
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
     print_exception_response,
 )
-from pyegeria import GovEng, AutomatedCuration
 
 disable_ssl_warnings = True
 
-good_platform1_url = "https://127.0.0.1:9443"
-good_platform2_url = "https://egeria.pdr-associates.com:7443"
-bad_platform1_url = "https://localhost:9443"
 
-# good_platform1_url = "https://127.0.0.1:30080"
-# good_platform2_url = "https://127.0.0.1:30081"
-# bad_platform1_url = "https://localhost:9443"
-
-good_user_1 = "garygeeke"
-good_user_2 = "erinoverview"
-bad_user_1 = "eviledna"
-bad_user_2 = ""
-
-good_server_1 = "active-metadata-store"
-good_server_2 = "simple-metadata-store"
-good_server_3 = "view-server"
-good_server_4 = "engine-host"
-bad_server_1 = "coco"
-bad_server_2 = ""
-
-
-def display_status_engine_actions(server: str = good_server_3, url: str = good_platform1_url, user: str = good_user_1):
+def display_status_engine_actions(server: str, url: str, user: str):
     g_client = AutomatedCuration(server, url, user, user_pwd="secret")
 
     def generate_table() -> Table:
         """Make a new table."""
         table = Table(
-            title=f"Engine Action Status for Platform {good_platform1_url} @ {time.asctime()}",
+            title=f"Engine Action Status for Platform {url} @ {time.asctime()}",
             # style = "black on grey66",
             header_style="white on dark_blue",
             show_lines=True,
@@ -103,7 +83,7 @@ def display_status_engine_actions(server: str = good_server_3, url: str = good_p
                 else:
                     action_status = f"[red]{action['actionStatus']}"
 
-                target= action.get("actionTargetElements","Empty")
+                target= action.get("actionTargetElements", "Empty")
                 if type(target) is list:
                     target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
                 else:
@@ -119,17 +99,23 @@ def display_status_engine_actions(server: str = good_server_3, url: str = good_p
         else:
             print("Egeria integration daemon not running")
             sys.exit()
-        # g_client.close_session()
+
         return table
 
     try:
-        console = Console()
-        with console.pager():
-            console.print(generate_table())
+        # console = Console()
+        # with console.pager():
+        #     console.print(generate_table())
+        with Live(generate_table(), refresh_per_second=1, screen=True, vertical_overflow="visible") as live:
+            while True:
+                time.sleep(2)
+                live.update(generate_table())
 
     except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
         print_exception_response(e)
         assert e.related_http_code != "200", "Invalid parameters"
+    finally:
+        g_client.close_session()
 
 
 if __name__ == "__main__":

pyegeria-0.3.8.data/scripts/glossary_view.py → pyegeria-0.4.0.data/scripts/view_glossary.py

@@ -28,8 +28,8 @@ from rich.console import Console
 
 
 from pyegeria.server_operations import ServerOps
-from pyegeria.gov_engine import GovEng
-from pyegeria.glossary_omvs import GlossaryBrowser
+from pyegeria._deprecated_gov_engine import GovEng
+from pyegeria.glossary_browser_omvs import GlossaryBrowser
 disable_ssl_warnings = True
 
 good_platform1_url = "https://127.0.0.1:9443"

pyegeria-0.3.8.data/scripts/gov_engine_status.py → pyegeria-0.4.0.data/scripts/view_gov_eng_status.py

@@ -25,7 +25,6 @@ from rich import box
 from rich import console
 
 from pyegeria.server_operations import ServerOps
-from pyegeria.gov_engine import GovEng
 
 disable_ssl_warnings = True
 

pyegeria-0.3.8.data/scripts/integration_daemon_status.py → pyegeria-0.4.0.data/scripts/view_integ_daemon_status.py

@@ -3,51 +3,38 @@
 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 the Integration Daemon.
+
+Note that there are a couple of assumptions currently being made that need to get resolved in future
+versions. First, we assume that the view-server used by AutomatedCuration is called "view-server". Second, we
+assume that the user password is always "secret".
 
-A simple status display for Engine Actions
 """
 
 import argparse
-import json
 import time
 
 from rich import box
 from rich.live import Live
+from rich.markdown import Markdown
 from rich.table import Table
-from rich import console
 
+from pyegeria import ServerOps, AutomatedCuration
 from pyegeria._exceptions import (
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
     print_exception_response,
 )
-from pyegeria.server_operations import ServerOps
 
 disable_ssl_warnings = True
 
-good_platform1_url = "https://127.0.0.1:9443"
-good_platform2_url = "https://egeria.pdr-associates.com:7443"
-bad_platform1_url = "https://localhost:9443"
-
-good_user_1 = "garygeeke"
-good_user_2 = "erinoverview"
-bad_user_1 = "eviledna"
-bad_user_2 = ""
-
-good_server_1 = "active-metadata-store"
-good_server_2 = "simple-metadata-store"
-good_server_3 = "view-server"
-good_server_4 = "engine-host"
-bad_server_1 = "coco"
-bad_server_2 = ""
 
-
-def display_integration_daemon_status(server: str = good_server_4, url: str = good_platform1_url,
-                                      user: str = good_user_1):
+def display_integration_daemon_status(server: str, url: str, user: str):
     s_client = ServerOps(server, url, user)
+    a_client = AutomatedCuration("view-server", url, user, "secret")
+    token = a_client.create_egeria_bearer_token()
 
     def generate_table() -> Table:
         """Make a new table."""
@@ -71,34 +58,35 @@ def display_integration_daemon_status(server: str = good_server_4, url: str = go
         daemon_status = s_client.get_integration_daemon_status()
         connector_reports = daemon_status["integrationConnectorReports"]
         for connector in connector_reports:
-            connector_name = connector["connectorName"]
-            connector_status = connector["connectorStatus"]
-            last_refresh_time = connector.get("lastRefreshTime","---")
-            refresh_interval = str(connector.get("minMinutesBetweenRefresh","---"))
-            target_element = " "
+            connector_name = connector.get("connectorName", "---")
+            connector_status = connector.get("connectorStatus", "---")
+            connector_guid = connector["connectorGUID"]
+            last_refresh_time = connector.get("lastRefreshTime", "---")
+            refresh_interval = str(connector.get("minMinutesBetweenRefresh", "---"))
             exception_msg = " "
 
-            if connector_name is None:
-                connector_name = "connector name"
-            if connector_status is None:
-                connector_status = "connector status"
+            targets = a_client.get_catalog_targets(connector_guid)
+            if type(targets) == list:
+                targets_m = "\n"
+                for target in targets:
+                    t_name = target["catalogTargetName"]
+                    t_sync = target["permittedSynchronization"]
+                    t_unique_name = target["catalogTargetElement"]["uniqueName"]
+                    targets_m += f"* Target Name: __{t_name}__\n* Sync: {t_sync}\n* Unique Name: {t_unique_name}\n\n"
+                targets_md = Markdown(targets_m)
+            else:
+                targets_md = " "
 
             if connector_status in ("RUNNING", "REFRESHING", "WAITING"):
                 connector_status = f"[green]{connector_status}"
-            elif connector_status in ("INITIALIZE FAILED","CONFIG_FAILED","FAILED"):
+            elif connector_status in ("INITIALIZE FAILED", "CONFIG_FAILED", "FAILED"):
                 connector_status = f"[red]{connector_status}"
             else:
                 connector_status = f"[yellow]{connector_status}"
 
-            # target= action.get("actionTargetElements","Empty")
-            # if type(target) is list:
-            #     target_element = json.dumps(target[0]["targetElement"]["elementProperties"]["propertiesAsStrings"])
-            # else:
-            #     target_element = " "
-
             table.add_row(
-                connector_name,connector_status,last_refresh_time,refresh_interval,
-                target_element, exception_msg
+                connector_name, connector_status, last_refresh_time, refresh_interval,
+                targets_md, exception_msg
             )
         return table
 
@@ -119,7 +107,7 @@ def display_integration_daemon_status(server: str = good_server_4, url: str = go
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--server", help="Name of the integration server to display status for")
     parser.add_argument("--url", help="URL Platform to connect to")
     parser.add_argument("--userid", help="User Id")
     args = parser.parse_args()

pyegeria-0.3.8.data/scripts/my_todos.py → pyegeria-0.4.0.data/scripts/view_my_todos.py

@@ -24,7 +24,7 @@ from pyegeria import (
     UserNotAuthorizedException,
     print_exception_response,
 )
-from pyegeria.gov_engine import GovEng
+from pyegeria._deprecated_gov_engine import GovEng
 from pyegeria.my_profile_omvs import MyProfile
 disable_ssl_warnings = True