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

pyegeria/{glossary_manager_omvs.py → glossary_manager.py}

@@ -11,16 +11,27 @@ import asyncio
 import csv
 import os
 import time
-from datetime import datetime
-from typing import List
+from typing import List, Annotated, Literal
 
-from pyegeria._client import Client
+from loguru import logger
+from pydantic import Field
+
+from pyegeria._client_new import Client2
 from pyegeria._exceptions import InvalidParameterException
-from pyegeria._globals import NO_TERMS_FOUND
-from pyegeria._validators import validate_guid, validate_name
-from pyegeria.glossary_browser_omvs import GlossaryBrowser
+from pyegeria._exceptions_new import PyegeriaInvalidParameterException
+from pyegeria._globals import NO_GUID_RETURNED
+from pyegeria._validators import validate_guid
+from pyegeria.glossary_browser import GlossaryBrowser
+from pyegeria.load_config import get_app_config
+from pyegeria.models import (NewElementRequestBody,
+                             ReferenceableProperties, UpdateElementRequestBody, DeleteRequestBody, TemplateRequestBody,
+                             NewRelationshipRequestBody, UpdateRelationshipRequestBody, NewClassificationRequestBody)
 from pyegeria.utils import body_slimmer
 
+app_settings = get_app_config()
+EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
+
+
 def query_seperator(current_string):
     if current_string == "":
         return "?"
@@ -28,7 +39,8 @@ def query_seperator(current_string):
         return "&"
 
 
-"params are in the form of [(paramName, value), (param2Name, value)] if the value is not None, it will be added to the query string"
+("params are in the form of [(paramName, value), (param2Name, value)] if the value is not None, it will be added to "
+ "the query string")
 
 
 def query_string(params):
@@ -43,6 +55,23 @@ def base_path(client, view_server: str):
     return f"{client.platform_url}/servers/{view_server}/api/open-metadata/classification-manager"
 
 
+class GlossaryProperties(ReferenceableProperties):
+    class_: Annotated[Literal["GlossaryProperties"], Field(alias="class")]
+    language: str = "English"
+    usage: str = None
+
+
+class GlossaryTermProperties(ReferenceableProperties):
+    class_: Annotated[Literal["GlossaryTermProperties"], Field(alias="class")]
+    summary: str = None
+    description: str = None
+    abbreviation: str = None
+    examples: str = None
+    usage: str = None
+    user_defined_status: str = None
+    publishVersionIdentifier: str = None
+
+
 class GlossaryManager(GlossaryBrowser):
     """
     GlossaryManager is a class that extends the Client class. It provides methods to create and manage glossaries,
@@ -64,20 +93,20 @@ class GlossaryManager(GlossaryBrowser):
     """
 
     def __init__(
-        self,
-        view_server: str,
-        platform_url: str,
-        user_id: str,
-        user_pwd: str = None,
-        token: str = None,
-    ):
+            self,
+            view_server: str,
+            platform_url: str,
+            user_id: str,
+            user_pwd: str = None,
+            token: str = None,
+            ):
         self.gl_mgr_command_root: str
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
 
-        Client.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token)
 
     #
     #       Get Valid Values for Enumerations
@@ -88,13 +117,19 @@ class GlossaryManager(GlossaryBrowser):
         recognized_term_status = self.get_glossary_term_statuses()
         return status in recognized_term_status
 
+    #
+    #       Glossaries
+    #
+
     async def _async_create_glossary(
-        self,
-        display_name: str,
-        description: str,
-        language: str = "English",
-        usage: str = None,
-    ) -> str:
+            self,
+            display_name: str,
+            description: str,
+            language: str = "English",
+            usage: str = None,
+            initial_classifications: list = None,
+            body: dict | NewElementRequestBody = None,
+            ) -> str:
         """Create a new glossary. Async version.
 
         Parameters
@@ -117,27 +152,53 @@ class GlossaryManager(GlossaryBrowser):
         """
 
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries"
-        body = {
-            "class": "ReferenceableRequestBody",
-            "elementProperties": {
-                "class": "GlossaryProperties",
-                "qualifiedName": self.__create_qualified_name__("Glossary", display_name),
-                "displayName": display_name,
-                "description": description,
-                "language": language,
-                "usage": usage,
-            },
-        }
-        response = await self._async_make_request("POST", url, body_slimmer(body))
-        return response.json().get("guid", None)
+        if body:
+            validated_body = self.validate_new_element_request(body, "GlossaryProperties")
+        elif (body is None) and (display_name is not None):
+            pre = initial_classifications[0] if initial_classifications is not None else "Glossary"
+            qualified_name = self.__create_qualified_name__(pre, display_name, EGERIA_LOCAL_QUALIFIER)
+            if initial_classifications:
+                initial_classifications_dict = {}
+                for c in initial_classifications:
+                    initial_classifications_dict = initial_classifications_dict | {
+                        c: {"class": "ClassificationProperties"}
+                        }
+
+            else:
+                initial_classifications_dict = None
+
+            glossary_properties = GlossaryProperties(class_="GlossaryProperties",
+                                                     qualified_name=qualified_name,
+                                                     display_name=display_name,
+                                                     description=description,
+                                                     language=language,
+                                                     usage=usage
+                                                     )
+            body = {
+                "class": "NewElementRequestBody",
+                "isOwnAnchor": True,
+                "initialClassifications": initial_classifications_dict,
+                "properties": glossary_properties.model_dump()
+                }
+            validated_body = NewElementRequestBody.model_validate(body)
+        else:
+            raise PyegeriaInvalidParameterException(additional_info={"reason": "Invalid input parameters"})
+
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        resp = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(f"Create glossary with GUID: {resp.json().get('guid')}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
 
     def create_glossary(
-        self,
-        display_name: str,
-        description: str,
-        language: str = "English",
-        usage: str = None,
-    ) -> str:
+            self,
+            display_name: str,
+            description: str,
+            language: str = "English",
+            usage: str = None,
+            initial_classifications: list = None,
+            body: dict | NewElementRequestBody = None
+            ) -> str:
         """Create a new glossary.
 
         Parameters
@@ -160,11 +221,13 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_glossary(display_name, description, language, usage)
-        )
+            self._async_create_glossary(display_name, description, language, usage,
+                                        initial_classifications, body)
+            )
         return response
 
-    async def _async_delete_glossary(self, glossary_guid: str, cascade:bool = False) -> None:
+    async def _async_delete_glossary(self, glossary_guid: str, body: dict | DeleteRequestBody = None,
+                                     cascade: bool = False) -> None:
         """Delete glossary. Async version.
 
         Parameters
@@ -179,15 +242,16 @@ class GlossaryManager(GlossaryBrowser):
         None
 
         """
-        cascade_str = str(cascade).lower()
+
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/remove?cascadedDelete={cascade_str}"
+            f"{glossary_guid}/delete"
         )
 
-        await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body, cascade)
+        logger.info(f"Deleted collection {glossary_guid} with cascade {cascade}")
 
-    def delete_glossary(self, glossary_guid: str, cascade: bool = False) -> None:
+    def delete_glossary(self, glossary_guid: str, body: dict | DeleteRequestBody = None, cascade: bool = False) -> None:
         """Delete a new glossary.
 
         Parameters
