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

pyegeria/classification_manager_omvs.py

@@ -7,17 +7,16 @@ module.
 """
 
 import asyncio
-import json
 
 from httpx import Response
 
 from pyegeria import body_slimmer
+
 # import json
 from pyegeria._client import Client, max_paging_size
 from pyegeria._globals import enable_ssl_check, default_time_out
 
 
-
 def query_seperator(current_string):
     if current_string == "":
         return "?"
@@ -107,20 +106,42 @@ class ClassificationManager(Client):
 
     """
 
-    def __init__(self, server_name: str, platform_url: str, token: str = None, user_id: str = None,
-                 user_pwd: str = None, verify_flag: bool = enable_ssl_check, sync_mode: bool = True, ):
+    def __init__(
+        self,
+        server_name: str,
+        platform_url: str,
+        token: str = None,
+        user_id: str = None,
+        user_pwd: str = None,
+        verify_flag: bool = enable_ssl_check,
+        sync_mode: bool = True,
+    ):
         self.admin_command_root: str
-        Client.__init__(self, server_name, platform_url, user_id=user_id, user_pwd=user_pwd, token=token,
-                        async_mode=sync_mode, )
+        Client.__init__(
+            self,
+            server_name,
+            platform_url,
+            user_id=user_id,
+            user_pwd=user_pwd,
+            token=token,
+            async_mode=sync_mode,
+        )
 
     #
     #   Get elements
     #
 
-    async def _async_get_elements(self, open_metadata_type_name: str = None, effective_time: str = None,
-                                  for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-                                  page_size: int = max_paging_size, server_name: str = None,
-                                  time_out: int = default_time_out) -> list | str:
+    async def _async_get_elements(
+        self,
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements of the requested type name. If no type name is specified, then any type of element may
         be returned.
@@ -164,23 +185,41 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-                "effectiveTime": effective_time, }
+        body = {
+            "class": "FindProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "effectiveTime": effective_time,
+        }
 
         url = f"{base_path(self, server_name)}/elements/by-type{possible_query_params}"
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_elements(self, open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-                     for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-                     server_name: str = None, time_out: int = default_time_out) -> list | str:
+    def get_elements(
+        self,
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements of the requested type name. If no type name is specified, then any type of element may
         be returned.
@@ -223,16 +262,32 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_elements(open_metadata_type_name, effective_time, for_lineage, for_duplicate_processing,
-                                     start_from, page_size, server_name, time_out))
+            self._async_get_elements(
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_get_elements_by_property_value(self, property_value: str, property_names: [str],
-                                                    open_metadata_type_name: str = None, effective_time: str = None,
-                                                    for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                    start_from: int = 0, page_size: int = max_paging_size,
-                                                    server_name: str = None,
-                                                    time_out: int = default_time_out) -> list | str:
+    async def _async_get_elements_by_property_value(
+        self,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results. Async version.
@@ -280,27 +335,47 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
         url = f"{base_path(self, server_name)}/elements/by-exact-property-value{possible_query_params}"
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
 
-        elements = response.json().get('elements', 'No elements found')
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_elements_by_property_value(self, property_value: str, property_names: [str],
-                                       open_metadata_type_name: str = None, effective_time: str = None,
-                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                       start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-                                       time_out: int = default_time_out) -> list | str:
+    def get_elements_by_property_value(
+        self,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results.
@@ -347,17 +422,117 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_elements_by_property_value(property_value, property_names, open_metadata_type_name,
-                                                       effective_time, for_lineage, for_duplicate_processing,
-                                                       start_from, page_size, server_name, time_out))
+            self._async_get_elements_by_property_value(
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_find_elements_by_property_value(self, property_value: str, property_names: [str],
-                                                     open_metadata_type_name: str = None, effective_time: str = None,
-                                                     for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                     start_from: int = 0, page_size: int = max_paging_size,
-                                                     server_name: str = None,
-                                                     time_out: int = default_time_out) -> list | str:
+    async def _async_get_guid_for_name(
+        self, name: str, server_name: str = None, time_out: int = default_time_out
+    ) -> list | str:
+        """
+        Retrieve the guid associated with the supplied element name.
+        If more than one element returned, an exception is thrown. Async version.
+
+        Parameters
+        ----------
+        name: str
+            - element name to be searched.
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        str
+            Returns the guid of the element.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+        """
+        if server_name is None:
+            server_name = self.server_name
+        property_name = ["name", "qualifiedName", "title"]
+        elements = await self._async_get_elements_by_property_value(
+            name, property_name, None
+        )
+
+        if type(elements) is list:
+            if len(elements) == 0:
+                return "No elements found"
+            elif len(elements) > 1:
+                raise Exception("Multiple elements found for supplied name!")
+            elif len(elements) == 1:
+                return elements[0]["elementHeader"]["guid"]
+        return elements
+
+    def get_guid_for_name(
+        self, name: str, server_name: str = None, time_out: int = default_time_out
+    ) -> list | str:
+        """
+        Retrieve the guid associated with the supplied element name.
+        If more than one element returned, an exception is thrown.
+
+        Parameters
+        ----------
+        name: str
+            - element name to be searched.
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        str
+            Returns the guid of the element.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_guid_for_name(name, server_name, time_out)
+        )
+        return response
+
+    async def _async_find_elements_by_property_value(
+        self,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must be contained in the
         properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict
@@ -406,25 +581,45 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
         url = f"{base_path(self, server_name)}/elements/by-property-value-search{possible_query_params}"
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def find_elements_by_property_value(self, property_value: str, property_names: [str],
-                                        open_metadata_type_name: str = None, effective_time: str = None,
-                                        for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                        start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-                                        time_out: int = default_time_out) -> list | str:
+    def find_elements_by_property_value(
+        self,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must be contained in the
         properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict
@@ -472,19 +667,36 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_elements_by_property_value(property_value, property_names, open_metadata_type_name,
-                                                        effective_time, for_lineage, for_duplicate_processing,
-                                                        start_from, page_size, server_name, time_out))
+            self._async_find_elements_by_property_value(
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
     #
     # Elements by classification
     #
-    async def _async_get_elements_by_classification(self, classification_name: str, open_metadata_type_name: str = None,
-                                                    effective_time: str = None, for_lineage: bool = None,
-                                                    for_duplicate_processing: bool = None, start_from: int = 0,
-                                                    page_size: int = max_paging_size, server_name: str = None,
-                                                    time_out: int = default_time_out) -> list | str:
+    async def _async_get_elements_by_classification(
+        self,
+        classification_name: str,
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
          Retrieve elements with the requested classification name. It is also possible to limit the results
         by specifying a type name for the elements that should be returned. If no type name is specified then
@@ -531,26 +743,45 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-                "effectiveTime": effective_time, }
+        body = {
+            "class": "FindProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}"
-               f"{possible_query_params}")
-        response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        url = (
+            f"{base_path(self, server_name)}/elements/by-classification/{classification_name}"
+            f"{possible_query_params}"
+        )
+        response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_elements_by_classification(self, classification_name: str, open_metadata_type_name: str = None,
-                                       effective_time: str = None, for_lineage: bool = None,
-                                       for_duplicate_processing: bool = None, start_from: int = 0,
-                                       page_size: int = max_paging_size, server_name: str = None,
-                                       time_out: int = default_time_out) -> list | str:
+    def get_elements_by_classification(
+        self,
+        classification_name: str,
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements with the requested classification name. It is also possible to limit the results
         by specifying a type name for the elements that should be returned. If no type name is specified then
@@ -596,92 +827,127 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_elements_by_classification(classification_name, open_metadata_type_name, effective_time,
-                                                       for_lineage, for_duplicate_processing, start_from, page_size,
-                                                       server_name, time_out))
+            self._async_get_elements_by_classification(
+                classification_name,
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_get_elements_by_classification_with_property_value(self, classification_name: str,
-                                                                        property_value: str, property_names: [str],
-                                                                        open_metadata_type_name: str = None,
-                                                                        effective_time: str = None,
-                                                                        for_lineage: bool = None,
-                                                                        for_duplicate_processing: bool = None,
-                                                                        start_from: int = 0,
-                                                                        page_size: int = max_paging_size,
-                                                                        server_name: str = None,
-                                                                        time_out: int = default_time_out) -> list | str:
-        """
-       Retrieve elements with the requested classification name and with the requested a value found in one of the
-       classification's properties specified.  The value must match exactly. An open metadata type name may be supplied
-       to restrict the types of elements returned. Async version.
+    async def _async_get_elements_by_classification_with_property_value(
+        self,
+        classification_name: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve elements with the requested classification name and with the requested a value found in one of the
+        classification's properties specified.  The value must match exactly. An open metadata type name may be supplied
+        to restrict the types of elements returned. Async version.
 
-        https://egeria-project.org/types/
+         https://egeria-project.org/types/
 
-        Parameters
-        ----------
-        classification_name: str
-            - the classification name to retrieve elements for.
-        property_value: str
-            - property value to be searched.
-        property_names: [str]
-            - property names to search in.
-        open_metadata_type_name : str, default = None
-            - open metadata type to be used to restrict the search
-        effective_time: str, default = None
-            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
-        start_from: int, default = 0
-            - index of the list to start from (0 for start).
-        page_size
-            - maximum number of elements to return.
-        server_name: str, default = None
-            - name of the server instances for this request.
-        time_out: int, default = default_time_out
-            - http request timeout for this request
+         Parameters
+         ----------
+         classification_name: str
+             - the classification name to retrieve elements for.
+         property_value: str
+             - property value to be searched.
+         property_names: [str]
+             - property names to search in.
+         open_metadata_type_name : str, default = None
+             - open metadata type to be used to restrict the search
+         effective_time: str, default = None
+             - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         start_from: int, default = 0
+             - index of the list to start from (0 for start).
+         page_size
+             - maximum number of elements to return.
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
 
-        Returns
-        -------
-        [dict] | str
-            Returns a string if no elements found and a list of dict of elements with the results.
+         Returns
+         -------
+         [dict] | str
+             Returns a string if no elements found and a list of dict of elements with the results.
 
-        Raises
-        ------
-        InvalidParameterException
-            one of the parameters is null or invalid or
-        PropertyServerException
-            There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
-            the requesting user is not authorized to issue this request.
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
         """
         if server_name is None:
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
-               f"with-exact-property-value{possible_query_params}")
-        response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        url = (
+            f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
+            f"with-exact-property-value{possible_query_params}"
+        )
+        response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_elements_by_classification_with_property_value(self, classification_name: str, property_value: str,
-                                                           property_names: [str], open_metadata_type_name: str = None,
-                                                           effective_time: str = None, for_lineage: bool = None,
-                                                           for_duplicate_processing: bool = None, start_from: int = 0,
-                                                           page_size: int = max_paging_size, server_name: str = None,
-                                                           time_out: int = default_time_out) -> list | str:
+    def get_elements_by_classification_with_property_value(
+        self,
+        classification_name: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results.
@@ -730,23 +996,36 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_elements_by_classification_with_property_value(classification_name, property_value,
-                                                                           property_names, open_metadata_type_name,
-                                                                           effective_time, for_lineage,
-                                                                           for_duplicate_processing, start_from,
-                                                                           page_size, server_name, time_out))
+            self._async_get_elements_by_classification_with_property_value(
+                classification_name,
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_find_elements_by_classification_with_property_value(self, classification_name: str,
-                                                                         property_value: str, property_names: [str],
-                                                                         open_metadata_type_name: str = None,
-                                                                         effective_time: str = None,
-                                                                         for_lineage: bool = None,
-                                                                         for_duplicate_processing: bool = None,
-                                                                         start_from: int = 0,
-                                                                         page_size: int = max_paging_size,
-                                                                         server_name: str = None,
-                                                                         time_out: int = default_time_out) -> list | str:
+    async def _async_find_elements_by_classification_with_property_value(
+        self,
+        classification_name: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements with the requested classification name and with the requested value found in
         one of the classification's properties specified.  The value must only be contained in the
@@ -798,27 +1077,49 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
-               f"with-property-value-search{possible_query_params}")
-        response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        url = (
+            f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
+            f"with-property-value-search{possible_query_params}"
+        )
+        response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def find_elements_by_classification_with_property_value(self, classification_name: str, property_value: str,
-                                                            property_names: [str], open_metadata_type_name: str = None,
-                                                            effective_time: str = None, for_lineage: bool = None,
-                                                            for_duplicate_processing: bool = None, start_from: int = 0,
-                                                            page_size: int = max_paging_size, server_name: str = None,
-                                                            time_out: int = default_time_out) -> list | str:
+    def find_elements_by_classification_with_property_value(
+        self,
+        classification_name: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements with the requested classification name and with the requested a value found in
         one of the classification's properties specified.  The value must only be contained in the
@@ -869,21 +1170,38 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_elements_by_classification_with_property_value(classification_name, property_value,
-                                                                            property_names, open_metadata_type_name,
-                                                                            effective_time, for_lineage,
-                                                                            for_duplicate_processing, start_from,
-                                                                            page_size, server_name, time_out))
+            self._async_find_elements_by_classification_with_property_value(
+                classification_name,
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
     #
     #   related elements
     #
-    async def _async_get_all_related_elements(self, element_guid: str, open_metadata_type_name: str = None,
-                                              start_at_end: int = 1, effective_time: str = None,
-                                              for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                              start_from: int = 0, page_size: int = max_paging_size,
-                                              server_name: str = None, time_out: int = default_time_out) -> list | str:
+    async def _async_get_all_related_elements(
+        self,
+        element_guid: str,
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -932,26 +1250,47 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+                ("startAtEnd", start_at_end),
+            ]
+        )
 
-        body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-                "effectiveTime": effective_time, }
+        body = {
+            "class": "FindProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship"
-               f"{possible_query_params}")
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship"
+            f"{possible_query_params}"
+        )
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_all_related_elements(self, element_guid: str, open_metadata_type_name: str = None, start_at_end: int = 1,
-                                 effective_time: str = None, for_lineage: bool = None,
-                                 for_duplicate_processing: bool = None, start_from: int = 0,
-                                 page_size: int = max_paging_size, server_name: str = None,
-                                 time_out: int = default_time_out) -> list | str:
+    def get_all_related_elements(
+        self,
+        element_guid: str,
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -999,17 +1338,35 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_all_related_elements(element_guid, open_metadata_type_name, start_at_end, effective_time,
-                                                 for_lineage, for_duplicate_processing, start_from, page_size,
-                                                 server_name, time_out))
+            self._async_get_all_related_elements(
+                element_guid,
+                open_metadata_type_name,
+                start_at_end,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_get_related_elements(self, element_guid: str, relationship_type: str,
-                                          open_metadata_type_name: str = None, start_at_end: int = 1,
-                                          effective_time: str = None, for_lineage: bool = None,
-                                          for_duplicate_processing: bool = None, start_from: int = 0,
-                                          page_size: int = max_paging_size, server_name: str = None,
-                                          time_out: int = default_time_out) -> list | str:
+    async def _async_get_related_elements(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -1060,26 +1417,48 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+                ("startAtEnd", start_at_end),
+            ]
+        )
 
-        body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-                "effectiveTime": effective_time, }
+        body = {
+            "class": "FindProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
-               f"{relationship_type}{possible_query_params}")
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
+            f"{relationship_type}{possible_query_params}"
+        )
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_related_elements(self, element_guid: str, relationship_type: str, open_metadata_type_name: str = None,
-                             start_at_end: int = 1, effective_time: str = None, for_lineage: bool = None,
-                             for_duplicate_processing: bool = None, start_from: int = 0,
-                             page_size: int = max_paging_size, server_name: str = None,
-                             time_out: int = default_time_out) -> list | str:
+    def get_related_elements(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -1129,20 +1508,38 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_related_elements(element_guid, relationship_type, open_metadata_type_name, start_at_end,
-                                             effective_time, for_lineage, for_duplicate_processing, start_from,
-                                             page_size, server_name, time_out))
+            self._async_get_related_elements(
+                element_guid,
+                relationship_type,
+                open_metadata_type_name,
+                start_at_end,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_get_related_elements_with_property_value(self, element_guid: str, relationship_type: str,
-                                                              property_value: str, property_names: [str],
-                                                              open_metadata_type_name: str = None,
-                                                              start_at_end: int = 1, effective_time: str = None,
-                                                              for_lineage: bool = None,
-                                                              for_duplicate_processing: bool = None,
-                                                              start_from: int = 0, page_size: int = max_paging_size,
-                                                              server_name: str = None,
-                                                              time_out: int = default_time_out) -> list | str:
+    async def _async_get_related_elements_with_property_value(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must match exactly. An open metadata type name may be
@@ -1198,29 +1595,53 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+                ("startAtEnd", start_at_end),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
-               f"{relationship_type}/with-exact-property-value{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
+            f"{relationship_type}/with-exact-property-value{possible_query_params}"
+        )
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        elements = response.json().get('elements', 'No elements found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def get_related_elements_with_property_value(self, element_guid: str, relationship_type: str, property_value: str,
-                                                 property_names: [str], open_metadata_type_name: str = None,
-                                                 start_at_end: int = 1, effective_time: str = None,
-                                                 for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                 start_from: int = 0, page_size: int = max_paging_size,
-                                                 server_name: str = None,
-                                                 time_out: int = default_time_out) -> list | str:
+    def get_related_elements_with_property_value(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must match exactly. An open metadata type name may be
@@ -1274,21 +1695,40 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_related_elements_with_property_value(element_guid, relationship_type, property_value,
-                                                                 property_names, open_metadata_type_name, start_at_end,
-                                                                 effective_time, for_lineage, for_duplicate_processing,
-                                                                 start_from, page_size, server_name, time_out))
+            self._async_get_related_elements_with_property_value(
+                element_guid,
+                relationship_type,
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                start_at_end,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_find_related_elements_with_property_value(self, element_guid: str, relationship_type: str,
-                                                               property_value: str, property_names: [str],
-                                                               open_metadata_type_name: str = None,
-                                                               start_at_end: int = 1, effective_time: str = None,
-                                                               for_lineage: bool = None,
-                                                               for_duplicate_processing: bool = None,
-                                                               start_from: int = 0, page_size: int = max_paging_size,
-                                                               server_name: str = None,
-                                                               time_out: int = default_time_out) -> list | str:
+    async def _async_find_related_elements_with_property_value(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must only be contained in the properties rather than
@@ -1345,30 +1785,54 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+                ("startAtEnd", start_at_end),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataTypeName": open_metadata_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
-               f"{relationship_type}/with-property-value-search{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
+            f"{relationship_type}/with-property-value-search{possible_query_params}"
+        )
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
 
-        elements = response.json().get('elements', 'No elements found')
+        elements = response.json().get("elements", "No elements found")
         if type(elements) is list:
             if len(elements) == 0:
                 return "No elements found"
         return elements
 
-    def find_related_elements_with_property_value(self, element_guid: str, relationship_type: str, property_value: str,
-                                                  property_names: [str], open_metadata_type_name: str = None,
-                                                  start_at_end: int = 1, effective_time: str = None,
-                                                  for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                  start_from: int = 0, page_size: int = max_paging_size,
-                                                  server_name: str = None,
-                                                  time_out: int = default_time_out) -> list | str:
+    def find_related_elements_with_property_value(
+        self,
+        element_guid: str,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        open_metadata_type_name: str = None,
+        start_at_end: int = 1,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must only be contained in the properties rather than
@@ -1423,19 +1887,38 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_related_elements_with_property_value(element_guid, relationship_type, property_value,
-                                                                  property_names, open_metadata_type_name, start_at_end,
-                                                                  effective_time, for_lineage, for_duplicate_processing,
-                                                                  start_from, page_size, server_name, time_out))
+            self._async_find_related_elements_with_property_value(
+                element_guid,
+                relationship_type,
+                property_value,
+                property_names,
+                open_metadata_type_name,
+                start_at_end,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
     #
     #   relationships
 
-    async def _async_get_relationships(self, relationship_type: str, effective_time: str = None,
-                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                       start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-                                       time_out: int = default_time_out) -> list | str:
+    async def _async_get_relationships(
+        self,
+        relationship_type: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name. Async version.
 
@@ -1476,25 +1959,42 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
         body = {"class": "FindProperties", "effectiveTime": effective_time}
 
-        url = (f"{base_path(self, server_name)}/relationships/{relationship_type}"
-               f"{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/relationships/{relationship_type}"
+            f"{possible_query_params}"
+        )
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        rels = response.json().get('relationships', 'No relationships found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        rels = response.json().get("relationships", "No relationships found")
 
         if type(rels) is list:
             if len(rels) == 0:
                 return "No elements found"
         return rels
 
-    def get_relationships(self, relationship_type: str, effective_time: str = None, for_lineage: bool = None,
-                          for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-                          server_name: str = None, time_out: int = default_time_out) -> list | str:
+    def get_relationships(
+        self,
+        relationship_type: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name.
 
@@ -1534,16 +2034,32 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_relationships(relationship_type, effective_time, for_lineage, for_duplicate_processing,
-                                          start_from, page_size, server_name, time_out))
+            self._async_get_relationships(
+                relationship_type,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_get_relationships_with_property_value(self, relationship_type: str, property_value: str,
-                                                           property_names: [str], effective_time: str = None,
-                                                           for_lineage: bool = None,
-                                                           for_duplicate_processing: bool = None, start_from: int = 0,
-                                                           page_size: int = max_paging_size, server_name: str = None,
-                                                           time_out: int = default_time_out) -> list | str:
+    async def _async_get_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in
         one of the relationship's properties specified.  The value must match exactly. Async version.
@@ -1591,27 +2107,48 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "propertyValue": property_value,
-                "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/relationships/{relationship_type}/"
-               f"with-exact-property-value{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/relationships/{relationship_type}/"
+            f"with-exact-property-value{possible_query_params}"
+        )
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        rels = response.json().get('relationships', 'No elements found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        rels = response.json().get("relationships", "No elements found")
         if type(rels) is list:
             if len(rels) == 0:
                 return "No elements found"
         return rels
 
-    def get_relationships_with_property_value(self, relationship_type: str, property_value: str, property_names: [str],
-                                              effective_time: str = None, for_lineage: bool = None,
-                                              for_duplicate_processing: bool = None, start_from: int = 0,
-                                              page_size: int = max_paging_size, server_name: str = None,
-                                              time_out: int = default_time_out) -> list | str:
+    def get_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in
         one of the relationship's properties specified.  The value must match exactly.
@@ -1656,17 +2193,34 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_relationships_with_property_value(relationship_type, property_value, property_names,
-                                                              effective_time, for_lineage, for_duplicate_processing,
-                                                              start_from, page_size, server_name, time_out))
+            self._async_get_relationships_with_property_value(
+                relationship_type,
+                property_value,
+                property_names,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
-    async def _async_find_relationships_with_property_value(self, relationship_type: str, property_value: str,
-                                                            property_names: [str], effective_time: str = None,
-                                                            for_lineage: bool = None,
-                                                            for_duplicate_processing: bool = None, start_from: int = 0,
-                                                            page_size: int = max_paging_size, server_name: str = None,
-                                                            time_out: int = default_time_out) -> list | str:
+    async def _async_find_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in one of
         the relationship's properties specified.  The value must only be contained in the properties rather than
@@ -1713,28 +2267,49 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-             ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("startFrom", start_from),
+                ("pageSize", page_size),
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindPropertyNamesProperties", "propertyValue": property_value,
-                "propertyNames": property_names, "effectiveTime": effective_time, }
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{base_path(self, server_name)}/relationships/"
-               f"{relationship_type}/with-property-value-search{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/relationships/"
+            f"{relationship_type}/with-property-value-search{possible_query_params}"
+        )
 
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
 
-        rels = response.json().get('relationships', 'No elements found')
+        rels = response.json().get("relationships", "No elements found")
         if type(rels) is list:
             if len(rels) == 0:
                 return "No elements found"
         return rels
 
-    def find_relationships_with_property_value(self, relationship_type: str, property_value: str, property_names: [str],
-                                               effective_time: str = None, for_lineage: bool = None,
-                                               for_duplicate_processing: bool = None, start_from: int = 0,
-                                               page_size: int = max_paging_size, server_name: str = None,
-                                               time_out: int = default_time_out) -> list | str:
+    def find_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in one of
         the relationship's properties specified.  The value must only be contained in the properties rather than
@@ -1782,18 +2357,34 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_relationships_with_property_value(relationship_type, property_value, property_names,
-                                                               effective_time, for_lineage, for_duplicate_processing,
-                                                               start_from, page_size, server_name, time_out))
+            self._async_find_relationships_with_property_value(
+                relationship_type,
+                property_value,
+                property_names,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
     #
     #  guid
     #
 
-    async def _async_retrieve_instance_for_guid(self, guid: str, effective_time: str = None, for_lineage: bool = None,
-                                                for_duplicate_processing: bool = None, server_name: str = None,
-                                                time_out: int = default_time_out) -> list | str:
+    async def _async_retrieve_instance_for_guid(
+        self,
+        guid: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
          Retrieve the header for the instance identified by the supplied unique identifier.
          It may be an element (entity) or a relationship between elements. Async version.
@@ -1831,18 +2422,33 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        body = {"class": "FindProperties", "effectiveTime": effective_time, }
+        body = {
+            "class": "FindProperties",
+            "effectiveTime": effective_time,
+        }
 
         url = f"{base_path(self, server_name)}/guids/{guid}{possible_query_params}"
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-        element = response.json().get('element', 'No elements found')
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        element = response.json().get("element", "No elements found")
         return element
 
-    def retrieve_instance_for_guid(self, guid: str, effective_time: str = None, for_lineage: bool = None,
-                                   for_duplicate_processing: bool = None, server_name: str = None,
-                                   time_out: int = default_time_out) -> list | str:
+    def retrieve_instance_for_guid(
+        self,
+        guid: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> list | str:
         """
          Retrieve the header for the instance identified by the supplied unique identifier.
          It may be an element (entity) or a relationship between elements.
@@ -1879,17 +2485,30 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_retrieve_instance_for_guid(guid, effective_time, for_lineage, for_duplicate_processing,
-                                                   server_name, time_out))
+            self._async_retrieve_instance_for_guid(
+                guid,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
         return response
 
     #
     #   Classification CRUD
     #
 
-    async def _async_set_confidence_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                   for_duplicate_processing: bool = None, server_name: str = None,
-                                                   time_out: int = default_time_out) -> None:
+    async def _async_set_confidence_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization
         has that the data is complete, accurate and up-to-date.  The level of confidence is expressed by the
@@ -1951,16 +2570,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidence"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def set_confidence_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                      for_duplicate_processing: bool = None, server_name: str = None,
-                                      time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/confidence"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def set_confidence_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization
         has that the data is complete, accurate and up-to-date.  The level of confidence is expressed by the
@@ -2021,15 +2654,27 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_set_confidence_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                      server_name, time_out))
-
-    async def _async_clear_confidence_classification(self, element_guid: str, for_lineage: bool = None,
-                                                     for_duplicate_processing: bool = None, effective_time: str = None,
-                                                     server_name: str = None,
-                                                     time_out: int = default_time_out) -> None:
+            self._async_set_confidence_classification(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_confidence_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-        Remove the confidence classification from the element.  This normally occurs when the organization has lost 
+        Remove the confidence classification from the element.  This normally occurs when the organization has lost
         track of the level of confidence to assign to the element. Async Version.
 
         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
@@ -2069,24 +2714,34 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidence/remove"
-               f"{possible_query_params}")
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_confidence_classification(self, element_guid: str, for_lineage: bool = None,
-                                        for_duplicate_processing: bool = None, effective_time: str = None,
-                                        server_name: str = None,
-                                        time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/confidence/remove"
+            f"{possible_query_params}"
+        )
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_confidence_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-        Remove the confidence classification from the element.  This normally occurs when the organization has lost 
-        track of the level of confidence to assign to the element. 
+        Remove the confidence classification from the element.  This normally occurs when the organization has lost
+        track of the level of confidence to assign to the element.
 
         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
 
@@ -2124,12 +2779,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_confidence_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                        effective_time, server_name, time_out))
-
-    async def _async_set_confidentiality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                        for_duplicate_processing: bool = None, server_name: str = None,
-                                                        time_out: int = default_time_out) -> None:
+            self._async_clear_confidence_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_set_confidentiality_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the
         level of confidentiality that any data associated with the element should be given.  If the classification is
