pyegeria 5.4.0.22__py3-none-any.whl → 5.4.0.23__py3-none-any.whl

pyegeria/collection_manager.py

@@ -9,7 +9,7 @@ Copyright Contributors to the ODPi Egeria project.
 import asyncio
 import inspect
 from datetime import datetime
-from typing import Optional, Annotated, Literal
+from typing import Optional, Annotated, Literal, Union
 
 from loguru import logger
 from pydantic import ValidationError, Field, HttpUrl
@@ -21,9 +21,11 @@ from pyegeria.load_config import get_app_config
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
                              ReferenceableProperties, InitialClassifications, TemplateRequestBody,
                              UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
-                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody)
+                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody,
+                             get_defined_field_values, PyegeriaModel)
 from pyegeria.output_formatter import (generate_output,
-                                       _extract_referenceable_properties)
+                                       _extract_referenceable_properties, populate_columns_from_properties,
+                                       get_required_relationships)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 
@@ -61,28 +63,39 @@ class CollectionProperties(ReferenceableProperties):
     class_: Annotated[Literal["CollectionProperties"], Field(alias="class")]
 
 
-class DataSpecProperties(ReferenceableProperties):
+class DataSpecProperties(CollectionProperties):
     class_: Annotated[Literal["DataSpecProperties"], Field(alias="class")]
 
 
-class DataDictionaryProperties(ReferenceableProperties):
+class DataDictionaryProperties(CollectionProperties):
     class_: Annotated[Literal["DataDictionaryProperties"], Field(alias="class")]
 
 
-class AgreementProperties(ReferenceableProperties):
+class AgreementProperties(CollectionProperties):
     class_: Annotated[Literal["AgreementProperties"], Field(alias="class")]
     identifier: str | None = None
     user_defined_status: str | None = None
 
+class DigitalSubscriptionProperties(AgreementProperties):
+    class_: Annotated[Literal["DigitalSubscriptionProperties"], Field(alias="class")]
+    support_level: str | None = None
+    service_levels: dict | None = None
 
-class DigitalProductProperties(ReferenceableProperties):
+
+class DigitalProductProperties(CollectionProperties):
+    class_: Annotated[Literal["DigitalProductProperties"], Field(alias="class")]
+    user_defined_status: str | None = None
     product_name: str | None = None
+    identifier: str | None = None
+    introduction_date: datetime | None = None
     maturity: str | None = None
     service_life: str | None = None
-    introduction_date: datetime | None = None
     next_version_date: datetime | None = None
     withdrawal_date: datetime | None = None
-    current_version: str | None = None
+
+class Collections(PyegeriaModel):
+    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, AgreementProperties,
+                      DataSpecProperties, DataDictionaryProperties] = Field(desciminator="class_")
 
 
 class CollectionManager(Client2):
@@ -127,7 +140,8 @@ class CollectionManager(Client2):
 
     @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",
