pyegeria 5.4.0.3__py3-none-any.whl → 5.4.0.5__py3-none-any.whl

pyegeria/_output_formats.py

@@ -5,18 +5,24 @@ Copyright Contributors to the ODPi Egeria project.
 
 """
 # Purpose
+This file manages output format sets.
+
 pyegeria allows find and get requests to generate output in different output formats - 
 including DICT, MD, FORM, REPORT, LIST, MERMAID, TABLE, and perhaps additional ones in the future.
 
-Some of the formats, such as REPORT and LIST,  allow the user to filter which attributes to
+Some of the formats, such as REPORT and LIST, allow the user to filter which attributes to
 display, and the order in which they appear. However, many, if not most users will likely not want to customize
 the column list and so we need a sensible set of defaults for each type of output. These defaults are used 
 by the find and get methods if the user doesn't provide a value for the columns parameter.
 
-This file contains these defaults and a function to return the the right default dict for a given type.
-
+This file contains these defaults and a function to return the right default dict for a given type.
 """
 
+from loguru import logger
+
+# Constants
+MD_SEPARATOR = "\n---\n\n"
+
 # Define shared elements
 COMMON_COLUMNS = [
     {'name': 'Display Name', 'key': 'display_name'},
@@ -49,6 +55,11 @@ COLLECTION_DICT = {
         "columns": COLLECTIONS_COLUMNS,
     }
 
+COLLECTION_TABLE = {
+    "types": ["TABLE"],
+    "columns": COMMON_COLUMNS,
+    }
+
 COMMON_ANNOTATIONS = {
     "wikilinks": ["[[Commons]]"]
 }
@@ -85,7 +96,11 @@ output_format_sets = {
         "aliases": ["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                     "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         "annotations": COMMON_ANNOTATIONS,
-        "formats": [COMMON_FORMATS_ALL, COLLECTION_DICT]  # 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": {    },
+            }]
     },
 
     "DigitalProducts": {
@@ -107,6 +122,11 @@ output_format_sets = {
                     {'name': 'Members', 'key': 'members', 'format': True},
                 ],
             }
+        ],
+        "action": [{"function": "CollectionManager.find_collections",
+                    "user_params": [ "search_string"],
+                    "spec_params": { "classification_name":"DigitalProducts"}
+                       }
         ]
     },
 
@@ -115,30 +135,74 @@ output_format_sets = {
         "description": "Attributes generic to all Agreements.",
         "aliases": ["DataSharingAgreement"],
         "annotations": {"wikilinks": ["[[Agreements]]", "[[Egeria]]"]},
-        "formats": COMMON_FORMATS_ALL  # Reusing common formats and columns
+        "formats": [COMMON_FORMATS_ALL] # Reusing common formats and columns
     },
 
-    "Data Dictionary": {
+    "DataDictionary": {
         "heading": "Data Dictionary Information",
         "description": "Attributes useful to Data Dictionary.",
-        "aliases": ["Data Dict"],
+        "aliases": ["Data Dict", "Data Dictionary"],
         "annotations": {"wikilinks": ["[[Data Dictionary]]"]},
-        "formats": COMMON_FORMATS_ALL  # Reusing common formats and columns
+        "formats": [COMMON_FORMATS_ALL],  # Reusing common formats and columns
+        "action": [{"function": "CollectionManager.find_collections",
+                   "user_params": [ "search_string"],
+                   "spec_params": { "classification_name": "DataDictionary" },
+            }]
     },
 
     "Data Specification": {
         "heading": "Data Specification Information",
         "description": "Attributes useful to Data Specification.",
-        "aliases": ["Data Spec"],
+        "aliases": ["Data Spec", "DataSpec", "DataSpecification"],
         "annotations": {"wikilinks": ["[[Data Specification]]"]},
-        "formats": COMMON_FORMATS_ALL  # 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" },
+            }]
+    },
+    "DataStruct": {
+        "heading": "Data Structure Information",
+        "description": "Attributes useful to Data Structures.",
+        "aliases": ["Data Structure", "DataStructures", "Data Structures", "Data Struct", "DataStructure"],
+        "annotations": {"wikilinks": ["[[Data Structure]]"]},
+        "formats": [{"types": ["ALL"], "columns" : COMMON_COLUMNS}],  # Reusing common formats and columns
+        "action": [{"function": "DataDesigner.find_data_structures",
+                   "user_params": ["search_string" ],
+                   "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",
+        "aliases": [],
+        "annotations": {"wikilinks": ["[[Data Structure]]"]},
+        "formats": [{"types": ["TABLE"], "columns":  COMMON_COLUMNS + [{'name': 'GUID', 'key': 'GUID'}]},
+                    { "types": ["DICT", "LIST", "REPORT"], "columns": COMMON_COLUMNS + [{'name': 'GUID', 'key': 'GUID'}]}
+                    ],
+        "action": [{
+                       "function": "DataDesigner.find_data_structures",
+                       "user_params": ["filter"],
+                       "spec_params": {},
+                       }]
+        },
 }
 
-
 def select_output_format_set(kind: str, output_type: str) -> dict | None:
     """
     This function retrieves the appropriate output set configuration dictionary based on the `kind` and `output_type`.
+    If output_type = `ANY` that indicates this is just a test to see of the output format set exists.
 
     :param kind: The kind of output set (e.g., "Referenceable", "Collections").
     :param output_type: The desired output format type (e.g., "DICT", "LIST", "REPORT").
@@ -147,17 +211,14 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
     Returns:
         dict | None: 
     """
-    from loguru import logger
-    # from pyegeria.logging_configuration import config_logging
-
-    # config_logging()
-
     # Normalize the output type to uppercase for consistency
+    output_sets = output_format_sets
+
     output_type = output_type.upper()
     output_struct:dict = {}
 
     # Step 1: Check if `kind` exists in the `output_format_sets` dictionary
-    element = output_format_sets.get(kind)
+    element = output_sets.get(kind)
 
     # Step 2: If not found, attempt to match `kind` in aliases
     if element is None:
@@ -170,7 +231,7 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 
     # Step 3: If still not found, return None
     if element is None:
-        msg = "No matching column set found for kind='{kind}' and output type='{output_type}'."
+        msg = f"No matching column set found for kind='{kind}' and output type='{output_type}'."
         logger.error(msg)
         return None
     else:
@@ -178,6 +239,12 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
         output_struct["heading"] = element.get("heading", [])
         output_struct["description"] = element.get("description", [])
         output_struct["annotations"] = element.get("annotations", {})
+        if "action" in element:
+            output_struct["action"] = element.get("action", [])
+
+    # If this was just a validation that the format set could be found then the output type is ANY - so just return.
+    if output_type == "ANY":
+        return output_struct
 
     # Step 4: Search for a matching format in the `formats` list
     for format in element.get("formats", []):
@@ -193,4 +260,27 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 
     # Step 6: If no match is found, return None
     logger.error(f"No matching format found for kind='{kind}' with output type='{output_type}'.")
-    return None
+    return None
+
+def output_format_set_list()->list[str]:
+    return list(output_format_sets.keys())
+
+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: 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 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,