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

pyegeria/_exceptions_new.py

@@ -114,12 +114,15 @@ def print_bullet_list(items)->Text:
 def flatten_dict_to_string(d: dict) -> str:
     """Flatten a dictionary into a string and replace quotes with backticks."""
     try:
-        flat_string = "\n\t".join(
-            # Change replace(\"'\", '`') to replace("'", '`')
-            f"\t* {key}=`{str(value).replace('\"', '`').replace("'", '`')}`"
-            for key, value in d.items()
-        )
-        return flat_string
+        if d:
+            flat_string = "\n\t".join(
+                # Change replace(\"'\", '`') to replace("'", '`')
+                f"\t* {key}=`{str(value).replace('\"', '`').replace("'", '`')}`"
+                for key, value in d.items()
+            )
+            return flat_string
+        else:
+            return ""
     except Exception as e:
         # Corrected syntax for exception chaining
         raise Exception("Error flattening dictionary") from e
@@ -380,17 +383,17 @@ def print_basic_exception(e: PyegeriaException):
     if isinstance(e, PyegeriaException):
         table.add_row("HTTP Code", str(e.response_code))
         table.add_row("Egeria Code", str(related_code))
-        table.add_row("Caller Method", e.context.get("caller method", "---"))
+        table.add_row("Caller Method", e.context.get("caller method", "---")) if e.context else ""
         table.add_row("Request URL", str(e.response_url))
         table.add_row("Egeria Message",
-                      format_dict_to_string(related_response.get('exceptionErrorMessage',"")))
+                      format_dict_to_string(related_response.get('exceptionErrorMessage',"")) if isinstance(related_response,dict) else related_response)
         table.add_row("Egeria User Action",
-                      format_dict_to_string(related_response.get('exceptionUserAction',"")))
+                      format_dict_to_string(related_response.get('exceptionUserAction',"")) if isinstance(related_response,dict) else related_response)
 
-        exception_msg_id = related_response.get("exceptionErrorMessageId", None)
+        exception_msg_id = related_response.get("exceptionErrorMessageId", None) if isinstance(related_response,dict) else related_response
         table.add_row("Pyegeria Exception", exception_msg_id)
-        table.add_row("Pyegeria Message",
-                      f"\n\t{e.error_details['message_template'].format(exception_msg_id)}\n")
+        table.add_row("Pyegeria Message", e.message)
+        console.print(table)
 
 
         console.print(table)
@@ -408,7 +411,7 @@ def print_validation_error(e: ValidationError):
 
     for error in e.errors():
         error_type = error["type"]
-        attribute = " ".join(error["loc"])
+        attribute = " ".join(str(part) for part in error["loc"])
         message = error["msg"]
         table.add_row(error_type, attribute, message)
 

pyegeria/_output_format_models.py

@@ -175,14 +175,16 @@ class FormatSet(BaseModel):
         aliases: Alternative names that can be used to reference this format set
         annotations: Additional metadata, like wiki links
         formats: A list of format configurations
