pyegeria 5.2.1__py3-none-any.whl → 5.3__py3-none-any.whl

pyegeria/glossary_manager_omvs.py

@@ -6,25 +6,42 @@ This module contains an initial version of the glossary_manager omvs module. The
 added in subsequent versions of the glossary_omvs module.
 
 """
+
 import asyncio
+import csv
 import os
 import time
-import csv
 from datetime import datetime
 from typing import List
 
-from pyegeria import InvalidParameterException
-
-# import json
 from pyegeria._client import Client
-from pyegeria._validators import (
-    validate_name,
-    validate_guid,
-    validate_search_string,
-)
+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.utils import body_slimmer
 
+def query_seperator(current_string):
+    if current_string == "":
+        return "?"
+    else:
+        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"
+
+
+def query_string(params):
+    result = ""
+    for i in range(len(params)):
+        if params[i][1] is not None:
+            result = f"{result}{query_seperator(result)}{params[i][0]}={params[i][1]}"
+    return result
+
+
+def base_path(client, view_server: str):
+    return f"{client.platform_url}/servers/{view_server}/api/open-metadata/classification-manager"
+
 
 class GlossaryManager(GlossaryBrowser):
     """
@@ -104,7 +121,7 @@ class GlossaryManager(GlossaryBrowser):
             "class": "ReferenceableRequestBody",
             "elementProperties": {
                 "class": "GlossaryProperties",
-                "qualifiedName": f"Glossary:{display_name}",
+                "qualifiedName": self.__create_qualified_name__("Glossary", display_name),
                 "displayName": display_name,
                 "description": description,
                 "language": language,
@@ -147,36 +164,38 @@ class GlossaryManager(GlossaryBrowser):
         )
         return response
 
-    async def _async_delete_glossary(self, glossary_guid: str) -> None:
+    async def _async_delete_glossary(self, glossary_guid: str, cascade:bool = False) -> None:
         """Delete glossary. Async version.
 
         Parameters
         ----------
         glossary_guid: str
             The ID of the glossary to delete.
-
+        cascade: bool, optional, default = False
+            If true, then delete all terms and categories in the glossary as well.
 
         Returns
         -------
         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"
+            f"{glossary_guid}/remove?cascadedDelete={cascade_str}"
         )
 
         await self._async_make_request("POST", url)
-        return
 
-    def delete_glossary(self, glossary_guid: str) -> None:
-        """Create a new glossary.
+    def delete_glossary(self, glossary_guid: str, cascade: bool = False) -> None:
+        """Delete a new glossary.
 
         Parameters
         ----------
         glossary_guid: str
             The ID of the glossary to delete.
+        cascade: bool, optional, default = False
+            If true, then delete all terms and categories in the glossary as well.
 
 
         Returns
@@ -185,8 +204,7 @@ class GlossaryManager(GlossaryBrowser):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_delete_glossary(glossary_guid))
-        return response
+        loop.run_until_complete(self._async_delete_glossary(glossary_guid, cascade))
 
     async def _async_update_glossary(
         self,
@@ -243,7 +261,6 @@ class GlossaryManager(GlossaryBrowser):
         )
 
         await self._async_make_request("POST", url, body_slimmer(body))
-        return
 
     def update_glossary(
         self,
@@ -300,210 +317,41 @@ class GlossaryManager(GlossaryBrowser):
                 for_duplicate_processing,
             )
         )
-        return
 
     #
     #       Glossaries
     #
 
-    async def _async_find_glossaries(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        type_name: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary metadata elements that contain the search string. Async version.
-            The search string is located in the request body and is interpreted as a plain string.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-
-        Parameters
-        ----------
-        search_string: str,
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-        for_lineage : bool, [default=False], optional
-
-        for_duplicate_processing : bool, [default=False], optional
-        type_name: str, [default=None], optional
-            An optional parameter indicating the subtype of the glossary to filter by.
-            Values include 'ControlledGlossary', 'EditingGlossary', and 'StagingGlossary'
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of glossary definitions active in the server.
-
-        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
-
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-        for_lineage_s = str(for_lineage).lower()
-        for_duplicate_processing_s = str(for_duplicate_processing).lower()
-
-        validate_search_string(search_string)
-
-        if search_string == "*":
-            search_string = None
-
-        body = {
-            "class": "SearchStringRequestBody",
-            "searchString": search_string,
-            "effectiveTime": effective_time,
-            "typeName": type_name,
-        }
-        body = body_slimmer(body)
-        # print(f"\n\nBody is: \n{body}")
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-            f"forDuplicateProcessing={for_duplicate_processing_s}"
-        )
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("elementList", "No Glossaries found")
-
-    def find_glossaries(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        type_name: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary metadata elements that contain the search string.
-                The search string is located in the request body and is interpreted as a plain string.
-                The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-
-        Parameters
-        ----------
-        search_string: str,
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-        for_lineage : bool, [default=False], optional
-             Indicates the search is for lineage.
-        for_duplicate_processing : bool, [default=False], optional
-        type_name: str, [default=None], optional
-            An optional parameter indicating the subtype of the glossary to filter by.
-            Values include 'ControlledGlossary', 'EditingGlossary', and 'StagingGlossary'
-         start_from: int, [default=0], optional
-             When multiple pages of results are available, the page number to start from.
-         page_size: int, [default=None]
-             The number of items to return in a single page. If not specified, the default will be taken from
-             the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of glossary definitions active in the server.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_find_glossaries(
-                search_string,
-                effective_time,
-                starts_with,
-                ends_with,
-                ignore_case,
-                for_lineage,
-                for_duplicate_processing,
-                type_name,
-                start_from,
-                page_size,
-            )
-        )
 
-        return response
 
-    async def _async_get_glossaries_by_name(
+    #
+    # Glossary Categories
+    #
+    async def _async_create_category(
         self,
-        glossary_name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> dict | str:
-        """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
-            There are no wildcards supported on this request.
+        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_name: str,
-            Name of the glossary to be retrieved
-        effective_time: datetime, [default=None], optional
-            Effective time of the query. If not specified will default to any effective time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        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?
 
