pyegeria 5.4.0.22__py3-none-any.whl → 5.4.0.24__py3-none-any.whl

commands/cat/dr_egeria_md.py

@@ -6,6 +6,7 @@ import sys
 from datetime import datetime
 
 from loguru import logger
+from pydantic import ValidationError
 
 log_format = "{time} | {level} | {function} | {line} | {message} | {extra}"
 logger.remove()
@@ -31,7 +32,8 @@ from md_processing import (extract_command, process_glossary_upsert_command, pro
                            process_collection_list_command, process_collection_upsert_command, process_link_agreement_item_command,
                            process_gov_definition_upsert_command, GOV_COM_LIST, GOV_LINK_LIST,
                            process_gov_def_link_detach_command, process_gov_definition_list_command,
-                           process_gov_def_context_command, COLLECTIONS_LIST, SIMPLE_COLLECTIONS)
+                           process_gov_def_context_command, process_supporting_gov_def_link_detach_command,
+                           COLLECTIONS_LIST, SIMPLE_COLLECTIONS, GOV_LINK_LIST,)
 from md_processing.md_commands.data_designer_commands import (process_data_spec_upsert_command,
                                                               process_data_dict_upsert_command,
                                                               process_data_collection_list_command,
@@ -41,7 +43,8 @@ from md_processing.md_commands.data_designer_commands import (process_data_spec_
                                                               process_data_field_upsert_command,
                                                               process_data_structure_upsert_command,
                                                               process_data_class_upsert_command)
-from pyegeria import EgeriaTech
+
+from pyegeria import EgeriaTech, PyegeriaException, print_basic_exception, print_validation_error
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
@@ -112,7 +115,7 @@ def process_markdown_file(input_file: str, output_folder:str, directive: str, se
             return  # No block to process
 
         potential_command = extract_command(current_block)  # Extract object_action
-        if potential_command in cmd_list:
+        if (potential_command in cmd_list):
             # Process the block based on the object_action
             if potential_command == "Provenance":
                 result = process_provenance_command(input_file, current_block)
@@ -198,6 +201,12 @@ def process_markdown_file(input_file: str, output_folder:str, directive: str, se
             elif potential_command in ['View Governance Definitions', 'List Governance Definitions',
                                        'View Gov Definitions', 'List Gov Definitions']:
                 result = process_gov_definition_list_command(client, current_block, directive)
+            elif potential_command in GOV_LINK_LIST:
+                result = process_gov_def_link_detach_command(client, current_block, directive)
+            elif potential_command in ['Link Governance Mechanism', 'Detach Governance Mechanism',
+                                       'Link Governance Response', 'Detach Governance Response',]:
+                result = process_supporting_gov_def_link_detach_command(client, current_block, directive)
+
             elif potential_command in COLLECTIONS_LIST:
                 result = process_collection_list_command(client, current_block, directive)
 
@@ -283,6 +292,10 @@ def process_markdown_file(input_file: str, output_folder:str, directive: str, se
                 click.echo("\nNo updates detected. New File not created.")
                 logger.error("===> Unknown Command? <===")
 
+    except PyegeriaException as e:
+        print_basic_exception(e)
+    except ValidationError as e:
+        print_validation_error(e)
     except (Exception):
         console.print_exception(show_locals=True)
 

commands/cat/list_collections.py

@@ -10,6 +10,7 @@ import json
 import os
 import time
 
+from jsonschema import ValidationError
 from rich import box
 from rich.console import Console
 from rich.markdown import Markdown
@@ -21,6 +22,8 @@ from pyegeria import (
     CollectionManager,
     NO_ELEMENTS_FOUND, config_logging, load_app_config, get_app_config, init_logging, config_logging, PyegeriaException,
     print_basic_exception,PyegeriaException, )
+from pyegeria._exceptions_new import print_validation_error
+
 # from pyegeria._exceptions_new import PyegeriaException, print_exception_response
 
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
@@ -135,7 +138,7 @@ def display_collections(
         table.add_column("Members")
 
         collections = m_client.find_collections(
-            search_string.strip(), None, True, False, ignore_case=True,
+            search_string.strip(), None, ["Collection"],True, False, ignore_case=True,
             output_format = "DICT", output_format_set=out_struct
         )
         if type(collections) is list:
@@ -153,7 +156,7 @@ def display_collections(
                 collection_type = collection.get("collectionType", "---")
                 classifications = collection.get("classifications", "---")
 
-                classifications_md = Markdown(classifications)
+                classifications_md = Markdown(classifications) if classifications else ""
                 members_struct = m_client.get_member_list(collection_guid=guid)
                 member_list = ""
                 if isinstance(members_struct, list):
@@ -161,7 +164,7 @@ def display_collections(
                         member_list = member_list + f"- {member.get('qualifiedName','---')}\n"
 
                 # members = "\n* ".join(collection.get("members", []))
-                members_md = Markdown(member_list)
+                members_md = Markdown(member_list) if member_list else ""
 
                 table.add_row(
                     display_name,
@@ -180,10 +183,12 @@ def display_collections(
         else:
             print("==> No collections with that name found")
 
-    except (
-        PyegeriaException
-    ) as e:
+    except (PyegeriaException) as e:
         print_basic_exception(e)
+    except ValidationError as e:
+        print_validation_error(e)
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
     finally:
         m_client.close_session()
 
@@ -217,6 +222,10 @@ def main():
 
     except PyegeriaException as e:
         print_basic_exception(e)
+    except ValidationError as e:
+        print_validation_error(e)
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
 
 
 if __name__ == "__main__":

commands/cat/list_format_set.py

@@ -50,16 +50,15 @@ import pydevd_pycharm
 
 from pyegeria import (
     EgeriaTech,
-    NO_ELEMENTS_FOUND,
+    CollectionManager,
+    NO_ELEMENTS_FOUND, GovernanceOfficer,
     # config_logging,
     # get_app_config
-)
+    )
 from pyegeria.load_config import get_app_config
 from pyegeria.logging_configuration import config_logging
-from pyegeria._output_formats import select_output_format_set, get_output_format_set_heading, \
-    get_output_format_set_description
+from pyegeria._output_formats import (select_output_format_set, get_output_format_set_heading, get_output_format_set_description)
 from pyegeria._exceptions_new import PyegeriaException, print_exception_response
-from pyegeria.egeria_tech_client import EgeriaTech
 
 # pydevd_pycharm.settrace('host.docker.internal',  # Use 'host.docker.internal' to connect to the host machine
 #                              port=5678,               # Port to communicate with PyCharm
@@ -130,8 +129,8 @@ def execute_format_set_action(
         print(f"Error: Output format set '{format_set_name}' does not have an action property.")
         return
 
-    # Extract the function and parameters from the action property
-    action = format_set["action"][0]  # Assuming there's only one action
+    # Extract the function and parameters from the action property (now a dict)
+    action = format_set["action"]
     func = action.get("function")
     user_params = action.get("user_params", [])
     spec_params = action.get("spec_params", {})
@@ -141,6 +140,7 @@ def execute_format_set_action(
     for param in user_params:
         if param in kwargs and kwargs[param]:
             params[param] = kwargs[param]
+            # print(f"Found value '{kwargs[param]}' for parameter '{param}'.")
         elif param not in kwargs and param not in spec_params:
             print(f"Warning: Required parameter '{param}' not provided for format set '{format_set_name}'.")
     
@@ -157,10 +157,14 @@ def execute_format_set_action(
     # If function name is provided as a string, parse it to get class and method
     if isinstance(func, str) and "." in func:
         class_name, method_name = func.split(".")
-        # if class_name == "CollectionManager":
-        #     client_class = CollectionManager
-        # elif class_name == "EgeriaTech":
-        client_class = EgeriaTech
+        if class_name == "CollectionManager":
+            client_class = CollectionManager
+        elif class_name == "GovernanceOfficer":
+            client_class = GovernanceOfficer
+        else:
+            client_class = EgeriaTech
+
+
         # Add more client classes as needed
     
     # # If client_class is still None, determine based on format set name
@@ -217,6 +221,7 @@ def execute_format_set_action(
             params['output_format'] = output_format
             
             # Call the function with the parameters
+            print(f"\n==> Calling function: {func} with parameters:{params}")
             try:
                 if isinstance(func, type(client.find_collections)):  # It's a method of the client
                     # Call the function as an instance method of the client
@@ -246,88 +251,88 @@ def execute_format_set_action(
             if output_format == "HTML":
                 print(f"\n==> Web link: [{file_name}]({app_config.pyegeria_publishing_root}/{file_name}")
             return
+        else:
+            # For TABLE output, add output_format to params
+            params['output_format'] = "DICT"
+            print(f"\n==> Calling function: {func} with parameters:{params}")
+            # Call the function and create a table
+            try:
+                if hasattr(client, method_name):  # It's a method of the client
+                    # Call the function as an instance method of the client
+                    result = func(**params)
+                else:
+                    # For standalone functions, call with client as first argument
+                    result = func(client, **params)
+            except TypeError as e:
+                # Handle parameter mismatch errors
+                print(f"Error calling function: {e}")
+                print(f"Parameters provided: {params}")
+                return
 
-        # For TABLE output, add output_format to params
-        params['output_format'] = "DICT"
-        
-        # Call the function and create a table
-        try:
-            if isinstance(func, type(client.find_collections)):  # It's a method of the client
-                # Call the function as an instance method of the client
-                result = func(**params)
-            else:
-                # For standalone functions, call with client as first argument
-                result = func(client, **params)
-        except TypeError as e:
-            # Handle parameter mismatch errors
-            print(f"Error calling function: {e}")
-            print(f"Parameters provided: {params}")
-            return
-        
-        if not result or result == NO_ELEMENTS_FOUND:
-            print(f"\n==> No elements found for format set '{format_set_name}'")
-            return
-        
-
-        if heading and desc:
-            console.print(Markdown(preamble))
-
-        # Create a table for the results
-        table = Table(
-            title=f"{format_set_name} @ {time.asctime()}",
-            style="bright_white on black",
-            header_style="bright_white on dark_blue",
-            title_style="bold white on black",
-            caption_style="white on black",
-            show_lines=True,
-            box=box.ROUNDED,
-            caption=f"View Server '{view_server}' @ Platform - {view_url}",
-            expand=True,
-        )
-        
-        # Handle both list and dictionary results
-        if isinstance(result, list):
-            if not result:
+            if not result or result == NO_ELEMENTS_FOUND:
                 print(f"\n==> No elements found for format set '{format_set_name}'")
                 return
-                
-            # Sort the results by display_name if available
-            if "display_name" in result[0]:
-                sorted_results = sorted(result, key=lambda k: k.get("display_name", ""))
-            elif "Display Name" in result[0]:
-                sorted_results = sorted(result, key=lambda k: k.get("Display Name", ""))
+
+
+            if heading and desc:
+                console.print(Markdown(preamble))
+
+            # Create a table for the results
+            table = Table(
+                title=f"{format_set_name} @ {time.asctime()}",
+                style="bright_white on black",
+                header_style="bright_white on dark_blue",
+                title_style="bold white on black",
+                caption_style="white on black",
+                show_lines=True,
+                box=box.ROUNDED,
+                caption=f"View Server '{view_server}' @ Platform - {view_url}",
+                expand=True,
+            )
+
+            # Handle both list and dictionary results
+            if isinstance(result, list):
+                if not result:
+                    print(f"\n==> No elements found for format set '{format_set_name}'")
+                    return
+
+                # Sort the results by display_name if available
+                if "display_name" in result[0]:
+                    sorted_results = sorted(result, key=lambda k: k.get("display_name", ""))
+                elif "Display Name" in result[0]:
+                    sorted_results = sorted(result, key=lambda k: k.get("Display Name", ""))
+                else:
+                    sorted_results = result
+
+                # Add columns dynamically based on the first result
+                column_headings = list(sorted_results[0].keys())
+                for heading in column_headings:
+                    table.add_column(heading, justify="left", style="cyan")
+
+                # Add rows
+                for item in sorted_results:
+                    row_values = []
+                    for key in column_headings:
+                        value = item.get(key, "")
+                        row_values.append(str(value))
+
+                    table.add_row(*row_values)
             else:
-                sorted_results = result
-                
-            # Add columns dynamically based on the first result
-            column_headings = list(sorted_results[0].keys())
-            for heading in column_headings:
-                table.add_column(heading, justify="left", style="cyan")
-                
-            # Add rows
-            for item in sorted_results:
+                # Handle single dictionary result
+                column_headings = list(result.keys())
+                for heading in column_headings:
+                    table.add_column(heading, justify="left", style="cyan")
+
                 row_values = []
                 for key in column_headings:
-                    value = item.get(key, "")
+                    value = result.get(key, "")
                     row_values.append(str(value))
-                    
+
                 table.add_row(*row_values)
-        else:
-            # Handle single dictionary result
-            column_headings = list(result.keys())
-            for heading in column_headings:
-                table.add_column(heading, justify="left", style="cyan")
-                
-            row_values = []
-            for key in column_headings:
-                value = result.get(key, "")
-                row_values.append(str(value))
-                
-            table.add_row(*row_values)
-            
-        # Print the table
 
-        console.print(table)
+            # Print the table
+
+            console.print(table)
 
     except PyegeriaException as e:
         print_exception_response(e)
@@ -370,7 +375,7 @@ def main():
     # Add arguments based on the format set's user_params
     user_params = []
     if "action" in format_set:
-        action = format_set["action"][0]  # Assuming there's only one action
+        action = format_set["action"]
         user_params = action.get("user_params", [])
         
         for param in user_params:

md_processing/__init__.py

@@ -3,8 +3,10 @@ This package contains functions to parse and process Egeria Markdown (Freddie)
 """
 from md_processing.md_commands.governance_officer_commands import (process_gov_definition_upsert_command,
                                                                    process_gov_def_link_detach_command,
+                                                                   process_supporting_gov_def_link_detach_command,
                                                                    process_gov_definition_list_command,
-                                                                   process_gov_def_context_command)
+                                                                   process_gov_def_context_command,
+                                                                   )
 
 
 from md_processing.md_commands.product_manager_commands import (process_digital_product_upsert_command,
@@ -45,11 +47,11 @@ from md_processing.md_processing_utils.common_md_utils import (render_markdown,
                                                                console, debug_level, get_element_dictionary,
                                                                update_element_dictionary, clear_element_dictionary,
                                                                is_present, find_key_with_value,
-                                                               process_provenance_command, set_metadata_source_request_body,
+                                                               process_provenance_command, set_delete_request_body,
                                                                set_rel_request_body, set_filter_request_body,
                                                                set_update_body, set_peer_gov_def_request_body,
                                                                 set_gov_prop_body, set_prop_body, set_create_body,
-
+                                                                GOVERNANCE_POLICIES, GOVERNANCE_CONTROLS, GOVERNANCE_DRIVERS
                                                                )
 from md_processing.md_processing_utils.extraction_utils import (extract_command_plus, extract_command,
                                                                 extract_attribute, process_simple_attribute,