pyegeria 5.4.0.dev2__py3-none-any.whl → 5.4.0.dev5__py3-none-any.whl

md_processing/md_commands/glossary_commands.py

@@ -95,36 +95,6 @@ def update_term_categories(egeria_client: EgeriaTech, term_guid: str, categories
             print_msg("DEBUG-INFO", msg, debug_level)
 
 
-# def update_term_categories(egeria_client: EgeriaTech, term_guid: str, current_categories: List[str],
-# new_categories: List[str]) -> None:
-#     """
-#     Updates the categories of a term.
-#
-#     Args:
-#         egeria_client: The Egeria client to use for the update.
-#         term_guid: The GUID of the term to update.
-#         current_categories: The current categories of the term.
-#         new_categories: The new categories of the term.
-#     """
-#     if new_categories:  # If categories are specified, add them
-#         for cat in new_categories:
-#             if cat not in current_categories:
-#                 egeria_client.add_term_to_category(term_guid, cat)
-#                 msg = f"Added term {term_guid} to category {cat}"
-#                 print_msg("DEBUG-INFO", msg, debug_level)
-#         # Remove any categories that are not in the new list
-#         for cat in current_categories:
-#             if cat not in new_categories:
-#                 egeria_client.remove_term_from_category(term_guid, cat)
-#                 msg = f"Removed term {term_guid} from category {cat}"
-#                 print_msg("DEBUG-INFO", msg, debug_level)
-#     else:  # No categories specified - so remove any categories a term is in
-#         for cat in current_categories:
-#             egeria_client.remove_term_from_category(term_guid, cat)
-#             msg = f"Removed term {term_guid} from category {cat}"
-#             print_msg("DEBUG-INFO", msg, debug_level)
-
-
 def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """
     Processes a glossary create or update object_action by extracting key attributes such as

md_processing/md_commands/solution_architect_commands.py

@@ -917,7 +917,7 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
 @logger.catch
 def process_sol_arch_list_command(egeria_client: EgeriaTech, txt: str, kind:str, directive: str = "display" ) -> Optional[str]:
     """
-    Processes a Informartion Blueprint list object_action by extracting key attributes such as
+    Processes Solution Blueprint list object_action by extracting key attributes such as
      search string from the given text.
 
     :param txt: A string representing the input cell to be processed for

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -154,6 +154,9 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
                     logger.error(msg)
                     parsed_output['valid'] = False
                     parsed_output['reason'] += msg
+                elif parsed_attributes[key]['valid'] is False:
+                    parsed_output['valid'] = False
+                    parsed_output['reason'] += parsed_attributes[key]['reason']
 
             elif style == 'GUID':
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
@@ -244,7 +247,7 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
             logger.info(msg)
 
 
-    if parsed_output.get('qualified_name',None):
+    if parsed_output.get('qualified_name',None) and "* Qualified Name" not in parsed_output['display']:
         parsed_output['display'] += f"\n\t* Qualified Name: `{parsed_output['qualified_name']}`\n\t"
     if parsed_output.get('guid',None):
         parsed_output['display'] += f"\n\t* GUID: `{parsed_output['guid']}`\n\t"
@@ -341,8 +344,12 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
 
             elif style == 'Reference Name':
                 parsed_attributes[key] = proc_ids(egeria_client, key, labels, txt, object_action, if_missing)
-                if ((if_missing == ERROR) and parsed_attributes[key].get("value", None) and parsed_attributes[key][
-                    'exists'] is False):
+                if ((if_missing == ERROR) and parsed_attributes[key].get("value", None)):
+                    msg = f"Required parameter `{parsed_attributes[key]['value']}` is missing"
+                    logger.error(msg)
+                    parsed_output['valid'] = False
+                    parsed_output['reason'] += msg
+                elif parsed_attributes[key]['value'] and parsed_attributes['exists'] is False:
                     msg = f"Reference Name `{parsed_attributes[key]['value']}` is specified but does not exist"
                     logger.error(msg)
                     parsed_output['valid'] = False
@@ -366,7 +373,6 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             elif style == 'Bool':
                 parsed_attributes[key] = proc_bool_attribute(txt, object_action, labels, if_missing, default_value)
 
-
             elif style == 'Reference Name List':
                 parsed_attributes[key] = proc_name_list(egeria_client, key, txt, labels, if_missing)
                 if (parsed_attributes[key].get("value", None) and (
@@ -671,6 +677,7 @@ def proc_ids(egeria_client: EgeriaTech, element_type: str, element_labels: set,
     """
     Processes element identifiers from the input text using the labels supplied,
     checking if the element exists in Egeria, and validating the information.
+    Only a single element is allowed.
 
     Parameters
     ----------
@@ -704,7 +711,12 @@ def proc_ids(egeria_client: EgeriaTech, element_type: str, element_labels: set,
     value = None
 
     element_name = extract_attribute(txt, element_labels)
+
     if element_name:
+        if '\n' in element_name or ',' in element_name:
+            msg = f"Element name `{element_name}` appears to be a list rather than a single element"
+            logger.error(msg)
+            return {"status": ERROR, "reason": msg, "value": None, "valid": False, "exists": False, }
         q_name, guid, unique, exists = get_element_by_name(egeria_client, element_type, element_name)
         value = element_name
     else:

md_processing/md_processing_utils/md_processing_constants.py

@@ -60,7 +60,9 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "Update Term-Term Relationship", "Create Data Spec", "Create Data Specification", "Update Data Spec",
                 "Update Data Specification", "Create Data Field", "Update Data Field", "Create Data Structure",
                 "Update Data Structure", "Create Data Dictionary", "Update Data Dictionary", "Create Data Dict",
-                "Update Data Dict", " View Data Dictionary", "View Data Dictionaries", "Create Data Class", "Update Data Class",]
+                "Update Data Dict", " View Data Dictionary", "View Data Dictionaries", "View Data Specifications",
+                "View Data Specs", "View Data Structures", "View Data Structure", "View Data Fields", "View Data Field",
+                "View Dataa Classes", "View Data Class", "Create Data Class", "Update Data Class",]
 
 
 pre_command = "\n---\n==> Processing object_action:"

pyegeria/collection_manager_omvs.py

@@ -303,7 +303,7 @@ class CollectionManager(Client):
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_collection_output(elements, None, None, output_format, output_profile)
+            return self.generate_collection_output(elements, None, None, output_format)
         return elements
 
     def find_collections(self, search_string: str, as_of_time: str = None, effective_time: str = None,
@@ -1138,6 +1138,7 @@ class CollectionManager(Client):
             qualified_name = self.__create_qualified_name__("DataSpec", display_name)
 
         body = body_slimmer({
+            "class": "NewCollectionRequestBody",
             "anchorGUID": anchor_guid, "anchorScopeGUID": anchor_scope_guid, "isOwnAnchor": is_own_anchor,
             "parentGUID": parent_guid, "parentRelationshipTypeName": parent_relationship_type_name,
             "parentAtEnd1": parent_at_end1, "collectionProperties": {
@@ -1276,6 +1277,7 @@ class CollectionManager(Client):
             qualified_name = self.__create_qualified_name__("DataDict", display_name)
 
         body = {
+            "class": "NewCollectionRequestBody",
             "anchorGUID": anchor_guid, "isOwnAnchor": is_own_anchor_s, "anchorScopeGUID": anchor_scope_guid,
             "parentGUID": parent_guid, "parentRelationshipTypeName": parent_relationship_type_name,
             "parentAtEnd1": parent_at_end1_s, "collectionProperties": {
@@ -2665,18 +2667,28 @@ class CollectionManager(Client):
         display_name = properties.get("name", "") or ""
         description = properties.get("description", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
-        collection_type = properties.get("collectionType", "") or ""
+        # collection_type = properties.get("collectionType", "") or ""
         additional_properties = properties.get("additionalProperties", {}) or {}
         extended_properties = properties.get("extendedProperties", {}) or {}
-        classifications = ",  ".join(properties.get("classifications", [])) or ""
-        # classification_names = ""
-        # classifications = element['elementHeader'].get("classifications", [])
-        # for classification in classifications:
-        #     classification_names += f"{classification['classificationName']}, "
+        # classifications = ",  ".join(properties.get("classifications", [])) or ""
+
+        classification_names = ""
+        classifications = element['elementHeader'].get("classifications", [])
+        for classification in classifications:
+            classification_names += f"{classification['classificationName']}, "
+        classification_names = classification_names[:-2]
+
+        member_names = ""
+        members = self.get_member_list(collection_guid=guid)
+        if isinstance(members, list):
+            for member in members:
+                member_names += f"{member['qualifiedName']}, "
+            member_names = member_names[:-2]
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
-            'qualified_name': qualified_name, 'classifications': classifications, 'collection_type': collection_type,
+             'GUID': guid,'display_name': display_name,'qualified_name': qualified_name, 'description': description,
+             'classifications': classification_names, 'members': member_names, 'properties': properties,
+            # 'collection_type': collection_type,
             'additional_properties': additional_properties, 'extended_properties': extended_properties,
             }
 
@@ -2719,80 +2731,116 @@ class CollectionManager(Client):
         # Default case
         return None
 
-    def generate_collection_output(self, elements, filter, collection_type: str, output_format,
-                                   output_profile: str = "CORE") -> str | list | dict:
+
+    def generate_collection_output(self, elements, filter, collection_type,  output_format) -> str | list:
         """
-        Generate output in the specified format for the given elements.
+        Generate output for collections in the specified format.
 
         Args:
-            elements: Dictionary or list of dictionaries containing element data
+            elements: Dictionary or list of dictionaries containing data field elements
+            collection_type: str
+                The type of collection.
             filter: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, JSON)
-            output_profile: str, optional, default = "CORE"
-                The desired output profile - BASIC, CORE, FULL
+            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID)
+
         Returns:
-            Formatted output as string or list of dictionaries
+            Formatted output as a string or list of dictionaries
         """
         if collection_type is None:
             entity_type = "Collection"
         else:
             entity_type = collection_type
 
-        # For LIST and DICT formats, get member information
-
-        if output_format in ["LIST", "DICT"]:
-            # Get the collection GUID
-            collection_guid = None
-            if isinstance(elements, dict):
-                collection_guid = elements.get('elementHeader', {}).get('guid')
-            elif isinstance(elements, list) and len(elements) > 0:
-                collection_guid = elements[0].get('elementHeader', {}).get('guid')
-
-            # Get member list if we have a valid collection GUID
-            members = []
-            if collection_guid:
-                members = self.get_member_list(collection_guid=collection_guid)
-                if isinstance(members, str):  # "No members found" case
-                    members = []
-
-            # For DICT format, include all member information in the result
-            if output_format == "DICT":
-                result = self.generate_basic_structured_output(elements, filter, output_format, collection_type)
-                if isinstance(result, list):
-                    for item in result:
-                        item['members'] = members
-                    return result
-                elif isinstance(result, dict):
-                    result['members'] = members
-                    return result
-
-            # For LIST format, add a column with bulleted list of qualified names
-            elif output_format == "LIST":
-                # Define columns for LIST format, including the new Members column
-                columns = [{'name': 'Collection Name', 'key': 'display_name'},
-                    {'name': 'Qualified Name', 'key': 'qualified_name'},
-                    {'name': 'Collection Type', 'key': 'collection_type'},
-                    {'name': 'Description', 'key': 'description', 'format': True},
-                    {'name': 'Classifications', 'key': 'classifications'},
-                    {'name': 'Members', 'key': 'members', 'format': True}]
-
-                # Create a function to add member information to the properties
-                def get_additional_props(element, guid, output_format):
-                    if not members:
-                        return {'members': ''}
-
-                    # Create a comma-separated list of qualified names (no newlines to avoid table formatting issues)
-                    member_list = ", ".join([member.get('qualifiedName', '') for member in members])
-                    return {'members': member_list}
-
-                # Generate output with the additional properties
-
-                return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
-                    output_format=output_format, extract_properties_func=self._extract_collection_properties,
-                    get_additional_props_func=get_additional_props, columns=columns)
-
-        # For FORM, REPORT, JSON formats, keep behavior unchanged
-        return self.generate_basic_structured_output(elements, filter, output_format, collection_type)
+        if output_format in ["MD", "FORM", "REPORT", "LIST", "DICT", "MERMAID"]:
+            # Define columns for LIST format
+            columns = [{'name': '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},
+                ]
+
+            return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
+                output_format=output_format, extract_properties_func=self._extract_collection_properties,
+                columns=columns if output_format == 'LIST' else None)
+        else:
+            return self.generate_basic_structured_output(elements, filter, output_format)
+
+
+    # def generate_collection_output(self, elements, filter, collection_type: str, output_format,
+    #                                output_profile: str = "CORE") -> str | list | dict:
+    #     """
+    #     Generate output in the specified format for the given elements.
+    #
+    #     Args:
+    #         elements: Dictionary or list of dictionaries containing element data
+    #         filter: The search string used to find the elements
+    #         output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, JSON)
+    #         output_profile: str, optional, default = "CORE"
+    #             The desired output profile - BASIC, CORE, FULL
+    #     Returns:
+    #         Formatted output as string or list of dictionaries
+    #     """
+    #     if collection_type is None:
+    #         entity_type = "Collection"
+    #     else:
+    #         entity_type = collection_type
+    #
+    #     # For LIST and DICT formats, get member information
+    #
+    #     if output_format in ["LIST", "DICT"]:
+    #         # Get the collection GUID
+    #         collection_guid = None
+    #         if isinstance(elements, dict):
+    #             collection_guid = elements.get('elementHeader', {}).get('guid')
+    #         elif isinstance(elements, list) and len(elements) > 0:
+    #             collection_guid = elements[0].get('elementHeader', {}).get('guid')
+    #
+    #         # Get member list if we have a valid collection GUID
+    #         members = []
+    #         if collection_guid:
+    #             members = self.get_member_list(collection_guid=collection_guid)
+    #             if isinstance(members, str):  # "No members found" case
+    #                 members = []
+    #
+    #         # For DICT format, include all member information in the result
+    #         if output_format == "DICT":
+    #             result = self.generate_basic_structured_output(elements, filter, output_format, collection_type)
+    #             if isinstance(result, list):
+    #                 for item in result:
+    #                     item['members'] = members
+    #                 return result
+    #             elif isinstance(result, dict):
+    #                 result['members'] = members
+    #                 return result
+    #
+    #         # For LIST format, add a column with bulleted list of qualified names
+    #         elif output_format == "LIST":
+    #             # Define columns for LIST format, including the new Members column
+    #             columns = [{'name': 'Collection Name', 'key': 'display_name'},
+    #                 {'name': 'Qualified Name', 'key': 'qualified_name'},
+    #                 {'name': 'Collection Type', 'key': 'collection_type'},
+    #                 {'name': 'Description', 'key': 'description', 'format': True},
+    #                 {'name': 'Classifications', 'key': 'classifications'},
+    #                 {'name': 'Members', 'key': 'members', 'format': True}]
+    #
+    #             # Create a function to add member information to the properties
+    #             def get_additional_props(element, guid, output_format):
+    #                 if not members:
+    #                     return {'members': ''}
+    #
+    #                 # Create a comma-separated list of qualified names (no newlines to avoid table formatting issues)
+    #                 member_list = ", ".join([member.get('qualifiedName', '') for member in members])
+    #                 return {'members': member_list}
+    #
+    #             # Generate output with the additional properties
+    #
+    #             return generate_output(elements=elements, search_string=filter, entity_type=entity_type,
+    #                 output_format=output_format, extract_properties_func=self._extract_collection_properties,
+    #                 get_additional_props_func=get_additional_props, columns=columns)
+    #
+    #     # For FORM, REPORT, JSON formats, keep behavior unchanged
+    #     return self.generate_basic_structured_output(elements, filter, output_format, collection_type)
 
     # def generate_data_class_output(self, elements, filter, output_format) -> str | list:  #     return
     # self.generate_basic_structured_output(elements, filter, output_format)  #  # def generate_data_field_output(