pyegeria 5.4.0.1__py3-none-any.whl → 5.4.0.3__py3-none-any.whl

pyegeria/collection_manager_omvs.py

@@ -7,11 +7,18 @@ Copyright Contributors to the ODPi Egeria project.
 """
 
 import asyncio
+from typing import Dict, Union, List, Optional
+
+from loguru import logger
+
+from pyegeria import select_output_format_set
 from pyegeria._client import Client
-from pyegeria._globals import NO_ELEMENTS_FOUND
+from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
 from pyegeria._validators import validate_guid, validate_search_string
-from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, generate_output, markdown_to_html)
-from pyegeria.utils import body_slimmer
+from pyegeria.output_formatter import (generate_output,
+                                       _extract_referenceable_properties)
+from pyegeria.utils import body_slimmer, dynamic_catch
+
 
 
 def query_seperator(current_string):
@@ -32,10 +39,9 @@ def query_string(params):
             result = f"{result}{query_seperator(result)}{params[i][0]}={params[i][1]}"
     return result
 
+from pyegeria._client_new import Client2
 
-
-
-class CollectionManager(Client):
+class CollectionManager(Client2):
     """
     Maintain and explore the contents of nested collections. These collections can be used to represent digital
     products, or collections of resources for a particular project or team. They can be used to organize assets and
@@ -57,21 +63,28 @@ class CollectionManager(Client):
 
     """
 
+
     def __init__(self, view_server: str, platform_url: str, user_id: str, user_pwd: str = None, token: str = None, ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
 
+
+        Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        result = self.get_platform_origin()
+        logger.info(f"CollectionManager initialized, platform origin is: {result}")
         self.collection_command_root: str = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections")
-        Client.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        #
+        #       Retrieving Collections - https://egeria-project.org/concepts/collection
+        #
 
-    #
-    #       Retrieving Collections - https://egeria-project.org/concepts/collection
-    #
+
+    @dynamic_catch
     async def _async_get_attached_collections(self, parent_guid: str, start_from: int = 0, page_size: int = 0,
-                                              body: dict = None, output_format: str = "JSON") -> list:
+                                              body: dict = None, output_format: str = "JSON",
+                                              output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
 
@@ -88,6 +101,8 @@ class CollectionManager(Client):
             If supplied, adds addition request details - for instance, to filter the results on collectionType
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict = None), optional, default = None
+            The desired output columns/fields to include.
 
         Returns
         -------
@@ -130,14 +145,18 @@ class CollectionManager(Client):
         response = await self._async_make_request("POST", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, None, output_format,
+                                                   output_format_set=output_format_set)
         return elements
 
+
     def get_attached_collections(self, parent_guid: str, start_from: int = 0, page_size: int = 0, body: dict = None,
-                                 output_format: str = "JSON") -> list:
+                                 output_format: str = "JSON", output_format_set: str | dict = None) -> list:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
 
@@ -154,6 +173,8 @@ class CollectionManager(Client):
             If supplied, adds addition request details - for instance, to filter the results on collectionType
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict = None), optional, default = None
+                The desired output columns/fields to include.
 
 
         Returns
@@ -189,12 +210,16 @@ class CollectionManager(Client):
 
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_attached_collections(parent_guid, start_from, page_size, body, output_format))
+            self._async_get_attached_collections(parent_guid, start_from, page_size,
+                                                 body, output_format, output_format_set))
 
+
+    # @dynamic_catch
     async def _async_find_collections_w_body(self, body: dict, classification_name: str = None,
                                              starts_with: bool = True, ends_with: bool = False,
                                              ignore_case: bool = False, start_from: int = 0, page_size: int = 0,
-                                             output_format: str = 'JSON', output_profile: str = "CORE") -> list | str:
+                                             output_format: str = 'JSON',
+                                             output_format_set: str | dict = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
             The search string is located in the request body and is interpreted as a plain string. The full
             body allows complete control including status, asOfTime and effectiveTime.
@@ -220,8 +245,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_profile: str, optional, default = "CORE"
-                The desired output profile - BASIC, CORE, FULL
+         output_format_set: str | dict , optional, default = None
+            - The desired output columns/field options.
         Returns
         -------
         List | str
@@ -259,7 +284,7 @@ class CollectionManager(Client):
         ends_with_s = str(ends_with).lower()
         ignore_case_s = str(ignore_case).lower()
 
-        if classification_name == "*":
+        if classification_name in ["*", "Collections", "Collection"]:
             classification_name = None
 
         body_s = body_slimmer(body)
@@ -273,16 +298,20 @@ class CollectionManager(Client):
         response = await self._async_make_request("POST", url, body_s)
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, classification_name,
+                                                   output_format, output_format_set)
         return elements
 
+
     def find_collections_w_body(self, body: dict, classification_name: str = None, starts_with: bool = True,
                                 ends_with: bool = False, ignore_case: bool = False, start_from: int = 0,
                                 page_size: int = 0, output_format: str = 'JSON',
-                                output_profile: str = "CORE") -> list | str:
+                                output_format_set: str | dict = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
             The search string is located in the request body and is interpreted as a plain string. The full
             body allows complete control including status, asOfTime and effectiveTime.
@@ -308,8 +337,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_profile: str, optional, default = "CORE"
-                The desired output profile - BASIC, CORE, FULL
+         output_format_set: str | dict , optional, default = None
+                The desired output columns.
         Returns
         -------
         List | str
@@ -343,12 +372,14 @@ class CollectionManager(Client):
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_find_collections_w_body(body, classification_name, starts_with, ends_with, ignore_case,
-                                                start_from, page_size, output_format, output_profile))
+                                                start_from, page_size, output_format, output_format_set))
 
+
+    @dynamic_catch
     async def _async_find_collections(self, search_string: str = '*', classification_name: str = None,
                                       starts_with: bool = True, ends_with: bool = False, ignore_case: bool = False,
                                       start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
-                                      output_profile: str = "CORE") -> list | str:
+                                      output_format_set: str | dict = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
             The search string is located in the request body and is interpreted as a plain string. The full
             body allows complete control including status, asOfTime and effectiveTime.
@@ -375,8 +406,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_profile: str, optional, default = "CORE"
-                The desired output profile - BASIC, CORE, FULL
+         output_format_set: str | dict , optional, default = None
+            - The desired output columns/fields to include.
         Returns
         -------
         List | str
@@ -400,12 +431,14 @@ class CollectionManager(Client):
             }
 
         resp = await self._async_find_collections_w_body(body, classification_name, starts_with, ends_with, ignore_case,
-                                                         start_from, page_size, output_format, output_profile)
+                                                         start_from, page_size, output_format, output_format_set)
         return resp
 
+    @dynamic_catch
     def find_collections(self, search_string: str = '*', classification_name: str = None, starts_with: bool = True,
                          ends_with: bool = False, ignore_case: bool = False,
-                        start_from: int = 0, page_size: int = 0, output_format: str = 'JSON', output_profile: str = "CORE") -> list | str:
+                         start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
+                         output_format_set: str | dict = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
             The search string is located in the request body and is interpreted as a plain string. The full
             body allows complete control including status, asOfTime and effectiveTime.
@@ -431,8 +464,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_profile: str, optional, default = "CORE"
-                The desired output profile - BASIC, CORE, FULL
+         output_format_set: str | dict , optional, default = None
+            - The desired output columns/fields to include.
         Returns
         -------
         List | str
@@ -452,11 +485,14 @@ class CollectionManager(Client):
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_find_collections(search_string, classification_name, starts_with, ends_with, ignore_case,
-                                         start_from, page_size, output_format, output_profile))
+                                         start_from, page_size, output_format, output_format_set))
+
 
+    @dynamic_catch
     async def _async_get_collections_by_name(self, name: str, classification_name: str = None, body: dict = None,
                                              start_from: int = 0, page_size: int = 0,
-                                             output_format: str = 'JSON') -> list | str:
+                                             output_format: str = 'JSON',
+                                             output_format_set: str | dict = None) -> list | str:
         """ Returns the list of collections with a particular name.
 
             Parameters
