pyegeria 5.4.7.8__py3-none-any.whl → 5.4.8__py3-none-any.whl

pyegeria/format_set_executor.py

@@ -26,12 +26,12 @@ from pyegeria.governance_officer import GovernanceOfficer
 from pyegeria.glossary_manager import GlossaryManager
 from pyegeria._globals import NO_ELEMENTS_FOUND
 from pyegeria.config import settings
-from pyegeria.external_references import ExternalReferences
+from pyegeria.external_links import ExternalReferences
 from pyegeria._exceptions_new import PyegeriaException
-from pyegeria._output_formats import (
-    select_output_format_set,
-    get_output_format_set_heading,
-    get_output_format_set_description,
+from pyegeria.base_report_formats import (
+    select_report_spec,
+    get_report_spec_heading,
+    get_report_spec_description,
 )
 
 
@@ -95,7 +95,7 @@ async def _async_run_report(
     user_pwd = egeria_client.user_pwd
 
     # Resolve the format set and action
-    fmt = select_output_format_set(report_name, output_format)
+    fmt = select_report_spec(report_name, output_format)
     if not fmt:
         raise ValueError(
             f"Output format set '{report_name}' does not have a compatible '{output_format}' format."
@@ -133,9 +133,9 @@ async def _async_run_report(
     # Include fixed specifics
     call_params.update(spec_params)
 
-    # Always include output_format and output_format_set for downstream rendering
+    # Always include output_format and report_spec for downstream rendering
     call_params["output_format"] = output_format
-    call_params["output_format_set"] = report_name
+    call_params["report_spec"] = report_name
 
     client_class, method_name = _resolve_client_and_method(func_decl)
 
@@ -173,8 +173,8 @@ async def _async_run_report(
             return {"kind": "empty"}
 
         # Prepare optional preamble for narrative outputs
-        heading = get_output_format_set_heading(report_name)
-        desc = get_output_format_set_description(report_name)
+        heading = get_report_spec_heading(report_name)
+        desc = get_report_spec_description(report_name)
         preamble = f"# {heading}\n{desc}\n\n" if heading and desc else ""
 
         if output_format in {"DICT", "JSON", "ALL"}:
@@ -201,7 +201,7 @@ async def _async_run_report(
 
 
 
-def exec_format_set(
+def exec_report_spec(
     format_set_name: str,
     *,
     output_format: str = "DICT",
@@ -224,7 +224,7 @@ def exec_format_set(
     params = dict(params or {})
 
     # Resolve the format set and action
-    fmt = select_output_format_set(format_set_name, output_format)
+    fmt = select_report_spec(format_set_name, output_format)
     if not fmt:
         raise ValueError(
             f"Output format set '{format_set_name}' does not have a compatible '{output_format}' format."
@@ -255,9 +255,9 @@ def exec_format_set(
     # Include fixed specifics
     call_params.update(spec_params)
 
-    # Always include output_format and output_format_set for downstream rendering
+    # Always include output_format and report_spec for downstream rendering
     call_params["output_format"] = output_format
-    call_params["output_format_set"] = format_set_name
+    call_params["report_spec"] = format_set_name
 
     client_class, method_name = _resolve_client_and_method(func_decl)
     client = client_class(view_server, view_url, user_id=user, user_pwd=user_pass)
@@ -276,8 +276,8 @@ def exec_format_set(
             return {"kind": "empty"}
 
         # Prepare optional preamble for narrative outputs
-        heading = get_output_format_set_heading(format_set_name)
-        desc = get_output_format_set_description(format_set_name)
+        heading = get_report_spec_heading(format_set_name)
+        desc = get_report_spec_description(format_set_name)
         preamble = f"# {heading}\n{desc}\n\n" if heading and desc else ""
 
         if output_format in {"DICT", "JSON", "ALL"}:

pyegeria/glossary_manager.py

@@ -27,7 +27,7 @@ from pyegeria.models import (NewElementRequestBody,
                              ReferenceableProperties, UpdateElementRequestBody, DeleteRequestBody, TemplateRequestBody,
                              NewRelationshipRequestBody, UpdateRelationshipRequestBody, NewClassificationRequestBody,
                              FilterRequestBody, GetRequestBody, SearchStringRequestBody, UpdateStatusRequestBody)
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
+from pyegeria.base_report_formats import select_report_spec, get_report_spec_match
 from pyegeria.output_formatter import (generate_output,
                                        _extract_referenceable_properties, populate_columns_from_properties,
                                        get_required_relationships, populate_common_columns, overlay_additional_values, resolve_output_formats)
@@ -2510,7 +2510,7 @@ class GlossaryManager(CollectionManager):
         # 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', [])
+        columns_list = col_data.get('formats', {}).get('attributes', [])
         try:
             classification_names = ""
             classifications = element.get('elementHeader', {}).get("collectionCategories", [])
@@ -2568,9 +2568,9 @@ class GlossaryManager(CollectionManager):
     def _generate_glossary_output(self, elements: dict | list[dict], search_string: str,
                                   element_type_name: str | None,
                                   output_format: str = 'DICT',
-                                  output_format_set: dict | str = None) -> str | list[dict]:
+                                  report_spec: dict | str = None) -> str | list[dict]:
         entity_type = 'Glossary'
-        output_formats = resolve_output_formats(entity_type, output_format, output_format_set)
+        output_formats = resolve_output_formats(entity_type, output_format, report_spec)
         return generate_output(
             elements=elements,
             search_string=search_string,
@@ -2584,9 +2584,9 @@ class GlossaryManager(CollectionManager):
     def _generate_term_output(self, elements: dict | list[dict], search_string: str,
                                element_type_name: str | None,
                                output_format: str = 'DICT',
-                               output_format_set: dict | str = None) -> str | list[dict]:
+                               report_spec: dict | str = None) -> str | list[dict]:
         entity_type = 'GlossaryTerm'
-        output_formats = resolve_output_formats(entity_type, output_format, output_format_set)
+        output_formats = resolve_output_formats(entity_type, output_format, report_spec)
         return generate_output(
             elements=elements,
             search_string=search_string,
@@ -2645,56 +2645,56 @@ class GlossaryManager(CollectionManager):
                                      metadata_element_types: list[str] = ["Glossary"],
                                      starts_with: bool = False, 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,
+                                     report_spec: str | dict  = None,
                                      body: dict | SearchStringRequestBody = None) -> list | str:
 
         response = await self._async_find_collections(search_string, classificaton_names,
                                                       metadata_element_types, starts_with, ends_with, ignore_case,
-                                                      start_from, page_size, output_format, output_format_set, body)
+                                                      start_from, page_size, output_format, report_spec, body)
         return response
 
     def find_glossaries(self, search_string: str = "*", classificaton_names: list[str] = None,
                                      metadata_element_types: list[str] = ["Glossary"],
                                      starts_with: bool = False, 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,
+                                     report_spec: str | dict  = None,
                                      body: dict | SearchStringRequestBody = None) -> list | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-                    self._async_find_glossaries(search_string,  classificaton_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body))
+                    self._async_find_glossaries(search_string,  classificaton_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, report_spec, body))
         return response
 
     async def _async_get_glossaries_by_name(self, filter_string: str = None, classification_names: list[str] = None,
                                              body: dict | FilterRequestBody = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> dict | str:
-        return await self._async_get_collections_by_name(filter_string, classification_names, body, start_from, page_size, output_format, output_format_set)
+                                             report_spec: str | dict = None) -> dict | str:
+        return await self._async_get_collections_by_name(filter_string, classification_names, body, start_from, page_size, output_format, report_spec)
 
 
     def get_glossaries_by_name(self, filter_string: str = None, classification_names: list[str] = None,
                                              body: dict | FilterRequestBody = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> dict | str:
+                                             report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_glossaries_by_name(filter_string, classification_names, body,start_from, page_size,
-                                               output_format, output_format_set))
+                                               output_format, report_spec))
         return response
 
     async def _async_get_glossary_by_guid(self, glossary_guid: str, element_type: str = "Glossary", body: dict | GetRequestBody = None,
-                                          output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                                          output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
 
-        return await self._async_get_collection_by_guid(glossary_guid, element_type, body, output_format, output_format_set)
+        return await self._async_get_collection_by_guid(glossary_guid, element_type, body, output_format, report_spec)
 
 
 
     def get_glossary_by_guid(self, glossary_guid: str, element_type: str = "Glossary", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_by_guid(glossary_guid, element_type, body,output_format, output_format_set))
+            self._async_get_glossary_by_guid(glossary_guid, element_type, body,output_format, report_spec))
         return response
 
 
@@ -2703,7 +2703,7 @@ class GlossaryManager(CollectionManager):
                                              body: dict | FilterRequestBody = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list:
+                                             report_spec: str | dict = None) -> list:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
                f"terms/by-name")
         response = await self._async_get_name_request(url, _type="GlossaryTerm",
@@ -2711,7 +2711,7 @@ class GlossaryManager(CollectionManager):
                                                       filter_string=filter_string,
                                                       classification_names=classification_names,
                                                       start_from=start_from, page_size=page_size,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
         return response
 
@@ -2719,34 +2719,34 @@ class GlossaryManager(CollectionManager):
                                              body: dict | FilterRequestBody = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list:
+                                             report_spec: str | dict = None) -> list:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_terms_by_name(filter_string, classification_names, body,start_from, page_size,
-                                           output_format, output_format_set))
+                                           output_format, report_spec))
         return response
 
     async def _async_get_term_by_guid(self, term_guid: str, element_type: str = "GlossaryTerm", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
                f"{term_guid}")
         response = await self._async_get_guid_request(url, _type=element_type,
                                                       _gen_output=self._generate_term_output,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
         return response
 
     def get_term_by_guid(self, term_guid: str, element_type: str = "GlossaryTerm", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, element_type, body,  output_format, output_format_set))
+        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, element_type, body,  output_format, report_spec))
         return response
 
     async def _async_find_glossary_terms(self, search_string: str, starts_with: bool = True,
                                      ends_with: bool = False, ignore_case: bool = False, type_name: str = "GlossaryTerm",
                                      classification_names: list[str] = None, start_from: int = 0,
                                      page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict = "Glossary-Term-DrE", body: dict = None) -> list | str:
