pyegeria 5.3.10__py3-none-any.whl → 5.4.0.dev3__py3-none-any.whl

pyegeria/collection_manager_omvs.py

@@ -12,18 +12,8 @@ import asyncio
 from pyegeria._client import Client
 from pyegeria._globals import NO_ELEMENTS_FOUND
 from pyegeria._validators import validate_guid, validate_search_string
+from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, generate_output)
 from pyegeria.utils import body_slimmer
-from pyegeria.output_formatter import (
-    extract_mermaid_only, 
-    extract_basic_dict,
-    generate_output,
-    generate_entity_md,
-    generate_entity_md_table,
-    generate_entity_dict,
-    make_preamble,
-    make_md_attribute,
-    MD_SEPARATOR
-)
 
 
 class CollectionManager(Client):
@@ -62,7 +52,7 @@ class CollectionManager(Client):
     #       Retrieving Collections - https://egeria-project.org/concepts/collection
     #
     async def _async_get_attached_collections(self, parent_guid: str, start_from: int = 0,
-            page_size: int = None, ) -> list:
+                                              page_size: int = None, ) -> list:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
 
@@ -143,8 +133,8 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_get_attached_collections(parent_guid, start_from, page_size))
         return resp
 
-    async def _async_get_classified_collections(self, classification: str, start_from: int = 0,
-            page_size: int = None, output_format: str = 'JSON') -> list | str | dict:
+    async def _async_get_classified_collections(self, classification: str, start_from: int = 0, page_size: int = None,
+                                                output_format: str = 'JSON') -> list | str | dict:
         """Returns the list of collections with a particular classification.  These classifications
             are typically "RootCollection", "Folder" or "DigitalProduct". Async version.
 
@@ -193,11 +183,11 @@ class CollectionManager(Client):
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, filter, output_format)
+            return self.generate_collection_output(elements, None, classification, output_format)
         return elements
 
-    def get_classified_collections(self, classification: str, start_from: int = 0,
-            page_size: int = None, output_format:str = 'JSON') -> list | str | dict:
+    def get_classified_collections(self, classification: str, start_from: int = 0, page_size: int = None,
+                                   output_format: str = 'JSON') -> list | str | dict:
         """Returns the list of collections with a particular classification.  These classifications
              are typically "RootCollection", "Folder" or "DigitalProduct".
 
@@ -231,13 +221,14 @@ class CollectionManager(Client):
 
         """
         loop = asyncio.get_event_loop()
-        resp = loop.run_until_complete(self._async_get_classified_collections(classification,
-                                                                              start_from, page_size, output_format))
+        resp = loop.run_until_complete(
+            self._async_get_classified_collections(classification, start_from, page_size, output_format))
         return resp
 
-    async def _async_find_collections(self, search_string: str, effective_time: str = None, starts_with: bool = False,
-            ends_with: bool = False, ignore_case: bool = False, start_from: int = 0, page_size: int = None,
-            output_format: str = 'JSON') -> list | str:
+    async def _async_find_collections(self, search_string: str, as_of_time=None, effective_time: str = None,
+                                      starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
+                                      start_from: int = 0, page_size: int = None, output_format: str = 'JSON',
+                                      output_profile: str = "CORE") -> list | str:
         """Returns the list of collections matching the search string.
             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.
@@ -246,6 +237,8 @@ class CollectionManager(Client):
         ----------
         search_string: str,
             Search string to use to find matching collections. If the search string is '*' then all glossaries returned.
+        as_of_time: str, optional, [default=None]
+            The point in time to use for querying the repository - ISO8601 format.
         effective_time: str, [default=None], optional
             Effective time of the query. If not specified will default to any time. ISO8601 format is assumed.
         starts_with : bool, [default=False], optional
@@ -261,6 +254,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+        output_profile: str, optional, default = "CORE"
+                The desired output profile - BASIC, CORE, FULL
         Returns
         -------
         List | str