+                                              category: str = None, classification_names: list[str]= None,
+                                              body: dict | FilterRequestBody = 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.
@@ -180,12 +194,10 @@ class CollectionManager(Client2):
         }
 
         """
-        if body is None:
-            body = {}
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/"
-               f"metadata-elements/{parent_guid}/collections?startFrom={start_from}&pageSize={page_size}")
-
+               f"metadata-elements/{parent_guid}/collections")
+        return await self._async_get_name_request(url, body, output_format, output_format_set)
         response = await self._async_make_request("POST", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
@@ -259,7 +271,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_find_collections(self, search_string: str = '*', classification_names: list[str] = None,
+    async def _async_find_collections(self, search_string: str = "*", classification_names: list[str] = None,
+                                      metadata_element_types: list[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_format_set: str | dict = None,
@@ -273,9 +286,11 @@ class CollectionManager(Client2):
         search_string: str
             Search string to match against - None or '*' indicate match against all collections (may be filtered by
             classification).
-        initial_classifications: list[str], optional, default=None
+        classification_names: list[str], optional, default=None
             A list of classification names to filter on - for example, ["DataSpec"], for data specifications. If none,
             then all classifications are returned.
+        metadata_element_types: list[str], optional, default=None
+            A list of metadata element types to filter on - for example, ["DataSpec"], for data specifications. If none,
         starts_with : bool, [default=False], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
@@ -315,6 +330,7 @@ class CollectionManager(Client2):
         response = await self._async_find_request(url, _type="Collection",
                                                   _gen_output=self._generate_collection_output,
                                                   search_string = search_string, classification_names = classification_names,
+                                                  metadata_element_types = metadata_element_types,
                                                   starts_with = starts_with, ends_with = ends_with, ignore_case = ignore_case,
                                                   start_from = start_from, page_size = page_size,
                                                   output_format=output_format, output_format_set=output_format_set,
@@ -323,7 +339,8 @@ class CollectionManager(Client2):
         return response
 
     @dynamic_catch
-    def find_collections(self, search_string: str = '*', classification_names: str = None, starts_with: bool = True,
+    def find_collections(self, search_string: str = '*', classification_names: str = None,
+                         metadata_element_types: list[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_format_set: str | dict = None,
@@ -337,9 +354,12 @@ class CollectionManager(Client2):
         search_string: str
             Search string to match against - None or '*' indicate match against all collections (may be filtered by
             classification).
-        initial_classifications: list[str], optional, default=None
+        classification_names: list[str], optional, default=None
             A list of classification names to filter on - for example, ["DataSpec"], for data specifications. If none,
             then all classifications are returned.
+        metadata_element_types: list[str], optional, default=None
+            A list of metadata element types to filter on - for example, ["DataSpec"], for data specifications. If none,
+            then all metadata element types are returned.
         starts_with : bool, [default=False], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
@@ -374,10 +394,16 @@ class CollectionManager(Client2):
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
+        Args:
+            classification_names ():
+            metadata_element_types ():
+
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_find_collections(search_string, classification_names, starts_with, ends_with, ignore_case,
-                                         start_from, page_size, output_format, output_format_set, body))
+            self._async_find_collections(search_string, classification_names, metadata_element_types,
+                                         starts_with, ends_with, ignore_case,
+                                         start_from, page_size, output_format,
+                                         output_format_set, body))
 
 
     @dynamic_catch
@@ -4843,7 +4869,7 @@ class CollectionManager(Client2):
         Parameters
         ----------
         collection_guid: str
-            The guid of the collection to update.
+            The guid of the collection to delete.
 
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
@@ -4885,13 +4911,13 @@ class CollectionManager(Client2):
 
     def delete_collection(self, collection_guid: str, body: dict | DeleteRequestBody = None,
                           cascade: bool = False) -> None:
-        """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
+        """Delete a collection.  It is deleted from all parent elements.  If members are anchored to the collection
         then they are also deleted.
 
         Parameters
         ----------
         collection_guid: str
-            The guid of the collection to update.
+            The guid of the collection to delete.
 
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
@@ -5352,46 +5378,113 @@ class CollectionManager(Client2):
             self._async_get_member_list(collection_guid, collection_name, collection_qname))
         return resp
 
-
-    def _extract_collection_properties(self, element: dict) -> dict:
+    def _extract_digital_product_properties(self, element: dict, guid: str, output_format: str) -> dict:
+        props = element["properties"]
+        digital_prod = DigitalProductProperties.model_validate(props)
+        added_props = get_defined_field_values(digital_prod)
+
+        used_by_digital_products = element.get("usedByDigitalProducts", "")
+        if isinstance(used_by_digital_products, (list | dict)):
+            used_by_digital_products_list = ""
+            for prod in used_by_digital_products:
+                used_by_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["used_by_digital_products"] = used_by_digital_products_list[:-2]
+
+        uses_digital_products = element.get("usesDigitalProducts", "")
+        if isinstance(uses_digital_products, (list | dict)):
+            uses_digital_products_list = ""
+            for prod in uses_digital_products:
+                uses_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["uses_digital_products"] = uses_digital_products_list[:-2]
+
+        return added_props
+
+    def _extract_agreement_properties(self, element: dict, guid: str, output_format: str) -> dict:
+        props = element["properties"]
+        # agreement = Collections.model_validate(props)
+        # added_props = get_defined_field_values(agreement)
+
+        added_props = {}
+        agreement_items = element.get("agreementItems", "")
+        if isinstance(agreement_items, (list | dict)):
+            agreement_items_list = ""
+            for item in agreement_items:
+                agreement_items_list += f"{item["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["agreementItems"] = agreement_items_list[:-2]
+
+        return added_props
+
+    def _extract_collection_properties(self, element: dict, columns_struct: dict) -> dict:
         """