@@ -204,16 +268,13 @@ class GlossaryManager(GlossaryBrowser):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_delete_glossary(glossary_guid, cascade))
+        loop.run_until_complete(self._async_delete_glossary(glossary_guid, body, cascade))
 
     async def _async_update_glossary(
-        self,
-        glossary_guid: str,
-        body: dict,
-        is_merge_update: bool = True,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> None:
+            self,
+            glossary_guid: str,
+            body: dict | UpdateElementRequestBody
+            ) -> None:
         """Update Glossary.
 
         Async version.
@@ -224,14 +285,6 @@ class GlossaryManager(GlossaryBrowser):
             The ID of the glossary to update.
         body: dict
             A dict containing the properties to update.
-        is_merge_update: bool, optional, default = True
-            If true, then only those properties specified in the body will be updated. If false, then all the
-            properties of the glossary will be replaced with those of the body.
-        for_lineage: bool, optional, default = False
-            Normally false. Used when we want to retrieve elements that have been delete but have a Memento entry.
-        for_duplicate_processing: bool, optional, default = False
-            Normally false. Set true when Egeria is told to skip deduplication because another system will do it.
-
 
         Returns
         -------
@@ -242,34 +295,21 @@ class GlossaryManager(GlossaryBrowser):
 
         Sample body:
 
-            {
-                "class" : "ReferenceableRequestBody",
-                "elementProperties" :
-                    {
-                        "class" : "GlossaryProperties",
-                        "qualifiedName" : "MyGlossary",
-                        "displayName" : "My Glossary",
-                        "description" : "This is an example glossary"
-                    }
-            }
         """
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/update?isMergeUpdate={is_merge_update}&forLineage={for_lineage}&"
-            f"forDuplicateProcessing={for_duplicate_processing}"
+            f"{glossary_guid}/update"
         )
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_element_body_request(url, ["GlossaryProperties"], body)
+        logger.info(f"Updated digital subscription {glossary_guid}")
 
     def update_glossary(
-        self,
-        glossary_guid: str,
-        body: dict,
-        is_merge_update: bool = True,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> None:
+            self,
+            glossary_guid: str,
+            body: dict | UpdateElementRequestBody
+            ) -> None:
         """Update Glossary.
 
         Parameters
@@ -296,475 +336,29 @@ class GlossaryManager(GlossaryBrowser):
 
         Sample body:
 
-            {
-                "class" : "ReferenceableRequestBody",
-                "elementProperties" :
-                    {
-                        "class" : "GlossaryProperties",
-                        "qualifiedName" : "MyGlossary",
-                        "displayName" : "My Glossary",
-                        "description" : "This is an example glossary"
-                    }
-            }
+
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_update_glossary(
                 glossary_guid,
-                body,
-                is_merge_update,
-                for_lineage,
-                for_duplicate_processing,
+                body
+                )
             )
-        )
-
-    #
-    #       Glossaries
-    #
-
-
-
 
     #
-    # Glossary Categories
-    #
-    async def _async_create_category(
-        self,
-        glossary_guid: str,
-        display_name: str,
-        description: str,
-        is_root_category: bool = False,
-    ) -> str:
-        """Create a new category within the specified glossary. Async Version.
-
-        Parameters
-        ----------
-        glossary_guid: str,
-            Unique identifier for the glossary.
-        display_name: str,
-            Display name for the glossary category. Will be used as the base for a constructed unique qualified name.
-        description: str,
-            Description for the category.
-        is_root_category: bool, [default=False], optional
-            Is this category a root category?
-
-
-        Returns
-        -------
-        A string with the GUID of the new category..
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/categories?isRootCategory={is_root_category}"
-        )
-        body = {
-            "class": "ReferenceableRequestBody",
-            "elementProperties": {
-                "class": "GlossaryCategoryProperties",
-                "qualifiedName": self.__create_qualified_name__("Category", display_name),
-                "displayName": display_name,
-                "description": description,
-            },
-        }
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("guid", None)
-
-    def create_category(
-        self,
-        glossary_guid: str,
-        display_name: str,
-        description: str,
-        is_root_category: bool = False,
-    ) -> str:
-        """Create a new category within the specified glossary.
-
-        Parameters
-        ----------
-        glossary_guid: str,
-            Unique identifier for the glossary.
-        display_name: str,
-            Display name for the glossary category. Will be used as the base for a constructed unique qualified name.
-        description: str,
-            Description for the category.
-        is_root_category: bool, [default=False], optional
-            Is this category a root category?
-
-        Returns
-        -------
-        A string with the GUID of the new category..
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_create_category(glossary_guid, display_name, description, is_root_category)
-        )
-        return response
-
-    async def _async_update_category(
-        self,
-        category_guid: str,
-        display_name: str,
-        description: str,
-        qualified_name: str = None,
-        effective_time: str = None,
-        update_description: str = None,
-        is_merge_update: bool = True,
-    ) :
-        """Create a new category within the specified glossary. Async Version.
-
-        Parameters
-        ----------
-        category_guid: str,
-            Unique identifier for the glossary.
-        display_name: str,
-            Display name for the glossary category. Will be used as the base for a constructed unique qualified name.
-        description: str,
-            Description for the category.
-        qualified_name: str, [default=None], optional
-            Unique identifier for the glossary category. Must be specified if not a merge update.
-        effective_time: datetime, [default=None], optional
-            Time when the category becomes effective.
-        update_description: str, [default=None], optional
-            Description of the update to the category.
-        is_merge_update: bool, [default=True], optional
-            Should this be a merge or a replace?
-
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-        if (not is_merge_update and qualified_name is None):
-            raise ValueError('qualified_name must be specified for a replace update')
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{category_guid}/update?isMergeUpdate={is_merge_update}"
-        )
-        body = {
-            "class": "ReferenceableUpdateRequestBody",
-            "effectiveTime": effective_time,
-            "updateDescription": update_description,
-            "elementProperties": {
-                "class": "GlossaryCategoryProperties",
-                "qualifiedName": qualified_name ,
-                "displayName": display_name,
-                "description": description
-            },
-        }
-        response = await self._async_make_request("POST", url, body_slimmer(body))
-        return response.json().get("guid", None)
-
-    def update_category(
-        self,
-        glossary_guid: str,
-        display_name: str,
-        description: str,
-        qualified_name: str = None,
-        effective_time: str = None,
-        update_description: str = None,
-        is_merge_update: bool = True,
-    ) -> str:
-        """Create a new category within the specified glossary.
-
-        Parameters
-        ----------
-        glossary_guid: str,
-            Unique identifier for the glossary.
-        display_name: str,
-            Display name for the glossary category. Will be used as the base for a constructed unique qualified name.
-        description: str,
-            Description for the category.
-        qualified_name: str, [default=None], optional
-            Unique identifier for the glossary category. Must be specified if not a merge update.
-        effective_time: datetime, [default=None], optional
-            Time when the category becomes effective.
-        update_description: str, [default=None], optional
-            Description of the update to the category.
-        is_merge_update: bool, [default=True], optional
-            Should this be a merge or a replace?
-
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_update_category(glossary_guid, display_name, description,
-                                        qualified_name, effective_time, update_description, is_merge_update)
-        )
-        return response
-
-
-    async def _async_delete_category(
-        self,
-        category_guid: str,
-    ) -> None:
-        """Delete a category. Async Version.
-
-        Parameters
-        ----------
-        category_guid: str,
-            Unique identifier for the category.
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{category_guid}/remove"
-        )
-
-        await self._async_make_request("POST", url)
-
-
-    def delete_category(
-        self,
-        category_guid: str,
-    ) -> None:
-        """Delete a category.
-
-        Parameters
-        ----------
-        category_guid: str,
-            Unique identifier for the category.
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_delete_category(category_guid)
-        )
-
-    async def _async_set_parent_category(
-        self,
-        parent_category_guid: str, child_category_guid: str) -> None:
-        """Set parent category Async Version.
-
-        Parameters
-        ----------
-        parent_category_guid: str,
-            Unique identifier for the parent category.
-        child_category_guid: str,
-            Unique identifier for the child category.
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{parent_category_guid}/subcategories/{child_category_guid}"
-        )
-
-        await self._async_make_request("POST", url)
-
-    def set_parent_category(self, parent_category_guid: str, child_category_guid: str) -> None:
-        """Set parent category
-
-        Parameters
-        ----------
-        parent_category_guid: str,
-            Unique identifier for the parent category.
-        child_category_guid: str,
-            Unique identifier for the child category.
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_set_parent_category(parent_category_guid,child_category_guid)
-        )
-
-    async def _async_remove_parent_category(
-            self,
-            parent_category_guid: str, child_category_guid: str) -> None:
-        """Remove parent category relationship. Async Version.
-
-        Parameters
-        ----------
-        parent_category_guid: str,
-            Unique identifier for the parent category.
-        child_category_guid: str,
-            Unique identifier for the child category.
-
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{parent_category_guid}/subcategories/{child_category_guid}/remove"
-        )
-
-        await self._async_make_request("POST", url)
-
-    def remove_parent_category(self, parent_category_guid: str, child_category_guid: str) -> None:
-        """Remove parent category relationship.
-
-        Parameters
-        ----------
-        parent_category_guid: str,
-            Unique identifier for the parent category.
-        child_category_guid: str,
-            Unique identifier for the child category.
+    #   add glossary classifications? is-canonical, is editing, is staging, is taxonomy?
+    #   Not all show up in UML
 
-        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
-        ConfigurationErrorException
-          Raised when configuration parameters passed on earlier calls turn out to be
-          invalid or make the new call invalid.
-        """
 
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_remove_parent_category(parent_category_guid, child_category_guid)
-            )
 
     #
     #  Terms
     #
