pyegeria 5.4.5__py3-none-any.whl → 5.4.7__py3-none-any.whl

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,
+    )

pyegeria/mcp_server.py

@@ -0,0 +1,172 @@
+"""PDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+This module provides a basic MCP server for Egeria.
+"""
+import asyncio
+import re
+import sys
+from typing import Any, Dict, Optional, List, Coroutine
+
+try:
+    # We use Optional[] and List[] types, so we import them.
+    from mcp.server.fastmcp import FastMCP
+    print("MCP import successful...", file=sys.stderr)
+except ImportError:
+    print("MCP import failed.", file=sys.stderr)
+    raise
+
+from pyegeria.mcp_adapter import (
+    list_reports,
+    describe_report,
+    run_report, _execute_egeria_call_blocking,
+)
+
+
+def _ok(result: Dict[str, Any] ) -> Dict[str, Any]:
+    # Pass-through helper in case you want to normalize or add metadata
+    print("OK: Operation completed successfully.", file=sys.stderr)
+    return result
+
+
+def main() -> None:
+    # Initialize the server
+    srv = FastMCP(name="pyegeria-mcp")
+    print("Starting MCP server...", file=sys.stderr)
+
+    # list_reports tool (formerly list_format_sets)
+    @srv.tool(name="list_reports")
+    def list_reports_tool() -> Dict[str, Any]:
+        """Lists all available reports (FormatSets)."""
+        print("DEBUG: Listing reports...", file=sys.stderr)
+        return _ok(list_reports())
+
+    # describe_report tool (formerly describe_format_set)
+    @srv.tool(name="describe_report")
+    def describe_report_tool(name: str, output_type: str = "DICT") -> Dict[str, Any]:
+        """Returns the schema and details for a specified report."""
+        # FastMCP handles validation of 'name' and 'output_type' types automatically.
+        print(f"DEBUG: Describing report: {name} with output type: {output_type}", file=sys.stderr)
+        try:
+            return _ok(describe_report(name, output_type))
+        except Exception as e:
+            print(f"DEBUG: Exception during describe_report: {str(e)}", file=sys.stderr)
+            raise
+
+    # run_report tool (formerly run_format_set_action)
+    @srv.tool(name="run_report")
+    async def run_report_tool(
+            report_name: str,
+            search_string: str = "*",
+            page_size: Optional[int] = None,
+            start_from: Optional[int] = None,
+            starts_with: Optional[bool] = None,
+            ends_with: Optional[bool] = None,
+            ignore_case: Optional[bool] = None,
+            output_format: str = "DICT"
+    ) -> Dict[str, Any]:
+
+        """Run a report with the specified parameters."""
+        print("DEBUG: Running report...", file=sys.stderr)
+        # 1. Automatic Validation: FastMCP/Pydantic ensures types are correct.
+
+        # 2. Manual Validation (for specific values like output_format)
+        if output_format not in ["DICT", "JSON", "REPORT", "MERMAID", "HTML"]:
+            print(f"DEBUG: Invalid output_format: {output_format}", file=sys.stderr)
+            raise ValueError(
+                f"Invalid output_format: {output_format}. Must be one of ['DICT', 'JSON', 'REPORT', 'MERMAID', 'HTML'].")
+
+        # 3. Build params dictionary with only non-None values for clean passing
+        params = {
+            "search_string": search_string,
+            "page_size": page_size,
+            "start_from": start_from,
+            "starts_with": starts_with,
+            "ends_with": ends_with,
+            "ignore_case": ignore_case,
+        }
+        # Filter out None values before passing to run_report
+        params = {k: v for k, v in params.items() if v is not None}
+
+        print(f"DEBUG: Running report={report_name} with params={params}", file=sys.stderr)
+
+        try:
+
+            result = await asyncio.to_thread(
+                _execute_egeria_call_blocking,
+                report = report_name,
+                params = params
+            )
+            print("DEBUG: run_report completed successfully", file=sys.stderr)
+            return _ok(result)
+        except Exception as e:
+            # Re-raise the exception to be sent back as a JSON-RPC error
+            print(f"DEBUG: Exception occurred: {str(e)}", file=sys.stderr)
+            raise
+
+    @srv.tool(name="prompt")
+    def natural_language_prompt(prompt: str) -> Dict[str, Any]:
+        """
+        Handles natural language queries from the user.
+        In a production environment, this would call an LLM API.
+        """
+        print(f"DEBUG: Received natural language prompt: {prompt}", file=sys.stderr)
+
+        # Example of simple logic: If the user asks to list reports, delegate to the tool.
+        if "list" in prompt.lower() and "reports" in prompt.lower():
+            print("DEBUG: Delegating prompt to list_reports tool.", file=sys.stderr)
+            return list_reports()  # Call the standard tool function directly
+        elif "run" in prompt.lower() and "report" in prompt.lower():
+            print("DEBUG: Delegating prompt to run_report tool.", file=sys.stderr)
+            # Simple entity extraction for report name (Requires more robust logic in reality!)
+            # Let's assume the report name is the word immediately following "report"
+
+            match = re.search(r'report\s+([a-zA-Z0-9]+)', prompt, re.IGNORECASE)
+            report_name = match.group(1) if match else None
+
+            if report_name:
+                print(f"DEBUG: Extracted report name: {report_name}", file=sys.stderr)
+
+                # Use another simple regex to look for page size
+                page_size_match = re.search(r'page size of\s+(\d+)', prompt, re.IGNORECASE)
+                page_size = int(page_size_match.group(1)) if page_size_match else None
+
+                search_match = re.search(r'search for\s+(.*?)(?:\s+in\s+report|\.|$)', prompt, re.IGNORECASE)
+
+                if search_match:
+                    # Extract the content captured by the group (.*?)
+                    search_string = search_match.group(1).strip()
+
+                    # Check if the search string is meaningful
+                    if search_string:
+                        # Use a default report for demonstration purposes
+
+                        print(
+                            f"DEBUG: Delegating prompt to run_report tool. Report: {report_name}, Search: '{search_string}'",
+                            file=sys.stderr)
+
+                        # Call the standard tool function with extracted parameters
+                        return run_report_tool(
+                            report_name=report_name,
+                            page_size=page_size,
+                            search_string=search_string
+                        )
+
+                # Delegate to the run_report_tool with the extracted parameters
+                return run_report_tool(
+                    report_name=report_name,
+                    page_size=page_size
+                )
+        # Fallback: Just confirm the prompt was received.
+        return {
+            "response": f"Acknowledged natural language query: '{prompt}'. This would be sent to an LLM."
+        }
+
+    # CRITICAL: This is the missing step. It tells the server to read and process
+    # JSON-RPC messages from standard input (stdin).
+    srv.run()
+    print("MCP server finished running.", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

pyegeria/project_manager.py

@@ -915,7 +915,7 @@ class ProjectManager(Client2):
         """
 
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/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_project_from_template(

pyegeria/reference_data.py

@@ -652,7 +652,7 @@ class ReferenceDataManager(Client2):
         """
 
         url = f"{self.ref_data_command_base}/valid-value-definitions/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_valid_value_definition_from_template(

pyegeria/x_action_author_omvs.py

@@ -49,7 +49,7 @@ class ActionAuthor(AutomatedCuration):
         )
         self.action_command_root = f"{platform_url}/servers/"
 