-        start_from: int, [default=0], optional
-             When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
 
         Returns
         -------
-        None
+        A string with the GUID of the new category..
 
         Raises
         ------
@@ -519,52 +367,49 @@ class GlossaryManager(GlossaryBrowser):
           invalid or make the new call invalid.
         """
 
-        if page_size is None:
-            page_size = self.page_size
-        validate_name(glossary_name)
-
-        if effective_time is None:
-            body = {"name": glossary_name}
-        else:
-            body = {"name": glossary_name, "effectiveTime": effective_time}
-
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
+            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("elementList", "No glossaries found")
+        return response.json().get("guid", None)
 
-    def get_glossaries_by_name(
+    def create_category(
         self,
-        glossary_name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> dict | str:
-        """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
-            There are no wildcards supported on this request.
+        glossary_guid: str,
+        display_name: str,
+        description: str,
+        is_root_category: bool = False,
+    ) -> str:
+        """Create a new category within the specified glossary.
 
         Parameters
         ----------
-        glossary_name: str,
-            Name of the glossary to be retrieved
-        effective_time: datetime, [default=None], optional
-            Effective time of the query. If not specified will default to any effective time.
-
-        start_from: int, [default=0], optional
-            When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            he class instance.
+        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
         -------
-        None
+        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
@@ -577,36 +422,43 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossaries_by_name(
-                glossary_name, effective_time, start_from, page_size
-            )
+            self._async_create_category(glossary_guid, display_name, description, is_root_category)
         )
         return response
 
-    #
-    # Glossary Categories
-    #
-    async def _async_create_category(
+    async def _async_update_category(
         self,
-        glossary_guid: str,
+        category_guid: str,
         display_name: str,
         description: str,
-    ) -> 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
         ----------
-        glossary_guid: str,
+        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
         -------
-        A string with the GUID of the new category..
+        None
 
         Raises
         ------
@@ -621,28 +473,35 @@ class GlossaryManager(GlossaryBrowser):
           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"{glossary_guid}/categories"
+            f"categories/{category_guid}/update?isMergeUpdate={is_merge_update}"
         )
         body = {
-            "class": "ReferenceableRequestBody",
+            "class": "ReferenceableUpdateRequestBody",
+            "effectiveTime": effective_time,
+            "updateDescription": update_description,
             "elementProperties": {
                 "class": "GlossaryCategoryProperties",
-                "qualifiedName": f"GlossaryCategory-{display_name}-{time.asctime()}",
+                "qualifiedName": qualified_name ,
                 "displayName": display_name,
-                "description": description,
+                "description": description
             },
         }
-        response = await self._async_make_request("POST", url, body)
+        response = await self._async_make_request("POST", url, body_slimmer(body))
         return response.json().get("guid", None)
 
-    def create_category(
+    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.
 
@@ -654,11 +513,19 @@ class GlossaryManager(GlossaryBrowser):
             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
         -------
-        A string with the GUID of the new category..
+        None
 
         Raises
         ------
@@ -675,30 +542,26 @@ class GlossaryManager(GlossaryBrowser):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_create_category(glossary_guid, display_name, description)
+            self._async_update_category(glossary_guid, display_name, description,
+                                        qualified_name, effective_time, update_description, is_merge_update)
         )
         return response
 
-    async def _async_get_glossary_for_category(
+
+    async def _async_delete_category(
         self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
-        """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
-        specify that the glossary element should only be returned if it was effective at a particular time.
+        category_guid: str,
+    ) -> None:
+        """Delete a category. Async Version.
 
         Parameters
         ----------
-        glossary_category_guid: str,
-            Unique identifier for the glossary category.
-        effective_time: datetime, [default=None], optional
-            Effective time of the query. If not specified will default to any effective time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
+        category_guid: str,
+            Unique identifier for the category.
 
         Returns
         -------
-        A dict structure with the glossary metadata element for the requested category.
+        None
 
         Raises
         ------
@@ -714,39 +577,28 @@ class GlossaryManager(GlossaryBrowser):
           invalid or make the new call invalid.
         """
 
-        body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"for-category/{glossary_category_guid}/retrieve"
+            f"categories/{category_guid}/remove"
         )
 
-        response = await self._async_make_request("POST", url, body)
-        return response.json()
+        await self._async_make_request("POST", url)
+
 