-    async def _async_create_controlled_glossary_term(
-        self, glossary_guid: str, body: dict
-    ) -> str:
-        """Create a term for a controlled glossary.
+    async def _async_create_glossary_term(
+            self, body: dict | NewElementRequestBody
+            ) -> str:
+        """Create a term for a  glossary.
             See also: https://egeria-project.org/types/3/0385-Controlled-Glossary-Development/?h=controlled
             The request body also supports the specification of an effective time for the query.
 
@@ -772,10 +366,8 @@ class GlossaryManager(GlossaryBrowser):
 
         Parameters
         ----------
-            glossary_guid : str
-                Unique identifier for the glossary category to retrieve terms from.
-            body: dict
-                The dictionary to create te controlled glossary term for. Example below.
+            body: dict | NewElementRequestBody
+                The dictionary to create glossary term for. Example below.
 
 
         Returns
@@ -796,19 +388,25 @@ class GlossaryManager(GlossaryBrowser):
 
         Sample body like:
         {
-            "class" : "ReferenceableRequestBody",
-            "elementProperties" :
+            "class" : "NewElementRequestBody",
+            "parentGUID" : "Glossary GUID here",
+            "isOwnAnchor" : true,
+            "anchorScopeGUID" : "Glossary GUID here",
+            "parentRelationshipTypeName" : "ParentGlossary",
+            "parentAtEnd1": true,
+            "properties" :
                 {
                     "class" : "GlossaryTermProperties",
-                    "qualifiedName" : "GlossaryTerm: term name : {$isoTimestamp}",
+                    "qualifiedName" : "GlossaryTerm::term name",
                     "displayName" : "term name",
                     "aliases": []
                     "summary" : "This is the short description.",
                     "description" : "This is the long description of the term.",
-                    "abbreviation" : "GT",
+                    "abbreviation" : "aabrev",
                     "examples" : "Add examples and descriptions here.",
                     "usage" : "This is how the concept described by the glossary term is used.",
-                    "publishVersionIdentifier" : "V1.0",
+                    "versionIdentifier" : "V1.0",
+                    "category" : "A user defined category",
                     "additionalProperties" :
                     {
                        "propertyName1" : "xxxx",
@@ -820,30 +418,21 @@ class GlossaryManager(GlossaryBrowser):
 
         """
 
-        validate_guid(glossary_guid)
-        if self.__validate_term_status__(body["initialStatus"]) is False:
-            raise InvalidParameterException("Bad status value")
-
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/terms/new-controlled"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms"
         )
+        return await self._async_create_element_body_request(url, "GlossaryTermProperties", body)
 
-        response = await self._async_make_request("POST", url, body)
-
-        return response.json().get("guid", "Term not created")
-
-    def create_controlled_glossary_term(self, glossary_guid: str, body: dict) -> str:
+    def create_glossary_term(self, body: dict | NewElementRequestBody) -> str:
         """Create a term for a controlled glossary.
             See also: https://egeria-project.org/types/3/0385-Controlled-Glossary-Development/?h=controlled
             The request body also supports the specification of an effective time for the query.
 
         Parameters
         ----------
-            glossary_guid : str
-                Unique identifier for the glossary category to retrieve terms from.
+
             body: dict
-                The dictionary to create te controlled glossary term for. Example below.
+                The dictionary to create glossary term for. Example below.
 
 
         Returns
@@ -863,20 +452,26 @@ class GlossaryManager(GlossaryBrowser):
         -----
 
         Sample body like:
-        {
-            "class" : "ReferenceableRequestBody",
-            "elementProperties" :
+         {
+            "class" : "NewElementRequestBody",
+            "parentGUID" : "Glossary GUID here",
+            "isOwnAnchor" : true,
+            "anchorScopeGUID" : "Glossary GUID here",
+            "parentRelationshipTypeName" : "ParentGlossary",
+            "parentAtEnd1": true,
+            "properties" :
                 {
                     "class" : "GlossaryTermProperties",
-                    "qualifiedName" : "GlossaryTerm: term name : {$isoTimestamp}",
+                    "qualifiedName" : "GlossaryTerm::term name",
                     "displayName" : "term name",
                     "aliases": []
                     "summary" : "This is the short description.",
                     "description" : "This is the long description of the term.",
-                    "abbreviation" : "GT",
+                    "abbreviation" : "aabrev",
                     "examples" : "Add examples and descriptions here.",
                     "usage" : "This is how the concept described by the glossary term is used.",
-                    "publishVersionIdentifier" : "V1.0",
+                    "versionIdentifier" : "V1.0",
+                    "category" : "A user defined category",
                     "additionalProperties" :
                     {
                        "propertyName1" : "xxxx",
@@ -889,19 +484,19 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_controlled_glossary_term(glossary_guid, body)
-        )
+            self._async_create_glossary_term(body)
+            )
 
         return response
 
     def load_terms_from_csv_file(
-        self,
-        glossary_name: str,
-        filename: str,
-        file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
-        upsert: bool = True,
-        verbose: bool = True,
-    ) -> List[dict] | None:
+            self,
+            glossary_name: str,
+            filename: str,
+            file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
+            upsert: bool = True,
+            verbose: bool = True,
+            ) -> List[dict] | None:
         """This method loads glossary terms into the specified glossary from the indicated file.
 
         Parameters
@@ -975,7 +570,7 @@ class GlossaryManager(GlossaryBrowser):
             "Usage",
             "Version Identifier",
             "Status",
-        }
+            }
 
         if file_path:
             full_file_path = os.path.join(file_path, filename)
@@ -985,7 +580,7 @@ class GlossaryManager(GlossaryBrowser):
         if not os.path.isfile(full_file_path):
             raise FileNotFoundError(
                 f"Did not find file with path {file_path} and name {filename}"
-            )
+                )
         # process file
         with open(full_file_path, mode="r") as file:
             # Create a CSV reader object
@@ -1007,8 +602,8 @@ class GlossaryManager(GlossaryBrowser):
                             "qualified_name": "---",
                             "term_guid": "---",
                             "error": "missing or invalid term names - skipping",
-                        }
-                    )
+                            }
+                        )
                     continue
                 qualified_name = row.get("Qualified Name", None)
                 abbrev_in = row.get("Abbreviation", None)
@@ -1035,8 +630,8 @@ class GlossaryManager(GlossaryBrowser):
                             "qualified_name": "---",
                             "term_guid": "---",
                             "error": "invalid term status",
-                        }
-                    )
+                            }
+                        )
                     continue
 
                 if upsert:
@@ -1045,7 +640,7 @@ class GlossaryManager(GlossaryBrowser):
                     if qualified_name:
                         term_stuff = self.get_terms_by_name(
                             qualified_name, glossary_guid
-                        )
+                            )
                         if type(term_stuff) is str:
                             # An existing term was not found with that qualified name
                             term_info.append(
@@ -1053,8 +648,8 @@ class GlossaryManager(GlossaryBrowser):
                                     "term_name": term_name,
                                     "qualified_name": qualified_name,
                                     "error": "Matching term not found - skipping",
-                                }
-                            )
+                                    }
+                                )
                             continue
                         elif len(term_stuff) > 1:
                             term_info.append(
@@ -1062,8 +657,8 @@ class GlossaryManager(GlossaryBrowser):
                                     "term_name": term_name,
                                     "qualified_name": qualified_name,
                                     "error": "Multiple matching terms - skipping",
-                                }
-                            )
+                                    }
+                                )
                             continue
                         else:
                             # An existing term was found - so update it! Get the existing values and overlay
@@ -1081,21 +676,21 @@ class GlossaryManager(GlossaryBrowser):
                                     "examples": examples,
                                     "usage": usage,
                                     "publishVersionIdentifier": version,
-                                },
+                                    },
                                 "updateDescription": "Update from file import via upsert",
-                            }
+                                }
                             term_guid = term_stuff[0]["elementHeader"]["guid"]
                             self.update_term(
                                 term_guid, body_slimmer(body), is_merge_update=True
-                            )
+                                )
                             term_info.append(
                                 {
                                     "term_name": term_name,
                                     "qualified_name": qualified_name,
                                     "term_guid": term_guid,
                                     "updated": "the term was updated",
-                                }
-                            )
+                                    }
+                                )
                             continue
 
                 # Add the term
@@ -1113,32 +708,32 @@ class GlossaryManager(GlossaryBrowser):
                         "examples": examples,
                         "usage": usage,
                         "publishVersionIdentifier": version,
-                    },
+                        },
                     "initialStatus": status,
-                }
+                    }
 
                 # Add the term
                 term_guid = self.create_controlled_glossary_term(
                     glossary_guid, body_slimmer(body)
-                )
+                    )
                 term_info.append(
                     {
                         "term_name": term_name,
                         "qualified_name": term_qualified_name,
                         "term_guid": term_guid,
-                    }
-                )
+                        }
+                    )
         if verbose:
             return term_info
         else:
             return
 
     async def _async_export_glossary_to_csv(
-        self,
-        glossary_guid: str,
-        target_file: str,
-        file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
-    ) -> int:
+            self,
+            glossary_guid: str,
+            target_file: str,
+            file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
+            ) -> int:
         """Export all the terms in a glossary to a CSV file. Async version
 
         Parameters:
@@ -1167,7 +762,7 @@ class GlossaryManager(GlossaryBrowser):
             "Usage",
             "Version Identifier",
             "Status",
-        ]
+            ]
         if file_path:
             full_file_path = os.path.join(file_path, target_file)
         else:
@@ -1187,7 +782,7 @@ class GlossaryManager(GlossaryBrowser):
                 usage = term["glossaryTermProperties"].get("usage", "---")
                 version = term["glossaryTermProperties"].get(
                     "publishVersionIdentifier", "---"
-                )
+                    )
                 status = term["elementHeader"]["status"]
 
                 csv_writer.writerow(
@@ -1201,18 +796,18 @@ class GlossaryManager(GlossaryBrowser):
                         "Usage": usage,
                         "Version Identifier": version,
                         "Status": status,
-                    }
-                )
+                        }
+                    )
 
                 count += 1
         return count
 
     def export_glossary_to_csv(
-        self,
-        glossary_guid: str,
-        target_file: str,
-        file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
-    ) -> int:
+            self,
+            glossary_guid: str,
+            target_file: str,
+            file_path: str = os.environ.get("EGERIA_GLOSSARY_PATH", None),
+            ) -> int:
         """Export all the terms in a glossary to a CSV file.
 
         Parameters:
@@ -1232,18 +827,19 @@ class GlossaryManager(GlossaryBrowser):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_export_glossary_to_csv(glossary_guid, target_file, file_path)
-        )
+            )
 
         return response
 
     async def _async_create_term_copy(
-        self,
-        glossary_guid: str,
-        glossary_term_guid: str,
-        new_display_name: str,
-        version_id: str,
-        term_status: str = "PROPOSED",
-    ) -> str:
+            self,
+            glossary_guid: str,
+            glossary_term_guid: str,
+            new_display_name: str,
+            version_id: str = None,
+            term_status: str = "PROPOSED",
+            body: dict | TemplateRequestBody = None,
+            ) -> str:
         """Create a new term from an existing term.
 
             Async Version.