@@ -474,6 +510,9 @@ class CollectionManager(Client):
                 the class instance.
             output_format: str, default = "JSON"
                 - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: dict , optional, default = None
+                The desired output columns/fields to include.
+
             Returns
             -------
             List | str
@@ -505,14 +544,19 @@ class CollectionManager(Client):
         response = await self._async_make_request("POST", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, filter, classification_name, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, filter, classification_name,
+                                                   output_format, output_format_set)
         return elements
 
+
     def get_collections_by_name(self, name: str, classification_name: str = None, body: dict = None,
-                                start_from: int = 0, page_size: int = None, output_format: str = 'JSON') -> list | str:
+                                start_from: int = 0, page_size: int = None, output_format: str = 'JSON',
+                                output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections matching the search string. Async version.
             The search string is located in the request body and is interpreted as a plain string.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -532,6 +576,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -554,11 +600,15 @@ class CollectionManager(Client):
 
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collections_by_name(name, classification_name, body, start_from, page_size, output_format))
+            self._async_get_collections_by_name(name, classification_name, body, start_from, page_size,
+                                                output_format, output_format_set))
+
 
+    @dynamic_catch
     async def _async_get_collections_by_type(self, collection_type: str, classification_name: str = None,
                                              body: dict = None, start_from: int = 0, page_size: int = 0,
-                                             output_format: str = 'JSON') -> list | str:
+                                             output_format: str = 'JSON',
+                                             output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections with a particular collectionType. This is an optional text field in the
             collection element.
 
@@ -578,6 +628,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -630,14 +682,19 @@ class CollectionManager(Client):
         response = await self._async_make_request("POST", url, body_s)
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, filter, collection_type, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, filter, collection_type,
+                                                   output_format, output_format_set)
         return elements
 
+
     def get_collections_by_type(self, collection_type: str, classification_name: str = None, body: dict = None,
-                                start_from: int = 0, page_size: int = 0, output_format: str = 'JSON') -> list | str:
+                                start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
+                                output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections with a particular collectionType. This is an optional text field in the
             collection element.
 
@@ -657,12 +714,14 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
         List | str
 
-        A list of collections the specified collection type. Returns a string if none found.
+        A list of collections of the specified collection type. Returns a string if none found.
 
         Raises
         ------
@@ -694,10 +753,13 @@ class CollectionManager(Client):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_collections_by_type(collection_type, classification_name, body, start_from, page_size,
-                                                output_format))
+                                                output_format, output_format_set))
+
 
+    @dynamic_catch
     async def _async_get_collection_by_guid(self, collection_guid: str, collection_type: str = None, body: dict = None,
-                                            output_format: str = 'JSON') -> dict | str:
+                                            output_format: str = 'JSON',
+                                            output_format_set: str | dict = None) -> dict | str:
         """Return the properties of a specific collection. Async version.
 
         Parameters
@@ -710,6 +772,8 @@ class CollectionManager(Client):
             full request body.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -749,14 +813,18 @@ class CollectionManager(Client):
             response = await self._async_make_request("GET", url)
         elements = response.json().get("element", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, collection_type, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, collection_type,
+                                                   output_format, output_format_set)
         return elements
 
+
     def get_collection_by_guid(self, collection_guid: str, collection_type: str = None, body: dict = None,
-                               output_format: str = 'JSON') -> dict | str:
+                               output_format: str = 'JSON', output_format_set: str | dict = None) -> dict | str:
         """ Return the properties of a specific collection. Async version.
 
             Parameters
@@ -769,6 +837,9 @@ class CollectionManager(Client):
                 full request body.
             output_format: str, default = "JSON"
                 - one of "DICT", "MERMAID" or "JSON"
+         output_format_set: dict , optional, default = None
+                The desired output columns/fields to include.
+
 
             Returns
             -------
@@ -798,11 +869,15 @@ class CollectionManager(Client):
             }
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collection_by_guid(collection_guid, collection_type, body, output_format))
+            self._async_get_collection_by_guid(collection_guid, collection_type, body,
+                                               output_format, output_format_set))
+
 
+    @dynamic_catch
     async def _async_get_collection_members(self, collection_guid: str = None, collection_name: str = None,
                                             collection_qname: str = None, body: dict = None, start_from: int = 0,
-                                            page_size: int = 0, output_format: str = "JSON") -> list | str:
+                                            page_size: int = 0, output_format: str = "JSON",
+                                            output_format_set: str | dict = None) -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
 
         Parameters
@@ -825,6 +900,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -857,7 +934,8 @@ class CollectionManager(Client):
         """
 
         if collection_guid is None:
-            collection_guid = self.__get_guid__(collection_guid, collection_name, "name", collection_qname, None, )
+            collection_guid = self.__get_guid__(collection_guid, collection_name, "name",
+                                                collection_qname, None, )
 
         url = (f"{self.collection_command_root}/{collection_guid}/"
                f"members?startFrom={start_from}&pageSize={page_size}")
@@ -867,17 +945,22 @@ class CollectionManager(Client):
         else:
             response = await self._async_make_request("POST", url)
 
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        elements = response.json().get("elements", NO_MEMBERS_FOUND)
         if type(elements) is str:
-            return NO_ELEMENTS_FOUND
+            logger.trace(f"No elements found for collection {collection_guid}")
+            return NO_MEMBERS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format)
+            logger.debug(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, None,
+                                                   output_format, output_format_set)
         return elements
 
+
     def get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-                               collection_qname: str = None, body: dict = None, start_from: int = 0, page_size: int = 0,
-                               output_format: str = "JSON") -> list | str:
+                               collection_qname: str = None, body: dict = None, start_from: int = 0,
+                               page_size: int = 0,
+                               output_format: str = "JSON", output_format_set: str | dict = None) -> list | str:
         """Return a list of elements that are a member of a collection.
         Parameters
         ----------
@@ -899,6 +982,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -928,63 +1013,68 @@ class CollectionManager(Client):
           "sequencingProperty": ""
         }
 
-        """
+    """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_get_collection_members(collection_guid, collection_name, collection_qname, body, start_from,
-                                               page_size, output_format))
+                                               page_size, output_format, output_format_set))
 
         return resp
 
+
+    @dynamic_catch
     async def _async_get_collection_graph(self, collection_guid: str, body: dict = None, start_from: int = 0,
-                                          page_size: int = 0, output_format: str = "JSON") -> list | str:
+                                          page_size: int = 0, output_format: str = "JSON",
+                                          output_format_set: str | dict = None) -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
-            with elements immediately connected to the starting collection.  The result
-            includes a mermaid graph of the returned elements. Async version.
+                with elements immediately connected to the starting collection.  The result
+                includes a mermaid graph of the returned elements. Async version.
 
-        Parameters
-        ----------
-        collection_guid: str,
-            identity of the collection to return members for. If none, collection_name or
-            collection_qname are used.
-        body: dict, optional, default = None
-            Providing the body allows full control of the request and replaces filter parameters.
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        output_format: str, default = "JSON"
-            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+            Parameters
+            ----------
+            collection_guid: str,
+                identity of the collection to return members for. If none, collection_name or
+                collection_qname are used.
+            body: dict, optional, default = None
+                Providing the body allows full control of the request and replaces filter parameters.
+            start_from: int, [default=0], optional
+                        When multiple pages of results are available, the page number to start from.
+            page_size: int, [default=None]
+                The number of items to return in a single page. If not specified, the default will be taken from
+                the class instance.
+            output_format: str, default = "JSON"
+                - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: dict , optional, default = None
+                The desired output columns/fields to include.
 
