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

pyegeria/output_formatter.py

@@ -11,6 +11,60 @@ console = Console(width= 250)
 # Constants
 MD_SEPARATOR = "\n---\n\n"
 
+
+def _extract_referenceable_properties(element: dict[str, Any]) -> dict[str, Any]:
+    # Get general header attributes
+    guid = element['elementHeader'].get("guid", None)
+    metadata_collection_id = element['elementHeader']['origin'].get("homeMetadataCollectionId", None)
+    metadata_collection_name = element['elementHeader']['origin'].get("homeMetadataCollectionName", None)
+    origin_category = element['elementHeader'].get("origin_category", None)
+    created_by = element['elementHeader']["versions"].get("createdBy", None)
+    create_time = element['elementHeader']["versions"].get("createTime", None)
+    updated_by = element['elementHeader']["versions"].get("updatedBy", None)
+    version = element['elementHeader']["versions"].get("version", None)
+    type_name = element['elementHeader']["type"].get("typeName", None)
+    classifications = element['elementHeader'].get("classifications", [])
+
+    # Get attributes from properties
+    properties = element['properties']
+    display_name = properties.get("name", "") or ""
+    description = properties.get("description", "") or ""
+    qualified_name = properties.get("qualifiedName", "") or ""
+    category = properties.get("category", "") or ""
+    version_identifier = properties.get("versionIdentifier", "") or ""
+    additional_properties = properties.get("additionalProperties", {}) or {}
+    extended_properties = properties.get("extendedProperties", {}) or {}
+    effective_from = element['elementHeader'].get("effectiveFrom", None)
+    effective_to = element['elementHeader'].get("effectiveTo", None)
+
+    return {
+        "GUID": guid,
+        "metadata_collection_id": metadata_collection_id,
+        "metadata_collection_name": metadata_collection_name,
+        "origin_category": origin_category,
+        "created_by": created_by,
+        "create_time": create_time,
+        "updated_by": updated_by,
+        "version": version,
+        "type_name": type_name,
+        "classifications": classifications,
+
+        "display_name": display_name,
+        "description": description,
+        "qualified_name": qualified_name,
+        "category": category,
+        "version_identifier": version_identifier,
+        "additional_properties": additional_properties,
+        "extended_properties": extended_properties,
+        "effective_from": effective_from,
+        "effective_to": effective_to,
+        }
+
+
+
+
+
+
 def markdown_to_html(markdown_text: str) -> str:
     """
     Convert markdown text to HTML, with special handling for mermaid code blocks.
@@ -120,7 +174,7 @@ def make_md_attribute(attribute_name: str, attribute_value: str, output_type: st
     output = ""
     if isinstance(attribute_value,str):
         attribute_value = attribute_value.strip() if attribute_value else ""
-    elif isinstance(attribute_value,list):
+    elif isinstance(attribute_value,list) and len(attribute_value) > 0:
         attribute_value = ",\n".join(attribute_value)
     if attribute_name:
         if attribute_name.upper() == "GUID":
@@ -170,7 +224,8 @@ def generate_entity_md(elements: List[Dict],
                       output_format: str, 
                       entity_type: str,
                       extract_properties_func: Callable, 
-                      get_additional_props_func: Optional[Callable] = None) -> str:
+                      get_additional_props_func: Optional[Callable] = None,
+                       columns_struct: [dict] = None) -> str:
     """
     Generic method to generate markdown for entities.
 