-        action: Optional actions associated with the format set
+        action: Optional action associated with the format set
+        get_additional_props: Optional action used to retrieve additional properties for a format set
     """
     heading: str
     description: str
     aliases: List[str] = Field(default_factory=list)
     annotations: Dict[str, List[str]] = Field(default_factory=dict)
     formats: List[Union[Format, Dict[str, Any]]]
-    action: Optional[List[Union[ActionParameter, Dict[str, Any]]]] = None
+    action: Optional[Union[ActionParameter, Dict[str, Any]]] = None
+    get_additional_props: Optional[Union[ActionParameter, Dict[str, Any]]] = None
     
     @validator('formats', pre=True)
     def validate_formats(cls, v):
@@ -195,18 +197,20 @@ class FormatSet(BaseModel):
                 result.append(item)
         return result
     
-    @validator('action', pre=True)
-    def validate_action(cls, v):
-        """Convert dictionary actions to ActionParameter objects."""
+    @validator('action', 'get_additional_props', pre=True)
+    def validate_action_like(cls, v):
+        """Convert dictionary action-like fields to ActionParameter objects. Accepts legacy list shape."""
         if v is None:
             return None
-        result = []
-        for item in v:
-            if isinstance(item, dict):
-                result.append(ActionParameter(**item))
-            else:
-                result.append(item)
-        return result
+        # Backward compatibility: if a list is provided, use the first element
+        if isinstance(v, list):
+            if not v:
+                return None
+            logger.warning("FormatSet.action/get_additional_props provided as a list; coercing first element to dict. This shape is deprecated.")
+            v = v[0]
+        if isinstance(v, dict):
+            return ActionParameter(**v)
+        return v
     
     def dict(self, *args, **kwargs):
         """Override dict method to convert nested objects back to dictionaries."""
@@ -215,11 +219,12 @@ class FormatSet(BaseModel):
             format if isinstance(format, dict) else format.dict()
             for format in self.formats
         ]
-        if self.action:
-            result['action'] = [
-                action if isinstance(action, dict) else action.dict()
-                for action in self.action
-            ]
+        if self.action is not None:
+            result['action'] = self.action if isinstance(self.action, dict) else self.action.dict()
+        if self.get_additional_props is not None:
+            result['get_additional_props'] = (
+                self.get_additional_props if isinstance(self.get_additional_props, dict) else self.get_additional_props.dict()
+            )
         return result
     
     def get(self, key, default=None):

pyegeria/_output_formats.py

@@ -70,9 +70,11 @@ from pathlib import Path
 from typing import Dict, List, Optional, Union, Any
 from loguru import logger
 
-from pyegeria._output_format_models import Column, Format, ActionParameter, FormatSet, FormatSetDict, save_format_sets_to_json, load_format_sets_from_json
+from pyegeria._output_format_models import (Column, Format, ActionParameter, FormatSet, FormatSetDict,
+                                            save_format_sets_to_json, load_format_sets_from_json)
 from pyegeria.load_config import get_app_config
 
+
 # Get the configured value for the user format sets directory
 app_config = get_app_config()
 USER_FORMAT_SETS_DIR = os.path.expanduser(app_config.Environment.pyegeria_user_format_sets_dir)
@@ -90,6 +92,7 @@ COMMON_COLUMNS = [
 
 COMMON_METADATA_COLUMNS = [
     Column(name='GUID', key='guid', format=True),
+    Column(name='Type Name', key='type_name'),
     Column(name='Metadata Collection ID', key='metadata_collection_id', format=True),
     Column(name='Metadata Collection Name', key='metadata_collection_name', format=True),
 ]
@@ -120,6 +123,8 @@ COMMON_FORMATS_ALL = Format(
 
 
 COLLECTIONS_COLUMNS = COMMON_COLUMNS + [
+    Column(name='Type Name', key='type_name'),
+    Column(name='Classifications', key='classifications'),
     Column(name="Created By", key='created_by'),
     Column(name="Create Time", key='create_time'),
     Column(name="Updated By", key='updated_by'),
@@ -127,23 +132,36 @@ COLLECTIONS_COLUMNS = COMMON_COLUMNS + [
 ]
 
 COLLECTIONS_MEMBERS_COLUMNS = COLLECTIONS_COLUMNS + [
-    Column(name="Members", key='members'),
+    Column(name="Containing Members", key='collection_members'),
+    Column(name="Member Of", key='member_of_collections')
     ]
 
 COLLECTION_DICT = Format(
     types=["DICT"],
-    columns=COLLECTIONS_COLUMNS,
+    columns=COLLECTIONS_MEMBERS_COLUMNS + [
+        Column(name="GUID", key='GUID'),
+        ],
+)
+
+COLLECTION_REPORT = Format(
+    types=["REPORT"],
+    columns=COLLECTIONS_MEMBERS_COLUMNS + [
+        Column(name="GUID", key='GUID'),
+        Column(name="Mermaid", key='mermaid'),
+        ],
 )
 
 COLLECTION_TABLE = Format(
     types=["TABLE"],
-    columns=COMMON_COLUMNS,
+    columns=COLLECTIONS_MEMBERS_COLUMNS,
 )
 
 GOVERNANCE_DEFINITIONS_COLUMNS = COMMON_COLUMNS + [
-    Column(name="Document Identifier", key='document_identifier'),
-    Column(name="Title", key='title'),
+    Column(name="Summary", key='summary'),
+    Column(name="Usage", key='usage'),
+    Column(name="Importance", key='importance'),
     Column(name="Scope", key='scope'),
+    Column(name="Type", key='type_name'),
     ]
 
 COMMON_ANNOTATIONS = {
@@ -152,6 +170,29 @@ COMMON_ANNOTATIONS = {
 
 # Modularized output_format_sets
 output_format_sets = FormatSetDict({
+    "Default": FormatSet(
+        heading="Default Base Attributes",
+        description="Was a valid combination of output_format_set and output_format provided?",
+        annotations={},  # No specific annotations
+        formats=[
+            Format(
+                types=["ALL"],
+                columns=COMMON_COLUMNS + COMMON_METADATA_COLUMNS + [
+                    Column(name='Version Identifier', key='version_identifier'),
+                    Column(name="Classifications", key='classifications'),
+                    Column(name="Additional Properties", key='additional_properties'),
+                    Column(name="Created By", key='created_by'),
+                    Column(name="Create Time", key='create_time'),
+                    Column(name="Updated By", key='updated_by'),
+                    Column(name="Update Time", key='update_time'),
+                    Column(name="Effective From", key='effective_from'),
+                    Column(name="Effective To", key='effective_to'),
+                    Column(name="Version", key='version'),
+                    Column(name="Open Metadata Type Name", key='type_name'),
+                ],
+            )
+        ],
+    ),
     "Referenceable": FormatSet(
         heading="Common Attributes",
         description="Attributes that apply to all Referenceables.",
@@ -205,12 +246,12 @@ output_format_sets = FormatSetDict({
         aliases=["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                 "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         annotations=COMMON_ANNOTATIONS,
-        formats=[COLLECTION_DICT, COLLECTION_TABLE, COMMON_FORMATS_ALL],  # Reusing common formats
-        action=[ActionParameter(
+        formats=[COLLECTION_DICT, COLLECTION_TABLE, COLLECTION_REPORT, COMMON_FORMATS_ALL],  # Reusing common formats
+        action=ActionParameter(
             function="CollectionManager.find_collections",
             user_params=["search_string"],
             spec_params={},
-        )]
+        )
     ),
 
     "CollectionMembers": FormatSet(
@@ -219,11 +260,11 @@ output_format_sets = FormatSetDict({
         aliases=["CollectionMember", "Member", "Members"],
         annotations= {"wikilinks": ["[[CollectionMembers]]"]},
         formats = [COLLECTION_DICT, COLLECTION_TABLE],
-        action=[ActionParameter(
+        action=ActionParameter(
             function="CollectionManager.get_collection_members",
             user_params=["collection_guid"],
             spec_params={"output_format": "DICT"},
-            )]
+            )
         ),
     "DigitalProducts": FormatSet(
         heading="Digital Product Information",
@@ -232,7 +273,7 @@ output_format_sets = FormatSetDict({
         annotations={},
         formats=[
             Format(
-                types=["REPORT"],
+                types=["REPORT", "DICT", "TABLE"],
                 columns=COMMON_COLUMNS + [
                     Column(name="Status", key='status'),
                     Column(name='Product Name', key='product_name'),
@@ -242,35 +283,65 @@ output_format_sets = FormatSetDict({
                     Column(name='Next Version', key='next_version'),
                     Column(name='Withdraw Date', key='withdraw_date'),
                     Column(name='Members', key='members', format=True),
+                    Column(name='Uses Products', key='uses_digital_products'),
+                    Column(name='Used by Products', key='used_by_digital_products'),
                 ],
             )
         ],
-        action=[ActionParameter(
+        action=ActionParameter(
             function="CollectionManager.find_collections",
             user_params=["search_string"],
-            spec_params={"classification_name": "DigitalProducts"},
-        )]
+            spec_params={},
+        ),
+        get_additional_props=ActionParameter(
+            function="CollectionManager._extract_digital_product_properties",
+            user_params = [],
+            spec_params={},
+            )
     ),
 
     "Agreements": FormatSet(
         heading="General Agreement Information",
         description="Attributes generic to all Agreements.",
-        aliases=["DataSharingAgreement"],
+        aliases=["DataSharingAgreement", "Agreement"],
         annotations={"wikilinks": ["[[Agreements]]", "[[Egeria]]"]},
-        formats=[COMMON_FORMATS_ALL]  # Reusing common formats and columns
+        formats=[
+            Format(
+                types=["REPORT", "DICT", "TABLE"],
+                columns=COMMON_COLUMNS + COMMON_HEADER_COLUMNS + [
+                    Column(name='Identifier', key='identifier'),
+                    Column(name='Support Level', key='support_level'),
+                    Column(name='service Levels', key='service_levels'),
+                    Column(name='Agreement Items', key='agreement_items', format=True),
+                    Column(name='Members', key='members', format=True),
+                    ]
+                )
+            ],
+        action=ActionParameter(
+            function="CollectionManager.find_collections",
+            user_params=["search_string"],
+            spec_params={"metadata_element_types": ["Agreement"]},
+            # spec_params={},
+            ),
+        get_additional_props=ActionParameter(
+            function="CollectionManager._extract_agreement_properties",
+            user_params=[],
+            spec_params={},
+            ),
     ),
 
+
     "DataDictionary": FormatSet(
         heading="Data Dictionary Information",
         description="Attributes useful to Data Dictionary.",
         aliases=["Data Dict", "Data Dictionary"],
         annotations={"wikilinks": ["[[Data Dictionary]]"]},
         formats=[COMMON_FORMATS_ALL],  # Reusing common formats and columns
-        action=[ActionParameter(
+        action=ActionParameter(
             function="CollectionManager.find_collections",
             user_params=["search_string"],
-            spec_params={"classification_name": "DataDictionary"},
-        )]
+            spec_params={"initial_classifications": "DataDictionary"},
+        )
     ),
 
     "Data Specification": FormatSet(
@@ -285,11 +356,11 @@ output_format_sets = FormatSetDict({
                 Column(name="Mermaid", key='mermaid'),
                 ]),
             Format(types=["ALL"], columns=COMMON_COLUMNS)],  # Reusing common formats and columns
-        action=[ActionParameter(
+        action=ActionParameter(
             function="CollectionManager.find_collections",
             user_params=["search_string"],
-            spec_params={"classification_name": "DataSpec"},
-        )]
+            spec_params={"initial_classifications": "DataSpec"},
+        )
     ),
 
     "DataStruct": FormatSet(
@@ -298,11 +369,11 @@ output_format_sets = FormatSetDict({
         aliases=["Data Structure", "DataStructures", "Data Structures", "Data Struct", "DataStructure"],
         annotations={"wikilinks": ["[[Data Structure]]"]},
         formats=[Format(types=["ALL"], columns=COMMON_COLUMNS)],  # Reusing common formats and columns
-        action=[ActionParameter(
+        action=ActionParameter(
             function="DataDesigner.find_data_structures",
             user_params=["search_string"],
             spec_params={},
-        )]
+        )
     ),
 
     "DataField": FormatSet(
@@ -311,11 +382,11 @@ output_format_sets = FormatSetDict({
         aliases=["Data Field", "Data Fields", "DataFields"],
         annotations={"wikilinks": ["[[Data Field]]"]},
         formats=[Format(types=["ALL"], columns=COMMON_COLUMNS)],  # Reusing common formats and columns
-        action=[ActionParameter(
+        action=ActionParameter(
             function="DataDesigner.find_data_fields",
             user_params=["search_string"],
             spec_params={},
-        )]
+        )
     ),
 
     "Mandy-DataStruct": FormatSet(
@@ -329,11 +400,11 @@ output_format_sets = FormatSetDict({
             Format(types=["REPORT","MERMAID", "HTML"], columns=[Column(name='Display Name', key='display_name'),
                                                Column(name='Mermaid', key='mermaid'),]),
         ],
-        action=[ActionParameter(
+        action=ActionParameter(
             function="DataDesigner.find_data_structures",
             user_params=["search_string"],
             spec_params={"output_format":"DICT"},
-        )]
+        )
     ),
 
     "Governance Definitions": FormatSet(
@@ -342,11 +413,11 @@ output_format_sets = FormatSetDict({
         aliases=["GovernanceDefinitions"],
         annotations={"wikilinks": ["[[Governance]]"]},
         formats=[Format(types=["ALL"], columns=GOVERNANCE_DEFINITIONS_COLUMNS)],
-        action=[ActionParameter(
+        action=ActionParameter(
             function="GovernanceOfficer.find_governance_definitions",
-            user_params=["search_filter"],
-            spec_params={"output_format":"DICT"},
-            )]
+            user_params=["search_string"],
+            spec_params={},
+            )
     ),
     })
 
@@ -390,7 +461,9 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
         output_struct["annotations"] = element.annotations
         if element.action:
             # Convert ActionParameter to dictionary for backward compatibility
-            output_struct["action"] = [action.dict() for action in element.action]
+            output_struct["action"] = element.action.dict()
+        if element.get_additional_props:
+            output_struct["get_additional_props"] = element.get_additional_props.dict()
 
     # If this was just a validation that the format set could be found then the output type is ANY - so just return.
     if output_type == "ANY":