@@ -277,6 +272,9 @@ class CollectionManager(Client):
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
+        Args:
+            as_of_time ():
+
         """
 
         if page_size is None:
@@ -290,7 +288,9 @@ class CollectionManager(Client):
         if search_string == "*":
             search_string = None
 
-        body = {"filter": search_string, "effective_time": effective_time}
+        body = {
+            "filter": search_string, "effective_time": effective_time, "asOfTime": as_of_time
+            }
 
         body_s = body_slimmer(body)
         url = (f"{self.collection_command_root}/"
@@ -303,12 +303,13 @@ class CollectionManager(Client):
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, filter, output_format)
+            return self.generate_collection_output(elements, None, None, output_format, output_profile)
         return elements
 
-    def find_collections(self, search_string: str, effective_time: str = None, starts_with: bool = False,
-            ends_with: bool = False, ignore_case: bool = False, start_from: int = 0, page_size: int = None,
-            output_format: str = 'JSON') -> list | str:
+    def find_collections(self, search_string: str, as_of_time: str = None, effective_time: str = None,
+                         starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
+                         start_from: int = 0, page_size: int = None, output_format: str = 'JSON',
+                         output_profile: str = "CORE") -> 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.
@@ -317,6 +318,8 @@ class CollectionManager(Client):
         ----------
         search_string: str,
             Search string to use to find matching collections. If the search string is '*' then all glossaries returned.
+        as_of_time: str, optional, [default=None]
+            The point in time to use for querying the repository - ISO8601 format.
         effective_time: str, [default=None], optional
             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
         starts_with : bool, [default=False], optional
@@ -332,6 +335,8 @@ class CollectionManager(Client):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
+        output_profile: str, optional, default = "CORE"
+                The desired output profile - BASIC, CORE, FULL
         Returns
         -------
         List | str
@@ -351,13 +356,13 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_find_collections(search_string, effective_time, starts_with, ends_with, ignore_case, start_from,
-                page_size, output_format))
+            self._async_find_collections(search_string, as_of_time, effective_time, starts_with, ends_with, ignore_case,
+                                         start_from, page_size, output_format, output_profile))
 
         return resp
 
     async def _async_get_collections_by_name(self, name: str, effective_time: str = None, start_from: int = 0,
-            page_size: int = None, output_format: str = 'JSON') -> list | str:
+                                             page_size: int = None, output_format: str = 'JSON') -> list | str:
         """Returns the list of collections with a particular name.
 
         Parameters
@@ -416,7 +421,7 @@ class CollectionManager(Client):
         return elements
 
     def get_collections_by_name(self, name: str, effective_time: str = None, start_from: int = 0, page_size: int = None,
-            output_format: str = 'JSON') -> list | str:
+                                output_format: str = 'JSON') -> 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.
@@ -459,7 +464,8 @@ class CollectionManager(Client):
         return resp
 
     async def _async_get_collections_by_type(self, collection_type: str, effective_time: str = 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') -> list | str:
         """Returns the list of collections with a particular collectionType. This is an optional text field in the
             collection element.
 
@@ -518,7 +524,7 @@ class CollectionManager(Client):
         return elements
 
     def get_collections_by_type(self, collection_type: str, effective_time: str = None, start_from: int = 0,
-            page_size: int = None, output_format: str = 'JSON') -> list | str:
+                                page_size: int = None, output_format: str = 'JSON') -> 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.
@@ -561,7 +567,7 @@ class CollectionManager(Client):
         return resp
 
     async def _async_get_collection_by_guid(self, collection_guid: str, effective_time: str = None,
-            output_format: str = 'JSON') -> dict | str:
+                                            collection_type: str = None, output_format: str = 'JSON') -> dict | str:
         """Return the properties of a specific collection. Async version.
 
         Parameters
@@ -570,6 +576,8 @@ class CollectionManager(Client):
             unique identifier of the collection.
         effective_time: str, [default=None], optional
             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
+        collection_type: str, default = None, optional
+            type of collection - Data Dictionary, Data Spec, Data Product, etc.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
 
@@ -603,11 +611,11 @@ class CollectionManager(Client):
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, filter, output_format)
+            return self.generate_collection_output(elements, None, collection_type, output_format)
         return elements
 
-    def get_collection_by_guid(self, collection_guid: str, effective_time: str = None,
-            output_format: str = 'JSON') -> dict | str:
+    def get_collection_by_guid(self, collection_guid: str, effective_time: str = None, collection_type: str = None,
+                               output_format: str = 'JSON') -> dict | str:
         """Return the properties of a specific collection.
 
         Parameters
@@ -616,6 +624,8 @@ class CollectionManager(Client):
             unique identifier of the collection.
         effective_time: str, [default=None], optional
             Effective time of the query. If not specified will default to any time.
+        collection_type: str, default = None, optional
+            type of collection - Data Dictionary, Data Spec, Data Product, etc.
         output_format: str, default = "JSON"
                     - one of "DICT", "MERMAID" or "JSON"
 
@@ -638,7 +648,7 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_get_collection_by_guid(collection_guid, effective_time, output_format))
+            self._async_get_collection_by_guid(collection_guid, effective_time, collection_type, output_format))
 
         return resp
 
@@ -796,9 +806,11 @@ class CollectionManager(Client):
         return resp
 
     async def _async_create_collection(self, classification_name: str, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = False,
-            collection_ordering: str = None, order_property_name: str = None, ) -> str:
+                                       parent_relationship_type_name: str, parent_at_end1: bool, display_name: str,
+                                       description: str, collection_type: str, anchor_scope_guid: str = None,
+                                       is_own_anchor: bool = False, collection_ordering: str = None,
+                                       order_property_name: str = None, additional_properties: dict = None,
+                                       extended_properties: dict = None) -> str:
         """Create Collections: https://egeria-project.org/concepts/collection Async version.
 
         Parameters