@@ -181,11 +236,13 @@ def generate_entity_md(elements: List[Dict],
         entity_type (str): Type of entity (Glossary, Term, Category, etc.)
         extract_properties_func: Function to extract properties from an element
         get_additional_props_func: Optional function to get additional properties
+        columns (list): List of column name structures
 
     Returns:
         str: Markdown representation
     """
     elements_md = ""
+    columns = columns_struct['formats'].get('columns') if columns_struct else None
 
     for element in elements:
         if element is None:
@@ -197,7 +254,7 @@ def generate_entity_md(elements: List[Dict],
         if get_additional_props_func:
             additional_props = get_additional_props_func(element,props['GUID'], output_format)
 
-        display_name = props.get('displayName', None)
+        display_name = props.get('display_name', None)
         if display_name is None:
             display_name = props.get('title', None)
             if display_name is None:
@@ -208,25 +265,45 @@ def generate_entity_md(elements: List[Dict],
             elements_md += f"# {elements_action}\n\n"
             elements_md += f"## {entity_type} Name \n\n{display_name}\n\n"
         elif output_format == 'REPORT':
-            elements_md += f'<a id="{props["GUID"]}"></a>\n\n# {entity_type} Name: {display_name}\n\n'
+            elements_md += f'<a id="{props.get("GUID","No GUID")}"></a>\n# {entity_type} Name: {display_name}\n\n'
         else:
             elements_md += f"## {entity_type} Name \n\n{display_name}\n\n"
 
-        # Add common attributes
-        for key, value in props.items():
-            if output_format in ['FORM', 'MD', 'DICT'] and key == 'mermaid':
-                continue
+       # Add attributes based on column spec if available, otherwise, add all
+        if columns:
+            for column in columns:
+                key = column['key']
+                name = column['name']
+                value = ""
+
+                # Check if the key is in props or additional_props
+                if key in props:
+                    value = props[key]
+                elif key in additional_props:
+                    value = additional_props[key]
+                # Format the value if needed
+                if 'format' in column and column['format']:
+                    value = format_for_markdown_table(value, props['GUID'])
+                # elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
+                elements_md += make_md_attribute(name, value, output_format)
 
-            if key not in [ 'properties', 'display_name']:
+        else:
+            for key, value in props.items():
+                if output_format in ['FORM', 'MD', 'DICT'] and key == 'mermaid':
+                    continue
+                if key not in [ 'properties', 'display_name']:
+                    if key == "mermaid" and value == '':
+                        continue
+                    elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
+            # Add additional properties
+            for key, value in additional_props.items():
                 elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
 
-        # Add additional properties
-        for key, value in additional_props.items():
-            elements_md += make_md_attribute(key.replace('_', ' '), value, output_format)
-
         # # Add GUID
         # elements_md += make_md_attribute("GUID",props['GUID'], output_format)
 
+        if wk := columns_struct.get("annotations", {}).get("wikilinks", None):
+            elements_md += ", ".join(wk)
         # Add separator if not the last element
         if element != elements[-1]:
             elements_md += MD_SEPARATOR
@@ -237,7 +314,7 @@ def generate_entity_md_table(elements: List[Dict],
                             search_string: str, 
                             entity_type: str, 
                             extract_properties_func: Callable,
-                            columns: List[Dict], 
+                            columns_struct: dict,
                             get_additional_props_func: Optional[Callable] = None, 
                             output_format: str = 'LIST') -> str:
     """
@@ -257,6 +334,7 @@ def generate_entity_md_table(elements: List[Dict],
     """
     # Handle pluralization - if entity_type ends with 'y', use 'ies' instead of 's'
     entity_type_plural = f"{entity_type[:-1]}ies" if entity_type.endswith('y') else f"{entity_type}s"
+    columns = columns_struct['formats'].get('columns', [])
 
     elements_md = ""
     if output_format == "LIST":
@@ -304,14 +382,16 @@ def generate_entity_md_table(elements: List[Dict],
             row += f"{value} | "
 
         elements_md += row + "\n"
-
+        if wk := columns_struct.get("annotations",{}).get("wikilinks", None):
+            elements_md += ", ".join(wk)
     return elements_md
 
 def generate_entity_dict(elements: List[Dict], 
                         extract_properties_func: Callable, 
                         get_additional_props_func: Optional[Callable] = None,
                         include_keys: Optional[List[str]] = None, 
-                        exclude_keys: Optional[List[str]] = None, 
+                        exclude_keys: Optional[List[str]] = None,
+                        columns_struct: dict = None,
                         output_format: str = 'DICT') -> List[Dict]:
     """
     Generic method to generate a dictionary representation of entities.
@@ -322,6 +402,7 @@ def generate_entity_dict(elements: List[Dict],
         get_additional_props_func: Optional function to get additional properties
         include_keys: Optional list of keys to include in the result (if None, include all)
         exclude_keys: Optional list of keys to exclude from the result (if None, exclude none)
+        columns_struct: Optional dict of columns to include (if None, include all)
         output_format (str): Output format (FORM, REPORT, DICT, etc.)
 
     Returns:
@@ -329,11 +410,12 @@ def generate_entity_dict(elements: List[Dict],
     """
     result = []
 
+#####
+    # Add attributes based on column spec if available, otherwise, add all
     for element in elements:
         if element is None:
             continue
         props = extract_properties_func(element)
-
         # Get additional properties if function is provided
         additional_props = {}
         if get_additional_props_func:
@@ -342,19 +424,64 @@ def generate_entity_dict(elements: List[Dict],
         # Create entity dictionary
         entity_dict = {}
 
-        # Add properties based on include/exclude lists
-        for key, value in props.items():
-            if key not in [ 'properties', 'mermaid']:  # Skip the raw properties object
-                if (include_keys is None or key in include_keys) and (
-                        exclude_keys is None or key not in exclude_keys):
-                    entity_dict[key] = value
+        columns = columns_struct['formats'].get('columns', None) if columns_struct else None
+        if columns:
+            for column in columns:
+                key = column['key']
+                name = column['name']
+                value = ""
+
+                # Check if the key is in props or additional_props
+                if key in props:
+                    value = props[key]
+                elif key in additional_props:
+                    value = additional_props[key]
+                # Format the value if needed
+                if  column.get('format', None):
+                    value = format_for_markdown_table(value, props['GUID'])
+                entity_dict[name] = value
 
-        # Add additional properties
-        for key, value in additional_props.items():
-            if (include_keys is None or key in include_keys) and (exclude_keys is None or key not in exclude_keys):
-                entity_dict[key] = value
+        else:
+            # Add properties based on include/exclude lists
+            for key, value in props.items():
+                if key not in ['properties', 'mermaid']:  # Skip the raw properties object
+                    if (include_keys is None or key in include_keys) and (
+                            exclude_keys is None or key not in exclude_keys):
+                        entity_dict[key] = value
+
+            # Add additional properties
+            for key, value in additional_props.items():
+                if (include_keys is None or key in include_keys) and (exclude_keys is None or key not in exclude_keys):
+                    entity_dict[key] = value
 
         result.append(entity_dict)
+    #####
+    # for element in elements:
+    #     if element is None:
+    #         continue
+    #     props = extract_properties_func(element)
+    #
+    #     # Get additional properties if function is provided
+    #     additional_props = {}
+    #     if get_additional_props_func:
+    #         additional_props = get_additional_props_func(element,props['GUID'], output_format)
+    #
+    #     # Create entity dictionary
+    #     entity_dict = {}
+    #
+    #     # Add properties based on include/exclude lists
+    #     for key, value in props.items():
+    #         if key not in [ 'properties', 'mermaid']:  # Skip the raw properties object
+    #             if (include_keys is None or key in include_keys) and (
+    #                     exclude_keys is None or key not in exclude_keys):
+    #                 entity_dict[key] = value
+    #
+    #     # Add additional properties
+    #     for key, value in additional_props.items():
+    #         if (include_keys is None or key in include_keys) and (exclude_keys is None or key not in exclude_keys):
+    #             entity_dict[key] = value
+    #
+    #     result.append(entity_dict)
 
     return result
 
@@ -430,7 +557,7 @@ def generate_output(elements: Union[Dict, List[Dict]],
                    output_format: str,
                    extract_properties_func: Callable,
                    get_additional_props_func: Optional[Callable] = None,
-                   columns: Optional[List[Dict]] = None) -> Union[str, List[Dict]]:
+                   columns_struct: dict = None) -> Union[str, list[dict]]:
     """
     Generate output in the specified format for the given elements.
 
@@ -446,6 +573,7 @@ def generate_output(elements: Union[Dict, List[Dict]],
     Returns:
         Formatted output as string or list of dictionaries
     """
+    columns = columns_struct['formats'].get('columns',None) if columns_struct else None
     # Ensure elements is a list
     if isinstance(elements, dict):
         elements = [elements]
@@ -466,7 +594,8 @@ def generate_output(elements: Union[Dict, List[Dict]],
             entity_type=entity_type,
             output_format="REPORT",
             extract_properties_func=extract_properties_func,
-            get_additional_props_func=get_additional_props_func
+            get_additional_props_func=get_additional_props_func,
+            columns_struct=columns_struct
         )
 
         # Convert the markdown to HTML
@@ -478,6 +607,7 @@ def generate_output(elements: Union[Dict, List[Dict]],
             extract_properties_func=extract_properties_func,
             get_additional_props_func=get_additional_props_func,
             exclude_keys=['properties'],
+            columns_struct=columns_struct,
             output_format=output_format
         )
 
@@ -490,7 +620,7 @@ def generate_output(elements: Union[Dict, List[Dict]],
             search_string=search_string,
             entity_type=entity_type,
             extract_properties_func=extract_properties_func,
-            columns=columns,
+            columns_struct=columns_struct,
             get_additional_props_func=get_additional_props_func,
             output_format=output_format
         )
@@ -508,7 +638,8 @@ def generate_output(elements: Union[Dict, List[Dict]],
             output_format=output_format,
             entity_type=entity_type,
             extract_properties_func=extract_properties_func,
-            get_additional_props_func=get_additional_props_func
+            get_additional_props_func=get_additional_props_func,
+            columns_struct = columns_struct
         )
 
         return elements_md

pyegeria/utils.py

@@ -8,72 +8,17 @@ General utility functions in support of the Egeria Python Client package.
 
 import json
 from datetime import datetime
-
+from loguru import logger
 from rich import print, print_json
 from rich.console import Console
+from pyegeria.load_config import get_app_config
 
-console = Console(width=200)
+app_settings = get_app_config()
 
-# def wrap_text(df: pd.DataFrame, wrap_len: int = 30) -> pd.DataFrame:
-#     """ Wrap the text in a dataframe
-#     Parameters
-#     ----------
-#     df : pandas.DataFrame
-#         The DataFrame to wrap the text in.
-#     wrap_len : int, optional
-#         The maximum length of each cell's contents to wrap. Defaults to 30.
-#
-#     Returns
-#     -------
-#     pandas.DataFrame
-#         A new DataFrame with the wrapped text.
-#
-#     """
-#
-#     # Helper function to wrap text in a particular cell
-#     def wrap_cell_contents(cell_contents: str, wrap: int = 30) -> str:
-#         """ Wrap the text in a cell
-#         Parameters
-#         ----------
-#         cell_contents : str or any
-#             The contents of a cell in a dataframe.
-#         wrap : int, optional
-#             The maximum width at which to wrap the cell contents. Default is 30.
-#
-#         Returns
-#         -------
-#         str or any
-#             If the cell_contents is a string and its length is greater than wrap_len,
-#             the contents are wrapped at wrap_len width using textwrap.
-#             Otherwise, the original cell_contents are returned as is.
-#         """
-#         if isinstance(cell_contents, str) and len(cell_contents) > wrap:
-#             return textwrap.fill(cell_contents, width=wrap)
-#         else:
-#             return cell_contents
-#
-#     # Apply the helper function to each element in the DataFrame
-#     return df.map(lambda x: wrap_cell_contents(x, wrap_len))
-#
-#
-# def print_nice_table(df, wrap_len: int = 20, tablefmt: str = "grid") -> None:
-#     """ Print a nice table from the data frame"""
-#     print(tabulate(wrap_text(df, wrap_len), headers="keys", tablefmt=tablefmt))
-#
-#
-# def get_json_as_table(input_json, wrap_len: int = 30, tablefmt: str = "grid") -> str:
-#     """ return the input json as a table"""
-#     data = json.loads(json.dumps(input_json))
-#     df = pd.json_normalize(data)
-#     return tabulate(wrap_text(df, wrap_len), headers="keys", tablefmt=tablefmt)
-#
-#
-# def print_json_list_as_table(input_json, wrap_len: int = 30, tablefmt: str = "grid") -> None:
-#     """ print a json list as a table"""
-#     data = json.loads(json.dumps(input_json))
-#     df = pd.json_normalize(data)
-#     print(tabulate(wrap_text(df, wrap_len), headers="keys", tablefmt=tablefmt))
+console = Console(width=200)
 
+def init_log():
+    pass
 
 def print_rest_request_body(body):
     """
@@ -213,5 +158,98 @@ def camel_to_title_case(input_string):
     return result
 
 
+def to_camel_case(input_string):
+    """Convert an input string to camelCase, singularizing if plural.
+    
+    This function takes an input string, converts it to singular form if it's plural,
+    and then transforms it to camelCase format (first word lowercase, subsequent words
+    capitalized with no spaces).
+    
+    Parameters
+    ----------
+    input_string : str
+        The string to convert to camelCase
+        
+    Returns
+    -------
+    str:
+        The input string converted to camelCase, after singularization if needed
+        
+    Examples
+    --------
+    >>> to_camel_case("data categories")
+    'dataCategory'
+    >>> to_camel_case("business terms")
+    'businessTerm'
+    >>> to_camel_case("glossary categories")
+    'glossaryCategory'
+    """
+    if not input_string:
+        return ""
+    
+    # Convert to lowercase for consistent processing
+    lowercase_input = input_string.lower()
+    
+    # First, convert to singular if plural
+    singular = lowercase_input
+    
+    # Handle common plural endings
+    if singular.endswith('ies'):
+        singular = singular[:-3] + 'y'
+    elif singular.endswith('es'):
+        # Special cases like 'classes' -> 'class'
+        if singular.endswith('sses') or singular.endswith('ches') or singular.endswith('shes') or singular.endswith('xes'):
+            singular = singular[:-2]
+        else:
+            singular = singular[:-1]
+    elif singular.endswith('s') and not singular.endswith('ss'):
+        singular = singular[:-1]
+    
+    # Split the string into words and convert to camelCase
+    words = singular.split()
+    if not words:
+        return ""
+    
+    # First word is lowercase, rest are capitalized
+    result = words[0]
+    for word in words[1:]:
+        result += word.capitalize()
+    
+    return result
+
+def to_pascal_case(input_string)->str:
+    """
+        Convert input string to PascalCase, singularizing if plural.
+    Args:
+        input_string ():
+
+    Returns:
+        transformed string
+    """
+    result = to_camel_case(input_string)
+    output_string = result[0].upper() + result[1:]
+    return output_string
+
+def flatten_dict_to_string(d: dict) -> str:
+    """Flatten a dictionary into a string and replace quotes with backticks."""
+    try:
+        flat_string = ", ".join(
+            # Change replace(\"'\", '`') to replace("'", '`')
+            f"{key}=`{str(value).replace('\"', '`').replace("'", '`')}`"
+            for key, value in d.items()
+        )
+        return flat_string
+    except Exception as e:
+        # Corrected syntax for exception chaining
+        raise Exception("Error flattening dictionary") from e
+# The decorator logic, which applies @logger.catch dynamically
+
+
+def dynamic_catch(func):
+    if app_settings.get("enable_logger_catchh", False):
+        return logger.catch(func)  # Apply the logger.catch decorator
+    else:
+        return func  # Return the function unwrapped
+
 if __name__ == "__main__":
     print("Main-Utils")

{pyegeria-5.4.0.dev14.dist-info → pyegeria-5.4.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.4.0.dev14
+Version: 5.4.0.2
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance
@@ -14,11 +14,14 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: click
 Requires-Dist: httpx
+Requires-Dist: inflect (>=7.5.0,<8.0.0)
 Requires-Dist: jupyter
 Requires-Dist: jupyter-notebook-parser (>=0.1.4,<0.2.0)
 Requires-Dist: loguru (>=0.7.3,<0.8.0)
 Requires-Dist: mermaid-py
+Requires-Dist: poetry-core (>=2.1.3,<3.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
+Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Requires-Dist: pytest (>=8.3.5,<9.0.0)
 Requires-Dist: requests
 Requires-Dist: rich