-        Returns
-        -------
-        List | str
+            Returns
+            -------
+            List | str
 
-        A graph anchored in the collection.
+            A graph anchored in the collection.
 
-        Raises
-        ------
+            Raises
+            ------
 
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
+            InvalidParameterException
+              If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+            PropertyServerException
+              Raised by the server when an issue arises in processing a valid request
+            NotAuthorizedException
+              The principle specified by the user_id does not have authorization for the requested action
 
-        Notes:
-        -----
-            Body sample:
-            {
-              "class": "ResultsRequestBody",
-              "effectiveTime": "{{$isoTimestamp}}",
-              "limitResultsByStatus": ["ACTIVE"],
-              "asOfTime": "{{$isoTimestamp}}",
-              "sequencingOrder": "CREATION_DATE_RECENT",
-              "sequencingProperty": ""
-            }
-        """
+            Notes:
+            -----
+                Body sample:
+                {
+                  "class": "ResultsRequestBody",
+                  "effectiveTime": "{{$isoTimestamp}}",
+                  "limitResultsByStatus": ["ACTIVE"],
+                  "asOfTime": "{{$isoTimestamp}}",
+                  "sequencingOrder": "CREATION_DATE_RECENT",
+                  "sequencingProperty": ""
+                }
+            """
 
         url = (f"{self.collection_command_root}/{collection_guid}/"
                f"graph?startFrom={start_from}&pageSize={page_size}")
@@ -996,14 +1086,19 @@ class CollectionManager(Client):
 
         elements = response.json().get("graph", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, None,
+                                                   output_format, output_format_set)
         return elements
 
+
     def get_collection_graph(self, collection_guid: str = None, body: dict = None, start_from: int = 0,
-                             page_size: int = 0, output_format: str = "JSON") -> list | str:
+                             page_size: int = 0, output_format: str = "JSON",
+                             output_format_set: str | dict = None) -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
             with elements immediately connected to the starting collection.  The result
             includes a mermaid graph of the returned elements.
@@ -1022,6 +1117,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+         output_format_set: str | dict , optional, default = None
+                The desired output columns/fields to include.
 
         Returns
         -------
@@ -1052,10 +1149,14 @@ class CollectionManager(Client):
             }
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collection_graph(collection_guid, body, start_from, page_size, output_format))
+            self._async_get_collection_graph(collection_guid, body, start_from, page_size,
+                                             output_format, output_format_set))
+
 
+    @dynamic_catch
     async def _async_get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
-                                                 page_size: int = None, output_format: str = "JSON") -> list | str:
+                                                 page_size: int = None, output_format: str = "JSON",
+                                                 output_format_set: str | dict = None) -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
             with elements immediately connected to the starting collection.  The result
             includes a mermaid graph of the returned elements. Async version.
@@ -1073,6 +1174,7 @@ class CollectionManager(Client):
                 the class instance.
             output_format: str, default = "JSON"
                 - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+    output_format_set: dict , optional, default = None
 
             Returns
             -------
@@ -1111,15 +1213,19 @@ class CollectionManager(Client):
         response = await self._async_make_request("GET", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format)
+            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
+            return self.generate_collection_output(elements, None, None,
+                                                   output_format, output_format_set)
         return elements
 
-    def get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
-                                    page_size: int = None, output_format: str = "JSON") -> list | str:
 
+    def get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
+                                    page_size: int = None, output_format: str = "JSON",
+                                    output_format_set: str | dict = None) -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
             with elements immediately connected to the starting collection.  The result
             includes a mermaid graph of the returned elements.
@@ -1137,6 +1243,8 @@ class CollectionManager(Client):
                the class instance.
             output_format: str, default = "JSON"
                - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+             output_format_set: str | dict  , optional, default = None
+                The desired output columns/fields to include.
 
             Returns
             -------
@@ -1167,33 +1275,39 @@ class CollectionManager(Client):
        """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collection_graph_w_body(collection_guid, body, start_from, page_size, output_format))
-
-    #
-    #   Create collection methods
-    #
-
-    ###
-    # =====================================================================================================================
-    # Create Collections: https://egeria-project.org/concepts/collection
-    # These requests use the following parameters:
-    #
-    # anchorGUID - the unique identifier of the element that should be the anchor for the new element. Set to null if
-    # no anchor,
-    # or if this collection is to be its own anchor.
-    #
-    # isOwnAnchor -this element should be classified as its own anchor or not.  The default is false.
-    #
-    # parentGUID - the optional unique identifier for an element that should be connected to the newly created element.
-    # If this property is specified, parentRelationshipTypeName must also be specified
-    #
-    # parentRelationshipTypeName - the name of the relationship, if any, that should be established between the new
-    # element and the parent element.
-    # Examples could be "ResourceList" or "DigitalServiceProduct".
-    #
-    # parentAtEnd1 -identifies which end any parent entity sits on the relationship.
-    #
-
+            self._async_get_collection_graph_w_body(collection_guid, body, start_from,
+                                                    page_size, output_format, output_format_set))
+
+        #
+        #   Create collection methods
+        #
+
+        ###
+        # =====================================================================================================================
+        # Create Collections: https://egeria-project.org/concepts/collection
+        # These requests use the following parameters:
+        #
+        # anchorGUID - the unique identifier of the element that should be the anchor for the new element. Set to
+        # null if
+        # no anchor,
+        # or if this collection is to be its own anchor.
+        #
+        # isOwnAnchor -this element should be classified as its own anchor or not.  The default is false.
+        #
+        # parentGUID - the optional unique identifier for an element that should be connected to the newly
+        # created element.
+        # If this property is specified, parentRelationshipTypeName must also be specified
+        #
+        # parentRelationshipTypeName - the name of the relationship, if any, that should be established between
+        # the new
+        # element and the parent element.
+        # Examples could be "ResourceList" or "DigitalServiceProduct".
+        #
+        # parentAtEnd1 -identifies which end any parent entity sits on the relationship.
+        #
+
+
+    @dynamic_catch
     async def _async_create_collection_w_body(self, body: dict, classification_name: str = None) -> str:
         """ Create a new generic collection.
             Collections: https://egeria-project.org/concepts/collection
@@ -1259,7 +1373,9 @@ class CollectionManager(Client):
         url = f"{self.collection_command_root}{possible_query_params}"
 
         resp = await self._async_make_request("POST", url, body)
