pyegeria 5.4.0.26__py3-none-any.whl → 5.4.0.27__py3-none-any.whl

pyegeria/_output_formats.py

@@ -72,12 +72,12 @@ from loguru import logger
 
 from pyegeria._output_format_models import (Column, Format, ActionParameter, FormatSet, FormatSetDict,
                                             save_format_sets_to_json, load_format_sets_from_json)
-from pyegeria.load_config import get_app_config
+from pyegeria.load_config import settings
 
 
 # Get the configured value for the user format sets directory
-app_config = get_app_config()
-USER_FORMAT_SETS_DIR = os.path.expanduser(app_config.Environment.pyegeria_user_format_sets_dir)
+
+USER_FORMAT_SETS_DIR = os.path.expanduser(settings.Environment.pyegeria_user_format_sets_dir)
 
 # Constants
 MD_SEPARATOR = "\n---\n\n"
@@ -122,8 +122,10 @@ COMMON_FORMATS_ALL = Format(
 )
 
 PROJECT_COLUMNS = COMMON_COLUMNS + [
+    Column(name="Classifications", key='classifications'),
     Column(name='Priority', key='priority'),
     Column(name='Project Status', key='project_status'),
+    Column(name='Element Status', key='status'),
     Column(name='Start Date', key='start_date'),
     Column(name='Assigned Actors', key='assigned_actors'),
     Column(name='Resources', key='resource_list'),

pyegeria/collection_manager.py

@@ -17,7 +17,7 @@ from pydantic import ValidationError, Field, HttpUrl
 from pyegeria._exceptions_new import PyegeriaInvalidParameterException
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
 from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
-from pyegeria.load_config import get_app_config
+from pyegeria.config import settings
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
                              ReferenceableProperties, InitialClassifications, TemplateRequestBody,
                              UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
@@ -1118,7 +1118,7 @@ class CollectionManager(Client2):
             if initial_classifications:
                 initial_classifications_dict = {}
                 for c in initial_classifications:
-                    initial_classifications_dict = initial_classifications_dict | {c : {"class": "ClassificationProperties"}}
+                    initial_classifications_dict = initial_classifications_dict | {c : {"class": f"{c}Properties"}}
 
             else:
                 initial_classifications_dict = None
@@ -1260,7 +1260,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     def create_root_collection(self, display_name: str = None, description: str = None,
-                                      category: str = None, body: dict | NewElementRequestBody = None) -> str:
+                                      category: str = None,  body: dict | NewElementRequestBody = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1293,8 +1293,8 @@ class CollectionManager(Client2):
         """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_create_collection(display_name, description, category,
-                                          ["RootCollection"], body))
+            self._async_create_collection(display_name=display_name, description=description, category=category,
+                                         initial_classifications = ["RootCollection"], body=body))
 
 
     @dynamic_catch
@@ -1414,25 +1414,28 @@ class CollectionManager(Client2):
             self._async_create_collection(display_name, description, category,
                                           ["ContextEvent"], body))
 
-    @dynamic_catch
-    def create_glossary_category(self, display_name: str, parent_guid: str, description: str = None ) -> str:
-        """Create a new glossary category."""
-        body = {
-            "class": "NewRelationshipRequestBody",
-            "parentGUID": parent_guid,
-            "parentRelationshipTypeName": "CategoryHierarchy",
-            "parentAtEnd1": True,
-            "is_own_anchor": False,
-            "anchor_guid": parent_guid,
-            "properties": {
-                "class": "GlossaryCategoryProperties",
-                "displayName": display_name,
-                "description": description,
-                "parentCategory": parent_guid,
-                },
-            }
-        response = self.create_collection(body=body)
-        return response
+    # @dynamic_catch
+    # def create_glossary(self, display_name: str, description: str = None, language: str = "English", usage: str = None,
+    #                     category: str = None, body: dict | NewElementRequestBody = None) -> str:
+    #     """Create a new glossary with optional classification. """
+    #     if body is None:
+    #
+    #         qualified_name = self.__create_qualified_name__("Glossary", display_name, EGERIA_LOCAL_QUALIFIER)
+    #         body = {
+    #             "class": "NewElementRequestBody",
+    #             "is_own_anchor": True,
+    #             "properties": {
+    #                 "class": "GlossaryProperties",
+    #                 "displayName": display_name,
+    #                 "qualifiedName": qualified_name,
+    #                 "description": description,
+    #                 "language": language,
+    #                 "usage": usage,
+    #                 "category": category
+    #                 },
+    #             }
+    #     response = self.create_collection(body=body)
+    #     return response
 
     @dynamic_catch
     async def _async_create_data_spec_collection(self, display_name: str = None, description: str = None,
@@ -5091,11 +5094,11 @@ class CollectionManager(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_add_to_collection(collection_guid, element_guid, body))
 
-    def add_term_to_category(self, category_guid: str, term_guid: str,
+    def add_term_to_folder(self, folder_guid: str, term_guid: str,
                              body: dict | NewRelationshipRequestBody = None) -> None:
         """Add a term to a category.  The request body is optional."""
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_add_to_collection(category_guid, term_guid, body))
+        loop.run_until_complete(self._async_add_to_collection(folder_guid, term_guid, body))
 
 
     @dynamic_catch
@@ -5322,7 +5325,7 @@ class CollectionManager(Client2):
         #
 
 
-    def remove_term_from_category(self, category_guid: str, term_guid: str,
+    def remove_term_from_category(self, folder_guid: str, term_guid: str,
                                body: dict | DeleteRequestBody= None) -> None:
         """Remove a term from a category.
 
@@ -5354,7 +5357,7 @@ class CollectionManager(Client2):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_remove_from_collection(category_guid, term_guid, body))
+        loop.run_until_complete(self._async_remove_from_collection(folder_guid, term_guid, body))
 
         #
         #

