pyegeria 5.4.3.2__py3-none-any.whl → 5.4.3.4__py3-none-any.whl

pyegeria/data_designer.py

@@ -18,7 +18,8 @@ from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequ
                              TemplateRequestBody,
                              UpdateElementRequestBody, NewRelationshipRequestBody,
                              DeleteRequestBody)
-from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict)
+from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, populate_columns_from_properties,
+                                       get_required_relationships, populate_common_columns)
 from pyegeria.output_formatter import (generate_output,
                                        _extract_referenceable_properties)
 from pyegeria.utils import body_slimmer, dynamic_catch
@@ -1296,13 +1297,11 @@ class DataDesigner(Client2):
 
         member_of_collections = el_struct.get("memberOfCollections", {})
         for collection in member_of_collections:
-            c_type = collection["relatedElement"]["properties"].get("collectionType", "") or ""
+            type_name = collection["relatedElement"]["elementHeader"]["type"].get("typeName", "") or ""
             guid = collection["relatedElement"]["elementHeader"]["guid"]
-            name = collection["relatedElement"]["properties"].get("name", "") or ""
+            name = collection["relatedElement"]["properties"].get("displayName", "") or ""
             qualifiedName = collection['relatedElement']["properties"].get("qualifiedName", "") or ""
-            classifications = collection["relatedElement"]["elementHeader"]["classifications"]
-            for classification in classifications:
-                type_name = classification["type"]['typeName']
+            if type_name:
                 if type_name == "DataDictionary":
                     member_of_data_dicts_guids.append(guid)
                     member_of_data_dicts_names.append(name)
@@ -2517,7 +2516,7 @@ class DataDesigner(Client2):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_data_fields_by_name(filter, classification_names, body, start_from, page_size,
+            self._async_get_data_fields_by_name(filter_string, classification_names, body, start_from, page_size,
                                                 output_format, output_format_set))
         return response
 
@@ -4682,120 +4681,163 @@ class DataDesigner(Client2):
 
 
 
