pyegeria 5.4.0.22__py3-none-any.whl → 5.4.0.24__py3-none-any.whl

pyegeria/_client_new.py

@@ -476,7 +476,8 @@ class Client2:
         except (HTTPStatusError, httpx.HTTPStatusError, httpx.RequestError) as e:
             # context["caught_exception"] = e
             # context['HTTPStatusCode'] = e.response.status_code
-            additional_info = {"userid": self.user_id}
+            additional_info = {"userid": self.user_id, "reason": response.text}
+
             raise PyegeriaClientException(response, context, additional_info, e)
         #
         # except json.JSONDecodeError as e:
@@ -736,20 +737,20 @@ class Client2:
         return elements
 
     def validate_new_element_request(self, body: dict | NewElementRequestBody,
-                                     prop: str) -> NewElementRequestBody | None:
+                                     prop: list[str]) -> NewElementRequestBody | None:
         if isinstance(body, NewElementRequestBody):
-            if body.properties.class_ == prop:
-                validated_body = body
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
+            # if body.properties.class_ in prop:
+            validated_body = body
+            # else:
+            #     raise PyegeriaInvalidParameterException(additional_info=
+            #                                             {"reason": "unexpected property class name"})
 
         elif isinstance(body, dict):
-            if body.get("properties", {}).get("class", "") == prop:
-                validated_body = self._new_element_request_adapter.validate_python(body)
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
+            # if body.get("properties", {}).get("class", "") == prop:
+            validated_body = self._new_element_request_adapter.validate_python(body)
+            # else:
+            #     raise PyegeriaInvalidParameterException(additional_info=
+            #                                             {"reason": "unexpected property class name"})
         else:
             return None
         return validated_body
@@ -780,12 +781,12 @@ class Client2:
             validated_body = body
         elif isinstance(body, dict):
             validated_body = self._delete_request_adapter.validate_python(body)
-        else:
+        else: # handle case where body not provided
             body= {
                 "class": "DeleteRequestBody",
                 "cascadeDelete": cascade_delete
                 }
-            validated_body= DeleteRequestBody.validate_python(body)
+            validated_body= DeleteRequestBody.model_validate(body)
         return validated_body
 
     def validate_update_element_request(self, body: dict | UpdateElementRequestBody,
@@ -798,17 +799,17 @@ class Client2:
                                                         {"reason": "unexpected property class name"})
 
         elif isinstance(body, dict):
-            if body.get("properties", {}).get("class", "") in prop:
-                validated_body = self._update_element_request_adapter.validate_python(body)
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
+            # if body.get("properties", {}).get("class", "") in prop:
+            validated_body = self._update_element_request_adapter.validate_python(body)
+            # else:
+            #     raise PyegeriaInvalidParameterException(additional_info=
+            #                                             {"reason": "unexpected property class name"})
         else:
             validated_body = None
         return validated_body
 
     def validate_update_status_request(self, status: str = None, body: dict | UpdateStatusRequestBody = None,
-                                       prop: str = None) -> UpdateStatusRequestBody | None:
+                                       prop: list[str] = None) -> UpdateStatusRequestBody | None:
         if isinstance(body, UpdateStatusRequestBody):
             validated_body = body
 
@@ -820,33 +821,34 @@ class Client2:
                 "class": "UpdateStatusRequestBody",
                 "status": status
                 }
-            validated_body = UpdateStatusRequestBody.validate_python(body)
+            validated_body = UpdateStatusRequestBody.model_validate(body)
         else:
             raise PyegeriaInvalidParameterException(additional_info={"reason": "invalid parameters"})
 
         return validated_body
 
     def validate_update_relationship_request(self, body: dict | UpdateRelationshipRequestBody,
-                                             prop: str) -> UpdateRelationshipRequestBody | None:
+                                             prop: [str]) -> UpdateRelationshipRequestBody | None:
         if isinstance(body, UpdateRelationshipRequestBody):
-            if body.properties.class_ == prop:
-                validated_body = body
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
+            # if body.properties.class_ == prop:
+            validated_body = body
+            # else:
+            #     raise PyegeriaInvalidParameterException(additional_info=
+            #                                             {"reason": "unexpected property class name"})
 
         elif isinstance(body, dict):
-            if body.get("properties", {}).get("class", "") == prop:
-                validated_body = self._update_relationship_request_adapter.validate_python(body)
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
+            # if body.get("properties", {}).get("class", "") == prop:
+            validated_body = self._update_relationship_request_adapter.validate_python(body)
+            # else:
+            #     raise PyegeriaInvalidParameterException(additional_info=
+            #                                             {"reason": "unexpected property class name"})
         else:
             validated_body = None
         return validated_body
 
     async def _async_find_request(self, url: str, _type: str, _gen_output: Callable[..., Any],
                                   search_string: str = '*', classification_names: list[str] = None,
+                                  metadata_element_types: list[str] = None,
                                   starts_with: bool = True, ends_with: bool = False, ignore_case: bool = False,
                                   start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
                                   output_format_set: str | dict = None,
@@ -867,13 +869,14 @@ class Client2:
                 "start_from": start_from,
                 "page_size": page_size,
                 "include_only_classified_elements": classification_names,
+                "metadata_element_subtype_names": metadata_element_types,
                 }
             validated_body = SearchStringRequestBody.model_validate(body)
 
