pyegeria 5.4.0.25__py3-none-any.whl → 5.4.0.27__py3-none-any.whl

pyegeria/data_designer.py

@@ -21,7 +21,6 @@ from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequ
 from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict)
 from pyegeria.output_formatter import (generate_output,
                                        _extract_referenceable_properties)
-from pyegeria.output_formatter import (populate_columns_from_properties, get_required_relationships)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 
@@ -4683,136 +4682,118 @@ class DataDesigner(Client2):
 
 
 
-    def _extract_data_structure_properties(self, element: dict, columns_struct: dict) -> dict:
+    def _extract_data_structure_properties(self, element: dict) -> dict:
         """
-        Populate columns_struct values for a Data Structure element using a standardized approach.
+        Extract common properties from a data structure element.
 
-        - Populate values from element.properties via populate_columns_from_properties
-        - Overlay header-derived values using _extract_referenceable_properties
-        - Derive classifications as a comma-separated list
-        - Populate relationship-based columns using get_required_relationships
-        - Populate mermaid graph if requested
+        Args:
+            element (dict): The data structure element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+
+        props['properties'] = element.get('properties', {})
+
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_specs'] = associated_elements.get("member_of_data_spec_qnames", [])
+
+        # data_structures = associated_elements.get("member_of_data_struct_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['member_data_fields'] = associated_elements.get("member_data_field_qnames", [])
 
-        Returns the updated columns_struct.
-        """
-        # Start with properties-based values
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        # 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')
-
-        # Classifications (names only)
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationship-derived values (generic)
-        col_data = get_required_relationships(element, col_data)
-
-        # Mermaid graph
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
-
-    def _extract_data_class_properties(self, element: dict, columns_struct: dict) -> dict:
-        """
-        Populate columns_struct values for a Data Class element using the standardized approach.
-
-        Uses properties population, header overlay, classifications, generic relationships,
-        and mermaid graph assignment similar to collection_manager.
-        """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        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')
-
-        # Classifications from header
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationships and mermaid
-        col_data = get_required_relationships(element, col_data)
-
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
-
-    def _extract_data_field_properties(self, element: dict, columns_struct: dict) -> dict:
-        """
-        Populate columns_struct values for a Data Field element using the standardized approach.
-
-        Populates from properties, overlays header values, derives classifications, uses
-        get_required_relationships for relationships, and adds mermaid graph.
-        """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        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')
-
-        # Classifications from header
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationships and mermaid
-        col_data = get_required_relationships(element, col_data)
-
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
+
+    def _extract_data_class_properties(self, element: dict) -> dict:
+        """
+        Extract common properties from a data class element.
+
+        Args:
+            element (dict): The data class element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+        properties = element.get('properties', {})
+        props['properties'] = properties
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+
+        props['data_type'] = properties.get('dataType', "") or ""
+        props['match_property_names'] = properties.get('matchPropertyNames', []) or []
+        props['match_threshold'] = properties.get('matchThreshold', 0)
+        props['allow_duplicate_values'] = properties.get('allowDuplicateValues', False)
+        props['is_case_sensitive'] = properties.get('isCaseSensitive', False)
+        props['is_nullable'] = properties.get('isNullable', False)
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_dictionaries'] = associated_elements.get("member_of_data_dicts_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['nested_data_classes'] = associated_elements.get("nested_data_class_qnames", [])
+        props['specialized_data_classes'] = associated_elements.get("specialized_data_class_qnames", [])
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
+
+    def _extract_data_field_properties(self, element: dict) -> dict:
+        """
+        Extract common properties from a data field element.
+
+        Args:
+            element (dict): The data field element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+
+        props['properties'] = element.get('properties', {})
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+        properties = element.get('properties', {})
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        props['is_nullable'] = properties.get('isNullable', False)
+        props['data_type'] = properties.get('dataType', "") or ""
+        props['minimum_length'] = properties.get('minimumLength', 0)
+        props['length'] = properties.get('length', 0)
+        props['precision'] = properties.get('precision', 0)
+        props['ordered_values'] = properties.get('orderedValues', False)
+        props['sort_order'] = properties.get('sortOrder', "") or ""
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_dictionaries'] = associated_elements.get("member_of_data_dicts_qnames", [])
+        props['data_structures'] = associated_elements.get("data_structure_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['data_class'] = associated_elements.get("data_class_qnames", [])
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
 
     def _generate_basic_structured_output(self, elements: dict, filter: str, output_format: str,
                                           columns_struct: dict = None) -> str | list:
@@ -4857,7 +4838,6 @@ class DataDesigner(Client2):
                                    )
 
     def _generate_data_structure_output(self, elements: dict | list[dict], filter: str = None,
-                                        element_type_name: str | None = None,
                                         output_format: str = "DICT",
                                         output_format_set: str | dict = None) -> str | list:
         """
@@ -4866,43 +4846,33 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data structure elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
 
         Returns:
             Formatted output as string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Structure"
+        entity_type = "Data Structure"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
 
-        # 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(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if 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 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 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)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_structure_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_structure_properties,
-            None,
-            output_formats,
-        )
-
-    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None,
-                                    element_type_name: str | None = None,
-                                    output_format: str = "DICT",
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_structure_properties,
+                               None,
+                               output_formats,
+                               )
+
+    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data classes in the specified format.
@@ -4910,40 +4880,34 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data class elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
             output_format_set: Optional output format set
                 - Option column/attribute selection and definition.
         Returns:
             Formatted output as either a string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Class"
+        entity_type = "Data Class"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
+
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        elif element_type_name:
-            output_formats = select_output_format_set(element_type_name, output_format)
         else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_class_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_class_properties,
-            None,
-            output_formats,
-        )
-
-    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None,
-                                    element_type_name: str | None = None,
-                                    output_format: str = "DICT",
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_class_properties,
+                               None,
+                               output_formats,
+                               )
+
+    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data fields in the specified format.
@@ -4951,7 +4915,6 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data field elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
             output_format_set: str|dict, Optional, default = None
             - Option column/attribute selection and definition.
@@ -4959,29 +4922,26 @@ class DataDesigner(Client2):
         Returns:
             Formatted output as a string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Field"
+        entity_type = "Data Field"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
+
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        elif element_type_name:
-            output_formats = select_output_format_set(element_type_name, output_format)
         else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_field_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_field_properties,
-            None,
-            output_formats,
-        )
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_field_properties,
+                               None,
+                               output_formats,
+                               )
 
 
 if __name__ == "__main__":

pyegeria/egeria_cat_client.py

@@ -8,39 +8,29 @@ AssetCatalog, CollectionManager, GlossaryManager, and ProjectManager.
 """
 from pyegeria.egeria_my_client import EgeriaMy
 from pyegeria.asset_catalog_omvs import AssetCatalog
