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

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