-        return resp.json().get("guid", "No GUID returned")
+        logger.info(f"Create collection with GUID: {resp.json().get['guid']}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
+
 
     def create_collection_w_body(self, body: dict, classification_name: str = None, ) -> str:
         """ Create a new generic collection.
@@ -1323,6 +1439,8 @@ class CollectionManager(Client):
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection_w_body(body, classification_name))
 
+
+    @dynamic_catch
     async def _async_create_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
                                        classification_name: str = None, anchor_guid: str = None,
                                        parent_guid: str = None, parent_relationship_type_name: str = None,
@@ -1403,7 +1521,8 @@ class CollectionManager(Client):
             }
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        return resp.json().get("guid", NO_GUID_RETURNED)
+
 
     def create_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
                           classification_name: str = None, anchor_guid: str = None, parent_guid: str = None,
@@ -1460,11 +1579,16 @@ class CollectionManager(Client):
 
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_create_collection(display_name, description, is_own_anchor, classification_name, anchor_guid,
-                                          parent_guid, parent_relationship_type_name, parent_at_end1, collection_type,
+            self._async_create_collection(display_name, description, is_own_anchor, classification_name,
+                                          anchor_guid,
+                                          parent_guid, parent_relationship_type_name, parent_at_end1,
+                                          collection_type,
                                           anchor_scope_guid, additional_properties, extended_properties))
 
-    async def _async_create_generic_collection(self, display_name: str, description: str, qualified_name: str = None,
+
+    @dynamic_catch
+    async def _async_create_generic_collection(self, display_name: str, description: str,
+                                               qualified_name: str = None,
                                                is_own_anchor: bool = True, url_item=None,
                                                classification_name: str = None, anchor_guid: str = None,
                                                parent_guid: str = None, parent_relationship_type_name: str = None,
@@ -1550,8 +1674,12 @@ class CollectionManager(Client):
             }
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
 
+
+    @dynamic_catch
     async def _async_create_root_collection(self, display_name: str, description: str, qualified_name: str = None,
                                             is_own_anchor: bool = True, anchor_guid: str = None,
                                             parent_guid: str = None, parent_relationship_type_name: str = None,
@@ -1560,7 +1688,8 @@ class CollectionManager(Client):
 
                                             additional_properties: dict = None,
                                             extended_properties: dict = None) -> str:
-        """ Create a new collection with the RootCollection classification.  Used to identify the top of a collection
+        """ Create a new collection with the RootCollection classification.  Used to identify the top of a
+        collection
         hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
             Async version.
@@ -1624,6 +1753,7 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_root_collection(self, display_name: str, description: str, qualified_name: str = None,
                                is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                parent_relationship_type_name: str = None, parent_at_end1: bool = True,
@@ -1681,13 +1811,17 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_root_collection(display_name, description, qualified_name, is_own_anchor, anchor_guid,
+            self._async_create_root_collection(display_name, description, qualified_name, is_own_anchor,
+                                               anchor_guid,
                                                parent_guid, parent_relationship_type_name, parent_at_end1,
                                                collection_type, anchor_scope_guid, additional_properties,
                                                extended_properties))
         return resp
 
-    async def _async_create_data_spec_collection(self, display_name: str, description: str, qualified_name: str = None,
+
+    @dynamic_catch
+    async def _async_create_data_spec_collection(self, display_name: str, description: str,
+                                                 qualified_name: str = None,
                                                  is_own_anchor: bool = True, anchor_guid: str = None,
                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
                                                  parent_at_end1: bool = True, collection_type: str = None,
@@ -1745,7 +1879,8 @@ class CollectionManager(Client):
         """
 
         resp = await self._async_create_generic_collection(display_name, description, qualified_name,
-                                                           is_own_anchor=is_own_anchor, url_item="data-spec-collection",
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="data-spec-collection",
                                                            classification_name="DataSpec", anchor_guid=anchor_guid,
                                                            parent_guid=parent_guid,
                                                            parent_relationship_type_name=parent_relationship_type_name,
@@ -1757,6 +1892,7 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_data_spec_collection(self, display_name: str, description: str, qualified_name: str = None,
                                     is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                     parent_relationship_type_name: str = None, parent_at_end1: bool = True,
@@ -1820,6 +1956,8 @@ class CollectionManager(Client):
                                                     additional_properties, extended_properties))
         return resp
 
+
+    @dynamic_catch
     async def _async_create_data_dictionary_collection(self, display_name: str, description: str,
                                                        qualified_name: str = None, is_own_anchor: bool = True,
                                                        anchor_guid: str = None, parent_guid: str = None,
@@ -1893,12 +2031,15 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_data_dictionary_collection(self, display_name: str, description: str, qualified_name: str = None,
-                                          is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
+                                          is_own_anchor: bool = True, anchor_guid: str = None,
+                                          parent_guid: str = None,
                                           parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                           collection_type: str = None, anchor_scope_guid: str = None,
 
-                                          additional_properties: dict = None, extended_properties: dict = None) -> str:
+                                          additional_properties: dict = None,
+                                          extended_properties: dict = None) -> str:
         """ Create a new collection with the DataSpec classification.  Used to identify a collection of data
         structures and
             data fields used to define data requirements for a project or initiative.
@@ -1956,6 +2097,8 @@ class CollectionManager(Client):
                                                           additional_properties, extended_properties))
         return resp
 
+
+    @dynamic_catch
     async def _async_create_folder_collection(self, display_name: str, description: str, qualified_name: str = None,
                                               is_own_anchor: bool = True, anchor_guid: str = None,
                                               parent_guid: str = None, parent_relationship_type_name: str = None,
@@ -1964,7 +2107,8 @@ class CollectionManager(Client):
 
                                               additional_properties: dict = None,
                                               extended_properties: dict = None) -> str:
-        """ Create a new collection with the Folder classification.  This is used to identify the organizing collections
+        """ Create a new collection with the Folder classification.  This is used to identify the organizing
+        collections
             in a collection hierarchy.
             Async version.
 
@@ -2027,13 +2171,15 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_folder_collection(self, display_name: str, description: str, qualified_name: str = None,
                                  is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                  parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                  collection_type: str = None, anchor_scope_guid: str = None,
 
                                  additional_properties: dict = None, extended_properties: dict = None) -> str:
-        """ Create a new collection with the Folder classification.  This is used to identify the organizing collections
+        """ Create a new collection with the Folder classification.  This is used to identify the organizing
+        collections
             in a collection hierarchy.
 
         Parameters
@@ -2083,18 +2229,22 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_folder_collection(display_name, description, qualified_name, is_own_anchor, anchor_guid,
+            self._async_create_folder_collection(display_name, description, qualified_name, is_own_anchor,
+                                                 anchor_guid,
                                                  parent_guid, parent_relationship_type_name, parent_at_end1,
                                                  collection_type, anchor_scope_guid, additional_properties,
                                                  extended_properties))
         return resp
 
+
+    @dynamic_catch
     async def _async_create_context_event_collection(self, display_name: str, description: str,
                                                      qualified_name: str = None, is_own_anchor: bool = True,
                                                      anchor_guid: str = None, parent_guid: str = None,
                                                      parent_relationship_type_name: str = None,
                                                      parent_at_end1: bool = True, collection_type: str = None,
-                                                     anchor_scope_guid: str = None, additional_properties: dict = None,
+                                                     anchor_scope_guid: str = None,
+                                                     additional_properties: dict = None,
                                                      extended_properties: dict = None) -> str:
         """ Create a new collection with the ContextEventCollection classification.  This is used to group context
         events together.
@@ -2161,12 +2311,15 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_context_event_collection(self, display_name: str, description: str, qualified_name: str = None,
-                                        is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
+                                        is_own_anchor: bool = True, anchor_guid: str = None,
+                                        parent_guid: str = None,
                                         parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                         collection_type: str = None, anchor_scope_guid: str = None,
 
-                                        additional_properties: dict = None, extended_properties: dict = None) -> str:
+                                        additional_properties: dict = None,
+                                        extended_properties: dict = None) -> str:
         """ Create a new collection with the ContextEventCollection classification.  This is used to group context
         events together.
             For example, the collection may be a series of events that affect a set of resources.
@@ -2224,13 +2377,18 @@ class CollectionManager(Client):
                                                         additional_properties, extended_properties))
         return resp
 
-    async def _async_create_name_space_collection(self, display_name: str, description: str, qualified_name: str = None,
+
+    @dynamic_catch
+    async def _async_create_name_space_collection(self, display_name: str, description: str,
+                                                  qualified_name: str = None,
                                                   is_own_anchor: bool = True, anchor_guid: str = None,
-                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
+                                                  parent_guid: str = None,
+                                                  parent_relationship_type_name: str = None,
                                                   parent_at_end1: bool = True, collection_type: str = None,
                                                   anchor_scope_guid: str = None, additional_properties: dict = None,
                                                   extended_properties: dict = None) -> str:
-        """ Create a new collection with the Namespace classification.  This is used to group elements that belong to
+        """ Create a new collection with the Namespace classification.  This is used to group elements that
+        belong to
         the same namespace.
          For example, the collection may be a series of processes that are recording OpenLineage under a single
          namespace.
@@ -2283,7 +2441,8 @@ class CollectionManager(Client):
         """
 
         resp = await self._async_create_generic_collection(display_name, description, qualified_name,
-                                                           is_own_anchor=is_own_anchor, url_item="namespace-collection",
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="namespace-collection",
                                                            classification_name="NamespaceCollection",
                                                            anchor_guid=anchor_guid, parent_guid=parent_guid,
                                                            parent_relationship_type_name=parent_relationship_type_name,
@@ -2295,13 +2454,14 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_name_space_collection(self, display_name: str, description: str, qualified_name: str = None,
                                      is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                      parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                      collection_type: str = None, anchor_scope_guid: str = None,
-
                                      additional_properties: dict = None, extended_properties: dict = None) -> str:
-        """ Create a new collection with the Namespace classification.  This is used to group elements that belong to
+        """ Create a new collection with the Namespace classification.  This is used to group elements that
+        belong to
         the same namespace.
          For example, the collection may be a series of processes that are recording OpenLineage under a single
          namespace.
@@ -2358,7 +2518,10 @@ class CollectionManager(Client):
                                                      parent_at_end1, collection_type, anchor_scope_guid))
         return resp
 