-from pyegeria.collection_manager import CollectionManager
-from pyegeria.glossary_manager_omvs import GlossaryManager
-from pyegeria.project_manager_omvs import ProjectManager
+# from pyegeria.collection_manager import CollectionManager
+from pyegeria.glossary_manager import GlossaryManager
+from pyegeria.project_manager import ProjectManager
 
 
-class EgeriaCat(
-    AssetCatalog,
-    CollectionManager,
-    EgeriaMy,
-    GlossaryManager,
-    # GovernanceAuthor,
-    # PeopleOrganizer,
-    ProjectManager,
-):
+class EgeriaCat:
     """
-    Client to issue Runtime status requests.
+    Catalog-oriented client using composition of AssetCatalog, EgeriaMy, GlossaryManager, and ProjectManager.
 
     Attributes:
-
-        server_name: str
-                Name of the server to use.
+        view_server: str
+            Name of the view server to use.
         platform_url : str
             URL of the server platform to connect to
         user_id : str
-            The identity of the user calling the method - this sets a default optionally used by the methods
-            when the user doesn't pass the user_id on a method call.
+            The identity of the user calling the method.
         user_pwd: str
             The password associated with the user_id. Defaults to None
         token: str
             An optional bearer token
 
     Methods:
-
+        Methods are provided by composed sub-clients via delegation.
     """
 
     def __init__(
@@ -56,19 +46,47 @@ class EgeriaCat(
         self.user_id = user_id
         self.user_pwd = user_pwd
 
-        AssetCatalog.__init__(self, view_server, platform_url, user_id, user_pwd, token)
-        CollectionManager.__init__(
-            self, view_server, platform_url, user_id, user_pwd, token
-        )
-        EgeriaMy.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        # Compose sub-clients
+        self._asset_catalog = AssetCatalog(view_server, platform_url, user_id, user_pwd, token)
+        self._my = EgeriaMy(view_server, platform_url, user_id, user_pwd, token)
+        self._glossary = GlossaryManager(view_server, platform_url, user_id, user_pwd, token)
+        self._projects = ProjectManager(view_server, platform_url, user_id, user_pwd, token)
+        self._subclients = [
+            self._asset_catalog,
+            self._my,
+            self._glossary,
+            self._projects,
+        ]
+
+    def __getattr__(self, name):
+        for sub in self._subclients:
+            if hasattr(sub, name):
+                return getattr(sub, name)
+        raise AttributeError(f"{self.__class__.__name__!s} object has no attribute {name!r}")
+
+    def create_egeria_bearer_token(self, user_id: str = None, user_pwd: str = None):
+        token_val = None
+        for sub in self._subclients:
+            token_val = sub.create_egeria_bearer_token(user_id, user_pwd)
+        return token_val
+
+    def set_bearer_token(self, token: str) -> None:
+        for sub in self._subclients:
+            sub.set_bearer_token(token)
 
-        GlossaryManager.__init__(
-            self, view_server, platform_url, user_id, user_pwd, token
-        )
+    def get_token(self) -> str:
+        for sub in self._subclients:
+            if hasattr(sub, "get_token"):
+                return sub.get_token()
+        return None
 
-        ProjectManager.__init__(
-            self, view_server, platform_url, user_id, user_pwd, token
-        )
+    def close_session(self) -> None:
+        for sub in self._subclients:
+            if hasattr(sub, "close_session"):
+                try:
+                    sub.close_session()
+                except Exception:
+                    pass
 
 
 if __name__ == "__main__":