-    async def _async_create_elem_from_template(
+    async def _async_x_create_element_from_template(
         self, body: str, server: str = None
     ) -> str:
         """Create a metadata element from a template.  Async version.

{pyegeria-5.4.5.dist-info → pyegeria-5.4.7.dist-info}/METADATA

@@ -1,40 +1,37 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pyegeria
-Version: 5.4.5
+Version: 5.4.7
 Summary: A python client for Egeria
-License: Apache 2.0
+Author-email: Dan Wolfson <dan.wolfson@pdr-associates.com>
+License-Expression: Apache-2.0
 Keywords: egeria,metadata,governance
-Author: Dan Wolfson
-Author-email: dan.wolfson@pdr-associates.com
-Requires-Python: >3.12,<4.0.0
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: click
+Requires-Python: >3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: httpx
-Requires-Dist: inflect (>=7.5.0,<8.0.0)
-Requires-Dist: jupyter
-Requires-Dist: jupyter-notebook-parser (>=0.1.4,<0.2.0)
-Requires-Dist: loguru (>=0.7.3,<0.8.0)
-Requires-Dist: mermaid-py
-Requires-Dist: poetry-core (>=2.1.3,<3.0.0)
-Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
-Requires-Dist: pydantic (>=2.11.7,<3.0.0)
-Requires-Dist: pydantic-settings (>=2.10.1,<3.0.0)
-Requires-Dist: pydevd-pycharm (>=252.23892.364,<253.0.0)
-Requires-Dist: pytest (>=8.3.5,<9.0.0)
-Requires-Dist: requests
 Requires-Dist: rich
-Requires-Dist: textual
-Requires-Dist: trogon (>=0.6.0,<0.7.0)
-Requires-Dist: urllib3
 Requires-Dist: validators
-Requires-Dist: wcwidth (==0.2.13)
-Project-URL: Homepage, https://github.com/odpi/egeria-python
-Project-URL: Repository, https://github.com/odpi/egeria-python
-Description-Content-Type: text/markdown
+Requires-Dist: urllib3
+Requires-Dist: requests
+Requires-Dist: jupyter
+Requires-Dist: click
+Requires-Dist: trogon
+Requires-Dist: textual
+Requires-Dist: mermaid-py
+Requires-Dist: psycopg2-binary
+Requires-Dist: jupyter-notebook-parser
+Requires-Dist: loguru
+Requires-Dist: inflect
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pydevd-pycharm>=252.23892.364
+Requires-Dist: wcwidth
+Requires-Dist: altair
+Requires-Dist: modelcontextprotocol
+Requires-Dist: mcp>=1.15.0
+Dynamic: license-file
 
 <!-- SPDX-License-Identifier: CC-BY-4.0 -->
 <!-- Copyright Contributors to the ODPi Egeria project. -->