-    async def _async_create_event_set_collection(self, display_name: str, description: str, qualified_name: str = None,
+
+    @dynamic_catch
+    async def _async_create_event_set_collection(self, display_name: str, description: str,
+                                                 qualified_name: str = None,
                                                  is_own_anchor: bool = True, anchor_guid: str = None,
                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
                                                  parent_at_end1: bool = True, collection_type: str = None,
@@ -2418,7 +2581,8 @@ class CollectionManager(Client):
         """
 
         resp = await self._async_create_generic_collection(display_name, description, qualified_name,
-                                                           is_own_anchor=is_own_anchor, url_item="event-set-collection",
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="event-set-collection",
                                                            classification_name="EventSetCollection",
                                                            anchor_guid=anchor_guid, parent_guid=parent_guid,
                                                            parent_relationship_type_name=parent_relationship_type_name,
@@ -2430,6 +2594,7 @@ class CollectionManager(Client):
 
         return resp
 
+
     def create_event_set_collection(self, display_name: str, description: str, qualified_name: str = None,
                                     is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                     parent_relationship_type_name: str = None, parent_at_end1: bool = True,
@@ -2493,11 +2658,15 @@ class CollectionManager(Client):
                                                     additional_properties, extended_properties))
         return resp
 
+
+    @dynamic_catch
     async def _async_create_naming_standard_ruleset_collection(self, display_name: str, description: str,
-                                                               qualified_name: str = None, is_own_anchor: bool = True,
+                                                               qualified_name: str = None,
+                                                               is_own_anchor: bool = True,
                                                                anchor_guid: str = None, parent_guid: str = None,
                                                                parent_relationship_type_name: str = None,
-                                                               parent_at_end1: bool = True, collection_type: str = None,
+                                                               parent_at_end1: bool = True,
+                                                               collection_type: str = None,
                                                                anchor_scope_guid: str = None,
                                                                additional_properties: dict = None,
                                                                extended_properties: dict = None) -> str:
@@ -2566,9 +2735,12 @@ class CollectionManager(Client):
 
         return resp
 
-    def create_naming_standard_ruleset_collection(self, display_name: str, description: str, qualified_name: str = None,
+
+    def create_naming_standard_ruleset_collection(self, display_name: str, description: str,
+                                                  qualified_name: str = None,
                                                   is_own_anchor: bool = True, anchor_guid: str = None,
-                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
+                                                  parent_guid: str = None,
+                                                  parent_relationship_type_name: str = None,
                                                   parent_at_end1: bool = True, collection_type: str = None,
                                                   anchor_scope_guid: str = None, additional_properties: dict = None,
                                                   extended_properties: dict = None) -> str:
@@ -2629,9 +2801,12 @@ class CollectionManager(Client):
                                                                   collection_type, anchor_scope_guid))
         return resp
 
-    #
-    #
-    #
+        #
+        #
+        #
+
+
+    @dynamic_catch
     async def _async_create_collection_from_template(self, body: dict) -> str:
         """Create a new metadata element to represent a collection using an existing metadata element as a template.
         The template defines additional classifications and relationships that are added to the new collection.
@@ -2690,7 +2865,10 @@ class CollectionManager(Client):
         url = f"{self.collection_command_root}/from-template"
 
         resp = await self._async_make_request("POST", url, body)
-        return resp.json().get("guid", "No GUID Returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
+
 
     def create_collection_from_template(self, body: dict) -> str:
         """Create a new metadata element to represent a collection using an existing metadata element as a template.
@@ -2747,10 +2925,14 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_collection_from_template(body))
         return resp
 
-    #
-    # Manage collections
-    #
-    async def _async_update_collection(self, collection_guid: str, qualified_name: str = None, display_name: str = None,
+        #
+        # Manage collections
+        #
+
+
+    @dynamic_catch
+    async def _async_update_collection(self, collection_guid: str, qualified_name: str = None,
+                                       display_name: str = None,
                                        description: str = None, collection_type: str = None,
 
                                        additional_properties: dict = None, extended_properties: dict = None,
@@ -2804,6 +2986,8 @@ class CollectionManager(Client):
             }
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
+        logger.info(f"Successfully updated {collection_guid}")
+
 
     def update_collection(self, collection_guid, qualified_name: str = None, display_name: str = None,
                           description: str = None, collection_type: str = None, additional_properties: dict = None,
@@ -2845,10 +3029,13 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_collection(collection_guid, qualified_name, display_name, description, collection_type,
+            self._async_update_collection(collection_guid, qualified_name, display_name, description,
+                                          collection_type,
 
                                           additional_properties, extended_properties, replace_all_props))
 
+
+    @dynamic_catch
     async def _async_update_collection_w_body(self, collection_guid: str, body: dict,
                                               replace_all_props: bool = False) -> None:
         """Update the properties of a collection.  Async version.
@@ -2900,6 +3087,8 @@ class CollectionManager(Client):
 
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
+        logger.info(f"Updated properties of collection {collection_guid}")
+
 
     def update_collection_w_body(self, collection_guid: str, body: dict, replace_all_props: bool = False) -> None:
         """Update the properties of a collection.
@@ -2949,9 +3138,12 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_collection_w_body(collection_guid, body, replace_all_props))
 
-    #
-    #   Digital Products
-    #
+        #
+        #   Digital Products
+        #
+
+
+    @dynamic_catch
     async def _async_create_digital_product(self, body: dict) -> str:
         """ Create a new collection that represents a digital product. To set a lifecycle status
             use a NewDigitalProductRequestBody which has a default status of DRAFT. Using a
@@ -3063,7 +3255,10 @@ class CollectionManager(Client):
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
+
 
     def create_digital_product(self, body: dict) -> str:
         """ Create a new collection that represents a digital product. To set a lifecycle status
@@ -3175,7 +3370,10 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_digital_product(body))
         return resp
 
-    async def _async_update_digital_product(self, collection_guid: str, body: dict, replace_all_props: bool = False, ):
+
+    @dynamic_catch
+    async def _async_update_digital_product(self, collection_guid: str, body: dict,
+                                            replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection. Async version.
 
         Parameters
@@ -3229,6 +3427,8 @@ class CollectionManager(Client):
                f"{collection_guid}/update?replaceAllProperties={replace_all_props_s}")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f'Updated properties of DigitalProduct: {collection_guid}')
+
 
     def update_digital_product(self, collection_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection.
@@ -3280,6 +3480,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product(collection_guid, body, replace_all_props))
 
+
+    @dynamic_catch
     async def _async_update_digital_product_status(self, digital_prod_guid: str, body: dict):
         """Update the status of a DigitalProduct collection. Async version.
 
@@ -3318,11 +3520,14 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{digital_prod_guid}/update=status")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f'Updated status of DigitalProduct: {digital_prod_guid}')
+
 
     def update_digital_product_status(self, digital_prod_guid: str, body: dict):
         """Update the status of a DigitalProduct collection. Async version.
@@ -3364,6 +3569,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product_status(digital_prod_guid, body))
 
+
+    @dynamic_catch
     async def _async_link_digital_product_dependency(self, upstream_digital_prod_guid: str,
                                                      downstream_digital_prod_guid: str, body: dict = None):
         """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
@@ -3412,13 +3619,16 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Linked {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
+
 
     def link_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str,
                                         body: dict = None):
@@ -3468,8 +3678,11 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_link_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid, body))
+            self._async_link_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid,
+                                                        body))
+
 
