pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -4,39 +4,42 @@ This file contains general utility functions for processing Egeria Markdown
 import json
 import os
 import sys
-from typing import List, Optional
+import re
+from typing import Optional
 
 from loguru import logger
+from pydantic import ValidationError
 from rich import print
 from rich.markdown import Markdown
 from rich.console import Console
-
-from md_processing.md_processing_utils.common_md_utils import (get_current_datetime_string, get_element_dictionary,
-                                                               update_element_dictionary,
-                                                               split_tb_string, str_to_bool, )
+from pyegeria.core.utils import parse_to_dict
+from pyegeria.core.config import settings
+from md_processing.md_processing_utils.common_md_utils import (get_current_datetime_string, split_tb_string, str_to_bool, )
 from md_processing.md_processing_utils.extraction_utils import (process_simple_attribute, extract_attribute,
                                                                 get_element_by_name)
-from md_processing.md_processing_utils.common_md_utils import (update_element_dictionary, set_gov_prop_body, \
-                                                               set_update_body, set_create_body,
-                                                               set_peer_gov_def_request_body, set_rel_request_body,
-                                                               set_delete_request_body,set_rel_request_body,
-                                                               set_filter_request_body, setup_log,
-                                                               ALL_GOVERNANCE_DEFINITIONS, set_find_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 (get_command_spec)
-from md_processing.md_processing_utils.message_constants import (ERROR, INFO, WARNING, ALWAYS, EXISTS_REQUIRED)
-from pyegeria import EgeriaTech, select_output_format_set
+from md_processing.md_processing_utils.common_md_utils import (update_element_dictionary, set_find_body)
+from md_processing.md_processing_utils.extraction_utils import (extract_command_plus)
+from md_processing.md_processing_utils.md_processing_constants import (get_command_spec, add_default_upsert_attributes,
+                                                                       add_default_link_attributes)
+from md_processing.md_processing_utils.message_constants import (ERROR, INFO, WARNING, EXISTS_REQUIRED)
+from pyegeria import EgeriaTech, PyegeriaException
+from pyegeria.view.base_report_formats import select_report_spec
+from pyegeria.core._exceptions import print_basic_exception, print_validation_error, print_basic_exception
+from pyegeria.core._globals import DEBUG_LEVEL
 
-from pyegeria._globals import DEBUG_LEVEL
+debug_level = DEBUG_LEVEL
+global COMMAND_DEFINITIONS
 
+user_config = settings.User_Profile
 
 # Constants
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
-EGERIA_USAGE_LEVEL = os.environ.get("EGERIA_USAGE_LEVEL", "Basic")
+EGERIA_USAGE_LEVEL = os.environ.get("EGERIA_USAGE_LEVEL", user_config.egeria_usage_level)
+LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", None)
 console = Console(width=EGERIA_WIDTH)
 
-debug_level = DEBUG_LEVEL
-global COMMAND_DEFINITIONS
+
+
 
 
 @logger.catch
@@ -59,7 +62,7 @@ def process_provenance_command(file_path: str, txt: [str]) -> str:
 
 @logger.catch
 def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_action: str, txt: str,
-                       directive: str = "display") -> dict:
+                       directive: str = "display", body_type: str = None) -> dict:
     parsed_attributes, parsed_output = {}, {}
 
     parsed_output['valid'] = True
@@ -68,8 +71,12 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
     display_name = ""
     labels = {}
 
-    command_spec = get_command_spec(f"Create {object_type}")
-    attributes = command_spec.get('Attributes', [])
+    command_spec = get_command_spec(f"Create {object_type}", body_type = body_type)
+    if command_spec is None:
+        logger.error("Command not found in command spec")
+        raise Exception("Command not found in command spec")
+    distinguished_attributes = command_spec.get('Attributes', [])
+    attributes = add_default_upsert_attributes(distinguished_attributes)
     command_display_name = command_spec.get('display_name', None)
     command_qn_prefix = command_spec.get('qn_prefix', None)
 
@@ -89,131 +96,160 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
 
     for attr in attributes:
         for key in attr:
-            # Run some checks to see if the attribute is appropriate to the operation and usage level
-            for_update = attr[key].get('inUpdate', True)
-            level = attr[key].get('level', 'Basic')
-            msg = (f"___\nProcessing `{key}` in `{object_action}` on a `{object_type}` "
-                   f"\n\twith usage level: `{EGERIA_USAGE_LEVEL}` and  attribute level `{level}` and for_update `"
-                   f"{for_update}`\n")
-            logger.trace(msg)
-            if for_update is False and object_action == "Update":
-                logger.trace(f"Attribute `{key}`is not allowed for `Update`", highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Basic" and level != "Basic":
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Advanced" and level in ["Expert", "Invisible"]:
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-            if EGERIA_USAGE_LEVEL == "Expert" and level == "Invisible":
-                logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
-                            highlight=True)
-                continue
-
-            if attr[key].get('input_required', False) is True:
-                if_missing = ERROR
-            else:
-                if_missing = INFO
-
-            # lab = [item.strip() for item in re.split(r'[;,\n]+',attr[key]['attr_labels'])]
-            lab = split_tb_string(attr[key]['attr_labels'])
-            labels: set = set()
-            labels.add(key.strip())
-            if key == 'Display Name':
-                labels.add(object_type.strip())
-            if lab is not None and lab != [""]:
-                labels.update(lab)
-
-            default_value = attr[key].get('default_value', None)
-
-            style = attr[key]['style']
-            if style in ['Simple', 'Comment']:
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
-            elif style == 'Dictionary':
-                parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing, default_value)
-                parsed_attributes[key]['name_list'] = json.dumps(parsed_attributes[key]['value'], indent=2)
-
-            elif style == 'Valid Value':
-                parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
-                                                          attr[key].get('valid_values', None), if_missing,
-                                                          default_value)
-            elif style == 'QN':
-                parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
-                                                    object_action, version, if_missing)
-                if key == 'Qualified Name' and parsed_attributes[key]['value'] and parsed_attributes[key][
-                    'exists'] is False:
-                    parsed_output['exists'] = False
-            elif style == 'ID':
-                parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
-                                                    object_action, version, if_missing)
-
-                parsed_output['guid'] = parsed_attributes[key].get('guid', None)
-                parsed_output['qualified_name'] = parsed_attributes[key].get('qualified_name', None)
-                parsed_output['exists'] = parsed_attributes[key]['exists']
-                if parsed_attributes[key]['valid'] is False:
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += parsed_attributes[key]['reason']
-
-            elif style == 'Reference Name':
-                parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
-                if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) and parsed_attributes[key][
-                    'exists'] is False):
-                    msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
-                    logger.error(msg)
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += msg
-                elif parsed_attributes[key]['valid'] is False:
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += parsed_attributes[key]['reason']
-
-            elif style == 'GUID':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
-            elif style == 'Ordered Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
-            elif style == 'Simple Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
-            elif style == 'Simple List':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
-                name_list = parsed_attributes[key]['value']
-                # attribute = re.split(r'[;,\n]+', name_list) if name_list is not None else None
-                attribute = split_tb_string(name_list)
-                parsed_attributes[key]['value'] = attribute
-                parsed_attributes[key]['name_list'] = name_list
-            elif style == 'Parent':
-                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'])
-
+            try:
+                # Run some checks to see if the attribute is appropriate to the operation and usage level
+                for_update = attr[key].get('inUpdate', True)
+                level = attr[key].get('level', 'Basic')
+                msg = (f"___\nProcessing `{key}` in `{object_action}` on a `{object_type}` "
+                       f"\n\twith usage level: `{EGERIA_USAGE_LEVEL}` and  attribute level `{level}` and for_update `"
+                       f"{for_update}`\n")
+                logger.trace(msg)
+                if for_update is False and object_action == "Update":
+                    logger.trace(f"Attribute `{key}`is not allowed for `Update`", highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Basic" and level != "Basic":
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Advanced" and level in ["Expert", "Invisible"]:
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
+                if EGERIA_USAGE_LEVEL == "Expert" and level == "Invisible":
+                    logger.trace(f"Attribute `{key}` is not supported for `{EGERIA_USAGE_LEVEL}` usage level. Skipping.",
+                                highlight=True)
+                    continue
 
-            elif style == 'Reference Name List':
-                parsed_attributes[key] = proc_name_list(egeria_client, key, txt, labels, if_missing)
-                if (parsed_attributes[key].get("value", None) and (
-                        parsed_attributes[key]['exists'] is False or parsed_attributes[key]['valid'] is False)):
-                    msg = (f"A Reference Name in `{parsed_attributes[key].get('name_list', None)}` is specified but "
-                           f"does not exist")
+                if attr[key].get('input_required', False) is True:
+                    if_missing = ERROR
+                else:
+                    if_missing = INFO
+
+                # lab = [item.strip() for item in re.split(r'[;,\n]+',attr[key]['attr_labels'])]
+                lab = split_tb_string(attr[key]['attr_labels'])
+                labels: set = set()
+                labels.add(key.strip())
+                if key == 'Display Name':
+                    labels.add(object_type.strip())
+                if lab is not None and lab != [""]:
+                    labels.update(lab)
+
+                default_value = attr[key].get('default_value', None)
+
+                style = attr[key]['style']
+                if style in ['Simple', 'Comment']:
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                elif style in ['Dictionary', "Named DICT"]:
+                    parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing, default_value)
+                    if key in parsed_attributes and parsed_attributes[key] is not None:
+                            if parsed_attributes[key].get('value', None) is not None:
+                                if isinstance(parsed_attributes[key]['value'], dict):
+                                    parsed_attributes[key]['dict'] = json.dumps(parsed_attributes[key]['value'], indent=2)
+                            else:
+                                continue
+                    else:
+                        continue
+
+                elif style == 'Valid Value':
+                    parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
+                                                              attr[key].get('valid_values', None), if_missing,
+                                                              default_value)
+                elif style == 'QN':
+                    parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
+                                                        object_action, version, if_missing)
+                    if key == 'Qualified Name' and parsed_attributes[key]['value'] and parsed_attributes[key][
+                        'exists'] is False:
+                        parsed_output['exists'] = False
+                elif style == 'ID':
+                    parsed_attributes[key] = proc_el_id(egeria_client, command_display_name, command_qn_prefix, labels, txt,
+                                                        object_action, version, if_missing)
+
+                    parsed_output['guid'] = parsed_attributes[key].get('guid', None)
+                    parsed_output['qualified_name'] = parsed_attributes[key].get('qualified_name', None)
+                    parsed_output['exists'] = parsed_attributes[key]['exists']
+                    if parsed_attributes[key]['valid'] is False:
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += parsed_attributes[key]['reason']
+
+                elif style == 'Reference Name':
+                    parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
+                    if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) and parsed_attributes[key][
+                        'exists'] is False):
+                        msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
+                        logger.error(msg)
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += msg
+                    elif parsed_attributes[key]['valid'] is False:
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += parsed_attributes[key]['reason']
+
+                elif style == 'GUID':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
+                    g = parsed_attributes[key].get('value', None)
+                    if g and ("___" not in g and "---" not in g):
+                        parsed_output['guid'] = parsed_attributes[key]['value']
+                elif style == 'Ordered Int':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
+                elif style == 'Simple Int':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
+                elif style == 'Simple List':
+                    parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "list")
+                    name_list = parsed_attributes[key]['value']
+                    # attribute = re.split(r'[;,\n]+', name_list) if name_list is not None else None
+                    attribute = split_tb_string(name_list)
+                    parsed_attributes[key]['value'] = attribute
+                    parsed_attributes[key]['name_list'] = name_list
+                elif style == 'Parent':
+                    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)
+                    if (parsed_attributes[key].get("value", None) and (
+                            parsed_attributes[key]['exists'] is False or parsed_attributes[key]['valid'] is False)):
+                        msg = (f"A Reference Name in `{parsed_attributes[key].get('name_list', None)}` is specified but "
+                               f"does not exist")
+                        logger.error(msg)
+                        parsed_output['valid'] = False
+                        parsed_output['reason'] += msg
+                else:
+                    msg = f"Unknown attribute style: {style} for key `{key}`"
                     logger.error(msg)
-                    parsed_output['valid'] = False
-                    parsed_output['reason'] += msg
-            else:
-                msg = f"Unknown attribute style: {style} for key `{key}`"
-                logger.error(msg)
-                sys.exit(1)
+                    sys.exit(1)
+                    parsed_attributes[key]['valid'] = False
+                    parsed_attributes[key]['value'] = None
+                if key == "Display Name":
+                    display_name = parsed_attributes[key]['value']
+
+                value = parsed_attributes[key].get('value', None)
+
+                if value is not None:
+                    if isinstance(value, list):
+                        list_out = f"\n\t* {key}:\n\n"
+                        for item in value:
+                            list_out += f"\t{item}\n"
+                        parsed_output['display'] += list_out
+                    elif isinstance(value, dict):
+                        list_out = f"\n\t* {key}:\n\n"
+                        for k, v in value.items():
+                            list_out += f"\t{k}: \n\t\t{v}\n"
+                        parsed_output['display'] += list_out
+                    else:
+                        parsed_output['display'] += f"\n\t* {key}: \n`{value}`\n\t"
+            except PyegeriaException as e:
+                logger.error(f"PyegeriaException occurred: {e}")
+
+                print_basic_exception(e)
+
+            except ValidationError as e:
                 parsed_attributes[key]['valid'] = False
                 parsed_attributes[key]['value'] = None