@@ -832,6 +844,10 @@ class CollectionManager(Client):
              "OTHER"
         order_property_name: str, optional, defaults to "Something"
             Property to use for sequencing if collection_ordering is "OTHER"
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
 
         Returns
@@ -866,6 +882,7 @@ class CollectionManager(Client):
                 "class": "CollectionProperties", "qualifiedName": f"{classification_name}::{display_name}",
                 "name": display_name, "description": description, "collectionType": collection_type,
                 "collectionOrdering": collection_ordering, "orderPropertyName": order_property_name,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
             }
 
@@ -873,9 +890,10 @@ class CollectionManager(Client):
         return resp.json().get("guid", "No GUID returned")
 
     def create_collection(self, classification_name: str, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = False,
-            collection_ordering: str = "OTHER", order_property_name: str = "Something", ) -> str:
+                          parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
+                          collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = False,
+                          collection_ordering: str = None, order_property_name: str = None,
+                          additional_properties: dict = None, extended_properties: dict = None) -> str:
         """Create Collections: https://egeria-project.org/concepts/collection
 
         Parameters
@@ -910,6 +928,10 @@ class CollectionManager(Client):
             "DATE_CREATED", "OTHER"
         order_property_name: str, optional, defaults to "Something"
             Property to use for sequencing if collection_ordering is "OTHER"
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
 
         Returns
@@ -929,13 +951,16 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_create_collection(classification_name, anchor_guid, parent_guid, parent_relationship_type_name,
-                parent_at_end1, display_name, description, collection_type, anchor_scope_guid, is_own_anchor,
-                collection_ordering, order_property_name))
+                                          parent_at_end1, display_name, description, collection_type, anchor_scope_guid,
+                                          is_own_anchor, collection_ordering, order_property_name,
+                                          additional_properties, extended_properties))
         return resp
 
     async def _async_create_root_collection(self, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = False, ) -> str:
+                                            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str,
+                                            description: str, collection_type: str, anchor_scope_guid: str = None,
+                                            is_own_anchor: bool = False, 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 hierarchy. Async version.
 
@@ -962,6 +987,10 @@ class CollectionManager(Client):
             optional GUID of search scope
         is_own_anchor: bool, optional, defaults to False
             Indicates if the collection should be classified as its own anchor or not.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -978,25 +1007,25 @@ class CollectionManager(Client):
 
         """
 
-        is_own_anchor_s = str(is_own_anchor).lower()
-        parent_at_end1_s = str(parent_at_end1).lower()
         url = f"{self.collection_command_root}/root-collection"
 