-    def _extract_data_structure_properties(self, element: dict) -> dict:
-        """
-        Extract common properties from a data structure element.
-
-        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", [])
-
-        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,
+    def _extract_data_structure_properties(self, element: dict, columns_struct: dict) -> dict:
+        """Extractor for Data Structure elements with related overlay.
+
+        Pattern:
+        - Populate common columns via populate_common_columns.
+        - Derive related properties using get_data_rel_elements_dict from the element body.
+        - Overlay values into matching columns' 'value' fields, handling formats as list or dict.
+        - Return the enriched columns_struct.
+        """
+        col_data = populate_common_columns(element, columns_struct)
+
+        try:
+            related_map = self.get_data_rel_elements_dict(element)
+        except Exception:
+            related_map = {}
+
+        if isinstance(related_map, dict) and related_map:
+            try:
+                formats = col_data.get("formats") if isinstance(col_data, dict) else None
+                if isinstance(formats, list):
+                    targets = formats
+                elif isinstance(formats, dict):
+                    inner = formats.get("formats") if isinstance(formats.get("formats"), (dict, list)) else None
+                    if isinstance(inner, list):
+                        targets = inner
+                    elif isinstance(inner, dict):
+                        targets = [inner]
+                    else:
+                        targets = [formats]
+                else:
+                    targets = []
+
+                if targets:
+                    for fmt in targets:
+                        cols = fmt.get("columns", []) if isinstance(fmt, dict) else []
+                        for col in cols:
+                            key = col.get("key") if isinstance(col, dict) else None
+                            if key and key in related_map:
+                                col["value"] = related_map.get(key)
+                else:
+                    cols = col_data.get("columns", []) if isinstance(col_data, dict) else []
+                    for col in cols:
+                        key = col.get("key") if isinstance(col, dict) else None
+                        if key and key in related_map:
+                            col["value"] = related_map.get(key)
+            except Exception:
+                pass
+
+        return col_data
+
+
+    def _extract_data_class_properties(self, element: dict,columns_struct: dict) -> dict:
+        """Extractor for Data Class elements with related overlay, mirroring Data Field pattern."""
+        col_data = populate_common_columns(element, columns_struct)
+
+        try:
+            related_map = self.get_data_rel_elements_dict(element)
+        except Exception:
+            related_map = {}
+
+        if isinstance(related_map, dict) and related_map:
+            try:
+                formats = col_data.get("formats") if isinstance(col_data, dict) else None
+                if isinstance(formats, list):
+                    targets = formats
+                elif isinstance(formats, dict):
+                    inner = formats.get("formats") if isinstance(formats.get("formats"), (dict, list)) else None
+                    if isinstance(inner, list):
+                        targets = inner
+                    elif isinstance(inner, dict):
+                        targets = [inner]
+                    else:
+                        targets = [formats]
+                else:
+                    targets = []
+
+                if targets:
+                    for fmt in targets:
+                        cols = fmt.get("columns", []) if isinstance(fmt, dict) else []
+                        for col in cols:
+                            key = col.get("key") if isinstance(col, dict) else None
+                            if key and key in related_map:
+                                col["value"] = related_map.get(key)
+                else:
+                    cols = col_data.get("columns", []) if isinstance(col_data, dict) else []
+                    for col in cols:
+                        key = col.get("key") if isinstance(col, dict) else None
+                        if key and key in related_map:
+                            col["value"] = related_map.get(key)
+            except Exception:
+                pass
+
+        return col_data
+
+    def _extract_data_field_properties(self, element: dict, columns_struct: dict) -> dict:
+        """Extractor for Data Field elements.
+        
+        Steps:
+        - Populate base/referenceable/common properties into columns_struct via populate_common_columns.
+        - Derive related properties using get_data_rel_elements_dict from the element body.
+        - For each column in columns_struct, if its 'key' matches a key from the related dict, set its 'value'.
+        - Return the enriched columns_struct.
+        """
+        # 1) Populate common columns first (header, properties, basic relationships, mermaid)
+        col_data = populate_common_columns(element, columns_struct)
+        
+        # 2) Build a map of related properties/elements from the body. The Data Designer methods
+        #    return a body that may include keys like assignedMeanings, otherRelatedElements,
+        #    memberOfCollections, memberDataFields, assignedDataClasses, nestedDataClasses, etc.
+        try:
+            related_map = self.get_data_rel_elements_dict(element)
+        except Exception:
+            related_map = {}
+        
+        if isinstance(related_map, dict) and related_map:
+            # 3) Walk the configured columns and overlay values when the key matches an entry from related_map
+            try:
+                formats = col_data.get("formats") if isinstance(col_data, dict) else None
+                if isinstance(formats, list):
+                    targets = formats
+                elif isinstance(formats, dict):
+                    # Handle dict variant. It may be a single format dict or a wrapper containing 'formats'.
+                    # Examples seen:
+                    #   { 'columns': [...] }
+                    #   { 'types': 'ALL', 'columns': [...] }
+                    #   { 'formats': { 'columns': [...] } }
+                    inner = formats.get("formats") if isinstance(formats.get("formats"), dict | list) else None
+                    if isinstance(inner, list):
+                        targets = inner
+                    elif isinstance(inner, dict):
+                        targets = [inner]
+                    else:
+                        targets = [formats]
+                else:
+                    targets = []
+
+                if targets:
+                    for fmt in targets:
+                        cols = fmt.get("columns", []) if isinstance(fmt, dict) else []
+                        for col in cols:
+                            key = col.get("key") if isinstance(col, dict) else None
+                            if key and key in related_map:
+                                col["value"] = related_map.get(key)
+                else:
+                    # If columns are on the top-level (non-standard), attempt to handle gracefully
+                    cols = col_data.get("columns", []) if isinstance(col_data, dict) else []
+                    for col in cols:
+                        key = col.get("key") if isinstance(col, dict) else None
+                        if key and key in related_map:
+                            col["value"] = related_map.get(key)
+            except Exception:
+                # Do not fail rendering due to overlay issues; keep the base columns
+                pass
+        
+        return col_data
+
+    def _generate_basic_structured_output(self, elements: dict, filter: str, type: str = None ,output_format: str = 'DICT',
                                           columns_struct: dict = None) -> str | list:
         """
         Generate output in the specified format for the given elements.
@@ -4837,7 +4879,7 @@ class DataDesigner(Client2):
                                    columns_struct,
                                    )
 