+                                     report_spec: str | dict = "Glossary-Term-DrE", body: dict = None) -> list | str:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
                f"by-search-string")
         response = await self._async_find_request(url, _type= type_name,
@@ -2755,7 +2755,7 @@ class GlossaryManager(CollectionManager):
                                                   metadata_element_types = ["GlossaryTerm"],
                                                   starts_with = starts_with, ends_with = ends_with, ignore_case = ignore_case,
                                                   start_from = start_from, page_size = page_size,
-                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  output_format=output_format, report_spec=report_spec,
                                                   body=body)
         return response
 
@@ -2763,13 +2763,13 @@ class GlossaryManager(CollectionManager):
                                      ends_with: bool = False, ignore_case: bool = False, type_name: str = "GlossaryTerm",
                                      classification_names: list[str] = None, start_from: int = 0,
                                      page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict = None, body: dict = None) -> list | str:
+                                     report_spec: str | dict = None, body: dict = None) -> list | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_glossary_terms(search_string, starts_with,
                                             ends_with, ignore_case, type_name,classification_names,
                                             start_from,
-                                            page_size, output_format, output_format_set, body))
+                                            page_size, output_format, report_spec, body))
         return response
 
 

pyegeria/governance_officer.py

@@ -24,7 +24,7 @@ from pyegeria.output_formatter import (
     get_required_relationships,
     populate_common_columns,
 )
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
+from pyegeria.base_report_formats import select_report_spec, get_report_spec_match
 
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 from pyegeria._exceptions_new import PyegeriaInvalidParameterException
@@ -106,7 +106,7 @@ class GovernanceOfficer(Client2):
     # Extract properties functions
     #
     def _generate_governance_definition_output(self, elements: list | dict, search_string: str, element_type_name: str = None,
-                                               output_format: str = 'DICT', output_format_set: dict | str = None
+                                               output_format: str = 'DICT', report_spec: dict | str = None
                                                ) -> str | list:
         """
         Render governance definitions using the shared output pipeline.
@@ -121,7 +121,7 @@ class GovernanceOfficer(Client2):
             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
+        report_spec : 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".
 
@@ -136,18 +136,18 @@ class GovernanceOfficer(Client2):
 
         entity_type = element_type_name if element_type_name else "Governance Definition"
         # Resolve columns_struct via output format sets
-        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)
+        if report_spec:
+            if isinstance(report_spec, str):
+                output_formats = select_report_spec(report_spec, output_format)
+            elif isinstance(report_spec, dict):
+                output_formats = get_report_spec_match(report_spec, output_format)
             else:
                 output_formats = None
         else:
             # Default to the Governance Definitions format set
-            output_formats = select_output_format_set("Governance Definitions", output_format)
+            output_formats = select_report_spec("Governance Definitions", output_format)
         if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
+            output_formats = select_report_spec("Default", output_format)
 
         logger.trace(f"Executing generate_governance_definition_output: {output_formats}")
         return generate_output(
@@ -1672,7 +1672,7 @@ class GovernanceOfficer(Client2):
                                                  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: dict = None,
+                                                 output_format: str = 'JSON', report_spec: dict = None,
                                                  body: dict | SearchStringRequestBody = None,
                                                  ) -> list | str:
         """ Retrieve the list of governance definition metadata elements that contain the search string.