pyegeria/{load_config.py → config.py}

@@ -444,7 +444,7 @@ def load_app_config(env_file: str = None):
     return _app_config
 
 
-def get_app_config(env_file: str = None):
+def get_app_config(env_file: str = None)-> AppConfig:
     """
     Provides access to the loaded application configuration.
     Ensures config is loaded if not already (useful for testing or simple scripts).
@@ -465,6 +465,8 @@ def get_app_config(env_file: str = None):
     return _app_config
 
 
+
+
 def _parse_bool_env(env_var: str, default: bool) -> bool:
     """
     Parse a boolean environment variable.
@@ -515,4 +517,7 @@ def _parse_list_env(env_var: str, default: List[str]) -> List[str]:
         value = os.getenv(env_var)
         if value:
             return [item.strip() for item in value.split(',')]
-    return default
+    return default
+
+
+settings = get_app_config()

pyegeria/data_designer.py

@@ -21,7 +21,6 @@ from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequ
 from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict)
 from pyegeria.output_formatter import (generate_output,
                                        _extract_referenceable_properties)
-from pyegeria.output_formatter import (populate_columns_from_properties, get_required_relationships)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 
@@ -4683,136 +4682,118 @@ class DataDesigner(Client2):
 
 
 
-    def _extract_data_structure_properties(self, element: dict, columns_struct: dict) -> dict:
+    def _extract_data_structure_properties(self, element: dict) -> dict:
         """
-        Populate columns_struct values for a Data Structure element using a standardized approach.
+        Extract common properties from a data structure element.
 
-        - Populate values from element.properties via populate_columns_from_properties
-        - Overlay header-derived values using _extract_referenceable_properties
-        - Derive classifications as a comma-separated list
-        - Populate relationship-based columns using get_required_relationships
-        - Populate mermaid graph if requested
+        Args:
+            element (dict): The data structure element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+
+        props['properties'] = element.get('properties', {})
+
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_specs'] = associated_elements.get("member_of_data_spec_qnames", [])
+
+        # data_structures = associated_elements.get("member_of_data_struct_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['member_data_fields'] = associated_elements.get("member_data_field_qnames", [])
 
-        Returns the updated columns_struct.
-        """
-        # Start with properties-based values
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        # Header-derived values
-        header_props = _extract_referenceable_properties(element)
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = header_props.get('GUID')
-
-        # Classifications (names only)
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationship-derived values (generic)
-        col_data = get_required_relationships(element, col_data)
-
-        # Mermaid graph
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
-
-    def _extract_data_class_properties(self, element: dict, columns_struct: dict) -> dict:
-        """
-        Populate columns_struct values for a Data Class element using the standardized approach.
-
-        Uses properties population, header overlay, classifications, generic relationships,
-        and mermaid graph assignment similar to collection_manager.
-        """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        header_props = _extract_referenceable_properties(element)
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = header_props.get('GUID')
-
-        # Classifications from header
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationships and mermaid
-        col_data = get_required_relationships(element, col_data)
-
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
-
-    def _extract_data_field_properties(self, element: dict, columns_struct: dict) -> dict:
-        """
-        Populate columns_struct values for a Data Field element using the standardized approach.
-
-        Populates from properties, overlays header values, derives classifications, uses
-        get_required_relationships for relationships, and adds mermaid graph.
-        """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        header_props = _extract_referenceable_properties(element)
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = header_props.get('GUID')
-
-        # Classifications from header
-        cl_names = []
-        for c in element.get('elementHeader', {}).get('classifications', []) or []:
-            nm = c.get('classificationName')
-            if nm:
-                cl_names.append(nm)
-        if cl_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = ", ".join(cl_names)
-                    break
-
-        # Relationships and mermaid
-        col_data = get_required_relationships(element, col_data)
-
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
-
-        return col_data
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
+
+    def _extract_data_class_properties(self, element: dict) -> dict:
+        """
+        Extract common properties from a data class element.
+
+        Args:
+            element (dict): The data class element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+        properties = element.get('properties', {})
+        props['properties'] = properties
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+
+        props['data_type'] = properties.get('dataType', "") or ""
+        props['match_property_names'] = properties.get('matchPropertyNames', []) or []
+        props['match_threshold'] = properties.get('matchThreshold', 0)
+        props['allow_duplicate_values'] = properties.get('allowDuplicateValues', False)
+        props['is_case_sensitive'] = properties.get('isCaseSensitive', False)
+        props['is_nullable'] = properties.get('isNullable', False)
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_dictionaries'] = associated_elements.get("member_of_data_dicts_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['nested_data_classes'] = associated_elements.get("nested_data_class_qnames", [])
+        props['specialized_data_classes'] = associated_elements.get("specialized_data_class_qnames", [])
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
+
+    def _extract_data_field_properties(self, element: dict) -> dict:
+        """
+        Extract common properties from a data field element.
+
+        Args:
+            element (dict): The data field element
+
+        Returns:
+            dict: Dictionary of extracted properties
+        """
+        props = _extract_referenceable_properties(element)
+
+        props['properties'] = element.get('properties', {})
+        props['namespace'] = props['properties'].get("namespace", "") or ""
+        properties = element.get('properties', {})
+
+        classification_names = []
+        for c in props['classifications']:
+            classification_names.append(c.get("classificationName", None))
+        props['classifications'] = classification_names
+
+        props['is_nullable'] = properties.get('isNullable', False)
+        props['data_type'] = properties.get('dataType', "") or ""
+        props['minimum_length'] = properties.get('minimumLength', 0)
+        props['length'] = properties.get('length', 0)
+        props['precision'] = properties.get('precision', 0)
+        props['ordered_values'] = properties.get('orderedValues', False)
+        props['sort_order'] = properties.get('sortOrder', "") or ""
+
+        # Now lets get the related elements
+        associated_elements = self.get_data_rel_elements_dict(element)
+        props['data_dictionaries'] = associated_elements.get("member_of_data_dicts_qnames", [])
+        props['data_structures'] = associated_elements.get("data_structure_qnames", [])
+        props['assigned_meanings'] = associated_elements.get("assigned_meanings_qnames", [])
+        props['parent_names'] = associated_elements.get("parent_qnames", [])
+        props['data_class'] = associated_elements.get("data_class_qnames", [])
+        props['mermaid'] = element.get('mermaidGraph', "") or ""
+
+        return props
 
     def _generate_basic_structured_output(self, elements: dict, filter: str, output_format: str,
                                           columns_struct: dict = None) -> str | list:
@@ -4857,7 +4838,6 @@ class DataDesigner(Client2):
                                    )
 
     def _generate_data_structure_output(self, elements: dict | list[dict], filter: str = None,
-                                        element_type_name: str | None = None,
                                         output_format: str = "DICT",
                                         output_format_set: str | dict = None) -> str | list:
         """