@@ -1254,7 +850,7 @@ class GlossaryManager(GlossaryBrowser):
                 Unique identifier for the glossary category to retrieve terms from.
             glossary_term_guid: str
                 Unique identifier for the source glossary term.
-            new_display_named: str
+            new_display_name: str
                 The display name of the new term.
             version_id: str
                 The version identifier of the new term.
@@ -1280,37 +876,66 @@ class GlossaryManager(GlossaryBrowser):
 
         """
 
-        validate_guid(glossary_guid)
-        validate_guid(glossary_term_guid)
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
+
+        elif isinstance(body, dict):
+            validated_body = self._template_request_adapter.validate_python(body)
+        else:
+            qualified_name = self.__create_qualified_name__("Term", new_display_name, EGERIA_LOCAL_QUALIFIER)
+            body = {
+                "class" : "TemplateRequestBody",
+                "templateGUID": glossary_term_guid,
+                "replacementProperties": {
+                    "class": "ElementProperties",
+                    "propertyValueMap": {
+                        "qualifiedName": {
+                            "class": "PrimitiveTypePropertyValue",
+                            "typeName": "string",
+                            "primitiveValue": qualified_name,
+                            },
+
+                        "displayName": {
+                            "class": "PrimitiveTypePropertyValue",
+                            "typeName": "string",
+                            "primitiveValue": new_display_name,
+                            },
+
+                        # "publishVersionIdentifier": {
+                        #     "class": "PrimitiveTypePropertyValue",
+                        #     "typeName": "string",
+                        #     "primitiveValue": version_id,
+                        #     },
+
+                        }
+                    },
+                "initialStatus": term_status,
+                }
+            validated_body = self._template_request_adapter.validate_python(body)
+
+        v_body = body_slimmer(validated_body.model_dump(exclude_none=True))
+        logger.info(v_body)
+
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/terms/from-template/{glossary_term_guid}"
+            f"terms/from-template/{glossary_term_guid}"
         )
 
-        body = {
-            "class": "GlossaryTemplateRequestBody",
-            "elementProperties": {
-                "class": "TemplateProperties",
-                "qualifiedName": f"Term-{new_display_name}-{time.asctime()}",
-                "displayName": new_display_name,
-                "versionIdentifier": version_id,
-            },
-            "glossaryTermStatus": term_status,
-        }
-
-        response = await self._async_make_request("POST", url, body)
-
-        return response.json().get("guid", "Term not created")
+        resp = await self._async_make_request("POST", url, v_body)
+        guid = resp.json().get("guid", NO_GUID_RETURNED)
+        logger.info(f"Create Term from template with GUID: {guid}")
+        return guid
 
     def create_term_copy(
-        self,
-        glossary_guid: str,
-        glossary_term_guid: str,
-        new_display_name: str,
-        version_id: str,
-        term_status: str = "PROPOSED",
-    ) -> str:
+            self,
+            glossary_guid: str,
+            glossary_term_guid: str,
+            new_display_name: str,
+            version_id: str = None,
+            term_status: str = "PROPOSED",
+            body: dict | TemplateRequestBody = None,
+            ) -> str:
         """Create a new term from an existing term.
 
         Parameters
