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

md_processing/__init__.py

@@ -16,6 +16,7 @@ from md_processing.md_commands.product_manager_commands import (process_digital_
                                                                 process_product_dependency_command,
                                                                 process_attach_collection_command,
                                                                 process_attach_subscriber_command,
+                                                                process_csv_element_upsert_command,
                                                                )
 
 from md_processing.md_commands.solution_architect_commands import (process_blueprint_upsert_command,
@@ -41,6 +42,7 @@ from md_processing.md_commands.ext_ref_commands import (process_external_referen
                                                         process_link_to_media_reference_command,
                                                         process_link_to_external_reference_command,
                                                         process_link_to_cited_document_command,
+
                                                         )
 
 # Re-export all functions from the original md_processing_utils.py to maintain backward compatibility

md_processing/dr_egeria.py

@@ -23,7 +23,7 @@ from md_processing import (extract_command, process_glossary_upsert_command, pro
                            process_provenance_command, get_current_datetime_string,
                            process_project_upsert_command, command_list, process_blueprint_upsert_command,
                            process_solution_component_upsert_command, process_component_link_unlink_command,
-
+                           process_csv_element_upsert_command,
                            process_link_term_term_relationship_command,
                            process_information_supply_chain_upsert_command,
                            process_information_supply_chain_link_unlink_command, process_sol_arch_list_command,
@@ -202,6 +202,9 @@ def process_md_file(input_file: str, output_folder:str, directive: str, server:
                                        "Create Product Subscription", "Update Agreement", "Update Data Sharing Agreement",
                                        "Update Digital Subscription", "Update Product Subscription"]:
                 result = process_agreement_upsert_command(client, current_block, directive)
+            elif potential_command in ["Create CSV File"]:
+                result = process_csv_element_upsert_command(client, current_block, directive)
+
             elif potential_command in SIMPLE_COLLECTIONS:
                 result = process_collection_upsert_command(client, current_block, directive)
             elif potential_command in GOV_COM_LIST:
@@ -296,7 +299,7 @@ def process_md_file(input_file: str, output_folder:str, directive: str, server:
         process_current_block(current_block)
 
     # Join the final output list into a single string
-    final_output = "\n".join(final_output)
+    final_output = "\n".join(final_output) if isinstance(final_output, list) else final_output
 
     try:
         if updated:

md_processing/md_commands/data_designer_commands.py

@@ -1,6 +1,11 @@
-"""
+"""PDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
 This file contains term-related object_action functions for processing Egeria Markdown
+
+
 """
+
 import json
 import os
 import sys

md_processing/md_commands/product_manager_commands.py

@@ -265,7 +265,7 @@ def process_collection_upsert_command(egeria_client: EgeriaTech, txt: str, direc
                             })
                         msg = f"\nCreated Element `{display_name}` with GUID {guid}\n\n___"
                        # todo - add the source member asset to the product manager
-                       # create_element_from_template
+                       # create_elem_from_template
                        # add this guid to the product collection
                         logger.success(msg)
                         return egeria_client.get_collection_by_guid(guid, obj, output_format='MD', output_format_set=output_set)
@@ -631,6 +631,106 @@ def process_agreement_upsert_command(egeria_client: EgeriaTech, txt: str, direct
 
 
 
+@logger.catch
+def process_csv_element_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a create CSV element command by extracting key attributes and calling the pyegeria
+    api that creates a csv element from template.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting glossary-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
+
+    parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
+    if not parsed_output:
+        logger.error(f"No output for `{object_action}`")
+        return None
+
+    valid = parsed_output['valid']
+    exists = parsed_output['exists']
+
+    qualified_name = parsed_output.get('qualified_name', None)
+    guid = parsed_output.get('guid', None)
+
+    print(Markdown(parsed_output['display']))
+
+    logger.debug(json.dumps(parsed_output, indent=4))
+
+    attributes = parsed_output['attributes']
+
+    display_name = attributes['Display Name'].get('value', None)
+    status = attributes.get('Status', {}).get('value', None)
+    output_set = make_format_set_name_from_type(object_type)
+
+    file_name = attributes.get('File Name', {}).get('value', None)
+    file_type = attributes.get('File Type', {}).get('value', None)
+    file_path = attributes.get('File Path', {}).get('value', None)
+    file_encoding = attributes.get('File Encoding', {}).get('value', 'UTF-8')
+    file_extension = attributes.get('File Extension', {}).get('value', 'csv')
+    file_system_name = attributes.get('File System Name', {}).get('value', None)
+    version_identifier = attributes.get('Version Identifier', {}).get('value', None)
+    description = attributes.get('Description', {}).get('value', None)
+
+    if directive == "display":
+
+        return None
+    elif directive == "validate":
+        if valid:
+            print(Markdown(f"==> Validation of {command} completed successfully!\n"))
+        else:
+            msg = f"Validation failed for object_action `{command}`\n"
+        return valid
+
+    elif directive == "process":
+        try:
+
+            if object_action == "Create":
+                if valid is False and exists:
+                    msg = (f"  Element `{display_name}` already exists and result document updated changing "
+                           f"`Create` to `Update` in processed output\n\n___")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+
+                else:
+                    guid = egeria_client.get_create_csv_data_file_element_from_template(
+                       file_name, file_type, file_path, version_identifier, file_encoding, file_extension, file_system_name, description)
+
+                    if guid:
+                        update_element_dictionary(qualified_name, {
+                            'guid': guid, 'display_name': display_name
+                            })
+                        msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
+                        logger.success(msg)
+                        output_md = (f"# Create CSV File\n\n## Display Name:\n\n {display_name}\n\n"
+                                    f"## File Type:\n\n {file_type}\n\n## File Path:\n\n {file_path}\n\n"
+                                    f"## File Encoding:\n\n {file_encoding}\n\n## File Extension:\n\n {file_extension}\n\n"
+                                    f"## File System Name:\n\n {file_system_name}\n\n## Version Identifier:\n\n {version_identifier}\n\n"
+                                    f"## Description:\n\n {description}\n\n"
+                                    f"## Qualified Name\n\n {qualified_name}\n\n"
+                                    f"## GUID:\n\n {guid}\n\n"
+                                     )
+                        return output_md
+                    else:
+                        msg = f"Failed to create element `{display_name}` with GUID {guid}\n\n___"
+                        logger.error(msg)
+                        return None
+            else:
+                logger.error(f"Currently only the Create action is supported for this command: {command}")
+
+        except PyegeriaException as e:
+            logger.error(f"Pyegeria error performing {command}: {e}")
+            print_exception_table(e)
+            return None
+        except Exception as e:
+            logger.error(f"Error performing {command}: {e}")
+    else:
+        logger.error(f"Invalid directive `{directive}`")
+        return None
+
 
 
 def process_link_agreement_item_command(egeria_client: EgeriaTech, txt: str,

md_processing/md_processing_utils/md_processing_constants.py

@@ -242,7 +242,8 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "Link Governance Drivers", "Detach Governance Drivers",
                 "Link Governance Policies", "Detach Governance Policies",
                 "Link Governance Controls", "Detach Governance Controls",
-                "Link Governed By", "Attach Governed By", "Detach Governed By"
+                "Link Governed By", "Attach Governed By", "Detach Governed By",
+                "Create CSV File"
 
                 ]
 command_list.extend(LIST_COMMANDS)

pyegeria/__init__.py

@@ -68,6 +68,7 @@ from .x_action_author_omvs import ActionAuthor
 from .template_manager_omvs import TemplateManager
 from .data_designer import DataDesigner
 from ._output_formats import select_output_format_set
+from .mcp_adapter import list_reports, describe_report, run_report
 #
 global template_guids, integration_guids
 

pyegeria/_client_new.py

@@ -1081,7 +1081,7 @@ class Client2:
         logger.info(response.json())
         return response.json().get("guid", "NO_GUID_RETURNED")
 
-    async def _async_create_elem_from_template(self, url: str, body: dict | TemplateRequestBody = None) -> str:
+    async def _async_create_element_from_template(self, url: str, body: dict | TemplateRequestBody = None) -> str:
         validated_body = self.validate_new_element_from_template_request(body)
         json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
         logger.info(json_body)

pyegeria/_output_formats.py

@@ -2179,15 +2179,16 @@ output_format_sets = combine_format_set_dicts(base_output_format_sets, generated
 
 def select_output_format_set(kind: str, output_type: str) -> dict | None:
     """
-    This function retrieves the appropriate output set configuration dictionary based on the `kind` and `output_type`.
-    If output_type = `ANY` that indicates this is just a test to see of the output format set exists.
+    Retrieve the appropriate output set configuration dictionary based on `kind` and `output_type`.
 
-    :param kind: The kind of output set (e.g., "Referenceable", "Collections").
-    :param output_type: The desired output format type (e.g., "DICT", "LIST", "REPORT").
-    :return: The matched output set dictionary or None if no match is found.
+    Intent of special output_type values:
+    - "ANY": Discovery-only. Resolve the FormatSet (including aliases), action, and metadata, but DO NOT
+      resolve a concrete format. Callers typically use this to check existence or to later pick a specific type
+      via get_output_format_type_match(...).
 
-    Returns:
-        dict | None: 
+    :param kind: The kind of output set (e.g., "Referenceable", "Collections"). Aliases are supported.
+    :param output_type: The desired output format type (e.g., "DICT", "LIST", "REPORT"), or "ANY".
+    :return: The matched output set dictionary or None if no match is found.
     """
     # Normalize the output type to uppercase for consistency
     output_type = output_type.upper()
@@ -2256,6 +2257,41 @@ def output_format_set_list() -> list[str]:
     return list(output_format_sets.keys())
 
 
+def list_mcp_format_sets() -> dict:
+    """
+    Returns only those format set names that can be safely exposed as MCP tools.
+    A format set is eligible if it has a DICT format or an ALL catch-all format.
+    
+    This allows MCP to prefer machine-consumable outputs and avoid side effects.
+    """
+    # eligible: list[str] = []
+    # for name, fs in output_format_sets.items():
+    #     try:
+    #         # fs is a FormatSet
+    #         has_dict = any("DICT" in f.types for f in fs.formats)
+    #         has_all = any("ALL" in f.types for f in fs.formats)
+    #         if has_dict or has_all:
+    #             eligible.append(name)
+    #     except Exception:
+    #         # Defensive: skip malformed entries
+    #         continue
+    # return sorted(eligible)
+    return {
+        name: {
+            "description": fs.description,
+            "target_type": fs.target_type,
+            "required_params": ", ".join(fs.action.required_params) or "",
+            "optional_params": ", ".join(fs.action.optional_params) or "",
+        }
+        for name, fs in sorted(output_format_sets.items())
+        if fs and fs.action and any(
+            format_type in ["DICT", "ALL"]
+            for format_obj in fs.formats
+            for format_type in format_obj.types
+        )
+    }
+
+
 def get_output_format_set_heading(format_set: str) -> str:
     """
     Gets the heading of a format set.

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(