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

md_processing/md_commands/product_manager_commands.py

@@ -21,7 +21,7 @@ from md_processing.md_processing_utils.md_processing_constants import (load_comm
 from pyegeria import DEBUG_LEVEL, body_slimmer, to_pascal_case, PyegeriaException, print_basic_exception, print_exception_table
 from pyegeria.egeria_tech_client import EgeriaTech
 
-GERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+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")
@@ -142,270 +142,6 @@ def update_data_collection_memberships(egeria_client: EgeriaTech, entity_type: s
         add_member_to_collections(egeria_client, guid_list, display_name, guid)
 
 
-# @logger.catch
-
-
-# @logger.catch
-# def add_field_to_data_structures(egeria_client: EgeriaTech, display_name: str, struct_list: list, guid) -> None:
-#     """
-#         Add data field to data structures.
-#         """
-#
-#     try:
-#         for structure_guid in struct_list:
-#             egeria_client.link_member_data_field(structure_guid, guid, None)
-#             msg = f"Added `{display_name}` to structure `{structure_guid}`"
-#             logger.info(msg)
-#         return
-#
-#     except Exception as e:
-#         console.print_exception()
-#
-#
-# @logger.catch
-# def remove_field_from_data_structures(egeria_client: EgeriaTech, display_name: str, struct_list: list,
-#                                       guid: str) -> None:
-#     """Remove a data field from a list of data structures."""
-#     try:
-#         for structure_guid in struct_list:
-#             egeria_client.detach_member_data_field(structure_guid, guid, None)
-#             msg = f"Removed `{display_name}` from structure `{structure_guid}`"
-#             logger.info(msg)
-#         return
-#
-#     except Exception as e:
-#         console.print_exception()
-#
-
-# @logger.catch
-# def sync_data_field_rel_elements(egeria_client: EgeriaTech, structure_list: list, parent_field_list: list, terms: list,
-#                                  data_class_guid: str, guid: str, display_name: str,
-#                                  replace_all_props: bool = True) -> None:
-#     """Sync a field's related elements.
-#
-#     TODO: Need to add data class support when ready and may need to revisit bodies.
-#
-#     """
-#     if terms:
-#         terms = [terms]
-#
-#     if replace_all_props:
-#         rel_el_list = egeria_client.get_data_field_rel_elements(guid)
-#         # should I throw an exception if empty?
-#         if rel_el_list is None:
-#             logger.warning("Unexpected -> the list was None - assigning empty list")
-#             rel_el_list = {}
-#
-#         as_is_data_structs = set(rel_el_list.get("data_structure_guids", []))
-#         as_is_parent_fields = set(rel_el_list.get("parent_guids", []))
-#         as_is_assigned_meanings = set(rel_el_list.get("assigned_meanings_guids", []))
-#         as_is_data_classes = set(rel_el_list.get("data_class_guids", []))
-#
-#         to_be_data_structs = set(structure_list) if structure_list is not None else set()
-#         to_be_parent_fields = set(parent_field_list) if parent_field_list is not None else set()
-#         to_be_assigned_meanings = set(terms) if terms is not None else set()
-#         to_be_data_classes = set([data_class_guid]) if data_class_guid is not None else set()
-#
-#         logger.trace(f"as_is_data_structs: {list(as_is_data_structs)} to_be_data_struct: {list(to_be_data_structs)}")
-#         logger.trace(
-#             f"as_is_parent_fields: {list(as_is_parent_fields)} to_be_parent_fields: {list(to_be_parent_fields)}")
-#         logger.trace(f"as_is_assigned_meanings: {list(as_is_assigned_meanings)} to_be_assigned_meanings: "
-#                      f"{list(to_be_assigned_meanings)}")
-#         logger.trace(f"as_is_data_classes: {list(as_is_data_classes)} to_be_assigned_data_classes: "
-#                      f"{list(to_be_data_classes)}")
-#
-#         data_struct_to_remove = as_is_data_structs - to_be_data_structs
-#         logger.trace(f"data_struct_to_remove: {list(data_struct_to_remove)}")
-#         if len(data_struct_to_remove) > 0:
-#             for ds in data_struct_to_remove:
-#                 egeria_client.detach_member_data_field(ds, guid, None)
-#                 msg = f"Removed `{display_name}` from structure `{ds}`"
-#                 logger.trace(msg)
-#         data_struct_to_add = to_be_data_structs - as_is_data_structs
-#         logger.trace(f"data_struct_to_add: {list(data_struct_to_add)}")
-#         if len(data_struct_to_add) > 0:
-#             for ds in data_struct_to_add:
-#                 egeria_client.link_member_data_field(ds, guid, None)
-#                 msg = f"Added `{display_name}` to structure `{ds}`"
-#                 logger.trace(msg)
-#
-#         parent_field_to_remove = to_be_parent_fields - as_is_parent_fields
-#         logger.trace(f"parent_field_to_remove: {list(parent_field_to_remove)}")
-#         if len(parent_field_to_remove) > 0:
-#             for field in parent_field_to_remove:
-#                 egeria_client.detach_nested_data_field(field, guid, None)
-#                 msg = f"Removed `{display_name}` from field `{field}`"
-#                 logger.trace(msg)
-#         parent_field_to_add = to_be_parent_fields - as_is_parent_fields
-#         logger.trace(f"parent_field_to_add: {list(parent_field_to_add)}")
-#         if len(parent_field_to_add) > 0:
-#             for field in parent_field_to_add:
-#                 egeria_client.link_nested_data_field(field, guid, None)
-#                 msg = f"Added `{display_name}` to field `{field}`"
-#                 logger.trace(msg)
-#
-#         terms_to_remove = as_is_assigned_meanings - to_be_assigned_meanings
-#         logger.trace(f"terms_to_remove: {list(terms_to_remove)}")
-#         if terms:
-#             for term in terms_to_remove:
-#                 egeria_client.detach_semantic_definition(guid, term, None)
-#                 msg = f"Removed `{term}` from `{display_name}`"
-#                 logger.trace(msg)
-#         terms_to_add = to_be_assigned_meanings - as_is_assigned_meanings
-#         logger.trace(f"terms_to_add: {list(terms_to_add)}")
-#         if len(terms_to_add) > 0:
-#             for term in terms_to_add:
-#                 egeria_client.link_semantic_definition(guid, term, None)
-#                 msg = f"Added `{term}` to`{display_name}`"
-#                 logger.trace(msg)
-#
-#         classes_to_remove = as_is_data_classes - to_be_data_classes
-#         logger.trace(f"classes_to_remove: {list(classes_to_remove)}")
-#         if len(terms_to_remove) > 0:
-#             for dc in classes_to_remove:
-#                 body = {
-#                     "class": "MetadataSourceRequestBody", "forLineage": False, "forDuplicateProcessing": False
-#                     }
-#                 egeria_client.detach_data_class_definition(guid, dc, body)
-#                 msg = f"Removed `{dc}` from `{display_name}`"
-#                 logger.trace(msg)
-#         classes_to_add = to_be_data_classes - as_is_data_classes
-#         logger.trace(f"classes_to_add: {list(classes_to_add)}")
-#         if len(terms_to_add) > 0:
-#             for dc in classes_to_add:
-#                 body = {
-#                     "class": "RelationshipRequestBody", "forLineage": False, "forDuplicateProcessing": False
-#                     }
-#                 egeria_client.link_data_class_definition(guid, dc, body)
-#                 msg = f"Added `{dc}` to`{display_name}`"
-#                 logger.trace(msg)
-#
-#
-#     else:  # merge - add field to related elements
-#         if structure_list:
-#             add_field_to_data_structures(egeria_client, display_name, structure_list, guid)
-#             msg = f"Added `{display_name}` to `{structure_list}`"
-#             logger.trace(msg)
-#
-#         if parent_field_list:
-#             for field in parent_field_list:
-#                 egeria_client.link_nested_data_field(field, guid, None)
-#                 msg = f"Added `{display_name}` to `{field}`"
-#                 logger.trace(msg)
-#         if terms:
-#             for term in terms:
-#                 egeria_client.link_semantic_definition(guid, term, None)
-#                 msg = f"Added `{term}` to `{display_name}`"
-#                 logger.trace(msg)
-#
-#         if data_class_guid:
-#             egeria_client.link_data_class_definition(guid, data_class_guid)
-#             msg = f"Added `{data_class_guid}` to `{display_name}`"
-#             logger.trace(msg)
-
-#
-# @logger.catch
-# def sync_data_class_rel_elements(egeria_client: EgeriaTech, containing_data_class_guids: list, terms: list,
-#                                  specializes_data_classes: list, guid: str, display_name: str,
-#                                  replace_all_props: bool = True) -> None:
-#     """Sync a data class' related elements.
-#
-#     """
-#     if terms:
-#         terms = [terms]
-#
-#     if replace_all_props:
-#         rel_el_list = egeria_client.get_data_class_rel_elements(guid)
-#         if rel_el_list is None:
-#             logger.warning("Unexpected -> the list was None - assigning empty list")
-#             rel_el_list = {}
-#         if terms:
-#             terms = [terms]
-#
-#         as_is_nested_classes = set(rel_el_list.get("nested_data_class_guids", []))
-#         as_is_assigned_meanings = set(rel_el_list.get("assigned_meanings_guids", []))
-#         as_is_specialized_classes = set(rel_el_list.get("specialized_data_class_guids", []))
-#
-#         to_be_nested_classes = set(containing_data_class_guids) if containing_data_class_guids is not None else set()
-#         to_be_assigned_meanings = set(terms) if terms is not None else set()
-#         to_be_specialized_classes = set([specializes_data_classes]) if specializes_data_classes is not None else set()
-#
-#         logger.trace(
-#             f"as_is_nested_classes: {list(as_is_nested_classes)} to_be_nested_classes: {list(to_be_nested_classes)}")
-#         logger.trace(f"as_is_assigned_meanings: {list(as_is_assigned_meanings)} to_be_assigned_meanings: "
-#                      f"{list(to_be_assigned_meanings)}")
-#         logger.trace(f"as_is_specialized_classes: {list(as_is_specialized_classes)} to_be_specizialized_data_classes: "
-#                      f"{list(to_be_specialized_classes)}")
-#
-#         nested_classes_to_remove = to_be_nested_classes - as_is_nested_classes
-#         logger.trace(f"nested_classes_to_remove: {list(nested_classes_to_remove)}")
-#         if len(nested_classes_to_remove) > 0:
-#             for field in nested_classes_to_remove:
-#                 egeria_client.detach_nested_data_class(field, guid, None)
-#                 msg = f"Removed `{display_name}` from field `{field}`"
-#                 logger.trace(msg)
-#         nested_classes_to_add = to_be_nested_classes - as_is_nested_classes
-#         logger.trace(f"nested_classes_to_add: {list(nested_classes_to_add)}")
-#         if len(nested_classes_to_add) > 0:
-#             for field in nested_classes_to_add:
-#                 egeria_client.link_nested_data_class(field, guid, None)
-#                 msg = f"Added `{display_name}` to field `{field}`"
-#                 logger.trace(msg)
-#
-#         terms_to_remove = as_is_assigned_meanings - to_be_assigned_meanings
-#         logger.trace(f"terms_to_remove: {list(terms_to_remove)}")
-#         if len(terms_to_remove) > 0:
-#             for term in terms_to_remove:
-#                 egeria_client.detach_semantic_definition(guid, term, None)
-#                 msg = f"Removed `{term}` from `{display_name}`"
-#                 logger.trace(msg)
-#         terms_to_add = to_be_assigned_meanings - as_is_assigned_meanings
-#         logger.trace(f"terms_to_add: {list(terms_to_add)}")
-#         if len(terms_to_add) > 0:
-#             for term in terms_to_add:
-#                 egeria_client.link_semantic_definition(guid, term, None)
-#                 msg = f"Added `{term}` to`{display_name}`"
-#                 logger.trace(msg)
-#
-#         specialized_classes_to_remove = as_is_specialized_classes - to_be_specialized_classes
-#         logger.trace(f"classes_to_remove: {list(specialized_classes_to_remove)}")
-#         if len(terms_to_remove) > 0:
-#             for dc in specialized_classes_to_remove:
-#                 body = {
-#                     "class": "MetadataSourceRequestBody", "forLineage": False, "forDuplicateProcessing": False
-#                     }
-#                 egeria_client.detach_specialist_data_class(guid, dc, body)
-#                 msg = f"Removed `{dc}` from `{display_name}`"
-#                 logger.trace(msg)
-#         specialized_classes_to_add = to_be_specialized_classes - as_is_specialized_classes
-#         logger.trace(f"classes_to_add: {list(specialized_classes_to_add)}")
-#         if len(specialized_classes_to_add) > 0:
-#             for dc in specialized_classes_to_add:
-#                 body = {
-#                     "class": "RelationshipRequestBody", "forLineage": False, "forDuplicateProcessing": False
-#                     }
-#                 egeria_client.link_specialist_data_class(guid, dc, body)
-#                 msg = f"Added `{dc}` to`{display_name}`"
-#                 logger.trace(msg)
-#
-#
-#     else:  # merge - add field to related elements
-#         if containing_data_class_guids:
-#             for field in containing_data_class_guids:
-#                 egeria_client.link_nested_data_class(field, guid, None)
-#                 msg = f"Added `{display_name}` to `{field}`"
-#                 logger.trace(msg)
-#
-#         if terms:
-#             for term in terms:
-#                 egeria_client.link_semantic_definition(guid, term, None)
-#                 msg = f"Added `{term}` to `{display_name}`"
-#                 logger.trace(msg)
-#         if specializes_data_classes:
-#             for el in specializes_data_classes:
-#                 egeria_client.link_specialist_data_class(guid, el)
-#             msg = f"Linked `{el}` to `{display_name}`"
-#             logger.trace(msg)
 #
 # Product Manager Commands
 #
@@ -465,14 +201,14 @@ def process_collection_upsert_command(egeria_client: EgeriaTech, txt: str, direc
             if object_action == "Update":
                 if not exists:
                     msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
-                           f"object_action\n")
+                           f"`{object_action}`\n")
                     logger.error(msg)
                     return update_a_command(txt, object_action, object_type, qualified_name, guid)
                 elif not valid:
                     return None
                 else:
                     print(Markdown(
-                        f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
+                        f"==> Validation of `{command}` completed successfully! Proceeding to apply the changes.\n"))
                 prop_body = set_prop_body(obj,qualified_name,attributes)
 
                 body = set_update_body(obj, attributes)
@@ -573,6 +309,8 @@ def process_digital_product_upsert_command(egeria_client: EgeriaTech, txt: str,
 
     elif directive == "process":
         try:
+            prop_body = set_product_body(object_type, qualified_name, attributes)
+
             if object_action == "Update":
                 if not exists:
                     msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
@@ -584,9 +322,9 @@ def process_digital_product_upsert_command(egeria_client: EgeriaTech, txt: str,
                 else:
                     print(Markdown(
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
-                prop_body = set_product_body(object_type,qualified_name,attributes)
+
                 body = set_update_body(object_type, attributes)
-                body['properties'] = set_prop_body(object_type,qualified_name,attributes)
+                body['properties'] = prop_body
                 # Todo: Update product manager later?
 
                 egeria_client.update_digital_product(guid, body)
@@ -612,7 +350,7 @@ def process_digital_product_upsert_command(egeria_client: EgeriaTech, txt: str,
                 else:
                     body = set_create_body(object_type, attributes)
                     body["initialClassifications"] = set_collection_classifications(object_type, attributes,[])
-                    prop_body = set_product_body(object_type, qualified_name, attributes)
+
                     body["properties"] = prop_body
 
                     guid = egeria_client.create_digital_product(body_slimmer(body))

md_processing/md_commands/project_commands.py

@@ -8,7 +8,7 @@ from md_processing.md_processing_utils.common_md_utils import (debug_level, prin
 from md_processing.md_processing_utils.extraction_utils import (extract_command, process_simple_attribute)
 from md_processing.md_processing_utils.md_processing_constants import ALWAYS, ERROR, INFO, pre_command
 from pyegeria._globals import NO_PROJECTS_FOUND
-from pyegeria.project_manager_omvs import ProjectManager
+from pyegeria.project_manager import ProjectManager
 
 setup_log()
 

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -474,6 +474,9 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     if attribute and simp_type == "int" :
         attribute = int(attribute)
+    elif attribute and simp_type == "list":
+        attribute = list(attribute)
+
 
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
@@ -915,74 +918,145 @@ def proc_name_list(egeria_client: EgeriaTech, element_type: str, txt: str, eleme
 
 
 @logger.catch
-def update_term_categories(egeria_client: EgeriaTech, term_guid: str, categories_exist: bool,
-                           categories_list: List[str]) -> None:
+def sync_collection_memberships(egeria_client: EgeriaTech, guid: str, get_method: callable, collection_types: list,
+                                to_be_collection_guids:list, merge_update: bool = True)-> None:
     """
+    Synchronize collection memberships for an element.
 
-    Adds or removes a term to/from specified categories in a glossary.
-
-    This function associates a term, identified by its GUID, with one or more
-    categories. It uses the provided EgeriaTech client to assign the term
-    to the categories. If the GUID of a category is not readily available, it
-    is retrieved either from a pre-loaded dictionary or through a client lookup.
-
-    Args:
-        egeria_client (EgeriaTech): The client to interact with the glossary.
-        term_guid (str): The GUID of the term to be associated with categories.
-        categories_exist (bool): Flag indicating whether the categories already
-                                 exist.
-        categories_list (List[str]): A list of category names to associate with
-                                     the term.
-
-    Returns:
-        None
+    Parameters
+    - egeria_client: EgeriaTech composite client used to call add/remove operations.
+    - guid: the GUID of the element (e.g., GlossaryTerm) whose memberships we sync.
+    - get_method: callable to fetch the element details by guid; must accept (guid, output_format="JSON").
+    - collection_types: list of collection type identifiers to consider when syncing (e.g., ["Glossary", "Folder"]).
+    - to_be_collection_guids: list of lists of GUIDs corresponding positionally to collection_types; may contain None.
+    - merge_update: if True, only add missing memberships; if False, remove existing memberships for the
+      specified collection_types and then add the desired memberships.
+
+    Behavior
+    - When merge_update is True: determine the element's current memberships and add the missing ones only.
+    - When merge_update is False: remove the element from all collections of the specified types, then add the
+      provided target memberships for those types.
     """
-    to_be_cat_guids: list[str] = []
-    # find the categories a term is currently in.
-    existing_categories = egeria_client.get_categories_for_term(term_guid)
-    if type(existing_categories) is str:
-        current_categories = []
-    else:
-        current_categories = [cat['elementHeader']['guid'] for cat in existing_categories]
-
-    if categories_exist is True and categories_list is not None:
-        if type(categories_list) is str:
-            # categories_list = re.split(r'[;,\n]+', categories_list)
-            # categories_list = categories_list.split(";,").trim()
-            categories_list = split_tb_string(categories_list)
-        for category in categories_list:
-            cat_guid = None
-            cat_el = category.strip()
-            element_dict = get_element_dictionary()
-            if cat_el in element_dict:
-                cat = element_dict.get(cat_el, None)
-                cat_guid = cat.get('guid', None) if cat else None
-            if cat_guid is None:
-                cat_guid = egeria_client.__get_guid__(qualified_name=cat_el)
-                update_element_dictionary(cat_el, {'guid': cat_guid})
-            to_be_cat_guids.append(cat_guid)
-
-        for cat in to_be_cat_guids:
-            if cat not in current_categories:
-                egeria_client.add_term_to_category(term_guid, cat)
-                current_categories.append(cat)
-                msg = f"Added term {term_guid} to category {cat}"
-                logger.info(msg)
-
-        for cat in current_categories:
-            if cat not in to_be_cat_guids:
-                egeria_client.remove_term_from_category(term_guid, cat)
-                msg = f"Removed term {term_guid} from category {cat}"
-                logger.info(msg)
-    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}"
-            logger.info(msg)
-
-
-
+    try:
+        # Defensive defaults and shape normalization
+        collection_types = collection_types or []
+        to_be_collection_guids = to_be_collection_guids or []
+        # Ensure the lists align by index; pad to length
+        max_len = max(len(collection_types), len(to_be_collection_guids)) if (collection_types or to_be_collection_guids) else 0
+        if len(collection_types) < max_len:
+            collection_types = collection_types + [None] * (max_len - len(collection_types))
+        if len(to_be_collection_guids) < max_len:
+            to_be_collection_guids = to_be_collection_guids + [None] * (max_len - len(to_be_collection_guids))
+
+        # Get current element details with raw JSON to inspect relationships
+        element = None
+        try:
+            element = get_method(guid, output_format="JSON")
+        except TypeError:
+            # Some get methods require element_type parameter; fallback best-effort
+            element = get_method(guid, element_type=None, output_format="JSON")
+        if isinstance(element, str):
+            # e.g., "No elements found"; nothing to do
+            logger.debug(f"sync_collection_memberships: element lookup returned: {element}")
+            return
+        if not isinstance(element, dict):
+            logger.debug("sync_collection_memberships: element lookup did not return a dict; skipping")
+            return
+
+        member_rels = element.get("memberOfCollections", []) or []
+
+        # Build current membership maps
+        # - by GUID: set of current collection guids
+        # - by type name (classification names found on related collection): map type->set(guids)
+        current_all_guids: set[str] = set()
+        current_by_type: dict[str, set[str]] = {}
+
+        for rel in member_rels:
+            try:
+                related = (rel or {}).get("relatedElement", {})
+                rel_guid = ((related.get("elementHeader") or {}).get("guid"))
+                if not rel_guid:
+                    continue
+                current_all_guids.add(rel_guid)
+
+                # Collect type hints from classifications and from properties.collectionType
+                type_names: set[str] = set()
+                classifications = ((related.get("elementHeader") or {}).get("classifications")) or []
+                for cls in classifications:
+                    tname = (((cls or {}).get("type") or {}).get("typeName"))
+                    if tname:
+                        type_names.add(tname)
+                ctype = ((related.get("properties") or {}).get("collectionType"))
+                if isinstance(ctype, str) and ctype:
+                    type_names.add(ctype)
+
+                if not type_names:
+                    # Fallback: try elementHeader.type.typeName
+                    tname2 = (((related.get("elementHeader") or {}).get("type") or {}).get("typeName"))
+                    if tname2:
+                        type_names.add(tname2)
+
+                for tn in type_names:
+                    s = current_by_type.setdefault(tn, set())
+                    s.add(rel_guid)
+            except Exception as e:
+                logger.debug(f"sync_collection_memberships: skipping malformed relationship: {e}")
+                continue
 
+        # Helper to coerce incoming desired list entry to a set of guids
+        def to_guid_set(maybe_list) -> set[str]:
+            if not maybe_list:
+                return set()
+            if isinstance(maybe_list, list):
+                return {g for g in maybe_list if isinstance(g, str) and g}
+            # Sometimes a single guid may slip through
+            if isinstance(maybe_list, str):
+                return {maybe_list}
+            return set()
+
+        # If merge_update is False: remove all existing memberships for the specified types
+        if not merge_update:
+            # Build a set of guids to remove across specified types
+            to_remove: set[str] = set()
+            for t in collection_types:
+                if not t:
+                    continue
+                # Match by exact type name as seen in current_by_type
+                guids_for_type = current_by_type.get(t) or set()
+                if not guids_for_type and t.lower() in {k.lower() for k in current_by_type.keys()}:
+                    # Case-insensitive fallback
+                    for k, v in current_by_type.items():
+                        if k.lower() == t.lower():
+                            guids_for_type = v
+                            break
+                to_remove.update(guids_for_type)
+
+            for coll_guid in to_remove:
+                try:
+                    egeria_client.remove_from_collection(coll_guid, guid)
+                    logger.info(f"Removed element {guid} from collection {coll_guid}")
+                except Exception as e:
+                    logger.debug(f"Failed to remove element {guid} from collection {coll_guid}: {e}")
+
+        # Now add desired memberships (for both merge and replace flows)
+        for idx, t in enumerate(collection_types):
+            desired_set = to_guid_set(to_be_collection_guids[idx] if idx < len(to_be_collection_guids) else None)
+            if not desired_set:
+                continue
+            for coll_guid in desired_set:
+                # If merge_update True, skip if already a member; if False, we removed earlier so can re-add
+                if merge_update and coll_guid in current_all_guids:
+                    continue
+                try:
+                    egeria_client.add_to_collection(coll_guid, guid)
+                    logger.info(f"Added element {guid} to collection {coll_guid}")
+                except Exception as e:
+                    logger.debug(f"Failed to add element {guid} to collection {coll_guid}: {e}")
+
+        return
+    except Exception as e:
+        logger.error(f"sync_collection_memberships: unexpected error: {e}")
+        return
 
 @logger.catch
 def process_output_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:

md_processing/md_processing_utils/common_md_utils.py

@@ -300,10 +300,11 @@ def set_update_body(object_type: str, attributes: dict)->dict:
 def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
 
     prop_name = object_type.replace(" ", "")
+    display_name = attributes.get('Display Name', {}).get('value', None)
 
     return {
         "class": prop_name + "Properties",
-        "displayName": attributes['Display Name'].get('value', None),
+        "displayName": attributes.get('Display Name', {}).get('value', None),
         "qualifiedName" : qualified_name,
         "description": attributes['Description'].get('value', None),
         "category": attributes.get('Category', {}).get('value', None),

pyegeria/__init__.py

@@ -31,7 +31,7 @@ from ._exceptions_new import (PyegeriaInvalidParameterException,PyegeriaAPIExcep
                               PyegeriaUnauthorizedException, PyegeriaClientException, PyegeriaUnknownException,
                               PyegeriaConnectionException, PyegeriaNotFoundException,
                               print_exception_table, print_basic_exception, print_validation_error)
-from .load_config import load_app_config, get_app_config
+from .config import load_app_config, get_app_config, settings
 from .logging_configuration import config_logging, console_log_filter, init_logging
 from ._exceptions import (InvalidParameterException, PropertyServerException, UserNotAuthorizedException,
                           print_exception_response, )
@@ -44,13 +44,12 @@ from .collection_manager import CollectionManager
 from .core_omag_server_config import CoreServerConfig
 from .create_tech_guid_lists import build_global_guid_lists
 from .egeria_cat_client import EgeriaCat
-# from .egeria_client import Egeria
+from .egeria_client import Egeria
 from .egeria_config_client import EgeriaConfig
 from .egeria_my_client import EgeriaMy
 from .egeria_tech_client import EgeriaTech
 from .feedback_manager_omvs import FeedbackManager
 from .full_omag_server_config import FullServerConfig
-from .glossary_browser import GlossaryBrowser
 from .glossary_manager import GlossaryManager
 from .governance_officer import GovernanceOfficer
 from .mermaid_utilities import (construct_mermaid_web, construct_mermaid_jup, generate_process_graph, load_mermaid,

pyegeria/_client_new.py

@@ -380,7 +380,7 @@ class Client2:
             endpoint: str,
             payload: str | dict = None,
             time_out: int = 30,
-            is_json: bool = True,
+            is_json: bool = True
             ) -> Response | str:
         """Make a request to the Egeria API."""
         try:
@@ -401,7 +401,7 @@ class Client2:
             endpoint: str,
             payload: str | dict = None,
             time_out: int = 30,
-            is_json: bool = True,
+            is_json: bool = True
             ) -> Response | str:
         """Make a request to the Egeria API - Async Version
         Function to make an API call via the self.session Library. Raise an exception if the HTTP response code
@@ -935,6 +935,7 @@ class Client2:
             validated_body = self._filter_request_adapter.validate_python(body)
         else:
             filter_string = None if filter_string is "*" else filter_string
+            classification_names = None if classification_names == [] else classification_names
             body = {
                 "class": "FilterRequestBody",
                 "filter": filter_string,
@@ -947,7 +948,7 @@ class Client2:
         # classification_names = validated_body.include_only_classified_elements
         # element_type_name = classification_names[0] if classification_names else _type
 
-        json_body = validated_body.model_dump_json(indent=2)
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
 
         response = await self._async_make_request("POST", url, json_body)
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)