@@ -4866,43 +4846,33 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data structure elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
 
         Returns:
             Formatted output as string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Structure"
+        entity_type = "Data Structure"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
 
-        # 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(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        # If no output_format was set, then use the element_type_name to lookup the output format
-        elif element_type_name:
-            output_formats = select_output_format_set(element_type_name, output_format)
         else:
-            # fallback to entity type
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_structure_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_structure_properties,
-            None,
-            output_formats,
-        )
-
-    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None,
-                                    element_type_name: str | None = None,
-                                    output_format: str = "DICT",
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_structure_properties,
+                               None,
+                               output_formats,
+                               )
+
+    def _generate_data_class_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data classes in the specified format.
@@ -4910,40 +4880,34 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data class elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
             output_format_set: Optional output format set
                 - Option column/attribute selection and definition.
         Returns:
             Formatted output as either a string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Class"
+        entity_type = "Data Class"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
+
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        elif element_type_name:
-            output_formats = select_output_format_set(element_type_name, output_format)
         else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_class_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_class_properties,
-            None,
-            output_formats,
-        )
-
-    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None,
-                                    element_type_name: str | None = None,
-                                    output_format: str = "DICT",
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_class_properties,
+                               None,
+                               output_formats,
+                               )
+
+    def _generate_data_field_output(self, elements: dict | list[dict], filter: str = None, output_format: str = "DICT",
                                     output_format_set: str | dict = None) -> str | list:
         """
         Generate output for data fields in the specified format.
@@ -4951,7 +4915,6 @@ class DataDesigner(Client2):
         Args:
             elements: Dictionary or list of dictionaries containing data field elements
             filter: The search string used to find the elements
-            element_type_name: Optional specific subtype name to drive output format selection
             output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
             output_format_set: str|dict, Optional, default = None
             - Option column/attribute selection and definition.
@@ -4959,29 +4922,26 @@ class DataDesigner(Client2):
         Returns:
             Formatted output as a string or list of dictionaries
         """
-        entity_type = element_type_name or "Data Field"
+        entity_type = "Data Field"
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
+
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
+            if isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        elif element_type_name:
-            output_formats = select_output_format_set(element_type_name, output_format)
         else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
-
+            output_formats = None
         logger.trace(f"Executing _generate_data_field_output for {entity_type}: {output_formats}")
-        return generate_output(
-            elements,
-            filter,
-            entity_type,
-            output_format,
-            self._extract_data_field_properties,
-            None,
-            output_formats,
-        )
+        return generate_output(elements,
+                               filter,
+                               entity_type,
+                               output_format,
+                               self._extract_data_field_properties,
+                               None,
+                               output_formats,
+                               )
 
 
 if __name__ == "__main__":