-        Extract common properties from a collection element.
+        Extract common properties from a collection element and populate into the provided columns_struct.
 
         Args:
             element (dict): The collection element
+            columns_struct (dict): The columns structure to populate
 
         Returns:
-            dict: Dictionary of extracted properties
+            dict: columns_struct with column 'value' fields populated
         """
-
-        props = _extract_referenceable_properties(element)
+        # First, populate from element.properties using the utility
+        col_data = populate_columns_from_properties(element, columns_struct)
+
+        columns_list = col_data.get("formats", {}).get("columns", [])
+
+        # Populate header-derived values
+        header_props = _extract_referenceable_properties(element)
+        for column in columns_list:
+            key = column.get('key')
+            if key in header_props:
+                column['value'] = header_props.get(key)
+            elif isinstance(key, str) and key.lower() == 'guid':
+                column['value'] = header_props.get('GUID')
+
+        # Derived/computed fields
+        # collectionCategories are classifications
         classification_names = ""
-        # classifications = element['elementHeader'].get("classifications", [])
-        for classification in props['classifications']:
+        classifications = element.get('elementHeader', {}).get("collectionCategories", [])
+        for classification in classifications:
             classification_names += f"{classification['classificationName']}, "
-        props["classifications"] = classification_names[:-2]  # why?
+        if classification_names:
+            for column in columns_list:
+                if column.get('key') == 'classifications':
+                    column['value'] = classification_names[:-2]
+                    break
+
+        # Populate requested relationship-based columns generically from top-level keys
+        col_data = get_required_relationships(element, col_data)
 
-        props['mermaid'] = element.get('mermaidGraph', "") or ""
+        # Subject area classification
+        subject_area = element.get('elementHeader', {}).get("subjectArea", "") or ""
+        subj_val = ""
+        if isinstance(subject_area, dict):
+            subj_val = subject_area.get("classificationProperties", {}).get("subjectAreaName", "")
+        for column in columns_list:
+            if column.get('key') == 'subject_area':
+                column['value'] = subj_val
+                break
 
-        member_names = ""
-        members = self.get_member_list(collection_guid=props["GUID"])
-        if isinstance(members, list):
-            for member in members:
-                member_names += f"{member['qualifiedName']}, "
-            props['members'] = member_names[:-2]
-        logger.trace(f"Extracted properties: {props}")
-        return props
+        # Mermaid graph
+        mermaid_val = element.get('mermaidGraph', "") or ""
+        for column in columns_list:
+            if column.get('key') == 'mermaid':
+                column['value'] = mermaid_val
+                break
+
+        logger.trace(f"Extracted/Populated columns: {col_data}")
+
+        return col_data
 
 
     def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],
-                                    classification_name: Optional[str], output_format: str = "DICT",
+                                    element_type_name: Optional[str], output_format: str = "DICT",
                                     output_format_set: dict | str = None) -> 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
+                element_type_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.
@@ -5399,22 +5492,33 @@ class CollectionManager(Client2):
             Returns:
                 Union[str, List[Dict]]: Formatted output as a string or list of dictionaries
         """