-    def _generate_data_structure_output(self, elements: dict | list[dict], filter: str = None,
+    def _generate_data_structure_output(self, elements: dict | list[dict], filter: str = None, type: str = None,
                                         output_format: str = "DICT",
                                         output_format_set: str | dict = None) -> str | list:
         """
@@ -4872,7 +4914,7 @@ class DataDesigner(Client2):
                                output_formats,
                                )
 
-    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
+    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None, type: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data classes in the specified format.
@@ -4907,7 +4949,7 @@ class DataDesigner(Client2):
                                output_formats,
                                )
 
-    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
+    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None, type: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data fields in the specified format.
@@ -4943,6 +4985,12 @@ class DataDesigner(Client2):
                                output_formats,
                                )
 
+    def _extract_additional_data_struct_properties(self, element, columns_struct):
+        return None
+    def _extract_additional_data_field_properties(self, element, columns_struct):
+        return None
+    def _extract_additional_data_class_properties(self, element, columns_struct):
+        return None
 
 if __name__ == "__main__":
     print("Data Designer")

pyegeria/egeria_client.py

@@ -24,7 +24,7 @@ from pyegeria.full_omag_server_config import FullServerConfig
 from pyegeria.metadata_explorer_omvs import MetadataExplorer
 from pyegeria.my_profile_omvs import MyProfile
 from pyegeria.feedback_manager_omvs import FeedbackManager
-from pyegeria.solution_architect_omvs import SolutionArchitect
+from pyegeria.solution_architect import SolutionArchitect
 from pyegeria.server_operations import ServerOps
 from pyegeria.registered_info import RegisteredInfo
 from pyegeria.valid_metadata_omvs import ValidMetadataManager

pyegeria/egeria_tech_client.py

@@ -12,7 +12,7 @@ from pyegeria.egeria_cat_client import EgeriaCat
 from pyegeria.metadata_explorer_omvs import MetadataExplorer
 from pyegeria.registered_info import RegisteredInfo
 from pyegeria.runtime_manager_omvs import RuntimeManager
-from pyegeria.solution_architect_omvs import SolutionArchitect
+from pyegeria.solution_architect import SolutionArchitect
 from pyegeria.template_manager_omvs import TemplateManager
 from pyegeria.valid_metadata_omvs import ValidMetadataManager
 from pyegeria.governance_officer import GovernanceOfficer

pyegeria/glossary_manager.py

@@ -30,7 +30,7 @@ from pyegeria.models import (NewElementRequestBody,
 from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 from pyegeria.output_formatter import (generate_output,
                                        _extract_referenceable_properties, populate_columns_from_properties,
-                                       get_required_relationships)
+                                       get_required_relationships, populate_common_columns, overlay_additional_values, resolve_output_formats)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
@@ -2527,84 +2527,90 @@ class GlossaryManager(CollectionManager):
     #
 
     def _extract_glossary_properties(self, element: dict, columns_struct: dict) -> dict:
-        props = element.get('properties', {}) or {}
-        normalized = {
-            'properties': props,
-            'elementHeader': element.get('elementHeader', {}),
-        }
-        col_data = populate_columns_from_properties(normalized, columns_struct)
-        columns_list = col_data.get('formats', {}).get('columns', [])
+        """Extract glossary columns for rendering.
+
+        This extractor uses `populate_common_columns` for standard fields (properties, header, relationships,
+        subject area, mermaid). It then overlays glossary-specific values such as:
+        - categories_names: comma/newline separated Display Names of categories in the glossary
+        - categories_qualified_names: comma/newline separated Qualified Names of categories in the glossary
+
+        Parameters
+        ----------
+        element : dict
+            Raw element as returned by the OMVS.
+        columns_struct : dict
+            The selected output format structure (from _output_formats), whose columns' `value` fields will be filled.
+
+        Returns
+        -------
+        dict
+            The same columns_struct with values populated. Non-empty values are not overwritten.
+        """
+        # Common population first
+        col_data = populate_common_columns(element, columns_struct)
+        # Overlay glossary-specific extras: categories lists
         header_props = _extract_referenceable_properties(element)
         guid = header_props.get('GUID')
-        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'] = guid
+        extra: dict = {}
         if guid:
-            categories = None
             try:
                 categories = self.get_categories_for_glossary(guid)
             except Exception:
                 categories = None
-            cat_display_list = []
-            cat_qn_list = []
             if isinstance(categories, list):
+                cat_display_list = []
+                cat_qn_list = []
                 for category in categories:
                     gcp = category.get('glossaryCategoryProperties', {})
-                    dn = gcp.get('displayName', '') or ''
-                    qn = gcp.get('qualifiedName', '') or ''
+                    dn = (gcp.get('displayName') or '')
+                    qn = (gcp.get('qualifiedName') or '')
                     if dn:
                         cat_display_list.append(dn)
                     if qn:
                         cat_qn_list.append(qn)
-            cat_names_md = (", \n".join(cat_display_list)).rstrip(',') if cat_display_list else ''
-            cat_qn_md = (", \n".join(cat_qn_list)).rstrip(',') if cat_qn_list else ''
-            for column in columns_list:
-                if column.get('key') == 'categories_names' and not column.get('value'):
-                    column['value'] = cat_names_md
-                if column.get('key') == 'categories_qualified_names' and not column.get('value'):
-                    column['value'] = cat_qn_md
-        for column in columns_list:
-            if column.get('key') == 'mermaid' and not column.get('value'):
-                column['value'] = element.get('mermaidGraph', '') or ''
-                break
-        return col_data
+                if cat_display_list:
+                    extra['categories_names'] = ", \n".join(cat_display_list)
+                if cat_qn_list:
+                    extra['categories_qualified_names'] = ", \n".join(cat_qn_list)
+        return overlay_additional_values(col_data, extra)
 
     def _extract_term_properties(self, element: dict, columns_struct: dict) -> dict:
-        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')
-        classification_names = ""
-        classifications = element.get('elementHeader', {}).get("collectionCategories", [])
-        for classification in classifications:
-            classification_names += f"{classification['classificationName']}, "
-        if classification_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = classification_names[:-2]
-                    break
-        col_data = get_required_relationships(element, col_data)
-        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
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
+        """Extract glossary term columns for rendering.
+
+        Populates standard columns via `populate_common_columns`, and if requested by the
+        selected columns, derives a classifications string (from `elementHeader.collectionCategories`)
+        into the `classifications` column.
+
+        Parameters
+        ----------
+        element : dict
+            Raw term element returned by the OMVS.
+        columns_struct : dict
+            The chosen format-set structure whose column `value`s will be set.
+
+        Returns
+        -------
+        dict
+            The same `columns_struct` with values populated.
+        """
+        # Use centralized population
+        col_data = populate_common_columns(element, columns_struct)
+        # Term-specific classifications (collectionCategories) to 'classifications' column
+        columns_list = col_data.get('formats', {}).get('columns', [])
+        try:
+            classification_names = ""
+            classifications = element.get('elementHeader', {}).get("collectionCategories", [])
+            for classification in classifications:
+                nm = classification.get('classificationName')
+                if nm:
+                    classification_names += f"{nm}, "
+            if classification_names:
+                for column in columns_list:
+                    if column.get('key') == 'classifications' and column.get('value') in (None, ""):
+                        column['value'] = classification_names[:-2]
+                        break
+        except Exception:
+            pass
         return col_data
 
     def _get_term_additional_properties(self, element: dict, term_guid: str, output_format: str = None) -> dict:
@@ -2650,17 +2656,7 @@ class GlossaryManager(CollectionManager):
                                   output_format: str = 'DICT',
                                   output_format_set: dict | str = None) -> str | list[dict]:
         entity_type = 'Glossary'
-        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):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
-            else:
-                output_formats = None
-        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 = resolve_output_formats(entity_type, output_format, output_format_set)
         return generate_output(
             elements=elements,
             search_string=search_string,
@@ -2676,17 +2672,7 @@ class GlossaryManager(CollectionManager):
                                output_format: str = 'DICT',
                                output_format_set: dict | str = None) -> str | list[dict]:
         entity_type = 'GlossaryTerm'
-        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):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
-            else:
-                output_formats = None
-        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 = resolve_output_formats(entity_type, output_format, output_format_set)
         return generate_output(
             elements=elements,
             search_string=search_string,