@@ -1741,7 +1741,7 @@ class GovernanceOfficer(Client2):
                                               metadata_element_types=metadata_element_types,
                                               starts_with=starts_with, ends_with=ends_with, ignore_case=ignore_case,
                                               start_from=start_from, page_size=page_size,
-                                              output_format=output_format, output_format_set=output_format_set,
+                                              output_format=output_format, report_spec=report_spec,
                                               body=body)
 
     @dynamic_catch
@@ -1749,7 +1749,7 @@ class GovernanceOfficer(Client2):
                                     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: dict = None,
+                                    output_format: str = 'JSON', report_spec: dict = None,
                                     body: dict | SearchStringRequestBody = None, ) -> list | str:
         """ Retrieve the list of governance definition metadata elements that contain the search string.
 
@@ -1810,7 +1810,7 @@ class GovernanceOfficer(Client2):
         response = loop.run_until_complete(
             self._async_find_governance_definitions(search_string, classification_names, metadata_element_types,
                                                     starts_with, ends_with, ignore_case, start_from,
-                                                    page_size, output_format, output_format_set, body))
+                                                    page_size, output_format, report_spec, body))
         return response
 
     @dynamic_catch
@@ -1819,7 +1819,7 @@ class GovernanceOfficer(Client2):
                                                         body: dict | FilterRequestBody = None,
                                                         start_from: int = 0, page_size: int = 0,
                                                         output_format: str = "JSON",
-                                                        output_format_set: dict = None) -> list | str:
+                                                        report_spec: dict = None) -> list | str:
         """ Returns the list of governance definitions with a particular name. Async Version.
 
             Parameters
