pyegeria 0.7.45.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyegeria/_client.py

@@ -17,14 +17,15 @@ from pyegeria._exceptions import (
     OMAGCommonErrorCode,
     InvalidParameterException,
     PropertyServerException,
-    UserNotAuthorizedException )
+    UserNotAuthorizedException,
+)
 from pyegeria._globals import max_paging_size, TEMPLATE_GUIDS, INTEGRATION_GUIDS
 from pyegeria._validators import (
     validate_name,
     validate_server_name,
     validate_url,
     validate_user_id,
-    is_json
+    is_json,
 )
 
 ...
@@ -73,27 +74,23 @@ class Client:
     json_header = {"Content-Type": "application/json"}
 
     def __init__(
-            self,
-            server_name: str,
-            platform_url: str,
-            user_id: str = None,
-            user_pwd: str = None,
-            verify_flag: bool = False,
-            api_key: str = None,
-            page_size: int = max_paging_size,
-            token: str = None,
-            token_src: str = None,
-            async_mode: bool = False
+        self,
+        server_name: str,
+        platform_url: str,
+        user_id: str = None,
+        user_pwd: str = None,
+        api_key: str = None,
+        page_size: int = max_paging_size,
+        token: str = None,
+        token_src: str = None,
     ):
         self.server_name = None
         self.platform_url = None
         self.user_id = user_id
         self.user_pwd = user_pwd
-        self.ssl_verify = verify_flag
         self.page_size = page_size
         self.token_src = token_src
         self.token = token
-        self.sync_mode = async_mode
         self.exc_type = None
         self.exc_value = None
         self.exc_tb = None
@@ -164,35 +161,37 @@ class Client:
         loop.run_until_complete(self._async_close_session())
         return
 
-    async def _async_create_egeria_bearer_token(self, user_id: str = None, password: str = None) -> str:
-        """ Create and set an Egeria Bearer Token for the user. Async version
-            Parameters
-            ----------
-            user_id : str, opt
-                The user id to authenticate with. If None, then user_id from class instance used.
-            password : str, opt
-                The password for the user. If None, then user_pwd from class instance is used.
-
-            Returns
-            -------
-            token
-                The bearer token for the specified user.
-
-            Raises
-            ------
-            InvalidParameterException
-              If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
-              Raised by the server when an issue arises in processing a valid request
-            NotAuthorizedException
-              The principle specified by the user_id does not have authorization for the requested action
-            Notes
-            -----
-            This routine creates a new bearer token for the user and updates the object with it.
-            It uses Egeria's mechanisms to create a token. This is useful if an Egeria token expires.
-            A bearer token from another source can be set with the set_bearer_token() method.
-
-            """
+    async def _async_create_egeria_bearer_token(
+        self, user_id: str = None, password: str = None
+    ) -> str:
+        """Create and set an Egeria Bearer Token for the user. Async version
+        Parameters
+        ----------
+        user_id : str, opt
+            The user id to authenticate with. If None, then user_id from class instance used.
+        password : str, opt
+            The password for the user. If None, then user_pwd from class instance is used.
+
+        Returns
+        -------
+        token
+            The bearer token for the specified user.
+
+        Raises
+        ------
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+        Notes
+        -----
+        This routine creates a new bearer token for the user and updates the object with it.
+        It uses Egeria's mechanisms to create a token. This is useful if an Egeria token expires.
+        A bearer token from another source can be set with the set_bearer_token() method.
+
+        """
         if user_id is None:
             validate_user_id(self.user_id)
             user_id = self.user_id
@@ -201,10 +200,7 @@ class Client:
             password = self.user_pwd
 
         url = f"{self.platform_url}/api/token"
-        data = {
-            "userId": user_id,
-            "password": password
-        }
+        data = {"userId": user_id, "password": password}
         async with AsyncClient(verify=self.ssl_verify) as client:
             try:
                 response = await client.post(url, json=data, headers=self.headers)
@@ -214,15 +210,17 @@ class Client:
                 return "FAILED"
 
         if token:
-            self.token_src = 'Egeria'
+            self.token_src = "Egeria"
             self.headers["Authorization"] = f"Bearer {token}"
             self.text_headers["Authorization"] = f"Bearer {token}"
             return token
         else:
             raise InvalidParameterException("No token returned - request issue")
 
-    def create_egeria_bearer_token(self, user_id: str = None, password: str = None) -> str:
-        """ Create and set an Egeria Bearer Token for the user
+    def create_egeria_bearer_token(
+        self, user_id: str = None, password: str = None
+    ) -> str:
+        """Create and set an Egeria Bearer Token for the user
         Parameters
         ----------
         user_id : str
@@ -251,7 +249,9 @@ class Client:
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_create_egeria_bearer_token(user_id, password))
+        response = loop.run_until_complete(
+            self._async_create_egeria_bearer_token(user_id, password)
+        )
         return response
 
     async def _async_refresh_egeria_bearer_token(self) -> None:
@@ -271,7 +271,11 @@ class Client:
         Raises:
             InvalidParameterException: If the token source is invalid.
         """
-        if (self.token_src == 'Egeria') and validate_user_id(self.user_id) and validate_name(self.user_pwd):
+        if (
+            (self.token_src == "Egeria")
+            and validate_user_id(self.user_id)
+            and validate_name(self.user_pwd)
+        ):
             await self._async_create_egeria_bearer_token(self.user_id, self.user_pwd)
         else:
             raise InvalidParameterException("Invalid token source")
@@ -302,7 +306,7 @@ class Client:
         return
 
     def set_bearer_token(self, token: str) -> None:
-        """ Retrieve and set a Bearer Token
+        """Retrieve and set a Bearer Token
         Parameters
         ----------
         token: str
@@ -331,20 +335,31 @@ class Client:
         self.text_headers["Authorization"] = f"Bearer {token}"
 
     def get_token(self) -> str:
-        """ Retrieve and return the bearer token   """
+        """Retrieve and return the bearer token"""
         return self.text_headers["Authorization"]
 
-    def make_request(self, request_type: str, endpoint: str, payload: str | dict = None,
-                     time_out: int = 30) -> Response | str:
-        """ Make a request to the Egeria API"""
+    def make_request(
+        self,
+        request_type: str,
+        endpoint: str,
+        payload: str | dict = None,
+        time_out: int = 30,
+    ) -> Response | str:
+        """Make a request to the Egeria API"""
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_make_request(request_type, endpoint,
-                                                                    payload, time_out))
+        response = loop.run_until_complete(
+            self._async_make_request(request_type, endpoint, payload, time_out)
+        )
         return response
 
-    async def _async_make_request(self, request_type: str, endpoint: str, payload: str | dict = None,
-                                  time_out: int = 30) -> Response | str:
-        """  Make a request to the Egeria API - Async Version
+    async def _async_make_request(
+        self,
+        request_type: str,
+        endpoint: str,
+        payload: str | dict = None,
+        time_out: int = 30,
+    ) -> Response | str:
+        """Make a request to the Egeria API - Async Version
         Function to make an API call via the self.session Library. Raise an exception if the HTTP response code
         is not 200/201. IF there is a REST communication exception, raise InvalidParameterException.
 
@@ -364,25 +379,37 @@ class Client:
         try:
             response = ""
             if request_type == "GET":
-                response = await self.session.get(endpoint, params=payload, headers=self.headers, timeout=time_out)
+                response = await self.session.get(
+                    endpoint, params=payload, headers=self.headers, timeout=time_out
+                )
 
             elif request_type == "POST":
                 if payload is None:
-                    response = await self.session.post(endpoint, headers=self.headers, timeout=time_out)
+                    response = await self.session.post(
+                        endpoint, headers=self.headers, timeout=time_out
+                    )
                 elif type(payload) is str:
-                    response = await self.session.post(endpoint, headers=self.text_headers, data=payload,
-                                                       timeout=time_out)
+                    response = await self.session.post(
+                        endpoint,
+                        headers=self.text_headers,
+                        data=payload,
+                        timeout=time_out,
+                    )
                 else:
-                    response = await self.session.post(endpoint, headers=self.headers,
-                                                       json=payload, timeout=time_out)
+                    response = await self.session.post(
+                        endpoint, headers=self.headers, json=payload, timeout=time_out
+                    )
 
             elif request_type == "POST-DATA":
                 if True:
-                    response = await self.session.post(endpoint, headers=self.headers,
-                                                       data=payload, timeout=time_out)
+                    response = await self.session.post(
+                        endpoint, headers=self.headers, data=payload, timeout=time_out
+                    )
             elif request_type == "DELETE":
                 if True:
-                    response = await self.session.delete(endpoint, headers=self.headers, timeout=time_out)
+                    response = await self.session.delete(
+                        endpoint, headers=self.headers, timeout=time_out
+                    )
 
             status_code = response.status_code
 
@@ -484,14 +511,21 @@ class Client:
 
             elif response.status_code in (500, 501, 502, 503, 504):
                 # server errors
-                msg = OMAGCommonErrorCode.EXCEPTION_RESPONSE_FROM_API.value[
-                          "message_template"
-                      ].format(
-                    str(response.status_code),
-                    caller_method,
-                    endpoint,
-                    OMAGCommonErrorCode.EXCEPTION_RESPONSE_FROM_API.value["message_id"],
-                ) + "==>System reports:'" + response.reason_phrase + "'"
+                msg = (
+                    OMAGCommonErrorCode.EXCEPTION_RESPONSE_FROM_API.value[
+                        "message_template"
+                    ].format(
+                        str(response.status_code),
+                        caller_method,
+                        endpoint,
+                        OMAGCommonErrorCode.EXCEPTION_RESPONSE_FROM_API.value[
+                            "message_id"
+                        ],
+                    )
+                    + "==>System reports:'"
+                    + response.reason_phrase
+                    + "'"
+                )
                 exc_msg = json.dumps(
                     {
                         "class": "VoidResponse",
@@ -527,25 +561,30 @@ class Client:
         except UserNotAuthorizedException:
             raise
         except (
-                httpx.NetworkError,
-                httpx.ProtocolError,
-                httpx.HTTPStatusError,
-                httpx.TimeoutException,
+            httpx.NetworkError,
+            httpx.ProtocolError,
+            httpx.HTTPStatusError,
+            httpx.TimeoutException,
         ) as e:
             if type(response) is str:
                 reason = response
             else:
                 reason = response.reason_phrase
 
-            msg = OMAGCommonErrorCode.CLIENT_SIDE_REST_API_ERROR.value[
-                      "message_template"
-                  ].format(
-                e.args[0],
-                caller_method,
-                class_name,
-                endpoint,
-                OMAGCommonErrorCode.CLIENT_SIDE_REST_API_ERROR.value["message_id"],
-            ) + "==>System reports:'" + reason + "'"
+            msg = (
+                OMAGCommonErrorCode.CLIENT_SIDE_REST_API_ERROR.value[
+                    "message_template"
+                ].format(
+                    e.args[0],
+                    caller_method,
+                    class_name,
+                    endpoint,
+                    OMAGCommonErrorCode.CLIENT_SIDE_REST_API_ERROR.value["message_id"],
+                )
+                + "==>System reports:'"
+                + reason
+                + "'"
+            )
             exc_msg = json.dumps(
                 {
                     "class": "VoidResponse",
@@ -573,9 +612,11 @@ class Client:
 
         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")
+        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)
@@ -588,13 +629,13 @@ class Client:
                 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")
+                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
+                    template_guids[display_name] = None
                 else:
                     for template in templates:
                         template_name = template.get("name", None)
@@ -603,19 +644,18 @@ class Client:
                         # print(f"Added {template_name} template with GUID {template_guids[template_name]}")
 
                 # Now find the integration connector guids
-                resource_list = details.get('resourceList', ' ')
+                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']
+                        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:
         connection = Client(