-        body = {
-            "anchorGUID": anchor_guid, "isOwnAnchor": is_own_anchor_s, "anchorScopeGUID": anchor_scope_guid,
+        body = body_slimmer({
+            "anchorGUID": anchor_guid, "isOwnAnchor": is_own_anchor, "anchorScopeGUID": anchor_scope_guid,
             "parentGUID": parent_guid, "parentRelationshipTypeName": parent_relationship_type_name,
-            "parentAtEnd1": parent_at_end1_s, "collectionProperties": {
-                "class": "CollectionProperties", "qualifiedName": f"root-collection::{display_name}",
+            "parentAtEnd1": parent_at_end1, "collectionProperties": {
+                "class": "CollectionProperties", "qualifiedName": f"RootCollection::{display_name}",
                 "name": display_name, "description": description, "collectionType": collection_type,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
-            }
+            })
 
-        resp = await self._async_make_request("POST", url, body_slimmer(body))
+        resp = await self._async_make_request("POST", url, body)
         return resp.json().get("guid", "No GUID Returned")
 
     def create_root_collection(self, anchor_guid: str, parent_guid: str, parent_relationship_type_name: str,
-            parent_at_end1: bool, display_name: str, description: str, collection_type: str,
-            anchor_scope_guid: str = None, is_own_anchor: bool = False, ) -> str:
+                               parent_at_end1: bool, display_name: str, description: str, collection_type: str,
+                               anchor_scope_guid: str = None, is_own_anchor: bool = False,
+                               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 hierarchy.
 
@@ -1024,6 +1053,10 @@ class CollectionManager(Client):
             optional GUID of search scope
         is_own_anchor: bool, optional, defaults to False
             Indicates if the collection should be classified as its own anchor or not.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1042,14 +1075,16 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_create_root_collection(anchor_guid, parent_guid, parent_relationship_type_name, parent_at_end1,
-                display_name, description, collection_type, anchor_scope_guid, is_own_anchor, ))
+                                               display_name, description, collection_type, anchor_scope_guid,
+                                               is_own_anchor, additional_properties, extended_properties))
         return resp
 
     async def _async_create_data_spec_collection(self, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = True,
-            collection_ordering: str = "OTHER", order_property_name: str = "Something",
-            qualified_name: str = None, ) -> str:
+                                                 parent_relationship_type_name: str, parent_at_end1: bool,
+                                                 display_name: str, description: str, collection_type: str,
+                                                 anchor_scope_guid: str = None, is_own_anchor: bool = True,
+                                                 qualified_name: str = None, additional_properties: dict = None,
+                                                 extended_properties: dict = None) -> str:
         """Create a new collection with the DataSpec classification.  Used to identify a collection of data fields
          and schema types. Async version.
 
@@ -1076,13 +1111,12 @@ class CollectionManager(Client):
             optional GUID of search scope
         is_own_anchor: bool, optional, defaults to False
             Indicates if the collection should be classified as its own anchor or not.
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER",
-            "DATE_CREATED", "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         qualified_name: str, optional, defaults to None
             If not specified, a unique name will be created for the collection.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1099,29 +1133,28 @@ class CollectionManager(Client):
           The principle specified by the user_id does not have authorization for the requested action
         """
 
-        is_own_anchor_s = str(is_own_anchor).lower()
-        parent_at_end1_s = str(parent_at_end1).lower()
         url = f"{self.collection_command_root}/data-spec-collection"
         if qualified_name is None:
             qualified_name = self.__create_qualified_name__("DataSpec", display_name)
 
-        body = {
-            "anchorGUID": anchor_guid, "anchorScopeGUID": anchor_scope_guid, "isOwnAnchor": is_own_anchor_s,
+        body = body_slimmer({
+            "anchorGUID": anchor_guid, "anchorScopeGUID": anchor_scope_guid, "isOwnAnchor": is_own_anchor,
             "parentGUID": parent_guid, "parentRelationshipTypeName": parent_relationship_type_name,
-            "parentAtEnd1": parent_at_end1_s, "collectionProperties": {
+            "parentAtEnd1": parent_at_end1, "collectionProperties": {
                 "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
                 "description": description, "collectionType": collection_type,
-                "collectionOrdering": collection_ordering, "orderPropertyName": order_property_name,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
-            }
+            })
 
-        resp = await self._async_make_request("POST", url, body_slimmer(body))
+        resp = await self._async_make_request("POST", url, body)
         return resp.json().get("guid", "No GUID Returned")
 
     def create_data_spec_collection(self, anchor_guid: str, parent_guid: str, parent_relationship_type_name: str,
-            parent_at_end1: bool, display_name: str, description: str, collection_type: str,
-            anchor_scope_guid: str = None, is_own_anchor: bool = False, collection_ordering: str = "OTHER",
-            order_property_name: str = "Something", qualified_name: str = None, ) -> str:
+                                    parent_at_end1: bool, display_name: str, description: str, collection_type: str,
+                                    anchor_scope_guid: str = None, is_own_anchor: bool = False,
+                                    qualified_name: str = None, additional_properties: dict = None,
+                                    extended_properties: dict = None) -> str:
         """Create a new collection with the DataSpec classification.  Used to identify a collection of data fields
          and schema types.
 
@@ -1148,12 +1181,12 @@ class CollectionManager(Client):
             optional GUID of search scope
         is_own_anchor: bool, optional, defaults to False
             Indicates if the collection should be classified as its own anchor or not.
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED", "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         qualified_name: str, optional, defaults to None
             If not specified, a unique name will be created for the collection.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1172,15 +1205,17 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_create_data_spec_collection(anchor_guid, parent_guid, parent_relationship_type_name,
-                parent_at_end1, display_name, description, collection_type, anchor_scope_guid, is_own_anchor,
-                collection_ordering, order_property_name, qualified_name, ))
+                                                    parent_at_end1, display_name, description, collection_type,
+                                                    anchor_scope_guid, is_own_anchor, qualified_name,
+                                                    additional_properties, extended_properties))
         return resp
 
     async def _async_create_data_dictionary_collection(self, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = True,
-            collection_ordering: str = "OTHER", order_property_name: str = "Something",
-            qualified_name: str = None, ) -> str:
+                                                       parent_relationship_type_name: str, parent_at_end1: bool,
+                                                       display_name: str, description: str, collection_type: str,
+                                                       anchor_scope_guid: str = None, is_own_anchor: bool = True,
+                                                       qualified_name: str = None, additional_properties: dict = None,
+                                                       extended_properties: dict = None) -> str:
         """ Create a new collection with the Data Dictionary classification.  Used to identify a collection of
             data fields that represent a data store collection of common data types. Async version.
 
@@ -1214,6 +1249,11 @@ class CollectionManager(Client):
             Property to use for sequencing if collection_ordering is "OTHER"
         qualified_name: str, optional, defaults to None
             If not specified a qualified name will be generated from the display name and the collection type.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
+
         Returns
         -------
         str - the guid of the created collection
@@ -1241,7 +1281,7 @@ class CollectionManager(Client):
             "parentAtEnd1": parent_at_end1_s, "collectionProperties": {
                 "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
                 "description": description, "collectionType": collection_type,
-                "collectionOrdering": collection_ordering, "orderPropertyName": order_property_name,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties,
                 },
             }
 
