pyegeria 5.4.0.dev14__py3-none-any.whl → 5.4.0.2__py3-none-any.whl

md_processing/md_commands/product_manager_commands.py

@@ -14,10 +14,10 @@ from rich.markdown import Markdown
 from md_processing.md_processing_utils.common_md_proc_utils import (parse_upsert_command, parse_view_command)
 from md_processing.md_processing_utils.common_md_utils import update_element_dictionary, setup_log, set_update_body, \
     set_element_status_request_body, set_prop_body, set_metadata_source_request_body, set_peer_gov_def_request_body, \
-    set_rel_request_body
+    set_rel_request_body, set_create_body, set_collection_classifications, set_collection_property_body
 from md_processing.md_processing_utils.extraction_utils import (extract_command_plus, update_a_command)
 from md_processing.md_processing_utils.md_processing_constants import (load_commands, ERROR)
-from pyegeria import DEBUG_LEVEL, body_slimmer
+from pyegeria import DEBUG_LEVEL, body_slimmer, to_pascal_case
 from pyegeria.egeria_tech_client import EgeriaTech
 
 GERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
@@ -409,6 +409,143 @@ def sync_data_class_rel_elements(egeria_client: EgeriaTech, containing_data_clas
 # Product Manager Commands
 #
 
+@logger.catch
+def process_collection_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a digital product create or update object_action by extracting key attributes such as
+    spec name, parent_guid, parent_relationship_type, parent_at_end_1, collection_type
+
+    :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)
+    description = attributes.get('Description',{}).get('value', None)
+    user_defined_status = attributes.get('User Defined Status',{}).get('value', None)
+
+    collection_classification = attributes.get('Collection Classification', {}).get('value', None)
+
+    current_version = attributes.get('Version Identifier',{}).get('value', None)
+
+    # status = attributes.get('Status',{}).get('value', "ACTIVE")
+
+    anchor_guid = attributes.get('Anchor ID', {}).get('guid', None)
+    parent_guid = attributes.get('Parent ID', {}).get('guid', None)
+    parent_relationship_type_name = attributes.get('Parent Relationship Type Name', {}).get('value', None)
+    parent_relationship_type_name = attributes.get('Parent Relationship Type Name', {}).get('value',"CollectionMembership")
+    parent_at_end1 = attributes.get('Parent at End1', {}).get('value', True)
+    anchor_scope_guid = attributes.get('Anchor Scope GUID', {}).get('value', None)
+    is_own_anchor = attributes.get('Is Own Anchor', {}).get('value', True)
+    if parent_guid is None:
+        is_own_anchor = True
+
+
+    additional_prop = attributes.get('Additional Properties', {}).get('value', None)
+    additional_properties = json.loads(additional_prop) if additional_prop is not None else None
+    extended_prop = attributes.get('Extended Properties', {}).get('value', None)
+    extended_properties = json.loads(extended_prop) if extended_prop is not None else None
+    external_source_guid = attributes.get('External Source Name', {}).get('guid', None)
+    external_source_name = attributes.get('External Source Name', {}).get('value', None)
+    effective_time = attributes.get('Effective Time', {}).get('value', None)
+    for_lineage = attributes.get('For Lineage', {}).get('value', None)
+    for_duplicate_processing = attributes.get('For Duplicate Processing', {}).get('value', None)
+
+    replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
+
+    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 == "Update":
+                if not exists:
+                    msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
+                           f"object_action\n")
+                    logger.error(msg)
+                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+                elif not valid:
+                    return None
+                else:
+                    print(Markdown(
+                        f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
+                prop_body = set_collection_property_body(object_type,qualified_name,attributes)
+
+                body = set_update_body(object_type, attributes)
+                body['properties'] = set_collection_property_body(object_type,qualified_name,attributes)
+
+                egeria_client.update_collection_w_body(guid, body)
+                # egeria_client.update_collection_status(guid, status)
+
+                logger.success(f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___")
+                update_element_dictionary(qualified_name, {
+                    'guid': guid, 'display_name': display_name
+                    })
+                return egeria_client.get_collection_by_guid(guid, collection_type='Data Specification',
+                                                            output_format='MD')
+
+
+            elif object_action == "Create":
+                if valid is False and exists:
+                    msg = (f"  Digital Product `{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:
+                    body = set_create_body(object_type,attributes)
+                    body["initialClassifications"] = set_collection_classifications(object_type, attributes)
+                    body["properties"] = set_collection_property_body(object_type, qualified_name,attributes)
+
+
+                    guid = egeria_client.create_collection_w_body(body)
+                    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)
+                        return egeria_client.get_collection_by_guid(guid, collection_type='Digital Product',
+                                                                    output_format='MD')
+                    else:
+                        msg = f"Failed to create element `{display_name}` with GUID {guid}\n\n___"
+                        logger.error(msg)
+                        return None
+
+        except Exception as e:
+            logger.error(f"Error performing {command}: {e}")
+            return None
+    else:
+        return None
+
 @logger.catch
 def process_digital_product_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
@@ -610,7 +747,6 @@ def process_digital_product_upsert_command(egeria_client: EgeriaTech, txt: str,
     else:
         return None
 
-
 @logger.catch
 def process_agreement_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
@@ -821,7 +957,6 @@ def process_link_agreement_item_command(egeria_client: EgeriaTech, txt: str,
         return valid
 
     elif directive == "process":
-        gov_peer_relationship_type = object_type[:-1].replace(" ","") + "Link"
 
         try:
             if object_action == "Detach":
@@ -837,13 +972,26 @@ def process_link_agreement_item_command(egeria_client: EgeriaTech, txt: str,
                     print(Markdown(
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
                     body = set_metadata_source_request_body(object_type, attributes)
+                    item_props = {
+                        "class": "AgreementItemProperties",
+                        "agreementItemId": attributes["Agreement Item Id"],
+                        "agreementStart": attributes["Agreement Start"],
+                        "agreementEnd": attributes["Agreement End"],
+                        "restrictions": attributes["Restrictions"],
+                        "obligations": attributes["Obligations"],
+                        "entitlements": attributes["Entitlements"],
+                        "usageMeasurements": attributes["Usage Measurements"],
+                        "effectiveFrom": attributes["Effective From"],
+                        "effectiveTo": attributes["Effective To"]
 
-                egeria_client.detach_agreement_item(agreement_guid, item_guid,body)
+                        }
+                    body['properties'] = item_props
+                    egeria_client.detach_agreement_item(agreement_guid, item_guid,body)
 
-                logger.success(f"===> Detached agreement item `{item}` from agreement `{agreement}`\n")
-                out = parsed_output['display'].replace('Unlink', 'Link', 1)
+                    logger.success(f"===> Detached agreement item `{item}` from agreement `{agreement}`\n")
+                    out = parsed_output['display'].replace('Unlink', 'Link', 1)
 
-                return (out)
+                    return (out)
 
             elif object_action == "Link":
                 if valid is False and exists:
@@ -871,6 +1019,7 @@ def process_link_agreement_item_command(egeria_client: EgeriaTech, txt: str,
                         "effectiveTo": attributes["Effective To"]
 
                     }
+                    body['properties'] = item_props
                     egeria_client.link_agreement_item(agreement_guid,
                                                         item_guid, body)
                     msg = f"==>Linked {object_type} `{agreement} to item {item}\n"
@@ -891,8 +1040,7 @@ def process_link_agreement_item_command(egeria_client: EgeriaTech, txt: str,
 # View commands
 #
 @logger.catch
-def process_data_collection_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[
-    str]:
+def process_collection_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a Data Dictionary list object_action by extracting key attributes such as
      search string from the given text.
@@ -904,30 +1052,33 @@ def process_data_collection_list_command(egeria_client: EgeriaTech, txt: str, di
     """
     command, object_type, object_action = extract_command_plus(txt)
     print(Markdown(f"# {command}\n"))
-    if object_type in ["Data Dictionary", "Data Dictionaries", "DataDict", "DataDictionary"]:
-        col_type = "DataDictionary"
-    elif object_type in ["Data Specification", "Data Specifications", "Data Specs"]:
-        col_type = "DataSpec"
-    else:
-        col_type = "Collection"
 
     parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 
-
+    col_type = to_pascal_case(object_type) if object_type != "Collections" else None
 
     valid = parsed_output['valid']
     print(Markdown(f"Performing {command}"))
     print(Markdown(parsed_output['display']))
 
     attr = parsed_output.get('attributes',{})
+    columns = attr.get('Columns',{}).get('value',None).replace("'", '"')
+
+    try:
+        columns_list = json.loads(columns)
+    except Exception as e:
+        print(e)
+        exit(1)
+
     effective_time = attr.get('effectiveTime', {}).get('value', None)
     as_of_time = attr.get('asOfTime', {}).get('value', None)
     for_duplicate_processing = attr.get('forDuplicateProcessing', {}).get('value', False)
     for_lineage = attr.get('forLineage',{}).get('value', False)
-    limit_result_by_status = attr.get('limitResultsByStatus',{}).get('value', ['ACTIVE'])
+    limit_result_by_status = attr.get('limitResultsByStatus',{}).get('value', [])
     sequencing_property = attr.get('sequencingProperty',{}).get('value',"qualifiedName" )
     sequencing_order = attr.get('sequencingOrder',{}).get('value', "PROPERTY_ASCENDING")
     search_string = attr.get('Search String', {}).get('value', '*')
+    search_string = search_string if search_string != "*" else None
     output_format = attr.get('Output Format', {}).get('value', 'LIST')
     detailed = attr.get('Detailed', {}).get('value', False)
 
@@ -961,7 +1112,8 @@ def process_data_collection_list_command(egeria_client: EgeriaTech, txt: str, di
                     "filter": search_string,
                 }
 
-            struct = egeria_client.find_collections_w_body(body, col_type, output_format=output_format)
+            struct = egeria_client.find_collections_w_body(body, col_type,
+                                                           output_format = output_format, columns=columns_list)
             if output_format == "DICT":
                 list_md += f"```\n{json.dumps(struct, indent=4)}\n```\n"
             else:
@@ -977,204 +1129,3 @@ def process_data_collection_list_command(egeria_client: EgeriaTech, txt: str, di
     else:
         return None
 
-# TODO
-def process_data_agreement_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[
-    str]:
-    """
-    Processes a Data Dictionary list object_action by extracting key attributes such as
-     search string from the given text.
-
-    :param txt: A string representing the input cell to be processed for
-        extracting term-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_view_command(egeria_client, object_type, object_action, txt, directive)
-
-    attributes = parsed_output['attributes']
-
-    valid = parsed_output['valid']
-    print(Markdown(f"Performing {command}"))
-    print(Markdown(parsed_output['display']))
-
-    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"
-            logger.error(msg)
-        return valid
-
-    elif directive == "process":
-        attributes = parsed_output['attributes']
-        search_string = attributes.get('Search String', {}).get('value', '*')
-        output_format = attributes.get('Output Format', {}).get('value', 'LIST')
-        detailed = attributes.get('Detailed', {}).get('value', False)
-
-        try:
-            if not valid:  # First validate the command before we process it
-                msg = f"Validation failed for {object_action} `{object_type}`\n"
-                logger.error(msg)
-                return None
-
-            list_md = f"\n# `{object_type}` with filter: `{search_string}`\n\n"
-            struct = egeria_client.find_data_structures(search_string, output_format=output_format)
-
-            if output_format == "DICT":
-                list_md += f"```\n{json.dumps(struct, indent=4)}\n```\n"
-            else:
-                list_md += struct
-            logger.info(f"Wrote `{object_type}` for search string: `{search_string}`")
-
-            return list_md
-
-        except Exception as e:
-            logger.error(f"Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None
-
-# TODO
-def process_subscription_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a Data Dictionary list object_action by extracting key attributes such as
-     search string from the given text.
-
-    :param txt: A string representing the input cell to be processed for
-        extracting term-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_view_command(egeria_client, object_type, object_action, txt, directive)
-
-    attributes = parsed_output['attributes']
-
-    valid = parsed_output['valid']
-    print(Markdown(f"Performing {command}"))
-    print(Markdown(parsed_output['display']))
-
-    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"
-            logger.error(msg)
-        return valid
-
-    elif directive == "process":
-        attributes = parsed_output['attributes']
-        search_string = attributes.get('Search String', {}).get('value', '*')
-        output_format = attributes.get('Output Format', {}).get('value', 'LIST')
-        detailed = attributes.get('Detailed', {}).get('value', False)
-        as_of_time = attributes.get('AsOfTime', {}).get('value', None)
-        effective_time = attributes.get('Effective Time', {}).get('value', None)
-        sort_order = attributes.get('Sort Order', {}).get('value', None)
-        order_property = attributes.get('Order Property', {}).get('value', None)
-        starts_with = attributes.get('Start With', {}).get('value', True)
-        ends_with = attributes.get('End With', {}).get('value', False)
-        ignore_case = attributes.get('Ignore Case', {}).get('value', False)
-        start_from = attributes.get('Start From', {}).get('value', 0)
-        page_size = attributes.get('Page Size', {}).get('value', None)
-
-        try:
-            if not valid:  # First validate the command before we process it
-                msg = f"Validation failed for {object_action} `{object_type}`\n"
-                logger.error(msg)
-                return None
-
-            list_md = f"\n# `{object_type}` with filter: `{search_string}`\n\n"
-            body = {
-                "class": "FilterRequestBody", "asOfTime": as_of_time, "effectiveTime": effective_time,
-                "forLineage": False, "forDuplicateProcessing": False, "limitResultsByStatus": ["ACTIVE"],
-                "sequencingOrder": sort_order, "sequencingProperty": order_property, "filter": search_string,
-                }
-            struct = egeria_client.find_data_fields_w_body(body, start_from, page_size, starts_with, ends_with,
-                                                           ignore_case, output_format)
-
-            if output_format == "DICT":
-                list_md += f"```\n{json.dumps(struct, indent=4)}\n```\n"
-            else:
-                list_md += struct
-            logger.info(f"Wrote `{object_type}` for search string: `{search_string}`")
-
-            return list_md
-
-        except Exception as e:
-            logger.error(f"Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None
-
-# TODO
-def process_digital_product_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a Data Dictionary list object_action by extracting key attributes such as
-     search string from the given text.
-
-    :param txt: A string representing the input cell to be processed for
-        extracting term-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_view_command(egeria_client, object_type, object_action, txt, directive)
-
-    attributes = parsed_output['attributes']
-
-    valid = parsed_output['valid']
-    print(Markdown(f"Performing {command}"))
-    print(Markdown(parsed_output['display']))
-
-    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"
-            logger.error(msg)
-        return valid
-
-    elif directive == "process":
-        attributes = parsed_output['attributes']
-        search_string = attributes.get('Search String', {}).get('value', '*')
-        output_format = attributes.get('Output Format', {}).get('value', 'LIST')
-        detailed = attributes.get('Detailed', {}).get('value', False)
-
-        try:
-            if not valid:  # First validate the command before we process it
-                msg = f"Validation failed for {object_action} `{object_type}`\n"
-                logger.error(msg)
-                return None
-
-            list_md = f"\n# `{object_type}` with filter: `{search_string}`\n\n"
-            struct = egeria_client.find_data_classes(search_string, output_format=output_format)
-
-            if output_format == "DICT":
-                list_md += f"```\n{json.dumps(struct, indent=4)}\n```\n"
-            else:
-                list_md += struct
-            logger.info(f"Wrote `{object_type}` for search string: `{search_string}`")
-
-            return list_md
-
-        except Exception as e:
-            logger.error(f"Error performing {command}: {e}")
-            console.print_exception(show_locals=True)
-            return None
-    else:
-        return None

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -1,6 +1,7 @@
 """
 This file contains general utility functions for processing Egeria Markdown
 """
+import json
 import os
 import sys
 from typing import List
@@ -175,6 +176,9 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
             elif style == 'Bool':
                 parsed_attributes[key] = proc_bool_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == "Dictionary List":
+                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                parsed_attributes[key]['list'] = json.loads(parsed_attributes[key]['value'])
 
 
             elif style == 'Reference Name List':
@@ -374,6 +378,9 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
             elif style == 'Bool':
                 parsed_attributes[key] = proc_bool_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == "Dictionary List":
+                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                # parsed_attributes[key]['list'] = json.loads(parsed_attributes[key]['value'])
 
             elif style == 'Reference Name List':
                 parsed_attributes[key] = proc_name_list(egeria_client, key, txt, labels, if_missing)
@@ -490,6 +497,8 @@ def proc_valid_value(txt: str, action: str, labels: set, valid_values: [], if_mi
     if isinstance(valid_values, str):
         # v_values = [item.strip() for item in re.split(r'[;,\n]+', valid_values)]
         v_values = split_tb_string(valid_values)
+    if isinstance(valid_values, list):
+        v_values = valid_values
     if not isinstance(v_values, list):
         msg = "Valid values list is not a list"
         logger.error(msg)

md_processing/md_processing_utils/common_md_utils.py

@@ -232,8 +232,8 @@ def set_create_body(object_type: str, attributes: dict)->dict:
         "parentRelationshipProperties": attributes.get('Parent Relationship Properties', {}).get('value', None),
         "parentAtEnd1": attributes.get('Parent at End1', {}).get('value', True),
         "properties": "",
-        "initialStatus": attributes.get('Status', {}).get('value', "ACTIVE")
-        }
+        "initialStatus": attributes.get('Status', {}).get('value', "ACTIVE"),
+        "initialClassifications": {}}
 
     return body
 
@@ -261,6 +261,8 @@ def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict
         "displayName": attributes['Display Name'].get('value', None),
         "qualifiedName" : qualified_name,
         "description": attributes['Description'].get('value', None),
+        "status": attributes.get('Status', {}).get('value', "ACTIVE"),
+        "userDefinedStatus": attributes.get('User Defined Status', {}).get('value', None),
         "versionIdentifier": attributes.get('Version Identifier', {}).get('value', None),
         "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
         "effectiveTo": attributes.get('Effective To', {}).get('value', None),
@@ -369,3 +371,14 @@ def set_element_status_request_body(object_type: str, attributes: dict)->dict:
         "forLineage": attributes.get('For Lineage', {}).get('value', False),
         "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
     }
+def set_collection_property_body(object_type: str, qualified_name:str, attributes: dict)->dict:
+    body = set_prop_body("Collection", qualified_name,attributes)
+    body["category"] = attributes.get('Category', {}).get('value', None)
+    return body
+
+def set_collection_classifications(object_type: str, attributes: dict)->dict:
+    collection_classifications = attributes.get('Collection Classifications', {}).get('name_list', None)
+    if collection_classifications is None:
+        collection_classifications = object_type
+    body = {classification: {} for classification in collection_classifications} if collection_classifications else {}
+    return body

md_processing/md_processing_utils/md_processing_constants.py

@@ -4,6 +4,7 @@ This file contains display-related constants and formatting functions for Egeria
 import importlib.resources
 import json
 import os
+import inflect
 
 from rich.markdown import Markdown
 
@@ -11,6 +12,9 @@ from md_processing.md_processing_utils.message_constants import ERROR
 from pyegeria._globals import DEBUG_LEVEL
 from md_processing.md_processing_utils.message_constants import message_types, ALWAYS, ERROR, INFO, WARNING
 
+inflect_engine = inflect.engine()
+
+
 EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "/home/jovyan")
 EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "loading-bay/dr_egeria_inbox")
 
@@ -71,6 +75,40 @@ GOV_COM_LIST = [ "Create Business Imperative", "Update Business Imperative",
                 "Create Certification Type", "Update Certification Type",
                 "Create License Type", "Update License Type",]
 
+SIMPLE_BASE_COLLECTIONS: set = { "Collection", "Home Collection", "Digital Product", "Result Set" , "Recent Access",
+                       "Reference List", "Work Item List", "Data Sharing Agreement", "Namespace", "Agreement",
+                       "Digital Subscription", "Data Product", "Subscription",
+                      "Root Collection",  "Folders",  "Context Event Collection",  "Name Space Collection",
+                    # "Data Specifications", "Data Specifications", "Data Specs", "Data Specs",
+                    # "Data Dictionaries", "Data Dictionaries",
+                     "Event Set Collection", "Naming Standard Ruleset",
+                    }
+SIMPLE_COLLECTIONS: set = set()
+for element in SIMPLE_BASE_COLLECTIONS:
+    SIMPLE_COLLECTIONS.add(f"Create {element}")
+    SIMPLE_COLLECTIONS.add(f"Update {element}")
+    plural = inflect_engine.plural_noun(element)
+    SIMPLE_COLLECTIONS.add(f"Create {plural}")
+    SIMPLE_COLLECTIONS.add(f"Update {plural}")
+
+
+
+COLLECTIONS_LIST = ["List Collections", "View Collections", "List Digital Products", "View Digital Products",
+                    "List Data Products", "View Data Products",
+                    "List Data Sharing Agreements", "View Data Sharing Agreements",
+                    "List Agreements", "View Agreements",
+                    "List Digital Subscriptions", "View Digital Subscriptions",
+                    "List Subscriptions", "View Subscriptions",
+                    "List Root Collections", "View Root Collections",
+                    "List Data Specifications", "View Data Specifications", "List Data Specs", "View Data Specs",
+                    "List Data Dictionaries", "View Data Dictionaries",
+                    "List Folders", "View Folders",
+                    "List Context Event Collections", "View Context Event Collections",
+                    "List Name Space Collections", "View Name Space Collections",
+                    "List Event Set Collections", "View Event Set Collections",
+                    "List Naming Standard Rulesets", "View Naming Standard Rulesets",
+                    ]
+
 command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms",
                 "List Term Details", "List Glossary Terms", "List Term History", "List Term Revision History",
                 "List Term Update History", "List Glossary Structure", "List Glossaries", "List Categories",
@@ -87,13 +125,13 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "Update Term-Term Relationship", "Create Data Spec", "Create Data Specification", "Update Data Spec",
                 "Update Data Specification", "Create Data Field", "Update Data Field", "Create Data Structure",
                 "Update Data Structure", "Create Data Dictionary", "Update Data Dictionary", "Create Data Dict",
-                "Update Data Dict", " View Data Dictionary", "View Data Dictionaries", "View Data Specifications",
-                "View Data Specs", "View Data Structures", "View Data Structure", "View Data Fields", "View Data Field",
+                "Update Data Dict",
+                "View Data Structures", "View Data Structure", "View Data Fields", "View Data Field",
                 "View Dataa Classes", "View Data Class", "Create Data Class", "Update Data Class",
                 "Create Digital Product", "Create Data Product", "Update Digital Product", "Update Data Product",
                 "Create Agreement", "Update Agreement",
                 "Link Digital Products", "Link Data Products", "Detach Digital Products", "Detach Data Products",
-                "Create Data Sharing Agreement", "Update Data Sharing Agreement",
+                # "Create Data Sharing Agreement", "Update Data Sharing Agreement",
                 "Create Digital Subscription", "Create Product Subscription", "Update Digital Subscription", "Update Product Subscription",
                 "Attach Agreement Items", "Detach Agreement Items",
                 "Attach Contract", "Detach Contract",
@@ -102,9 +140,7 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "Unlink Collection From Resource", "Detach Collection From Resource",
                 "Add Member to Collection", "Add Member", "Member->Collection",
                 "Remove Member from Collection","Remove Member from Collection",
-                "View Digital Products", "View Data Products", "List Data Products", "List Digtal Products",
-                "View Agreements", "View Data Sharing Agreements", "List Agreements", "List Data Sharing Agreements",
-                "View Subscriptions", "List Subscriptions", "View Governance Definitions", "View Gov Definitions",
+                 "View Governance Definitions", "View Gov Definitions",
                  "List Governance Definitions", "List Gov Definitions",
                 "View Governance Definition Context","List Governance Definition Context",
                 "View Governance Def Context", "List Governance Def Context",
@@ -135,6 +171,8 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
 
 command_list.extend(GOV_COM_LIST)
 command_list.extend(GOV_LINK_LIST)
+command_list.extend(COLLECTIONS_LIST)
+command_list.extend(SIMPLE_COLLECTIONS)
 
 pre_command = "\n---\n==> Processing object_action:"
 command_seperator = Markdown("\n---\n")