+    @dynamic_catch
     async def _async_detach_digital_product_dependency(self, upstream_digital_prod_guid: str,
                                                        downstream_digital_prod_guid: str, body: dict = None):
         """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
@@ -3511,14 +3724,18 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached digital product dependency {upstream_digital_prod_guid}, {downstream_digital_prod_guid}")
 
+
+    @dynamic_catch
     async def _async_link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
                                           body: dict = None) -> None:
         """ Attach a product manager to a digital product. Request body is optional.
@@ -3560,13 +3777,16 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Attached digital product manager {digital_prod_manager_guid} to {digital_prod_guid}")
+
 
     def link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict = None):
         """ Link a product manager to a digital product.
@@ -3607,8 +3827,11 @@ class CollectionManager(Client):
             }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
+        loop.run_until_complete(
+            self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
+
 
+    @dynamic_catch
     async def _async_detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
                                             body: dict = None):
         """ Detach a product manager from a digital product. Request body is optional.
@@ -3650,13 +3873,16 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f'Detached product manager {digital_prod_manager_guid} from {digital_prod_guid}')
+
 
     def detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict = None):
         """ Detach a product manager from a digital product. Request body is optional.
@@ -3696,11 +3922,15 @@ class CollectionManager(Client):
             }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
+        loop.run_until_complete(
+            self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
+
+        #
+        # Agreements
+        #
 
-    #
-    # Agreements
-    #
+
+    @dynamic_catch
     async def _async_create_agreement(self, body: dict) -> str:
         """Create a new collection that represents am agreement. Async version.
 
@@ -3790,7 +4020,10 @@ class CollectionManager(Client):
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
+
 
     def create_agreement(self, body: dict) -> str:
         """Create a new collection that represents am agreement. Async version.
@@ -3881,6 +4114,8 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_agreement(body))
         return resp
 
+
+    @dynamic_catch
     async def _async_create_data_sharing_agreement(self, body: dict) -> str:
         """ Create a new collection with the DataSharingAgreement classification.  The collection is typically
             an agreement which may use the NewElementRequestBody, or the NewAgreementRequestBody if the
@@ -3938,11 +4173,15 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/data"
-               f"-sharing-agreement")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/data"
+            f"-sharing-agreement")
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
+
 
     def create_data_sharing_agreement(self, body: dict) -> str:
         """ Create a new collection with the DataSharingAgreement classification.  The collection is typically
@@ -4004,6 +4243,8 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_data_sharing_agreement(body))
         return resp
 
+
+    @dynamic_catch
     async def _async_update_agreement(self, agreement_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the agreement collection. Async version.
 
@@ -4061,6 +4302,8 @@ class CollectionManager(Client):
                f"{agreement_guid}/update?replaceAllProperties={replace_all_props_s}")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f"Updated properties for agreement {agreement_guid}")
+
 
     def update_agreement(self, agreement_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection.
@@ -4116,6 +4359,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product(agreement_guid, body, replace_all_props))
 
+
+    @dynamic_catch
     async def _async_update_agreement_status(self, agreement_guid: str, body: dict):
         """Update the status of an agreement collection. Async version.
 
@@ -4159,6 +4404,8 @@ class CollectionManager(Client):
             f"{agreement_guid}/update-status")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f"Updated status for agreement {agreement_guid}")
+
 
     def update_agreement_status(self, agreement_guid: str, body: dict):
         """Update the status of an agreement collection. Async version.
@@ -4200,8 +4447,11 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_agreement_status(agreement_guid, body))
 
+
+    @dynamic_catch
     async def _async_link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
-        """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT profile);
+        """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT
+        profile);
             actor role (person role, team role or IT profile role); or user identity. Request body is optional.
             Async version.
 
@@ -4254,9 +4504,12 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Attached actor {actor_guid} to agreement {agreement_guid}")
+
 
     def link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
-        """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT profile);
+        """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT
+        profile);
             actor role (person role, team role or IT profile role); or user identity. Request body is optional.
 
 
@@ -4303,6 +4556,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_agreement_actor(agreement_guid, actor_guid, body))
 
+
+    @dynamic_catch
     async def _async_detach_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
         """ Unlink an actor from an agreement. Request body is optional. Async version.
 
@@ -4349,6 +4604,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached agreement actor {actor_guid} from {agreement_guid}")
+
 
     def detach_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
         """ Unlink an actor from an agreement. Request body is optional.
@@ -4390,6 +4647,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_agreement_actor(agreement_guid, actor_guid, body))
 
+
+    @dynamic_catch
     async def _async_link_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
                                          body: dict = None) -> None:
         """ Attach an agreement to an element referenced in its definition. The agreement item element is of type
@@ -4458,6 +4717,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Attached agreement item {agreement_item_guid} to {agreement_guid}")
+
 
     def link_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
         """ Attach an agreement to an element referenced in its definition. The agreement item element is of type
@@ -4521,6 +4782,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_agreement_item(agreement_guid, agreement_item_guid, body))
 
+
+    @dynamic_catch
     async def _async_detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
                                            body: dict = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
@@ -4569,6 +4832,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached agreement item {agreement_item_guid} from {agreement_guid}")
+
 
     def detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
@@ -4610,8 +4875,11 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_agreement_item(agreement_guid, agreement_item_guid, body))
 
+
+    @dynamic_catch
     async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
-        """ Attach an agreement to an external reference element that describes the location of the contract documents.
+        """ Attach an agreement to an external reference element that describes the location of the contract
+        documents.
             Request body is optional. Async version.
 
         Parameters
@@ -4666,9 +4934,12 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Attached agreemenbt {agreement_guid} to contract {external_ref_guid}")
+
 
     def link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
-        """ Attach an agreement to an external reference element that describes the location of the contract documents.
+        """ Attach an agreement to an external reference element that describes the location of the contract
+        documents.
             Request body is optional.
 
         Parameters
@@ -4718,6 +4989,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_contract(agreement_guid, external_ref_guid, body))
 
+
+    @dynamic_catch
     async def _async_detach_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """Detach an external reference to a contract, from an agreement. Request body is optional. Async version.
 
@@ -4765,6 +5038,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached contract: {external_ref_guid} from {agreement_guid}")
+
 
     def detach_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """Detach an external reference to a contract, from an agreement. Request body is optional.
@@ -4806,10 +5081,12 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_contract(agreement_guid, external_ref_guid, body))
 
-    #
-    # Digital Subscriptions
-    #
+        #
+        # Digital Subscriptions
+        #
 
+
+    @dynamic_catch
     async def _async_create_digital_subscription(self, body: dict) -> str:
         """Create a new collection that represents a type of agreement called a digital_subscription. Async version.
 
