pyegeria 5.4.7.3__py3-none-any.whl → 5.4.7.5__py3-none-any.whl

pyegeria/collection_manager.py

@@ -93,8 +93,20 @@ class DigitalProductProperties(CollectionProperties):
     next_version_date: datetime | None = None
     withdrawal_date: datetime | None = None
 
+class DigitalProductFamilyProperties(CollectionProperties):
+    class_: Annotated[Literal["DigitalProductFamilyProperties"], Field(alias="class")]
+    user_defined_status: str | None = None
+    product_name: str | None = None
+    identifier: str | None = None
+    introduction_date: datetime | None = None
+    maturity: str | None = None
+    service_life: str | None = None
+    next_version_date: datetime | None = None
+    withdrawal_date: datetime | None = None
+
+
 class Collections(PyegeriaModel):
-    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, AgreementProperties,
+    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, DigitalProductFamilyProperties,AgreementProperties,
                       DataSpecProperties, DataDictionaryProperties] = Field(desciminator="class_")
 
 
@@ -5505,7 +5517,7 @@ class CollectionManager(Client2):
         # finally, construct a list of  member information
         for member_rel in members:
             member_guid = member_rel["elementHeader"]["guid"]
-            member = await self._async_get_element_by_guid_(member_guid)
+            member = await self.async_get_element_by_guid_(member_guid)
             if isinstance(member, dict):
                 member_instance = {
                     "name": member["properties"].get('displayName', ''),

pyegeria/data_designer.py

@@ -11,8 +11,7 @@ import asyncio
 
 from loguru import logger
 
-from pyegeria import Client2
-from pyegeria._client import max_paging_size
+from pyegeria._client_new import max_paging_size, Client2
 from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
                              TemplateRequestBody,

pyegeria/egeria_tech_client.py

@@ -67,6 +67,8 @@ class EgeriaTech:
         self._gov_officer = GovernanceOfficer(view_server, platform_url, user_id, user_pwd, token)
         self._collections = CollectionManager(view_server, platform_url, user_id, user_pwd, token)
         self._external_references = ExternalReferences(view_server, platform_url, user_id, user_pwd, token)
+        self._classification_manager = ClassificationManager(view_server, platform_url, user_id, user_pwd, token)
+
 
         self._subclients = [
             self._auto_curate,
@@ -82,6 +84,7 @@ class EgeriaTech:
             self._gov_officer,
             self._collections,
             self._external_references,
+            self._classification_manager
         ]
         self.NO_ELEMENTS_FOUND = NO_ELEMENTS_FOUND
 

pyegeria/external_references.py

@@ -1252,7 +1252,7 @@ class ExternalReferences(Client2):
         ignore_case : bool, [default=False], optional
             Ignore case when searching
         start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
+            When multiple pages of results are available, the page number to start from.
         page_size: int, [default=None]
             The number of items to return in a single page. If not specified, the default will be taken from
             the class instance.

pyegeria/format_set_executor.py

@@ -20,13 +20,11 @@ from typing import Any, Dict, Optional
 
 from loguru import logger
 
-from pyegeria import (
-    EgeriaTech,
-    CollectionManager,
-    GovernanceOfficer,
-    GlossaryManager,
-    NO_ELEMENTS_FOUND,
-)
+from pyegeria.egeria_tech_client import EgeriaTech
+from pyegeria.collection_manager import CollectionManager
+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._exceptions_new import PyegeriaException
@@ -93,6 +91,8 @@ async def _async_run_report(
         - {"kind":"unknown","raw": any}
         """
     params = dict(params or {})
+    user_name = egeria_client.user_id
+    user_pwd = egeria_client.user_pwd
 
     # Resolve the format set and action
     fmt = select_output_format_set(report_name, output_format)
@@ -141,7 +141,6 @@ async def _async_run_report(
 
 
     try:
-        egeria_client.create_egeria_bearer_token()
         func = getattr(egeria_client, method_name) if method_name and hasattr(egeria_client, method_name) else None
         # Add logging to validate func
         msg = f"DEBUG: func={func}, method_name={method_name}, client_class={client_class}"
@@ -152,7 +151,7 @@ async def _async_run_report(
             raise TypeError(
                 f"Resolved function '{method_name}'  not found in client class '{client_class.__name__}' is not callable."
             )
-
+        token = await egeria_client._async_create_egeria_bearer_token(user_name, user_pwd)
         result = await func(**call_params)
 
         if not result or result == NO_ELEMENTS_FOUND:

pyegeria/full_omag_server_config.py

@@ -9,7 +9,7 @@ Copyright Contributors to the ODPi Egeria project.
 import json
 from pyegeria.utils import body_slimmer
 from pyegeria._client import Client
-from pyegeria import TEMPLATE_GUIDS, max_paging_size
+from pyegeria._globals import max_paging_size
 from pyegeria._exceptions import  InvalidParameterException
 from pyegeria._globals import enable_ssl_check
 from pyegeria._validators import validate_name, validate_url

pyegeria/mcp_adapter.py

@@ -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 run_format_set(
+    return exec_format_set(
         format_set_name=report,
         output_format="DICT",
         params=params or {},

pyegeria/mcp_server.py

@@ -5,11 +5,18 @@ This module provides a basic MCP server for Egeria.
 """
 import re
 import sys
+import nest_asyncio
+
 from typing import Any, Dict, Optional
 
+from mcp.server.fastmcp.exceptions import ValidationError
+
 from pyegeria.egeria_tech_client import EgeriaTech
+from pyegeria._exceptions_new import print_validation_error
+
 
 GLOBAL_EGERIA_CLIENT: Optional[EgeriaTech] = None
+nest_asyncio.apply()
 
 try:
     # We use Optional[] and List[] types, so we import them.
@@ -42,16 +49,22 @@ def main() -> None:
         """
         print("DEBUG: Initializing Egeria client...", file=sys.stderr)
         from pyegeria.config import settings as _settings
+        user_id = _settings.User_Profile.user_name
+        user_pwd = _settings.User_Profile.user_pwd
 
         GLOBAL_EGERIA_CLIENT = EgeriaTech(
             _settings.Environment.egeria_view_server,
             _settings.Environment.egeria_view_server_url,
-            _settings.User_Profile.user_name,
-            _settings.User_Profile.user_pwd
+            user_id,
+            user_pwd
         )
+        print("DEBUG: Egeria Client initialized", file=sys.stderr)
         GLOBAL_EGERIA_CLIENT.create_egeria_bearer_token("erinoverview","secret")
         print("DEBUG: Egeria Client connected", file=sys.stderr)
 
+    except ValidationError as e:
+        print_validation_error(e)
+        raise
     except Exception as e:
         print(f"DEBUG: Exception occurred: {str(e)}", file=sys.stderr)
         raise
@@ -89,6 +102,9 @@ def main() -> None:
             ignore_case: Optional[bool] = None,
             output_format: str = "DICT"
     ) -> Dict[str, Any]:
+        import asyncio
+        import nest_asyncio
+        nest_asyncio.apply()
 
         """Run a report with the specified parameters."""
         print("DEBUG: Running report...", file=sys.stderr)
@@ -118,12 +134,18 @@ def main() -> None:
 
             egeria_client: EgeriaTech = GLOBAL_EGERIA_CLIENT
             print("DEBUG: Egeria Client connected", file=sys.stderr)
-
-            result = await _async_run_report_tool(
-                report=report_name,
-                egeria_client=egeria_client,
-                params=params
+            result = await asyncio.wait_for(
+                _async_run_report_tool(
+                    report=report_name,
+                    egeria_client=egeria_client,
+                    params=params),
+                timeout=30  # Adjust timeout as needed
             )
+            # result = await _async_run_report_tool(
+            #     report=report_name,
+            #     egeria_client=egeria_client,
+            #     params=params
+            # )
             print("DEBUG: run_report completed successfully", file=sys.stderr)
             return _ok(result)
         except Exception as e:
@@ -132,7 +154,7 @@ def main() -> None:
             raise
 
     @srv.tool(name="prompt")
-    def natural_language_prompt(prompt: str) -> Dict[str, Any]:
+    async 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.
@@ -142,11 +164,9 @@ def main() -> None:
         # 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
+            return list_reports()  # This is sync, so no await needed
         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
@@ -154,37 +174,32 @@ def main() -> 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(
+                        # AWAIT the async function call
+                        return await 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(
+                # AWAIT the async function call
+                return await 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."
         }

pyegeria/md_processing_utils.py

@@ -15,14 +15,14 @@ from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
 
-from pyegeria import body_slimmer
+from pyegeria.utils import body_slimmer
 from pyegeria._globals import (NO_GLOSSARIES_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND, DEBUG_LEVEL)
 from pyegeria.egeria_tech_client import EgeriaTech
-from md_processing.md_processing_utils.md_processing_constants import (message_types,
+from md_processing.md_processing_utils.md_processing_constants import (
         pre_command, EXISTS_REQUIRED, load_commands, get_command_spec, get_attribute, get_attribute_labels, get_alternate_names)
 
 
-from pyegeria.project_manager_omvs import ProjectManager
+from pyegeria.project_manager import ProjectManager
 
 ALWAYS = "ALWAYS"
 ERROR = "ERROR"

pyegeria/md_processing_utils_orig.py

@@ -17,11 +17,11 @@ from rich import box, print
 from rich.console import Console
 from rich.markdown import Markdown
 
-from pyegeria import body_slimmer
+from pyegeria.utils import body_slimmer
 from pyegeria._globals import NO_TERMS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND
 from pyegeria.egeria_tech_client import EgeriaTech
-from pyegeria.project_manager_omvs import ProjectManager
-from pyegeria.glossary_manager_omvs import GlossaryManager
+from pyegeria.project_manager import ProjectManager
+from pyegeria.glossary_manager import GlossaryManager
 
 from datetime import datetime
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))

pyegeria/mermaid_utilities.py

@@ -21,14 +21,6 @@ nest_asyncio.apply()
 from IPython.display import HTML, display
 from rich.console import Console
 
-from pyegeria.automated_curation import AutomatedCuration
-from pyegeria._exceptions import (
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException,
-)
-from pyegeria._globals import NO_ELEMENTS_FOUND
-
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
 EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
@@ -1252,147 +1244,3 @@ def save_mermaid_graph(title, mermaid_str, folder: str = EGERIA_MERMAID_FOLDER):
     return mermaid_file
 
 
-def generate_process_graph(
-    process_guid: str,
-    view_server: str = EGERIA_VIEW_SERVER,
-    url: str = EGERIA_VIEW_SERVER_URL,
-    user_id: str = EGERIA_USER,
-    user_pass: str = EGERIA_USER_PASSWORD,
-) -> str:
-    """Generate Mermaid Markdown text reflecting the Egeria process graph identified by the GUID
-
-    Parameters
-        ----------
-        process_guid: str
-            The identity of the progress to generate a graph of.
-
-        Returns
-        -------
-        str
-
-        A Mermaid markdown string
-
-        Raises
-        ------
-
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
-
-    """
-    console = Console()
-    a_client = AutomatedCuration(view_server, url, user_id, user_pass)
-    token = a_client.create_egeria_bearer_token()
-    try:
-        start_time = time.perf_counter()
-        response = a_client.get_gov_action_process_graph(process_guid)
-        duration = time.perf_counter() - start_time
-
-        if type(response) is dict:
-            process_steps: [dict]
-            step_links: [dict] = []
-            gov_process_qn = response["governanceActionProcess"]["processProperties"][
-                "qualifiedName"
-            ]
-            gov_process_dn = response["governanceActionProcess"]["processProperties"][
-                "displayName"
-            ]
-
-            md = f"\n---\ntitle: {gov_process_dn}\n---\nflowchart LR\n"
-            header = '%%{init: {"flowchart": {"htmlLabels": false}} }%%\n'
-            md += header
-            element = response["firstProcessStep"]["element"]
-            qname = element["processStepProperties"]["qualifiedName"]
-            dname = element["processStepProperties"]["displayName"]
-            domain_id = element["processStepProperties"]["domainIdentifier"]
-            guid = element["elementHeader"]["guid"]
-            wait = element["processStepProperties"]["waitTime"]
-            ignore_mult_trig = element["processStepProperties"][
-                "ignoreMultipleTriggers"
-            ]
-            link = response["firstProcessStep"]["linkGUID"]
-
-            md = f'{md}\nStep1("`**{dname}**\n*nwait_time*: {wait}\n*nmult_trig*: {ignore_mult_trig}`")'
-            process_steps = {
-                qname: {
-                    "step": "Step1",
-                    "displayName": dname,
-                    "guid": guid,
-                    "domain": domain_id,
-                    "ignoreMultTrig": ignore_mult_trig,
-                    "waitTime": wait,
-                    "link_guid": link,
-                }
-            }
-            next_steps = response.get("nextProcessSteps", None)
-            if next_steps is not None:
-                i = 1
-                for step in next_steps:
-                    i += 1
-                    qname = step["processStepProperties"]["qualifiedName"]
-                    dname = step["processStepProperties"]["displayName"]
-                    wait = step["processStepProperties"]["waitTime"]
-                    step = f"Step{i}"
-                    md = f'{md}\n{step}("`**{dname}**\n*wait_time*: {wait}\n*mult_trig*: {ignore_mult_trig}`")'
-                    process_steps.update(
-                        {
-                            qname: {
-                                "step": step,
-                                "displayName": dname,
-                                "guid": guid,
-                                "domain": domain_id,
-                                "ignoreMultTrig": ignore_mult_trig,
-                                "waitTime": wait,
-                            }
-                        }
-                    )  # process_steps.append({qname: {"step": step,"displayName": dname, "waitTime": wait}})
-            # print(md)
-            # Now process the links
-            process_step_links = response.get("processStepLinks", None)
-            if process_step_links is not None:
-                for slink in process_step_links:
-                    prev_step_name = slink["previousProcessStep"]["uniqueName"]
-                    next_step_name = slink["nextProcessStep"]["uniqueName"]
-                    next_step_link_guid = slink["nextProcessStepLinkGUID"]
-                    guard = slink["guard"]
-                    mandatory_guard = slink["mandatoryGuard"]
-                    # print(f"\n\n Links: prev_step: {prev_step_name}\t next_step: {next_step_name}\t next_step_link:
-                    # {next_step_link_guid}\t Guard: {guard}\t mandatory_guard: {mandatory_guard}")
-                    step_links.append(
-                        {
-                            next_step_link_guid: {
-                                "prev_step_name": prev_step_name,
-                                "next_step_name": next_step_name,
-                                "guard": guard,
-                                "mandatory_guard": mandatory_guard,
-                            }
-                        }
-                    )
-                    step_p = process_steps[prev_step_name]["step"]
-                    step_n = process_steps[next_step_name]["step"]
-                    if mandatory_guard:
-                        link = f"Mandatory:{guard}"
-                    else:
-                        link = guard
-                    md = f"{md}\n{step_p}-->|{link}|{step_n}"
-                i = 1
-
-            return md
-
-        elif type(response) is str:
-            console.log("\n\n" + response)
-        assert True
-
-    except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
-    ) as e:
-        console.print_exception(show_locals=True)
-        assert False, "Invalid request"
-
-    finally:
-        a_client.close_session()

pyegeria/models.py

@@ -378,6 +378,11 @@ class ResultsRequestBody(GetRequestBody):
     start_from: int = 0
     page_size: int = 0
 
+class LevelIdentifierQueryBody(ResultsRequestBody):
+    class_: Annotated[Literal["LevelIdentifierQueryProperties"], Field(alias="class")]
+    return_specific_level: bool = True
+    level_identifier: int
+
 class FilterRequestBody(ResultsRequestBody):
     class_: Annotated[Literal["FilterRequestBody"], Field(alias="class")]
     filter: str

pyegeria/output_formatter.py

@@ -8,7 +8,7 @@ from loguru import logger
 from pyegeria.config import settings
 
 from pyegeria.mermaid_utilities import construct_mermaid_web
-from pyegeria._output_formats import select_output_format_set, MD_SEPARATOR
+from pyegeria._output_formats import select_output_format_set, MD_SEPARATOR, get_output_format_type_match
 from pyegeria.models import to_camel_case
 
 """

pyegeria/project_manager.py

@@ -157,6 +157,10 @@ class ProjectManager(Client2):
             The identity of the parent to find linked projects from.
         project_status: str, optional
             Optionally, filter results by project status.
+        output_format: str, default = "JSON"
+            - Type of output to return.
+        output_format_set: dict | str, default = None
+            - Output format set to use. If None, the default output format set is used.
 
         start_from: int, [default=0], optional
                     When multiple pages of results are available, the page number to start from.
@@ -211,6 +215,10 @@ class ProjectManager(Client2):
             Optionally, filter results by project status.
         effective_time: str, optional
             Time at which to query for projects. Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
+        output_format: str, default = "JSON"
+            - Type of output to return.
+        output_format_set: dict | str, default = None
+            - Output format set to use. If None, the default output format set is used.
 
         start_from: int, [default=0], optional
                     When multiple pages of results are available, the page number to start from.

pyegeria/reference_data.py

@@ -164,6 +164,10 @@ class ReferenceDataManager(Client2):
             Search string to use to find matching projects. If the search string is '*' then all projects returned.
         effective_time: str, [default=None], optional
             Effective time of the query. If not specified will default to any time.
+        output_format: str, default = "JSON"
+            - Type of output to return.
+        output_format_set: dict | str, default = None
+            - Output format set to use. If None, the default output format set is used.
 
         starts_with : bool, [default=False], optional
             Starts with the supplied string.

pyegeria/runtime_manager_omvs.py

@@ -11,7 +11,7 @@ import asyncio
 from requests import Response
 from pyegeria.utils import body_slimmer
 from pyegeria._client_new import Client2
-from pyegeria import TEMPLATE_GUIDS, max_paging_size,default_time_out
+from pyegeria._globals import TEMPLATE_GUIDS, max_paging_size,default_time_out
 from pyegeria._exceptions_new import PyegeriaInvalidParameterException
 from pyegeria._globals import NO_ELEMENTS_FOUND
 

pyegeria/solution_architect.py

@@ -19,7 +19,7 @@ from pyegeria.models import NewElementRequestBody, TemplateRequestBody, UpdateEl
 from pyegeria.output_formatter import make_preamble, make_md_attribute, generate_output, extract_mermaid_only, \
     extract_basic_dict, MD_SEPARATOR, populate_common_columns
 from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
-from pyegeria import validate_guid
+from pyegeria._validators import validate_guid
 from pyegeria.governance_officer import GovernanceOfficer
 from pyegeria._client_new import Client2, max_paging_size
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED

{pyegeria-5.4.7.3.dist-info → pyegeria-5.4.7.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyegeria
-Version: 5.4.7.3
+Version: 5.4.7.5
 Summary: A python client for Egeria
 Author-email: Dan Wolfson <dan.wolfson@pdr-associates.com>
 License-Expression: Apache-2.0