@@ -1319,7 +944,7 @@ class GlossaryManager(GlossaryBrowser):
                 Unique identifier for the glossary category to retrieve terms from.
             glossary_term_guid: str
                 Unique identifier for the source glossary term.
-            new_display_named: str
+            new_display_name: str
                 The display name of the new term.
             version_id: str
                 The version identifier of the new term.
@@ -1352,23 +977,26 @@ class GlossaryManager(GlossaryBrowser):
                 new_display_name,
                 version_id,
                 term_status,
+                body,
+                )
             )
-        )
 
         return response
 
-
-    async def _async_add_term_to_category(
-            self, glossary_term_guid: str, glossary_category_guid: str
+    async def _async_update_term(
+            self,
+            glossary_term_guid: str,
+            body: dict | UpdateElementRequestBody,
             ) -> None:
-        """Add the term to the specified category. Async Version.
+        """Update a term. Async version.
 
         Parameters
         ----------
-            glossary_term_guid : str
-                Unique identifier for the glossary term to assign.
-            glossary_category_guid: str
-                Unique identifier for the category the term will be assigned to.
+            glossary_term_guid: str
+                Unique identifier for the source glossary term.
+            body: dict
+                Body containing information about the data field to add
+
 
         Returns
         -------
@@ -1382,39 +1010,44 @@ class GlossaryManager(GlossaryBrowser):
              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
+        -----
 
         """
 
         validate_guid(glossary_term_guid)
-        validate_guid(glossary_category_guid)
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{glossary_category_guid}/terms/{glossary_term_guid}"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
+            f"{glossary_term_guid}/"
+            f"update"
         )
-        body = {
-            "class": "RelationshipRequestBody",
-            "properties": {
-                "class": "GlossaryTermCategorization"
-
-                }
-            }
+        await self._async_update_element_body_request(url, ["GlossaryTermProperties"], body)
+        logger.info(f"Updated digital subscription {glossary_term_guid}")
 
-        await self._async_make_request("POST", url, body)
+    def update_term(
+            self,
+            glossary_term_guid: str,
+            body: dict | UpdateElementRequestBody,
 
+            ) -> None:
+        """Add the data field values classification to a glossary term
 
-    def add_term_to_category(self, glossary_term_guid: str, glossary_category_guid: str) -> None:
-        """Add the term to the specified category.
+            Async Version.
 
         Parameters
         ----------
-            glossary_term_guid : str
-                Unique identifier for the glossary term to assign.
-            glossary_category_guid: str
-                Unique identifier for the category the term will be assigned to.
+            glossary_term_guid: str
+                Unique identifier for the source glossary term.
+            body: dict
+                Body containing information about the data field to add
+            is_merge_update: bool, optional, default = True
+                Whether the data field values should be merged with existing definition or replace it.
+
 
         Returns
         -------
+        None
 
         Raises
         ------
@@ -1424,24 +1057,48 @@ class GlossaryManager(GlossaryBrowser):
              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
+        -----
+        An example body is:
+
+        {
+            "class" : "ReferenceableRequestBody",
+            "elementProperties" :
+                {
+                    "class" : "GlossaryTermProperties",
+                    "description" : "This is the long description of the term. And this is some more text."
+                },
+                "updateDescription" : "Final updates based on in-house review comments."
+        }
 
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_term_to_category(glossary_term_guid, glossary_category_guid)
+            self._async_update_term(
+                glossary_term_guid,
+                body,
+                )
             )
 
-    async def _async_remove_term_from_category(
-            self, glossary_term_guid: str, glossary_category_guid: str
+
+
+
+    async def _async_delete_term(
+            self,
+            term_guid: str,
+            cascade: bool = False,
+            body: dict | DeleteRequestBody = None
             ) -> None:
-        """Remove the term from the specified category. Async Version.
+        """Delete the glossary terms associated with the specified glossary. Async version.
 
         Parameters
         ----------
-            glossary_term_guid : str
-                Unique identifier for the glossary term to assign.
-            glossary_category_guid: str
-                Unique identifier for the category the term will be assigned to.
+            term_guid : str,
+                The unique identifier for the term to delete.
+            for_lineage: bool, opt, default = False
+                Set true for lineage processing - generally false.
+            for_duplicate_processing: bool, opt, default = False
+                Set true if duplicate processing handled externally - generally set False.
 
         Returns
         -------
@@ -1455,31 +1112,74 @@ class GlossaryManager(GlossaryBrowser):
              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
+        -----
         """
 
-        validate_guid(glossary_term_guid)
-        validate_guid(glossary_category_guid)
+        validate_guid(term_guid)
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/{glossary_category_guid}/terms/{glossary_term_guid}/remove"
+            f"terms/{term_guid}/delete"
         )
-        await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body, cascade)
+        logger.info(f"Deleted collection {term_guid} with cascade {cascade}")
+
+
+    def delete_term(
+            self,
+            term_guid: str,
+            cascade: bool = False,
+            body: dict | DeleteRequestBody = None
+            ) -> None:
+        """Delete the glossary terms associated with the specified glossary.
+
+        Parameters
+        ----------
+            term_guid : str,
+                The unique identifier for the term to delete.
+            for_lineage: bool, opt, default = False
+                Set true for lineage processing - generally false.
+            for_duplicate_processing: bool, opt, default = False
+                Set true if duplicate processing handled externally - generally set False.
+
+        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_delete_term(term_guid, cascade, body)
+            )
 
-    def remove_term_from_category(self, glossary_term_guid: str, glossary_category_guid: str) -> None:
-        """Remove the term from the specified category.
+    async def _async_move_term(
+            self,
+            term_guid: str,
+            glossary_guid: str,
+            body: dict | DeleteRequestBody = None
+            ) -> None:
+        """Move the glossary terms to the specified glossary. Async version.
 
         Parameters
         ----------
-            glossary_term_guid : str
-                Unique identifier for the glossary term to assign.
-            glossary_category_guid: str
-                Unique identifier for the category the term will be assigned to.
+            term_guid : str,
+                The unique identifier for the term to delete.
+
 
         Returns
         -------
+        None
 
         Raises
         ------
@@ -1489,16 +1189,63 @@ class GlossaryManager(GlossaryBrowser):
              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
+        -----
+        """
+
+        validate_guid(term_guid)
+
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/move-to/{glossary_guid}"
+        )
+        await self._async_delete_request(url, body)
+        logger.info(f"Moved collection {term_guid} to glossary {glossary_guid}")
+
 