@@ -1877,7 +1877,7 @@ class GovernanceOfficer(Client2):
                                                       filter_string=filter_string,
                                                       classification_names=classification_names,
                                                       start_from=start_from, page_size=page_size,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
 
         return response
@@ -1887,7 +1887,7 @@ class GovernanceOfficer(Client2):
                                            body: dict | FilterRequestBody = None,
                                            start_from: int = 0, page_size: int = 0,
                                            output_format: str = "JSON",
-                                           output_format_set: dict = None) -> list | str:
+                                           report_spec: dict = None) -> list | str:
         """ Returns the list of governance definitions with a particular name."""
 
         """ Returns the list of information governance definitions with a particular name. Async Version.
@@ -1947,14 +1947,14 @@ class GovernanceOfficer(Client2):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_governance_definitions_by_name(filter_string, classification_names, body,
-                                                           start_from, page_size, output_format, output_format_set))
+                                                           start_from, page_size, output_format, report_spec))
         return response
 
     @dynamic_catch
     async def _async_get_governance_definition_by_guid(self, guid: str, element_type: str = None,
                                                        body: dict | FilterRequestBody = None,
                                                        output_format: str = "JSON",
-                                                       output_format_set: dict = None) -> dict | str:
+                                                       report_spec: dict = None) -> dict | str:
 
         """ Get governance definition by guid.
             Async version.