-        classification_names = validated_body.include_only_classified_elements
-        classification_name = classification_names[0] if classification_names else _type
+        # classification_names = validated_body.include_only_classified_elements
+        # element_type_name = classification_names[0] if classification_names else _type
 
-        json_body = validated_body.model_dump_json(indent=2)
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
 
         response = await self._async_make_request("POST", url, json_body)
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
@@ -883,7 +886,7 @@ class Client2:
 
         if output_format != 'JSON':  # return a simplified markdown representation
             # logger.info(f"Found elements, output format: {output_format} and output_format_set: {output_format_set}")
-            return _gen_output(elements, search_string, classification_name,
+            return _gen_output(elements, search_string, _type,
                                output_format, output_format_set)
         return elements
 
@@ -908,8 +911,8 @@ class Client2:
                 }
             validated_body = FilterRequestBody.model_validate(body)
 
-        classification_names = validated_body.include_only_classified_elements
-        classification_name = classification_names[0] if classification_names else _type
+        # classification_names = validated_body.include_only_classified_elements
+        # element_type_name = classification_names[0] if classification_names else _type
 
         json_body = validated_body.model_dump_json(indent=2)
 
@@ -921,7 +924,7 @@ class Client2:
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format} and output_format_set: {output_format_set}")
-            return _gen_output(elements, filter_string, classification_name,
+            return _gen_output(elements, filter_string, _type,
                                output_format, output_format_set)
         return elements
 
@@ -972,7 +975,10 @@ class Client2:
         json_body = validated_body.model_dump_json(indent=2)
 
         response = await self._async_make_request("POST", url, json_body)
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        elements = response.json().get("elements", None)
+        if elements is None:
+            elements = response.json().get("element", NO_ELEMENTS_FOUND)
+
         if type(elements) is str:
             logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
@@ -983,7 +989,7 @@ class Client2:
                                output_format, output_format_set)
         return elements
 
-    async def _async_create_element_body_request(self, url: str, prop: str,
+    async def _async_create_element_body_request(self, url: str, prop: list[str],
                                                  body: dict | NewElementRequestBody = None) -> str:
         validated_body = self.validate_new_element_request(body, prop)
         json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
@@ -1008,7 +1014,7 @@ class Client2:
         response = await self._async_make_request("POST", url, json_body)
         logger.info(response.json())
 
-    async def _async_new_relationship_request(self, url: str, prop: str,
+    async def _async_new_relationship_request(self, url: str, prop: list[str],
                                               body: dict | NewRelationshipRequestBody = None) -> None:
         validated_body = self.validate_new_relationship_request(body, prop)
         if validated_body:
@@ -1029,15 +1035,6 @@ class Client2:
             await self._async_make_request("POST", url)
 
 
-    async def _async_new_relationship_request(self, url: str, prop: str,
-                                              body: dict | NewRelationshipRequestBody = None) -> None:
-        validated_body = self.validate_new_relationship_request(body, prop)
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            logger.info(json_body)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
 
 
 

pyegeria/_exceptions_new.py

@@ -374,6 +374,11 @@ def print_exception_table(e: PyegeriaException):
 def print_basic_exception(e: PyegeriaException):
     """Prints the exception response"""
     related_code = e.related_http_code if hasattr(e, "related_http_code") else ""
+    http_reason = e.response.text if e.response else ""
+    table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
+    table.caption = e.pyegeria_code
+    table.add_column("Facet", justify="center")
+    table.add_column("Item", justify="left", width=80)
     related_response = e.response.json() if e.response else ""
     table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
     table.caption = e.pyegeria_code
@@ -382,6 +387,7 @@ def print_basic_exception(e: PyegeriaException):
 
     if isinstance(e, PyegeriaException):
         table.add_row("HTTP Code", str(e.response_code))
+        table.add_row("HTTP Reason", str(http_reason))
         table.add_row("Egeria Code", str(related_code))
         table.add_row("Caller Method", e.context.get("caller method", "---")) if e.context else ""
         table.add_row("Request URL", str(e.response_url))

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,31 +132,71 @@ 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'),
+    ]
+GOVERNANCE_DEFINITIONS_BASIC =  [
+    Column(name="Type", key='type_name'),
+    Column(name='Qualified Name', key='qualified_name', format=True),
+    Column(name="GUID", key='guid', format=True),
     ]
-
 COMMON_ANNOTATIONS = {
     "wikilinks": ["[[Commons]]"]
 }
 
 # 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 +250,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 +264,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 +277,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 +287,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={"initial_classifications": "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={"initial_classifications": "DataDictionary"},
-        )]
+        )
     ),
 
     "Data Specification": FormatSet(
@@ -285,11 +360,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={"initial_classifications": "DataSpec"},
-        )]
+        )
     ),
 
     "DataStruct": FormatSet(
@@ -298,11 +373,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 +386,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,24 +404,35 @@ 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 Basics": FormatSet(
+        heading="Basic Governance-Definitions Information",
+        description="Core Attributes useful to Governance-Definitions.",
+        aliases=["BasicGovernance"],
+        annotations={"wikilinks": ["[[Governance]]"]},
+        formats=[Format(types=["ALL"], columns=GOVERNANCE_DEFINITIONS_BASIC)],
+        action=ActionParameter(
+            function="GovernanceOfficer.find_governance_definitions",
+            user_params=["search_string"],
+            spec_params={},
+            )
     ),
-
     "Governance Definitions": FormatSet(
         heading="Governance-Definitions Information",
         description="Attributes useful to Governance-Definitions.",
         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 +476,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":