@@ -1249,9 +1289,10 @@ class CollectionManager(Client):
         return resp.json().get("guid", "No GUID Returned")
 
     def create_data_dictionary_collection(self, anchor_guid: str, parent_guid: str, parent_relationship_type_name: str,
-            parent_at_end1: bool, display_name: str, description: str, collection_type: str,
-            anchor_scope_guid: str = None, is_own_anchor: bool = False, collection_ordering: str = "OTHER",
-            order_property_name: str = "Something", qualified_name: str = None, ) -> str:
+                                          parent_at_end1: bool, display_name: str, description: str,
+                                          collection_type: str, anchor_scope_guid: str = None,
+                                          is_own_anchor: bool = False, qualified_name: str = None,
+                                          additional_properties: dict = None, extended_properties: dict = None) -> str:
         """Create a new collection with the DataSpec classification.  Used to identify a collection of data fields
          and schema types.
 
@@ -1284,6 +1325,10 @@ class CollectionManager(Client):
             Property to use for sequencing if collection_ordering is "OTHER"
         qualified_name: str, optional, defaults to None
             If not specified a qualified name will be generated from the display name and the collection type.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1302,14 +1347,18 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_create_data_dictionary_collection(anchor_guid, parent_guid, parent_relationship_type_name,
-                parent_at_end1, display_name, description, collection_type, anchor_scope_guid, is_own_anchor,
-                collection_ordering, order_property_name, qualified_name))
+                                                          parent_at_end1, display_name, description, collection_type,
+                                                          anchor_scope_guid, is_own_anchor, qualified_name,
+                                                          additional_properties, extended_properties))
         return resp
 
     async def _async_create_folder_collection(self, anchor_guid: str, parent_guid: str,
-            parent_relationship_type_name: str, parent_at_end1: bool, display_name: str, description: str,
-            collection_type: str, anchor_scope_guid: str = None, is_own_anchor: bool = True,
-            collection_ordering: str = "OTHER", order_property_name: str = "Something", ) -> str:
+                                              parent_relationship_type_name: str, parent_at_end1: bool,
+                                              display_name: str, description: str, collection_type: str,
+                                              anchor_scope_guid: str = None, is_own_anchor: bool = True,
+                                              collection_ordering: str = None, order_property_name: 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 in a collection hierarchy. Async version.
 
@@ -1341,6 +1390,10 @@ class CollectionManager(Client):
             "DATE_CREATED", "OTHER"
         order_property_name: str, optional, defaults to "Something"
             Property to use for sequencing if collection_ordering is "OTHER"
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1368,6 +1421,7 @@ class CollectionManager(Client):
                 "class": "CollectionProperties", "qualifiedName": f"folder-collection::{display_name}",
                 "name": display_name, "description": description, "collectionType": collection_type,
                 "collectionOrdering": collection_ordering, "orderPropertyName": order_property_name,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
             }
 
@@ -1375,9 +1429,10 @@ class CollectionManager(Client):
         return resp.json().get("guid", "No GUID returned")
 
     def create_folder_collection(self, anchor_guid: str, parent_guid: str, parent_relationship_type_name: str,
-            parent_at_end1: bool, display_name: str, description: str, collection_type: str,
-            anchor_scope_guid: str = None, is_own_anchor: bool = True, collection_ordering: str = "OTHER",
-            order_property_name: str = "Something", ) -> str:
+                                 parent_at_end1: bool, display_name: str, description: str, collection_type: str,
+                                 anchor_scope_guid: str = None, is_own_anchor: bool = True,
+                                 collection_ordering: str = None, order_property_name: 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 in a collection hierarchy.
 
@@ -1409,6 +1464,10 @@ class CollectionManager(Client):
             "OTHER"
         order_property_name: str, optional, defaults to "Something"
             Property to use for sequencing if collection_ordering is "OTHER"
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
         Returns
         -------
@@ -1428,8 +1487,9 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_create_folder_collection(anchor_guid, parent_guid, parent_relationship_type_name,
-                parent_at_end1, display_name, description, collection_type, anchor_scope_guid, is_own_anchor,
-                collection_ordering, order_property_name, ))
+                                                 parent_at_end1, display_name, description, collection_type,
+                                                 anchor_scope_guid, is_own_anchor, collection_ordering,
+                                                 order_property_name, additional_properties, extended_properties))
         return resp
 
     async def _async_create_collection_from_template(self, body: dict) -> str:
@@ -1685,8 +1745,10 @@ class CollectionManager(Client):
     # Manage collections
     #
     async def _async_update_collection(self, collection_guid: str, qualified_name: str = None, display_name: str = None,
-            description: str = None, collection_type: str = None, collection_ordering: str = None,
-            order_property_name: str = None, replace_all_props: bool = False, ) -> None:
+                                       description: str = None, collection_type: str = None,
+                                       collection_ordering: str = None, order_property_name: str = None,
+                                       replace_all_props: bool = False, additional_properties: dict = None,
+                                       extended_properties: dict = None) -> None:
         """Update the properties of a collection.  Async version.
 
         Parameters
@@ -1708,9 +1770,11 @@ class CollectionManager(Client):
            Property to use for sequencing if collection_ordering is "OTHER"
         replace_all_props: bool, optional, defaults to False
             Whether to replace all properties in the collection.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
-            If not provided, the server name associated
-           with the instance is used.
 
         Returns
         -------
@@ -1733,15 +1797,17 @@ class CollectionManager(Client):
         body = {
             "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
             "description": description, "collectionType": collection_type, "collectionOrdering": collection_ordering,
-            "orderPropertyName": order_property_name,
+            "orderPropertyName": order_property_name, "additionalProperties": additional_properties,
+            "extendedProperties": extended_properties
             }
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
         return
 
     def update_collection(self, collection_guid, qualified_name: str = None, display_name: str = None,
-            description: str = None, collection_type: str = None, collection_ordering: str = None,
-            order_property_name: str = None, replace_all_props: bool = False, ) -> None:
+                          description: str = None, collection_type: str = None, collection_ordering: str = None,
+                          order_property_name: str = None, replace_all_props: bool = False,
+                          additional_properties: dict = None, extended_properties: dict = None) -> None:
         """Update the properties of a collection.
 
         Parameters
@@ -1763,9 +1829,11 @@ class CollectionManager(Client):
            Property to use for sequencing if collection_ordering is "OTHER"
         replace_all_props: bool, optional, defaults to False
             Whether to replace all properties in the collection.
+        additional_properties: dict, optional, defaults to None
+            User specified Additional properties to add to the collection definition.
+        extended_properties: dict, optional, defaults to None
+            Properties defined by extensions to Egeria types to add to the collection definition.
 
-            If not provided, the server name associated
-           with the instance is used.
 
         Returns
         -------
@@ -1783,7 +1851,8 @@ 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,
-                collection_ordering, order_property_name, replace_all_props, ))
+                                          collection_ordering, order_property_name, replace_all_props,
+                                          additional_properties, extended_properties))
         return
 
     async def _async_update_digital_product(self, collection_guid: str, body: dict, replace_all_props: bool = False, ):
@@ -1893,8 +1962,8 @@ class CollectionManager(Client):
         return
 
     async def _async_attach_collection(self, collection_guid: str, element_guid: str, resource_use: str,
-            resource_use_description: str = None, resource_use_props: dict = None, watch_resources: bool = False,
-            make_anchor: bool = False, ) -> None:
+                                       resource_use_description: str = None, resource_use_props: dict = None,
+                                       watch_resources: bool = False, make_anchor: bool = False, ) -> None:
         """ Connect an existing collection to an element using the ResourceList relationship (0019). Async version.
         Parameters
         ----------