@@ -2008,7 +2008,7 @@ class GovernanceOfficer(Client2):
 
         response = await self._async_get_guid_request(url, _type=type,
                                                       _gen_output=self._generate_governance_definition_output,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
 
         return response
@@ -2016,7 +2016,7 @@ class GovernanceOfficer(Client2):
     @dynamic_catch
     def get_governance_definition_by_guid(self, guid: str, element_type: str = None, body: dict = None,
                                           output_format: str = "JSON",
-                                          output_format_set: dict = None) -> dict | str:
+                                          report_spec: dict = None) -> dict | str:
 
         """ Get governance definition by guid.
 
@@ -2063,7 +2063,7 @@ class GovernanceOfficer(Client2):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(self._async_get_governance_definition_by_guid(guid, element_type, body,
                                                                                          output_format,
-                                                                                         output_format_set))
+                                                                                         report_spec))
         return response
 
     @dynamic_catch

pyegeria/mcp_adapter.py

@@ -15,12 +15,12 @@ from typing import Any, Dict, Optional
 
 from loguru import logger
 
-from pyegeria._output_formats import (
+from pyegeria.base_report_formats import (
     list_mcp_format_sets,
-    select_output_format_set,
+    select_report_spec,
 )
 from pyegeria.egeria_tech_client import EgeriaTech
-from pyegeria.format_set_executor import exec_format_set, _async_run_report
+from pyegeria.format_set_executor import exec_report_spec, _async_run_report
 
 
 def list_reports() -> dict:
@@ -33,7 +33,7 @@ def describe_report(name: str, output_type: str = "DICT") -> Dict[str, Any]:
     Describe a format set for MCP discovery. If outputType != ANY, a concrete format
     will be resolved; otherwise only metadata/action are returned.
     """
-    meta = select_output_format_set(name, output_type)
+    meta = select_report_spec(name, output_type)
     if not meta:
         raise ValueError(f"Unknown or incompatible format set: {name}")
     return meta
@@ -62,7 +62,7 @@ def _execute_egeria_call_blocking(
     from pyegeria.config import settings as _settings
 
 
-    return exec_format_set(
+    return exec_report_spec(
         format_set_name=report,
         output_format="DICT",
         params=params or {},
@@ -97,7 +97,7 @@ def run_report(
     # Lazy import of settings to avoid circulars when optional args are None
     from pyegeria.config import settings as _settings
     logger.info(f"Format set: {report}\nparams: {json.dumps(params)}\nview_server: {view_server}\nview_url: {view_url}\nuser: {user}\nuser_pass: {user_pass}")
-    return exec_format_set(
+    return exec_report_spec(
         format_set_name=report,
         output_format="DICT",
         params=params or {},