pyegeria 5.4.0.24__py3-none-any.whl → 5.4.0.25__py3-none-any.whl

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -129,8 +129,12 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
             default_value = attr[key].get('default_value', None)
 
             style = attr[key]['style']
-            if style in ['Simple', 'Dictionary', 'Comment']:
+            if style in ['Simple', 'Comment']:
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == 'Dictionary':
+                parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing, default_value)
+                parsed_attributes[key]['name_list'] = json.dumps(parsed_attributes[key]['value'], indent=2)
+
             elif style == 'Valid Value':
                 parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
                                                           attr[key].get('valid_values', None), if_missing,
@@ -330,8 +334,12 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             default_value = attr[key].get('default_value', None)
 
             style = attr[key]['style']
-            if style in ['Simple', 'Dictionary', 'Comment']:
+            if style in ['Simple', 'Comment']:
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+            elif style == 'Dictionary':
+                parsed_attributes[key] = proc_dictionary_attribute(txt, object_action, labels, if_missing,
+                                                           default_value)
+                parsed_attributes[key]['name_list'] = json.dumps(parsed_attributes[key]['value'], indent=2)
             elif style == 'Valid Value':
                 parsed_attributes[key] = proc_valid_value(txt, object_action, labels,
                                                           attr[key].get('valid_values', None), if_missing,
@@ -406,7 +414,7 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             value = parsed_attributes[key].get('value', None)
 
             if value is not None:
-                # if the value is a dict, get the flattened name list
+                # if the value is a dict or list, get the stringifiedt
                 value = parsed_attributes[key].get('name_list', None) if isinstance(value, (dict, list)) else value
                 parsed_output['display'] += f"\n\t* {key}: `{value}`\n\t"
 
@@ -469,6 +477,50 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
 
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
+@logger.catch
+def proc_dictionary_attribute(txt: str, action: str, labels: set, if_missing: str = INFO, default_value=None,
+                          simp_type: str = None) -> dict:
+    """Process a dictionary attribute based on the provided labels and if_missing value.
+       Extract the attribute value from the text and store it in a dictionary along with valid.
+       If it doesn`t exist, mark the dictionary entry as invalid and print an error message with severity of if_missing.
+
+       Parameters:
+       ----------
+       txt: str
+         The block of object_action text to extract attributes from.
+       labels: list
+         The possible attribute labels to search for. The first label will be used in messages.
+       if_missing: str, default is INFO
+         Can be one of "WARNING", "ERROR", "INFO". The severity of the missing attribute.
+       default_value: default is None
+        The default value to return if the attribute is missing.
+    """
+    valid = True
+
+    if if_missing not in ["WARNING", "ERROR", "INFO"]:
+        msg = "Invalid severity for missing attribute"
+        logger.error(msg)
+        return {"status": ERROR, "reason": msg, "value": None, "valid": False}
+
+    if default_value == "":
+        default_value = None
+
+    attr = extract_attribute(txt, labels)
+    attribute = json.loads(attr) if attr is not None else default_value
+
+
+    if attribute is None:
+        if if_missing == INFO or if_missing == WARNING:
+            msg = f"Optional attribute with labels: `{labels}` missing"
+            valid = True
+            logger.info(msg)
+        else:
+            msg = f"Missing attribute with labels `{labels}` "
+            valid = False
+            logger.error(msg)
+        return {"status": if_missing, "reason": msg, "value": None, "valid": valid, "exists": False}
+
+    return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
 @logger.catch
 def proc_valid_value(txt: str, action: str, labels: set, valid_values: [], if_missing: str = INFO,
@@ -529,8 +581,11 @@ def proc_valid_value(txt: str, action: str, labels: set, valid_values: [], if_mi
             logger.error(msg)
         return {"status": if_missing, "reason": msg, "value": None, "valid": valid, "exists": False}
     else:
+        # Todo: look at moving validation into pydantic or another style...
+        if "Status" in labels:
+            attribute = attribute.upper()
         if attribute not in v_values:
-            msg = f"Invalid value for attribute `{labels}`"
+            msg = f"Invalid value for attribute `{labels}` attribute is `{attribute}`"
             logger.warning(msg)
             return {"status": WARNING, "reason": msg, "value": attribute, "valid": False, "exists": True}
 
@@ -656,7 +711,7 @@ def proc_el_id(egeria_client: EgeriaTech, element_type: str, qn_prefix: str, ele
         logger.error(msg)
         identifier_output = {"status": ERROR, "reason": msg, "value": element_name, "valid": False, "exists": False, }
 
-    elif action in ["Update", "View"] and exists:
+    elif action in ["Update", "View", "Link", "Detach"] and exists:
         msg = f"Element {element_name} exists"
         logger.info(msg)
         identifier_output = {

md_processing/md_processing_utils/common_md_utils.py

@@ -307,12 +307,15 @@ def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict
         "qualifiedName" : qualified_name,
         "description": attributes['Description'].get('value', None),
         "category": attributes.get('Category', {}).get('value', None),
+        "identifier": attributes.get('Identifier', {}).get('value', None),
         "userDefinedStatus": attributes.get('User Defined Status', {}).get('value', None),
         "versionIdentifier": attributes.get('Version Identifier', {}).get('value', None),
         "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
         "effectiveTo": attributes.get('Effective To', {}).get('value', None),
         "additionalProperties": attributes.get('Additional Properties', {}).get('value', None),
-        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None)
+        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None),
+        "supportLevel": attributes.get('Support Level', {}).get('value', None),
+        "serviceLevels": attributes.get('Service Levels', {}).get('value', None),
         }
 
 def set_product_body(object_type: str, qualified_name: str, attributes: dict)->dict:
@@ -324,6 +327,9 @@ def set_product_body(object_type: str, qualified_name: str, attributes: dict)->d
     prop_bod["introductionDate"] = attributes.get('Introduction Date', {}).get('value', [])
     prop_bod["withdrawalDate"] = attributes.get('Withdrawal Date', {}).get('value', [])
     prop_bod["nextVersion"] = attributes.get('Next Version Date', {}).get('value', [])
+    return prop_bod
+
+
 
 def set_update_status_body(object_type: str, attributes: dict)->dict:
     return {
@@ -425,6 +431,8 @@ def set_delete_request_body(object_type: str, attributes: dict)->dict:
         "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
         }
 
+
+
 def set_filter_request_body(object_type: str, attributes: dict)->dict:
     return {
             "class": "FilterRequestBody",
@@ -457,14 +465,18 @@ def set_classifications(object_type: str, attributes: dict)->dict:
         body = {classification: {} for classification in classifications} if cclassifications else {}
     return body
 
-def set_collection_classifications(object_type: str, attributes: dict)->dict:
+def set_collection_classifications(object_type: str, attributes: dict, obj_types: list[str])->dict:
     classifications = attributes.get('Classifications', {}).get('name_list', None)
-
-    if object_type in ["Folder", "Root"]:
-        if object_type not in classifications:
-            classifications.append(object_type)
-
-    body = None
+    obj = object_type.replace(" ", "")
+    if object_type in obj_types:
+        if classifications:
+            if object_type not in classifications:
+                classifications.append(obj)
+        else:
+            classifications = [obj]
+
+    body = {}
     if classifications:
-        body = {classification: {} for classification in classifications} if cclassifications else {}
+        for classification in classifications:
+            body[classification] = {"class" : f"{classification}Properties"}
     return body

md_processing/md_processing_utils/extraction_utils.py

@@ -91,7 +91,7 @@ def extract_attribute(text: str, labels: set) -> str | None:
     # Iterate over the list of labels
     for label in labels:
         # Construct pattern for the current label
-        # text = re.sub(r'\s+', ' ', text).strip()
+        # text = re.sub(r'\s+', ' ', text).strip() # just added
         text = re.sub(r'\n\n+', '\n\n', text).strip()
 
         label = label.strip()
@@ -395,7 +395,7 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str) ->
             return q_name, guid, unique, exists
 
         else:  # Missing guid from element_dictionary
-            guid = egeria_client.get_element_guid_by_unique_name(element_name)
+            guid = egeria_client.__get_guid__(qualified_name=q_name)
             if guid == NO_ELEMENTS_FOUND:
                 guid = None
                 exists = False

md_processing/md_processing_utils/md_processing_constants.py

@@ -131,20 +131,21 @@ command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term
                 "View Dataa Classes", "View Data Class", "Create Data Class", "Update Data Class",
                 "Create Digital Product", "Create Data Product", "Update Digital Product", "Update Data Product",
                 "Create Agreement", "Update Agreement",
-                "Link Digital Products", "Link Data Products", "Detach Digital Products", "Detach Data Products",
+                "Link Digital Products", "Link Product-Product", "Detach Digital Products", "Detach Product-Product",
                 "Create Data Sharing Agreement", "Update Data Sharing Agreement",
-                # "Create Digital Subscription", "Create Product Subscription", "Update Digital Subscription", "Update Product Subscription",
-                "Attach Agreement Items", "Detach Agreement Items",
+                "Create Digital Subscription", "Create Product Subscription", "Update Digital Subscription", "Update Product Subscription",
+                "Link Agreement->Item", "Detach Agreement->Item",
                 "Attach Contract", "Detach Contract",
-                "Attach Subscriber", "Detach Subscriber",
-                "Link Collection to Resource", "Attach Collection to Resource",
-                "Unlink Collection From Resource", "Detach Collection From Resource",
+                "Link Subscriber->Subscription", "Detach Subscriber->Subscription",
+                "Link Collection->Resource", "Attach Collection->Resource",
+                "Unlink Collection->Resource", "Detach Collection->Resource",
                 "Add Member to Collection", "Add Member", "Member->Collection",
-                "Remove Member from Collection","Remove Member from Collection",
+                "Remove Member from Collection","Remove Member->Collection",
                  "View Governance Definitions", "View Gov Definitions",
                  "List Governance Definitions", "List Gov Definitions",
                 "View Governance Definition Context","List Governance Definition Context",
                 "View Governance Def Context", "List Governance Def Context",
+                "View Report",
                 # "Create Business Imperative", "Update Business Imperative",
                 # "Create Regulation Article Definition", "Update Regulation Article Definition",
                 # "Create Threat Definition", "Update Threat Definition",

pyegeria/_client_new.py

@@ -35,7 +35,7 @@ from pyegeria._validators import (
     )
 from pyegeria.models import SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody, \
     TemplateRequestBody, UpdateStatusRequestBody, UpdateElementRequestBody, NewRelationshipRequestBody, \
-    DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody
+    DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody, NewClassificationRequestBody
 from pyegeria.utils import body_slimmer
 
 ...
@@ -146,6 +146,7 @@ class Client2:
         self._update_element_request_adapter = TypeAdapter(UpdateElementRequestBody)
         self._update_status_request_adapter = TypeAdapter(UpdateStatusRequestBody)
         self._new_relationship_request_adapter = TypeAdapter(NewRelationshipRequestBody)
+        self._new_classification_request_adapter = TypeAdapter(NewClassificationRequestBody)
         self._delete_request_adapter = TypeAdapter(DeleteRequestBody)
         self._template_request_adapter = TypeAdapter(TemplateRequestBody)
         self._update_relationship_request_adapter = TypeAdapter(UpdateRelationshipRequestBody)
@@ -755,9 +756,21 @@ class Client2:
             return None
         return validated_body
 
+    def validate_new_element_from_template_request(self, body: dict | TemplateRequestBody
+                                     ) -> NewElementRequestBody | None:
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
+
+        elif isinstance(body, dict):
+            # if body.get("properties", {}).get("class", "") == prop:
+            validated_body = self._template_request_adapter.validate_python(body)
+        else:
+            return None
+        return validated_body
+
     def validate_new_relationship_request(self, body: dict | NewRelationshipRequestBody,
                                           prop: str = None) -> NewRelationshipRequestBody | None:
-        if isinstance(body, NewElementRequestBody):
+        if isinstance(body, NewRelationshipRequestBody):
             if (prop and body.properties.class_ == prop) or (prop is None):
                 validated_body = body
             else:
@@ -775,6 +788,26 @@ class Client2:
 
         return validated_body
 
+    def validate_new_classification_request(self, body: dict | NewClassificationRequestBody,
+                                          prop: str = None) -> NewClassificationRequestBody | None:
+        if isinstance(body, NewClassificationRequestBody):
+            if (prop and body.properties.class_ == prop) or (prop is None):
+                validated_body = body
+            else:
+                raise PyegeriaInvalidParameterException(additional_info=
+                                                        {"reason": "unexpected property class name"})
+
+        elif isinstance(body, dict):
+            if body.get("properties", {}).get("class", "") == prop:
+                validated_body = self._new_classification_request_adapter.validate_python(body)
+            else:
+                raise PyegeriaInvalidParameterException(additional_info=
+                                                        {"reason": "unexpected property class name"})
+        else:
+            return None
+
+        return validated_body
+
     def validate_delete_request(self, body: dict | DeleteRequestBody,
                                 cascade_delete: bool = False) -> DeleteRequestBody | None:
         if isinstance(body, DeleteRequestBody):
@@ -819,7 +852,7 @@ class Client2:
         elif status:
             body = {
                 "class": "UpdateStatusRequestBody",
-                "status": status
+                "newStatus": status
                 }
             validated_body = UpdateStatusRequestBody.model_validate(body)
         else:
@@ -939,11 +972,11 @@ class Client2:
         else:
             body = {
                 "class": "GetRequestBody",
-
+                "metadataElementTypeName": _type
                 }
             validated_body = GetRequestBody.model_validate(body)
 
-        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("element", NO_ELEMENTS_FOUND)
@@ -972,7 +1005,7 @@ class Client2:
                 }
             validated_body = ResultsRequestBody.model_validate(body)
 
-        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", None)
@@ -996,7 +1029,15 @@ class Client2:
         logger.info(json_body)
         response = await self._async_make_request("POST", url, json_body)
         logger.info(response.json())
-        return response.json().get("guid")
+        return response.json().get("guid", "NO_GUID_RETURNED")
+
+    async def _async_create_element_from_template(self, url: str, body: dict | TemplateRequestBody = None) -> str:
+        validated_body = self.validate_new_element_from_template_request(body)
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        response = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(response.json())
+        return response.json().get("guid", "NO_GUID_RETURNED")
 
     async def _async_update_element_body_request(self, url: str, prop: list[str],
                                                  body: dict | UpdateElementRequestBody = None) -> None:
@@ -1024,6 +1065,16 @@ class Client2:
         else:
             await self._async_make_request("POST", url)
 
+    async def _async_new_classification_request(self, url: str, prop: str,
+                                              body: dict | NewRelationshipRequestBody = None) -> None:
+        validated_body = self.validate_new_classification_request(body, prop)
+        if validated_body:
+            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+            logger.info(json_body)
+            await self._async_make_request("POST", url, json_body)
+        else:
+            await self._async_make_request("POST", url)
+
     async def _async_delete_request(self, url: str, body: dict | DeleteRequestBody = None,
                                     cascade_delete: bool = False) -> None:
         validated_body = self.validate_delete_request(body, cascade_delete)
@@ -1035,9 +1086,6 @@ class Client2:
             await self._async_make_request("POST", url)
 
 
-
-
-
     async def _async_update_relationship_request(self, url: str, prop: str,
                                               body: dict | UpdateRelationshipRequestBody = None) -> None:
         validated_body = self.validate_update_relationship_request(body, prop)

pyegeria/_output_formats.py

@@ -143,6 +143,14 @@ COLLECTION_DICT = Format(
         ],
 )
 
