pyegeria 5.4.3.3__py3-none-any.whl → 5.4.4__py3-none-any.whl

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,

pyegeria/governance_officer.py

@@ -22,6 +22,7 @@ from pyegeria.output_formatter import (
     _extract_referenceable_properties,
     populate_columns_from_properties,
     get_required_relationships,
+    populate_common_columns,
 )
 from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 
@@ -108,16 +109,26 @@ class GovernanceOfficer(Client2):
                                                output_format: str = 'DICT', output_format_set: dict | str = None
                                                ) -> str | list:
         """
-        Generate output for governance definitions in the specified format, using output format sets.
+        Render governance definitions using the shared output pipeline.
 
-        Args:
-            elements: Dictionary or list of dictionaries containing governance definition elements
-            search_string: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
-            output_format_set: Optional format set name or structure to control columns
+        Parameters
+        ----------
+        elements : dict | list[dict]
+            Element(s) returned by the OMVS.
+        search_string : str
+            The search string used to retrieve these elements (shown in preamble for some formats).
+        element_type_name : str, optional
+            Friendly type label to display (defaults to "Governance Definition").
+        output_format : str
+            One of: MD, FORM, REPORT, LIST, DICT, MERMAID, HTML.
+        output_format_set : dict | str, optional
+            Either a label for a format set or a concrete format-set dict. When omitted, a sensible
+            default for Governance Definitions is chosen, falling back to "Default".
 
-        Returns:
-            Formatted output as string or list of dictionaries
+        Returns
+        -------
+        str | list
+            Rendered output in the requested format.
         """
         # Ensure elements handled consistently for MERMAID
         if output_format == "MERMAID":
@@ -167,27 +178,13 @@ class GovernanceOfficer(Client2):
         Returns:
             dict: columns_struct with populated 'value' fields
         """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get('formats', {}).get('columns', [])
-
-        # Header-derived values (GUID, type_name, etc.)
-        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')
-
-        # Populate requested relationship-based columns generically
-        col_data = get_required_relationships(element, col_data)
-
-        # Mermaid graph if requested
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = element.get('mermaidGraph', '') or ''
-                break
-
+        # Use the common population pipeline to reduce duplication
+        col_data = populate_common_columns(element, columns_struct,
+                                           include_header=True,
+                                           include_relationships=True,
+                                           include_subject_area=True,
+                                           mermaid_source_key='mermaidGraph',
+                                           mermaid_dest_key='mermaid')
         return col_data
 
     def _extract_gov_def_list(self, element: Union[Dict, List[Dict]]) -> List[Dict]:

pyegeria/output_formatter.py

@@ -677,7 +677,7 @@ def generate_entity_dict(elements: List[Dict],
                     value = format_for_markdown_table(value, guid or props.get('GUID'))
                 entity_dict[name] = value
         else:
-            props = extract_properties_func(element)
+            props = extract_properties_func(element, columns_struct)
             # Add properties based on include/exclude lists
             for key, value in props.items():
                 if key not in ['properties', 'mermaid']:  # Skip the raw properties object
@@ -721,6 +721,127 @@ def generate_entity_dict(elements: List[Dict],
 
     return result
 
+def resolve_output_formats(entity_type: str,
+                           output_format: str,
+                           output_format_set: Optional[Union[str, dict]] = None,
+                           default_label: Optional[str] = None) -> Optional[dict]:
+    """
+    Resolve an output format set structure given an entity type, the desired output format
+    (e.g., DICT, LIST, MD, REPORT, FORM), and either a label (str) or a dict of format sets.
+
+    Selection order:
+    - If output_format_set is a str: select by label.
+    - If output_format_set is a dict: use get_output_format_type_match to pick a matching format.
+    - Else: try selecting by entity_type or default_label.
+    - Fallback: select "Default".
+    """
+    from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
+
+    if isinstance(output_format_set, str):
+        return select_output_format_set(output_format_set, output_format)
+    if isinstance(output_format_set, dict):
+        return get_output_format_type_match(output_format_set, output_format)
+
+    label = default_label or entity_type
+    fmt = select_output_format_set(label, output_format)
+    if fmt is None:
+        fmt = select_output_format_set("Default", output_format)
+    return fmt
+
+
+def overlay_additional_values(columns_struct: dict, extra: Optional[dict]) -> dict:
+    """
+    Overlay extra values into columns_struct only where the column's value is empty or missing.
+    Returns the modified columns_struct.
+    """
+    if not isinstance(columns_struct, dict) or not extra:
+        return columns_struct
+    columns = columns_struct.get('formats', {}).get('columns')
+    if not isinstance(columns, list):
+        return columns_struct
+    for col in columns:
+        if not isinstance(col, dict):
+            continue
+        key = col.get('key')
+        if not key:
+            continue
+        if col.get('value') in (None, "") and key in extra:
+            col['value'] = extra[key]
+    return columns_struct
+
+
+def populate_common_columns(
+    element: dict,
+    columns_struct: dict,
+    *,
+    include_header: bool = True,
+    include_relationships: bool = True,
+    include_subject_area: bool = True,
+    mermaid_source_key: str = 'mermaidGraph',
+    mermaid_dest_key: str = 'mermaid'
+) -> dict:
+    """
+    Populate the common columns in columns_struct based on a standard Egeria element shape.
+
+    Steps:
+    - Populate from element.properties (camelCase mapped from snake_case keys)
+    - Optionally overlay header-derived values (GUID, type_name, times, etc.)
+    - Optionally populate relationship-based columns via get_required_relationships
+    - Optionally populate subject_area from element.elementHeader.subjectArea.classificationProperties.subjectAreaName
+    - If a column with key == mermaid_dest_key is present, set it from mermaid_source_key
+    - Do not overwrite non-empty values already set
+    """
+    # 1) Base properties
+    col_data = populate_columns_from_properties(element, columns_struct)
+    columns_list = col_data.get('formats', {}).get('columns', [])
+
+    # 2) Header overlay
+    header_props = _extract_referenceable_properties(element) if include_header else {}
+    guid = header_props.get('GUID') if include_header else None
+    if include_header:
+        for column in columns_list:
+            if not isinstance(column, dict):
+                continue
+            key = column.get('key')
+            if not key:
+                continue
+            if column.get('value') not in (None, ""):
+                continue
+            if key in header_props:
+                column['value'] = header_props.get(key)
+            elif isinstance(key, str) and key.lower() == 'guid':
+                column['value'] = guid
+
+    # 3) Relationships
+    if include_relationships:
+        col_data = get_required_relationships(element, col_data)
+
+    # 4) Subject area
+    if include_subject_area:
+        try:
+            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' and column.get('value') in (None, ""):
+                    column['value'] = subj_val
+        except Exception as e:
+            logger.debug(f"populate_common_columns: subject_area handling error: {e}")
+
+    # 5) Mermaid
+    try:
+        mermaid_val = element.get(mermaid_source_key, '') or ''
+        for column in columns_list:
+            if column.get('key') == mermaid_dest_key and column.get('value') in (None, ""):
+                column['value'] = mermaid_val
+                break
+    except Exception as e:
+        logger.debug(f"populate_common_columns: mermaid handling error: {e}")
+
+    return col_data
+
+
 def extract_mermaid_only(elements: Union[Dict, List[Dict]]) -> Union[str, List[str]]:
     """
     Extract mermaid graph data from elements.
