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

pyegeria/automated_curation_omvs.py

@@ -2,7 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
- Automated Curation View Service Methods - this file is in active development...
+ Automated Curation View Service Methods
 
 """
 import asyncio
@@ -11,10 +11,12 @@ from datetime import datetime
 from httpx import Response
 
 from pyegeria import Client, max_paging_size, body_slimmer
-from pyegeria._exceptions import (
-    InvalidParameterException,
-)
+from pyegeria._exceptions import (InvalidParameterException, PropertyServerException, UserNotAuthorizedException)
 from ._validators import validate_name, validate_guid, validate_search_string
+from .core_guids import (FileFolder_template_GUID,
+                         PostgreSQL_Server_template_GUID,
+                         Apache_Kafka_Server_template_GUID,
+                         )
 
 
 class AutomatedCuration(Client):
@@ -30,24 +32,15 @@ class AutomatedCuration(Client):
             when the user doesn't pass the user_id on a method call.
         user_pwd: str
             The password associated with the user_id. Defaults to None
-        verify_flag: bool
-            Flag to indicate if SSL Certificates should be verified in the HTTP requests.
-            Defaults to False.
+
 
     """
 
-    def __init__(
-            self,
-            server_name: str,
-            platform_url: str,
-            user_id: str,
-            user_pwd: str = None,
-            verify_flag: bool = False,
-    ):
+    def __init__(self, server_name: str, platform_url: str, user_id: str, user_pwd: str = None,
+                 verify_flag: bool = False, ):
         Client.__init__(self, server_name, platform_url, user_id, user_pwd, verify_flag)
         self.cur_command_root = f"{platform_url}/servers/"
 
-
     async def _async_create_element_from_template(self, body: dict, server: str = None) -> str:
         """ Create a new metadata element from a template.  Async version.
              Parameters
@@ -146,13 +139,11 @@ class AutomatedCuration(Client):
                 }
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_create_element_from_template(body, server)
-        )
+        response = loop.run_until_complete(self._async_create_element_from_template(body, server))
         return response
 
     async def _async_create_kafka_server_element_from_template(self, kafka_server: str, host_name: str, port: str,
-                                                               server: str = None) -> str:
+                                                               description: str = None, server: str = None) -> str:
         """ Create a Kafka server element from a template. Async version.
 
             Parameters
@@ -166,6 +157,9 @@ class AutomatedCuration(Client):
             port : str
                 The port number of the Kafka server.
 
+            description: str, opt
+                A description of the Kafka server.
+
             server : str, optional
                 The name of the view server to use. Default uses the client instance.
 
@@ -175,20 +169,15 @@ class AutomatedCuration(Client):
                 The GUID of the Kafka server element.
         """
 
-        body = {
-            "templateGUID": "5e1ff810-5418-43f7-b7c4-e6e062f9aff7",
-            "isOwnAnchor": 'true',
-            "placeholderPropertyValues": {
-                "serverName": kafka_server,
-                "hostIdentifier": host_name,
-                "portNumber": port
-            }
-        }
-        response = await self._async_create_element_from_template(body, server)
-        return response
+        body = {"templateGUID": Apache_Kafka_Server_template_GUID, "isOwnAnchor": 'true',
+                "placeholderPropertyValues": {"serverName": kafka_server, "hostIdentifier": host_name,
+                                              "portNumber": port, "description": description}}
+        body_s = body_slimmer(body)
+        response = await self._async_create_element_from_template(body_s, server)
+        return str(response)
 
     def create_kafka_server_element_from_template(self, kafka_server: str, host_name: str, port: str,
-                                                  server: str = None) -> str:
+                                                  description: str = None, server: str = None) -> str:
         """ Create a Kafka server element from a template.
 
             Parameters
@@ -202,6 +191,9 @@ class AutomatedCuration(Client):
             port : str
                 The port number of the Kafka server.
 
+            description: str, opt
+                A description of the Kafka server.
+
             server : str, optional
                 The name of the view server to use. Default uses the client instance.
 
@@ -212,12 +204,13 @@ class AutomatedCuration(Client):
             """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_kafka_server_element_from_template(kafka_server, host_name, port, server)
-        )
+            self._async_create_kafka_server_element_from_template(kafka_server, host_name, port,
+                                                                  description, server))
         return response
 
     async def _async_create_postgres_server_element_from_template(self, postgres_server: str, host_name: str, port: str,
-                                                                  db_user: str, db_pwd: str, server: str = None) -> str:
+                                                                  db_user: str, db_pwd: str, description: str = None,
+                                                                  server: str = None) -> str:
         """ Create a Postgres server element from a template. Async version.
 
             Parameters
@@ -237,30 +230,28 @@ class AutomatedCuration(Client):
             db_pwd: str
                 User password to connect to the database
 
+            description: str, opt
+                A description of the Kafka server.
+
             server : str, optional
                 The name of the view server to use. Default uses the client instance.
 
             Returns
             -------
             str
-                The GUID of the Kafka server element.
+                The GUID of the Postgres server element.
         """
-        body = {
-            "templateGUID": "542134e6-b9ce-4dce-8aef-22e8daf34fdb",
-            "isOwnAnchor": 'true',
-            "placeholderPropertyValues": {
-                "serverName": postgres_server,
-                "hostIdentifier": host_name,
-                "portNumber": port,
-                "databaseUserId": db_user,
-                "databasePassword": db_pwd
-            }
-        }
-        response = await self._async_create_element_from_template(body, server)
-        return response
+        body = {"templateGUID": PostgreSQL_Server_template_GUID, "isOwnAnchor": 'true',
+                "placeholderPropertyValues": {"serverName": postgres_server, "hostIdentifier": host_name,
+                                              "portNumber": port, "databaseUserId": db_user, "description": description,
+                                              "databasePassword": db_pwd}}
+        body_s = body_slimmer(body)
+        response = await self._async_create_element_from_template(body_s, server)
+        return str(response)
 
     def create_postgres_server_element_from_template(self, postgres_server: str, host_name: str, port: str,
-                                                     db_user: str, db_pwd: str, server: str = None) -> str:
+                                                     db_user: str, db_pwd: str, description: str = None,
+                                                     server: str = None) -> str:
         """ Create a Postgres server element from a template.
 
             Parameters
@@ -277,6 +268,9 @@ class AutomatedCuration(Client):
             server : str, optional
                 The name of the view server to use. Default uses the client instance.
 
+            description: str, opt
+                A description of the Kafka server.
+
             db_user: str
                 User name to connect to the database
 