+BASIC_COLLECTIONS_COLUMNS = [
+    Column(name='Qualified Name', key='qualified_name', format=True),
+    Column(name='GUID', key='guid', format=True),
+    Column(name='Type Name', key='type_name'),
+    Column(name="Containing Members", key='collection_members'),
+    Column(name="Member Of", key='member_of_collections')
+]
+
 COLLECTION_REPORT = Format(
     types=["REPORT"],
     columns=COLLECTIONS_MEMBERS_COLUMNS + [
@@ -239,6 +247,8 @@ output_format_sets = FormatSetDict({
                     Column(name="Effective To", key='effective_to'),
                     Column(name="GUID", key='guid'),
                     Column(name="Open Metadata Type Name", key='type_name'),
+                    Column(name="Glossary", key='parent_glossary'),
+                    Column(name="Subject Aream", key='subject_area'),
                 ],
             )
             ]
@@ -257,6 +267,21 @@ output_format_sets = FormatSetDict({
             spec_params={},
         )
     ),
+    "BasicCollections": FormatSet(
+        heading="Common Collection Information",
+        description="Attributes generic to all Collections.",
+        aliases=[],
+        annotations=COMMON_ANNOTATIONS,
+        formats=[Format(
+            types=["ALL"],
+            columns=BASIC_COLLECTIONS_COLUMNS,
+            )],  # Reusing common formats
+        action=ActionParameter(
+            function="CollectionManager.find_collections",
+            user_params=["search_string"],
+            spec_params={},
+            )
+        ),
 
     "CollectionMembers": FormatSet(
         heading="Collection Membership Information",

pyegeria/collection_manager.py

@@ -672,7 +672,7 @@ class CollectionManager(Client2):
         ----
         Body sample:
         {
-          "class": "AnyTimeRequestBody",
+          "class": "GetRequestBody",
           "asOfTime": "{{$isoTimestamp}}",
           "effectiveTime": "{{$isoTimestamp}}",
           "forLineage": false,
@@ -680,7 +680,7 @@ class CollectionManager(Client2):
         }
         """
 
-        url = str(HttpUrl(f"{self.collection_command_root}/{collection_guid}"))
+        url = str(HttpUrl(f"{self.collection_command_root}/{collection_guid}/retrieve"))
         type = element_type if element_type else "Collection"
 
         response = await self._async_get_guid_request(url, _type=type,
@@ -1414,6 +1414,26 @@ 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
     async def _async_create_data_spec_collection(self, display_name: str = None, description: str = None,
                                                 category: str = None, classification_name: str = None,
@@ -1520,15 +1540,16 @@ class CollectionManager(Client2):
         }
 
         """
-        validated_body = self.validate_new_element_request(body,"DataSpecProperties")
-
-        if validated_body is None and display_name is not None:
+        if body:
+            validated_body = self.validate_new_element_request(body,"DataSpecProperties")
+        elif display_name is not None:
             qualified_name = self.__create_qualified_name__("DataSpec", display_name, EGERIA_LOCAL_QUALIFIER)
-            print(f"\n\tDisplayName was {display_name}, classification {classification_name}\n")
-            initial_classifications_data = {"class" : "ClassificationProperties"}
+            logger.info(f"\n\tDisplayName was {display_name}, classification {classification_name}\n")
             if classification_name:
-                initial_classification_dict = {
-                    classification_name: InitialClassifications.model_validate(initial_classifications_data)
+                initial_classification_data = {
+                    classification_name: {
+                    "class" : "ClassificationProperties"
+                    }
                 }
             else:
                 initial_classification_dict = None
@@ -2398,12 +2419,11 @@ class CollectionManager(Client2):
         """
 
         url = (f"{self.collection_command_root}/{collection_guid}/update")
-        await self._async_update_element_request_body(url, "DigitalProductProperties", body )
+        await self._async_update_element_body_request(url, "DigitalProductProperties", body )
 
 
     @dynamic_catch
-    def update_digital_product(self, collection_guid: str,  body: dict | UpdateElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    def update_digital_product(self, collection_guid: str,  body: dict | UpdateElementRequestBody,) -> None:
         """ Update the properties of a digital product..
             Collections: https://egeria-project.org/concepts/collection
 
@@ -2467,7 +2487,7 @@ class CollectionManager(Client2):
         """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_update_digital_product(collection_guid, body, merge_update))
+            self._async_update_digital_product(collection_guid, body))
 
 
     @dynamic_catch
@@ -2512,7 +2532,7 @@ class CollectionManager(Client2):
         }
         """
 
-        url = f"{self.collection_command_root}/{collection_guid}/update-status"
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/metadata-elements/{collection_guid}/update-status"
         await self._async_update_status_request(url, status, body)
 
     @dynamic_catch
@@ -5071,6 +5091,12 @@ 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,
+                             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))
+
 
     @dynamic_catch
     async def _async_update_collection_membership_prop(self, collection_guid: str, element_guid: str, body: dict = None,
@@ -5296,6 +5322,45 @@ class CollectionManager(Client2):
         #
 
 
+    def remove_term_from_category(self, category_guid: str, term_guid: str,
+                               body: dict | DeleteRequestBody= None) -> None:
+        """Remove a term from a category.
+
+        Parameters
+        ----------
+        category_guid: str
+            identity of the collection to return members for.
+        term_guid: str
+            Effective time of the query. If not specified will default to any time.
+        body: dict, optional, defaults to None
+            The body of the request to add to the collection. See notes.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        Notes
+        -----
+
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self._async_remove_from_collection(category_guid, term_guid, body))
+
+        #
+        #
+        #
+
+
     @dynamic_catch
     async def _async_get_member_list(self, collection_guid: str = None, collection_name: str = None,
                                      collection_qname: str = None, ) -> list | str: