pyegeria 5.4.0.4__py3-none-any.whl → 5.4.0.6__py3-none-any.whl

commands/cat/list_collections.py

@@ -16,52 +16,44 @@ from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
 from rich.text import Text
-
+from loguru import logger
 from pyegeria import (
-    # EgeriaTech,
-    # InvalidParameterException,
-    # PropertyServerException,
-    # UserNotAuthorizedException,
     CollectionManager,
-     NO_ELEMENTS_FOUND,config_logging, get_app_config
+     NO_ELEMENTS_FOUND,config_logging, get_app_config, init_logging
     )
 from pyegeria._exceptions_new import PyegeriaException, print_exception_response
 
-
-
-# disable_ssl_warnings = True
-
-# EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
-# EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
-# EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
-# EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "view-server")
-# EGERIA_VIEW_SERVER_URL = os.environ.get(
-#     "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
-# )
-# EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
-# EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
-# EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
-# EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
-# EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
-# EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
-# EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
-# EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
-# EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
-app_settings = get_app_config()
-app_config = app_settings["Environment"]
+PYEGERIA_ROOT_PATH= os.environ.get("PYEGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
+app_settings = get_app_config(PYEGERIA_ROOT_PATH+"/.env")
+app_config = app_settings.Environment
 config_logging()
 
+out_struct = {
+            "formats": {
+                "types": ["ALL"],
+                "columns": [
+                    {'name': 'display_name', 'key': 'display_name'},
+                    {'name': 'qualified_name', 'key': 'qualified_name', 'format': True},
+                    {'name': 'description', 'key': 'description', 'format': True},
+                    {'name': "classifications", 'key': 'classifications'},
+                    {'name': 'members', 'key': 'members', 'format': True},
+                    {'name': 'collection_type', 'key': 'collection_type', 'format': True},
+                    {'name': 'GUID', 'key': 'GUID'},
+                ],
+            },
+
+        }
 
 def display_collections(
     search_string: str = "*",
-    view_server: str = app_config['Egeria View Server'],
-    view_url: str = app_config['Egeria View Server URL'],
-    user: str = EGERIA_USER,
-    user_pass: str = EGERIA_USER_PASSWORD,
-    jupyter: bool = app_config['Egeria Jupyter'],
-    width: int = app_config['Console Width'],
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
+    user: str = app_settings.User_Profile.user_name,
+    user_pass: str = app_settings.User_Profile.user_pwd,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width,
     output_format: str = "TABLE"
 ):
     """Display either a specified glossary or all collections if the search_string is '*'.
@@ -144,9 +136,10 @@ def display_collections(
 
         collections = m_client.find_collections(
             search_string.strip(), None, True, False, ignore_case=True,
-            output_format = "DICT"
+            output_format = "DICT", output_format_set=out_struct
         )
         if type(collections) is list:
+
             sorted_collection_list = sorted(
                 collections, key=lambda k: k["display_name"]
             )
@@ -203,13 +196,13 @@ def main():
     parser.add_argument("--password", help="User Password")
 
     args = parser.parse_args()
-    app_settings = get_app_config()
-    app_config = app_settings["Environment"]
+    # app_settings = get_app_config(PYEGERIA_ROOT_PATH + "/.env")
+    # app_config = app_settings.Environment
 
-    server = args.server if args.server is not None else app_config['Egeria View Server']
-    url = args.url if args.url is not None else app_config['Egeria View Server URL']
-    userid = args.userid if args.userid is not None else EGERIA_USER
-    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_url
+    userid = args.userid if args.userid is not None else app_settings.User_Profile.user_name
+    user_pass = args.password if args.password is not None else app_settings.User_Profile.user_pwd
 
     try:
         search_string = Prompt.ask(
@@ -227,4 +220,7 @@ def main():
 
 
 if __name__ == "__main__":
+    # EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+    # EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+    # PYEGERIA_ROOT_PATH = os.environ.get("PYEGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
     main()

commands/cat/list_format_set.py

@@ -61,21 +61,21 @@ from pyegeria.egeria_tech_client import EgeriaTech
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
 app_settings = get_app_config()
-app_config = app_settings["Environment"]
+app_config = app_settings.Environment
 config_logging()
 
 console = Console(
     style="bold bright_white on black",
-    width=app_config["Console Width"],
-    force_terminal=not app_config["Egeria Jupyter"],
+    width=app_config.console_width,
+    force_terminal=not app_config.egeria_jupyter,
     )
 
 def execute_format_set_action(
     format_set_name: str,
-    view_server: str = app_config['Egeria View Server'],
-    view_url: str = app_config['Egeria View Server URL'],
-    user: str = EGERIA_USER,
-    user_pass: str = EGERIA_USER_PASSWORD,
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
+    user: str = app_settings.User_Profile.user_name,
+    user_pass: str = app_settings.User_Profile.user_pwd,
     output_format: str = "TABLE",
     **kwargs
 ):
@@ -225,7 +225,7 @@ def execute_format_set_action(
 
             with open(full_file_path, 'w') as f:
                 f.write(output)
-            print(f"\n==> Output written to {full_file_path}")
+            print(f"\n==> Output written to [{format_set_name}]({full_file_path})")
             return
 
         # For TABLE output, add output_format to params

commands/cli/egeria.py

@@ -138,8 +138,8 @@ from commands.tech.generic_actions import delete_element
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
 app_settings = get_app_config()
-app_config = app_settings["Environment"]
-# config_logging()
+app_config = app_settings.Environment
+config_logging()
 
 
 @tui()
@@ -148,42 +148,42 @@ app_config = app_settings["Environment"]
 @click.group()
 @click.option(
     "--server",
-    default=app_config['Egeria Metadata Store'],
+    default=app_config.egeria_metadata_store,
     help="Egeria metadata store to work with",
 )
 @click.option(
     "--url",
-    default=app_config["Egeria Platform URL"],
+    default=app_config.egeria_platform_url,
     help="URL of Egeria metadata store platform to connect to",
 )
 @click.option(
     "--integration_daemon",
-    default=app_config["Egeria Integration Daemon"],
+    default=app_config.egeria_integration_daemon,
     help="Egeria integration daemon to work with",
 )
 @click.option(
     "--integration_daemon_url",
-    default=app_config['Egeria Integration Daemon URL'],
+    default=app_config.egeria_integration_daemon_url,
     help="URL of Egeria integration daemon platform to connect to",
 )
 @click.option(
     "--view_server",
-    default=app_config['Egeria View Server'],
+    default=app_config.egeria_view_server,
     help="Egeria view server to work with",
 )
 @click.option(
     "--view_server_url",
-    default=app_config['Egeria View Server URL'],
+    default=app_config.egeria_view_server_url,
     help="URL of Egeria view server platform to connect to",
 )
 @click.option(
     "--engine_host",
-    default=app_config['Egeria Engine Host'],
+    default=app_config.egeria_engine_host,
     help="Egeria engine host to work with",
 )
 @click.option(
     "--engine_host_url",
-    default=app_config['Egeria Engine Host URL'],
+    default=app_config.egeria_engine_host_url,
     help="URL of Egeria engine host platform to connect to",
 )
 
@@ -202,40 +202,40 @@ app_config = app_settings["Environment"]
     "--jupyter",
     is_flag=True,
     type=bool,
-    default=app_config['Egeria Jupyter'],
+    default=app_config.egeria_jupyter,
     help="Enable for rendering in a Jupyter terminal",
 )
 @click.option(
     "--width",
-    default=app_config['Console Width'],
+    default=app_config.console_width,
     type=int,
     help="Screen width, in characters, to use",
 )
 @click.option(
-    "--home_glossary_guid",
-    default=app_settings['User Profile']['Egeria Home Glossary Name'],
+    "--home_glossary_name",
+    default=app_settings.User_Profile.egeria_home_glossary_name,
     help="Glossary name to use as the home glossary",
 )
 @click.option(
     "--glossary_path",
-    default=app_config['Egeria Glossary Path'],
+    default=app_config.egeria_glossary_path,
     help="Path to glossary import/export files",
 )
 
 @click.option(
     "--root_path",
-    default=app_config['Pyegeria Root'],
+    default=app_config.pyegeria_root,
     help="Root path to use for file operations",
 )
 
 @click.option(
     "--inbox_path",
-    default=app_config['Dr.Egeria Inbox'],
+    default=app_config.dr_egeria_inbox,
     help="Path to inbox files",
 )
 @click.option(
     "--outbox_path",
-    default=app_config['Dr.Egeria Outbox'],
+    default=app_config.dr_egeria_outbox,
     help="Path to outbox files",
 )
 
@@ -255,7 +255,7 @@ def cli(
     timeout,
     jupyter,
     width,
-    home_glossary_guid,
+    home_glossary_name,
     glossary_path,
     root_path,
     inbox_path,
@@ -276,7 +276,7 @@ def cli(
         timeout,
         jupyter,
         width,
-        home_glossary_guid,
+        home_glossary_name,
         glossary_path,
         root_path,
         inbox_path,

commands/cli/egeria_cat.py

@@ -80,37 +80,37 @@ app_config = app_settings["Environment"]
 )
 @click.option(
     "--url",
-    default=app_config["Egeria Platform URL"],
+    default=app_config.egeria_platform_url,
     help="URL of Egeria metadata store platform to connect to",
 )
 @click.option(
     "--integration_daemon",
-    default=app_config["Egeria Integration Daemon"],
+    default=app_config.egeria_integration_daemon,
     help="Egeria integration daemon to work with",
 )
 @click.option(
     "--integration_daemon_url",
-    default=app_config['Egeria Integration Daemon URL'],
+    default=app_config.egeria_integration_daemon_url,
     help="URL of Egeria integration daemon platform to connect to",
 )
 @click.option(
     "--view_server",
-    default=app_config['Egeria View Server'],
+    default=app_config.egeria_view_server,
     help="Egeria view server to work with",
 )
 @click.option(
     "--view_server_url",
-    default=app_config['Egeria View Server URL'],
+    default=app_config.egeria_view_server_url,
     help="URL of Egeria view server platform to connect to",
 )
 @click.option(
     "--engine_host",
-    default=app_config['Egeria Engine Host'],
+    default=app_config.egeria_engine_host,
     help="Egeria engine host to work with",
 )
 @click.option(
     "--engine_host_url",
-    default=app_config['Egeria Engine Host URL'],
+    default=app_config.egeria_engine_host_url,
     help="URL of Egeria engine host platform to connect to",
 )
 
@@ -129,40 +129,40 @@ app_config = app_settings["Environment"]
     "--jupyter",
     is_flag=True,
     type=bool,
-    default=app_config['Egeria Jupyter'],
+    default=app_config.egeria_jupyter,
     help="Enable for rendering in a Jupyter terminal",
 )
 @click.option(
     "--width",
-    default=app_config['Console Width'],
+    default=app_config.console__width,
     type=int,
     help="Screen width, in characters, to use",
 )
 @click.option(
     "--home_glossary_guid",
-    default=app_settings['User Profile']['Egeria Home Glossary Name'],
+    default=app_settings.User_Profile.home_glossary_guid,
     help="Glossary name to use as the home glossary",
 )
 @click.option(
     "--glossary_path",
-    default=app_config['Egeria Glossary Path'],
+    default=app_config.egeria_platform_glossary_path,
     help="Path to glossary import/export files",
 )
 
 @click.option(
     "--root_path",
-    default=app_config['Pyegeria Root'],
+    default=app_config.pyegeria_root,
     help="Root path to use for file operations",
 )
 
 @click.option(
     "--inbox_path",
-    default=app_config['Dr.Egeria Inbox'],
+    default=app_config.dr_egeria_inbox,
     help="Path to inbox files",
 )
 @click.option(
     "--outbox_path",
-    default=app_config['Dr.Egeria Outbox'],
+    default=app_config.dr_egeria_outbox,
     help="Path to outbox files",
 )
 

commands/cli/ops_config.py

@@ -17,7 +17,7 @@ class Config(object):
         timeout: int,
         jupyter: bool,
         width: int,
-        home_glossary_guid: str,
+        home_glossary_name: str,
         glossary_path: str,
         root_path: str,
         inbox_path: str,
@@ -39,7 +39,7 @@ class Config(object):
         self.width = width
         self.server = server
         self.url = url
-        self.home_glossary_guid = home_glossary_guid
+        self.home_glossary_name = home_glossary_name
         self.glossary_path = glossary_path
         self.root_path = root_path
         self.inbox_path = inbox_path

pyegeria/__init__.py

@@ -11,7 +11,7 @@ the server platform and servers.
 
 """
 from .load_config import load_app_config, get_app_config
-from .logging_configuration import config_logging
+from .logging_configuration import config_logging, init_logging
 from ._globals import (INTEGRATION_GUIDS, TEMPLATE_GUIDS, default_time_out, disable_ssl_warnings, enable_ssl_check,
                        is_debug, max_paging_size, NO_ELEMENTS_FOUND, NO_ASSETS_FOUND, NO_SERVERS_FOUND,
                        NO_CATALOGS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_CATEGORIES_FOUND, NO_ELEMENT_FOUND,

pyegeria/_exceptions_new.py

@@ -360,3 +360,32 @@ def print_exception_table(e: PyegeriaException):
         console.print(table)
     else:
         print(f"\n\n\t  Not an Pyegeria exception {e}")
+
+def print_basic_exception(e: PyegeriaException):
+    """Prints the exception response"""
+    related_code = e.related_http_code if hasattr(e, "related_http_code") else ""
+    related_response = e.response.json()
+    table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
+    table.caption = e.pyegeria_code
+    table.add_column("Facet", justify="center")
+    table.add_column("Item", justify="left", width=80)
+
+    if isinstance(e, PyegeriaException):
+        table.add_row("HTTP Code", str(e.response_code))
+        table.add_row("Egeria Code", str(related_code))
+        table.add_row("Caller Method", e.context.get("caller method", "---"))
+        table.add_row("Request URL", str(e.response_url))
+        table.add_row("Egeria Message",
+                      format_dict_to_string(related_response.get('exceptionErrorMessage',"")))
+        table.add_row("Egeria User Action",
+                      format_dict_to_string(related_response.get('exceptionUserAction',"")))
+
+        exception_msg_id = related_response.get("exceptionErrorMessageId", None)
+        table.add_row("Pyegeria Exception", exception_msg_id)
+        table.add_row("Pyegeria Message",
+                      f"\n\t{e.error_details['message_template'].format(exception_msg_id)}\n")
+
+
+        console.print(table)
+    else:
+        print(f"\n\n\t  Not an Pyegeria exception {e}")

pyegeria/_output_formats.py

@@ -96,7 +96,7 @@ output_format_sets = {
         "aliases": ["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                     "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         "annotations": COMMON_ANNOTATIONS,
-        "formats": [COMMON_FORMATS_ALL, COLLECTION_DICT, COLLECTION_TABLE], # Reusing common formats
+        "formats": [ COLLECTION_DICT, COLLECTION_TABLE,COMMON_FORMATS_ALL], # Reusing common formats
         "action": [{"function": "CollectionManager.find_collections",
                    "user_params": [ "search_string"],
                    "spec_params": {    },
@@ -155,7 +155,7 @@ output_format_sets = {
         "description": "Attributes useful to Data Specification.",
         "aliases": ["Data Spec", "DataSpec", "DataSpecification"],
         "annotations": {"wikilinks": ["[[Data Specification]]"]},
-        "formats": [{"types": ["TABLE"], "columns": COMMON_COLUMNS,}],  # Reusing common formats and columns
+        "formats": [{"types": ["DICT"], "columns": COMMON_COLUMNS,}],  # Reusing common formats and columns
         "action": [{"function": "CollectionManager.find_collections",
                    "user_params": [ "search_string"],
                    "spec_params": { "classification_name": "DataSpec" },
@@ -172,6 +172,17 @@ output_format_sets = {
                    "spec_params": {  },
             }]
     },
+"DataField": {
+        "heading": "Data Structure Information",
+        "description": "Attributes useful to Data Structures.",
+        "aliases": ["Data Field", "Data Fields", "DataFields"],
+        "annotations": {"wikilinks": ["[[Data Field]]"]},
+        "formats": [{"types": ["ALL"], "columns" : COMMON_COLUMNS}],  # Reusing common formats and columns
+        "action": [{"function": "DataDesigner.find_data_fields",
+                   "user_params": ["search_string" ],
+                   "spec_params": {  },
+            }]
+    },
     "Mandy-DataStruct": {
         "heading": "Puddy Approves",
         "description": "This is a tutorial on how to use a data struct description",
@@ -254,7 +265,22 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 def output_format_set_list()->list[str]:
     return list(output_format_sets.keys())
 
-def get_output_format_set_heading(format_set: str) -> str:
+def get_output_format_set_heading(format_set: dict) -> str:
     return output_format_sets[format_set].get("heading")
-def get_output_format_set_description(format_set: str) -> str:
+def get_output_format_set_description(format_set: dict) -> str:
     return output_format_sets[format_set].get("description")
+
+def get_output_format_type_match(format_set: dict, output_format: str) -> dict:
+    if isinstance(format_set, list):
+        for format in format_set.get("formats", []):
+            if output_format in format.get("types", []):
+                format_set["formats"] = format
+                return format_set
+
+        # Step 5: Handle the fallback case of "ALL"
+        for format in format_set.get("formats", []):
+            if "ALL" in format.get("types", []):
+                format_set["formats"] = format
+                return format_set
+    else:
+        return format_set

pyegeria/collection_manager_omvs.py

@@ -11,7 +11,7 @@ from typing import Dict, Union, List, Optional
 
 from loguru import logger
 
-from pyegeria._output_formats import select_output_format_set
+from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 from pyegeria._client import Client
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
 from pyegeria._validators import validate_guid, validate_search_string
@@ -150,8 +150,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None, output_format,
-                                                   output_format_set=output_format_set)
+            return self._generate_collection_output(elements, None, None, output_format,
+                                                    output_format_set=output_format_set)
         return elements
 
 
@@ -303,8 +303,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, classification_name,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, classification_name,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -549,8 +549,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, filter, classification_name,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, filter, classification_name,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -687,8 +687,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, filter, collection_type,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, filter, collection_type,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -818,8 +818,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, collection_type,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, collection_type,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -952,8 +952,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.debug(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -1091,8 +1091,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -1218,8 +1218,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -6461,9 +6461,9 @@ class CollectionManager(Client2):
         return props
 
 
-    def generate_collection_output(self, elements: Union[Dict, List[Dict]], filter: Optional[str],
-                                   classification_name: Optional[str], output_format: str = "DICT",
-                                   output_format_set: Optional[dict] | str = None) -> Union[str, List[Dict]]:
+    def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],
+                                    classification_name: Optional[str], output_format: str = "DICT",
+                                    output_format_set: dict | str = None) -> str| list[dict]:
         """ Generate output for collections in the specified format.
 
             Args:
@@ -6484,15 +6484,16 @@ class CollectionManager(Client2):
         # First see if the user has specified an output_format_set - either a label or a dict
         if output_format_set:
             if isinstance(output_format_set, str):
-                output_formats = select_output_format_set(entity_type, output_format)
+                output_formats = select_output_format_set(output_format_set, output_format)
             if isinstance(output_format_set, dict):
-                output_formats = output_format_set
-
+                output_formats = get_output_format_type_match(output_format_set, output_format)
         # If no output_format was set, then use the classification_name to lookup the output format
         elif classification_name:
             output_formats = select_output_format_set(classification_name, output_format)
         else:
-            output_formats = None
+            # fallback to collections or entity type
+            output_formats = select_output_format_set(entity_type,output_format)
+
         logger.trace(f"Executing generate_collection_output for {entity_type}: {output_formats}")
         return generate_output(
             elements,