@@ -290,9 +284,89 @@ class AutomatedCuration(Client):
             """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_postgres_server_element_from_template(postgres_server, host_name,
-                                                                     port, db_user, db_pwd, server)
-        )
+            self._async_create_postgres_server_element_from_template(postgres_server, host_name, port, db_user, db_pwd,
+                                                                     description, server))
+        return response
+
+    async def _async_create_folder_element_from_template(self, path_name: str, folder_name: str, file_system: str,
+                                                         description: str = None, version: str = None,
+                                                         server: str = None) -> str:
+        """ Create a File folder element from a template. Async version.
+
+        Parameters
+        ----------
+        path_name : str
+            The name of the fill path including the folder..
+
+        folder_name : str
+            The name of the folder to create.
+
+        file_system : str
+            The unique name for the file system that the folder belongs to. It may be a machine name or URL to a remote
+            file store.
+
+        description: str, opt
+                A description of the Kafka server.
+
+        version: str, opt
+                version of the file folder - typically of the form x.y.z
+
+        server : str, optional
+            The name of the view server to use. Default uses the client instance.
+
+        Returns
+        -------
+        str
+            The GUID of the File Folder element.
+        """
+        body = {"templateGUID": FileFolder_template_GUID,
+                "isOwnAnchor": 'true',
+                "placeholderPropertyValues": {
+                    "directoryPathName": path_name,
+                    "directoryName": folder_name,
+                    "versionIdentifier": version,
+                    "fileSystemName": file_system,
+                    "description": description,
+                }
+                }
+        body_s = body_slimmer(body)
+        response = await self._async_create_element_from_template(body_s, server)
+        return str(response)
+
+    def create_folder_element_from_template(self, path_name: str, folder_name: str, file_system: str,
+                                            description: str = None, version: str = None, server: str = None) -> str:
+        """ Create a File folder element from a template.
+
+            Parameters
+            ----------
+            path_name : str
+                The name of the fill path including the folder..
+
+            folder_name : str
+                The name of the folder to create.
+
+            file_system : str
+                The unique name for the file system that the folder belongs to. It may be a machine name or URL to a
+                remote file store.
+
+            description: str, opt
+                A description of the Kafka server.
+
+            version: str, opt
+                version of the file folder - typically of the form x.y.z
+
+            server : str, optional
+                The name of the view server to use. Default uses the client instance.
+
+            Returns
+            -------
+            str
+                The GUID of the Postgres server element.
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_create_folder_element_from_template(path_name, folder_name, file_system,
+                                                            description, version, server))
         return response
 
     #
@@ -360,9 +434,7 @@ class AutomatedCuration(Client):
             For more information see: https://egeria-project.org/concepts/engine-action
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_engine_actions(server, start_from, page_size)
-        )
+        response = loop.run_until_complete(self._async_get_engine_actions(server, start_from, page_size))
         return response
 
     async def _async_get_engine_action(self, engine_action_guid: str, server: str = None) -> dict:
@@ -424,9 +496,7 @@ class AutomatedCuration(Client):
             For more information see: https://egeria-project.org/concepts/engine-action
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_engine_action(engine_action_guid, server)
-        )
+        response = loop.run_until_complete(self._async_get_engine_action(engine_action_guid, server))
         return response
 
     async def _async_cancel_engine_action(self, engine_action_guid: str, server: str = None) -> None:
@@ -488,8 +558,7 @@ class AutomatedCuration(Client):
             For more information see: https://egeria-project.org/concepts/engine-action
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_cancel_engine_action(engine_action_guid, server))
+        loop.run_until_complete(self._async_cancel_engine_action(engine_action_guid, server))
         return
 
     async def _async_get_active_engine_actions(self, server: str = None, start_from: int = 0,
@@ -553,9 +622,7 @@ class AutomatedCuration(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_active_engine_actions(server, start_from, page_size)
-        )
+        response = loop.run_until_complete(self._async_get_active_engine_actions(server, start_from, page_size))
         return response
 
     async def _async_get_engine_actions_by_name(self, name: str, server: str = None, start_from: int = 0,
@@ -596,9 +663,7 @@ class AutomatedCuration(Client):
 
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/engine-actions/by-name?"
                f"startFrom={start_from}&pageSize={page_size}")
-        body = {
-            "filter": name
-        }
+        body = {"filter": name}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
@@ -637,9 +702,7 @@ class AutomatedCuration(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_engine_actions_by_name(name, server, start_from, page_size)
-        )
+        response = loop.run_until_complete(self._async_get_engine_actions_by_name(name, server, start_from, page_size))
         return response
 
     async def _async_find_engine_actions(self, search_string: str, server: str = None, starts_with: bool = False,
@@ -695,12 +758,8 @@ class AutomatedCuration(Client):
 
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/engine-actions/"
                f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
-               )
-        body = {
-            "class": "SearchStringRequestBody",
-            "name": search_string
-        }
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}")
+        body = {"class": "SearchStringRequestBody", "name": search_string}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
@@ -750,10 +809,8 @@ class AutomatedCuration(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_engine_actions(search_string, server, starts_with,
-                                            ends_with, ignore_case, start_from,
-                                            page_size)
-        )
+            self._async_find_engine_actions(search_string, server, starts_with, ends_with, ignore_case, start_from,
+                                            page_size))
         return response
 
     #
@@ -812,9 +869,7 @@ class AutomatedCuration(Client):
                 UserNotAuthorizedException:
             """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_governance_action_process_by_guid(process_guid, server)
-        )
+        response = loop.run_until_complete(self._async_get_governance_action_process_by_guid(process_guid, server))
         return response
 
     async def _async_get_gov_action_process_graph(self, process_guid: str, server: str = None) -> dict | str:
@@ -846,7 +901,7 @@ class AutomatedCuration(Client):
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/"
                f"governance-action-processes/{process_guid}/graph")
 
-        response = await self._async_make_request("GET", url)
+        response = await self._async_make_request("POST", url)
         return response.json().get("element", "no actions")
 
     def get_gov_action_process_graph(self, process_guid: str, server: str = None) -> dict | str:
@@ -873,9 +928,7 @@ class AutomatedCuration(Client):
 
        """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_gov_action_process_graph(process_guid, server)
-        )
+        response = loop.run_until_complete(self._async_get_gov_action_process_graph(process_guid, server))
         return response
 
     async def _async_get_gov_action_processes_by_name(self, name: str, server: str = None, start_from: int = None,
@@ -912,10 +965,7 @@ class AutomatedCuration(Client):
 
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-processes/"
                f"by-name?startFrom={start_from}&pageSize={page_size}")