-    def get_glossary_for_category(
+    def delete_category(
         self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
-        """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
-        specify that the glossary element should only be returned if it was effective at a particular time.
+        category_guid: str,
+    ) -> None:
+        """Delete a category.
 
         Parameters
         ----------
-        glossary_category_guid: str,
-            Unique identifier for the glossary category.
-        effective_time: datetime, [default=None], optional
-            Effective time of the query. If not specified will default to any effective time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
+        category_guid: str,
+            Unique identifier for the category.
 
         Returns
         -------
-        A dict structure with the glossary metadata element for the requested category.
+        None
 
         Raises
         ------
@@ -762,53 +614,25 @@ class GlossaryManager(GlossaryBrowser):
           invalid or make the new call invalid.
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_glossary_for_category(
-                glossary_category_guid, effective_time
-            )
+        loop.run_until_complete(
+            self._async_delete_category(category_guid)
         )
-        return response
 
-    async def _async_find_glossary_categories(
+    async def _async_set_parent_category(
         self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary category metadata elements that contain the search string.
-            The search string is located in the request body and is interpreted as a plain string.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-            Async version.
+        parent_category_guid: str, child_category_guid: str) -> None:
+        """Set parent category Async Version.
 
         Parameters
         ----------
-        search_string: str,
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
+        parent_category_guid: str,
+            Unique identifier for the parent category.
+        child_category_guid: str,
+            Unique identifier for the child category.
+
         Returns
         -------
-        List | str
-
-        A list of glossary definitions active in the server.
+        None
 
         Raises
         ------
@@ -819,75 +643,31 @@ 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
-
+        ConfigurationErrorException
+          Raised when configuration parameters passed on earlier calls turn out to be
+          invalid or make the new call invalid.
         """
 
-        if page_size is None:
-            page_size = self.page_size
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-
-        validate_search_string(search_string)
-
-        if search_string == "*":
-            search_string = None
-
-        body = {
-            "class": "SearchStringRequestBody",
-            "searchString": search_string,
-            "effectiveTime": effective_time,
-        }
-        body = body_slimmer(body)
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"categories/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"categories/{parent_category_guid}/subcategories/{child_category_guid}"
         )
 
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("elementList", "No Categories found")
+        await self._async_make_request("POST", url)
 
-    def find_glossary_categories(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary category metadata elements that contain the search string.
-         The search string is located in the request body and is interpreted as a plain string.
-         The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+    def set_parent_category(self, parent_category_guid: str, child_category_guid: str) -> None:
+        """Set parent category
 
         Parameters
         ----------
-        search_string: str,
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. Time format is
-            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-         start_from: int, [default=0], optional
-             When multiple pages of results are available, the page number to start from.
-         page_size: int, [default=None]
-             The number of items to return in a single page. If not specified, the default will be taken from
-             the class instance.
+        parent_category_guid: str,
+            Unique identifier for the parent category.
+        child_category_guid: str,
+            Unique identifier for the child category.
+
         Returns
         -------
-        List | str
-
-        A list of glossary definitions active in the server.
+        None
 
         Raises
         ------
@@ -898,47 +678,31 @@ 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
-
+        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_find_glossary_categories(
-                search_string,
-                effective_time,
-                starts_with,
-                ends_with,
-                ignore_case,
-                start_from,
-                page_size,
-            )
+        loop.run_until_complete(
+            self._async_set_parent_category(parent_category_guid,child_category_guid)
         )
 
-        return response
-
-    async def _async_get_categories_for_glossary(
-        self,
-        glossary_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Return the list of categories associated with a glossary.
-            Async version.
+    async def _async_remove_parent_category(
+            self,
+            parent_category_guid: str, child_category_guid: str) -> None:
+        """Remove parent category relationship. Async Version.
 
         Parameters
         ----------
-        glossary_guid: str,
-            Unique identity of the glossary
+        parent_category_guid: str,
+            Unique identifier for the parent category.
+        child_category_guid: str,
+            Unique identifier for the child category.
 
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
         Returns
         -------
-        List | str
-
-        A list of categories associated with a glossary.
+        None
 
         Raises
         ------
@@ -949,43 +713,31 @@ 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
-
+        ConfigurationErrorException
+          Raised when configuration parameters passed on earlier calls turn out to be
+          invalid or make the new call invalid.
         """
 
-        if page_size is None:
-            page_size = self.page_size
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
-            f"{glossary_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
+            f"categories/{parent_category_guid}/subcategories/{child_category_guid}/remove"
         )
 
-        response = await self._async_make_request("POST", url)
-        return response.json().get("elementList", "No Categories found")
+        await self._async_make_request("POST", url)
 
-    def get_categories_for_glossary(
-        self,
-        glossary_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Return the list of categories associated with a glossary.
+    def remove_parent_category(self, parent_category_guid: str, child_category_guid: str) -> None:
+        """Remove parent category relationship.
 
         Parameters
         ----------
-        glossary_guid: str,
-            Unique identity of the glossary
+        parent_category_guid: str,
+            Unique identifier for the parent category.
+        child_category_guid: str,
+            Unique identifier for the child category.
 
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
         Returns
         -------
-        List | str
-
-        A list of categories associated with a glossary.
+        None
 
         Raises
         ------
@@ -996,406 +748,15 @@ 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
-
+        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_get_categories_for_glossary(
-                glossary_guid, start_from, page_size
+        loop.run_until_complete(
+            self._async_remove_parent_category(parent_category_guid, child_category_guid)
             )
-        )
-        return response
-
-    async def _async_get_categories_for_term(
-        self,
-        glossary_term_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Return the list of categories associated with a glossary term.
-            Async version.
-
-        Parameters
-        ----------
-        glossary_term_guid: str,
-            Unique identity of a glossary term
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of categories associated with a glossary term.
-
-        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
-
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
-            f"{glossary_term_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("elementList", "No Categories found")
-
-    def get_categories_for_term(
-        self,
-        glossary_term_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Return the list of categories associated with a glossary term.
-
-        Parameters
-        ----------
-        glossary_term_guid: str,
-            Unique identity of a glossary term
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of categories associated with a glossary term.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_categories_for_term(
-                glossary_term_guid, start_from, page_size
-            )
-        )
-        return response
-
-    async def _async_get_categories_by_name(
-        self,
-        name: str,
-        glossary_guid: str = None,
-        status: [str] = ["ACTIVE"],
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary category metadata elements that either have the requested qualified name or display name.
-            The name to search for is located in the request body and is interpreted as a plain string.
-            The request body also supports the specification of a glossaryGUID to restrict the search to within a single glossary.
-
-            Async version.
-
-        Parameters
-        ----------
-        name: str,
-            category name to search for.
-        glossary_guid: str, optional
-            The identity of the glossary to search. If not specified, all glossaries will be searched.
-        status: [str], optional
-            A list of statuses to optionally restrict results. Default is Active
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of categories with the corresponding display name or qualified name.
-
-        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
-
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-        validate_name(name)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        body = {
-            "class": "GlossaryNameRequestBody",
-            "name": name,
-            "glossaryGUID": glossary_guid,
-            "limitResultsByStatus": status,
-        }
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("elementList", "No Categories found")
-
-    def get_categories_by_name(
-        self,
-        name: str,
-        glossary_guid: str = None,
-        status: [str] = ["ACTIVE"],
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary category metadata elements that either have the requested qualified name or display name.
-            The name to search for is located in the request body and is interpreted as a plain string.
-            The request body also supports the specification of a glossaryGUID to restrict the search to within a single glossary.
-
-        Parameters
-        ----------
-        name: str,
-            category name to search for.
-        glossary_guid: str, optional
-            The identity of the glossary to search. If not specified, all glossaries will be searched.
-        status: [str], optional
-            A list of statuses to optionally restrict results. Default is Active
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of categories with the corresponding display name or qualified name.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_categories_by_name(
-                name, glossary_guid, status, start_from, page_size
-            )
-        )
-        return response
-
-    async def _async_get_categories_by_guid(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
-        """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
-        time for the query..
-
-        Async version.
-
-        Parameters
-        ----------
-        glossary_category_guid: str
-            The identity of the glossary category to search.
-        effective_time: str, optional
-            If specified, the category should only be returned if it was effective at the specified time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-
-        Returns
-        -------
-        List | str
-
-        Details for the category with the glossary category GUID.
-
-        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
-
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-            f"{glossary_category_guid}/retrieve"
-        )
-
-        body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("element", "No Category found")
-
-    def get_categories_by_guid(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
-        """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
-        time for the query..
-
-        Parameters
-        ----------
-        glossary_category_guid: str
-            The identity of the glossary category to search.
-        effective_time, datetime, optional
-            If specified, the category should only be returned if it was effective at the specified time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-
-        Returns
-        -------
-        List | str
-
-        Details for the category with the glossary category GUID.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_categories_by_guid(glossary_category_guid, effective_time)
-        )
-        return response
-
-    async def _async_get_category_parent(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
-        """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
-            element for the glossary category with the supplied unique identifier.  If the requested category
-            does not have a parent category, null is returned.  The optional request body contain an effective time
-            for the query.
-
-        Async version.
-
-        Parameters
-        ----------
-        glossary_category_guid: str
-            The identity of the glossary category to search.
-        effective_time, datetime, optional
-            If specified, the category should only be returned if it was effective at the specified time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-
-        Returns
-        -------
-        List | str
-
-        Details for the parent category with the glossary category GUID.
-
-        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
-
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-            f"{glossary_category_guid}/parent/retrieve"
-        )
-
-        body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("element", "No Parent Category found")
-
-    def get_category_parent(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
-        """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
-            element for the glossary category with the supplied unique identifier.  If the requested category
-            does not have a parent category, null is returned.  The optional request body contain an effective time
-            for the query.
-
-        Parameters
-        ----------
-        glossary_category_guid: str
-            The identity of the glossary category to search.
-        effective_time, datetime, optional
-            If specified, the category should only be returned if it was effective at the specified time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
-
-
-        Returns
-        -------
-        List | str
-
-        Details for the parent category with the glossary category GUID.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_category_parent(glossary_category_guid, effective_time)
-        )
-        return response
 
     #
     #  Terms
@@ -1441,6 +802,7 @@ class GlossaryManager(GlossaryBrowser):
                     "class" : "GlossaryTermProperties",
                     "qualifiedName" : "GlossaryTerm: term name : {$isoTimestamp}",
                     "displayName" : "term name",
+                    "aliases": []
                     "summary" : "This is the short description.",
                     "description" : "This is the long description of the term.",
                     "abbreviation" : "GT",
@@ -1508,6 +870,7 @@ class GlossaryManager(GlossaryBrowser):
                     "class" : "GlossaryTermProperties",
                     "qualifiedName" : "GlossaryTerm: term name : {$isoTimestamp}",
                     "displayName" : "term name",
+                    "aliases": []
                     "summary" : "This is the short description.",
                     "description" : "This is the long description of the term.",
                     "abbreviation" : "GT",
@@ -1531,7 +894,7 @@ class GlossaryManager(GlossaryBrowser):
 
         return response
 
-    def load_terms_from_file(
+    def load_terms_from_csv_file(
         self,
         glossary_name: str,
         filename: str,
@@ -1736,9 +1099,8 @@ class GlossaryManager(GlossaryBrowser):
                             continue
 
                 # Add the term
-                term_qualified_name = (
-                    f"GlossaryTerm: {term_name} - {datetime.now().isoformat()}"
-                )
+                term_qualified_name = self.__create_qualified_name__("Term", term_name)
+
                 body = {
                     "class": "ReferenceableRequestBody",
                     "elementProperties": {
@@ -1995,22 +1357,18 @@ class GlossaryManager(GlossaryBrowser):
 
         return response
 
-    async def _async_add_data_field_to_term(
-        self, glossary_term_guid: str, body: dict
-    ) -> None:
-        """Add the data field values classification to a glossary term
 
-            Async Version.
+    async def _async_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_guid : str
-                Unique identifier for the glossary category to retrieve terms from.
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            body: dict
-                Body containing information about the data field to add
-
+            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.
 
         Returns
         -------
@@ -2024,43 +1382,139 @@ 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 of the structure:
 
-        {
-            "class" : "ClassificationRequestBody",
-            "properties" :
-                {
-                    "class" : "DataFieldValuesProperties",
-                    "defaultValue" : "Add default value here",
-                    "sampleValues" : [ "Sample Value 1", "Sample Value 2"],
-                    "dataPattern" : ["add data pattern here"],
-                    "namePattern" : ["add column pattern here"]
-                }
-        }
         """
 
         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"terms/{glossary_term_guid}/is-data-field"
+            f"categories/{glossary_category_guid}/terms/{glossary_term_guid}"
         )
+        body = {
+            "class": "RelationshipRequestBody",
+            "properties": {
+                "class": "GlossaryTermCategorization"
+
+                }
+            }
 
         await self._async_make_request("POST", url, body)
-        return
 
-    def add_data_field_to_term(self, glossary_term_guid: str, body: dict) -> 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.
 
         Parameters
         ----------
-            glossary_term_guid: str
-                Unique identifier for the source glossary term.
-            body: dict
-                Body containing information about the data field to add
+            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.
+
+        Returns
+        -------
+
+        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_add_term_to_category(glossary_term_guid, glossary_category_guid)
+            )
+
+    async def _async_remove_term_from_category(
+            self, glossary_term_guid: str, glossary_category_guid: str
+            ) -> None:
+        """Remove the term from 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.
+
+        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(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}/remove"
+        )
+        await self._async_make_request("POST", url)
+
+
+    def remove_term_from_category(self, glossary_term_guid: str, glossary_category_guid: str) -> None:
+        """Remove the term from the specified category.
+
+        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.
+
+        Returns
+        -------
+
+        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_term_from_category(glossary_term_guid, glossary_category_guid)
+            )
 
+    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:
+        """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.
+        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
         -------
@@ -2074,28 +1528,356 @@ 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 of the structure:
+        ----
+        Body is currently required but can be empty except for class. Basic structure is:
 
-        {
-            "class" : "ClassificationRequestBody",
-            "properties" :
-                {
-                    "class" : "DataFieldValuesProperties",
-                    "defaultValue" : "Add default value here",
-                    "sampleValues" : [ "Sample Value 1", "Sample Value 2"],
-                    "dataPattern" : ["add data pattern here"],
-                    "namePattern" : ["add column pattern here"]
+            {
+             "class" : "RelationshipRequestBody",
+             "effectiveTime" : {{@isoTimestamp}},
+             "properties" : {
+                "class" : "GlossaryTermRelationship",
+                "expression" : "",
+                "confidence"  : 0,
+                "description" : "",
+                "status"   : "",
+                "steward"  : "",
+                "source" : "",
+                "effectiveFrom" : "{{@isoTimestamp}}",
+                "effectiveTo" : "{{@isoTimestamp}}",
+                "extendedProperties" : {
+                }
+             }
+        }
+        """
+
+        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}"
+        )
+
+        await self._async_make_request("POST", url, body_slimmer(body))
+
+
+    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:
+        """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.
+        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.
+
+        Notes
+        ----
+        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" : {
+            }
+         }
+        }
+        """
+        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)
+            )
+
+
+    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.
+
+        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 update.
+        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
+        -------
+        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" : "RelationshipRequestBody",
+         "effectiveTime" : {{@isoTimestamp}},
+         "properties" : {
+            "class" : "GlossaryTermRelationship",
+            "expression" : "",
+            "confidence"  : 0,
+            "description" : "",
+            "status"   : "",
+            "steward"  : "",
+            "source" : "",
+            "effectiveFrom" : "{{@isoTimestamp}}",
+            "effectiveTo" : "{{@isoTimestamp}}",
+            "extendedProperties" : {
+            }
+         }
+        }
+        """
+
+        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"}}
+
+        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}"
+        )
+
+        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.
+
+        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 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
+
+        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" : "RelationshipRequestBody",
+         "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_add_data_field_to_term(glossary_term_guid, body)
+            self._async_update_relationship_between_terms(term1_guid, term2_guid, relationship_type,
+                                                          body,for_lineage,for_duplicate_processing)
+            )
+
+    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.
+
+        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)
+
+        possible_query_params = query_string(
+            [
+                ("forLineage", for_lineage),
+                ("forDuplicateProcessing", for_duplicate_processing),
+                ]
+            )
+
+        body = {"properties": {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time
+            }
+        }
+
+        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}"
         )
 
-        return
+        await self._async_make_request("POST", url, body_slimmer(body))
+
+
+    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.
+
+        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().
+        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.
+
+        """
+        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)
+            )
+
+
 
     async def _async_add_confidentiality_to_term(
         self,
@@ -2287,7 +2069,7 @@ class GlossaryManager(GlossaryBrowser):
         self,
         glossary_term_guid: str,
         body: dict,
-        is_merge_update: bool = True,
+        is_merge_update: bool = False,
         for_lineage: bool = False,
         for_duplicate_processig: bool = False,
     ) -> None:
@@ -2566,122 +2348,15 @@ class GlossaryManager(GlossaryBrowser):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_undo_term_update(glossary_term_guid))
 
-    async def _async_get_terms_for_category(
+
+
+    async def _async_delete_term(
         self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
+        term_guid: str,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
     ) -> list | str:
-        """Retrieve ALL the glossary terms in a category.
-            The request body also supports the specification of an effective time for the query.
-
-            Async Version.
-
-        Parameters
-        ----------
-            glossary_category_guid : str
-                Unique identifier for the glossary category to retrieve terms from.
-            effective_time : str, optional
-                If specified, the terms are returned if they are active at the `effective_time
-                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-            start_from: int, optional defaults to 0
-                The page number to start retrieving elements from
-            page_size : int, optional defaults to None
-                The number of elements to retrieve
-        Returns
-        -------
-        dict
-            The glossary definition associated with the glossary_guid
-
-        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
-        -----
-        """
-
-        validate_guid(glossary_category_guid)
-
-        if page_size is None:
-            page_size = self.page_size
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-            f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        if effective_time is not None:
-            body = {"effectiveTime": effective_time}
-            response = await self._async_make_request("POST", url, body)
-        else:
-            response = await self._async_make_request("POST", url)
-
-        return response.json().get("elementList", "No terms found")
-
-    def get_terms_for_category(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve ALL the glossary terms in a category.
-            The request body also supports the specification of an effective time for the query.
-
-            Async Version.
-
-        Parameters
-        ----------
-            glossary_category_guid : str
-                Unique identifier for the glossary category to retrieve terms from.
-            effective_time : str, optional
-                If specified, the terms are returned if they are active at the `effective_time.
-                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)`.
-            start_from: int, optional defaults to 0
-                The page number to start retrieving elements from
-            page_size : int, optional defaults to None
-                The number of elements to retrieve
-        Returns
-        -------
-        dict
-            The glossary definition associated with the glossary_guid
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_terms_for_category(
-                glossary_category_guid,
-                effective_time,
-                start_from,
-                page_size,
-            )
-        )
-
-        return response
-
-    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.
+        """Delete the glossary terms associated with the specified glossary. Async version.
 
         Parameters
         ----------
@@ -2757,840 +2432,8 @@ class GlossaryManager(GlossaryBrowser):
 
         return
 
-    async def _async_get_term_relationships(
-        self,
-        term_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """This call retrieves details of the glossary terms linked to this glossary term.
-        Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
-        Parameters
-        ----------
-            term_guid : str
-                Unique identifier for the glossary term
-            effective_time : str, optional
-                If specified, term relationships are included if they are active at the `effective_time`.
-                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-            start_from: int, optional defaults to 0
-                The page number to start retrieving elements from
-            page_size : int, optional defaults to None
-                The number of elements to retrieve
-        Returns
-        -------
-        dict
-            The glossary definition associated with the glossary_guid
-
-        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
-        -----
-        """
-
-        validate_guid(term_guid)
-
-        if page_size is None:
-            page_size = self.page_size
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-            f"{term_guid}/related-terms?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        if effective_time is not None:
-            body = {"effectiveTime": effective_time}
-            response = await self._async_make_request("POST", url, body)
-        else:
-            response = await self._async_make_request("POST", url)
-
-        return response.json().get("elementList", "No terms found")
-
-    def get_term_relationships(
-        self,
-        term_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """This call retrieves details of the glossary terms linked to this glossary term.
-        Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
-        Parameters
-        ----------
-            term_guid : str
-                Unique identifier for the glossary term
-            effective_time : str, optional
-                If specified, term relationships are included if they are active at the `effective_time`.
-                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-            start_from: int, optional defaults to 0
-                The page number to start retrieving elements from
-            page_size : int, optional defaults to None
-                The number of elements to retrieve
-        Returns
-        -------
-        dict
-            The glossary definition associated with the glossary_guid
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_term_relationships(
-                term_guid, effective_time, start_from, page_size
-            )
-        )
-
-        return response
-
-    async def _async_get_glossary_for_term(
-        self, term_guid: str, effective_time: str = None
-    ) -> dict | str:
-        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to specify
-            that the glossary element should only be returned if it was effective at a particular time.
-
-            Async Version.
-
-        Parameters
-        ----------
-        term_guid : str
-            The unique identifier for the term.
-
-        effective_time : datetime, optional
-            If specified, the term information will be retrieved if it is active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        Returns
-        -------
-        dict
-            The glossary information retrieved for the specified term.
-        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
-        -----
-        """
-
-        validate_guid(term_guid)
-
-        body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"for-term/{term_guid}/retrieve"
-        )
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("element", "No glossary found")
-
-    def get_glossary_for_term(
-        self, term_guid: str, effective_time: str = None
-    ) -> dict | str:
-        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to specify
-            that the glossary element should only be returned if it was effective at a particular time.
-
-            Async Version.
-
-        Parameters
-        ----------
-        term_guid : str
-            The unique identifier for the term.
-
-        effective_time : datetime, optional
-            TIf specified, the term information will be retrieved if it is active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
-
-        Returns
-        -------
-        dict
-            The glossary information retrieved for the specified term.
-        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()
-        response = loop.run_until_complete(
-            self._async_get_glossary_for_term(term_guid, effective_time)
-        )
-        return response
-
-    async def _async_get_terms_by_name(
-        self,
-        term: str,
-        glossary_guid: str = None,
-        status_filter: list = [],
-        effective_time: str = None,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list:
-        """Retrieve glossary terms by display name or qualified name. Async Version.
-
-        Parameters
-        ----------
-        term : str
-            The term to search for in the glossaries.
-        glossary_guid : str, optional
-            The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
-        status_filter : list, optional
-            A list of status values to filter the search results. Default is an empty list, which means no filtering.
-
-        effective_time : datetime, optional
-            If specified, the term information will be retrieved if it is active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        for_lineage : bool, optional
-            Flag to indicate whether the search should include lineage information. Default is False.
-        for_duplicate_processing : bool, optional
-            Flag to indicate whether the search should include duplicate processing information. Default is False.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-
-        Returns
-        -------
-        list
-            A list of terms matching the search criteria. If no terms are found, it returns the string "No terms found".
-
-        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.
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        validate_name(term)
-
-        for_lineage_s = str(for_lineage).lower()
-        for_duplicate_processing_s = str(for_duplicate_processing).lower()
-
-        body = {
-            "class": "GlossaryNameRequestBody",
-            "glossaryGUID": glossary_guid,
-            "name": term,
-            "effectiveTime": effective_time,
-            "limitResultsByStatus": status_filter,
-        }
-        # body = body_slimmer(body)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"terms/by-name?startFrom={start_from}&pageSize={page_size}&"
-            f"&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}"
-        )
-
-        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("elementList", "No terms found")
-
-    def get_terms_by_name(
-        self,
-        term: str,
-        glossary_guid: str = None,
-        status_filter: list = [],
-        effective_time: str = None,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list:
-        """Retrieve glossary terms by display name or qualified name.
-
-        Parameters
-        ----------
-        term : str
-            The term to search for in the glossaries.
-        glossary_guid : str, optional
-            The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
-        status_filter : list, optional
-            A list of status values to filter the search results. Default is an empty list, which means no filtering.
-
-        effective_time : datetime, optional
-            If specified, the term information will be retrieved if it is active at the `effective_time`.
-             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        for_lineage : bool, optional
-            Flag to indicate whether the search should include lineage information. Default is False.
-        for_duplicate_processing : bool, optional
-            Flag to indicate whether the search should include duplicate processing information. Default is False.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-
-        Returns
-        -------
-        list
-            A list of terms matching the search criteria. If no terms are found,
-            it returns the string "No terms found".
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_terms_by_name(
-                term,
-                glossary_guid,
-                status_filter,
-                effective_time,
-                for_lineage,
-                for_duplicate_processing,
-                start_from,
-                page_size,
-            )
-        )
-        return response
-
-    async def _async_get_terms_by_guid(self, term_guid: str) -> dict | str:
-        """Retrieve a term using its unique id. Async version.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term represented by the GUID. If no term is found, the string
-            "No term found" will be returned.
-
-        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(term_guid)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-            f"{term_guid}/retrieve"
-        )
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("element", "No term found")
-
-    def get_terms_by_guid(self, term_guid: str) -> dict | str:
-        """Retrieve a term using its unique id. Async version.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term represented by the GUID. If no term is found, the string
-            "No term found" will be returned.
-
-        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()
-        response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid))
-
-        return response
-
-    async def _async_get_terms_versions(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the versions of a glossary term. Async version.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term represented by the GUID. If no term is found, the string
-            "No term found" will be returned.
-
-        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.
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        validate_guid(term_guid)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-            f"{term_guid}/history?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("element", "No term found")
-
-    def get_terms_versions(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the versions of a glossary term.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term represented by the GUID. If no term is found, the string
-            "No term found" will be returned.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_terms_versions(term_guid, start_from, page_size)
-        )
-
-        return response
-
-    async def _async_get_term_revision_logs(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the revision log history for a term. Async version.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term revision log history. If no term is found, the string
-            "No log found" will be returned.
-
-        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.
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        validate_guid(term_guid)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/elements/"
-            f"{term_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("elementList", "No log found")
-
-    def get_term_revision_logs(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the revision log history for a term.
-        Parameters
-        ----------
-        term_guid : str
-            The GUID of the glossary term to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term revision log history. If no term is found, the string
-            "No log found" will be returned.
-
-        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()
-        response = loop.run_until_complete(
-            self._async_get_term_revision_logs(term_guid, start_from, page_size)
-        )
-
-        return response
-
-    async def _async_get_term_revision_history(
-        self,
-        term_revision_log_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the revision history for a glossary term. Async version.
-
-        Parameters
-        ----------
-        term_revision_log_guid : str
-            The GUID of the glossary term revision log to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term revision history.
-
-        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
-        -----
-        This revision history is created automatically.  The text is supplied on the update request.
-        If no text is supplied, the value "None" is show.
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        validate_guid(term_revision_log_guid)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/note-logs/"
-            f"{term_revision_log_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        response = await self._async_make_request("POST", url)
-        return response.json().get("elementList", "No logs found")
-
-    def get_term_revision_history(
-        self,
-        term_revision_log_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
-        """Retrieve the revision history for a glossary term.
-
-        Parameters
-        ----------
-        term_revision_log_guid : str
-            The GUID of the glossary term revision log to retrieve.
-        start_from : int, optional
-            The index of the first term to retrieve. Default is 0.
-        page_size : int, optional
-            The number of terms to retrieve per page. If not provided, it will use the default page size.
-        Returns
-        -------
-        dict | str
-            A dict detailing the glossary term revision history.
-
-        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
-        -----
-        This revision history is created automatically.  The text is supplied on the update request.
-        If no text is supplied, the value "None" is show.
-        """
-
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_term_revision_history(
-                term_revision_log_guid, start_from, page_size
-            )
-        )
-
-        return response
-
-    async def _async_find_glossary_terms(
-        self,
-        search_string: str,
-        glossary_guid: str = None,
-        status_filter: list = [],
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = True,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary term metadata elements that contain the search string.
-
-        Parameters
-        ----------
-        search_string: str
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-        glossary_guid str
-            Identifier of the glossary to search within. If None, then all glossaries are searched.
-        status_filter: list, default = [], optional
-            Filters the results by the included Term statuses (such as 'ACTIVE', 'DRAFT'). If not specified,
-            the results will not be filtered.
-        effective_time: str, [default=None], optional
-            If specified, the term information will be retrieved if it is active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-        for_lineage : bool, [default=False], optional
-
-        for_duplicate_processing : bool, [default=False], optional
-
-        start_from: str, [default=0], optional
-            Page of results to start from
-        page_size : int, optional
-            Number of elements to return per page - if None, then default for class will be used.
-
-        Returns
-        -------
-        List | str
-
-        A list of term definitions
-
-        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
-        -----
-        The search string is located in the request body and is interpreted as a plain string.
-        The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-        The request body also supports the specification of a glossaryGUID to restrict the search to within a single glossary.
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-        if effective_time is None:
-            effective_time = datetime.now().isoformat()
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-        for_lineage_s = str(for_lineage).lower()
-        for_duplicate_processing_s = str(for_duplicate_processing).lower()
-        if search_string == "*":
-            search_string = None
-
-        # validate_search_string(search_string)
-
-        body = {
-            "class": "GlossarySearchStringRequestBody",
-            "glossaryGUID": glossary_guid,
-            "searchString": search_string,
-            "effectiveTime": effective_time,
-            "limitResultsByStatus": status_filter,
-        }
-        # body = body_slimmer(body)
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-            f"forDuplicateProcessing={for_duplicate_processing_s}"
-        )
-
-        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
-
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get(
-            "elementList", "No terms found"
-        )  # return response.text
-
-    def find_glossary_terms(
-        self,
-        search_string: str,
-        glossary_guid: str = None,
-        status_filter: list = [],
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Retrieve the list of glossary term metadata elements that contain the search string.
-
-        Parameters
-        ----------
-        search_string: str
-            Search string to use to find matching glossaries. If the search string is '*' then all glossaries returned.
-        glossary_guid str
-            Identifier of the glossary to search within. If None, then all glossaries are searched.
-        status_filter: list, default = [], optional
-            Filters the results by the included Term statuses (such as 'ACTIVE', 'DRAFT'). If not specified,
-            the results will not be filtered.
-        effective_time: str, [default=None], optional
-            If specified, the term information will be retrieved if it is active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-        starts_with : bool, [default=False], optional
-            Starts with the supplied string.
-        ends_with : bool, [default=False], optional
-            Ends with the supplied string
-        ignore_case : bool, [default=False], optional
-            Ignore case when searching
-        for_lineage : bool, [default=False], optional
-
-        for_duplicate_processing : bool, [default=False], optional
-
-        start_from: str, [default=0], optional
-            Page of results to start from
-        page_size : int, optional
-            Number of elements to return per page - if None, then default for class will be used.
-
-        Returns
-        -------
-        List | str
-
-        A list of term definitions
-
-        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
-        -----
-        The search string is located in the request body and is interpreted as a plain string.
-        The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-        The request body also supports the specification of a glossaryGUID to restrict the search to within a single glossary.
-        """
-
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_find_glossary_terms(
-                search_string,
-                glossary_guid,
-                status_filter,
-                effective_time,
-                starts_with,
-                ends_with,
-                ignore_case,
-                for_lineage,
-                for_duplicate_processing,
-                start_from,
-                page_size,
-            )
-        )
-
-        return response
+    async def _async_relate_terms(self, term1_guid: str, term2_guid: str, relationship: str) -> None:
+        pass
 
 
 if __name__ == "__main__":