@@ -810,6 +931,11 @@ def generate_output(elements: Union[Dict, List[Dict]],
         Formatted output as string or list of dictionaries
     """
     columns = columns_struct['formats'].get('columns',None) if columns_struct else None
+    if not columns:
+        columns_struct = select_output_format_set("Default",output_format)
+        if columns_struct:
+            columns = columns_struct.get('formats', {}).get('columns', None)
+
     target_type = columns_struct.get('target_type', entity_type) if columns_struct else entity_type
     if target_type is None:
         target_type = entity_type

pyegeria/project_manager.py

@@ -17,7 +17,7 @@ from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequ
                              TemplateRequestBody, DeleteRequestBody, UpdateElementRequestBody,
                              NewRelationshipRequestBody)
 from pyegeria.output_formatter import generate_output, populate_columns_from_properties, \
-    _extract_referenceable_properties, get_required_relationships
+    _extract_referenceable_properties, get_required_relationships, populate_common_columns, overlay_additional_values
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
@@ -28,20 +28,33 @@ PROJECT_TYPES = ["Project", "Campaign", "StudyProject", "Task", "PersonalProject
 
 class ProjectManager(Client2):
     """
-    Create and manage projects. Projects may be organized in a hierarchy.
-    See https://egeria-project.org/types/1/0130-Projects
-
-    Attributes:
-
-        server_name: str
-            The name of the View Server to connect to.
-        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.
-        user_pwd: str
-            The password associated with the user_id. Defaults to None
+    Manage Open Metadata Projects via the Project Manager OMVS.
+
+    This client provides asynchronous and synchronous helpers to create, update, search,
+    and relate Project elements and their subtypes (Campaign, StudyProject, Task, PersonalProject).
+
+    References
+    - Egeria concept: https://egeria-project.org/concepts/project
+    - Type lineage: https://egeria-project.org/types/1/0130-Projects
+
+    Parameters
+    -----------
+    view_server : str
+        The name of the View Server to connect to.
+    platform_url : str
+        URL of the server platform to connect to.
+    user_id : str
+        Default user identity for calls (can be overridden per call).
+    user_pwd : str, optional
+        Password for the user_id. If a token is supplied, this may be None.
+
+    Notes
+    -----
+    - Most high-level list/report methods accept an `output_format` and an optional `output_format_set` and
+      delegate rendering to `pyegeria.output_formatter.generate_output` along with shared helpers such as
+      `populate_common_columns`.
+    - Private extractor methods follow the convention: `_extract_<entity>_properties(element, columns_struct)` and
+      must return the same `columns_struct` with per-column `value` fields populated.
     """
 
     def __init__(
@@ -88,28 +101,12 @@ class ProjectManager(Client2):
             'properties': props,
             'elementHeader': element.get('elementHeader', {}),
         }
-        col_data = populate_columns_from_properties(element, columns_struct)
-        # col_data = populate_columns_from_properties(normalized, columns_struct)
+        # Common population pipeline
+        col_data = populate_common_columns(element, columns_struct)
         columns_list = col_data.get('formats', {}).get('columns', [])
-        header_props = _extract_referenceable_properties(element)
-        # Populate requested relationship-based columns generically
-        col_data = get_required_relationships(element, col_data)
-        additional_props = self._extract_additional_project_properties(element, columns_struct)
-        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 key == 'project_roles':
-                column['value'] = additional_props.get('project_roles', '')
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = guid
-
-        for column in columns_list:
-            if column.get('key') == 'mermaid' and not column.get('value'):
-                column['value'] = element.get('mermaidGraph', '') or ''
-                break
+        # Overlay extras (project roles) only where empty
+        extra = self._extract_additional_project_properties(element, columns_struct)
+        col_data = overlay_additional_values(col_data, extra)
         return col_data