+    def move_term(
+            self,
+            term_guid: str,
+            glossary_guid: str,
+            body: dict | DeleteRequestBody = None
+            ) -> None:
+        """Move the glossary terms to the specified glossary.
+
+        Parameters
+        ----------
+            term_guid : str,
+                The unique identifier for the term to delete.
+
+
+        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_term_from_category(glossary_term_guid, glossary_category_guid)
+            self._async_move_term(term_guid, glossary_guid, body)
             )
 
-    async def _async_add_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict = None,
-            for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
+
+
+    #
+    #   To work with categories, use the collection manager
+    #
+
+    async def _async_add_is_abstract_concepts(
+            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            ) -> None:
         """Add a relationship between terms. Async Version.
 
         Parameters
@@ -1511,10 +1258,7 @@ class GlossaryManager(GlossaryBrowser):
             Type of relationship to add.
         body: dict, optional, default = None
             Further optional details for the relationship.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
+
 
         Returns
         -------
@@ -1534,16 +1278,11 @@ class GlossaryManager(GlossaryBrowser):
         Body is currently required but can be empty except for class. Basic structure is:
 
             {
-             "class" : "RelationshipRequestBody",
+             "class" : "NewClassificationRequestBody",
              "effectiveTime" : {{@isoTimestamp}},
              "properties" : {
                 "class" : "GlossaryTermRelationship",
-                "expression" : "",
-                "confidence"  : 0,
-                "description" : "",
-                "status"   : "",
-                "steward"  : "",
-                "source" : "",
+
                 "effectiveFrom" : "{{@isoTimestamp}}",
                 "effectiveTo" : "{{@isoTimestamp}}",
                 "extendedProperties" : {
@@ -1552,33 +1291,27 @@ class GlossaryManager(GlossaryBrowser):
         }
         """
 
-        validate_guid(term1_guid)
-        validate_guid(term2_guid)
-
-        if body is None:
-            body = {"class": "RelationshipRequestBody",
-                    "properties":
-                        {"class": "GlossaryTermRelationship",}
-                }
-
-        possible_query_params = query_string(
-            [
-                ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing),
-                ]
-            )
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}{possible_query_params}"
+            f"terms/{term_guid}/is-abstract-concept"
         )
+        if body is None:
+            body = {
+                "class": "NewClassificationRequestBody",
+                "properties":
+                    {
+                        "class": "AbstractConceptProperties"
+                    }
+                }
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_new_classification_request(url, "AbstractConceptProperties",body)
+        logger.info(f"Added AbstractConcept classification to {term_guid}")
 
 
-    def add_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict = None,
-            for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
+
+    def add_is_abstract_concept(
+            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            ) -> None:
         """Add a relationship between terms.
 
         Parameters
@@ -1591,10 +1324,6 @@ class GlossaryManager(GlossaryBrowser):
             Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
         body: dict, optional, default = None
             Further optional details for the relationship.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
 
         Returns
         -------
@@ -1614,7 +1343,7 @@ class GlossaryManager(GlossaryBrowser):
         Body is currently required but can be empty except for class. Basic structure is:
 
         {
-         "class" : "RelationshipRequestBody",
+         "class" : "NewRelationshipRequestBody",
          "effectiveTime" : {{@isoTimestamp}},
          "properties" : {
             "class" : "GlossaryTermRelationship",
@@ -1633,16 +1362,13 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_add_relationship_between_terms(term1_guid, term2_guid, relationship_type,
-                                                       body, for_lineage, for_duplicate_processing)
+            self._async_add_is_abstract_concepts(term_guid, body)
             )
 
-
-    async def _async_update_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict = None,
-        for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
-
-        """Update a relationship between terms. Async Version.
+    async def _async_remove_is_abstract_concepts(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
@@ -1651,13 +1377,10 @@ class GlossaryManager(GlossaryBrowser):
         term2_guid : str
             Unique identifier of the second glossary term in relationship.
         relationship_type: str
-            Type of relationship to update.
+            Type of relationship to add.
         body: dict, optional, default = None
             Further optional details for the relationship.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
+
 
         Returns
         -------
@@ -1677,49 +1400,30 @@ class GlossaryManager(GlossaryBrowser):
         Body is currently required but can be empty except for class. Basic structure is:
 
             {
-         "class" : "RelationshipRequestBody",
-         "effectiveTime" : {{@isoTimestamp}},
-         "properties" : {
-            "class" : "GlossaryTermRelationship",
-            "expression" : "",
-            "confidence"  : 0,
-            "description" : "",
-            "status"   : "",
-            "steward"  : "",
-            "source" : "",
-            "effectiveFrom" : "{{@isoTimestamp}}",
-            "effectiveTo" : "{{@isoTimestamp}}",
-            "extendedProperties" : {
-            }
-         }
-        }
-        """
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
-        validate_guid(term1_guid)
-        validate_guid(term2_guid)
-
-        possible_query_params = query_string(
-            [
-                ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing),
-                ]
-            )
-
-        if body is None:
-            body = {"properties": {"class": "RelationshipRequestBody"}}
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}/update{possible_query_params}"
+            f"terms/{term_guid}/is-abstract-concept/remove"
         )
+        await self._async_delete_request(url, body)
+        logger.info(f"Removed AbstractConcept classification to {term_guid}")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
-
-
-    def update_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict,
-            for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
-        """Update a relationship between terms.
+    def remove_is_abstract_concept(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
@@ -1728,13 +1432,9 @@ class GlossaryManager(GlossaryBrowser):
         term2_guid : str
             Unique identifier of the second glossary term in relationship.
         relationship_type: str
-            Type of relationship to update. A list of relationship types can be found using get_term_relationship_types().
-        body: dict
-            Details of the relationship to update.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -1753,8 +1453,8 @@ class GlossaryManager(GlossaryBrowser):
         ----
         Body is currently required but can be empty except for class. Basic structure is:
 
-            {
-         "class" : "RelationshipRequestBody",
+        {
+         "class" : "NewRelationshipRequestBody",
          "effectiveTime" : {{@isoTimestamp}},
          "properties" : {
             "class" : "GlossaryTermRelationship",
@@ -1773,14 +1473,14 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_relationship_between_terms(term1_guid, term2_guid, relationship_type,
-                                                          body,for_lineage,for_duplicate_processing)
+            self._async_remove_is_abstract_concepts(term_guid, body)
             )
 
-    async def _async_remove_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, effective_time: str = None,
-            for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
-        """Remove a relationship between terms. Async Version.
+
+    async def _async_add_is_context_definition(
+            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
@@ -1790,12 +1490,9 @@ class GlossaryManager(GlossaryBrowser):
             Unique identifier of the second glossary term in relationship.
         relationship_type: str
             Type of relationship to add.
-        effective_time: str, optional, default = None
-            Effective time to remove the relationship.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
+        body: dict, optional, default = None
+            Further optional details for the relationship.
+
 
         Returns
         -------
@@ -1810,37 +1507,46 @@ class GlossaryManager(GlossaryBrowser):
          NotAuthorizedException
              The principle specified by the user_id does not have authorization for the requested action.
 
+        Notes
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
-        """
-
-        validate_guid(term1_guid)
-        validate_guid(term2_guid)
-
-        possible_query_params = query_string(
-            [
-                ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing),
-                ]
-            )
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
-        body = {"properties": {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time
-            }
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
         }
+        """
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}/remove{possible_query_params}"
+            f"terms/{term_guid}/is-context-definition"
         )