@@ -4912,7 +5189,10 @@ class CollectionManager(Client):
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
-        return resp.json().get("guid", "No GUID returned")
+        guid = resp.json().get('guid', NO_GUID_RETURNED)
+        logger.info(f"Create collection with GUID: {guid}")
+        return guid
+
 
     def create_digital_subscription(self, body: dict) -> str:
         """Create a new collection that represents a type of agreement called a digital_subscription.
@@ -4985,6 +5265,8 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_digital_subscription(body))
         return resp
 
+
+    @dynamic_catch
     async def _async_update_digital_subscription(self, digital_subscription_guid: str, body: dict,
                                                  replace_all_props: bool = False, ):
         """Update the properties of the digital_subscription collection. Async version.
@@ -5047,6 +5329,8 @@ class CollectionManager(Client):
                f"{digital_subscription_guid}/update?replaceAllProperties={replace_all_props_s}")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f"Updated digital subscription {digital_subscription_guid}")
+
 
     def update_digital_subscription(self, digital_subscription_guid: str, body: dict,
                                     replace_all_props: bool = False, ):
@@ -5104,6 +5388,8 @@ class CollectionManager(Client):
         loop.run_until_complete(
             self._async_update_digital_subscription(digital_subscription_guid, body, replace_all_props))
 
+
+    @dynamic_catch
     async def _async_update_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
         """Update the status of an digital_subscription collection. Async version.
 
@@ -5147,8 +5433,10 @@ class CollectionManager(Client):
             f"{digital_subscription_guid}/update-status")
 
         await self._async_make_request("POST", url, body)
+        logger.info(f"Updated status for DigitalProduct {digital_subscription_guid}")
+
 
-    def update_digital_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
+    def update_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
         """Update the status of an digital_subscription collection. Async version.
 
             Parameters
@@ -5188,6 +5476,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_subscription_status(digital_subscription_guid, body))
 
+
+    @dynamic_catch
     async def _async_link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Attach a subscriber to a subscription.  The subscriber is of type 'Referenceable' to allow digital
             products, team or business capabilities to be the subscriber. The subscription is an element of type
@@ -5243,6 +5533,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Linking subscriber {subscriber_guid} to subscription {subscription_guid}")
+
 
     def link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Attach a subscriber to a subscription.  The subscriber is of type 'Referenceable' to allow digital
@@ -5293,6 +5585,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_subscriber(subscriber_guid, subscription_guid, body))
 
+
+    @dynamic_catch
     async def _async_detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Detach a subscriber from a subscription Request body is optional. Async version.
 
@@ -5339,6 +5633,8 @@ class CollectionManager(Client):
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached subscriber {subscriber_guid} from subscription {subscription_guid}")
+
 
     def detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Detach a subscriber from a subscription. Request body is optional.
@@ -5380,11 +5676,14 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_subscriber(subscriber_guid, subscription_guid, body))
 
-    #
-    #
-    #
+        #
+        #
+        #
+
 
-    async def _async_attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None, make_anchor: bool = False):
+    @dynamic_catch
+    async def _async_attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None,
+                                       make_anchor: bool = False):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
             Async version.
 
@@ -5437,14 +5736,19 @@ class CollectionManager(Client):
 
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
-               f"{parent_guid}/collections/{collection_guid}/attach?makeAchor={make_anchor}")
+        url = (
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
+            f"{parent_guid}/collections/{collection_guid}/attach?makeAchor={make_anchor}")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Attached {collection_guid} to {parent_guid}")
+
 
-    def attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None, make_anchor: bool = False):
+    def attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None,
+                          make_anchor: bool = False):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
 
             Parameters
@@ -5497,8 +5801,11 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_attach_collection(parent_guid, collection_guid, body, make_anchor))
 
+
+    @dynamic_catch
     async def _async_detach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
-        """ Detach an existing collection from an element. If the collection is anchored to the element, it is delete.
+        """ Detach an existing collection from an element. If the collection is anchored to the element,
+        it is delete.
             Async version.
 
         Parameters
@@ -5537,15 +5844,20 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
-               f"{parent_guid}/collections/{collection_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/"
+            f"{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
+            f"{parent_guid}/collections/{collection_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
+        logger.info(f"Detached collection {collection_guid} from {parent_guid}")
+
 
     def detach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
-        """ Detach an existing collection from an element. If the collection is anchored to the element, it is delete.
+        """ Detach an existing collection from an element. If the collection is anchored to the element,
+        it is delete.
 
           Parameters
           ----------
@@ -5584,7 +5896,10 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_collection(parent_guid, collection_guid, body))
 
-    async def _async_delete_collection(self, collection_guid: str, body: dict = None, cascade: bool = False) -> None:
+
+    @dynamic_catch
+    async def _async_delete_collection(self, collection_guid: str, body: dict = None,
+                                       cascade: bool = False) -> None:
         """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
         then they are also deleted. Async version
 
@@ -5633,6 +5948,8 @@ class CollectionManager(Client):
             body = {"class": "NullRequestBody"}
 
         await self._async_make_request("POST", url, body)
+        logger.info(f"Deleted collection {collection_guid} with cascade {cascade}")
+
 
     def delete_collection(self, collection_guid: str, body: dict = None, cascade: bool = False) -> None:
         """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
@@ -5679,6 +5996,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_delete_collection(collection_guid, body, cascade))
 
+
+    @dynamic_catch
     async def _async_add_to_collection(self, collection_guid: str, element_guid: str, body: dict = None, ) -> None:
         """Add an element to a collection.  The request body is optional. Async version.
 
@@ -5740,6 +6059,8 @@ class CollectionManager(Client):
                f"{element_guid}/attach")
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
+        logger.info(f"Added {element_guid} to {collection_guid}")
+
 
     def add_to_collection(self, collection_guid: str, element_guid: str, body: dict = None, ) -> None:
         """Add an element to a collection.  The request body is optional.
@@ -5800,6 +6121,8 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_add_to_collection(collection_guid, element_guid, body))
 
+
+    @dynamic_catch
     async def _async_update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
                                                   replace_all_props: bool = False, ) -> None:
         """Update an element's membership to a collection. Async version.
@@ -5864,6 +6187,8 @@ class CollectionManager(Client):
                f"{element_guid}/update?replaceAllProperties={replace_all_props_s}")
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
+        logger.info(f"Updated membership for collection {collection_guid}")
+
 
     def update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
                                      replace_all_props: bool = False, ) -> None:
@@ -5927,7 +6252,10 @@ class CollectionManager(Client):
         loop.run_until_complete(
             self._async_update_collection_membership(collection_guid, element_guid, body, replace_all_props))
 
-    async def _async_remove_from_collection(self, collection_guid: str, element_guid: str, body: dict = None) -> None:
+
+    @dynamic_catch
+    async def _async_remove_from_collection(self, collection_guid: str, element_guid: str,
+                                            body: dict = None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -5971,6 +6299,8 @@ class CollectionManager(Client):
         if body is None:
             body = {"class": "NullRequestBody"}
         await self._async_make_request("POST", url, body)
+        logger.info(f"Removed member {element_guid} from collection {collection_guid}")
+
 
     def remove_from_collection(self, collection_guid: str, element_guid: str, body: dict = None) -> None:
         """Remove an element from a collection. Async version.
@@ -6013,10 +6343,12 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_remove_from_collection(collection_guid, element_guid, body))
 
-    #
-    #
-    #
+        #
+        #
+        #
+
 
+    @dynamic_catch
     async def _async_get_member_list(self, collection_guid: str = None, collection_name: str = None,
                                      collection_qname: str = None, ) -> list | str:
         """Get the member list for the collection - async version.
@@ -6050,6 +6382,7 @@ class CollectionManager(Client):
         member_list = []
         members = await self._async_get_collection_members(collection_guid, collection_name, collection_qname)
         if (type(members) is str) or (len(members) == 0):
+            logger.trace(f"No members found for collection {collection_guid}")
             return "No members found"
         # finally, construct a list of  member information
         for member_rel in members:
@@ -6063,12 +6396,13 @@ class CollectionManager(Client):
                     "type": member["elementHeader"]["type"]['typeName'],
                     }
                 member_list.append(member_instance)
-
+        logger.debug(f"Member list for collection {collection_guid}: {member_list}")
         return member_list if len(member_list) > 0 else "No members found"
 
+
     def get_member_list(self, collection_guid: str = None, collection_name: str = None,
                         collection_qname: str = None, ) -> list | bool:
-        """Get the member list for the collection - async version.
+        """Get the member list for a collection - async version.
         Parameters
         ----------
         collection_guid: str,
@@ -6092,9 +6426,11 @@ class CollectionManager(Client):
 
         """
         loop = asyncio.get_event_loop()
-        resp = loop.run_until_complete(self._async_get_member_list(collection_guid, collection_name, collection_qname))
+        resp = loop.run_until_complete(
+            self._async_get_member_list(collection_guid, collection_name, collection_qname))
         return resp
 
+
     def _extract_collection_properties(self, element: dict) -> dict:
         """
         Extract common properties from a collection element.
@@ -6105,129 +6441,71 @@ class CollectionManager(Client):
         Returns:
             dict: Dictionary of extracted properties
         """
-        guid = element['elementHeader'].get("guid", None)
-        properties = element['properties']
-        display_name = properties.get("name", "") or ""
-        description = properties.get("description", "") or ""
-        qualified_name = properties.get("qualifiedName", "") or ""
-        collection_type = properties.get("collectionType", "") or ""
-        additional_properties = properties.get("additionalProperties", {}) or {}
-        extended_properties = properties.get("extendedProperties", {}) or {}
+
+        props = _extract_referenceable_properties(element)
         classification_names = ""
-        classifications = element['elementHeader'].get("classifications", [])
-        for classification in classifications:
+        # classifications = element['elementHeader'].get("classifications", [])
+        for classification in props['classifications']:
             classification_names += f"{classification['classificationName']}, "
-        classification_names = classification_names[:-2]
-        mermaid = element.get('mermaidGraph', "") or ""
+        props["classifications"] = classification_names[:-2]  # why?
+
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
 
         member_names = ""
-        members = self.get_member_list(collection_guid=guid)
+        members = self.get_member_list(collection_guid=props["GUID"])
         if isinstance(members, list):
             for member in members:
                 member_names += f"{member['qualifiedName']}, "
-            member_names = member_names[:-2]
-
-        return {
-            'GUID': guid, 'display_name': display_name, 'qualified_name': qualified_name, 'description': description,
-            'classifications': classification_names, 'collection_type': collection_type, 'members': member_names,
-            'properties': properties, 'additional_properties': additional_properties,
-            'extended_properties': extended_properties, 'mermaid': mermaid
-            }
-
-    def generate_basic_structured_output(self, elements, filter, output_format: str = 'DICT',
-                                         collection_type: str = None) -> str | list:
-        """
-        Generate output in the specified format for the given elements.
-
-        Args:
-            elements: Dictionary or list of dictionaries containing element data
-            filter: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
-
-        Returns:
-            Formatted output as string or list of dictionaries
-        """
-        # Handle MERMAID and DICT formats using existing methods
-        if output_format == "MERMAID":
-            return extract_mermaid_only(elements)
-        elif output_format == "DICT":
-            return extract_basic_dict(elements)
-        elif output_format == "HTML":
-            if collection_type is None:
-                entity_type = "Collection"
-            else:
-                entity_type = collection_type
-
-            return generate_output(
-                elements=elements, 
-                search_string=filter, 
-                entity_type=entity_type,
-                output_format="HTML",
-                extract_properties_func=self._extract_collection_properties
-            )
-
-        # For other formats (MD, FORM, REPORT, LIST), use generate_output
-        elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
-            # Define columns for LIST format
-            columns = [{'name': 'Collection Name', 'key': 'display_name'},
-                       {'name': 'Qualified Name', 'key': 'qualified_name'},
-                       {'name': 'Collection Type', 'key': 'collection_type'},
-                       {'name': 'Classifications', 'key': 'classifications'},
-                       {'name': 'Description', 'key': 'description', 'format': True}]
-            if collection_type is None:
-                entity_type = "Collection"
-            else:
-                entity_type = collection_type
-
-            return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
-                                   output_format=output_format,
-                                   extract_properties_func=self._extract_collection_properties,
-                                   columns=columns if output_format == 'LIST' else None)
-
-    def generate_collection_output(self, elements, filter, classification_name, output_format) -> str | list:
-        """
-        Generate output for collections in the specified format.
-
-        Args:
-            elements: Dictionary or list of dictionaries containing data field elements
-            classification_name: str
-                The type of collection.
-            filter: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
-
-        Returns:
-            Formatted output as a string or list of dictionaries
+            props['members'] = member_names[:-2]
+        logger.trace(f"Extracted properties: {props}")
+        return props
+
+
+    def generate_collection_output(self, elements: Union[Dict, List[Dict]], filter: Optional[str],
+                                   classification_name: Optional[str], output_format: str = "DICT",
+                                   output_format_set: Optional[dict] | str = None) -> Union[str, List[Dict]]:
+        """ Generate output for collections in the specified format.
+
+            Args:
+                elements (Union[Dict, List[Dict]]): Dictionary or list of dictionaries containing data field elements
+                filter (Optional[str]): The search string used to find the elements
+                classification_name (Optional[str]): The type of collection
+                output_format (str): The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
+                output_format_set (Optional[dict], optional): List of dictionaries containing column data. Defaults
+                to None.
+
+            Returns:
+                Union[str, List[Dict]]: Formatted output as a string or list of dictionaries
         """
         if classification_name is None:
-            entity_type = "Collection"
+            entity_type = "Collections"
         else:
             entity_type = classification_name
-
-        if output_format == "HTML":
-            return generate_output(
-                elements=elements, 
-                search_string=filter, 
-                entity_type=entity_type,
-                output_format="HTML",
-                extract_properties_func=self._extract_collection_properties
+        # First see if the user has specified an output_format_set - either a label or a dict
+        if output_format_set:
+            if isinstance(output_format_set, str):
+                output_formats = select_output_format_set(entity_type, output_format)
+            if isinstance(output_format_set, dict):
+                output_formats = output_format_set
+
+        # If no output_format was set, then use the classification_name to lookup the output format
+        elif classification_name:
+            output_formats = select_output_format_set(classification_name, output_format)
+        else:
+            output_formats = None
+        logger.trace(f"Executing generate_collection_output for {entity_type}: {output_formats}")
+        return generate_output(
+            elements,
+            filter,
+            entity_type,
+            output_format,
+            self._extract_collection_properties,
+            None,
+            output_formats,
             )
 
-        elif output_format in ["MD", "FORM", "REPORT", "LIST", "DICT", "MERMAID"]:
-            # Define columns for LIST format
-            columns = [{'name': 'Name', 'key': 'display_name'},
-                       {'name': 'Qualified Name', 'key': 'qualified_name', 'format': True},
-                       {'name': 'Collection Type', 'key': 'collection_type'},
-                       {'name': 'Description', 'key': 'description', 'format': True},
-                       {'name': "Classifications", 'key': 'classifications'},
-                       {'name': 'Members', 'key': 'members', 'format': True}, ]
-
-            return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
-                                   output_format=output_format,
-                                   extract_properties_func=self._extract_collection_properties,
-                                   columns=columns if output_format == 'LIST' else None)
-        else:
-            return self.generate_basic_structured_output(elements, filter, output_format)
 
+from typing import Union, Dict, List, Optional
 
 if __name__ == "__main__":
     print("Main-Collection Manager")