-        body = {
-            "class": "NameRequestBody",
-            "name": name
-        }
+        body = {"class": "NameRequestBody", "name": name}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
@@ -950,8 +1000,7 @@ class AutomatedCuration(Client):
            """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_gov_action_processes_by_name(name, server, start_from, page_size)
-        )
+            self._async_get_gov_action_processes_by_name(name, server, start_from, page_size))
         return response
 
     async def _async_find_gov_action_processes(self, search_string: str, server: str = None, starts_with: bool = False,
@@ -1002,15 +1051,16 @@ class AutomatedCuration(Client):
         ends_with_s = str(ends_with).lower()
         ignore_case_s = str(ignore_case).lower()
 
-        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-process/"
+        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-processes/"
                f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
-               )
-        body = {
-            "class": "SearchStringRequestBody",
-            "name": search_string
-        }
-        response = await self._async_make_request("POST", url, body)
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}")
+
+        if search_string:
+            body = {"filter": search_string}
+            response = await self._async_make_request("POST", url, body)
+        else:
+            response = await self._async_make_request("POST", url)
+
         return response.json().get("elements", "no actions")
 
     def find_gov_action_processes(self, search_string: str = "*", server: str = None, starts_with: bool = False,
@@ -1057,8 +1107,7 @@ class AutomatedCuration(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_gov_action_processes(search_string, server, starts_with, ends_with, ignore_case,
-                                                  start_from, page_size)
-        )
+                                                  start_from, page_size))
         return response
 
     async def _async_initiate_gov_action_process(self, action_type_qualified_name: str, request_source_guids: [str],
@@ -1097,23 +1146,17 @@ class AutomatedCuration(Client):
         """
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-processes/"
                f"initiate")
-        body = {
-            "class": "GovernanceActionProcessRequestBody",
-            "processQualifiedName": action_type_qualified_name,
-            "requestSourceGUIDs": request_source_guids,
-            "actionTargets": action_targets,
-            "startTime": int(start_time.timestamp() * 1000),
-            "requestParameters": request_parameters,
-            "originatorServiceName": orig_service_name,
-            "originatorEngineName": orig_engine_name
-        }
+        body = {"class": "GovernanceActionProcessRequestBody", "processQualifiedName": action_type_qualified_name,
+                "requestSourceGUIDs": request_source_guids, "actionTargets": action_targets,
+                "startTime": int(start_time.timestamp() * 1000), "requestParameters": request_parameters,
+                "originatorServiceName": orig_service_name, "originatorEngineName": orig_engine_name}
         new_body = body_slimmer(body)
         response = await self._async_make_request("POST", url, new_body)
         return response.json().get("guid", "Action not initiated")
 
     def initiate_gov_action_process(self, action_type_qualified_name: str, request_source_guids: [str],
-                                           action_targets: [str], start_time: datetime, request_parameters: dict,
-                                           orig_service_name: str, orig_engine_name: str, server: str = None) -> str:
+                                    action_targets: [str], start_time: datetime, request_parameters: dict,
+                                    orig_service_name: str, orig_engine_name: str, server: str = None) -> str:
         """ Using the named governance action process as a template, initiate a chain of engine actions.
 
         Parameters
@@ -1148,10 +1191,9 @@ class AutomatedCuration(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_initiate_gov_action_process(action_type_qualified_name, request_source_guids,
-                                                    action_targets, start_time, request_parameters,
-                                                    orig_service_name, orig_engine_name, server)
-        )
+            self._async_initiate_gov_action_process(action_type_qualified_name, request_source_guids, action_targets,
+                                                    start_time, request_parameters, orig_service_name, orig_engine_name,
+                                                    server))
         return response
 
     async def _async_get_gov_action_types_by_guid(self, gov_action_type_guid: str, server: str = None) -> dict | str:
@@ -1204,13 +1246,11 @@ class AutomatedCuration(Client):
             UserNotAuthorizedException:
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_gov_action_type_by_guid(gov_action_type_guid, server)
-        )
+        response = loop.run_until_complete(self._async_get_gov_action_types_by_guid(gov_action_type_guid, server))
         return response
 
-    async def _async_get_gov_action_types_by_name(self, action_type_name, server: str = None,
-                                                  start_from: int = 0, page_size: int = max_paging_size) -> list | str:
+    async def _async_get_gov_action_types_by_name(self, action_type_name, server: str = None, start_from: int = 0,
+                                                  page_size: int = max_paging_size) -> list | str:
         """ Retrieve the list of governance action type metadata elements with a matching qualified or display name.
             There are no wildcards supported on this request. Async version.
 
@@ -1238,16 +1278,13 @@ class AutomatedCuration(Client):
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/"
                f"governance-action-types/by-name?startFrom={start_from}&pageSize={page_size}")
 
-        body = {
-            "class": "NameRequestBody",
-            "name": action_type_name
-        }
+        body = {"class": "NameRequestBody", "name": action_type_name}
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
-    def get_gov_action_types_by_name(self, action_type_name, server: str = None,
-                                     start_from: int = 0, page_size: int = max_paging_size) -> list | str:
+    def get_gov_action_types_by_name(self, action_type_name, server: str = None, start_from: int = 0,
+                                     page_size: int = max_paging_size) -> list | str:
         """ Retrieve the list of governance action type metadata elements with a matching qualified or display name.
             There are no wildcards supported on this request. Async version.
 
@@ -1270,15 +1307,12 @@ class AutomatedCuration(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_gov_action_types_by_name(action_type_name, server,
-                                                     start_from, page_size)
-        )
+            self._async_get_gov_action_types_by_name(action_type_name, server, start_from, page_size))
         return response
 
     async def _async_find_gov_action_types(self, search_string: str = "*", server: str = None,
-                                           starts_with: bool = False,
-                                           ends_with: bool = False, ignore_case: bool = True, start_from: int = 0,
-                                           page_size: int = max_paging_size) -> list | str:
+                                           starts_with: bool = False, ends_with: bool = False, ignore_case: bool = True,
+                                           start_from: int = 0, page_size: int = max_paging_size) -> list | str:
         """ Retrieve the list of governance action type metadata elements that contain the search string.
             Async Version.
 
@@ -1329,12 +1363,8 @@ class AutomatedCuration(Client):
 
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
-               )
-        body = {
-            "class": "SearchStringRequestBody",
-            "name": search_string
-        }
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}")
+        body = {"class": "SearchStringRequestBody", "name": search_string}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no action types")
 