@@ -2193,16 +2861,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def set_confidentiality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                           for_duplicate_processing: bool = None, server_name: str = None,
-                                           time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def set_confidentiality_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the
         level of confidentiality that any data associated with the element should be given.  If the classification is
@@ -2265,16 +2947,27 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_set_confidentiality_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                           server_name, time_out))
-
-    async def _async_clear_confidentiality_classification(self, element_guid: str, for_lineage: bool = None,
-                                                          for_duplicate_processing: bool = None,
-                                                          effective_time: str = None,
-                                                          server_name: str = None,
-                                                          time_out: int = default_time_out) -> None:
+            self._async_set_confidentiality_classification(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_confidentiality_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-        Remove the confidentiality classification from the element.  This normally occurs when the organization has lost 
+        Remove the confidentiality classification from the element.  This normally occurs when the organization has lost
         track of the level of confidentiality to assign to the element. Async Version.
 
         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
@@ -2314,25 +3007,35 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality/remove"
-               f"{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_confidentiality_classification(self, element_guid: str, for_lineage: bool = None,
-                                             for_duplicate_processing: bool = None, effective_time: str = None,
-                                             server_name: str = None,
-                                             time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality/remove"
+            f"{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_confidentiality_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-        Remove the confidentiality classification from the element.  This normally occurs when the organization has lost 
-        track of the level of confidentiality to assign to the element. 
+        Remove the confidentiality classification from the element.  This normally occurs when the organization has lost
+        track of the level of confidentiality to assign to the element.
 
         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
 
@@ -2370,12 +3073,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_confidentiality_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                             effective_time, server_name, time_out))
-
-    async def _async_set_criticality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                    for_duplicate_processing: bool = None, server_name: str = None,
-                                                    time_out: int = default_time_out) -> None:
+            self._async_clear_confidentiality_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_set_criticality_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how critical the element (or
         associated resource) is to the organization.  The level of criticality is expressed by the levelIdentifier