@@ -1943,8 +2012,8 @@ class CollectionManager(Client):
         await self._async_make_request("POST", url, body)
 
     def attach_collection(self, collection_guid: str, element_guid: str, resource_use: str,
-            resource_use_description: str, resource_use_props: dict = None, watch_resources: bool = False,
-            make_anchor: bool = False, ) -> None:
+                          resource_use_description: str, resource_use_props: dict = None, watch_resources: bool = False,
+                          make_anchor: bool = False, ) -> None:
         """Connect an existing collection to an element using the ResourceList relationship (0019).
         Parameters
         ----------
@@ -1983,7 +2052,7 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_attach_collection(collection_guid, element_guid, resource_use, resource_use_description,
-                resource_use_props, watch_resources, make_anchor, ))
+                                          resource_use_props, watch_resources, make_anchor, ))
         return
 
     async def _async_detach_collection(self, collection_guid: str, element_guid: str) -> None:
@@ -2087,7 +2156,7 @@ class CollectionManager(Client):
         await self._async_make_request("POST", url, body)
         return
 
-    def delete_collection(self, collection_guid: str, cascade:bool=False) -> None:
+    def delete_collection(self, collection_guid: str, 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.
 
@@ -2119,7 +2188,8 @@ class CollectionManager(Client):
         return
 
     async def _async_get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-            collection_qname: str = None, start_from: int = 0, page_size: int = None, ) -> list | str:
+                                            collection_qname: str = None, start_from: int = 0,
+                                            page_size: int = None, ) -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
 
         Parameters
@@ -2168,7 +2238,8 @@ class CollectionManager(Client):
         return resp.json().get("elements", NO_ELEMENTS_FOUND)
 
     def get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-            collection_qname: str = None, start_from: int = 0, page_size: int = None, ) -> list | str:
+                               collection_qname: str = None, start_from: int = 0,
+                               page_size: int = None, ) -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
 
                Parameters
@@ -2207,7 +2278,7 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_get_collection_members(collection_guid, collection_name, collection_qname, start_from,
-                page_size, ))
+                                               page_size, ))
 
         return resp
 
@@ -2319,7 +2390,7 @@ class CollectionManager(Client):
         return
 
     async def _async_update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
-            replace_all_props: bool = False, ) -> None:
+                                                  replace_all_props: bool = False, ) -> None:
         """Update an element's membership to a collection. Async version.
 
         Parameters
@@ -2378,7 +2449,7 @@ class CollectionManager(Client):
         return
 
     def update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
-            replace_all_props: bool = False, ) -> None:
+                                     replace_all_props: bool = False, ) -> None:
         """Update an element's membership to a collection.
 
         Parameters
@@ -2501,7 +2572,7 @@ class CollectionManager(Client):
         return
 
     async def _async_get_member_list(self, collection_guid: str = None, collection_name: str = None,
-            collection_qname: str = None, ) -> list | bool:
+                                     collection_qname: str = None, ) -> list | bool:
         """Get the member list for the collection - async version.
         Parameters
         ----------
@@ -2537,26 +2608,21 @@ class CollectionManager(Client):
         # finally, construct a list of  member information
         for member_rel in members:
             member_guid = member_rel["elementHeader"]["guid"]
-            member_resp = await self._async_get_collection_by_guid(member_guid)
-            if isinstance(member_resp,(dict,list)):
-                member = member_resp.get("element", None)
-                if member is None:
-                    continue
-            else:
-                continue
-            # print(json.dumps(member, indent = 4))
-
-            member_instance = {
-                "name": member["properties"]["name"], "qualifiedName": member["properties"]["qualifiedName"],
-                "guid": member["elementHeader"]["guid"], "description": member["properties"]["description"],
-                "collectionType": member["properties"]["collectionType"],
-                }
-            member_list.append(member_instance)
+            # member_resp = await self._async_get_collection_by_guid(member_guid)
+            member = await self._async_get_element_by_guid_(member_guid)
+            if isinstance(member, dict):
+                member_instance = {
+                    "name": member["properties"].get('displayName', ''),
+                    "qualifiedName": member["properties"]["qualifiedName"], "guid": member["elementHeader"]["guid"],
+                    "description": member["properties"].get("description", ''),
+                    "type": member["elementHeader"]["type"]['typeName'],
+                    }
+                member_list.append(member_instance)
 
         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:
+                        collection_qname: str = None, ) -> list | bool:
         """Get the member list for the collection - async version.
         Parameters
         ----------
@@ -2600,25 +2666,22 @@ class CollectionManager(Client):
         description = properties.get("description", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
         collection_type = properties.get("collectionType", "") or ""
-        classifications = "\n* ".join(properties.get("classifications", [])) or ""
+        additional_properties = properties.get("additionalProperties", {}) or {}
+        extended_properties = properties.get("extendedProperties", {}) or {}
+        classifications = ",  ".join(properties.get("classifications", [])) or ""
         # classification_names = ""
         # classifications = element['elementHeader'].get("classifications", [])
         # for classification in classifications:
         #     classification_names += f"{classification['classificationName']}, "
 
-
-
         return {
-            'guid': guid, 
-            'properties': properties, 
-            'display_name': display_name, 
-            'description': description,
-            'qualified_name': qualified_name,
-            'classifications': classifications,
-            'collection_type': collection_type
-        }
+            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
+            'qualified_name': qualified_name, 'classifications': classifications, 'collection_type': collection_type,
+            'additional_properties': additional_properties, 'extended_properties': extended_properties,
+            }
 
-    def generate_basic_structured_output(self, elements, filter, output_format) -> str | list:
+    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.
 
@@ -2639,27 +2702,25 @@ class CollectionManager(Client):
         # 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'},
+            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}
-            ]
-
-            return generate_output(
-                elements=elements,
-                search_string=filter,
-                entity_type="Collection",
-                output_format=output_format,
-                extract_properties_func=self._extract_collection_properties,
-                columns=columns if output_format == 'LIST' else None
-            )
+                {'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)
 
         # Default case
         return None
 
-    def generate_collection_output(self, elements, filter, output_format) -> str | list | dict:
+    def generate_collection_output(self, elements, filter, collection_type: str, output_format,
+                                   output_profile: str = "CORE") -> str | list | dict:
         """
         Generate output in the specified format for the given elements.
 
@@ -2667,11 +2728,18 @@ class CollectionManager(Client):
             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, JSON)
-
+            output_profile: str, optional, default = "CORE"
+                The desired output profile - BASIC, CORE, FULL
         Returns:
             Formatted output as string or list of dictionaries
         """
+        if collection_type is None:
+            entity_type = "Collection"
+        else:
+            entity_type = collection_type
+
         # For LIST and DICT formats, get member information
+
         if output_format in ["LIST", "DICT"]:
             # Get the collection GUID
             collection_guid = None
@@ -2689,7 +2757,7 @@ class CollectionManager(Client):
 
             # For DICT format, include all member information in the result
             if output_format == "DICT":
-                result = self.generate_basic_structured_output(elements, filter, output_format)
+                result = self.generate_basic_structured_output(elements, filter, output_format, collection_type)
                 if isinstance(result, list):
                     for item in result:
                         item['members'] = members
@@ -2701,14 +2769,12 @@ class CollectionManager(Client):
             # For LIST format, add a column with bulleted list of qualified names
             elif output_format == "LIST":
                 # Define columns for LIST format, including the new Members column
-                columns = [
-                    {'name': 'Collection Name', 'key': 'display_name'},
+                columns = [{'name': 'Collection Name', 'key': 'display_name'},
                     {'name': 'Qualified Name', 'key': 'qualified_name'},
                     {'name': 'Collection Type', 'key': 'collection_type'},
                     {'name': 'Description', 'key': 'description', 'format': True},
                     {'name': 'Classifications', 'key': 'classifications'},
-                    {'name': 'Members', 'key': 'members', 'format': True}
-                ]
+                    {'name': 'Members', 'key': 'members', 'format': True}]
 
                 # Create a function to add member information to the properties
                 def get_additional_props(element, guid, output_format):
@@ -2720,24 +2786,18 @@ class CollectionManager(Client):
                     return {'members': member_list}
 
                 # Generate output with the additional properties
-                return generate_output(
-                    elements=elements,
-                    search_string=filter,
-                    entity_type="Collection",
-                    output_format=output_format,
-                    extract_properties_func=self._extract_collection_properties,
-                    get_additional_props_func=get_additional_props,
-                    columns=columns
-                )
 
-        # For FORM, REPORT, JSON formats, keep behavior unchanged
-        return self.generate_basic_structured_output(elements, filter, output_format)
+                return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
+                    output_format=output_format, extract_properties_func=self._extract_collection_properties,
+                    get_additional_props_func=get_additional_props, columns=columns)
 
-    def generate_data_class_output(self, elements, filter, output_format) -> str | list:
-        return self.generate_basic_structured_output(elements, filter, output_format)
+        # For FORM, REPORT, JSON formats, keep behavior unchanged
+        return self.generate_basic_structured_output(elements, filter, output_format, collection_type)
 
-    def generate_data_field_output(self, elements, filter, output_format) -> str | list:
-        return self.generate_basic_structured_output(elements, filter, output_format)
+    # def generate_data_class_output(self, elements, filter, output_format) -> str | list:  #     return
+    # self.generate_basic_structured_output(elements, filter, output_format)  #  # def generate_data_field_output(
+    # self, elements, filter, output_format) -> str | list:  #     return self.generate_basic_structured_output(
+    # elements, filter, output_format)
 
 
 if __name__ == "__main__":