@@ -1381,16 +1411,14 @@ class AutomatedCuration(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_gov_action_types(search_string, server, starts_with, ends_with,
-                                              ignore_case, start_from, page_size)
-        )
+            self._async_find_gov_action_types(search_string, server, starts_with, ends_with, ignore_case, start_from,
+                                              page_size))
         return response
 
     async def _async_initiate_gov_action_type(self, action_type_qualified_name: str, request_source_guids: [str],
                                               action_targets: list, start_time: datetime = None,
-                                              request_parameters: dict = None,
-                                              orig_service_name: str = None, orig_engine_name: str = None,
-                                              server: str = None) -> str:
+                                              request_parameters: dict = None, orig_service_name: str = None,
+                                              orig_engine_name: str = None, server: str = None) -> str:
         """ Using the named governance action type as a template, initiate an engine action. Async version.
 
         Parameters
@@ -1426,16 +1454,12 @@ class AutomatedCuration(Client):
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName": action_type_qualified_name,
-            "requestSourceGUIDs": request_source_guids,
-            "actionTargets": action_targets,
-            "startDate": int(start_time.timestamp() * 1000),
-            "requestParameters": request_parameters,
-            "originatorServiceName": orig_service_name,
-            "originatorEngineName": orig_engine_name
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody",
+                "governanceActionTypeQualifiedName": action_type_qualified_name,
+                "requestSourceGUIDs": request_source_guids,
+                "actionTargets": action_targets, "startDate": int(start_time.timestamp() * 1000),
+                "requestParameters": request_parameters, "originatorServiceName": orig_service_name,
+                "originatorEngineName": orig_engine_name}
         new_body = body_slimmer(body)
         response = await self._async_make_request("POST", url, new_body)
         return response.json().get("guid", "Action not initiated")
@@ -1476,152 +1500,207 @@ class AutomatedCuration(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_initiate_gov_action_type(action_type_qualified_name, request_source_guids,
-                                                 action_targets, start_time, request_parameters,
-                                                 orig_service_name, orig_engine_name, server)
-        )
+            self._async_initiate_gov_action_type(action_type_qualified_name, request_source_guids, action_targets,
+                                                 start_time, request_parameters, orig_service_name, orig_engine_name,
+                                                 server))
         return response
 
     async def _async_initiate_postgres_database_survey(self, postgres_database_guid: str, server: str = None) -> str:
+        """ Initiate a postgres database survey"""
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
 
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName": "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-postgres-database",
-            "actionTargets": [{
-                "class": "NewActionTarget",
-                "actionTargetName": "serverToSurvey",
-                "actionTargetGUID": postgres_database_guid
-            }]
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody",
+                "governanceActionTypeQualifiedName":
+                    "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-postgres-database",
+                "actionTargets": [{"class": "NewActionTarget", "actionTargetName": "serverToSurvey",
+                                   "actionTargetGUID": postgres_database_guid}]}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("guid", "Action not initiated")
 
     def initiate_postgres_database_survey(self, postgres_database_guid: str, server: str = None) -> str:
+        """ Initiate a postgres database survey"""
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_initiate_postgres_server_survey(postgres_database_guid, server)
-        )
+        response = loop.run_until_complete(self._async_initiate_postgres_server_survey(postgres_database_guid, server))
         return response
 
     async def _async_initiate_postgres_server_survey(self, postgres_server_guid: str, server: str = None) -> str:
+        """ Initiate a postgres server survey - Async version"""
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
 
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName": "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-postgres-server",
-            "actionTargets": [{
-                "class": "NewActionTarget",
-                "actionTargetName": "serverToSurvey",
-                "actionTargetGUID": postgres_server_guid
-            }]
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody",
+                "governanceActionTypeQualifiedName": "Egeria:GovernanceActionType:AssetSurvey:survey-postgres-server",
+                "actionTargets": [{"class": "NewActionTarget", "actionTargetName": "serverToSurvey",
+                                   "actionTargetGUID": postgres_server_guid}]}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("guid", "Action not initiated")
-        # Create/Retrieve the Postgres Server Element
-
-        # Run the survey using the information and return the engine action to monitor
 
     def initiate_postgres_server_survey(self, postgres_server_guid: str, server: str = None) -> str:
+        """ Initiate a postgres server survey"""
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_initiate_postgres_server_survey(postgres_server_guid, server)
-        )
+        response = loop.run_until_complete(self._async_initiate_postgres_server_survey(postgres_server_guid, server))
         return response
 
-
-
     async def _async_initiate_file_folder_survey(self, file_folder_guid: str,
+                                                 survey_name: str =
+                                                 "Egeria:GovernanceActionType:AssetSurvey:survey-folder",
                                                  server: str = None) -> str:
+        """ Initiate a file folder survey - async version
+
+        Parameters:
+        ----------
+            file_folder_guid: str
+                The GUID of the File Folder that we wish to survey.
+            survey_name: str, optional
+                The unique name of the survey routine to execute. Default surveys all folders.
+            server: str, optional
+                The name of the server. If None, will use the default server specified in the instance will be used.
+        Returns:
+        -------
+            str:
+                The guid of the survey being run.
+
+        Raises:
+        ------
+            InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                       this exception is raised with details from the response content.
+            PropertyServerException: If the API response indicates a server side error.
+            UserNotAuthorizedException:
+
+        Notes:
+            There are multiple kinds of file folder surveys available, each with their own purpose. They are described
+            in the Core Content Brain.
+
+            File Folder Survey Names currently include::
+            - Egeria:GovernanceActionType:AssetSurvey:survey-folders
+            - Egeria:GovernanceActionType:AssetSurvey:survey-folder-and-files
+            - Egeria:GovernanceActionType:AssetSurvey:survey-all-folders
+            - Egeria:GovernanceActionType:AssetSurvey:survey-all-folders-and-files
+        """
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
 
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName":
-                "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-folder",
-            "actionTargets": [{
-                "class": "NewActionTarget",
-                "actionTargetName": "folderToSurvey",
-                "actionTargetGUID": file_folder_guid
-            }]
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody", "governanceActionTypeQualifiedName": survey_name,
+                "actionTargets": [{"class": "NewActionTarget", "actionTargetName": "folderToSurvey",
+                                   "actionTargetGUID": file_folder_guid}]}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("guid", "Action not initiated")
 
-    def initiate_file_folder_survey(self, file_folder_guid:str, server: str = None) -> str:
+    def initiate_file_folder_survey(self, file_folder_guid: str,
+                                    survey_name: str = "Egeria:GovernanceActionType:AssetSurvey:survey-folder",
+                                    server: str = None) -> str:
+        """ Initiate a file folder survey - async version
+
+        Parameters:
+        ----------
+            file_folder_guid: str
+                The GUID of the File Folder that we wish to survey.
+            survey_name: str, optional
+                The unique name of the survey routine to execute. Default surveys all folders.
+            server: str, optional
+                The name of the server. If None, will use the default server specified in the instance will be used.
+        Returns:
+        -------
+            str:
+                The guid of the survey being run.
+
+        Raises:
+        ------
+            InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                       this exception is raised with details from the response content.
+            PropertyServerException: If the API response indicates a server side error.
+            UserNotAuthorizedException:
+
+        Notes:
+            There are multiple kinds of file folder surveys available, each with their own purpose. They are described
+            in the Core Content Brain.
+
+            File Folder Survey Names currently include::
+            - Egeria:GovernanceActionType:AssetSurvey:survey-folders
+            - Egeria:GovernanceActionType:AssetSurvey:survey-folder-and-files
+            - Egeria:GovernanceActionType:AssetSurvey:survey-all-folders
+            - Egeria:GovernanceActionType:AssetSurvey:survey-all-folders-and-files
+
+
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_initiate_file_folder_survey(file_folder_guid, server)
-        )
+            self._async_initiate_file_folder_survey(file_folder_guid, survey_name, server))
         return response
 
