pyegeria 0.5.5.13__tar.gz → 0.5.5.14__tar.gz

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/PKG-INFO

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

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/examples/widgets/developer/get_tech_details.py

@@ -14,13 +14,14 @@ from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.text import Text
 from rich.tree import Tree
-
+from rich.console import Console
 from pyegeria import (UserNotAuthorizedException, PropertyServerException,
                       InvalidParameterException, AutomatedCuration)
 from pyegeria._exceptions import (
     print_exception_response,
 )
 
+console = Console()
 disable_ssl_warnings = True
 
 platform = "https://127.0.0.1:9443"
@@ -33,26 +34,33 @@ def tech_viewer(tech: str, server_name:str, platform_url:str, user:str):
     def view_tech_details(a_client: AutomatedCuration, root_collection_name: str, tree: Tree) -> Tree:
         l2: Tree = None
         tech_details = a_client.get_technology_type_detail(tech)
-        if type(tech_details) is dict:
+        if (type(tech_details) is dict) and (len(tech_details)>0):
+            name = tech_details.get('name','---')
+            qualified_name = tech_details.get('qualifiedName',"---")
+            category = tech_details.get('category','---')
+            description = tech_details.get('description','---')
+
             style = ""
-            l2 = tree.add(Text(f"Name: {tech_details.get('name',' ')}", "bold red"))
-            l2 = tree.add(Text(f"* QualifiedName: {tech_details['qualifiedName']}","bold white"))
-            l2 = tree.add(Text(f"* Category: {tech_details['category']}", "bold white"))
-            l2 = tree.add(Text(f"* Technology Description: {tech_details['description']}", "bold white"))
+            l2 = tree.add(Text(f"Name: {name}", "bold red"))
+            l2 = tree.add(Text(f"* QualifiedName: {qualified_name}","bold white"))
+            l2 = tree.add(Text(f"* Category: {category}", "bold white"))
+            l2 = tree.add(Text(f"* Technology Description: {description}", "bold white"))
             ext_ref = tech_details.get('externalReferences', None)
-            if ext_ref is not None:
-                l2 = tree.add(Text(f'* URI: {ext_ref[0]["properties"]["uri"]}', "bold white"))
 
+            if ext_ref is not None:
+                uri = ext_ref[0]["properties"].get("uri", "---")
+                # console.print(f" {type(ext_ref)}, {len(ext_ref)}")
+                l2 = tree.add(Text(f'* URI: {uri}', "bold white"))
 
             resource_list = tech_details.get('resourceList',None)
             if resource_list:
                 t_r = tree.add("Resource List[bold red]")
                 for resource in resource_list:
-                    resource_use = Text(f"[bold white]{resource['resourceUse']}", "")
-                    resource_use_description = Text(f"[bold white]{resource['resourceUseDescription']}", "")
-                    type_name = Text(f"[bold white]{resource['relatedElement']['type']['typeName']}", "")
-                    unique_name = Text(f"[bold white]{resource['relatedElement']['uniqueName']}", "")
-                    related_guid = Text(f"[bold white]{resource['relatedElement']['guid']}", "")
+                    resource_use = Text(f"[bold white]{resource.get('resourceUse','---')}", "")
+                    resource_use_description = Text(f"[bold white]{resource.get('resourceUseDescription','---')}", "")
+                    type_name = Text(f"[bold white]{resource['relatedElement']['type'].get('typeName','---')}", "")
+                    unique_name = Text(f"[bold white]{resource['relatedElement'].get('uniqueName','---')}", "")
+                    related_guid = Text(f"[bold white]{resource['relatedElement'].get('guid','---')}", "")
                     resource_text = (f"[bold red]Resource\n"
                                      f"[white]Resource use: {resource_use}[white]\nDescription: "
                                      f"{resource_use_description}\nType Name: {type_name}\n"
@@ -60,9 +68,10 @@ def tech_viewer(tech: str, server_name:str, platform_url:str, user:str):
                     p = Panel.fit(resource_text)
                     tt = t_r.add(p, style=style)
 
+        else:
+            tt = tree.add(f"Tech type {tech} was not found - please check the tech type name")
 
-            return tt
-
+        return tt
 
     try:
         tree = Tree(f"[bold bright green]{tech}", guide_style="bold bright_blue")

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/examples/widgets/operational/get_tech_type_template.py

@@ -62,51 +62,50 @@ def tech_viewer(tech_name: str, server_name:str, platform_url:str, user:str):
 
         token = a_client.create_egeria_bearer_token(user, "secret")
         tech_elements = a_client.get_technology_type_elements(tech_name, get_templates=True)
-        if len(tech_elements) <= 1:
-            console.print(f"No elements found for {tech_name}")
-            sys.exit(1)
-        tree = Tree(f"Deployed Technology Type: {tech_name}", style="bold bright_white", 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"* Createdy 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)
+        if (len(tech_elements) >= 1) and (type(tech_elements) is list):
+            tree = Tree(f"Deployed Technology Type: {tech_name}", style="bold bright_white", 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"* Createdy 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)
 
+        else:
+            tree = Tree(f"No elements found for {tech_name}", style="red")
         print(tree)
-
     except (
         InvalidParameterException,
         PropertyServerException,

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/examples/widgets/operational/view_integ_daemon_status.py

@@ -123,8 +123,8 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--integ_server", help="Name of the integration server to display status for")
     parser.add_argument("--integ_url", help="URL Platform to connect to")
-    parser.add_argument("--view_server", help="Name of the integration server to display status for")
-    parser.add_argument("--view_url", help="URL Platform to connect to")
+    parser.add_argument("--view_server", help="Name of the view server to use")
+    parser.add_argument("--view_url", help="view server URL Platform to connect to")
     parser.add_argument("--userid", help="User Id")
     args = parser.parse_args()
 

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/pyegeria/__init__.py

@@ -11,7 +11,7 @@ the server platform and servers.
 
 """
 
-from ._globals import (is_debug, disable_ssl_warnings, max_paging_size,
+from ._globals import (is_debug, disable_ssl_warnings, max_paging_size, template_guids, integration_guids
                        )
 from .core_guids import *
 
@@ -48,4 +48,6 @@ from .runtime_manager_omvs import RuntimeManager
 from .action_author_omvs import GovernanceAuthor
 from .glossary_manager_omvs import GlossaryManager
 
-__version__ = "0.5.2"
+
+
+

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/pyegeria/_client.py

@@ -10,7 +10,6 @@ import asyncio
 import inspect
 import json
 import os
-
 import httpx
 from httpx import AsyncClient, Response
 
@@ -18,8 +17,8 @@ from pyegeria._exceptions import (
     OMAGCommonErrorCode,
     InvalidParameterException,
     PropertyServerException,
-    UserNotAuthorizedException, )
-from pyegeria._globals import max_paging_size
+    UserNotAuthorizedException )
+from pyegeria._globals import max_paging_size, template_guids, integration_guids
 from pyegeria._validators import (
     validate_name,
     validate_server_name,
@@ -138,6 +137,10 @@ class Client:
             # else:
             #     self.session = httpx.AsyncClient(verify=self.ssl_verify)
             self.session = AsyncClient(verify=self.ssl_verify)
+        # if (len(template_guids) == 0) or (len(integration_guids) == 0):
+        #     self.build_global_guid_lists()
+        #     self.template_guids = template_guids
+        #     self.integration_guids = integration_guids
 
     def __enter__(self):
         return self
@@ -202,7 +205,7 @@ class Client:
             "userId": user_id,
             "password": password
         }
-        async with httpx.AsyncClient(verify=self.ssl_verify) as client:
+        async with AsyncClient(verify=self.ssl_verify) as client:
             try:
                 response = await client.post(url, json=data, headers=self.headers)
                 token = response.text
@@ -565,6 +568,53 @@ class Client:
             )
             raise InvalidParameterException(exc_msg)
 
+    def build_global_guid_lists(self) -> None:
+        global template_guids, integration_guids
+
+        self.create_egeria_bearer_token(self.user_id, self.user_pwd)
+        # get all technology types
+        url = (f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/automated-curation/technology-types/"
+               f"by-search-string?startFrom=0&pageSize=0&startsWith=false&"
+               f"endsWith=false&ignoreCase=true")
+        body = {"filter": ""}
+
+        response = self.make_request("POST", url, body)
+        tech_types = response.json().get("elements", "no tech found")
+        if type(tech_types) is list:
+            for tech_type in tech_types:
+                # get tech type details
+                display_name = tech_type["name"]
+
+                url = f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/automated-curation/technology-types/by-name"
+                body = {"filter": display_name}
+                response = self.make_request("POST", url, body)
+                details = response.json().get("element","no type found")
+                if type(details) is str:
+                    continue
+                # get templates and update the template_guids global
+                templates = details.get("catalogTemplates", "Not Found")
+                if type(templates) is str:
+                    template_guids[display_name]= None
+                else:
+                    for template in templates:
+                        template_name = template.get("name", None)
+                        template_guid = template["relatedElement"]["guid"]
+                        template_guids[template_name] = template_guid
+                        # print(f"Added {template_name} template with GUID {template_guids[template_name]}")
+
+                # Now find the integration connector guids
+                resource_list = details.get('resourceList', ' ')
+                if type(resource_list) is str:
+                    integration_guids[display_name] = None
+                else:
+                    for resource in resource_list:
+                        resource_guid = resource['relatedElement']['guid']
+                        resource_type = resource['relatedElement']['type']['typeName']
+                        if resource_type == "IntegrationConnector":
+                            integration_guids[display_name] = resource_guid
+                            # print(f"Added {display_name} integration connector with GUID {integration_guids[display_name]}")
+
+
 
 if __name__ == "__main__":
     try:

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/pyegeria/_globals.py

@@ -31,3 +31,5 @@ star_ratings = (
     "TWO_STARS",
 )
 
+template_guids: dict = {}
+integration_guids: dict = {}

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/pyegeria/utils.py

@@ -70,6 +70,8 @@ from rich import print, print_json
 #     df = pd.json_normalize(data)
 #     print(tabulate(wrap_text(df, wrap_len), headers="keys", tablefmt=tablefmt))
 
+template_guids: dict = None
+integration_guids: dict = None
 
 def print_rest_request_body(body):
     """
@@ -189,3 +191,4 @@ def body_slimmer(body: dict) -> dict:
     """
     slimmed = {key: value for key, value in body.items() if value}
     return slimmed
+

{pyegeria-0.5.5.13 → pyegeria-0.5.5.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyegeria"
-version = "0.5.5.13"
+version = "0.5.5.14"
 license = 'Apache 2.0'
 authors = ["Dan Wolfson <dan.wolfson@pdr-associates.com>"]
 readme = "README.md"