-        if classification_name is None:
+        if element_type_name is None:
             entity_type = "Collections"
         else:
-            entity_type = classification_name
+            entity_type = element_type_name
         # First see if the user has specified an output_format_set - either a label or a dict
+        get_additional_props_func  = None
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            if isinstance(output_format_set, dict):
+            elif isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        # If no output_format was set, then use the initial_classifications to lookup the output format
-        elif classification_name:
-            output_formats = select_output_format_set(classification_name, output_format)
+
+        # If no output_format was set, then use the element_type_name to lookup the output format
+        elif element_type_name:
+            output_formats = select_output_format_set(element_type_name, output_format)
         else:
             # fallback to collections or entity type
             output_formats = select_output_format_set(entity_type,output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        if output_formats:
+            get_additional_props_name = output_formats.get("get_additional_props", {}).get("function", None)
+            if isinstance(get_additional_props_name, str):
+                class_name, method_name = get_additional_props_name.split(".")
+                if hasattr(self, method_name):
+                    get_additional_props_func = getattr(self, method_name)
 
         logger.trace(f"Executing generate_collection_output for {entity_type}: {output_formats}")
         return generate_output(
@@ -5423,7 +5527,7 @@ class CollectionManager(Client2):
             entity_type,
             output_format,
             self._extract_collection_properties,
-            None,
+            get_additional_props_func,
             output_formats,
             )
 

pyegeria/collection_manager_omvs.py

@@ -16,7 +16,7 @@ from pyegeria._client import Client
 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 (generate_output,
-                                       _extract_referenceable_properties)
+                                       _extract_referenceable_properties, get_required_relationships)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 
@@ -6431,34 +6431,63 @@ class CollectionManager(Client2):
         return resp
 
 
-    def _extract_collection_properties(self, element: dict) -> dict:
+    def _extract_collection_properties(self, element: dict, columns_struct: dict) -> dict:
         """
-        Extract common properties from a collection element.
+        Extract common properties from a collection element and populate into the provided columns_struct.
 
         Args:
             element (dict): The collection element
+            columns_struct (dict): The columns structure to populate
 
         Returns:
-            dict: Dictionary of extracted properties
+            dict: columns_struct with column 'value' fields populated
         """
-
-        props = _extract_referenceable_properties(element)
-        classification_names = ""
-        # classifications = element['elementHeader'].get("classifications", [])
-        for classification in props['classifications']:
-            classification_names += f"{classification['classificationName']}, "
-        props["classifications"] = classification_names[:-2]  # why?
-
-        props['mermaid'] = element.get('mermaidGraph', "") or ""
-
+        col_data = columns_struct
+        # Populate display/qualified/description etc. from properties via output formatter util not available here,
+        # so we do minimal direct mapping for OMVS variant.
+        props = element.get('properties', {}) or {}
+        columns_list = col_data.get('formats', {}).get('columns', [])
+        
+        # Header props
+        header_props = _extract_referenceable_properties(element)
+        for column in columns_list:
+            key = column.get('key')
+            # from element.properties (camelCase); keys here are snake_case or GUID
+            if isinstance(key, str):
+                if key.lower() == 'guid':
+                    column['value'] = header_props.get('GUID')
+                elif key in header_props:
+                    column['value'] = header_props.get(key)
+                else:
+                    # simple camelCase mapping inline to reduce imports here
+                    snake_parts = key.split('_')
+                    camel = snake_parts[0] + ''.join([p.capitalize() if p.lower() != 'guid' else 'GUID' for p in snake_parts[1:]])
+                    if camel in props:
+                        column['value'] = props.get(camel)
+        
+        # Mermaid graph
+        for column in columns_list:
+            if column.get('key') == 'mermaid':
+                column['value'] = element.get('mermaidGraph', '') or ''
+                break
+        
+        # Members list (uses API call)
         member_names = ""