-    async def _async_initiate_file_survey(self, file_guid: str,
-                                                 server: str = None) -> str:
+    async def _async_initiate_file_survey(self, file_guid: str, server: str = None) -> str:
+        """ Initiate a file survey - async version"""
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
 
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName":
-                "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-folder",
-            "actionTargets": [{
-                "class": "NewActionTarget",
-                "actionTargetName": "fileToSurvey",
-                "actionTargetGUID": file_guid
-            }]
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody",
+                "governanceActionTypeQualifiedName": "Egeria:GovernanceActionType:AssetSurvey:survey-data-file",
+                "actionTargets": [
+                    {"class": "NewActionTarget", "actionTargetName": "fileToSurvey", "actionTargetGUID": file_guid}]}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("guid", "Action not initiated")
 
-    def initiate_file_survey(self, file_guid:str, server: str = None) -> str:
+    def initiate_file_survey(self, file_guid: str, server: str = None) -> str:
+        """ Initiate a file survey """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_initiate_file_survey(file_guid, server)
-        )
+        response = loop.run_until_complete(self._async_initiate_file_survey(file_guid, server))
         return response
 
     async def _async_initiate_kafka_server_survey(self, kafka_server_guid: str, server: str = None) -> str:
+        """ Initiate survey of a kafka server. Async Version.
+        Parameters
+        ----------
+        kafka_server_guid : str
+            The GUID of the Kafka server to be surveyed.
+
+        server : str, optional
+            The name of the server. If not provided, the default server name is used.
+
+        Returns
+        -------
+        str
+            The GUID of the initiated action or "Action not initiated" if the action was not initiated.
+
+        """
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-action-types/"
                f"initiate")
 
-        body = {
-            "class": "InitiateGovernanceActionTypeRequestBody",
-            "governanceActionTypeQualifiedName":
-                "Egeria:GovernanceActionType:2adeb8f1-0f59-4970-b6f2-6cc25d4d2402survey-kafka-server",
-            "actionTargets": [{
-                "class": "NewActionTarget",
-                "actionTargetName": "serverToSurvey",
-                "actionTargetGUID": kafka_server_guid
-            }]
-        }
+        body = {"class": "InitiateGovernanceActionTypeRequestBody",
+                "governanceActionTypeQualifiedName": "Egeria:GovernanceActionType:AssetSurvey:survey-kafka-server",
+                "actionTargets": [{"class": "NewActionTarget", "actionTargetName": "serverToSurvey",
+                                   "actionTargetGUID": kafka_server_guid}]}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("guid", "Action not initiated")
 
     def initiate_kafka_server_survey(self, kafka_server_guid: str, server: str = None) -> str:
+        """ Initiate survey of a kafka server.
+                Parameters
+                ----------
+                kafka_server_guid : str
+                    The GUID of the Kafka server to be surveyed.
+
+                server : str, optional
+                    The name of the server. If not provided, the default server name is used.
+
+                Returns
+                -------
+                str
+                    The GUID of the initiated action or "Action not initiated" if the action was not initiated.
+
+                """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_initiate_file_folder_survey(kafka_server_guid, server)
-        )
+        response = loop.run_until_complete(self._async_initiate_file_folder_survey(kafka_server_guid, server))
         return response
 
-    async def run_gov_action_postgres_server_survey(self, postgres_server: str, host_name: str, port: str, ):
-        pass
-        # New combo process to do
-        # run a process the creates the postgres server catalog entry, runs the server survey
-        # creates a survey report
-        # adds a to-do list element when done
-
     async def _async_initiate_engine_action(self, qualified_name: str, domain_identifier: int, display_name: str,
                                             description: str, request_source_guids: str, action_targets: str,
-                                            received_guards: [str], start_time: datetime, gov_engine_name: str,
+                                            received_guards: [str], start_time: datetime,
                                             request_type: str, request_parameters: dict, process_name: str,
                                             request_src_name: str = None, originator_svc_name: str = None,
                                             originator_eng_name: str = None, server: str = None) -> str:
@@ -1639,7 +1718,6 @@ class AutomatedCuration(Client):
                 action_targets (str): Targets of the governance action.
                 received_guards (List[str]): List of guards received for the action.
                 start_time (datetime): The start time for the governance action.
-                gov_engine_name (str): The name of the governance engine associated with the action.
                 request_type (str): The type of the governance action request.
                 request_parameters (dict): Additional parameters for the governance action.
                 process_name (str): The name of the associated governance action process.
@@ -1658,39 +1736,31 @@ class AutomatedCuration(Client):
 
             Note
             ----
-                The `start_time` parameter should be a `datetime` object representing the start time of the governance action.
+                The `start_time` parameter should be a `datetime` object representing the start time of the
+                governance action.
 
 
         """
         server = self.server_name if server is None else server
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/governance-engines/"
                f"engine-actions/initiate")
-        body = {
-            "class": "GovernanceActionRequestBody",
-            "qualifiedName": qualified_name + str(int(start_time.timestamp())),
-            "domainIdentifier": domain_identifier,
-            "displayName": display_name,
-            "description": description,
-            "requestSourceGUIDs": request_source_guids,
-            "actionTargets": action_targets,
-            "receivedGuards": received_guards,
-            "startTime": int(start_time.timestamp() * 1000),
-            "requestType": request_type,
-            "requestParameters": request_parameters,
-            "processName": process_name,
-            "requestSourceName": request_src_name,
-            "originatorServiceName": originator_svc_name,
-            "originatorEngineName": originator_eng_name
-        }
+        body = {"class": "GovernanceActionRequestBody",
+                "qualifiedName": qualified_name + str(int(start_time.timestamp())),
+                "domainIdentifier": domain_identifier,
+                "displayName": display_name, "description": description, "requestSourceGUIDs": request_source_guids,
+                "actionTargets": action_targets, "receivedGuards": received_guards,
+                "startTime": int(start_time.timestamp() * 1000), "requestType": request_type,
+                "requestParameters": request_parameters, "processName": process_name,
+                "requestSourceName": request_src_name,
+                "originatorServiceName": originator_svc_name, "originatorEngineName": originator_eng_name}
         new_body = body_slimmer(body)
         response = await self._async_make_request("POST", url, new_body)
         return response.json().get("guid", "Action not initiated")
 
-    def initiate_engine_action(self, qualified_name: str, domain_identifier: int, display_name: str,
-                               description: str, request_source_guids: str, action_targets: str,
-                               received_guards: [str], start_time: datetime, gov_engine_name: str,
-                               request_type: str, request_parameters: dict, process_name: str,
-                               request_src_name: str = None, originator_svc_name: str = None,
+    def initiate_engine_action(self, qualified_name: str, domain_identifier: int, display_name: str, description: str,
+                               request_source_guids: str, action_targets: str, received_guards: [str],
+                               start_time: datetime, request_type: str, request_parameters: dict,
+                               process_name: str, request_src_name: str = None, originator_svc_name: str = None,
                                originator_eng_name: str = None, server: str = None) -> str:
         """ Create an engine action in the metadata store that will trigger the governance service associated with
             the supplied request type. The engine action remains to act as a record of the actions taken for auditing.
@@ -1724,21 +1794,19 @@ class AutomatedCuration(Client):
 
             Note
             ----
-                The `start_time` parameter should be a `datetime` object representing the start time of the governance action.
+                The `start_time` parameter should be a `datetime` object representing the start time of the
+                governance action.
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_initiate_engine_action(qualified_name, domain_identifier, display_name,
-                                               description, request_source_guids, action_targets,
-                                               received_guards, start_time, gov_engine_name,
+            self._async_initiate_engine_action(qualified_name, domain_identifier, display_name, description,
+                                               request_source_guids, action_targets, received_guards, start_time,
                                                request_type, request_parameters, process_name,
-                                               request_src_name, originator_svc_name,
-                                               originator_eng_name, server)
-        )
+                                               request_src_name, originator_svc_name, originator_eng_name, server))
         return response
 
-    async def _async_get_catalog_targets(self, integ_connector_guid: str, server: str = None,
-                                         start_from: int = 0, page_size: int = max_paging_size) -> list | str:
+    async def _async_get_catalog_targets(self, integ_connector_guid: str, server: str = None, start_from: int = 0,
+                                         page_size: int = max_paging_size) -> list | str:
         """ Retrieve the details of the metadata elements identified as catalog targets with an integration connector.
             Async version.
 
@@ -1766,10 +1834,10 @@ class AutomatedCuration(Client):
                f"{integ_connector_guid}/catalog-targets?startFrom={start_from}&pageSize={page_size}")
 
         response = await self._async_make_request("GET", url)
-        return response.json().get("elements", "no actions")
+        return response.json().get("elements", "no targets")
 
-    def get_catalog_targets(self, integ_connector_guid: str, server: str = None,
-                            start_from: int = 0, page_size: int = max_paging_size) -> list | str:
+    def get_catalog_targets(self, integ_connector_guid: str, server: str = None, start_from: int = 0,
+                            page_size: int = max_paging_size) -> list | str:
         """ Retrieve the details of the metadata elements identified as catalog targets with an integration connector.
 
         Parameters:
@@ -1792,22 +1860,17 @@ class AutomatedCuration(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_catalog_targets(integ_connector_guid, server,
-                                            start_from, page_size)
-        )
+            self._async_get_catalog_targets(integ_connector_guid, server, start_from, page_size))
         return response
 
-    async def _async_get_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str,
-                                        server: str = None) -> dict | str:
-        """ Retrieve a specific catalog target associated with an integration connector.
-            Async version.
+    async def _async_get_catalog_target(self, relationship_guid: str, server: str = None) -> dict | str:
+        """ Retrieve a specific catalog target associated with an integration connector. Further Information:
+            https://egeria-project.org/concepts/integration-connector/ .    Async version.
 
             Parameters:
             ----------
-                integ_connector_guid: str
-                    The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
-                metadata_element_guid: str
-                    The specific metadata element target we want to retrieve.
+                relationship_guid: str
+                    The GUID (Globally Unique Identifier) identifying the catalog targets for an integration connector.
                 server: str, optional
                     The name of the server. If None, will use the default server specified in the instance will be used.
             Returns:
@@ -1822,25 +1885,23 @@ class AutomatedCuration(Client):
                 UserNotAuthorizedException:
             """
         server = self.server_name if server is None else server
-        validate_guid(integ_connector_guid)
-        validate_guid(metadata_element_guid)
+        validate_guid(relationship_guid)
 
-        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/integration-connectors/"
-               f"{integ_connector_guid}/catalog-targets/{metadata_element_guid}")
+        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/catalog-targets/"
+               f"{relationship_guid}")
 
         response = await self._async_make_request("GET", url)
         return response.json().get("element", "no actions")
 
-    def get_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str,
+    def get_catalog_target(self, relationship_guid: str,
                            server: str = None) -> dict | str:
-        """ Retrieve a specific catalog target associated with an integration connector.
+        """ Retrieve a specific catalog target associated with an integration connector.  Further Information:
+            https://egeria-project.org/concepts/integration-connector/ .
 
             Parameters:
             ----------
-                integ_connector_guid: str
-                    The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
-                metadata_element_guid: str
-                    The specific metadata element target we want to retrieve.
+                relationship_guid: str
+                    The GUID (Globally Unique Identifier) identifying the catalog targets for an integration connector.
                 server: str, optional
                     The name of the server. If None, will use the default server specified in the instance will be used.
             Returns:
@@ -1857,15 +1918,13 @@ class AutomatedCuration(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_catalog_target(integ_connector_guid, metadata_element_guid,
-                                           server)
-        )
+            self._async_get_catalog_target(relationship_guid, server))
         return response
 
     async def _async_add_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str,
-                                        catalog_target_name: str, metadata_src_qual_name: str = None, config_properties: dict = None
-                                        , server: str = None) -> None:
-        """ Add a catalog target to an integration connector.
+                                        catalog_target_name: str, metadata_src_qual_name: str = None,
+                                        config_properties: dict = None, server: str = None) -> str:
+        """ Add a catalog target to an integration connector and .
             Async version.
 
             Parameters:
@@ -1884,7 +1943,7 @@ class AutomatedCuration(Client):
                 The name of the server. If None, will use the default server specified in the instance will be used.
             Returns:
             -------
-                None
+                Relationship GUID for the catalog target,
 
             Raises:
             ------
@@ -1899,16 +1958,14 @@ class AutomatedCuration(Client):
 
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/integration-connectors/"
                f"{integ_connector_guid}/catalog-targets/{metadata_element_guid}")
-        body = {
-            "catalogTargetName": catalog_target_name,
-            "metadataSourceQualifiedName": metadata_src_qual_name,
-            "configProperties": config_properties
-        }
-        await self._async_make_request("POST", url, body)
-        return
+        body = {"catalogTargetName": catalog_target_name, "metadataSourceQualifiedName": metadata_src_qual_name,
+                "configProperties": config_properties}
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get('guid', "No Guid returned")
 
     def add_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str, catalog_target_name: str,
-                           metadata_src_qual_name: str = None, config_properties: dict = None, server: str = None) -> None:
+                           metadata_src_qual_name: str = None, config_properties: dict = None,
+                           server: str = None) -> str:
         """ Add a catalog target to an integration connector.
 
             Parameters:
@@ -1937,23 +1994,92 @@ class AutomatedCuration(Client):
             UserNotAuthorizedException:
             """
         loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_add_catalog_target(integ_connector_guid, metadata_element_guid, catalog_target_name,
+                                           metadata_src_qual_name, config_properties, server))
+        return response
+
+    async def _async_update_catalog_target(self, relationship_guid: str,
+                                           catalog_target_name: str, metadata_src_qual_name: str = None,
+                                           config_properties: dict = None, server: str = None) -> None:
+        """ Update a catalog target to an integration connector.
+            Async version.
+
+            Parameters:
+            ----------
+            relationship_guid: str
+                The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
+
+            catalog_target_name : dict
+                Name of the catalog target to add.
+            metadata_src_qual_name: str
+                The qualified name of the metadata source for the catalog target
+            config_properties: dict
+                Configuration properties for the catalog target
+            server: str, optional
+                The name of the server. If None, will use the default server specified in the instance will be used.
+            Returns:
+            -------
+                None
+
+            Raises:
+            ------
+            InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                       this exception is raised with details from the response content.
+            PropertyServerException: If the API response indicates a server side error.
+            UserNotAuthorizedException:
+            """
+        server = self.server_name if server is None else server
+        validate_guid(relationship_guid)
+
+        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/catalog-targets/"
+               f"{relationship_guid}/update")
+        body = {"catalogTargetName": catalog_target_name, "metadataSourceQualifiedName": metadata_src_qual_name,
+                "configProperties": config_properties}
+        response = await self._async_make_request("POST", url, body)
+        return
+
+    def update_catalog_target(self, relationship_guid: str, catalog_target_name: str,
+                              metadata_src_qual_name: str = None, config_properties: dict = None,
+                              server: str = None) -> None:
+        """ Add a catalog target to an integration connector.
+
+            Parameters:
+            ----------
+            relationship_guid: str
+                The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
+            catalog_target_name : dict
+                Name of the catalog target to add.
+            metadata_src_qual_name: str
+                The qualified name of the metadata source for the catalog target
+            config_properties: dict
+                Configuration properties for the catalog target
+            server: str, optional
+                The name of the server. If None, will use the default server specified in the instance will be used.
+            Returns:
+            -------
+                None
+
+            Raises:
+            ------
+            InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                       this exception is raised with details from the response content.
+            PropertyServerException: If the API response indicates a server side error.
+            UserNotAuthorizedException:
+            """
+        loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_catalog_target(integ_connector_guid, metadata_element_guid,
-                                           metadata_src_qual_name, metadata_src_qual_name,
-                                           config_properties, server)
-        )
+            self._async_update_catalog_target(relationship_guid, catalog_target_name,
+                                              metadata_src_qual_name, config_properties, server))
         return
 
-    async def _async_remove_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str,
-                                            server: str = None) -> None:
+    async def _async_remove_catalog_target(self, relationship_guid: str, server: str = None) -> None:
         """ Remove a catalog target to an integration connector. Async version.
 
             Parameters:
             ----------
-            integ_connector_guid: str
-                The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
-            metadata_element_guid: str
-                The specific metadata element target we want to retrieve.
+            relationship_guid: str
+                The GUID (Globally Unique Identifier) identifying the catalog target relationship.
             server: str, optional
                 The name of the server. If None, will use the default server specified in the instance will be used.
             Returns:
@@ -1968,25 +2094,21 @@ class AutomatedCuration(Client):
             UserNotAuthorizedException:
             """
         server = self.server_name if server is None else server
-        validate_guid(integ_connector_guid)
-        validate_guid(metadata_element_guid)
+        validate_guid(relationship_guid)
 
-        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/integration-connectors/"
-               f"{integ_connector_guid}/catalog-targets/{metadata_element_guid}/remove")
+        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/catalog-targets/"
+               f"{relationship_guid}/remove")
 
         await self._async_make_request("POST", url)
         return
 
-    def remove_catalog_target(self, integ_connector_guid: str, metadata_element_guid: str,
-                               server: str = None) -> None:
+    def remove_catalog_target(self, relationship_guid: str, server: str = None) -> None:
         """ Remove a catalog target to an integration connector.
 
             Parameters:
             ----------
-            integ_connector_guid: str
-                The GUID (Globally Unique Identifier) of the integration connector used to retrieve catalog targets.
-            metadata_element_guid: str
-                The specific metadata element target we want to retrieve.
+            relationship_guid: str
+                The GUID (Globally Unique Identifier) identifying the catalog target relationship.
             server: str, optional
                 The name of the server. If None, will use the default server specified in the instance will be used.
             Returns:
@@ -2002,10 +2124,7 @@ class AutomatedCuration(Client):
             """
 
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_remove_catalog_target(integ_connector_guid, metadata_element_guid,
-                                              server)
-        )
+        loop.run_until_complete(self._async_remove_catalog_target(relationship_guid, server))
         return
 
     #
@@ -2045,9 +2164,7 @@ class AutomatedCuration(Client):
         # validate_name(type_name)
         url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/open-metadata-types/"
                f"{type_name}/technology-types?startFrom={start_from}&pageSize={page_size}")
-        body = {
-            "filter": tech_name
-        }
+        body = {"filter": tech_name}
 
         response = await self._async_make_request("GET", url, body)
         return response.json().get("elements", "no tech found")
@@ -2082,9 +2199,7 @@ class AutomatedCuration(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_tech_types_for_open_metadata_type(type_name, tech_name, server,
-                                                              start_from, page_size)
-        )
+            self._async_get_tech_types_for_open_metadata_type(type_name, tech_name, server, start_from, page_size))
         return response
 
     async def _async_get_technology_type_detail(self, type_name: str, server: str = None) -> list | str:
@@ -2095,7 +2210,8 @@ class AutomatedCuration(Client):
         type_name : str
             The name of the technology type to retrieve detailed information for.
         server : str, optional
-            The name of the server to fetch the technology type from. If not provided, the default server name will be used.
+            The name of the server to fetch the technology type from. If not provided, the default server name will
+            be used.
 
         Returns
         -------
@@ -2114,7 +2230,7 @@ class AutomatedCuration(Client):
         More information can be found at: https://egeria-project.org/concepts/deployed-implementation-type
         """
         server = self.server_name if server is None else server
-        validate_name(type_name)
+        # validate_name(type_name)
         url = f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/technology-types/by-name"
 
         body = {"filter": type_name}
@@ -2130,7 +2246,8 @@ class AutomatedCuration(Client):
             type_name : str
                 The name of the technology type to retrieve detailed information for.
             server : str, optional