-            if key == "Display Name":
-                display_name = parsed_attributes[key]['value']
-
-            value = parsed_attributes[key].get('value', None)
-
-            if value is not None:
-                # if the value is a dict, get the flattened name list
-                value = parsed_attributes[key].get('name_list', None) if isinstance(value, (dict, list)) else value
-                parsed_output['display'] += f"\n\t* {key}: `{value}`\n\t"
+                print_validation_error(e)
 
 
     parsed_output['attributes'] = parsed_attributes
@@ -227,8 +263,8 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
 
 
     if parsed_attributes.get('Parent ID', {}).get('value', None) is not None:
-        if (parsed_attributes['Parent Relationship Type Name']['value'] is None) or (
-                parsed_attributes['Parent at End1']['value'] is None):
+        if (parsed_attributes.get('Parent Relationship Type Name',{}).get('value', None) is None) or (
+                parsed_attributes.get('Parent at End1',{}).get('value',None) is None):
             msg = "Parent ID was found but either Parent `Relationship Type Name` or `Parent at End1` are missing"
             logger.error(msg)
             parsed_output['valid'] = False
@@ -277,11 +313,21 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
     parsed_output['exists'] = False
 
     labels = {}
-    if object_action in ["Unlink","Detach"]:
+    if object_action in ["Link", "Attach", "Unlink", "Detach"]:
         command_spec = get_command_spec(f"Link {object_type}")
+        if command_spec is None:
+            logger.error(f"Command specification not found for 'Link {object_type}'")
+            return None
+        distinguished_attributes = command_spec.get('distinguished_attributes', None)
+        if distinguished_attributes:
+            attributes = add_default_link_attributes(distinguished_attributes)
     else:
         command_spec = get_command_spec(f"{object_action} {object_type}")
-    attributes = command_spec.get('Attributes', [])
+        if command_spec is None:
+            logger.error(f"Command specification not found for '{object_action} {object_type}'")
+            return None
+        attributes = command_spec.get('Attributes', None)
+
     command_display_name = command_spec.get('display_name', None)
 
     parsed_output['reason'] = ""
@@ -290,6 +336,17 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
     msg = f"\tProcessing {object_action} on  {object_type}  \n"
     logger.info(msg)
 
+    # Helper: convert label to snake_case
+    def _to_snake_case(name: str) -> str:
+        name = name.strip()
+        # Replace non-alphanumeric with space, then collapse spaces to underscores
+        name = re.sub(r"[^0-9A-Za-z]+", "_", name)
+        # Lowercase and trim possible leading/trailing underscores
+        return name.strip("_").lower()
+
+    # Build known labels set from command spec
+    known_labels: set[str] = set()
+
     # get the version early because we may need it to construct qualified names.
 
     for attr in attributes:
@@ -327,6 +384,11 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             if lab is not None and lab != [""]:
                 labels.update(lab)
 
+            # Keep track of all known labels for later filtering of kwargs
+            for lab_entry in labels:
+                if lab_entry is not None and lab_entry != "":
+                    known_labels.add(lab_entry.strip())
+
             # set these to none since not needed for view commands
             version = None
             command_qn_prefix = None
@@ -356,20 +418,20 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
 
                 parsed_output['guid'] = parsed_attributes[key].get('guid', None)
                 parsed_output['qualified_name'] = parsed_attributes[key].get('qualified_name', None)
-                parsed_output['exists'] = parsed_attributes[key]['exists']
-                if parsed_attributes[key]['valid'] is False:
+                parsed_output['exists'] = parsed_attributes.get(key,{}).get('exists',None)
+                if parsed_attributes.get(key,{}).get('valid',None) is False:
                     parsed_output['valid'] = False
-                    parsed_output['reason'] += parsed_attributes[key]['reason']
+                    parsed_output['reason'] += parsed_attributes.get(key,{}).get('reason',None)
 
             elif style == 'Reference Name':
                 parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
                 if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) is None):
-                    msg = f"Required parameter `{parsed_attributes[key]['value']}` is missing"
+                    msg = f"Required parameter `{parsed_attributes.get(key,{}).get('value',None)}` is missing"
                     logger.error(msg)
                     parsed_output['valid'] = False
                     parsed_output['reason'] += msg
-                elif parsed_attributes[key]['value'] and parsed_attributes[key]['exists'] is False:
-                    msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
+                elif parsed_attributes.get(key,{}).get('value',None) and parsed_attributes.get(key,{}).get('exists',None) is False:
+                    msg = f"Reference Name `{parsed_attributes.get(key,{}).get('value',None)}` is specified but does not exist"
                     logger.error(msg)
                     parsed_output['valid'] = False
                     parsed_output['reason'] += msg
@@ -420,6 +482,26 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
 
     parsed_output['attributes'] = parsed_attributes
 
+    # Now, collect any unrecognized commands into kwargs
+    # Find all level-2 headings in the text
+    all_headings = set(re.findall(r"^\s*##\s*([^\n#]+)", txt, flags=re.MULTILINE))
+
+    kwargs: dict = {}
+    for heading in all_headings:
+        h = heading.strip()
+        if not h:
+            continue
+        if h in known_labels:
+            continue  # already known/processed
+        # Parse this unknown attribute using the simple attribute logic
+        parsed = proc_simple_attribute(txt, object_action, {h}, INFO, None)
+        value = parsed.get('value', None)
+        if value is not None:
+            kwargs[_to_snake_case(h)] = value.replace('\n', '') if isinstance(value, str) else value
+
+    if kwargs:
+        parsed_output['kwargs'] = kwargs
+
 
     if directive in ["validate", "process"] and not parsed_output['valid'] and object_action == "Update":
         msg = f"Request is invalid, `{object_action} {object_type}` is not valid - see previous messages\n"
@@ -459,7 +541,12 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     attribute = extract_attribute(txt, labels)
 
-    attribute = default_value if attribute is None else attribute.replace('\n', '')
+    # attribute = default_value if attribute is None else attribute.replace('\n', '')
+    attribute = default_value if attribute is None else attribute
+    if isinstance(attribute, str):
+        attribute = re.sub(r'\n+', '\n', attribute)
+        attribute = None if attribute.startswith('___') or attribute.startswith('---') else attribute
+
 
     if attribute is None:
         if if_missing == INFO or if_missing == WARNING:
@@ -474,8 +561,10 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     if attribute and simp_type == "int" :
         attribute = int(attribute)
-    elif attribute and simp_type == "list":
-        attribute = list(attribute)
+    # elif attribute and simp_type == "list":
+    #     if isinstance(attribute, str):
+    #         attribute = [piece.strip() for piece in re.split(r'[,\n]', attribute) if piece.strip()]
+
 
 
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
@@ -509,8 +598,8 @@ def proc_dictionary_attribute(txt: str, action: str, labels: set, if_missing: st
         default_value = None
 
     attr = extract_attribute(txt, labels)
-    attribute = json.loads(attr) if attr is not None else default_value
-
+    # attribute = json.loads(attr) if attr is not None else default_value
+    attribute = parse_to_dict(attr)
 
     if attribute is None:
         if if_missing == INFO or if_missing == WARNING:
@@ -735,7 +824,7 @@ def proc_el_id(egeria_client: EgeriaTech, element_type: str, qn_prefix: str, ele
         logger.info(msg)
 
         if q_name is None and qualified_name is None:
-            q_name = egeria_client.__create_qualified_name__(qn_prefix, element_name, version_identifier=version)
+            q_name = egeria_client.__create_qualified_name__(qn_prefix, element_name, LOCAL_QUALIFIER, version)
             update_element_dictionary(q_name, {'display_name': element_name})
 
         elif qualified_name:
@@ -792,6 +881,9 @@ def proc_ids(egeria_client: EgeriaTech, element_type: str, element_labels: set,
     element_name = extract_attribute(txt, element_labels)
 
     if element_name:
+        if element_type == "Tag ID": # Special case for informal tags
+            element_type = "InformalTag"
+
         if '\n' in element_name or ',' in element_name:
             msg = f"Element name `{element_name}` appears to be a list rather than a single element"
             logger.error(msg)
@@ -1063,7 +1155,7 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
     """
     Processes a generic output request by extracting attributes (including Output Format and
     Output Format Set) and dynamically invoking the find function specified by the
-    output_format_set, following the approach used in commands/cat/list_format_set.
+    report_spec, following the approach used in commands/cat/list_format_set.
 
     This is modeled on process_gov_definition_list_command but uses the dynamic
     dispatch via the output format set rather than directly calling a specific
@@ -1087,13 +1179,13 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
 
     search_string = attr.get('Search String', {}).get('value', '*')
     output_format = attr.get('Output Format', {}).get('value', 'LIST')
-    output_format_set = attr.get('Output Format Set', {}).get('value', object_type)
+    report_spec = attr.get('Output Format Set', {}).get('value', object_type)
 
     if directive == "display":
         return None
     elif directive == "validate":
         # Validate that the format set exists and has an action
-        fmt = select_output_format_set(output_format_set, "ANY") if valid else None
+        fmt = select_report_spec(report_spec, "ANY") if valid else None
         if valid and fmt and fmt.get("action"):
             print(Markdown(f"==> Validation of {command} completed successfully!\n"))
             return True
@@ -1110,9 +1202,9 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
                 return None
 
             # Resolve the find function from the output format set
-            fmt = select_output_format_set(output_format_set, output_format)
+            fmt = select_report_spec(report_spec, output_format)
             if not fmt:
-                logger.error(f"Output format set '{output_format_set}' not found or not compatible with '{output_format}'.")
+                logger.error(f"Output format set '{report_spec}' not found or not compatible with '{output_format}'.")
                 return None
             action = fmt.get("action", {})
             func_spec = action.get("function")
@@ -1135,7 +1227,7 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
                 'search_string': search_string,
                 'body': body,
                 'output_format': output_format,
-                'output_format_set': output_format_set,
+                'report_spec': report_spec,
             }
 
             # Call the resolved method
@@ -1145,7 +1237,7 @@ def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str =
                 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}` using format set '{output_format_set}'")
+            logger.info(f"Wrote `{object_type}` for search string: `{search_string}` using format set '{report_spec}'")
 
             return list_md