-        members = self.get_member_list(collection_guid=props["GUID"])
+        members = self.get_member_list(collection_guid=header_props.get('GUID'))
         if isinstance(members, list):
             for member in members:
                 member_names += f"{member['qualifiedName']}, "
-            props['members'] = member_names[:-2]
-        logger.trace(f"Extracted properties: {props}")
-        return props
+            member_names = member_names[:-2]
+        for column in columns_list:
+            if column.get('key') == 'members':
+                column['value'] = member_names
+                break
+        
+        # Populate any additional requested relationship-based columns generically
+        col_data = get_required_relationships(element, col_data)
+        
+        logger.trace(f"Extracted/Populated columns: {col_data}")
+        return col_data
 
 
     def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],

pyegeria/egeria_cat_client.py

@@ -8,7 +8,7 @@ AssetCatalog, CollectionManager, GlossaryManager, and ProjectManager.
 """
 from pyegeria.egeria_my_client import EgeriaMy
 from pyegeria.asset_catalog_omvs import AssetCatalog
-from pyegeria.collection_manager_omvs import CollectionManager
+from pyegeria.collection_manager import CollectionManager
 from pyegeria.glossary_manager_omvs import GlossaryManager
 from pyegeria.project_manager_omvs import ProjectManager
 

pyegeria/egeria_client.py

@@ -15,6 +15,7 @@ for all use cases..using the more role based clients is often appropriate:
 from pyegeria.asset_catalog_omvs import AssetCatalog
 from pyegeria.collection_manager_omvs import CollectionManager
 from pyegeria.glossary_manager_omvs import GlossaryManager
+from pyegeria.governance_officer import GovernanceOfficer
 from pyegeria.project_manager_omvs import ProjectManager
 from pyegeria.automated_curation_omvs import AutomatedCuration
 from pyegeria.classification_manager_omvs import ClassificationManager
@@ -30,6 +31,7 @@ from pyegeria.registered_info import RegisteredInfo
 from pyegeria.valid_metadata_omvs import ValidMetadataManager
 from pyegeria.egeria_config_client import EgeriaConfig
 from pyegeria.data_designer_omvs import DataDesigner
+from pyegeria.governance_officer import GovernanceOfficer
 # from pyegeria.md_processing_utils import render_markdown
 
 
@@ -55,6 +57,7 @@ class Egeria(
     SolutionArchitect,
     EgeriaConfig,
     DataDesigner,
+    GovernanceOfficer
 ):
     """
     Client to issue Runtime status requests.
@@ -129,4 +132,7 @@ class Egeria(
         DataDesigner.__init__(
             self, view_server, platform_url, user_id, user_pwd, token
             )
+        GovernanceOfficer.__init__(
+            self, view_server, platform_url, user_id, user_pwd, token
+            )
 print(Egeria.mro())

pyegeria/egeria_tech_client.py

@@ -15,7 +15,8 @@ from pyegeria.runtime_manager_omvs import RuntimeManager
 from pyegeria.solution_architect_omvs import SolutionArchitect
 from pyegeria.template_manager_omvs import TemplateManager
 from pyegeria.valid_metadata_omvs import ValidMetadataManager
-from pyegeria.governance_officer_omvs import GovernanceOfficer
+from pyegeria.governance_officer import GovernanceOfficer
+from pyegeria.collection_manager import CollectionManager
 
 
 class EgeriaTech(
@@ -31,6 +32,7 @@ class EgeriaTech(
     DataDesigner,
     TemplateManager,
     GovernanceOfficer,
+    CollectionManager
 ):
     """
     Client for technical Egeria users.
@@ -94,6 +96,9 @@ class EgeriaTech(
         GovernanceOfficer.__init__(
             self, view_server, platform_url, user_id, user_pwd, token
             )
+        CollectionManager.__init__(
+            self, view_server, platform_url, user_id, user_pwd, token
+            )
 
 if __name__ == "__main__":
     print("Main-Tech Client")