-                The name of the server to fetch the technology type from. If not provided, the default server name will be used.
+                The name of the server to fetch the technology type from. If not provided, the default server name will
+                be used.
 
             Returns
             -------
@@ -2150,9 +2267,7 @@ class AutomatedCuration(Client):
         """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_technology_type_detail(type_name, server)
-        )
+        response = loop.run_until_complete(self._async_get_technology_type_detail(type_name, server))
         return response
 
     async def _async_find_technology_types(self, search_string: str = "*", server: str = None, start_from: int = 0,
@@ -2214,8 +2329,8 @@ class AutomatedCuration(Client):
         return response.json().get("elements", "no tech found")
 
     def find_technology_types(self, search_string: str = "*", server: str = None, start_from: int = 0,
-                              page_size: int = max_paging_size, starts_with: bool = False,
-                              ends_with: bool = False, ignore_case: bool = True) -> list | str:
+                              page_size: int = max_paging_size, starts_with: bool = False, ends_with: bool = False,
+                              ignore_case: bool = True) -> list | str:
         """ Retrieve the list of technology types that contain the search string. Async version.
 
             Parameters:
@@ -2242,22 +2357,175 @@ class AutomatedCuration(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_technology_types(search_string, server, start_from,
-                                              page_size, starts_with, ends_with, ignore_case)
-        )
+            self._async_find_technology_types(search_string, server, start_from, page_size, starts_with, ends_with,
+                                              ignore_case))
         return response
 
     async def _async_get_all_technology_types(self, server: str = None, start_from: int = 0,
                                               page_size: int = max_paging_size) -> list | str:
+        """Get all technology types - async version"""
         return await self._async_find_technology_types("*", server, start_from, page_size)
 
     def get_all_technology_types(self, server: str = None, start_from: int = 0,
                                  page_size: int = max_paging_size) -> list | str:
+        """Get all technology types"""
         return self.find_technology_types("*", server, start_from, page_size)
 
+    def print_engine_action_summary(self, governance_action: dict):
+        """ print_governance_action_summary
+
+                Print all the governance actions with their status, in the server.
+
+                Parameters
+                ----------
+
+                Returns
+                -------
+
+                Raises
+                ------
+                InvalidParameterException
+                PropertyServerException
+                UserNotAuthorizedException
+                """
+        if governance_action:
+            name = governance_action.get('displayName')
+            if not name:
+                name = governance_action.get('qualifiedName')
+            action_status = governance_action.get('action_status')
+            if governance_action.get('completion_guards'):
+                completion_guards = governance_action.get('completion_guards')
+            else:
+                completion_guards = "\t"
+            if governance_action.get('process_name'):
+                process_name = governance_action.get('process_name')
+            else:
+                process_name = "\t"
+            if governance_action.get('completion_message'):
+                completion_message = governance_action.get('completion_message')
+            else:
+                completion_message = ""
+            print(action_status + "\n\t| " + name + "\t| " + process_name + "\t| " + '%s' % ', '.join(
+                map(str, completion_guards)) + "\t| " + completion_message)
+
+    def print_engine_actions(self):
+        """ print_governance_actions
+
+                Print all the governance actions with their status, in the server.
+
+                Parameters
+                ----------
+
+                Returns
+                -------
+
+                Raises
+                ------
+                InvalidParameterException
+                PropertyServerException
+                UserNotAuthorizedException
+
+        """
+        governance_actions = self.get_engine_actions()
+        if governance_actions is not None:
+            for x in range(len(governance_actions)):
+                self.print_engine_action_summary(governance_actions[x])
+
+    async def _async_get_technology_type_elements(self, filter: str, effective_time: str = None, server: str = None,
+                                                  start_from: int = 0, page_size: int = max_paging_size,
+                                                  get_templates: bool = False) -> list | str:
+        """ Retrieve the elements for the requested deployed implementation type. There are no wildcards allowed
+        in the name. Async version.
+
+        Parameters:
+        ----------
+        filter: str
+            The name of the deployed technology implementation type to retrieve elements for.
+        server: str, optional
+            The name of the server. If None, will use the default server specified in the instance will be used.
+
+        effective_time: datetime, [default=None], optional
+            Effective time of the query. If not specified will default to any effective time. Time format is
+            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+
+        start_from : int, optional
+           The index from which to start fetching the engine actions. Default is 0.
+
+        page_size : int, optional
+           The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+
+        Returns:
+        -------
+            [dict] | str: List of elements describing the technology - or "no tech found" if not found.
+
+        Raises:
+        ------
+        InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                   this exception is raised with details from the response content.
+        PropertyServerException: If the API response indicates a server side error.
+        UserNotAuthorizedException:
+
+        Notes
+        -----
+        For more information see: https://egeria-project.org/concepts/deployed-implementation-type
+        """
+        server = self.server_name if server is None else server
+
+        get_templates_s = str(get_templates).lower()
+        validate_name(filter)
+
+        url = (f"{self.platform_url}/servers/{server}/api/open-metadata/automated-curation/technology-types/elements?"
+               f"startFrom={start_from}&pageSize={page_size}&getTemplates={get_templates_s}"
+               )
+        body = {"filter": filter,
+                "effective_time": effective_time
+                }
+
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("elements", "no tech found")
+
+    def get_technology_type_elements(self, filter: str, effective_time: str = None, server: str = None,
+                                     start_from: int = 0, page_size: int = max_paging_size,
+                                     get_templates: bool = False) -> list | str:
+        """ Retrieve the elements for the requested deployed implementation type. There are no wildcards allowed
+        in the name.
+
+        Parameters:
+        ----------
+        filter: str
+            The name of the deployed technology implementation type to retrieve elements for.
+        server: str, optional
+            The name of the server. If None, will use the default server specified in the instance will be used.
+
+        effective_time: datetime, [default=None], optional
+            Effective time of the query. If not specified will default to any effective time. Time format is
+            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+
+        start_from : int, optional
+           The index from which to start fetching the engine actions. Default is 0.
+
+        page_size : int, optional
+           The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+
+        Returns:
+        -------
+            [dict] | str: List of elements describing the technology - or "no tech found" if not found.
+
+        Raises:
+        ------
+        InvalidParameterException: If the API response indicates an error (non-200 status code),
+                                   this exception is raised with details from the response content.
+        PropertyServerException: If the API response indicates a server side error.
+        UserNotAuthorizedException:
 
-if __name__ == "__main__":
-    p = AutomatedCuration("meow", "https://127.0.0.1:9443", "garygeeke", verify_flag=False)
-    response = p.get_active_engine_actions()
-    out = response.json()
-    print(out)
+        Notes
+        -----
+        For more information see: https://egeria-project.org/concepts/deployed-implementation-type
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_technology_type_elements(filter, effective_time, server,
+                                                     start_from, page_size, get_templates
+                                                     ))
+        return response