@@ -2437,16 +3153,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/criticality"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def set_criticality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                       for_duplicate_processing: bool = None, server_name: str = None,
-                                       time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/criticality"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def set_criticality_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how critical the element (or
         associated resource) is to the organization.  The level of criticality is expressed by the levelIdentifier
@@ -2507,13 +3237,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_set_criticality_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                       server_name, time_out))
-
-    async def _async_clear_criticality_classification(self, element_guid: str, for_lineage: bool = None,
-                                                      for_duplicate_processing: bool = None, effective_time: str = None,
-                                                      server_name: str = None,
-                                                      time_out: int = default_time_out) -> None:
+            self._async_set_criticality_classification(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_criticality_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the criticality classification from the element.  This normally occurs when the organization has lost
         track of the level of criticality to assign to the element. Async Version.
@@ -2555,22 +3297,32 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/criticality/remove"
-               f"{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_criticality_classification(self, element_guid: str, for_lineage: bool = None,
-                                         for_duplicate_processing: bool = None, effective_time: str = None,
-                                         server_name: str = None,
-                                         time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/criticality/remove"
+            f"{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_criticality_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the criticality classification from the element.  This normally occurs when the organization has lost
         track of the level of criticality to assign to the element.
@@ -2611,13 +3363,26 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_criticality_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                         effective_time, server_name, time_out))
-
-    async def _async_add_gov_definition_to_element(self, definition_guid: str, element_guid: str,
-                                                   effective_time: str = None, for_lineage: bool = None,
-                                                   for_duplicate_processing: bool = None, server_name: str = None,
-                                                   time_out: int = default_time_out) -> None:
+            self._async_clear_criticality_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_add_gov_definition_to_element(
+        self,
+        definition_guid: str,
+        element_guid: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Link a governance definition to an element using the GovernedBy relationship. Async version.
 
@@ -2658,18 +3423,33 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
 
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/{definition_guid}"
-               f"{possible_query_params}")
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/{definition_guid}"
+            f"{possible_query_params}"
+        )
 
         body = {"class": "RelationshipRequestBody", "effectiveTime": effective_time}
 
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def add_gov_definition_to_element(self, definition_guid: str, element_guid: str, effective_time: str = None,
-                                      for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                      server_name: str = None, time_out: int = default_time_out) -> None:
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def add_gov_definition_to_element(
+        self,
+        definition_guid: str,
+        element_guid: str,
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Link a governance definition to an element using the GovernedBy relationship.
 
@@ -2709,13 +3489,27 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_gov_definition_to_element(definition_guid, element_guid, effective_time, for_lineage,
-                                                      for_duplicate_processing, server_name, time_out))
-
-    async def _async_clear_gov_definition_from_element(self, definition_guid, element_guid: str,
-                                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                       effective_time: str = None, server_name: str = None,
-                                                       time_out: int = default_time_out) -> None:
+            self._async_add_gov_definition_to_element(
+                definition_guid,
+                element_guid,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_gov_definition_from_element(
+        self,
+        definition_guid,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the GovernedBy relationship between a governance definition and an element. Async Version.
 
@@ -2758,22 +3552,33 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/"
-               f"{definition_guid}/remove{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_gov_definition_from_element(self, definition_guid, element_guid: str, for_lineage: bool = None,
-                                          for_duplicate_processing: bool = None, effective_time: str = None,
-                                          server_name: str = None,
-                                          time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/"
+            f"{definition_guid}/remove{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_gov_definition_from_element(
+        self,
+        definition_guid,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the GovernedBy relationship between a governance definition and an element. Async Version.
 
@@ -2815,12 +3620,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_criticality_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                         effective_time, server_name, time_out))
-
-    async def _async_add_ownership_to_element(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                              for_duplicate_processing: bool = None, server_name: str = None,
-                                              time_out: int = default_time_out) -> None:
+            self._async_clear_criticality_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_add_ownership_to_element(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Add or replace the ownership classification for an element. Async version.
 
@@ -2873,16 +3691,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/ownership"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def add_ownership_to_element(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                 for_duplicate_processing: bool = None, server_name: str = None,
-                                 time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/ownership"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def add_ownership_to_element(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Add or replace the ownership classification for an element.
 
@@ -2934,13 +3766,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_ownership_to_element(element_guid, body, for_lineage, for_duplicate_processing, server_name,
-                                                 time_out))
-
-    async def _async_clear_ownership_from_element(self, element_guid: str, for_lineage: bool = None,
-                                                  for_duplicate_processing: bool = None, effective_time: str = None,
-                                                  server_name: str = None,
-                                                  time_out: int = default_time_out) -> None:
+            self._async_add_ownership_to_element(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_ownership_from_element(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the ownership classification from an element. Async version.
 
@@ -2980,22 +3824,32 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/ownership/remove"
-               f"{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_ownership_from_element(self, element_guid: str, for_lineage: bool = None,
-                                     for_duplicate_processing: bool = None, effective_time: str = None,
-                                     server_name: str = None,
-                                     time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/ownership/remove"
+            f"{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_ownership_from_element(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the ownership classification from an element.
 
@@ -3034,13 +3888,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_ownership_from_element(element_guid, for_lineage, for_duplicate_processing,
-                                                     effective_time, server_name,
-                                                     time_out))
-
-    async def _async_set_retention_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                  for_duplicate_processing: bool = None, server_name: str = None,
-                                                  time_out: int = default_time_out) -> None:
+            self._async_clear_ownership_from_element(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_set_retention_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource)
         is to be retained by the organization.  The policy to apply to the element/resource is captured by the retentionBasis
