pyegeria 5.4.4.8__py3-none-any.whl → 5.4.6__py3-none-any.whl

pyegeria/automated_curation.py

@@ -54,7 +54,7 @@ class AutomatedCuration(Client2):
         Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token=token)
         self.curation_command_root = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/automated-curation"
 
-    async def _async_create_element_from_template(self, body: dict) -> str:
+    async def _async_create_elem_from_template(self, body: dict) -> str:
         """Create a new metadata element from a template.  Async version.
         Parameters
         ----------
@@ -99,9 +99,9 @@ class AutomatedCuration(Client2):
         """
 
         url = f"{self.curation_command_root}/catalog-templates/new-element"
-        return await self._async_create_elem_from_template(url, body)
+        return await self._async_create_element_from_template(url, body)
 
-    def create_element_from_template(self, body: dict) -> str:
+    def create_elem_from_template(self, body: dict) -> str:
         """Create a new metadata element from a template.  Async version.
         Parameters
         ----------
@@ -147,10 +147,11 @@ class AutomatedCuration(Client2):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_element_from_template(body)
+            self._async_create_elem_from_template(body)
         )
         return response
 
+
     async def _async_create_kafka_server_element_from_template(
             self,
             kafka_server: str,
@@ -194,7 +195,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        return await self._async_create_element_from_template(body_s)
+        return await self._async_create_elem_from_template(body_s)
 
     def create_kafka_server_element_from_template(
             self,
@@ -289,7 +290,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        return await self._async_create_element_from_template(body_s)
+        return await self._async_create_elem_from_template(body_s)
 
     def create_csv_data_file_element_from_template(
             self,
@@ -337,6 +338,112 @@ class AutomatedCuration(Client2):
         )
         return response
 
+    async def _async_get_create_csv_data_file_element_from_template(
+            self,
+            file_name: str,
+            file_type: str,
+            file_path_name: str,
+            version_identifier: str,
+            file_encoding: str = "UTF-8",
+            file_extension: str = "csv",
+            file_system_name: str = None,
+            description: str = None,
+    ) -> str:
+        """Create a CSV file element from a template if it doesn't exist. If it does exist,
+           the guid will be returned. Async version.
+
+        Parameters
+        ----------
+        file_name : str
+            The name of the Kafka server.
+        file_type : str
+            The host name of the Kafka server.
+        file_path_name : str
+            The port number of the Kafka server.
+        version_identifier : str
+            The version identifier of the CSV file..
+        file_encoding: str, opt, default UTF-8
+            The encoding of the CSV file.
+        file_extension: str, opt, default is CSV
+            File extension of the CSV file.
+        file_system_name: str, opt
+            Name of the file system the CSV file is hosted on.
+        description: str, opt
+            A description of the CSV file..
+
+
+        Returns
+        -------
+        str
+            The GUID of the CSV File element.
+        """
+        template_guid = await self._async_get_template_guid_for_technology_type("CSV Data File")
+        body = {
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
+            "isOwnAnchor": True,
+            "allowRetrieve" : True,
+            "placeholderPropertyValues": {
+                "fileName": file_name,
+                "fileType": file_type,
+                "filePathName": file_path_name,
+                "versionIdentifier": version_identifier,
+                "fileEncoding": file_encoding,
+                "fileExtension": file_extension,
+                "fileSystemName": file_system_name,
+                "description": description
+            },
+        }
+        body_s = body_slimmer(body)
+        return await self._async_create_elem_from_template(body_s)
+
+    def get_create_csv_data_file_element_from_template(
+            self,
+            file_name: str,
+            file_type: str,
+            file_path_name: str,
+            version_identifier: str,
+            file_encoding: str = "UTF-8",
+            file_extension: str = "csv",
+            file_system_name: str = None,
+            description: str = None,
+    ) -> str:
+        """Create a CSV file element from a template if it doesn't exist. If it does exist,
+           the guid will be returned.
+
+        Parameters
+        ----------
+        file_name : str
+            The name of the Kafka server.
+        file_type : str
+            The host name of the Kafka server.
+        file_path_name : str
+            The port number of the Kafka server.
+        version_identifier : str
+            The version identifier of the CSV file..
+        file_encoding: str, opt, default UTF-8
+            The encoding of the CSV file.
+        file_extension: str, opt, default is CSV
+            File extension of the CSV file.
+        file_system_name: str, opt
+            Name of the file system the CSV file is hosted on.
+        description: str, opt
+            A description of the CSV file..
+
+        Returns
+        -------
+        str
+            The GUID of the CSV File element.
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_create_csv_data_file_element_from_template(
+                file_name, file_type, file_path_name, version_identifier,
+                file_encoding, file_extension, file_system_name, description
+            )
+        )
+        return response
+
     async def _async_create_postgres_server_element_from_template(
             self,
             postgres_server: str,
@@ -391,7 +498,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        return await self._async_create_element_from_template(body_s)
+        return await self._async_create_elem_from_template(body_s)
 
     def create_postgres_server_element_from_template(
             self,
@@ -490,7 +597,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_postgres_database_element_from_template(
@@ -592,7 +699,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_folder_element_from_template(
@@ -687,7 +794,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_server_element_from_template(
@@ -776,7 +883,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_catalog_element_from_template(
@@ -866,7 +973,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_schema_element_from_template(
@@ -977,7 +1084,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_table_element_from_template(
@@ -1097,7 +1204,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_function_element_from_template(
@@ -1214,7 +1321,7 @@ class AutomatedCuration(Client2):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
+        response = await self._async_create_elem_from_template(body_s)
         return str(response)
 
     def create_uc_volume_element_from_template(

pyegeria/collection_manager.py

@@ -5571,8 +5571,34 @@ class CollectionManager(Client2):
         if isinstance(resources, (list | dict)):
             resource_list = ""
             for resource in resources:
-                resource_list += f"{resource['resourceList']['properties']['qualifiedName']}, "
-            added_props["resource_list"] = resource_list[:-2]
+                resource_list += f"{resource.get('properties',{}).get('qualifiedName', None)}, "
+            added_props["resource_list"] = resource_list[:-2] if resource_list else ""
+
+        actors = element.get("assignedActors", "")
+        if isinstance(actors, (list | dict)):
+            actor_list = ""
+            for actor in actors:
+                actor_type = actor['relatedElement']['elementHeader']['type']['typeName']
+                actor_qname = actor['relatedElement']['properties']['qualifiedName']
+                actor_list += actor_qname
+            added_props["actor_list"] = actor_list[:-2] if actor_list else ""
+
+        governed_by = element.get("governedBy", "")
+        if isinstance(governed_by, (list | dict)):
+            governed_by_list = ""
+            for gov in governed_by:
+                license_type = gov['relatedElement']['properties'].get('typeName',"")
+                license_type_qname = gov['relatedElement']['properties'].get('qualifiedName','')
+                governed_by_list += license_type_qname
+            added_props["governed_list"] = governed_by_list[:-2] if governed_by_list else ""
+
+        solution_designs = element.get("solutionDesigns", "")
+        if isinstance(solution_designs, (list | dict)):
+            solution_design_list = ""
+            for design in solution_designs:
+                solution_design_qname = design['relatedElement']['properties'].get('qualifiedName', "")
+                solution_design_list += solution_design_qname
+            added_props["solution_design_list"] = solution_design_list[:-2] if solution_design_list else ""
 
         return added_props
 

pyegeria/data_designer.py

@@ -280,7 +280,7 @@ class DataDesigner(Client2):
 
         """
         url = f"{self.data_designer_root}/data-structures/from-template"
-        return await self._async_create_elem_from_template(url, body)
+        return await self._async_create_element_from_template(url, body)
 
     @dynamic_catch
     def create_data_structure_from_template(self, body: dict | TemplateRequestBody) -> str:
@@ -1696,7 +1696,7 @@ class DataDesigner(Client2):
 
         url = f"{base_path(self, self.view_server)}/data-fields/from-template"
 
-        return await self._async_create_elem_from_template(url, body)
+        return await self._async_create_element_from_template(url, body)
 
     @dynamic_catch
     def create_data_field_from_template(self, body: dict | TemplateRequestBody) -> str:
@@ -2945,7 +2945,7 @@ class DataDesigner(Client2):
         """
 
         url = f"{base_path(self, self.view_server)}/data-classes/from-template"
-        return await self._async_create_elem_from_template(url, body)
+        return await self._async_create_element_from_template(url, body)
 
     @dynamic_catch
     def create_data_class_from_template(self, body: dict | TemplateRequestBody) -> str:

pyegeria/format_set_executor.py

@@ -0,0 +1,159 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+A pure helper to execute a FormatSet action and return normalized results without side effects
+(printing or writing to disk). This is suitable for programmatic use (e.g., MCP adapters,
+notebooks, services) that want DICT/JSON or text output directly.
+
+Notes
+- Only use this for read-style format sets. It assumes the action is safe to call.
+- Credentials and endpoints default from pyegeria.config.settings (ENV/config.json/ENV files).
+- Prefer output_format="DICT" for machine-consumable results. REPORT/HTML/MERMAID are returned as text.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Optional
+
+from loguru import logger
+
+from pyegeria import (
+    EgeriaTech,
+    CollectionManager,
+    GovernanceOfficer,
+    GlossaryManager,
+    NO_ELEMENTS_FOUND,
+)
+from pyegeria.config import settings
+from pyegeria.external_references 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,
+)
+
+
+_CLIENT_CLASS_MAP = {
+    "CollectionManager": CollectionManager,
+    "GovernanceOfficer": GovernanceOfficer,
+    "GlossaryManager": GlossaryManager,
+    "ExternalReference": ExternalReferences,
+}
+
+
+def _resolve_client_and_method(func_decl: str):
+    """Given a function declaration like 'ClassName.method', return (client_class, method_name)."""
+    if not isinstance(func_decl, str) or "." not in func_decl:
+        return (EgeriaTech, None)
+    class_name, method_name = func_decl.split(".", 1)
+    client_class = _CLIENT_CLASS_MAP.get(class_name, EgeriaTech)
+    return (client_class, method_name)
+
+
+def run_format_set_action_return(
+    format_set_name: str,
+    *,
+    output_format: str = "DICT",
+    params: Optional[Dict[str, Any]] = None,
+    view_server: str = settings.Environment.egeria_view_server,
+    view_url: str = settings.Environment.egeria_view_server_url,
+    user: str = settings.User_Profile.user_name,
+    user_pass: str = settings.User_Profile.user_pwd,
+) -> Dict[str, Any]:
+    """
+    Execute the action for a given format set and return a normalized result structure.
+
+    Returns shapes:
+    - {"kind":"empty"}
+    - {"kind":"json","data": <list|dict|any>}
+    - {"kind":"text","mime": "text/markdown"|"text/html","content": str}
+    - {"kind":"unknown","raw": any}
+    """
+    output_format = (output_format or "DICT").upper()
+    params = dict(params or {})
+
+    # Resolve the format set and action
+    fmt = select_output_format_set(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."
+        )
+    if "action" not in fmt:
+        raise ValueError(f"Output format set '{format_set_name}' does not have an action property.")
+
+    action = fmt["action"]
+    func_decl = action.get("function")
+    required_params = action.get("required_params", action.get("user_params", [])) or []
+    optional_params = action.get("optional_params", []) or []
+    spec_params = action.get("spec_params", {}) or {}
+
+    # Build call params: required/optional provided by caller + fixed spec_params
+    call_params: Dict[str, Any] = {}
+
+    # Populate required and optional params when provided
+    for p in required_params:
+        if p in params and params[p] is not None:
+            call_params[p] = params[p]
+        elif p not in spec_params:
+            # Missing required param
+            logger.warning(f"Required parameter '{p}' not provided for format set '{format_set_name}'.")
+    for p in optional_params:
+        if p in params and params[p] is not None:
+            call_params[p] = params[p]
+
+    # Include fixed specifics
+    call_params.update(spec_params)
+
+    # Always include output_format and output_format_set for downstream rendering
+    call_params["output_format"] = output_format
+    call_params["output_format_set"] = 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)
+
+    try:
+        client.create_egeria_bearer_token()
+        func = getattr(client, method_name) if method_name and hasattr(client, method_name) else None
+        if func is None:
+            raise AttributeError(
+                f"Method '{method_name}' not found in client class '{client_class.__name__}'."
+            )
+
+        result = func(**call_params)
+
+        if not result or result == NO_ELEMENTS_FOUND:
+            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)
+        preamble = f"# {heading}\n{desc}\n\n" if heading and desc else ""
+
+        if output_format in {"DICT", "JSON", "ALL"}:
+            # Return raw data (list/dict/any) — do not stringify here
+            return {"kind": "json", "data": result}
+        elif output_format in {"REPORT", "MERMAID"}:
+            content = result
+            if isinstance(result, (list, dict)):
+                # Make a simple JSON code block if the source returned structured data unexpectedly
+                content = preamble + "```json\n" + json.dumps(result, indent=2) + "\n```"
+            else:
+                content = preamble + str(result)
+            return {"kind": "text", "mime": "text/markdown", "content": content}
+        elif output_format == "HTML":
+            content = str(result)
+            return {"kind": "text", "mime": "text/html", "content": content}
+        else:
+            # Unknown or table-like formats which aren't appropriate for MCP by default
+            return {"kind": "unknown", "raw": result}
+
+    except PyegeriaException as e:
+        # Re-raise with a simpler message for upstream mapping
+        raise
+    finally:
+        try:
+            client.close_session()
+        except Exception:
+            pass

pyegeria/mcp_adapter.py

@@ -0,0 +1,110 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+
+Thin adapter helpers to surface pyegeria FormatSets as MCP-style tools without
+side effects. This does NOT implement an MCP transport/server; it focuses on
+programmatic functions that an MCP server entry point can call.
+
+Only format sets that advertise DICT or ALL are considered eligible.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import asyncio
+
+from loguru import logger
+from typing import Any, Dict, Optional
+
+from loguru import logger
+
+from pyegeria._output_formats import (
+    list_mcp_format_sets,
+    select_output_format_set,
+    get_output_format_type_match,
+)
+from pyegeria.format_set_executor import run_format_set_action_return
+
+
+def list_reports() -> dict:
+    """List eligible format sets as MCP tools (support DICT or ALL)."""
+    return  list_mcp_format_sets()
+
+
+def describe_report(name: str, outputType: 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, outputType)
+    if not meta:
+        raise ValueError(f"Unknown or incompatible format set: {name}")
+    return meta
+
+
+def _execute_egeria_call_blocking(
+        *,
+        report: str,
+        params: Optional[Dict[str, Any]] = None,
+        view_server: Optional[str] = None,
+        view_url: Optional[str] = None,
+        user: Optional[str] = None,
+        user_pass: Optional[str] = None,) -> Dict[str, Any]:
+    """
+    Executes the synchronous, blocking Egeria client call on a dedicated worker thread.
+
+    You must replace the hardcoded return with your actual Egeria client logic here.
+    All code in this function runs in a blocking, synchronous manner.
+    """
+
+    print(
+        f"Format set: {report}\nparams: {json.dumps(params)}\nview_server: {view_server}\nview_url: {view_url}\nuser: {user}\nuser_pass: {user_pass}",
+        file=sys.stderr)
+    # Lazy import of settings to avoid circulars when optional args are None
+    # from pyegeria.config import settings as _settings
+    from pyegeria.config import settings as _settings
+
+
+    return run_format_set_action_return(
+        format_set_name=report,
+        output_format="DICT",
+        params=params or {},
+        view_server=view_server if view_server is not None else _settings.Environment.egeria_view_server,
+        view_url=view_url if view_url is not None else _settings.Environment.egeria_view_server_url,
+        user=user if user is not None else _settings.User_Profile.user_name,
+        user_pass=user_pass if user_pass is not None else _settings.User_Profile.user_pwd,
+    )
+    # # Returning the hardcoded success for now to prove the async structure works.
+    # return {
+    #     "status": "SUCCESS (Thread Test)",
+    #     "report_name": report_name,
+    #     "message": "The blocking call was successfully run on a separate thread, preventing timeout."
+    # }
+
+
+def run_report(
+    *,
+    report: str,
+    params: Optional[Dict[str, Any]] = None,
+    view_server: Optional[str] = None,
+    view_url: Optional[str] = None,
+    user: Optional[str] = None,
+    user_pass: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Execute a format set action as an MCP-style tool. Enforces DICT/ALL by default.
+    Caller may pass credentials explicitly; otherwise defaults are used from config.
+    """
+    print(f"Format set: {report}\nparams: {json.dumps(params)}\nview_server: {view_server}\nview_url: {view_url}\nuser: {user}\nuser_pass: {user_pass}", file=sys.stderr)
+    # Lazy import of settings to avoid circulars when optional args are None
+    from pyegeria.config import settings as _settings
+    logger.info(f"Format set: {formatSet}\nparams: {json.dumps(params)}\nview_server: {view_server}\nview_url: {view_url}\nuser: {user}\nuser_pass: {user_pass}")
+    return run_format_set_action_return(
+        format_set_name=report,
+        output_format="DICT",
+        params=params or {},
+        view_server=view_server if view_server is not None else _settings.Environment.egeria_view_server,
+        view_url=view_url if view_url is not None else _settings.Environment.egeria_view_server_url,
+        user=user if user is not None else _settings.User_Profile.user_name,
+        user_pass=user_pass if user_pass is not None else _settings.User_Profile.user_pwd,
+    )