+        if body is None:
+            body = {
+                "class": "NewClassificationRequestBody",
+                "properties":
+                    {
+                        "class": "ContextDefinitionProperties"
+                    }
+                }
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_new_classification_request(url, "ContextDefinitionProperties",body)
+        logger.info(f"Added AbstractConcept classification to {term_guid}")
 
 
-    def remove_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str,  effective_time: str = None,
-            for_lineage: bool = False, for_duplicate_processing: bool = False) -> None:
-        """Remove a relationship between terms.
+
+    def add_is_context_definition(
+            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
@@ -1849,13 +1555,9 @@ class GlossaryManager(GlossaryBrowser):
         term2_guid : str
             Unique identifier of the second glossary term in relationship.
         relationship_type: str
-            Type of relationship to remove. A list of relationship types can be found using get_term_relationship_types().
-        effective_time: str, optional, default = None
-            Effective time to remove the relationship.
-        for_lineage: bool, default is set by server
-            - determines if elements classified as Memento should be returned - normally false
-        for_duplicate_processing: bool, default is set by server
-            - Normally false. Set true when the caller is part of a deduplication function
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -1870,30 +1572,48 @@ class GlossaryManager(GlossaryBrowser):
          NotAuthorizedException
              The principle specified by the user_id does not have authorization for the requested action.
 
+        Notes
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
+
+        {
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_remove_relationship_between_terms(term1_guid, term2_guid, relationship_type,
-                                                          effective_time, for_lineage, for_duplicate_processing)
+            self._async_add_is_context_definition(term_guid, body)
             )
 
-
-
-    async def _async_add_confidentiality_to_term(
-        self,
-        glossary_term_guid: str,
-        confidentiality_level: int,
-    ) -> None:
-        """Add the confidentiality classification to a glossary term
-
-            Async Version.
+    async def _async_remove_is_context_definition(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            confidentiality_level: int
-                The level of confidentiality to classify the term with.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
 
         Returns
@@ -1908,45 +1628,47 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        See https://egeria-project.org/types/4/0421-Governance-Classification-Levels/?h=confidential#governance-classification-levels
-        for a list of default confidentiality levels.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
-        """
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
-        validate_guid(glossary_term_guid)
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/elements/"
-            f"{glossary_term_guid}/confidentiality"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/is-context-definition/remove"
         )
+        await self._async_delete_request(url, body)
+        logger.info(f"Removed ContextDefinition classification to {term_guid}")
 
-        body = {
-            "class": "ClassificationRequestBody",
-            "properties": {
-                "class": "GovernanceClassificationProperties",
-                "levelIdentifier": confidentiality_level,
-            },
-        }
-
-        await self._async_make_request("POST", url, body)
-        return
-
-    def add_confidentiality_to_term(
-        self,
-        glossary_term_guid: str,
-        confidentiality_level: int,
-    ) -> str:
-        """Add the confidentiality classification to a glossary term
+    def remove_is_context_definition(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            confidentiality_level: int
-                The level of confidentiality to classify the term with.
-
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -1960,34 +1682,50 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        See https://egeria-project.org/types/4/0421-Governance-Classification-Levels/?h=confidential#governance-classification-levels
-        for a list of default confidentiality levels.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
+        {
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_add_confidentiality_to_term(
-                glossary_term_guid, confidentiality_level
+        loop.run_until_complete(
+            self._async_remove_is_context_definition(term_guid, body)
             )
-        )
-
-        return
 
-    async def _async_add_subject_area_to_term(
-        self, glossary_term_guid: str, subject_area: str
-    ) -> None:
-        """Add the confidentiality classification to a glossary term
 
-            Async Version.
+    async def _async_add_is_data_value(
+            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            subject_area: str
-                The subject area to classify the term with.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
 
         Returns
@@ -2002,43 +1740,58 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        See https://egeria-project.org/types/4/0421-Governance-Classification-Levels/?h=confidential#governance-classification-levels
-        for a list of default confidentiality levels.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
-        """
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
-        validate_guid(glossary_term_guid)
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/elements/"
-            f"{glossary_term_guid}/subject-area-member"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/is-data-value"
         )
+        if body is None:
+            body = {
+                "class": "NewClassificationRequestBody",
+                "properties":
+                    {
+                        "class": "DataValueProperties"
+                    }
+                }
 
-        body = {
-            "class": "ClassificationRequestBody",
-            "properties": {
-                "class": "SubjectAreaMemberProperties",
-                "subjectAreaName": subject_area,
-            },
-        }
+        await self._async_new_classification_request(url, "DataValueProperties",body)
+        logger.info(f"Added DataValue classification to {term_guid}")
 
-        await self._async_make_request("POST", url, body)
-        return
 
-    def add_subject_area_to_term(
-        self, glossary_term_guid: str, subject_area: str
-    ) -> None:
-        """Add the confidentiality classification to a glossary term
+
+    def add_is_data_value(
+            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            subject_area: str
-                The subject area to classify the term with.
-
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -2052,39 +1805,49 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        See https://egeria-project.org/types/4/0421-Governance-Classification-Levels/?h=confidential#governance-classification-levels
-        for a list of default confidentiality levels.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
+        {
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_add_subject_area_to_term(glossary_term_guid, subject_area)
-        )
-
-        return
+        loop.run_until_complete(
+            self._async_add_is_data_value(term_guid, body)
+            )
 
-    async def _async_update_term(
-        self,
-        glossary_term_guid: str,
-        body: dict,
-        is_merge_update: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processig: bool = False,
-    ) -> None:
-        """Add the data field values classification to a glossary term
-
-            Async Version.
+    async def _async_remove_is_data_value(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            body: dict
-                Body containing information about the data field to add
-            is_merge_update: bool, optional, default = True
-                Whether the data field values should be merged with existing definition or replace it.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
 
         Returns
@@ -2099,56 +1862,170 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        An example body is:
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
+
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
+
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
+
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/is-data-value/remove"
+        )
+        await self._async_delete_request(url, body)
+        logger.info(f"Removed DataValue classification to {term_guid}")
+
+    def remove_is_data_value(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
+
+        Parameters
+        ----------
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
+
+        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
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
         {
-            "class" : "ReferenceableRequestBody",
-            "elementProperties" :
-                {
-                    "class" : "GlossaryTermProperties",
-                    "description" : "This is the long description of the term. And this is some more text."
-                },
-                "updateDescription" : "Final updates based on in-house review comments."
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
         }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_remove_is_data_value(term_guid, body)
+            )
+        
+        
+    async def _async_add_activity_description(
+            self, term_guid: str, activity_type: int = None, body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
+
+        Parameters
+        ----------
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
+
+
+        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
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
+
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
         """
 
-        validate_guid(glossary_term_guid)
-        is_merge_update_s = str(is_merge_update).lower()
-        for_lineage_s = str(for_lineage).lower()
-        for_duplicate_processing_s = str(for_duplicate_processig).lower()
+        if body is None:
+            body = {
+                "class": "NewClassificationRequestBody",
+                "properties": {
+                    "class": "ActivityDescriptionProperties",
+                    "type": activity_type,
+                    }
+                }
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/{glossary_term_guid}/"
-            f"update?isMergeUpdate={is_merge_update_s}&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/is-activity"
         )
+        await self._async_new_classification_request(url, "ActivityDescriptionProperties",body)
+        logger.info(f"Added DataValue classification to {term_guid}")
 
-        await self._async_make_request("POST", url, body)
-        return
 
-    def update_term(
-        self,
-        glossary_term_guid: str,
-        body: dict,
-        is_merge_update: bool = True,
-        for_lineage: bool = False,
-        for_duplicate_processig: bool = False,
-    ) -> None:
-        """Add the data field values classification to a glossary term
 
-            Async Version.
+    def add_activity_description(
+            self, term_guid: str,  activity_type: int = None, body: dict | NewClassificationRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            body: dict
-                Body containing information about the data field to add
-            is_merge_update: bool, optional, default = True
-                Whether the data field values should be merged with existing definition or replace it.
-
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -2162,49 +2039,49 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        An example body is:
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
         {
-            "class" : "ReferenceableRequestBody",
-            "elementProperties" :
-                {
-                    "class" : "GlossaryTermProperties",
-                    "description" : "This is the long description of the term. And this is some more text."
-                },
-                "updateDescription" : "Final updates based on in-house review comments."
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
         }
-
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_term(
-                glossary_term_guid,
-                body,
-                is_merge_update,
-                for_lineage,
-                for_duplicate_processig,
+            self._async_add_activity_description(term_guid, activity_type, body)
             )
-        )
 
-        return
-
-    async def _async_update_term_version_id(
-        self,
-        glossary_term_guid: str,
-        new_version_identifier: str,
-    ) -> None:
-        """Update a glossary term's version identifier
-
-            Async Version.
+    async def _async_remove_activity_description(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            new_version_identifier: str
-                The new version identifier to update the term with.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
 
         Returns
@@ -2219,45 +2096,47 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        This is a useful example of a term update, specifying a new version identifier.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
-        """
+            {
+             "class" : "NewClassificationRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
 
-        validate_guid(glossary_term_guid)
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/terms/{glossary_term_guid}/"
-            f"update?isMergeUpdate=true"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term_guid}/is-activity/remove"
         )
+        await self._async_delete_request(url, body)
+        logger.info(f"Removed ActivityDescription classification to {term_guid}")
 
-        body = {
-            "class": "ReferenceableRequestBody",
-            "elementProperties": {
-                "class": "GlossaryTermProperties",
-                "publishVersionIdentifier": new_version_identifier,
-            },
-        }
-        await self._async_make_request("POST", url, body)
-        return
-
-    def update_term_version_id(
-        self,
-        glossary_term_guid: str,
-        new_version_identifier: str,
-    ) -> None:
-        """Update a glossary term's version identifier
-
-            Async Version.
+    def remove_activity_description(
+            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            new_version_identifier: str
-                The new version identifier to update the term with.
-
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -2271,27 +2150,54 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        This is a useful example of a term update, specifying a new version identifier.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
+        {
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_term_version_id(
-                glossary_term_guid, new_version_identifier
+            self._async_remove_activity_description(term_guid, body)
             )
-        )
 
-    async def _async_undo_term_update(self, glossary_term_guid: str) -> None:
-        """Undo an update to a glossary term
+    #
+    #   Term - Term Relationships
+    #
 
-            Async Version.
+    async def _async_add_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms. Async Version.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
+
 
         Returns
         -------
@@ -2305,28 +2211,64 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        This creates a new version with the state of the term before the last update.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
+            {
+             "class" : "NewRelationshipRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
+                "expression" : "",
+                "confidence"  : 0,
+                "description" : "",
+                "status"   : "",
+                "steward"  : "",
+                "source" : "",
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
         """
 
-        validate_guid(glossary_term_guid)
+        validate_guid(term1_guid)
+        validate_guid(term2_guid)
+
+        if body is None:
+            body = {
+                "class": "RelationshipRequestBody",
+                "properties":
+                    {"class": "GlossaryTermRelationship", }
+                }
+
+
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
-            f"{glossary_term_guid}/undo"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}"
         )
+        await self._async_new_relationship_request(url, ["GlossaryTermRelationship"],body)
+        logger.info(f"Added relationship between {term1_guid} and {term2_guid} of type {relationship_type}")
 
-        await self._async_make_request("POST", url)
-
-    def undo_term_update(self, glossary_term_guid: str) -> None:
-        """Undo an update to a glossary term
+    def add_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Add a relationship between terms.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add. A list of relationship types can be found using get_term_relationship_types().
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -2340,32 +2282,51 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
-        This creates a new version with the state of the term before the last update.
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
+        {
+         "class" : "NewRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_undo_term_update(glossary_term_guid))
-
+        loop.run_until_complete(
+            self._async_add_relationship_between_terms(term1_guid, term2_guid, relationship_type,
+                                                       body)
+            )
 
+    async def _async_update_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | UpdateRelationshipRequestBody = None
+            ) -> None:
 
-    async def _async_delete_term(
-        self,
-        term_guid: str,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> list | str:
-        """Delete the glossary terms associated with the specified glossary. Async version.
+        """Update a relationship between terms. Async Version.
 
         Parameters
         ----------
-            term_guid : str,
-                The unique identifier for the term to delete.
-            for_lineage: bool, opt, default = False
-                Set true for lineage processing - generally false.
-            for_duplicate_processing: bool, opt, default = False
-                Set true if duplicate processing handled externally - generally set False.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to update.
+        body: dict, optional, default = None
+            Further optional details for the relationship.
 
         Returns
         -------
@@ -2379,36 +2340,58 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
+
+            {
+         "class" : "UpdateRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
 
-        validate_guid(term_guid)
+        validate_guid(term1_guid)
+        validate_guid(term2_guid)
+
+
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"terms/{term_guid}/remove?forLineage={for_lineage}&forDuplicateProcessing={for_duplicate_processing}"
-        )
+            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}/update")
 
-        await self._async_make_request("POST", url)
-        return
+        await self._async_update_relationship_request(url, "GlossaryTermRelationship", body)
+        logger.info(f"Updated relationship between {term1_guid} and {term2_guid} of type {relationship_type}")
 
-    def delete_term(
-        self,
-        term_guid: str,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> list | str:
-        """Delete the glossary terms associated with the specified glossary.
+    def update_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | UpdateRelationshipRequestBody = None
+            ) -> None:
+        """Update a relationship between terms.
 
         Parameters
         ----------
-            term_guid : str,
-                The unique identifier for the term to delete.
-            for_lineage: bool, opt, default = False
-                Set true for lineage processing - generally false.
-            for_duplicate_processing: bool, opt, default = False
-                Set true if duplicate processing handled externally - generally set False.
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to update. A list of relationship types can be found using
+            get_term_relationship_types().
+        body: dict
+            Details of the relationship to update.
 
         Returns
         -------
@@ -2422,18 +2405,117 @@ class GlossaryManager(GlossaryBrowser):
              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
-        -----
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
+
+            {
+         "class" : "UpdateRelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_delete_term(term_guid, for_lineage, for_duplicate_processing)
+            self._async_update_relationship_between_terms(term1_guid, term2_guid, relationship_type,
+                                                          body)
+            )
+
+    async def _async_remove_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | DeleteRequestBody = None,
+            ) -> None:
+        """Remove a relationship between terms. Async Version.
+
+        Parameters
+        ----------
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to add.
+        effective_time: str, optional, default = None
+            Effective time to remove the relationship.
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+
+        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.
+
+
+        """
+
+        validate_guid(term1_guid)
+        validate_guid(term2_guid)
+
+
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
+            f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}/remove"
         )
 
-        return
+        await self._async_delete_request(url, body)
 
-    async def _async_relate_terms(self, term1_guid: str, term2_guid: str, relationship: str) -> None:
-        pass
+    def remove_relationship_between_terms(
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | DeleteRequestBody = None) -> None:
+
+        """Remove a relationship between terms.
+
+        Parameters
+        ----------
+        term1_guid : str
+            Unique identifier of the first glossary term in relationship.
+        term2_guid : str
+            Unique identifier of the second glossary term in relationship.
+        relationship_type: str
+            Type of relationship to remove. A list of relationship types can be found using
+            get_term_relationship_types().
+
+
+        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.
+
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_remove_relationship_between_terms(term1_guid, term2_guid, relationship_type,
+                                                          body)
+            )
 
 
 if __name__ == "__main__":