@@ -3106,16 +3972,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/retention"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def set_retention_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                     for_duplicate_processing: bool = None, server_name: str = None,
-                                     time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/retention"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def set_retention_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource)
         is to be retained by the organization.  The policy to apply to the element/resource is captured by the retentionBasis
@@ -3179,76 +4059,98 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_set_retention_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                     server_name, time_out))
-
-    async def _async_clear_retention_classification(self, element_guid: str, for_lineage: bool = None,
-                                                    for_duplicate_processing: bool = None, effective_time: str = None,
-                                                    server_name: str = None,
-                                                    time_out: int = default_time_out) -> None:
+            self._async_set_retention_classification(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_retention_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-         Remove the retention classification from the element.  This normally occurs when the organization has lost
-         track of the level of retention to assign to the element. Async Version.
+        Remove the retention classification from the element.  This normally occurs when the organization has lost
+        track of the level of retention to assign to the element. Async Version.
 
-         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
 
-         Parameters
-         ----------
-         element_guid: str
-             - the identity of the element to update
-         for_lineage: bool, default is set by server
-             - determines if elements classified as Memento should be returned - normally false
-         for_duplicate_processing: bool, default is set by server
-             - Normally false. Set true when the caller is part of a deduplication function
-         effective_time: str, default = None
-            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-         server_name: str, default = None
-             - name of the server instances for this request.
-         time_out: int, default = default_time_out
-             - http request timeout for this request
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+           - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
 
-         Returns
-         -------
-         [dict] | str
-             Returns a string if no elements found and a list of dict of elements with the results.
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
 
-         Raises
-         ------
-         InvalidParameterException
-             one of the parameters is null or invalid or
-         PropertyServerException
-             There is a problem adding the element properties to the metadata repository or
-         UserNotAuthorizedException
-             the requesting user is not authorized to issue this request.
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
 
 
-         """
+        """
         if server_name is None:
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/retention/remove"
-               f"{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_retention_classification(self, element_guid: str, for_lineage: bool = None,
-                                       for_duplicate_processing: bool = None, effective_time: str = None,
-                                       server_name: str = None,
-                                       time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/retention/remove"
+            f"{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_retention_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the retention classification from the element.  This normally occurs when the organization has lost
         track of the level of retention to assign to the element.
-    
+
         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
-    
+
         Parameters
         ----------
         element_guid: str
@@ -3263,12 +4165,12 @@ class ClassificationManager(Client):
             - name of the server instances for this request.
         time_out: int, default = default_time_out
             - http request timeout for this request
-    
+
         Returns
         -------
         [dict] | str
             Returns a string if no elements found and a list of dict of elements with the results.
-    
+
         Raises
         ------
         InvalidParameterException
@@ -3277,19 +4179,31 @@ class ClassificationManager(Client):
             There is a problem adding the element properties to the metadata repository or
         UserNotAuthorizedException
             the requesting user is not authorized to issue this request.
-    
-    
+
+
         """
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_retention_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                       effective_time, server_name,
-                                                       time_out))
-
-    async def _async_set_security_tags_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                      for_duplicate_processing: bool = None, server_name: str = None,
-                                                      time_out: int = default_time_out) -> None:
+            self._async_clear_retention_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_set_security_tags_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Add or replace the security tags for an element. Async versuib,
 
@@ -3351,16 +4265,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/security-tags"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def set_security_tags_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                         for_duplicate_processing: bool = None, server_name: str = None,
-                                         time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/security-tags"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def set_security_tags_classification(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Add or replace the security tags for an element. Async versuib,
 
@@ -3421,110 +4349,146 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_set_security_tags_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                         server_name, time_out))
-
-    async def _async_clear_security_tags_classification(self, element_guid: str, for_lineage: bool = None,
-                                                        for_duplicate_processing: bool = None,
-                                                        effective_time: str = None, server_name: str = None,
-                                                        time_out: int = default_time_out) -> None:
+            self._async_set_security_tags_classification(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_security_tags_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-         Remove the security-tags classification from the element.
+        Remove the security-tags classification from the element.
 
-         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
 
-         Parameters
-         ----------
-         element_guid: str
-             - the identity of the element to update
-         for_lineage: bool, default is set by server
-             - determines if elements classified as Memento should be returned - normally false
-         for_duplicate_processing: bool, default is set by server
-             - Normally false. Set true when the caller is part of a deduplication function
-         server_name: str, default = None
-             - name of the server instances for this request.
-         time_out: int, default = default_time_out
-             - http request timeout for this request
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
 
-         Returns
-         -------
-            None
+        Returns
+        -------
+           None
 
-         Raises
-         ------
-         InvalidParameterException
-             one of the parameters is null or invalid or
-         PropertyServerException
-             There is a problem adding the element properties to the metadata repository or
-         UserNotAuthorizedException
-             the requesting user is not authorized to issue this request.
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
 
 
-         """
+        """
         if server_name is None:
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/security-tags/remove"
-               f"{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_security_tags_classification(self, element_guid: str, for_lineage: bool = None,
-                                           for_duplicate_processing: bool = None, effective_time: str = None,
-                                           server_name: str = None,
-                                           time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/security-tags/remove"
+            f"{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_security_tags_classification(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-         Remove the security-tags classification from the element.
+        Remove the security-tags classification from the element.
 
-         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
 
-         Parameters
-         ----------
-         element_guid: str
-             - the identity of the element to update
-         for_lineage: bool, default is set by server
-             - determines if elements classified as Memento should be returned - normally false
-         for_duplicate_processing: bool, default is set by server
-             - Normally false. Set true when the caller is part of a deduplication function
-         effective_time: str, default = None
-            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-         server_name: str, default = None
-             - name of the server instances for this request.
-         time_out: int, default = default_time_out
-             - http request timeout for this request
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+           - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
 
-         Returns
-         -------
-            None
+        Returns
+        -------
+           None
 
-         Raises
-         ------
-         InvalidParameterException
-             one of the parameters is null or invalid or
-         PropertyServerException
-             There is a problem adding the element properties to the metadata repository or
-         UserNotAuthorizedException
-             the requesting user is not authorized to issue this request.
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
 
 
-         """
+        """
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_security_tags_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                           effective_time, server_name, time_out))
-
-    async def _async_setup_semantic_assignment(self, glossary_term_guid: str, element_guid: str, body: dict,
-                                               for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                               server_name: str = None, time_out: int = default_time_out) -> None:
+            self._async_clear_security_tags_classification(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_setup_semantic_assignment(
+        self,
+        glossary_term_guid: str,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute,
         data field or asset). This relationship indicates that the data associated with the element meaning matches
@@ -3587,16 +4551,31 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms"
-               f"/{glossary_term_guid}{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def setup_semantic_assignment(self, glossary_term_guid: str, element_guid: str, body: dict,
-                                  for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                  server_name: str = None, time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms"
+            f"/{glossary_term_guid}{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def setup_semantic_assignment(
+        self,
+        glossary_term_guid: str,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute,
         data field or asset). This relationship indicates that the data associated with the element meaning matches
@@ -3657,118 +4636,154 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_setup_semantic_assignment(glossary_term_guid, element_guid, body, for_lineage,
-                                                  for_duplicate_processing, server_name, time_out))
-
-    async def _async_clear_semantic_assignment_classification(self, glossary_term_guid: str, element_guid: str,
-                                                              for_lineage: bool = None,
-                                                              for_duplicate_processing: bool = None,
-                                                              effective_time: str = None,
-                                                              server_name: str = None,
-                                                              time_out: int = default_time_out) -> None:
+            self._async_setup_semantic_assignment(
+                glossary_term_guid,
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_clear_semantic_assignment_classification(
+        self,
+        glossary_term_guid: str,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-         Remove the semantic_assignment classification from the element. Async version.
+        Remove the semantic_assignment classification from the element. Async version.
 
-         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
 
-         Parameters
-         ----------
-         glossary_term_guid: str
-            - identity of glossary to remove
-         element_guid: str
-             - the identity of the element to update
-         for_lineage: bool, default is set by server
-             - determines if elements classified as Memento should be returned - normally false
-         for_duplicate_processing: bool, default is set by server
-             - Normally false. Set true when the caller is part of a deduplication function
-         effective_time: str, default = None
-            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-         server_name: str, default = None
-             - name of the server instances for this request.
-         time_out: int, default = default_time_out
-             - http request timeout for this request
+        Parameters
+        ----------
+        glossary_term_guid: str
+           - identity of glossary to remove
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+           - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
 
-         Returns
-         -------
-            None
+        Returns
+        -------
+           None
 
-         Raises
-         ------
-         InvalidParameterException
-             one of the parameters is null or invalid or
-         PropertyServerException
-             There is a problem adding the element properties to the metadata repository or
-         UserNotAuthorizedException
-             the requesting user is not authorized to issue this request.
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
 
-         """
+        """
         if server_name is None:
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms/"
-               f"{glossary_term_guid}/remove{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def clear_semantic_assignment_classification(self, glossary_term_guid: str, element_guid: str,
-                                                 for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                 effective_time: str = None,
-                                                 server_name: str = None, time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms/"
+            f"{glossary_term_guid}/remove{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def clear_semantic_assignment_classification(
+        self,
+        glossary_term_guid: str,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
-         Remove the semantic_assignment classification from the element.
+        Remove the semantic_assignment classification from the element.
 
-         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
 
-         Parameters
-         ----------
-         glossary_term_guid: str
-            - identity of glossary to remove
-         element_guid: str
-             - the identity of the element to update
-         for_lineage: bool, default is set by server
-             - determines if elements classified as Memento should be returned - normally false
-         for_duplicate_processing: bool, default is set by server
-             - Normally false. Set true when the caller is part of a deduplication function
-         effective_time: str, default = None
-            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-         server_name: str, default = None
-             - name of the server instances for this request.
-         time_out: int, default = default_time_out
-             - http request timeout for this request
+        Parameters
+        ----------
+        glossary_term_guid: str
+           - identity of glossary to remove
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+           - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
 
-         Returns
-         -------
-            None
+        Returns
+        -------
+           None
 
-         Raises
-         ------
-         InvalidParameterException
-             one of the parameters is null or invalid or
-         PropertyServerException
-             There is a problem adding the element properties to the metadata repository or
-         UserNotAuthorizedException
-             the requesting user is not authorized to issue this request.
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
 
 
-         """
+        """
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_semantic_assignment_classification(glossary_term_guid, element_guid, for_lineage,
-                                                                 for_duplicate_processing, effective_time, server_name,
-                                                                 time_out))
-
-    async def _async_add_element_to_subject_area(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                                 for_duplicate_processing: bool = None, server_name: str = None,
-                                                 time_out: int = default_time_out) -> None:
+            self._async_clear_semantic_assignment_classification(
+                glossary_term_guid,
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_add_element_to_subject_area(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify the element to assert that the definitions it represents are part of a subject area definition. Async
 
@@ -3821,16 +4836,30 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
-               f"{possible_query_params}")
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def add_element_to_subject_area(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                    for_duplicate_processing: bool = None, server_name: str = None,
-                                    time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
+            f"{possible_query_params}"
+        )
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def add_element_to_subject_area(
+        self,
+        element_guid: str,
+        body: dict,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Classify the element to assert that the definitions it represents are part of a subject area definition. Async
 
@@ -3882,13 +4911,25 @@ class ClassificationManager(Client):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_element_to_subject_area(element_guid, body, for_lineage, for_duplicate_processing,
-                                                    server_name, time_out))
-
-    async def _async_remove_element_from_subject_area(self, element_guid: str, for_lineage: bool = None,
-                                                      for_duplicate_processing: bool = None, effective_time: str = None,
-                                                      server_name: str = None,
-                                                      time_out: int = default_time_out) -> None:
+            self._async_add_element_to_subject_area(
+                element_guid,
+                body,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                time_out,
+            )
+        )
+
+    async def _async_remove_element_from_subject_area(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the subject area designation from the identified element. Async version.
 
@@ -3923,27 +4964,37 @@ class ClassificationManager(Client):
              the requesting user is not authorized to issue this request.
 
 
-         """
+        """
         if server_name is None:
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
-        url = (f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
-               f"/remove{possible_query_params}")
-
-        body = {
-            "class": "ClassificationRequestBody",
-            "effectiveTime": effective_time
-        }
-
-        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
-
-    def remove_element_from_subject_area(self, element_guid: str, for_lineage: bool = None,
-                                         for_duplicate_processing: bool = None, effective_time: str = None,
-                                         server_name: str = None,
-                                         time_out: int = default_time_out) -> None:
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+            ]
+        )
+
+        url = (
+            f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
+            f"/remove{possible_query_params}"
+        )
+
+        body = {"class": "ClassificationRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+    def remove_element_from_subject_area(
+        self,
+        element_guid: str,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        effective_time: str = None,
+        server_name: str = None,
+        time_out: int = default_time_out,
+    ) -> None:
         """
         Remove the subject area designation from the identified element.
 
@@ -3978,9 +5029,16 @@ class ClassificationManager(Client):
              the requesting user is not authorized to issue this request.
 
 
-         """
+        """
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_remove_element_from_subject_area(element_guid, for_lineage, for_duplicate_processing,
-                                                         effective_time, server_name, time_out))
+            self._async_remove_element_from_subject_area(
+                element_guid,
+                for_lineage,
+                for_duplicate_processing,
+                effective_time,
+                server_name,
+                time_out,
+            )
+        )